← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_inventory/basics.py

  • Committer: John Arbash Meinel
  • Date: 2009-09-24 18:51:41 UTC
  • mto: (4634.52.3 2.0)
  • mto: This revision was merged to the branch mainline in revision 4716.
  • Revision ID: john@arbash-meinel.com-20090924185141-3gofyxyrmw276rjm
Finish adding CHKInventory as a permutation in per_inventory.

Get the Read tests working. Change the apply_delta tests to be create_by_apply_delta
and implement that functionality on the regular Inventory class.
(just does a .copy() and then apply delta on the result.)

This also required fixing a lot of the tests that never asserted the objects
were valid.
Namely: InventoryFile('file-id', 'name', 'parent-id')
does not generate a fully valid file object, as it has no text_size or text_sha1.


The filter() tests are finally failing, which means I have a chance to
actually fix things via tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_inventory/basics.py
21
21
 
22
22
from bzrlib import (
23
23
        errors,
 
24
        inventory,
 
25
        osutils,
24
26
        )
25
27
 
26
28
from bzrlib.inventory import (
28
30
        InventoryEntry,
29
31
        InventoryFile,
30
32
        InventoryLink,
31
 
        ROOT_ID,
32
33
        TreeReference,
33
34
        )
34
35
 
35
 
from bzrlib.tests import (
36
 
        TestCase,
37
 
        )
38
 
 
39
 
 
40
 
class TestInventory(TestCase):
41
 
 
42
 
    def make_inventory(self, root_id):
43
 
        return self.inventory_class(root_id=root_id)
 
36
from bzrlib.tests.per_inventory import TestCaseWithInventory
 
37
 
 
38
 
 
39
 
 
40
class TestInventory(TestCaseWithInventory):
 
41
 
 
42
    def make_init_inventory(self):
 
43
        inv = inventory.Inventory('tree-root')
 
44
        inv.revision = 'initial-rev'
 
45
        inv.root.revision = 'initial-rev'
 
46
        return self.inv_to_test_inv(inv)
 
47
 
 
48
    def make_file(self, file_id, name, parent_id, content='content\n',
 
49
                  revision='new-test-rev'):
 
50
        ie = InventoryFile(file_id, name, parent_id)
 
51
        ie.text_sha1 = osutils.sha_string(content)
 
52
        ie.text_size = len(content)
 
53
        ie.revision = revision
 
54
        return ie
 
55
 
 
56
    def make_link(self, file_id, name, parent_id, target='link-target\n'):
 
57
        ie = InventoryLink(file_id, name, parent_id)
 
58
        ie.symlink_target = target
 
59
        return ie
44
60
 
45
61
    def prepare_inv_with_nested_dirs(self):
46
 
        inv = self.make_inventory('tree-root')
 
62
        inv = inventory.Inventory('tree-root')
47
63
        for args in [('src', 'directory', 'src-id'),
48
64
                     ('doc', 'directory', 'doc-id'),
49
65
                     ('src/hello.c', 'file', 'hello-id'),
53
69
                     ('src/zz.c', 'file', 'zzc-id'),
54
70
                     ('src/sub/a', 'file', 'a-id'),
55
71
                     ('Makefile', 'file', 'makefile-id')]:
56
 
            inv.add_path(*args)
57
 
        return inv
58
 
 
59
 
 
60
 
class TestInventoryUpdates(TestInventory):
61
 
 
62
 
    def test_creation_from_root_id(self):
63
 
        # iff a root id is passed to the constructor, a root directory is made
64
 
        inv = self.make_inventory(root_id='tree-root')
65
 
        self.assertNotEqual(None, inv.root)
66
 
        self.assertEqual('tree-root', inv.root.file_id)
67
 
 
68
 
    def test_add_path_of_root(self):
69
 
        # if no root id is given at creation time, there is no root directory
70
 
        inv = self.make_inventory(root_id=None)
71
 
        self.assertIs(None, inv.root)
72
 
        # add a root entry by adding its path
73
 
        ie = inv.add_path("", "directory", "my-root")
74
 
        self.assertEqual("my-root", ie.file_id)
75
 
        self.assertIs(ie, inv.root)
76
 
 
77
 
    def test_add_path(self):
78
 
        inv = self.make_inventory(root_id='tree_root')
79
 
        ie = inv.add_path('hello', 'file', 'hello-id')
80
 
        self.assertEqual('hello-id', ie.file_id)
81
 
        self.assertEqual('file', ie.kind)
