← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

  • Committer: Olaf Conradi
  • Date: 2006-03-28 23:30:02 UTC
  • mto: (1661.1.1 bzr.mbp.remember)
  • mto: This revision was merged to the branch mainline in revision 1663.
  • Revision ID: olaf@conradi.org-20060328233002-f6262df0e19c1963
Added testcases for using pull with --remember. Moved remember code to
beginning of cmd_pull. This remembers the location in case of a failure
during pull.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
1
 
# (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
# Authors:  Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
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 cStringIO import StringIO
18
19
import os
 
20
 
 
21
import bzrlib
19
22
from bzrlib.branch import Branch
20
 
from bzrlib.selftest import TestCaseInTempDir
 
23
import bzrlib.bzrdir as bzrdir
 
24
from bzrlib.bzrdir import BzrDir
 
25
import bzrlib.errors as errors
 
26
from bzrlib.errors import NotBranchError, NotVersionedError
 
27
from bzrlib.lockdir import LockDir
 
28
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
29
from bzrlib.tests import TestCaseWithTransport
21
30
from bzrlib.trace import mutter
 
31
from bzrlib.transport import get_transport
 
32
import bzrlib.workingtree as workingtree
22
33
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
23
34
                                WorkingTree)
24
35
 
25
 
class TestTreeDirectory(TestCaseInTempDir):
 
36
class TestTreeDirectory(TestCaseWithTransport):
26
37
 
27
38
    def test_kind_character(self):
28
39
        self.assertEqual(TreeDirectory().kind_character(), '/')
29
40
 
30
41
 
31
 
class TestTreeEntry(TestCaseInTempDir):
 
42
class TestTreeEntry(TestCaseWithTransport):
32
43
 
33
44
    def test_kind_character(self):
34
45
        self.assertEqual(TreeEntry().kind_character(), '???')
35
46
 
36
47
 
37
 
class TestTreeFile(TestCaseInTempDir):
 
48
class TestTreeFile(TestCaseWithTransport):
38
49
 
39
50
    def test_kind_character(self):
40
51
        self.assertEqual(TreeFile().kind_character(), '')
41
52
 
42
53
 
43
 
class TestTreeLink(TestCaseInTempDir):
 
54
class TestTreeLink(TestCaseWithTransport):
44
55
 
45
56
    def test_kind_character(self):
46
57
        self.assertEqual(TreeLink().kind_character(), '')
47
58
 
48
59
 
49
 
class TestWorkingTree(TestCaseInTempDir):
50
 
 
51
 
    def test_listfiles(self):
52
 
        branch = Branch.initialize('.')
53
 
        os.mkdir('dir')
54
 
        print >> open('file', 'w'), "content"
55
 
        os.symlink('target', 'symlink')
56
 
        tree = branch.working_tree()
57
 
        files = list(tree.list_files())
58
 
        self.assertEqual(files[0], ('dir', '?', 'directory', None, TreeDirectory()))
59
 
        self.assertEqual(files[1], ('file', '?', 'file', None, TreeFile()))
60
 
        self.assertEqual(files[2], ('symlink', '?', 'symlink', None, TreeLink()))
61
 
 
62
 
    def test_construct_with_branch(self):
63
 
        branch = Branch.initialize('.')
64
 
        tree = WorkingTree(branch.base, branch)
65
 
        self.assertEqual(branch, tree.branch)
66
 
        self.assertEqual(branch.inventory, tree._inventory)
67
 
        self.assertEqual(branch.base, tree.basedir)
68
 
    
69
 
    def test_construct_without_branch(self):
70
 
        branch = Branch.initialize('.')
71
 
        tree = WorkingTree(branch.base)
72
 
        self.assertEqual(branch.base, tree.branch.base)
73
 
        self.assertEqual(branch.inventory, tree._inventory)
74
 
        self.assertEqual(branch.base, tree.basedir)
75
 
 
76
 
    def test_basic_relpath(self):
77
 
        # for comprehensive relpath tests, see whitebox.py.
