~didrocks/unity/altf10 : revision 59

17

18

from testtools import ExpectedException

19

20

from grackle.client import (

21

GrackleClient,

20

from grackle.client import GrackleClient

21

from grackle.error import (

22

ArchiveIdExists,

22

23

UnparsableDateRange,

23

24

UnsupportedDisplayType,

24

25

UnsupportedOrder,

32

33

def make_message(message_id, body='body', headers=None, hidden=False):

33

34

if headers is None:

34

35

headers = {}

35

headers['Message-Id'] = message_id

36

message = {

37

'message_id': message_id,

38

'headers': headers,

39

'thread_id': message_id,

40

'date': headers.get('date', '2005-01-01'),

41

'subject': headers.get('subject', 'subject'),

42

'author': headers.get('author', 'author'),

43

'hidden': hidden,

44

'attachments': [],

45

'replies': headers.get('in-reply-to', None),

46

'body': body,

36

message_headers = {

37

'Message-Id': message_id,

38

'date': '2005-01-01',

39

'subject': 'subject',

40

'from': 'author',

41

'replies': '',

47

42

}

48

return message

43

message_headers.update(headers.items())

44

message = Message()

45

message.set_payload(body)

46

for key, value in message_headers.items():

47

message[key] = value

48

return make_json_message(message_id, message.as_string(), hidden)

49

50

51

def make_mime_message(message_id, body='body', headers=None, hidden=False,

52

attachment_type=None):

53

if headers is None:

54

headers = {}

55

53

parts = MIMEMultipart()

56

54

parts.attach(MIMEText(body))

57

55

if attachment_type is not None:

60

58

attachment['Content-Type'] = attachment_type

61

59

attachment['Content-Disposition'] = 'attachment; filename="file.ext"'

62

60

parts.attach(attachment)

63

message = Message()

64

message.set_payload(parts.as_string())

65

for key, value in headers.items():

66

message[key] = value

67

return make_json_message(message_id, message.as_string())

61

return make_message(message_id, parts.as_string(), headers, hidden)

68

62

69

63

70

64

class ForkedFakeService:

119

113

"""Start the HTTP server."""

120

114

service = HTTPServer(('', self.port), FakeGrackleRequestHandler)

121

115

service.store = MemoryStore(self.message_archives)

122

for archive_id, messages in service.store.message_archives.iteritems():

123

for message in messages:

124

message.setdefault('headers', {})

125

116

self.is_ready()

126

117

if self.write_logs:

127

118

logging.basicConfig(

140

131

self.logger = logging.getLogger('http')

141

132

BaseHTTPRequestHandler.__init__(self, *args, **kwargs)

142

133

134

def do_PUT(self):

135

"""Create an archive or message on PUT."""

136

scheme, netloc, path, params, query_string, fragments = (

137

urlparse(self.path))

138

parts = path.split('/')

139

if parts[1] != 'archive':

140

# This is an unknonwn operation?

141

return

142

if len(parts) == 3:

143

# This expected path is /archive/archive_id.

144

try:

145

self.server.store.put_archive(parts[2])

146

self.send_response(httplib.CREATED)

147

self.end_headers()

148

self.wfile.close()

149

except Exception, error:

150

self.send_response(

151

httplib.BAD_REQUEST, error.__doc__)

152

if len(parts) == 4:

153

# This expected path is /archive/archive_id/message_id.

154

try:

155

message = self.rfile.read(int(self.headers['content-length']))

156

self.server.store.put_message(parts[2], parts[3], message)

157

self.send_response(httplib.CREATED)

158

self.end_headers()

159

self.wfile.close()

160

except:

161

self.send_error(httplib.BAD_REQUEST)

162

143

163

def do_POST(self):

144

"""Create a message on POST."""

145

message = self.rfile.read(int(self.headers['content-length']))

164

"""Change a message on POST."""

146

165

scheme, netloc, path, params, query_string, fragments = (

147

166

urlparse(self.path))

148

167

parts = path.split('/')

149

if parts[1] == 'archive' and len(parts) == 4:

168

if parts[1] != 'archive':

169

# This is an unknonwn operation?

170

return

171

if len(parts) == 4:

172

# This expected path is /archive/archive_id/message_id.

150

173

try:

151

174

# This expected path is /archive/archive_id/message_id.

152

self.server.store.put_message(parts[2], parts[3], message)

153

self.send_response(httplib.CREATED)

175

response = self.server.store.hide_message(

176

parts[2], parts[3], query_string)

177

self.send_response(httplib.OK)

154

178

self.end_headers()

155

self.wfile.close()

179

self.wfile.write(simplejson.dumps(response))

156

180

except:

157

181

self.send_error(httplib.BAD_REQUEST)

158

182

180

204

self.logger.info(message)

181

205

182

206

207

class TestPutArchive(TestCase):

208

209

def test_put_archive(self):

210

client = GrackleClient('localhost', 8410)

211

message_archives = {}

212

with ForkedFakeService.from_client(client, message_archives):

213

client.put_archive('arch1')

214

response = client.get_messages('arch1')

215

self.assertEqual(0, len(response['messages']))

216

217

def test_put_archive_existing_archive(self):

218

client = GrackleClient('localhost', 8411)

219

message_archives = {'arch1': []}

220

with ForkedFakeService.from_client(client, message_archives):

221

with ExpectedException(ArchiveIdExists, ''):

222

client.put_archive('arch1')

223

224

183

225

class TestPutMessage(TestCase):

184

226

185

227

def test_put_message(self):

244

286

245

287

def get_messages_member_order_test(self, key):

246

288

client = GrackleClient('localhost', 8439)

289

if key == 'author':

290

header_name = 'from'

291

else:

292

header_name = key

247

293

archive = {

248

294

'baz': [

249

make_message('foo', headers={key: '2011-03-25'}),

250

make_message('bar', headers={key: '2011-03-24'}),

295

make_message('foo', headers={header_name: '2011-03-25'}),

296

make_message('bar', headers={header_name: '2011-03-24'}),

251

297

]}

252

298

with ForkedFakeService.from_client(client, archive):

253

299

response = client.get_messages('baz')

400

446

first_message = response['messages'][0]

401

447

self.assertEqual('foo', first_message['message_id'])

402

448

self.assertEqual(

403

{'From': 'me', 'Message-Id': 'foo', 'To': 'you'},

404

first_message['headers'])

449

archive['baz'][0]['headers'], first_message['headers'])

405

450

self.assertNotIn('body', first_message)

406

451

407

452

def test_display_type_text_only(self):

477

522

with ForkedFakeService.from_client(client, archive):

478

523

with ExpectedException(UnparsableDateRange, ''):

479

524

client.get_messages('baz', date_range='2012-01..12-02..12-03')

525

526

527

class TestHideMessages(TestCase):

528

529

def test_hide_message_true(self):

530

client = GrackleClient('localhost', 8470)

531

archive = {

532

'baz': [

533

make_message('foo', hidden=False),

534

]}

535

with ForkedFakeService.from_client(client, archive):

536

response = client.hide_message('baz', 'foo', hidden=True)

537

self.assertEqual('foo', response['message_id'])

538

self.assertIs(True, response['hidden'])

539

540

def test_hide_message_false(self):

541

client = GrackleClient('localhost', 8470)

542

archive = {

543

'baz': [

544

make_message('foo', hidden=True),

545

]}

546

with ForkedFakeService.from_client(client, archive):

547

response = client.hide_message('baz', 'foo', hidden=False)

548

self.assertEqual('foo', response['message_id'])

549

self.assertIs(False, response['hidden'])