← Back to branch summary

~ubuntu-branches/ubuntu/saucy/migrate/saucy-proposed

« back to all changes in this revision

Viewing changes to test/versioning/test_version.py

  • Committer: Bazaar Package Importer
  • Author(s): Jan Dittberner
  • Date: 2010-07-12 00:24:57 UTC
  • mfrom: (1.1.5 upstream) (2.1.8 sid)
  • Revision ID: james.westby@ubuntu.com-20100712002457-4j2fdmco4u9kqzm5
Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/versioning/test_version.py
1
 
#!/usr/bin/env python
2
 
# -*- coding: utf-8 -*-
3
 
 
4
 
from test import fixture
5
 
from migrate.versioning.version import *
6
 
 
7
 
 
8
 
class TestVerNum(fixture.Base):
9
 
    def test_invalid(self):
10
 
        """Disallow invalid version numbers"""
11
 
        versions = ('-1', -1, 'Thirteen', '')
12
 
        for version in versions:
13
 
            self.assertRaises(ValueError, VerNum, version)
14
 
 
15
 
    def test_is(self):
16
 
        """Two version with the same number should be equal"""
17
 
        a = VerNum(1)
18
 
        b = VerNum(1)
19
 
        self.assert_(a is b)
20
 
 
21
 
        self.assertEqual(VerNum(VerNum(2)), VerNum(2))
22
 
 
23
 
    def test_add(self):
24
 
        self.assertEqual(VerNum(1) + VerNum(1), VerNum(2))
25
 
        self.assertEqual(VerNum(1) + 1, 2)
26
 
        self.assertEqual(VerNum(1) + 1, '2')
27
 
        self.assert_(isinstance(VerNum(1) + 1, VerNum))
28
 
 
29
 
    def test_sub(self):
30
 
        self.assertEqual(VerNum(1) - 1, 0)
31
 
        self.assert_(isinstance(VerNum(1) - 1, VerNum))
32
 
        self.assertRaises(ValueError, lambda: VerNum(0) - 1)
33
 
 
34
 
    def test_eq(self):
35
 
        """Two versions are equal"""
36
 
        self.assertEqual(VerNum(1), VerNum('1'))
37
 
        self.assertEqual(VerNum(1), 1)
38
 
        self.assertEqual(VerNum(1), '1')
39
 
        self.assertNotEqual(VerNum(1), 2)
40
 
 
41
 
    def test_ne(self):
42
 
        self.assert_(VerNum(1) != 2)
43
 
        self.assertFalse(VerNum(1) != 1)
44
 
 
45
 
    def test_lt(self):
46
 
        self.assertFalse(VerNum(1) < 1)
47
 
        self.assert_(VerNum(1) < 2)
48
 
        self.assertFalse(VerNum(2) < 1)
49
 
 
50
 
    def test_le(self):
51
 
        self.assert_(VerNum(1) <= 1)
52
 
        self.assert_(VerNum(1) <= 2)
53
 
        self.assertFalse(VerNum(2) <= 1)
54
 
 
55
 
    def test_gt(self):
56
 
        self.assertFalse(VerNum(1) > 1)
57
 
        self.assertFalse(VerNum(1) > 2)
58
 
        self.assert_(VerNum(2) > 1)
59
 
 
60
 
    def test_ge(self):
61
 
        self.assert_(VerNum(1) >= 1)
62
 
        self.assert_(VerNum(2) >= 1)
63
 
        self.assertFalse(VerNum(1) >= 2)
64
 
        
65
 
class TestVersion(fixture.Pathed):
66
 
 
67
 
    def setUp(self):
68
 
        super(TestVersion, self).setUp()
69
 
 
70
 
    def test_str_to_filename(self):
71
 
        self.assertEquals(str_to_filename(''), '')
72
 
        self.assertEquals(str_to_filename('__'), '_')
73
 
        self.assertEquals(str_to_filename('a'), 'a')
74
 
        self.assertEquals(str_to_filename('Abc Def'), 'Abc_Def')
75
 
        self.assertEquals(str_to_filename('Abc "D" Ef'), 'Abc_D_Ef')
76
 
        self.assertEquals(str_to_filename("Abc's Stuff"), 'Abc_s_Stuff')
77
 
        self.assertEquals(str_to_filename("a      b"), 'a_b')
78
 
 
79
 
    def test_collection(self):
80
 
        """Let's see how we handle versions collection"""
81
 
        coll = Collection(self.temp_usable_dir)
82
 
        coll.create_new_python_version("foo bar")
83
 
        coll.create_new_sql_version("postgres")
84
 
        coll.create_new_sql_version("sqlite")
85
 
        coll.create_new_python_version("")
86
 
 
87
 
        self.assertEqual(coll.latest, 4)
88
 
        self.assertEqual(len(coll.versions), 4)
89
 
        self.assertEqual(coll.version(4), coll.version(coll.latest))
90
 
 
91
 
        coll2 = Collection(self.temp_usable_dir)
92
 
        self.assertEqual(coll.versions, coll2.versions)
93
 
 
94
 
    #def test_collection_unicode(self):
95
 
    #    pass
96
 
 
97
 
    def test_create_new_python_version(self):
98
 
        coll = Collection(self.temp_usable_dir)
99
 
        coll.create_new_python_version("foo bar")
100
 
 
101
 
        ver = coll.version()
102
 
        self.assert_(ver.script().source())
103
 
 
104
 
    def test_create_new_sql_version(self):
105
 
        coll = Collection(self.temp_usable_dir)
106
 
        coll.create_new_sql_version("sqlite")
107
 
 
108
 
        ver = coll.version()
109
 
        ver_up = ver.script('sqlite', 'upgrade')
110
 
        ver_down = ver.script('sqlite', 'downgrade')
111
 
        ver_up.source()
112
 
        ver_down.source()
113
 
 
114
 
    def test_selection(self):
115
 
        """Verify right sql script is selected"""
116
 
        
117
 
        # Create empty directory.
118
 
        path = self.tmp_repos()
119
 
        os.mkdir(path)
120
 
        
121
 
        # Create files -- files must be present or you'll get an exception later.
122
 
        python_file = '001_initial_.py'
123
 
        sqlite_upgrade_file = '001_sqlite_upgrade.sql'
124
 
        default_upgrade_file = '001_default_upgrade.sql'
125
 
        for file_ in [sqlite_upgrade_file, default_upgrade_file, python_file]:
126
 
            filepath = '%s/%s' % (path, file_)
127
 
            open(filepath, 'w').close()
128
 
 
129
 
        ver = Version(1, path, [sqlite_upgrade_file])
130
 
        self.assertEquals(os.path.basename(ver.script('sqlite', 'upgrade').path), sqlite_upgrade_file)
131
 
    
132
 
        ver = Version(1, path, [default_upgrade_file])
133
 
        self.assertEquals(os.path.basename(ver.script('default', 'upgrade').path), default_upgrade_file)
134
 
    
135
 
        ver = Version(1, path, [sqlite_upgrade_file, default_upgrade_file])
136
 
        self.assertEquals(os.path.basename(ver.script('sqlite', 'upgrade').path), sqlite_upgrade_file)
137
 
    
138
 
        ver = Version(1, path, [sqlite_upgrade_file, default_upgrade_file, python_file])
139
 
        self.assertEquals(os.path.basename(ver.script('postgres', 'upgrade').path), default_upgrade_file)
140
 
 
141
 
        ver = Version(1, path, [sqlite_upgrade_file, python_file])
142
 
        self.assertEquals(os.path.basename(ver.script('postgres', 'upgrade').path), python_file)