78
 
        branch = Branch.initialize('.')
79
 
        tree = WorkingTree(branch.base)
80
 
        self.assertEqual('child',
81
 
                         tree.relpath(os.path.join(os.getcwd(), 'child')))
82
 
 
83
 
    def test_lock_locks_branch(self):
84
 
        branch = Branch.initialize('.')
85
 
        tree = WorkingTree(branch.base)
86
 
        tree.lock_read()
87
 
        self.assertEqual(1, tree.branch._lock_count)
88
 
        self.assertEqual('r', tree.branch._lock_mode)
89
 
        tree.unlock()
90
 
        self.assertEqual(None, tree.branch._lock_count)
 
60
class TestDefaultFormat(TestCaseWithTransport):
 
61
 
 
62
    def test_get_set_default_format(self):
 
63
        old_format = workingtree.WorkingTreeFormat.get_default_format()
 
64
        # default is 3
 
65
        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
 
66
        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
 
67
        try:
 
68
            # the default branch format is used by the meta dir format
 
69
            # which is not the default bzrdir format at this point
 
70
            dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
71
            dir.create_repository()
 
72
            dir.create_branch()
 
73
            result = dir.create_workingtree()
 
74
            self.assertEqual(result, 'A tree')
 
75
        finally:
 
76
            workingtree.WorkingTreeFormat.set_default_format(old_format)
 
77
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
 
78
 
 
79
 
 
80
class SampleTreeFormat(workingtree.WorkingTreeFormat):
 
81
    """A sample format
 
82
 
 
83
    this format is initializable, unsupported to aid in testing the 
 
84
    open and open_downlevel routines.
 
85
    """
 
86
 
 
87
    def get_format_string(self):
 
88
        """See WorkingTreeFormat.get_format_string()."""
 
89
        return "Sample tree format."
 
90
 
 
91
    def initialize(self, a_bzrdir, revision_id=None):
 
92
        """Sample branches cannot be created."""
 
93
        t = a_bzrdir.get_workingtree_transport(self)
 
94
        t.put('format', StringIO(self.get_format_string()))
 
95
        return 'A tree'
 
96
 
 
97
    def is_supported(self):
 
98
        return False
 
99
 
 
100
    def open(self, transport, _found=False):
 
101
        return "opened tree."
 
102
 
 
103
 
 
104
class TestWorkingTreeFormat(TestCaseWithTransport):
 
105
    """Tests for the WorkingTreeFormat facility."""
 
106
 
 
107
    def test_find_format(self):
 
108
        # is the right format object found for a working tree?
 
109
        # create a branch with a few known format objects.
 
110
        self.build_tree(["foo/", "bar/"])
 
111
        def check_format(format, url):
 
112
            dir = format._matchingbzrdir.initialize(url)
 
113
            dir.create_repository()
 
114
            dir.create_branch()
 
115
            format.initialize(dir)
 
116
            t = get_transport(url)
 
117
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
 
118
            self.failUnless(isinstance(found_format, format.__class__))
 
119
        check_format(workingtree.WorkingTreeFormat3(), "bar")
 
120
        
 
121
    def test_find_format_no_tree(self):
 
122
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
123
        self.assertRaises(errors.NoWorkingTree,
 
124
                          workingtree.WorkingTreeFormat.find_format,
 
125
                          dir)
 
126
 
 
127
    def test_find_format_unknown_format(self):
 
128
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
129
        dir.create_repository()
 
130
        dir.create_branch()
 
131
        SampleTreeFormat().initialize(dir)
 
132
        self.assertRaises(errors.UnknownFormatError,
 
133
                          workingtree.WorkingTreeFormat.find_format,
 
134
                          dir)
 
135
 
 
136
    def test_register_unregister_format(self):
 
137
        format = SampleTreeFormat()
 
138
        # make a control dir
 
139
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
140
        dir.create_repository()
 
141
        dir.create_branch()
 
142
        # make a branch
 
143
        format.initialize(dir)
 
144
        # register a format for it.
 
