← Back to branch summary

~chipaca/unity-lens-video/custom-user-agent

« back to all changes in this revision

Viewing changes to oneliners/tests.py

  • Committer: Janos Gyerik
  • Date: 2012-05-21 18:31:58 UTC
  • Revision ID: janos@axiom-20120521183158-kvtqzuo6yhe3mdzq
added example configuration for logging to file

Show diffs side-by-side

added added

removed removed

Lines of Context:
oneliners/tests.py
1
1
from django.test import TestCase
2
2
 
3
 
from main.models import Hacker, OneLiner, Vote
 
3
from oneliners.models import Tag, AcceptedAnswer, Question, OneLiner, Answer, User
 
4
from oneliners.forms import SearchOneLinerForm, EditOneLinerForm
 
5
 
4
6
 
5
7
class Util:
6
8
    @staticmethod
7
 
    def new_hacker(username):
8
 
        hacker = Hacker(username=username)
9
 
        hacker.save()
10
 
        return hacker
 
9
    def new_user(username):
 
10
        user = User(username=username)
 
11
        user.save()
 
12
        return user
11
13
 
12
14
    @staticmethod
13
 
    def new_oneliner(hacker, line):
14
 
        oneliner = OneLiner(hacker=hacker, line=line)
15
 
        oneliner.save()
16
 
        return oneliner
 
15
    def new_oneliner(user, line, summary=None, explanation=None, limitations=None):
 
16
        if summary is None:
 
17
            summary = '(incorrectly omitted)'
 
18
        if explanation is None:
 
19
            explanation = '(incorrectly omitted)'
 
20
        if limitations is None:
 
21
            limitations = '(this is optional)'
 
22
        oneliner = OneLiner(user=user, line=line, summary=summary, explanation=explanation, limitations=limitations)
 
23
        oneliner.save()
 
24
        return oneliner
17
25
 
18
26
    @staticmethod
19
27
    def new_vote():
20
 
        pass
 
28
        pass
 
29
 
 
30
    @staticmethod
 
31
    def new_question(user):
 
32
        question = Question(user=user)
 
33
        question.save()
 
34
        return question
 
35
 
 
36
    @staticmethod
 
37
    def new_answer(question, oneliner):
 
38
        answer = Answer(question=question, oneliner=oneliner)
 
39
        answer.save()
 
40
        return answer
 
41
 
 
42
 
 
43
class EditOneLinerTests(TestCase):
 
44
    def setUp(self):
 
45
        self.jack = Util.new_user('jack')
 
46
        self.jacks_oneliner = Util.new_oneliner(self.jack, 'echo jack')
 
47
 
 
48
        self.frank = Util.new_user('frank')
 
49
        self.franks_oneliner = Util.new_oneliner(self.frank, 'echo frank')
 
50
 
 
51
    def test_save_own_success(self):
 
52
        oneliner0 = self.jacks_oneliner
 
53
        data = {
 
54
                'summary': oneliner0.summary,
 
55
                'line': oneliner0.line,
 
56
                'explanation': oneliner0.explanation,
 
57
                'action': EditOneLinerForm.action_save,
 
58
                }
 
59
        new_summary = oneliner0.summary + ' some change'
 
60
        data['summary'] = new_summary
 
61
 
 
62
        form = EditOneLinerForm(self.jack, data, instance=oneliner0)
 
63
        self.assertTrue(form.is_valid())
 
64
        oneliner1 = form.save()
 
65
 
 
66
        self.assertEquals(oneliner1.summary, new_summary)
 
67
        self.assertEquals(oneliner1.user, self.jack)
 
68
 
 
69
    def test_save_own_failure(self):
 
70
        oneliner0 = self.jacks_oneliner
 
71
        data = {
 
72
                'summary': oneliner0.summary,
 
73
                'line': oneliner0.line,
 
74
                'action': EditOneLinerForm.action_save,
 
75
                }
 
76
        new_summary = oneliner0.summary + ' some change'
 
77
        data['summary'] = new_summary
 
78
 
 
79
        form = EditOneLinerForm(self.jack, data, instance=oneliner0)
 
80
        self.assertFalse(form.is_valid())
 
81
 
 
82
        error_items = form.errors.items()
 
83
        self.assertEquals(len(error_items), 1)
 
84
        self.assertEquals(error_items[0][0], 'explanation')
 
85
 
 
86
    def test_save_notown_failure(self):
 
87
        oneliner0 = self.jacks_oneliner
 
