← Back to branch summary

~ubuntu-branches/ubuntu/natty/moin/natty-updates

« back to all changes in this revision

Viewing changes to MoinMoin/_tests/test_wikiutil.py

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2008-06-22 21:17:13 UTC
  • mto: This revision was merged to the branch mainline in revision 18.
  • Revision ID: james.westby@ubuntu.com-20080622211713-inlv5k4eifxckelr
Import upstream version 1.7.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
MoinMoin/_tests/test_wikiutil.py
9
9
 
10
10
import py
11
11
 
12
 
from MoinMoin import config, wikiutil
13
 
 
14
 
from werkzeug import MultiDict
 
12
from MoinMoin import wikiutil
15
13
 
16
14
 
17
15
class TestQueryStringSupport:
23
21
    ]
24
22
    def testParseQueryString(self):
25
23
        for qstr, expected_str, expected_unicode in self.tests:
26
 
            assert wikiutil.parseQueryString(qstr) == MultiDict(expected_unicode)
27
 
            assert wikiutil.parseQueryString(unicode(qstr)) == MultiDict(expected_unicode)
 
24
            assert wikiutil.parseQueryString(qstr, want_unicode=False) == expected_str
 
25
            assert wikiutil.parseQueryString(qstr, want_unicode=True) == expected_unicode
 
26
            assert wikiutil.parseQueryString(unicode(qstr), want_unicode=False) == expected_str
 
27
            assert wikiutil.parseQueryString(unicode(qstr), want_unicode=True) == expected_unicode
28
28
 
29
29
    def testMakeQueryString(self):
30
30
        for qstr, in_str, in_unicode in self.tests:
31
 
            assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_unicode)) == MultiDict(in_unicode)
32
 
            assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_str)) == MultiDict(in_unicode)
 
31
            assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_unicode, want_unicode=False), want_unicode=False) == in_str
 
32
            assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_str, want_unicode=False), want_unicode=False) == in_str
 
33
            assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_unicode, want_unicode=True), want_unicode=True) == in_unicode
 
34
            assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_str, want_unicode=True), want_unicode=True) == in_unicode
33
35
 
34
36
 
35
37
class TestTickets:
85
87
            assert wikiutil.join_wiki(baseurl, pagename) == url
86
88
 
87
89
 
 
90
class TestSystemPagesGroup:
 
91
    def testSystemPagesGroupNotEmpty(self):
 
92
        assert self.request.dicts.members('SystemPagesGroup')
 
93
 
88
94
class TestSystemPage:
89
95
    systemPages = (
 
96
        # First level, on SystemPagesGroup
 
97
        'SystemPagesInEnglishGroup',
 
98
        # Second level, on one of the pages above
90
99
        'RecentChanges',
91
100
        'TitleIndex',
92
101
        )
288
297
            for val in result[2]:
289
298
                assert val is None or isinstance(val, unicode)
290
299
 
291
 
    def testDoubleNameValueSeparator(self):
292
 
        tests = [
293
 
                  # regular and quoting tests
294
 
                  (u'd==4,=3 ',    ([], {u'd': u'=4', u'': u'3'}, [])),
295
 
                  (u'===a,b,c,d',  ([], {u'': u'==a'}, [u'b', u'c', u'd'])),
296
 
                  (u'a,b,===,c,d', ([u'a', u'b'], {u'': u'=='}, [u'c', u'd'])),
297
 
                ]
298
 
 
299
 
        def _check(a, e):
300
 
            r = wikiutil.parse_quoted_separated(a)
301
 
            assert r == e
302
 
 
303
 
        for args, expected in tests:
304
 
            yield _check, args, expected
305
 
 
306
300
    def testNoNameValue(self):
307
301
        abcd = [u'a', u'b', u'c', u'd']
