← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/test_baz_import.py

  • Committer: Robert Collins
  • Date: 2005-09-08 14:46:57 UTC
  • mto: (147.2.6) (364.1.3 bzrtools)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: robertc@robertcollins.net-20050908144656-68176c43e7ea5531
start using testresources to coordinate import tests, saves 10 seconds

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_baz_import.py
15
15
#    along with this program; if not, write to the Free Software
16
16
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
from bzrlib.selftest.TestUtil import TestLoader, TestSuite
19
18
from bzrlib.selftest import TestCaseInTempDir
20
19
try:
21
20
    import pybaz
24
23
import os
25
24
from baz_import import import_version, revision_id
26
25
from bzrlib.branch import find_branch
 
26
import shutil
 
27
import tempfile
 
28
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
 
29
                           ResourcedTestCase)
27
30
 
28
31
def test_suite():
29
32
    if pybaz is None:
30
 
        return TestSuite()
 
33
        return OptimisingTestSuite()
31
34
    return TestLoader().loadTestsFromName(__name__)
32
 
    
33
 
 
34
 
class TestBazImport(TestCaseInTempDir):
35
 
 
36
 
    def setUp(self):
37
 
        TestCaseInTempDir.setUp(self)
38
 
        self._homedir = os.path.join(os.getcwdu(), 'home')
 
35
 
 
36
 
 
37
class BazTreeResource(TestResource):
 
38
 
 
39
    def cleanUp(self):
 
40
        os.environ['HOME'] = self._oldhome
 
41
        shutil.rmtree(self._tmpdir)
 
42
 
 
43
    def __init__(self):
 
44
        self._tmpdir = tempfile.mkdtemp()
 
45
        self._homedir = os.path.join(self._tmpdir, 'home')
39
46
        self._oldhome = os.environ['HOME']
40
47
        os.mkdir(self._homedir)
41
48
        os.environ['HOME'] = self._homedir
42
 
        self._archiveroot = os.path.join(os.getcwdu(), 'archive')
 
49
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
 
50
 
43
51
        self._archive = pybaz.make_archive('demo@DONOTUSE', str(self._archiveroot))
44
 
        os.mkdir('tree')
 
52
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
45
53
        pybaz.set_my_id("Test User<test@example.org>")
46
 
        tree = pybaz.init_tree('tree', 'demo@DONOTUSE/c--import--0')
 
54
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 'demo@DONOTUSE/c--import--0')
47
55
        msg = tree.log_message()
48
56
        msg["summary"] = "I am importing now"
49
57
        tree.import_(msg)
61
69
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
62
70
            pybaz.Version(self._empty_merged_tag))
63
71
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
64
 
            'tree-empty-merged')
 
72
            os.path.join(self._tmpdir, 'tree-empty-merged'))
65
73
        tree.star_merge(self._empty_tag,
66
74
                        pybaz.Version('demo@DONOTUSE/c--import--0'))
67
75
        msg = tree.log_message()
68
76
        msg["summary"]="did a merge, yarh"
69
77
        tree.commit(msg)
70
78
 
 
79
    @classmethod
 
80
    def _makeResource(self):
 
81
        return BazTreeResource()
 
82
 
 
83
    @classmethod
 
84
    def _cleanResource(self, resource):
 
85
        resource.cleanUp()
 
86
 
 
87
 
 
88
class TestBazImport(TestCaseInTempDir):
 
89
 
 
90
    _resources = [("_baz", BazTreeResource)]
 
91
 
 
92
    def setUp(self):
 
93
        TestCaseInTempDir.setUp(self)
 
94
        ResourcedTestCase.setUpResources(self)
 
95
 
71
96
    def tearDown(self):
72
 
        os.environ['HOME'] = self._oldhome
 
97
        ResourcedTestCase.tearDownResources(self)
 
98
        TestCaseInTempDir.tearDown(self)
73
99
        
74
100
    def test_import_empty(self):
75
101
        import_version('output', pybaz.Version('demo@DONOTUSE/c--import--0'))
94
120
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
95
121
 
96
122
    def test_empty_tagged(self):
97
 
        import_version('output', pybaz.Version(self._empty_tag))
 
123
        import_version('output', pybaz.Version(self._baz._empty_tag))
98
124
        # expected results:
99
125
        # two commits, no files, revision identifiers of 
100
126
        # 'demo@DONOTUSE_c--import--0--base-0' and
101
 
        # self._empty_tag_bzr
 
127
        # self._baz._empty_tag_bzr
102
128
        branch = find_branch('output', find_root=False)