88
        data = {
 
89
                'summary': oneliner0.summary,
 
90
                'line': oneliner0.line,
 
91
                'explanation': oneliner0.explanation,
 
92
                'action': EditOneLinerForm.action_save,
 
93
                }
 
94
 
 
95
        form = EditOneLinerForm(self.frank, data, instance=self.jacks_oneliner)
 
96
        self.assertFalse(form.is_valid())
 
97
 
 
98
        error_items = form.errors.items()
 
99
        self.assertEquals(len(error_items), 1)
 
100
        self.assertEquals(error_items[0][0], '__all__')
21
101
 
22
102
 
23
103
class VoteTests(TestCase):
24
104
    def setUp(self):
25
 
        self.jack = Util.new_hacker('jack')
26
 
        self.jacks_oneliner = Util.new_oneliner(self.jack, 'echo jack')
27
 
 
28
 
        self.mike = Util.new_hacker('mike')
29
 
        self.mikes_oneliner = Util.new_oneliner(self.mike, 'echo mike')
30
 
 
31
 
        self.frank = Util.new_hacker('frank')
32
 
        self.franks_oneliner = Util.new_oneliner(self.frank, 'echo frank')
 
105
        self.jack = Util.new_user('jack')
 
106
        self.jacks_oneliner = Util.new_oneliner(self.jack, 'echo jack')
 
107
 
 
108
        self.mike = Util.new_user('mike')
 
109
        self.mikes_oneliner = Util.new_oneliner(self.mike, 'echo mike')
 
110
 
 
111
        self.frank = Util.new_user('frank')
 
112
        self.franks_oneliner = Util.new_oneliner(self.frank, 'echo frank')
33
113
 
34
114
    def test_multiple_vote_tolerance(self):
35
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 0)
36
 
        self.jacks_oneliner.vote_up(self.jack)
37
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 0)
38
 
        self.jacks_oneliner.vote_up(self.mike)
39
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
40
 
        self.jacks_oneliner.vote_up(self.mike)
41
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
42
 
        self.jacks_oneliner.vote_up(self.mike)
43
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
 
115
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 0)
 
116
        self.jacks_oneliner.vote_up(self.jack)
 
117
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 0)
 
118
        self.jacks_oneliner.vote_up(self.mike)
 
119
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
 
120
        self.jacks_oneliner.vote_up(self.mike)
 
121
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
 
122
        self.jacks_oneliner.vote_up(self.mike)
 
123
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
44
124
 
45
125
    def test_vote_counts(self):
46
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 0)
47
 
        self.jacks_oneliner.vote_up(self.jack)
48
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 0)
49
 
        self.jacks_oneliner.vote_up(self.mike)
50
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
51
 
        self.jacks_oneliner.vote_up(self.frank)
52
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 2)
53
 
        self.jacks_oneliner.vote_up(self.frank)
54
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 2)
55
 
        self.jacks_oneliner.vote_down(self.frank)
56
 
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
57
 
        self.assertEquals(self.jacks_oneliner.get_votes_down(), 1)
58
 
        self.assertEquals(self.jacks_oneliner.get_votes(), (1, 1))
59
 
 
60
 
 
61
 
class TopTests(TestCase):
62
 
    def setUp(self):
63
 
        self.jack = Util.new_hacker('jack')
64
 
        self.jacks_oneliner = Util.new_oneliner(self.jack, 'echo jack')
65
 
 
66
 
        self.mike = Util.new_hacker('mike')
67
 
        self.mikes_oneliner = Util.new_oneliner(self.mike, 'echo mike')
68
 
 
69
 
    def test_top(self):
70
 
        u1 = Util.new_hacker('u1')
71
 
        u2 = Util.new_hacker('u2')
72
 
        u3 = Util.new_hacker('u3')
73
 
 
74
 
        self.jacks_oneliner.vote_up(u1)
75
 
        self.assertEquals(OneLiner.top()[0], self.jacks_oneliner)
76
 
 
77
 
        self.mikes_oneliner.vote_up(u1)
78
 
        self.mikes_oneliner.vote_up(u2)
79
 
        self.assertEquals(OneLiner.top()[0], self.mikes_oneliner)
80
 
 
81
 
        self.jacks_oneliner.vote_up(u2)
82
 
        self.jacks_oneliner.vote_up(u3)
83
 
        self.assertEquals(OneLiner.top()[0], self.jacks_oneliner)
84
 
 
85
 
        u4 = Util.new_hacker('u4')
86
 
        u5 = Util.new_hacker('u5')
87
 
        self.mikes_oneliner.vote_down(u4)
88
 
        self.mikes_oneliner.vote_down(u5)