145
        workingtree.WorkingTreeFormat.register_format(format)
 
146
        # which branch.Open will refuse (not supported)
 
147
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
 
148
        # but open_downlevel will work
 
149
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
 
150
        # unregister the format
 
151
        workingtree.WorkingTreeFormat.unregister_format(format)
 
152
 
 
153
 
 
154
class TestWorkingTreeFormat3(TestCaseWithTransport):
 
155
    """Tests specific to WorkingTreeFormat3."""
 
156
 
 
157
    def test_disk_layout(self):
 
158
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
159
        control.create_repository()
 
160
        control.create_branch()
 
161
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
162
        # we want:
 
163
        # format 'Bazaar-NG Working Tree format 3'
 
164
        # inventory = blank inventory
 
165
        # pending-merges = ''
 
166
        # stat-cache = ??
 
167
        # no inventory.basis yet
 
168
        t = control.get_workingtree_transport(None)
 
169
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
 
170
                             t.get('format').read())
 
171
        self.assertEqualDiff('<inventory format="5">\n'
 
172
                             '</inventory>\n',
 
173
                             t.get('inventory').read())
 
174
        self.assertEqualDiff('### bzr hashcache v5\n',
 
175
                             t.get('stat-cache').read())
 
176
        self.assertFalse(t.has('inventory.basis'))
 
177
        # no last-revision file means 'None' or 'NULLREVISION'
 
178
        self.assertFalse(t.has('last-revision'))
 
179
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
 
180
        # correctly and last-revision file becomes present.
 
181
 
 
182
    def test_uses_lockdir(self):
 
183
        """WorkingTreeFormat3 uses its own LockDir:
 
184
            
 
185
            - lock is a directory
 
186
            - when the WorkingTree is locked, LockDir can see that
 
187
        """
 
188
        t = self.get_transport()
 
189
        url = self.get_url()
 
190
        dir = bzrdir.BzrDirMetaFormat1().initialize(url)
 
191
        repo = dir.create_repository()
 
192
        branch = dir.create_branch()
 
193
        tree = workingtree.WorkingTreeFormat3().initialize(dir)
 
194
        self.assertIsDirectory('.bzr', t)
 
195
        self.assertIsDirectory('.bzr/checkout', t)
 
196
        self.assertIsDirectory('.bzr/checkout/lock', t)
 
197
        our_lock = LockDir(t, '.bzr/checkout/lock')
 
198
        self.assertEquals(our_lock.peek(), None)
91
199
        tree.lock_write()
92
 
        self.assertEqual(1, tree.branch._lock_count)
93
 
        self.assertEqual('w', tree.branch._lock_mode)
 
200
        self.assertTrue(our_lock.peek())
94
201
        tree.unlock()
95
 
        self.assertEqual(None, tree.branch._lock_count)
96
 
 
97
 
    def get_pullable_branches(self):
98
 
        self.build_tree(['from/', 'from/file', 'to/'])
99
 
        br_a = Branch.initialize('from')
100
 
        br_a.add('file')
101
 
        br_a.commit('foo', rev_id='A')
102
 
        br_b = Branch.initialize('to')
103
 
        return br_a, br_b
104
 
 
105
 
    def test_pull(self):
106
 
        br_a, br_b = self.get_pullable_branches()
107
 
        br_b.working_tree().pull(br_a)
108
 
        self.failUnless(br_b.has_revision('A'))
109
 
        self.assertEqual(['A'], br_b.revision_history())
110
 
 
111
 
    def test_pull_clobbers(self):
112
 
        br_a, br_b = self.get_pullable_branches()
113
 
        br_b.commit('foo', rev_id='B')
114
 
        self.assertEqual(['B'], br_b.revision_history())
115
 
        br_b.working_tree().pull(br_a, clobber=True)
116
 
        self.failUnless(br_b.has_revision('A'))
117
 
        self.failUnless(br_b.has_revision('B'))
118
 
        self.assertEqual(['A'], br_b.revision_history())
 
202
        self.assertEquals(our_lock.peek(), None)