~didrocks/unity/altf10 : revision 1

1

from BaseHTTPServer import (

2

HTTPServer,

3

BaseHTTPRequestHandler,

4

)

5

import httplib

6

import logging

7

import os

8

from signal import SIGKILL

9

import simplejson

10

from StringIO import StringIO

11

import sys

12

from unittest import TestCase

13

from urlparse import urlparse

14

from urlparse import parse_qs

15

16

from testtools import ExpectedException

17

18

from grackle.client import (

19

GrackleClient,

20

UnsupportedOrder,

21

)

22

23

24

def threaded_messages(messages):

25

threads = {}

26

count = 0

27

pending = []

28

for message in messages:

29

if message.get('in_reply_to') is None:

30

threads[message['message_id']] = [message]

31

count += 1

32

else:

33

pending.append(message)

34

for message in pending:

35

threads[message['in_reply_to']].append(message)

36

return threads.values()

37

38

39

class GrackleStore:

40

41

def __init__(self, messages):

42

self.messages = messages

43

44

def get_messages(self, archive_id, query_string):

45

query = parse_qs(query_string)

46

parameters = simplejson.loads(query['parameters'][0])

47

order = parameters.get('order')

48

messages = self.messages[archive_id]

49

if order is not None :

50

if order not in SUPPORTED_ORDERS:

51

raise UnsupportedOrder

52

elif order.startswith('thread_'):

53

threaded = threaded_messages(messages)

54

messages = []

55

if order == 'thread_subject':

56

threaded.sort(key=lambda t: t[0]['subject'])

57

if order == 'thread_oldest':

58

threaded.sort(key=lambda t: min(m['date'] for m in t))

59

if order == 'thread_newest':

60

threaded.sort(key=lambda t: max(m['date'] for m in t))

61

for thread in threaded:

62

messages.extend(thread)

63

else:

64

messages.sort(key=lambda m: m[order])

65

new_messages = []

66

for message in messages:

67

if (

68

not parameters['include_hidden']

69

and message.get('hidden', False)):

70

continue

71

72

if ('message_ids' in parameters and

73

message['message_id'] not in parameters['message_ids']):

74

continue

75

message = dict(message)

76

if 'headers' in parameters:

77

headers = dict(

78

(k, v) for k, v in message['headers'].iteritems()

79

if k in parameters['headers'])

80

message['headers'] = headers

81

max_body = parameters.get('max_body_length')

82

if max_body is not None:

83

message['body'] = message['body'][:max_body]

84

new_messages.append(message)

85

messages = new_messages

86

limit = parameters.get('limit', 100)

87

memo = parameters.get('memo')

88

message_id_indices = dict(

89

(m['message_id'], idx) for idx, m in enumerate(messages))

90

if memo is None:

91

start = 0

92

else:

93

start = message_id_indices[memo.encode('rot13')]

94

if start > 0:

95

previous_memo = messages[start - 1]['message_id'].encode('rot13')

96

else:

97

previous_memo = None

98

end = min(start + limit, len(messages))

99

if end < len(messages):

100

next_memo = messages[end]['message_id'].encode('rot13')

101

else:

102

next_memo = None

103

messages = messages[start:end]

104

105

response = {

106

'messages': messages,

107

'next_memo': next_memo,

108

'previous_memo': previous_memo

109

}

110

return response

111

112

113

114

class ForkedFake:

115

116

def __init__(self, port, messages=None):

117

self.pid = None

118

self.port = port

119

if messages is None:

120

self.messages = {}

121

else:

122

self.messages = messages

123

self.read_end, self.write_end = os.pipe()

124

125

@staticmethod

126

def from_client(client, messages=None):

127

return ForkedFake(client.port, messages)

128

129

def is_ready(self):

130

os.write(self.write_end, 'asdf')

131

132

def __enter__(self):

133

pid = os.fork()

134

if pid == 0:

135

self.start_server()

136

self.pid = pid

137

os.read(self.read_end, 1)

138

return

139

140

def start_server(self):

141

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

142

service.store = GrackleStore(self.messages)

143

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

144

for message in messages:

145

message.setdefault('headers', {})

146

self.is_ready()

147

# logging.basicConfig(

148

# stream=sys.stderr, level=logging.INFO)

149

service.serve_forever()

150

151

def __exit__(self, exc_type, exc_val, traceback):

152

os.kill(self.pid, SIGKILL)

153

154

155

SUPPORTED_ORDERS = set(

156

['date', 'author', 'subject', 'thread_newest', 'thread_oldest',

157

'thread_subject'])