89
 
        self.assertEquals(OneLiner.top()[0], self.jacks_oneliner)
 
126
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 0)
 
127
        self.jacks_oneliner.vote_up(self.jack)
 
128
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 0)
 
129
        self.jacks_oneliner.vote_up(self.mike)
 
130
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
 
131
        self.jacks_oneliner.vote_up(self.frank)
 
132
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 2)
 
133
        self.jacks_oneliner.vote_up(self.frank)
 
134
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 2)
 
135
        self.jacks_oneliner.vote_down(self.frank)
 
136
        self.assertEquals(self.jacks_oneliner.get_votes_up(), 1)
 
137
        self.assertEquals(self.jacks_oneliner.get_votes_down(), 1)
 
138
        self.assertEquals(self.jacks_oneliner.get_votes(), (1, 1))
 
139
 
 
140
 
 
141
class RecentTests(TestCase):
 
142
    def setUp(self):
 
143
        self.jack = Util.new_user('jack')
 
144
        self.jacks_oneliner = Util.new_oneliner(self.jack, 'echo jack')
 
145
 
 
146
        self.mike = Util.new_user('mike')
 
147
        self.mikes_oneliner = Util.new_oneliner(self.mike, 'echo mike')
 
148
 
 
149
    def xtest_recent(self):
 
150
        u1 = Util.new_user('u1')
 
151
        u2 = Util.new_user('u2')
 
152
        u3 = Util.new_user('u3')
 
153
 
 
154
        self.jacks_oneliner.vote_up(u1)
 
155
        self.assertEquals(OneLiner.recent()[0], self.jacks_oneliner)
 
156
 
 
157
        self.mikes_oneliner.vote_up(u1)
 
158
        self.mikes_oneliner.vote_up(u2)
 
159
        self.assertEquals(OneLiner.recent()[0], self.mikes_oneliner)
 
160
 
 
161
        self.jacks_oneliner.vote_up(u2)
 
162
        self.jacks_oneliner.vote_up(u3)
 
163
        self.assertEquals(OneLiner.recent()[0], self.jacks_oneliner)
 
164
 
 
165
        u4 = Util.new_user('u4')
 
166
        u5 = Util.new_user('u5')
 
167
        self.mikes_oneliner.vote_down(u4)
 
168
        self.mikes_oneliner.vote_down(u5)
 
169
        self.assertEquals(OneLiner.recent()[0], self.jacks_oneliner)
 
170
 
 
171
 
 
172
class SearchTests(TestCase):
 
173
    def setUp(self):
 
174
        self.jack = Util.new_user('jack')
 
175
        self.jacks_oneliner = Util.new_oneliner(self.jack, 'echo jack')
 
176
 
 
177
        self.mike = Util.new_user('mike')
 
178
        self.mikes_oneliner = Util.new_oneliner(self.mike, 'echo mike')
 
179
 
 
180
        self.vi_oneliner = Util.new_oneliner(self.mike, 'vi is an editor', summary='vi oneliner')
 
181
        self.video_oneliner = Util.new_oneliner(self.mike, 'mplayer is a video manipulator', summary='mplayer oneliner')
 
182
 
 
183
        self.mline_oneliner = Util.new_oneliner(self.jack, 'mline')
 
184
        self.msummary_oneliner = Util.new_oneliner(self.jack, '', summary='msummary')
 
185
        self.mexplanation_oneliner = Util.new_oneliner(self.jack, '', explanation='mexplanation')
 
186
        self.mlimitations_oneliner = Util.new_oneliner(self.jack, '', limitations='mlimitations')
 
187
 
 
188
    def test_simplesearch(self):
 
189
        self.assertEquals(OneLiner.simplesearch('echo').count(), 2)
 
190
        self.assertEquals(OneLiner.simplesearch('echo jack').count(), 1)
 
191
        self.assertEquals(OneLiner.simplesearch('echo mike').count(), 1)
 
192
        self.assertEquals(OneLiner.simplesearch('jack')[0], self.jacks_oneliner)
 
193
        self.assertEquals(OneLiner.simplesearch('echo jack')[0], self.jacks_oneliner)
 
194
        self.assertEquals(OneLiner.simplesearch('echo mike')[0], self.mikes_oneliner)
 
195
 
 
196
    def get_form(self, data):
 
197
        initial = {
 
198
                'match_summary': True,
 
199
                'match_line': True,
 
200
                'match_explanation': True,
 
201
                'match_limitations': True,
 
202
                }
 
203
        initial.update(data)
 
204
        form = SearchOneLinerForm(data=initial)
 
