/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/tests/test_object_store.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-17 00:47:52 UTC
  • mfrom: (7182 work)
  • mto: This revision was merged to the branch mainline in revision 7305.
  • Revision ID: jelmer@jelmer.uk-20181117004752-6ywampe5pfywlby4
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/tests/test_object_store.py
67
67
 
68
68
    def test_hex(self):
69
69
        _check_expected_sha(
70
 
                self.obj.sha().hexdigest().encode('ascii'), self.obj)
 
70
            self.obj.sha().hexdigest().encode('ascii'), self.obj)
71
71
        self.assertRaises(AssertionError, _check_expected_sha,
72
 
            b"0" * 40, self.obj)
 
72
                          b"0" * 40, self.obj)
73
73
 
74
74
    def test_binary(self):
75
75
        _check_expected_sha(self.obj.sha().digest(), self.obj)
76
76
        self.assertRaises(AssertionError, _check_expected_sha,
77
 
            b"x" * 20, self.obj)
 
77
                          b"x" * 20, self.obj)
78
78
 
79
79
 
80
80
class FindMissingBzrRevidsTests(TestCase):
89
89
 
90
90
    def test_up_to_date(self):
91
91
        self.assertEqual(set(),
92
 
                self._find_missing({"a": ["b"]}, ["a"], ["a"]))
 
92
                         self._find_missing({"a": ["b"]}, ["a"], ["a"]))
93
93
 
94
94
    def test_one_missing(self):
95
95
        self.assertEqual(set(["a"]),
96
 
                self._find_missing({"a": ["b"]}, ["a"], ["b"]))
 
96
                         self._find_missing({"a": ["b"]}, ["a"], ["b"]))
97
97
 
98
98
    def test_two_missing(self):
99
99
        self.assertEqual(set(["a", "b"]),
100
 
                self._find_missing({"a": ["b"], "b": ["c"]}, ["a"], ["c"]))
 
100
                         self._find_missing({"a": ["b"], "b": ["c"]}, ["a"], ["c"]))
101
101
 
102
102
    def test_two_missing_history(self):
103
103
        self.assertEqual(set(["a", "b"]),
104
 
                self._find_missing({"a": ["b"], "b": ["c"], "c": ["d"]},
105
 
                    ["a"], ["c"]))
 
104
                         self._find_missing({"a": ["b"], "b": ["c"], "c": ["d"]},
 
105
                                            ["a"], ["c"]))
106
106
 
107
107
 
108
108
class LRUTreeCacheTests(TestCaseWithTransport):
116
116
 
117
117
    def test_get_not_present(self):
118
118
        self.assertRaises(NoSuchRevision, self.cache.revision_tree,
119
 
                "unknown")
 
119
                          "unknown")
120
120
 
121
121
    def test_revision_trees(self):
122
122
        self.assertRaises(NoSuchRevision, self.cache.revision_trees,
123
 
                ["unknown", "la"])
 
123
                          ["unknown", "la"])
124
124
 
125
125
    def test_iter_revision_trees(self):
126
126
        self.assertRaises(NoSuchRevision, self.cache.iter_revision_trees,
127
 
                ["unknown", "la"])
 
127
                          ["unknown", "la"])
128
128
 
129
129
    def test_get(self):
130
130
        bb = BranchBuilder(branch=self.branch)
131
131
        bb.start_series()
132
132
        revid = bb.build_snapshot(None,
133
 
            [('add', ('', None, 'directory', None)),
134
 
             ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),
135
 
             ])
 
133
                                  [('add', ('', None, 'directory', None)),
 
134
                                   ('add', ('foo', b'foo-id',
 
135
                                            'file', b'a\nb\nc\nd\ne\n')),
 
136
                                   ])
136
137
        bb.finish_series()
137
138
        tree = self.cache.revision_tree(revid)
138
139
        self.assertEqual(revid, tree.get_revision_id())
156
157
        bb = BranchBuilder(branch=self.branch)
157
158
        bb.start_series()
158
159
        bb.build_snapshot(None,
159
 
            [('add', ('', None, 'directory', None)),
160
 
             ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),
161
 
             ])
 
160
                          [('add', ('', None, 'directory', None)),
 
161
                           ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),
 
162
                           ])
162
163
        bb.finish_series()
163
164
        # read locks cache
164
165
        self.assertRaises(KeyError, self.store.__getitem__, b.id)
175
176
        bb = BranchBuilder(branch=self.branch)
176
177
        bb.start_series()
177
178
        bb.build_snapshot(None,
178
 
            [('add', ('', None, 'directory', None)),
179
 
             ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),
180
 
             ])
 
179
                          [('add', ('', None, 'directory', None)),
 
180
                           ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),
 
181
                           ])
181
182
        bb.finish_series()
182
183
        # read locks cache
183
184
        self.assertRaises(KeyError, self.store.get_raw, b.id)
194
195
        bb = BranchBuilder(branch=self.branch)
195
196
        bb.start_series()
196
197
        bb.build_snapshot(None,
197
 
            [('add', ('', None, 'directory', None)),
198
 
             ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),
199
 
             ])
 
198
                          [('add', ('', None, 'directory', None)),
 
199
                           ('add', ('foo', b'foo-id', 'file', b'a\nb\nc\nd\ne\n')),
 
200
                           ])
200
201
        bb.finish_series()
201
202
        # read locks cache
202
203
        self.assertFalse(b.id in self.store)
237
238
    def test_empty_dir(self):
238
239
        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')
239
240
        t = directory_to_tree('', [child_ie], lambda p, x: None, {}, None,
240
 
                allow_empty=False)
 
241
                              allow_empty=False)
241
242
        self.assertEqual(None, t)
242
243
 
243
244
    def test_empty_dir_dummy_files(self):
244
245
        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')
245
246
        t = directory_to_tree('', [child_ie], lambda p, x: None, {}, ".mydummy",
246
 
                allow_empty=False)
 
247
                              allow_empty=False)
247
248
        self.assertTrue(".mydummy" in t)
248
249
 
249
250
    def test_empty_root(self):
250
251
        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')
251
252
        t = directory_to_tree('', [child_ie], lambda p, x: None, {}, None,
252
 
                allow_empty=True)
 
253
                              allow_empty=True)
253
254
        self.assertEqual(Tree(), t)
254
255
 
255
256
    def test_with_file(self):
256
257
        child_ie = InventoryFile(b'bar', 'bar', b'bar')
257
258
        b = Blob.from_string(b"bla")
258
259
        t1 = directory_to_tree('', [child_ie], lambda p, x: b.id, {}, None,
259
 
                allow_empty=False)
 
260
                               allow_empty=False)
260
261
        t2 = Tree()
261
262
        t2.add(b"bar", 0o100644, b.id)
262
263
        self.assertEqual(t1, t2)
266
267
        git_file_ie = InventoryFile(b'gitid', '.git', b'bar')
267
268
        b = Blob.from_string(b"bla")
268
269
        t1 = directory_to_tree('', [child_ie, git_file_ie],
269
 
                lambda p, x: b.id, {}, None,
270
 
                allow_empty=False)
 
270
                               lambda p, x: b.id, {}, None,
 
271
                               allow_empty=False)
271
272
        t2 = Tree()
272
273
        t2.add(b"bar", 0o100644, b.id)
273
274
        self.assertEqual(t1, t2)