103
129
        self.assertEqual(branch.revision_history(),
104
130
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
105
 
                          self._empty_tag_bzr])
106
 
        rev = branch.get_revision(self._empty_tag_bzr)
 
131
                          self._baz._empty_tag_bzr])
 
132
        rev = branch.get_revision(self._baz._empty_tag_bzr)
107
133
        # and again.
108
 
        import_version('output2', pybaz.Version(self._empty_tag))
 
134
        import_version('output2', pybaz.Version(self._baz._empty_tag))
109
135
        branch2 = find_branch('output2', find_root=False)
110
136
        self.assertEqual(branch.revision_history(), branch2.revision_history())
111
 
        rev2 = branch2.get_revision(self._empty_tag_bzr)
 
137
        rev2 = branch2.get_revision(self._baz._empty_tag_bzr)
112
138
        # they must be the same
113
139
        self.assertEqual(rev, rev2)
114
140
 
115
141
        # and we should get some expected values:
116
142
        self.assertEqual(rev.committer, "Test User<test@example.org>")
117
143
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
118
 
        self.assertEqual(rev.revision_id, self._empty_tag_bzr)
 
144
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
119
145
 
120
146
    def test_empty_merged_tagged(self):
121
 
        import_version('output', pybaz.Version(self._empty_merged_tag))
 
147
        import_version('output', pybaz.Version(self._baz._empty_merged_tag))
122
148
        # expected results:
123
149
        # two commits, no files, revision identifiers of 
124
150
        # 'demo@DONOTUSE_c--import--0--base-0' and
125
 
        # self._empty_merged_tag_bzr_base
126
 
        # self._empty_merged_tag_bzr
 
151
        # self._baz._empty_merged_tag_bzr_base
 
152
        # self._baz._empty_merged_tag_bzr
127
153
        # and a merged revision from the latter of
128
 
        # self._empty_tag_bzr
 
154
        # self._baz._empty_tag_bzr
129
155
        branch = find_branch('output', find_root=False)
130
156
        self.assertEqual(branch.revision_history(),
131
157
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
132
 
                          self._empty_merged_tag_bzr_base,
133
 
                          self._empty_merged_tag_bzr])
 
158
                          self._baz._empty_merged_tag_bzr_base,
 
159
                          self._baz._empty_merged_tag_bzr])
134
160
        # and again.
135
 
        import_version('output2', pybaz.Version(self._empty_merged_tag))
 
161
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag))
136
162
        branch2 = find_branch('output2', find_root=False)
137
163
        # and import what we should be merged up against for checking with.
138
 
        import_version('output3', pybaz.Version(self._empty_tag))
 
164
        import_version('output3', pybaz.Version(self._baz._empty_tag))
139
165
        branch3 = find_branch('output3', find_root=False)
140
166
        
141
167
        self.assertEqual(branch.revision_history(), branch2.revision_history())
142
168
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
143
169
        # check revisions in the history.
144
 
        rev = branch.get_revision(self._empty_merged_tag_bzr_base)
145
 
        rev2 = branch2.get_revision(self._empty_merged_tag_bzr_base)
 
170
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr_base)
 
171
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr_base)
146
172
        # they must be the same
147
173
        self.assertEqual(rev, rev2)
148
174
        # and we should get some expected values:
149
175
        self.assertEqual(rev.committer, "Test User<test@example.org>")
150
176
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
151
 
        self.assertEqual(rev.revision_id, self._empty_merged_tag_bzr_base)
 
177
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)
152
178
 
153
179
        # check next revisions in the history.
154
 
        rev = branch.get_revision(self._empty_merged_tag_bzr)
155
 
        rev2 = branch2.get_revision(self._empty_merged_tag_bzr)
 
180
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr)
 
181
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr)
156
182
        # they must be the same
157
183
        self.assertEqual(rev, rev2)
158
184
        # and we should get some expected values:
159
185
        self.assertEqual(rev.committer, "Test User<test@example.org>")
160
186
        self.assertEqual(rev.message, "did a merge, yarh")
161
 
        self.assertEqual(rev.revision_id, self._empty_merged_tag_bzr)
 
187
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr)
162
188
        self.assertEqual(rev.parents[0].revision_id,
163
 
                         self._empty_merged_tag_bzr_base)
 
189
                         self._baz._empty_merged_tag_bzr_base)
164
190
        self.assertEqual(rev.parents[1].revision_id,
165
 
                         self._empty_tag_bzr)
 
191
                         self._baz._empty_tag_bzr)
166
192
 
167
193
        # this tree should have nothing missing from that tree.   
168
194
        # FIXME there is no code for this right now.