~m4v/scratbot-plugins/spaces

« back to all changes in this revision

Viewing changes to test.py

  • Committer: Elián Hanisch
  • Date: 2010-01-17 01:40:24 UTC
  • Revision ID: lambdae2@gmail.com-20100117014024-9lz288y6kdttjtbs
some initial support for use spaces in fact names.

Show diffs side-by-side

added added

removed removed

Lines of Context:
39
39
 
40
40
class CommonReplies:
41
41
    """Because I don't like typing the same thing too many times."""
42
 
    notFound  = 'El facto @%s no existe.'
43
 
    created   = 'Facto @%s creado.'
44
 
    edit      = 'Facto @%s actualizado.'
 
42
    notFound  = 'El facto %s no existe.'
 
43
    created   = 'Facto %s creado.'
 
44
    edit      = 'Facto %s actualizado.'
45
45
    maxlen    = 'Me diste un facto de %s carácteres. El máximo es 400.'
46
46
    dup       = '@%s ya existe. Si desea editarlo utilise @no.'
47
47
    locked    = '@%s está protegido contra cambios.'
53
53
 
54
54
    def __call__(self, name, *args):
55
55
        s = getattr(self, name)
 
56
        if name in ('notFound', 'created', 'edit') and ' ' in args[0]:
 
57
             args = ('"%s"' %args, )
56
58
        return s % args
57
59
 
58
60
reply = CommonReplies()
87
89
        Fconf.repeatProtection.collision.setValue(False)
88
90
 
89
91
    def testFact(self):
90
 
        self.assertResponse('foobar', reply('notFound', 'foobar'))
91
 
        self.assertResponse('foobar es una prueba', reply('created', 'foobar'))
 
92
        self.assertResponse('foobar', reply('notFound', '@foobar'))
 
93
        self.assertResponse('foobar es una prueba', reply('created', '@foobar'))
92
94
        self.assertResponse('foobar', 'foobar es una prueba')
93
95
        self.assertResponse('foobar: ...', reply('dup', 'foobar'))
94
 
        self.assertResponse('foo:   bar', reply('created', 'foo'))
 
96
        self.assertResponse('foo:   bar', reply('created', '@foo'))
95
97
        self.assertResponse('foo', 'bar')
96
98
        #charlimits
97
99
        s = 'a' * 401
105
107
        #self.assertError('  es test ')
106
108
        # add a disabled fact
107
109
        self.assertNotError('borrar foo')
108
 
        self.assertResponse('foo es otro foo', reply('created', 'foo'))
 
110
        self.assertResponse('foo es otro foo', reply('created', '@foo'))
109
111
        self.assertResponse('foo', 'foo es otro foo')
 
112
        # spaces
 
113
        self.assertResponse('la respuesta a todo', reply('notFound', '@la respuesta a todo'))
 
114
        self.assertResponse('la respuesta a todo es algo que no existe', 
 
115
                reply('created', '@la respuesta a todo'))
 
116
        self.assertResponse('la respuesta a todo', 'la respuesta a todo es algo que no existe')
 
117
        self.assertResponse('what to do now: the same as yesterday',
 
118
                reply('created', '@what to do now'))
 
119
        self.assertResponse('what to do now', 'the same as yesterday')
110
120
 
111
121
    def testFactSpecialTests(self):
112
122
        self.assertNotError('foo es bar')
119
129
            self.prefix = 'test!user@factos.net'
120
130
        # add a fact with quotes
121
131
        #conf.supybot.commands.quotes.set('')
122
 
        self.assertResponse('comillas es "dobles" y  \'simples\'', reply('created', 'comillas'))
 
132
        self.assertResponse('comillas es "dobles" y  \'simples\'', reply('created', '@comillas'))
123
133
        self.assertResponse('comillas', 'comillas es "dobles" y \'simples\'')
124
134
        # channels that end with 'es'
125
135
        self.assertNotError('bar#test-es es un facto.')
127
137
 
128
138
    def testFactChannelPrefix(self):
129
139
        # test facts with '#' on their names
130
 
        self.assertResponse('#kubuntu-es es un canal de soporte', reply('created', '#kubuntu-es'))
 
140
        self.assertResponse('#kubuntu-es es un canal de soporte', reply('created', '@#kubuntu-es'))
131
141
        self.assertResponse('#kubuntu-es', '#kubuntu-es es un canal de soporte')
132
 
        self.assertResponse('#kubuntu-es#test es un facto', reply('created', '#kubuntu-es#test'))
 
