~didrocks/unity/altf10 : revision 49

17

18

from testtools import ExpectedException

19

20

from grackle.client import GrackleClient

21

from grackle.error import (

22

ArchiveIdExists,

20

from grackle.client import (

21

GrackleClient,

23

22

UnparsableDateRange,

24

23

UnsupportedDisplayType,

25

24

UnsupportedOrder,

33

32

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

34

33

if headers is None:

35

34

headers = {}

36

message_headers = {

37

'Message-Id': message_id,

38

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

39

'subject': 'subject',

40

'from': 'author',

41

'replies': '',

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,

42

47

}

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)

48

return message

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 = {}

53

55

parts = MIMEMultipart()

54

56

parts.attach(MIMEText(body))

55

57

if attachment_type is not None:

58

60

attachment['Content-Type'] = attachment_type

59

61

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

60

62

parts.attach(attachment)

61

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

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())

62

68

63

69

64

70

class ForkedFakeService:

134

140

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

135

141

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

136

142

137

def do_PUT(self):

138

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

139

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

140

urlparse(self.path))

141

parts = path.split('/')

142

if parts[1] != 'archive':

143

# This is an unknonwn operation?

144

return

145

if len(parts) == 3:

146

# This expected path is /archive/archive_id.

147

try:

148

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

149

self.send_response(httplib.CREATED)

150

self.end_headers()

151

self.wfile.close()

152

except Exception, error:

153

self.send_response(

154

httplib.BAD_REQUEST, error.__doc__)

155

if len(parts) == 4:

156

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

157

try:

158

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

159

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

160

self.send_response(httplib.CREATED)

161

self.end_headers()

162

self.wfile.close()

163

except:

164

self.send_error(httplib.BAD_REQUEST)

165

166

143

def do_POST(self):

167

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

144

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

145

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

168

146

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

169

147

urlparse(self.path))

170

148

parts = path.split('/')

171

if parts[1] != 'archive':

172

# This is an unknonwn operation?

173

return

174

if len(parts) == 4:

175

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

149

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

176

150

try:

177

151

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

178

response = self.server.store.hide_message(

179

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

180

self.send_response(httplib.OK)

152

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

153

self.send_response(httplib.CREATED)

181

154

self.end_headers()

182

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

155

self.wfile.close()

183

156

except:

184

157

self.send_error(httplib.BAD_REQUEST)

185

158

207

180

self.logger.info(message)

208

181

209

182

210

class TestPutArchive(TestCase):

211

212

def test_put_archive(self):

213

client = GrackleClient('localhost', 8410)

214

message_archives = {}

215

with ForkedFakeService.from_client(client, message_archives):

216

client.put_archive('arch1')

217

response = client.get_messages('arch1')

218

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

219

220

def test_put_archive_existing_archive(self):

221

client = GrackleClient('localhost', 8411)

222

message_archives = {'arch1': []}

223

with ForkedFakeService.from_client(client, message_archives):

224

with ExpectedException(ArchiveIdExists, ''):

225

client.put_archive('arch1')

226

227

228

183

class TestPutMessage(TestCase):

229

184

230

185

def test_put_message(self):

289

244

290

245

def get_messages_member_order_test(self, key):

291

246

client = GrackleClient('localhost', 8439)

292

if key == 'author':

293

header_name = 'from'

294

else:

295

header_name = key

296

247

archive = {

297

248

'baz': [

298

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

299

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

249

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

250

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

300

251

]}

301

252

with ForkedFakeService.from_client(client, archive):

302

253

response = client.get_messages('baz')

449

400

first_message = response['messages'][0]

450

401

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

451

402

self.assertEqual(

452

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

403

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

404

first_message['headers'])

453

405

self.assertNotIn('body', first_message)

454

406

455

407

def test_display_type_text_only(self):

525

477

with ForkedFakeService.from_client(client, archive):

526

478

with ExpectedException(UnparsableDateRange, ''):

527

479

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

528

529

530

class TestHideMessages(TestCase):

531

532

def test_hide_message_true(self):

533

client = GrackleClient('localhost', 8470)

534

archive = {

535

'baz': [

536

make_message('foo', hidden=False),

537

]}

538

with ForkedFakeService.from_client(client, archive):

539

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

540

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

541

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

542

543

def test_hide_message_false(self):

544

client = GrackleClient('localhost', 8470)

545

archive = {

546

'baz': [

547

make_message('foo', hidden=True),

548

]}

549

with ForkedFakeService.from_client(client, archive):

550

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

551

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

552

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