308
302
        tests = [
900
894
        tests = [
901
895
            # text                    expected output
902
896
            (u'\xf6\xf6ll\xdf\xdf',   'A.2BAPYA9g-ll.2BAN8A3w-'),
903
 
            (u'level 2',              'level_2'),
904
 
            (u'level_2',              'level_2'),
 
897
            (u'level 2',              'level2'),
905
898
            (u'',                     'A'),
906
899
            (u'123',                  'A123'),
907
 
            # make sure that a valid anchor is not modified:
908
 
            (u'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_.-',
909
 
             u'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_.-')
910
900
        ]
911
901
        for text, expected in tests:
912
902
            yield self._check, text, expected
964
954
        assert relative_page == wikiutil.RelPageName(current_page, absolute_page)
965
955
 
966
956
 
967
 
class TestNormalizePagename(object):
968
 
 
969
 
    def testPageInvalidChars(self):
970
 
        """ request: normalize pagename: remove invalid unicode chars
971
 
 
972
 
        Assume the default setting
973
 
        """
974
 
        test = u'\u0000\u202a\u202b\u202c\u202d\u202e'
975
 
        expected = u''
976
 
        result = wikiutil.normalize_pagename(test, self.request.cfg)
977
 
        assert result == expected
978
 
 
979
 
    def testNormalizeSlashes(self):
980
 
        """ request: normalize pagename: normalize slashes """
981
 
        cases = (
982
 
            (u'/////', u''),
983
 
            (u'/a', u'a'),
984
 
            (u'a/', u'a'),
985
 
            (u'a/////b/////c', u'a/b/c'),
986
 
            (u'a b/////c d/////e f', u'a b/c d/e f'),
987
 
            )
988
 
        for test, expected in cases:
989
 
            result = wikiutil.normalize_pagename(test, self.request.cfg)
990
 
            assert result == expected
991
 
 
992
 
    def testNormalizeWhitespace(self):
993
 
        """ request: normalize pagename: normalize whitespace """
994
 
        cases = (
995
 
            (u'         ', u''),
996
 
            (u'    a', u'a'),
997
 
            (u'a    ', u'a'),
998
 
            (u'a     b     c', u'a b c'),
999
 
            (u'a   b  /  c    d  /  e   f', u'a b/c d/e f'),
1000
 
            # All 30 unicode spaces
1001
 
            (config.chars_spaces, u''),
1002
 
            )
1003
 
        for test, expected in cases:
1004
 
            result = wikiutil.normalize_pagename(test, self.request.cfg)
1005
 
            assert result == expected
1006
 
 
1007
 
    def testUnderscoreTestCase(self):
1008
 
        """ request: normalize pagename: underscore convert to spaces and normalized
1009
 
 
1010
 
        Underscores should convert to spaces, then spaces should be
1011
 
        normalized, order is important!
1012
 
        """
1013
 
        cases = (
1014
 
            (u'         ', u''),
1015
 
            (u'  a', u'a'),
1016
 
            (u'a  ', u'a'),
1017
 
            (u'a  b  c', u'a b c'),
1018
 
            (u'a  b  /  c  d  /  e  f', u'a b/c d/e f'),
1019
 
            )
1020
 
        for test, expected in cases:
1021
 
            result = wikiutil.normalize_pagename(test, self.request.cfg)
1022
 
            assert result == expected
1023
 
 
1024
 
class TestGroupPages(object):
1025
 
 
1026
 
    def testNormalizeGroupName(self):
1027
 
        """ request: normalize pagename: restrict groups to alpha numeric Unicode
1028
 
 
1029
 
        Spaces should normalize after invalid chars removed!
1030
 
        """
1031
 
        cases = (
1032
 
            # current acl chars
1033
 
            (u'Name,:Group', u'NameGroup'),
1034
 
            # remove than normalize spaces
1035
 
            (u'Name ! @ # $ % ^ & * ( ) + Group', u'Name Group'),
1036
 
            )
1037
 
        for test, expected in cases:
1038
 
            # validate we are testing valid group names
1039
 
            if wikiutil.isGroupPage(test, self.request.cfg):
1040
 
                result = wikiutil.normalize_pagename(test, self.request.cfg)
1041
 
                assert result == expected
1042
 
 
1043
 
class TestVersion(object):
1044
 
    def test_Version(self):
1045
 
        Version = wikiutil.Version
1046
 
        # test properties
1047
 
        assert Version(1, 2, 3).major == 1
1048
 
        assert Version(1, 2, 3).minor == 2
1049
 
        assert Version(1, 2, 3).release == 3
1050
 
        assert Version(1, 2, 3, '4.5alpha6').additional == '4.5alpha6'
1051
 
        # test Version init and Version to str conversion
1052
 
        assert str(Version(1)) == "1.0.0"
1053
 
        assert str(Version(1, 2)) == "1.2.0"
1054
 
        assert str(Version(1, 2, 3)) == "1.2.3"
1055
 
        assert str(Version(1, 2, 3, '4.5alpha6')) == "1.2.3-4.5alpha6"
1056
 
        assert str(Version(version='1.2.3')) == "1.2.3"
1057
 
        assert str(Version(version='1.2.3-4.5alpha6')) == "1.2.3-4.5alpha6"
1058
 
        # test Version comparison, trivial cases
1059
 
        assert Version() == Version()
1060
 
        assert Version(1) == Version(1)
1061
 
        assert Version(1, 2) == Version(1, 2)
1062
 
        assert Version(1, 2, 3) == Version(1, 2, 3)
1063
 
        assert Version(1, 2, 3, 'foo') == Version(1, 2, 3, 'foo')
1064
 
        assert Version(1) != Version(2)
1065
 
        assert Version(1, 2) != Version(1, 3)
1066
 
        assert Version(1, 2, 3) != Version(1, 2, 4)
1067
 
        assert Version(1, 2, 3, 'foo') != Version(1, 2, 3, 'bar')
1068
 
        assert Version(1) < Version(2)
1069
 
        assert Version(1, 2) < Version(1, 3)
1070
 
        assert Version(1, 2, 3) < Version(1, 2, 4)
1071
 
        assert Version(1, 2, 3, 'bar') < Version(1, 2, 3, 'foo')
1072
 
        assert Version(2) > Version(1)
1073
 
        assert Version(1, 3) > Version(1, 2)
1074
 
        assert Version(1, 2, 4) > Version(1, 2, 3)
1075
 
        assert Version(1, 2, 3, 'foo') > Version(1, 2, 3, 'bar')
1076
 
        # test Version comparison, more delicate cases
1077
 
        assert Version(1, 12) > Version(1, 9)
1078
 
        assert Version(1, 12) > Version(1, 1, 2)
1079
 
        assert Version(1, 0, 0, '0.0a2') > Version(1, 0, 0, '0.0a1')
1080
 
        assert Version(1, 0, 0, '0.0b1') > Version(1, 0, 0, '0.0a9')
1081
 
        assert Version(1, 0, 0, '0.0b2') > Version(1, 0, 0, '0.0b1')
1082
 
        assert Version(1, 0, 0, '0.0c1') > Version(1, 0, 0, '0.0b9')
1083
 
        assert Version(1, 0, 0, '1') > Version(1, 0, 0, '0.0c9')
1084
 
        # test Version playing nice with tuples
1085
 
        assert Version(1, 2, 3) == (1, 2, 3, '')
1086
 
        assert Version(1, 2, 4) > (1, 2, 3)
1087
 
 
1088
 
 
1089
957
coverage_modules = ['MoinMoin.wikiutil']
1090