142
        self.assertResponse('#kubuntu-es#test es un facto', reply('created', '@#kubuntu-es#test'))
133
143
        self.assertResponse('#kubuntu-es', '#kubuntu-es es un facto')
134
144
        self.assertResponse('#kubuntu-es#', '#kubuntu-es es un canal de soporte')
135
145
 
136
 
    def testFactHighlight(self):
 
146
    def _testFactHighlight(self):
137
147
        self.assertNotError('foo : bar')
138
148
        self.assertResponse('foo', 'bar')
139
149
        m = self.getMsg('foo>user')
169
179
        self.assertEqual(m.args[1], 'user: por favor mira mi mensaje privado.')
170
180
        # if there was an error the 'see my private msg' shouldn't be send
171
181
        self.assertResponse('dile a nouser sobre foo', reply('nouser', 'nouser'))
172
 
        self.assertResponse('dile a user sobre moo', reply('notFound', 'moo'))
 
182
        self.assertResponse('dile a user sobre moo', reply('notFound', '@moo'))
173
183
        self.assertResponse('foo', 'bar')
174
184
 
175
185
    def testEditFact(self):
176
 
        self.assertResponse('no, foo es bar', reply('notFound', 'foo'))
 
186
        self.assertResponse('no, foo es bar', reply('notFound', '@foo'))
177
187
        self.assertNotError('foo:bar')
178
188
        self.assertResponse('foo', 'bar')
179
 
        self.assertResponse('no, foo es bar', reply('edit', 'foo'))
 
189
        self.assertResponse('no, foo es bar', reply('edit', '@foo'))
180
190
        self.assertResponse('foo', 'foo es bar')
181
 
        self.assertResponse('no foo : bar', reply('edit', 'foo'))
 
191
        self.assertResponse('no, foo : bar', reply('edit', '@foo'))
182
192
        self.assertResponse('foo', 'bar')
183
193
        self.assertResponse('no, foo:bar', 'Pero si @foo ya dice eso.')
184
194
        #charlimits
185
195
        s = 'a' * 401
186
196
        self.assertRegexp('no, foo:%s' % s , reply('maxlen', len(s)))
187
 
        self.assertResponse('no,foo:barbar', reply('edit', 'foo'))
 
197
        self.assertResponse('no,foo:barbar', reply('edit', '@foo'))
188
198
        # test bugfix: facts that starts with 'no' aren't confused as edit cmd
189
 
        self.assertResponse('normas alias foo', reply('created', 'normas→foo'))
 
199
        self.assertResponse('normas alias foo', reply('created', '@normas→foo'))
190
200
        # test bugfix:
191
 
        self.assertError('no asd asd asd')
 
201
        self.assertError('no, asd asd asd')
 
202
        # spaces
 
203
        self.assertNotError('servidor ftp es un server de archivos')
 
204
        self.assertResponse('no, servidor ftp: Descargas disponibles en asd asdasd.',
 
205
                reply('edit', '@servidor ftp'))
192
206
 
193
 
    def testSubstitute(self):
 
207
    def _testSubstitute(self):
194
208
        self.assertNotError('foo:bar')
195
209
        self.assertNotError('s/$/ bar/foo')
196
210
        self.assertResponse('foo', 'bar bar')
222
236
        self.assertNotError('agrega a alias BBB')
223
237
        self.assertResponse('alias', 'bar AAA A BBB')
224
238
 
225
 
    def testSpecialChars(self):
 
239
    def _testSpecialChars(self):
226
240
        self.assertNotError('ña_-a.z es válido')
227
241
        self.assertResponse('ña_-a.z', 'ña_-a.z es válido')
228
242
        self.assertNotError('test: %sasd %')
229
243
        self.assertResponse('test', '%sasd %')
230
244
 
231
 
    def testCaseInsensible(self):
 
245
    def _testCaseInsensible(self):
232
246
        self.assertNotError('tEsT:testing...')
233
247
        self.assertResponse('test', 'testing...')
234
248
        self.assertResponse('TEST', 'testing...')
249
263
        self.assertNotError('ÑOO es bar')
250
264
        self.assertResponse('ñoo', 'ÑOO es bar')
251
265
 
252
 
    def testChannelSpecific(self):
 
266
    def _testChannelSpecific(self):
253
267
        self.assertNotError('foo:global')
254
268
        self.assertResponse('foo', 'global')
255
269
        self.assertResponse('foo#test : local', reply('created', 'foo#test'))
265
279
        self.assertNotError('desborrar foo#test')