158

159

160

class FakeGrackleRequestHandler(BaseHTTPRequestHandler):

161

162

def __init__(self, *args, **kwargs):

163

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

164

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

165

166

def do_POST(self):

167

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

168

if message == 'This is a message':

169

self.send_response(httplib.CREATED)

170

self.end_headers()

171

self.wfile.close()

172

else:

173

self.send_error(httplib.BAD_REQUEST)

174

175

def do_GET(self):

176

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

177

urlparse(self.path))

178

parts = path.split('/')

179

if parts[1] == 'archive':

180

try:

181

response = self.server.store.get_messages(

182

parts[2], query_string)

183

self.send_response(httplib.OK)

184

self.end_headers()

185

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

186

except UnsupportedOrder:

187

self.send_response(httplib.BAD_REQUEST)

188

self.wfile.write('Unsupported order')

189

return

190

191

def log_message(self, format, *args):

192

message = "%s - - [%s] %s\n" % (

193

self.address_string(), self.log_date_time_string(), format%args)

194

self.logger.info(message)

195

196

197

class TestPutMessage(TestCase):

198

199

def test_put_message(self):

200

client = GrackleClient('localhost', 8436)

201

with ForkedFake.from_client(client):

202

client.put_message('arch1', 'asdf', StringIO('This is a message'))

203

with ExpectedException(Exception, 'wtf'):

204

client.put_message('arch1', 'asdf',

205

StringIO('This is not a message'))

206

207

208

class TestGetMessages(TestCase):

209

210

def assertIDOrder(self, ids, messages):

211

self.assertEqual(ids, [m['message_id'] for m in messages])

212

213

def assertMessageIDs(self, ids, messages):

214

self.assertIDOrder(

215

sorted(ids), sorted(messages, key=lambda m:m['message_id']))

216

217

def test_get_messages(self):

218

client = GrackleClient('localhost', 8435)

219

with ForkedFake.from_client(client,

220

{'baz':

221

[{'message_id': 'foo'},

222

{'message_id': 'bar'}]}):

223

response = client.get_messages('baz')

224

self.assertEqual(['bar', 'foo'], sorted(m['message_id'] for m in

225

response['messages']))

226

self.assertIs(None, response['next_memo'])

227

self.assertIs(None, response['previous_memo'])

228

229

def test_get_messages_by_id(self):

230

client = GrackleClient('localhost', 8437)

231

with ForkedFake.from_client(client,

232

{'baz':

233

[{'message_id': 'foo'},

234

{'message_id': 'bar'}]}):

235

response = client.get_messages('baz', message_ids=['foo'])

236

message, = response['messages']

237

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

238

239

def test_get_messages_batching(self):

240

client = GrackleClient('localhost', 8438)

241

with ForkedFake.from_client(client,

242

{'baz':

243

[{'message_id': 'foo'},

244

{'message_id': 'bar'}]}):

245

response = client.get_messages('baz', limit=1)

246

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

247

messages = response['messages']

248

response = client.get_messages(

249

'baz', limit=1, memo=response['next_memo'])

250

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

251

messages.extend(response['messages'])

252

self.assertMessageIDs(['foo', 'bar'], messages)

253

254

def get_messages_member_order_test(self, key):

255

client = GrackleClient('localhost', 8439)

256

with ForkedFake.from_client(client,

257

{'baz': [{'message_id': 'foo', key: '2011-03-25'},

258

{'message_id': 'bar', key: '2011-03-24'}]}):

259

response = client.get_messages('baz')

260

self.assertIDOrder(['foo', 'bar'], response['messages'])

261

response = client.get_messages('baz', order=key)

262

self.assertIDOrder(['bar', 'foo'], response['messages'])

263

264

def test_get_messages_date_order(self):

265

self.get_messages_member_order_test('date')

266

267

def test_get_messages_author_order(self):

268

self.get_messages_member_order_test('author')

269

270

def test_get_messages_subject_order(self):

271

self.get_messages_member_order_test('subject')

272

273

def test_get_messages_thread_subject_order(self):

274

client = GrackleClient('localhost', 8439)

275

with ForkedFake.from_client(client, {'baz': [

276

{'message_id': 'bar', 'subject': 'y'},

277

{'message_id': 'qux', 'subject': 'z'},

278

{'message_id': 'foo', 'subject': 'x', 'in_reply_to': 'qux'},

279

]}):

280

response = client.get_messages('baz')