82
 
 
83
 
    def test_copy(self):
84
 
        """Make sure copy() works and creates a deep copy."""
85
 
        inv = self.make_inventory(root_id='some-tree-root')
86
 
        ie = inv.add_path('hello', 'file', 'hello-id')
87
 
        inv2 = inv.copy()
88
 
        inv.root.file_id = 'some-new-root'
89
 
        ie.name = 'file2'
90
 
        self.assertEqual('some-tree-root', inv2.root.file_id)
91
 
        self.assertEqual('hello', inv2['hello-id'].name)
92
 
 
93
 
    def test_copy_empty(self):
94
 
        """Make sure an empty inventory can be copied."""
95
 
        inv = self.make_inventory(root_id=None)
96
 
        inv2 = inv.copy()
97
 
        self.assertIs(None, inv2.root)
98
 
 
99
 
    def test_copy_copies_root_revision(self):
100
 
        """Make sure the revision of the root gets copied."""
101
 
        inv = self.make_inventory(root_id='someroot')
102
 
        inv.root.revision = 'therev'
103
 
        inv2 = inv.copy()
104
 
        self.assertEquals('someroot', inv2.root.file_id)
105
 
        self.assertEquals('therev', inv2.root.revision)
106
 
 
107
 
    def test_create_tree_reference(self):
108
 
        inv = self.make_inventory('tree-root-123')
109
 
        inv.add(TreeReference('nested-id', 'nested', parent_id='tree-root-123',
110
 
                              revision='rev', reference_revision='rev2'))
111
 
 
112
 
    def test_error_encoding(self):
113
 
        inv = self.make_inventory('tree-root')
114
 
        inv.add(InventoryFile('a-id', u'\u1234', 'tree-root'))
115
 
        e = self.assertRaises(errors.InconsistentDelta, inv.add,
116
 
            InventoryFile('b-id', u'\u1234', 'tree-root'))
117
 
        self.assertContainsRe(str(e), r'\\u1234')
118
 
 
119
 
    def test_add_recursive(self):
120
 
        parent = InventoryDirectory('src-id', 'src', 'tree-root')
121
 
        child = InventoryFile('hello-id', 'hello.c', 'src-id')
122
 
        parent.children[child.file_id] = child
123
 
        inv = self.make_inventory('tree-root')
124
 
        inv.add(parent)
125
 
        self.assertEqual('src/hello.c', inv.id2path('hello-id'))
126
 
 
127
 
 
128
 
class TestInventoryApplyDelta(TestInventory):
 
72
            ie = inv.add_path(*args)
 
73
            if args[1] == 'file':
 
74
                ie.text_sha1 = osutils.sha_string('content\n')
 
75
                ie.text_size = len('content\n')
 
76
        return self.inv_to_test_inv(inv)
 
77
 
 
78
 
 
79
class TestInventoryCreateByApplyDelta(TestInventory):
129
80
    """A subset of the inventory delta application tests.
130
81
 
131
82
    See test_inv which has comprehensive delta application tests for
132
 
    inventories, dirstate, and repository based inventories, unlike the tests
133
 
    here which only test in-memory implementations that can support a plain
134
 
    'apply_delta'.
 
83
    inventories, dirstate, and repository based inventories.
135
84
    """
136
 
 
137
 
    def test_apply_delta_add(self):
138
 
        inv = self.make_inventory('tree-root')
139
 
        inv.apply_delta([
140
 
            (None, "a", "a-id", InventoryFile('a-id', 'a', 'tree-root')),
141
 
            ])
142
 
        self.assertEqual('a', inv.id2path('a-id'))
143
 
 
144
 
    def test_apply_delta_delete(self):
145
 
        inv = self.make_inventory('tree-root')
146
 
        inv.apply_delta([
147
 
            (None, "a", "a-id", InventoryFile('a-id', 'a', 'tree-root')),
148
 
            ])
149
 
        self.assertEqual('a', inv.id2path('a-id'))
150
 
        a_ie = inv['a-id']
151
 
        inv.apply_delta([("a", None, "a-id", None)])
 
85
    def test_add(self):
 
86
        inv = self.make_init_inventory()
 
87
        inv = inv.create_by_apply_delta([
 
88
            (None, "a", "a-id", self.make_file('a-id', 'a', 'tree-root')),
 
89
            ], 'new-test-rev')
 
90
        self.assertEqual('a', inv.id2path('a-id'))
 
91
 
 
92
    def test_delete(self):
 