266
280
        self.assertResponse('bar', 'local')
267
281
 
268
 
    def testChannelSpecificEdit(self):
 
282
    def _testChannelSpecificEdit(self):
269
283
        self.assertNotError('foo:global')
270
284
        self.assertNotError('foo#test:local')
271
285
        self.assertNotError('no, foo : local2')
291
305
        self.assertNotError('s/$/ AAA/foo#')
292
306
        self.assertResponse('foo#', 'global2 AAA AAA')
293
307
 
294
 
    def testPreview(self):
 
308
    def _testPreview(self):
295
309
        self.assertNotError('foo:bar')
296
310
        self.assertResponse('no, foo:bar bar --preview', 'Preview: bar bar')
297
311
        self.assertResponse('foo', 'bar')
299
313
        self.assertResponse('foo', 'bar')
300
314
        self.assertResponse('añadir a foo AAA --preview', 'Preview: bar AAA')
301
315
 
302
 
    def testRemoveFact(self):
 
316
    def _testRemoveFact(self):
303
317
        self.assertNotError('foo:bar')
304
318
        self.assertResponse('foo', 'bar')
305
319
        self.assertResponse('borrar foo', reply('deleted', 'foo'))
310
324
        self.assertResponse('desborrar foo', '@foo no se encuentra borrado.')
311
325
        self.assertResponse('foo', 'bar')
312
326
 
313
 
    def testLockFact(self):
 
327
    def _testLockFact(self):
314
328
        self.assertNotError('foo:bar')
315
329
        self.assertResponse('foo', 'bar')
316
330
        self.assertResponse('proteger foo', 'Facto @foo protegido contra cambios.')
325
339
        self.assertResponse('desborrar foo', reply('forbidden', 'foo'))
326
340
        self.assertResponse('foo:bar', reply('forbidden', 'foo'))
327
341
 
328
 
    def testAlias(self):
 
342
    def _testAlias(self):
329
343
        self.assertNotError('foo:bar')
330
344
        self.assertResponse('test alias foo', reply('created', 'test→foo'))
331
345
        self.assertResponse('test', 'bar')
344
358
        self.assertResponse('aliastoalias_2', 'a')
345
359
        self.assertRegexp('aliastoalias_2 --raw', 'flags:4 .* data:fact')
346
360
 
347
 
    def testAliasEdit(self):
 
361
    def _testAliasEdit(self):
348
362
        # create alias by editing
349
363
        self.assertNotError('foo:bar')
350
364
        self.assertNotError('foobar es una prueba')
355
369
        self.assertNotError('no, foo es bar')
356
370
        self.assertResponse('foobar', 'foo es bar')
357
371
 
358
 
    def testAliasLoops(self):
 
372
    def _testAliasLoops(self):
359
373
        self.assertNotError('foo:bar')
360
374
        self.assertResponse('test alias foo', reply('created', 'test→foo'))
361
375
        self.assertResponse('test', 'bar')
362
376
        self.assertError('no, foo alias test')  # alias loop
363
377
 
364
 
    def testAliasChannelSpecific(self):
 
378
    def _testAliasChannelSpecific(self):
365
379
        self.assertNotError('foo#channel:bar in #channel')
366
380
        self.assertResponse('test alias foo#channel', reply('created', 'test→foo#channel'))
367
381
        self.assertResponse('test', 'bar in #channel')
375
389
        self.assertResponse('test2', 'bar')
376
390
        self.assertResponse('test3', reply('notFound', 'test3→foo#test'))
377
391
 
378
 
    def testCounters(self):
 
392
    def _testCounters(self):
379
393
        self.assertNotError('foo:bar')
380
394
        self.assertRegexp('foo --raw', 'request_count:0')
381
395
        for i in range(10):
423
437
        self.assertRegexp('moo --raw', 'request_count:1')
424
438
        self.assertRegexp('foo --raw', 'request_count:12')
425
439
 
426
 
    def testGetFactRaw(self):
 
440
    def _testGetFactRaw(self):
427
441
        self.assertNotError('foo:bar')
428
442
        m = self.getMsg('foo --raw')
429
443
        msgs = m.args[1].split()
436
450
        for s in msgs:
437
451
            self.assertMatchRegexp(s, regiter.next())
438
452
 
439
 
    def testGetFactInfo(self):
 
453
    def _testGetFactInfo(self):
440
454
        self.assertNotError('foo:bar')
441
455
        self.assertNotError('bar alias foo')