205
        self.assertTrue(form.is_valid())
 
206
        return form
 
207
 
 
208
    def test_match_summary(self):
 
209
        results = OneLiner.search(self.get_form({'query': 'msummary', }))
 
210
        self.assertEquals(len(results), 1)
 
211
        self.assertEquals(results[0], self.msummary_oneliner)
 
212
 
 
213
        results = OneLiner.search(self.get_form({'query': 'msummary', 'match_summary': False, }))
 
214
        self.assertEquals(len(results), 0)
 
215
 
 
216
    def test_match_line(self):
 
217
        results = OneLiner.search(self.get_form({'query': 'mline', }))
 
218
        self.assertEquals(len(results), 1)
 
219
        self.assertEquals(results[0], self.mline_oneliner)
 
220
 
 
221
        results = OneLiner.search(self.get_form({'query': 'mline', 'match_line': False, }))
 
222
        self.assertEquals(len(results), 0)
 
223
 
 
224
    def test_match_explanation(self):
 
225
        results = OneLiner.search(self.get_form({'query': 'mexplanation', }))
 
226
        self.assertEquals(len(results), 1)
 
227
        self.assertEquals(results[0], self.mexplanation_oneliner)
 
228
 
 
229
        results = OneLiner.search(self.get_form({'query': 'mexplanation', 'match_explanation': False, }))
 
230
        self.assertEquals(len(results), 0)
 
231
 
 
232
    def test_match_limitations(self):
 
233
        results = OneLiner.search(self.get_form({'query': 'mlimitations', }))
 
234
        self.assertEquals(len(results), 1)
 
235
        self.assertEquals(results[0], self.mlimitations_oneliner)
 
236
 
 
237
        results = OneLiner.search(self.get_form({'query': 'mlimitations', 'match_limitations': False, }))
 
238
        self.assertEquals(len(results), 0)
 
239
 
 
240
    def test_match_whole_words(self):
 
241
        results = OneLiner.search(self.get_form({'query': 'vi', }))
 
242
        self.assertEquals(len(results), 2)
 
243
 
 
244
        results = OneLiner.search(self.get_form({'query': 'vi', 'match_whole_words': True, }))
 
245
        self.assertEquals(len(results), 1)
 
246
        self.assertEquals(results[0], self.vi_oneliner)
 
247
 
 
248
    def test_match_nothing(self):
 
249
        form = SearchOneLinerForm(data={'query': 'NOTHINGSHOULDMATCH'})
 
250
        self.assertTrue(form.is_valid())
 
251
        results = OneLiner.search(form)
 
252
        self.assertEquals(len(results), 0)
 
253
 
 
254
 
 
255
class QuestionTests(TestCase):
 
256
    def setUp(self):
 
257
        self.user = Util.new_user('user1')
 
258
 
 
259
    def test_create_question(self):
 
260
        Util.new_question(self.user)
 
261
 
 
262
    def test_list_questions(self):
 
263
        self.assertTrue(Question.objects.all().count() == 0)
 
264
        Util.new_question(self.user)
 
265
        self.assertTrue(Question.objects.all().count() > 0)
 
266
 
 
267
    def test_list_questions_latestfirst(self):
 
268
        Util.new_question(self.user)
 
269
        q2 = Util.new_question(self.user)
 
270
        self.assertTrue(Question.objects.latest() == q2)
 
271
 
 
272
    def test_list_excludes_nonpublished(self):
 
273
        Util.new_question(self.user)
 
274
        q2 = Util.new_question(self.user)
 
275
        self.assertEquals(Question.latest(), q2)
 
276
        q2.is_published = False
 
277
        q2.save()
 
278
        self.assertNotEquals(Question.latest(), q2)
 
279
 
 
280
    def test_list_excludes_answered(self):
 
281
        Util.new_question(self.user)
 
282
        q2 = Util.new_question(self.user)
 
283
        self.assertEquals(Question.latest(), q2)
 
284
        q2.is_answered = True
 
285
        q2.save()
 
286
        self.assertNotEquals(Question.latest(), q2)
 
287
 
 
288
    def test_answer(self):
 
289
        q1 = Util.new_question(self.user)
 
290
        jack = Util.new_user('jack')
 
291
        o1 = Util.new_oneliner(jack, 'echo jack')
 
292
        Util.new_answer(q1, o1)
 
293
 
 
294
    def test_multiple_answers(self):
 
295
        q1 = Util.new_question(self.user)
 
296
        jack = Util.new_user('jack')
 
297
        o1 = Util.new_oneliner(jack, 'echo jack')
 