93
        inv = self.make_init_inventory()
 
94
        inv = inv.create_by_apply_delta([
 
95
            (None, "a", "a-id", self.make_file('a-id', 'a', 'tree-root')),
 
96
            ], 'new-rev-1')
 
97
        self.assertEqual('a', inv.id2path('a-id'))
 
98
        inv = inv.create_by_apply_delta([
 
99
            ("a", None, "a-id", None),
 
100
            ], 'new-rev-2')
152
101
        self.assertRaises(errors.NoSuchId, inv.id2path, 'a-id')
153
102
 
154
 
    def test_apply_delta_rename(self):
155
 
        inv = self.make_inventory('tree-root')
156
 
        inv.apply_delta([
157
 
            (None, "a", "a-id", InventoryFile('a-id', 'a', 'tree-root')),
158
 
            ])
 
103
    def test_rename(self):
 
104
        inv = self.make_init_inventory()
 
105
        inv = inv.create_by_apply_delta([
 
106
            (None, "a", "a-id", self.make_file('a-id', 'a', 'tree-root')),
 
107
            ], 'new-rev-1')
159
108
        self.assertEqual('a', inv.id2path('a-id'))
160
109
        a_ie = inv['a-id']
161
 
        b_ie = InventoryFile(a_ie.file_id, "b", a_ie.parent_id)
162
 
        inv.apply_delta([("a", "b", "a-id", b_ie)])
 
110
        b_ie = self.make_file(a_ie.file_id, "b", a_ie.parent_id)
 
111
        inv = inv.create_by_apply_delta([("a", "b", "a-id", b_ie)], 'new-rev-2')
163
112
        self.assertEqual("b", inv.id2path('a-id'))
164
113
 
165
 
    def test_apply_delta_illegal(self):
 
114
    def test_illegal(self):
166
115
        # A file-id cannot appear in a delta more than once
167
 
        inv = self.make_inventory('tree-root')
168
 
        self.assertRaises(errors.InconsistentDelta, inv.apply_delta, [
169
 
            ("a", "a", "id-1", InventoryFile('id-1', 'a', 'tree-root')),
170
 
            ("a", "b", "id-1", InventoryFile('id-1', 'b', 'tree-root')),
171
 
            ])
 
116
        inv = self.make_init_inventory()
 
117
        self.assertRaises(errors.InconsistentDelta, inv.create_by_apply_delta, [
 
118
            (None, "a", "id-1", self.make_file('id-1', 'a', 'tree-root')),
 
119
            (None, "b", "id-1", self.make_file('id-1', 'b', 'tree-root')),
 
120
            ], 'new-rev-1')
172
121
 
173
122
 
174
123
class TestInventoryReads(TestInventory):
175
124
 
176
125
    def test_is_root(self):
177
126
        """Ensure our root-checking code is accurate."""
178
 
        inv = self.make_inventory('TREE_ROOT')
179
 
        self.assertTrue(inv.is_root('TREE_ROOT'))
 
127
        inv = self.make_init_inventory()
 
128
        self.assertTrue(inv.is_root('tree-root'))
180
129
        self.assertFalse(inv.is_root('booga'))
181
 
        inv.root.file_id = 'booga'
 
130
        ie = inv['tree-root'].copy()
 
131
        ie.file_id = 'booga'
 
132
        inv = inv.create_by_apply_delta([("", None, "tree-root", None),
 
133
                                         (None, "", "booga", ie)], 'new-rev-2')
182
134
        self.assertFalse(inv.is_root('TREE_ROOT'))
183
135
        self.assertTrue(inv.is_root('booga'))
184
 
        # works properly even if no root is set
185
 
        inv.root = None
186
 
        self.assertFalse(inv.is_root('TREE_ROOT'))
187
 
        self.assertFalse(inv.is_root('booga'))
188
136
 
189
137
    def test_ids(self):
190
138
        """Test detection of files within selected directories."""
191
 
        inv = self.make_inventory(ROOT_ID)
 
139
        inv = inventory.Inventory('TREE_ROOT')
192
140
        for args in [('src', 'directory', 'src-id'),
193
141
                     ('doc', 'directory', 'doc-id'),
194
142
                     ('src/hello.c', 'file'),
195
143
                     ('src/bye.c', 'file', 'bye-id'),
196
144
                     ('Makefile', 'file')]:
197
 
            inv.add_path(*args)
 
145
            ie = inv.add_path(*args)
 
146
            if args[1] == 'file':
 