442
456
        self.assertRegexp('foo --info', r'El facto @foo fué creado por ' \
457
471
        self.assertNotError('foo#test:bar')
458
472
        self.assertRegexp('foo --info', r'@foo#test')
459
473
 
460
 
    def testGetFactDisabled(self):
 
474
    def _testGetFactDisabled(self):
461
475
        self.assertNotError('foo:bar')
462
476
        self.assertResponse('foo', 'bar')
463
477
        self.assertNotError('borrar foo')
470
484
        self.assertEqual(m.args[0], 'test')
471
485
        self.assertEqual(m.args[1], 'bar')
472
486
 
473
 
    def testEditorRaw(self):
 
487
    def _testEditorRaw(self):
474
488
        regexps = r'user_id:0 host:test!user@factos.net'\
475
489
                ' first_seen:\d{10} last_seen:\d{10} facts:1 edits:0'.split()
476
490
        regexps.extend(r'user_id:1 host:moo!user@factos.net'\
487
501
        for s in msgs:
488
502
            self.assertMatchRegexp(s, regiter.next())
489
503
 
490
 
    def testKeywords(self):
 
504
    def _testKeywords(self):
491
505
        self.assertNotError('chan:This channel is $channel')
492
506
        self.assertResponse('chan', 'This channel is #test')
493
507
        self.assertResponse('chan --noreplace', 'This channel is $channel')
501
515
        self.assertNotError('no, slap:slaps ${1} with a ${2}')
502
516
        self.assertResponse('slap | m4v fish', 'slaps m4v with a fish')
503
517
 
504
 
    def testFactSubstitute(self):
 
518
    def _testFactSubstitute(self):
505
519
        self.assertNotError('foo:bar')
506
520
        self.assertNotError('moo: foo says %foo%')
507
521
        self.assertResponse('moo', 'foo says bar')
519
533
        self.assertNotError('no,boo: foo says %foo#test2%')
520
534
        self.assertResponse('boo', 'foo says LOCAL2')
521
535
 
522
 
    def testFactMode(self):
 
536
    def _testFactMode(self):
523
537
        self.assertNotError('foo:bar')
524
538
        self.assertRegexp('factmode foo', '\(none\)$')
525
539
        self.assertNotError('borrar foo')
531
545
        self.assertError('factmode foo +asdas')
532
546
        self.assertError('factmode foo lock')
533
547
 
534
 
    def testFactModeSetting(self):
 
548
    def _testFactModeSetting(self):
535
549
        self.assertNotError('foo:bar')
536
550
        self.assertNotError('boo alias foo')
537
551
        self.assertNotError('factmode boo -alias')
555
569
        m = self.getMsg('foo', frm='user!test@test.com')
556
570
        self.assertEqual(m.args[0], 'user')
557
571
 
558
 
    def testFactModeAlert(self):
 
572
    def _testFactModeAlert(self):
559
573
        self.assertNotError('foo:bar')
560
574
        self.assertNotError('bar#test:bar')
561
575
        self.assertNotError('boo alias foo')
607
621
        finally:
608
622
            Fconf.noticeInChannels.set('')
609
623
 
610
 
    def testIgnore(self):
 
624
    def _testIgnore(self):
611
625
        self.assertNotError('test:test')
612
626
        self.assertResponse('@test', 'test')
613
627
        self.assertNoResponse('@ test')
623
637
        self.assertNoResponse('asdasd')
624
638
        Fconf.quiet.get('#test').setValue(False)
625
639
 
626
 
    def testUsers(self):
 
640
    def _testUsers(self):
627
641
        self.assertNotError('foo:bar')
628
642
        self.assertRegexp('foo --raw', r'created_by:0 created_at:\d+')
629
643
        self.assertRegexp('foo --raw', r'edited_by:None edited_at:None')
643
657
        self.assertRegexp('foo --raw', r'flags:2 flags_set_by:2 flags_set_at:\d+')
644
658
        self.prefix = 'test!user@factos.net'
645
659
 
646
 
    def testEditor(self):
 
660
    def _testEditor(self):
647
661
        self.assertHelp('editor')
648
662
        #self.assertError('editor --id 0') # private
649
663
        self.assertRegexp('editor --id 0', r'No encontré ningún', private=True)
680
694
        finally:
681
695
            world.testing = True
682
696
 
683
 
    def testDates(self):
 
697
    def _testDates(self):
684
698
        def getTimeOf(s):
685
699
            m = self.getMsg('foo --raw')
686
700
            return int(re.search('%s_at:(\d+)\s' % s, m.args[1]).groups()[0])
721
735
        t = getTimeOf('created')
722
736
        self.assertEqual(t, ct)
723
737
 
724
 
    def testHistory(self):
 
738
    def _testHistory(self):
725
739
        self.assertNotError('foo:bar')
726
740
        self.assertResponse('deshacer foo', 'No hay cambios para deshacer en @foo.')
727
741
        self.assertResponse('rehacer foo', '@foo ya está en su último cambio.')
742
756
        self.assertNotError('deshacer foo')
743
757
        self.assertResponse('foo', 'new')
744
758
 
745
 
    def testHistLocal(self):
 
759
    def _testHistLocal(self):
746
760
        # local facts
747
761
        self.assertNotError('foo:bar')
748
762
        self.assertNotError('foo#test:mar')
752
766
        self.assertNotError('rehacer foo')
753
767
        self.assertResponse('foo', 'mar1')
754
768
 
755
 
    def testHistAlias(self):
 
769
    def _testHistAlias(self):
756
770
        self.assertNotError('foo:bar')
757
771
        self.assertNotError('test:testing')
758
772
        self.assertNotError('no, test alias foo')
762
776
        self.assertNotError('rehacer test')
763
777
        self.assertResponse('test', 'bar')
764
778
 
765
 
    def testHistRestart(self):
 
779
    def _testHistRestart(self):
766
780
        self.assertNotError('foo:bar')
767
781
        self.assertNotError('no, foo:bar1')
768
782
        self.assertNotError('no, foo:bar2')
783
797
        self.assertNotError('deshacer foo')
784
798
        self.assertResponse('foo', 'bar')
785
799
 
786
 
    def testHistRecord(self):
 
800
    def _testHistRecord(self):
787
801
        self.assertNotError('foo:bar')
788
802
        self.assertNotError('no, foo:bar1')
789
803
        self.assertNotError('no, foo:bar2')
832
846
        self.assertNotError('rehacer foo')
833
847
        self.assertResponse('foo', 'bar2')
834
848
 
835
 
    def testQuery(self):
 
849
    def _testQuery(self):
836
850
        self.assertResponse('foo:bar', reply('created', 'foo'), private=True)
837
851
        self.assertResponse('foo', 'bar', private=True)
838
852
        self.assertResponse('@bar:bar', reply('created', 'bar'), private=True)
839
853
        self.assertResponse('@bar', 'bar', private=True)
840
854
 
841
 
    def testNotices(self):
 
855
    def _testNotices(self):
842
856
        self.prefix = 'user!user@test.c'
843
857
        Fconf.noticeInChannels.set('#notice')
844
858
        try:
861
875
            Fconf.noticeInChannels.set('')
862
876
            self.prefix = 'test!user@factos.net'
863
877
 
864
 
    def testRestrictions(self):
 
878
    def _testRestrictions(self):
865
879
        try:
866
880
            world.testing = False # disable test privileges
867
881
            self.assertNotError('foo es bar')
891
905
            self.prefix = 'test!user@factos.net'
892
906
            world.testing = True
893
907
 
894
 
    def testRepeatProtection(self):
 
908
    def _testRepeatProtection(self):
895
909
        Fconf.repeatProtection.setValue(True)
896
910
        Fconf.repeatProtection.timeout.setValue(3)
897
911
        Fconf.repeatProtection.msgthreshold.setValue(5)
933
947
            Fconf.repeatProtection.collision.setValue(False)
934
948
            self.channel = '#test'
935
949
 
936
 
    def testStats(self):
 
950
    def _testStats(self):
937
951
        self.assertResponse('estadistica', 'No hay factos activos en la base.')
938
952
        self.assertNotError('foo:bar')
939
953
        self.assertRegexp('estadistica', '1 factos activos')
949
963
        self.assertNotError('boo:bar')
950
964
        self.assertRegexp('estadistica', 'usados son @moo, @boo\.')
951
965
 
952
 
    def testSearch(self):
 
966
    def _testSearch(self):
953
967
        self.assertNotError('foo:bar')
954
968
        self.assertNotError('foo#test:localbar')
955
969
        self.assertNotError('foo#channel:other bar')
968
982
        self.assertNotError('kubot')
969
983
        self.assertRegexp('buscar bot', ': .kubot#$')
970
984
 
971
 
    def testRestart(self):
 
985
    def _testRestart(self):
972
986
        self.assertNotError('foo:bar')
973
987
        self.assertNotError('no, foo:bar1')
974
988
        self.assertNotError('no, foo:bar2')