281

self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])

282

response = client.get_messages('baz', order='subject')

283

self.assertIDOrder(['foo', 'bar', 'qux'], response['messages'])

284

response = client.get_messages('baz', order='thread_subject')

285

self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])

286

287

def test_get_messages_thread_oldest_order(self):

288

client = GrackleClient('localhost', 8439)

289

with ForkedFake.from_client(client, {'baz': [

290

{'message_id': 'bar', 'date': 'x'},

291

{'message_id': 'qux', 'date': 'z'},

292

{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'qux'},

293

]}):

294

response = client.get_messages('baz')

295

self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])

296

response = client.get_messages('baz', order='date')

297

self.assertIDOrder(['bar', 'foo', 'qux'], response['messages'])

298

response = client.get_messages('baz', order='thread_oldest')

299

self.assertIDOrder(['bar', 'qux', 'foo'], response['messages'])

300

301

def test_get_messages_thread_newest_order(self):

302

client = GrackleClient('localhost', 8439)

303

with ForkedFake.from_client(client, {'baz': [

304

{'message_id': 'bar', 'date': 'x'},

305

{'message_id': 'qux', 'date': 'w'},

306

{'message_id': 'foo', 'date': 'y', 'in_reply_to': 'bar'},

307

{'message_id': 'baz', 'date': 'z', 'in_reply_to': 'qux'},

308

]}):

309

response = client.get_messages('baz', order='date')

310

self.assertIDOrder(

311

['qux', 'bar', 'foo', 'baz'], response['messages'])

312

response = client.get_messages('baz', order='thread_newest')

313

self.assertIDOrder(

314

['bar', 'foo', 'qux', 'baz'], response['messages'])

315

316

def test_get_messages_unsupported_order(self):

317

client = GrackleClient('localhost', 8439)

318

with ForkedFake.from_client(client,

319

{'baz': [{'message_id': 'foo', 'date': '2011-03-25'},

320

{'message_id': 'bar', 'date': '2011-03-24'}]}):

321

with ExpectedException(UnsupportedOrder):

322

client.get_messages('baz', order='nonsense')

323

324

def test_get_messages_headers_no_headers(self):

325

client = GrackleClient('localhost', 8440)

326

with ForkedFake.from_client(client,

327

{'baz': [

328

{'message_id': 'foo'}

329

]}):

330

response = client.get_messages('baz', headers=[

331

'Subject', 'Date', 'X-Launchpad-Message-Rationale'])

332

first_message = response['messages'][0]

333

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

334

self.assertEqual({}, first_message['headers'])

335

336

def test_get_messages_headers_exclude_headers(self):

337

client = GrackleClient('localhost', 8441)

338

with ForkedFake.from_client(client,

339

{'baz': [

340

{'message_id': 'foo', 'headers': {'From': 'me'}}

341

]}):

342

response = client.get_messages('baz', headers=[

343

'Subject', 'Date', 'X-Launchpad-Message-Rationale'])

344

first_message = response['messages'][0]

345

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

346

self.assertEqual({}, first_message['headers'])

347

348

def test_get_messages_headers_include_headers(self):

349

client = GrackleClient('localhost', 8442)

350

with ForkedFake.from_client(client,

351

{'baz': [

352

{'message_id': 'foo', 'headers': {'From': 'me', 'To': 'you'}}

353

]}):

354

response = client.get_messages('baz', headers=[

355

'From', 'To'])

356

first_message = response['messages'][0]

357

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

358

self.assertEqual({'From': 'me', 'To': 'you'}, first_message['headers'])

359

360

def test_get_messages_max_body_length(self):

361

client = GrackleClient('localhost', 8443)

362

with ForkedFake.from_client(client,

363

{'baz': [

364

{'message_id': 'foo', 'body': u'abcdefghi'}

365

]}):

366

response = client.get_messages('baz', max_body_length=3)

367

first_message = response['messages'][0]

368

self.assertEqual('abc', first_message['body'])

369

370

def test_include_hidden(self):

371

client = GrackleClient('localhost', 8444)

372

with ForkedFake.from_client(client,

373

{'baz': [

374

{'message_id': 'foo', 'hidden': True},

375

{'message_id': 'bar', 'hidden': False}

376

]}):

377

response = client.get_messages('baz', include_hidden=True)

378

self.assertMessageIDs(['bar', 'foo'], response['messages'])

379

response = client.get_messages('baz', include_hidden=False)

380

self.assertMessageIDs(['bar'], response['messages'])

381