147
                ie.text_sha1 = osutils.sha_string('content\n')
 
148
                ie.text_size = len('content\n')
 
149
        inv = self.inv_to_test_inv(inv)
198
150
        self.assertEqual(inv.path2id('src'), 'src-id')
199
151
        self.assertEqual(inv.path2id('src/bye.c'), 'bye-id')
200
 
        self.assert_('src-id' in inv)
 
152
        self.assertTrue('src-id' in inv)
201
153
 
202
154
    def test_non_directory_children(self):
203
155
        """Test path2id when a parent directory has no children"""
204
 
        inv = self.make_inventory('tree_root')
205
 
        inv.add(InventoryFile('file-id','file',
206
 
                                        parent_id='tree_root'))
207
 
        inv.add(InventoryLink('link-id','link',
208
 
                                        parent_id='tree_root'))
 
156
        inv = inventory.Inventory('tree-root')
 
157
        inv.add(self.make_file('file-id','file', 'tree-root'))
 
158
        inv.add(self.make_link('link-id','link', 'tree-root'))
209
159
        self.assertIs(None, inv.path2id('file/subfile'))
210
160
        self.assertIs(None, inv.path2id('link/subfile'))
211
161
 
212
162
    def test_iter_entries(self):
213
 
        inv = self.make_inventory('tree-root')
214
 
        for args in [('src', 'directory', 'src-id'),
215
 
                     ('doc', 'directory', 'doc-id'),
216
 
                     ('src/hello.c', 'file', 'hello-id'),
217
 
                     ('src/bye.c', 'file', 'bye-id'),
218
 
                     ('src/sub', 'directory', 'sub-id'),
219
 
                     ('src/sub/a', 'file', 'a-id'),
220
 
                     ('Makefile', 'file', 'makefile-id')]:
221
 
            inv.add_path(*args)
 
163
        inv = self.prepare_inv_with_nested_dirs()
222
164
 
223
165
        # Test all entries
224
166
        self.assertEqual([
230
172
            ('src/hello.c', 'hello-id'),
231
173
            ('src/sub', 'sub-id'),
232
174
            ('src/sub/a', 'a-id'),
 
175
            ('src/zz.c', 'zzc-id'),
 
176
            ('zz', 'zz-id'),
233
177
            ], [(path, ie.file_id) for path, ie in inv.iter_entries()])
234
178
 
235
179
        # Test a subdirectory
238
182
            ('hello.c', 'hello-id'),
239
183
            ('sub', 'sub-id'),
240
184
            ('sub/a', 'a-id'),
 
185
            ('zz.c', 'zzc-id'),
241
186
            ], [(path, ie.file_id) for path, ie in inv.iter_entries(
242
187
            from_dir='src-id')])
243
188
 
247
192
            ('Makefile', 'makefile-id'),
248
193
            ('doc', 'doc-id'),
249
194
            ('src', 'src-id'),
 
195
            ('zz', 'zz-id'),
250
196
            ], [(path, ie.file_id) for path, ie in inv.iter_entries(
251
197
            recursive=False)])
252
198
 
255
201
            ('bye.c', 'bye-id'),
256
202
            ('hello.c', 'hello-id'),
257
203
            ('sub', 'sub-id'),
 
204
            ('zz.c', 'zzc-id'),
258
205
            ], [(path, ie.file_id) for path, ie in inv.iter_entries(
259
206
            from_dir='src-id', recursive=False)])
260
207
 
261
208
    def test_iter_just_entries(self):
262
 
        inv = self.make_inventory('tree-root')
263
 
        for args in [('src', 'directory', 'src-id'),
264
 
                     ('doc', 'directory', 'doc-id'),
265
 
                     ('src/hello.c', 'file', 'hello-id'),
266
 
                     ('src/bye.c', 'file', 'bye-id'),
267
 
                     ('Makefile', 'file', 'makefile-id')]:
268
 
            inv.add_path(*args)
 
209
        inv = self.prepare_inv_with_nested_dirs()
269
210
        self.assertEqual([
 
211
            'a-id',
270
212
            'bye-id',
271
213
            'doc-id',
272
214
            'hello-id',
273
215
            'makefile-id',
274
216
            'src-id',
 
217
            'sub-id',
275
218
            'tree-root',
 
219
            'zz-id',
 
220
            'zzc-id',
276
221
            ], sorted([ie.file_id for ie in inv.iter_just_entries()]))
277
222
 
278
223
    def test_iter_entries_by_dir(self):