298
        Util.new_answer(q1, o1)
 
299
        mike = Util.new_user('mike')
 
300
        o2 = Util.new_oneliner(mike, 'echo mike')
 
301
        Util.new_answer(q1, o2)
 
302
 
 
303
 
 
304
class AcceptedAnswerTests(TestCase):
 
305
    def setUp(self):
 
306
        self.jack = Util.new_user('jack')
 
307
        self.oneliner = OneLiner(user=self.jack)
 
308
        self.oneliner.save()
 
309
 
 
310
        self.bill = Util.new_user('bill')
 
311
        OneLiner(user=self.bill).save()
 
312
 
 
313
        self.mike = Util.new_user('mike')
 
314
        self.question = Question(user=self.mike)
 
315
        self.question.save()
 
316
 
 
317
    def test_accept(self):
 
318
        self.assertEqual(AcceptedAnswer.objects.count(), 0)
 
319
        self.assertTrue(not self.question.is_answered)
 
320
 
 
321
        self.question.accept_answer(self.oneliner)
 
322
        self.assertTrue(self.question.is_answered)
 
323
        self.assertEqual(AcceptedAnswer.objects.count(), 1)
 
324
 
 
325
        self.question.accept_answer(self.oneliner)
 
326
        self.assertTrue(self.question.is_answered)
 
327
        self.assertEqual(AcceptedAnswer.objects.count(), 1)
 
328
 
 
329
    def test_accept_clear(self):
 
330
        self.test_accept()
 
331
        self.assertTrue(AcceptedAnswer.objects.count() > 0)
 
332
        self.assertTrue(self.question.is_answered)
 
333
 
 
334
        self.question.clear_all_answers()
 
335
        self.assertFalse(AcceptedAnswer.objects.count() > 0)
 
336
        self.assertFalse(self.question.is_answered)
 
337
 
 
338
    def test_clear_answers_when_is_answered_is_cleared(self):
 
339
        self.test_accept()
 
340
        self.assertTrue(AcceptedAnswer.objects.count() > 0)
 
341
        self.assertTrue(self.question.is_answered)
 
342
 
 
343
        self.question.is_answered = False
 
344
        self.question.save()
 
345
        self.assertFalse(AcceptedAnswer.objects.count() > 0)
 
346
 
 
347
 
 
348
class TagTests(TestCase):
 
349
    def test_tag_generator(self):
 
350
        user = Util.new_user('jack')
 
351
 
 
352
        line = 'find grep xargs'
 
353
        oneliner = Util.new_oneliner(user, line)
 
354
        self.assertItemsEqual(('xargs', 'grep', 'find'), oneliner.get_tags())
 
355
 
 
356
        line = '''find /etc -type f -print0 2>/dev/null | xargs -0 grep --color=AUTO -Hn 'nameserver' 2>/dev/null'''
 
357
        oneliner = Util.new_oneliner(user, line)
 
358
        self.assertItemsEqual(('xargs', 'grep', 'find'), oneliner.get_tags())
 
359
 
 
360
        line = '''MAX=$(NUM=1;cat author.xml |perl -p -e 's/(Times Cited)/\n$1/g'|grep "Times Cited" |perl -p -e 's/^Times Cited:([0-9]*).*$/$1/g'|sort -nr | while read LINE; do if [ $LINE -ge $NUM ]; then echo "$NUM"; fi; NUM=$[$NUM+1]; done;); echo "$MAX"|tail -1'''
 
361
        oneliner = Util.new_oneliner(user, line)
 
362
        self.assertItemsEqual((u'sort', u'do', u'grep', u'then', u'read', u'tail', u'perl', u'while', u'done', u'echo', u'fi', u'cat', u'if'), oneliner.get_tags())
 
363
 
 
364
    def test_tag_cloud(self):
 
365
        user = Util.new_user('jack')
 
366
 
 
367
        Util.new_oneliner(user, 'xargs find grep')
 
368
        Util.new_oneliner(user, 'xargs ls rm find')
 
369
        Util.new_oneliner(user, 'xargs xargs while sleep done do')
 
370
 
 
371
        tagcloud = Tag.tagcloud()
 
372
        tagcloud = tagcloud.values_list('text', 'count')
 
373
        dd = dict(tagcloud)
 
374
        self.assertEquals(3, dd['xargs'])
 
375
        self.assertEquals(3, dd.get('xargs'))
 
376
        self.assertEquals(2, dd['find'])
 
377
        self.assertFalse(dd.get('BLAH'))
90
378
 
91
379
 
92
380
# eof