[MERGE] Convert non-ascii blackbox tests to use internals where appropriate

Daniel Watkins D.M.Watkins at warwick.ac.uk
Sun Sep 16 18:34:51 BST 2007


Attached is a bundle doing what is detailed in the subject line.
tests.blackbox.test_non-ascii.test_missing fails (for each encoding)
with incorrect return codes, but this is the case in bzr.dev so I didn't
want to change this incorrectly.

-- 
Daniel Watkins (Odd_Bloke) <D.M.Watkins at warwick.ac.uk>
University of Warwick Christian Focus President
University of Warwick Computing Society WUGLUG Liaison Officer
-------------- next part --------------
# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: d.m.watkins at warwick.ac.uk-20070916173050-\
#   fky4k5whizn0xy1l
# target_branch: file:///home/daniel/devel/bzr/bzr.dev/
# testament_sha1: a6a5acd14c2407974be0ab22b2ee65419a23857b
# timestamp: 2007-09-16 18:32:09 +0100
# base_revision_id: pqm at pqm.ubuntu.com-20070914082550-j9aknobh4x00qksk
# 
# Begin patch
=== modified file 'bzrlib/tests/blackbox/test_non_ascii.py'
--- bzrlib/tests/blackbox/test_non_ascii.py	2007-06-26 20:32:49 +0000
+++ bzrlib/tests/blackbox/test_non_ascii.py	2007-09-16 17:30:50 +0000
@@ -49,8 +49,6 @@
         super(TestNonAscii, self).tearDown()
 
     def create_base(self):
-        bzr = self.run_bzr
-
         fs_enc = sys.getfilesystemencoding()
         terminal_enc = osutils.get_terminal_encoding()
         fname = self.info['filename']
@@ -72,27 +70,27 @@
                                    % (thing, terminal_enc, fs_enc))
 
         wt = self.make_branch_and_tree('.')
-        open('a', 'wb').write('foo\n')
+        self.build_tree_contents([('a', 'foo\n')])
         wt.add('a')
         wt.commit('adding a')
 
-        open('b', 'wb').write('non-ascii \xFF\xFF\xFC\xFB\x00 in b\n')
+        self.build_tree_contents(
+            [('b', 'non-ascii \xFF\xFF\xFC\xFB\x00 in b\n')])
         wt.add('b')
         wt.commit(self.info['message'])
 
-        open(fname, 'wb').write('unicode filename\n')
+        self.build_tree_contents([(fname, 'unicode filename\n')])
         wt.add(fname)
         wt.commit(u'And a unicode file\n')
         self.wt = wt
 
     def test_status(self):
-        bzr = self.run_bzr_decode
-
-        open(self.info['filename'], 'ab').write('added something\n')
-        txt = bzr('status')
+        self.build_tree_contents(
+            [(self.info['filename'], 'changed something\n')])
+        txt = self.run_bzr_decode('status')
         self.assertEqual(u'modified:\n  %s\n' % (self.info['filename'],), txt)
 
-        txt = bzr('status', encoding='ascii')
+        txt = self.run_bzr_decode('status', encoding='ascii')
         expected = u'modified:\n  %s\n' % (
                     self.info['filename'].encode('ascii', 'replace'),)
         self.assertEqual(expected, txt)
@@ -107,79 +105,67 @@
         self.assertEqual('unicode filename\n', txt)
 
     def test_cat_revision(self):
-        bzr = self.run_bzr_decode
-
         committer = self.info['committer']
-        txt = bzr('cat-revision -r 1')
+        txt = self.run_bzr_decode('cat-revision -r 1')
         self.failUnless(committer in txt,
                         'failed to find %r in %r' % (committer, txt))
 
         msg = self.info['message']
-        txt = bzr('cat-revision -r 2')
+        txt = self.run_bzr_decode('cat-revision -r 2')
         self.failUnless(msg in txt, 'failed to find %r in %r' % (msg, txt))
 
     def test_mkdir(self):
-        bzr = self.run_bzr_decode
-
-        txt = bzr(['mkdir', self.info['directory']])
+        txt = self.run_bzr_decode(['mkdir', self.info['directory']])
         self.assertEqual(u'added %s\n' % self.info['directory'], txt)
 
         # The text should be garbled, but the command should succeed
-        txt = bzr(['mkdir', self.info['directory'] + '2'], encoding='ascii')
+        txt = self.run_bzr_decode(['mkdir', self.info['directory'] + '2'],
+                                  encoding='ascii')
         expected = u'added %s2\n' % (self.info['directory'],)
         expected = expected.encode('ascii', 'replace')
         self.assertEqual(expected, txt)
 
     def test_relpath(self):
-        bzr = self.run_bzr_decode
-
-        txt = bzr(['relpath', self.info['filename']])
+        txt = self.run_bzr_decode(['relpath', self.info['filename']])
         self.assertEqual(self.info['filename'] + '\n', txt)
 
-        bzr(['relpath', self.info['filename']], encoding='ascii', retcode=3)
+        self.run_bzr_decode(['relpath', self.info['filename']],
+                            encoding='ascii', retcode=3)
 
     def test_inventory(self):
-        bzr = self.run_bzr_decode
-
-        txt = bzr('inventory')
+        txt = self.run_bzr_decode('inventory')
         self.assertEqual(['a', 'b', self.info['filename']],
                          txt.splitlines())
 
         # inventory should fail if unable to encode
-        bzr('inventory', encoding='ascii', retcode=3)
+        self.run_bzr_decode('inventory', encoding='ascii', retcode=3)
 
         # We don't really care about the ids themselves,
         # but the command shouldn't fail
-        txt = bzr('inventory --show-ids')
+        txt = self.run_bzr_decode('inventory --show-ids')
 
     def test_revno(self):
         # There isn't a lot to test here, since revno should always
         # be an integer
-        bzr = self.run_bzr_decode
-
-        self.assertEqual('3\n', bzr('revno'))
-        self.assertEqual('3\n', bzr('revno', encoding='ascii'))
+        self.assertEqual('3\n', self.run_bzr_decode('revno'))
+        self.assertEqual('3\n', self.run_bzr_decode('revno', encoding='ascii'))
 
     def test_revision_info(self):
-        bzr = self.run_bzr_decode
-
-        bzr('revision-info -r 1')
+        self.run_bzr_decode('revision-info -r 1')
 
         # TODO: jam 20060105 If we support revisions with non-ascii characters,
         # this should be strict and fail.
-        bzr('revision-info -r 1', encoding='ascii')
+        self.run_bzr_decode('revision-info -r 1', encoding='ascii')
 
     def test_mv(self):
-        bzr = self.run_bzr_decode
-
         fname1 = self.info['filename']
         fname2 = self.info['filename'] + '2'
         dirname = self.info['directory']
 
         # fname1 already exists
-        bzr(['mv', 'a', fname1], retcode=3)
+        self.run_bzr_decode(['mv', 'a', fname1], retcode=3)
 
-        txt = bzr(['mv', 'a', fname2])
+        txt = self.run_bzr_decode(['mv', 'a', fname2])
         self.assertEqual(u'a => %s\n' % fname2, txt)
         self.failIfExists('a')
         self.failUnlessExists(fname2)
@@ -190,28 +176,26 @@
 
         os.mkdir(dirname)
         self.wt.add(dirname)
-        txt = bzr(['mv', fname1, fname2, dirname])
+        txt = self.run_bzr_decode(['mv', fname1, fname2, dirname])
         self.assertEqual([u'%s => %s/%s' % (fname1, dirname, fname1),
                           u'%s => %s/%s' % (fname2, dirname, fname2)]
                          , txt.splitlines())
 
         # The rename should still succeed
         newpath = u'%s/%s' % (dirname, fname2)
-        txt = bzr(['mv', newpath, 'a'], encoding='ascii')
+        txt = self.run_bzr_decode(['mv', newpath, 'a'], encoding='ascii')
         self.failUnlessExists('a')
         self.assertEqual(newpath.encode('ascii', 'replace') + ' => a\n', txt)
 
     def test_branch(self):
         # We should be able to branch into a directory that
         # has a unicode name, even if we can't display the name
-        bzr = self.run_bzr_decode
-        bzr(['branch', u'.', self.info['directory']])
-        bzr(['branch', u'.', self.info['directory'] + '2'], encoding='ascii')
+        self.run_bzr_decode(['branch', u'.', self.info['directory']])
+        self.run_bzr_decode(['branch', u'.', self.info['directory'] + '2'],
+                            encoding='ascii')
 
     def test_pull(self):
         # Make sure we can pull from paths that can't be encoded
-        bzr = self.run_bzr_decode
-
         dirname1 = self.info['directory']
         dirname2 = self.info['directory'] + '2'
         url1 = urlutils.local_path_to_url(dirname1)
@@ -219,310 +203,266 @@
         out_bzrdir = self.wt.bzrdir.sprout(url1)
         out_bzrdir.sprout(url2)
 
-        os.chdir(dirname1)
-        open('a', 'ab').write('more text\n')
+        self.build_tree_contents(
+            [(osutils.pathjoin(dirname1, "a"), 'different text\n')])
         self.wt.commit('mod a')
 
-        pwd = osutils.getcwd()
-
-        os.chdir(u'../' + dirname2)
-        txt = bzr('pull')
-
+        txt = self.run_bzr_decode('pull', working_dir=dirname2)
+
+        expected = osutils.pathjoin(osutils.getcwd(), dirname1)
         self.assertEqual(u'Using saved location: %s/\n'
-                'No revisions to pull.\n' % (pwd,), txt)
+                'No revisions to pull.\n' % (expected,), txt)
 
-        os.chdir('../' + dirname1)
-        open('a', 'ab').write('and yet more\n')
+        self.build_tree_contents(
+            [(osutils.pathjoin(dirname1, 'a'), 'and yet more\n')])
         self.wt.commit(u'modifying a by ' + self.info['committer'])
 
-        os.chdir('../' + dirname2)
         # We should be able to pull, even if our encoding is bad
-        bzr('pull --verbose', encoding='ascii')
+        self.run_bzr_decode('pull --verbose', encoding='ascii',
+                            working_dir=dirname2)
 
     def test_push(self):
         # TODO: Test push to an SFTP location
         # Make sure we can pull from paths that can't be encoded
-        bzr = self.run_bzr_decode
-
         # TODO: jam 20060427 For drastically improving performance, we probably
         #       could create a local repository, so it wouldn't have to copy
         #       the files around as much.
 
         dirname = self.info['directory']
-        bzr(['push', dirname])
+        self.run_bzr_decode(['push', dirname])
 
-        open('a', 'ab').write('adding more text\n')
+        self.build_tree_contents([('a', 'adding more text\n')])
         self.wt.commit('added some stuff')
 
         # TODO: check the output text is properly encoded
-        bzr('push')
+        self.run_bzr_decode('push')
 
-        f = open('a', 'ab')
-        try:
-            f.write('and a bit more: ')
-            f.write(dirname.encode('utf-8'))
-            f.write('\n')
-        finally:
-            f.close()
+        self.build_tree_contents(
+            [('a', 'and a bit more: \n%s\n' % (dirname.encode('utf-8'),))])
 
         self.wt.commit('Added some ' + dirname)
-        bzr('push --verbose', encoding='ascii')
-
-        bzr(['push', '--verbose', dirname + '2'])
-
-        bzr(['push', '--verbose', dirname + '3'], encoding='ascii')
-
-        bzr(['push', '--verbose', '--create-prefix',
-             dirname + '4/' + dirname + '5'])
-        bzr(['push', '--verbose', '--create-prefix',
-             dirname + '6/' + dirname + '7'], encoding='ascii')
+        self.run_bzr_decode('push --verbose', encoding='ascii')
+
+        self.run_bzr_decode(['push', '--verbose', dirname + '2'])
+
+        self.run_bzr_decode(['push', '--verbose', dirname + '3'],
+                            encoding='ascii')
+
+        self.run_bzr_decode(['push', '--verbose', '--create-prefix',
+                            dirname + '4/' + dirname + '5'])
+        self.run_bzr_decode(['push', '--verbose', '--create-prefix',
+                            dirname + '6/' + dirname + '7'], encoding='ascii')
 
     def test_renames(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename'] + '2'
-        bzr(['mv', 'a', fname])
-        txt = bzr('renames')
+        self.wt.rename_one('a', fname)
+        txt = self.run_bzr_decode('renames')
         self.assertEqual(u'a => %s\n' % fname, txt)
 
-        bzr('renames', retcode=3, encoding='ascii')
+        self.run_bzr_decode('renames', retcode=3, encoding='ascii')
 
     def test_remove(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename']
-        txt = bzr(['remove', fname], encoding='ascii')
+        txt = self.run_bzr_decode(['remove', fname], encoding='ascii')
 
     def test_remove_verbose(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename']
-        txt = bzr(['remove', '--verbose', fname], encoding='ascii')
+        txt = self.run_bzr_decode(['remove', '--verbose', fname],
+                                  encoding='ascii')
 
     def test_file_id(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename']
-        txt = bzr(['file-id', fname])
+        txt = self.run_bzr_decode(['file-id', fname])
 
         # TODO: jam 20060106 We don't support non-ascii file ids yet, 
         #       so there is nothing which would fail in ascii encoding
         #       This *should* be retcode=3
-        txt = bzr(['file-id', fname], encoding='ascii')
+        txt = self.run_bzr_decode(['file-id', fname], encoding='ascii')
 
     def test_file_path(self):
-        bzr = self.run_bzr_decode
-
         # Create a directory structure
         fname = self.info['filename']
         dirname = self.info['directory']
-        os.mkdir('base')
-        os.mkdir('base/' + dirname)
+        self.build_tree_contents([
+            ('base/', ),
+            (osutils.pathjoin('base', '%s/' % (dirname,)), )])
         self.wt.add('base')
         self.wt.add('base/'+dirname)
-        path = '/'.join(['base', dirname, fname])
+        path = osutils.pathjoin('base', dirname, fname)
         self.wt.rename_one(fname, path)
         self.wt.commit('moving things around')
 
-        txt = bzr(['file-path', path])
+        txt = self.run_bzr_decode(['file-path', path])
 
         # TODO: jam 20060106 We don't support non-ascii file ids yet, 
         #       so there is nothing which would fail in ascii encoding
         #       This *should* be retcode=3
-        txt = bzr(['file-path', path], encoding='ascii')
+        txt = self.run_bzr_decode(['file-path', path], encoding='ascii')
 
     def test_revision_history(self):
-        bzr = self.run_bzr_decode
-
         # TODO: jam 20060106 We don't support non-ascii revision ids yet, 
         #       so there is nothing which would fail in ascii encoding
-        txt = bzr('revision-history')
+        txt = self.run_bzr_decode('revision-history')
 
     def test_ancestry(self):
-        bzr = self.run_bzr_decode
-
         # TODO: jam 20060106 We don't support non-ascii revision ids yet, 
         #       so there is nothing which would fail in ascii encoding
-        txt = bzr('ancestry')
+        txt = self.run_bzr_decode('ancestry')
 
     def test_diff(self):
         # TODO: jam 20060106 diff is a difficult one to test, because it 
         #       shouldn't encode the file contents, but it needs some sort
         #       of encoding for the paths, etc which are displayed.
-        open(self.info['filename'], 'ab').write('newline\n')
+        self.build_tree_contents([(self.info['filename'], 'newline\n')])
         txt = self.run_bzr('diff', retcode=1)[0]
 
     def test_deleted(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename']
         os.remove(fname)
         self.wt.remove(fname)
 
-        txt = bzr('deleted')
+        txt = self.run_bzr_decode('deleted')
         self.assertEqual(fname+'\n', txt)
 
-        txt = bzr('deleted --show-ids')
+        txt = self.run_bzr_decode('deleted --show-ids')
         self.failUnless(txt.startswith(fname))
 
         # Deleted should fail if cannot decode
         # Because it is giving the exact paths
         # which might be used by a front end
-        bzr('deleted', encoding='ascii', retcode=3)
+        self.run_bzr_decode('deleted', encoding='ascii', retcode=3)
 
     def test_modified(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename']
-        open(fname, 'ab').write('modified\n')
+        self.build_tree_contents([(fname, 'modified\n')])
 
-        txt = bzr('modified')
+        txt = self.run_bzr_decode('modified')
         self.assertEqual(fname+'\n', txt)
 
-        bzr('modified', encoding='ascii', retcode=3)
+        self.run_bzr_decode('modified', encoding='ascii', retcode=3)
 
     def test_added(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename'] + '2'
-        open(fname, 'wb').write('added\n')
+        self.build_tree_contents([(fname, 'added\n')])
         self.wt.add(fname)
 
-        txt = bzr('added')
+        txt = self.run_bzr_decode('added')
         self.assertEqual(fname+'\n', txt)
 
-        bzr('added', encoding='ascii', retcode=3)
+        self.run_bzr_decode('added', encoding='ascii', retcode=3)
 
     def test_root(self):
-        bzr = self.run_bzr_decode
-
         dirname = self.info['directory']
         url = urlutils.local_path_to_url(dirname)
-        bzr('root')
+        self.run_bzr_decode('root')
 
         self.wt.bzrdir.sprout(url)
 
-        os.chdir(dirname)
-
-        txt = bzr('root')
+        txt = self.run_bzr_decode('root', working_dir=dirname)
         self.failUnless(txt.endswith(dirname+'\n'))
 
-        txt = bzr('root', encoding='ascii', retcode=3)
+        txt = self.run_bzr_decode('root', encoding='ascii', retcode=3,
+                                  working_dir=dirname)
 
     def test_log(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename']
 
-        txt = bzr('log')
+        txt = self.run_bzr_decode('log')
         self.assertNotEqual(-1, txt.find(self.info['committer']))
         self.assertNotEqual(-1, txt.find(self.info['message']))
 
-        txt = bzr('log --verbose')
+        txt = self.run_bzr_decode('log --verbose')
         self.assertNotEqual(-1, txt.find(fname))
 
         # Make sure log doesn't fail even if we can't write out
-        txt = bzr('log --verbose', encoding='ascii')
+        txt = self.run_bzr_decode('log --verbose', encoding='ascii')
         self.assertEqual(-1, txt.find(fname))
         self.assertNotEqual(-1, txt.find(fname.encode('ascii', 'replace')))
 
     def test_touching_revisions(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename']
-        txt = bzr(['touching-revisions', fname])
+        txt = self.run_bzr_decode(['touching-revisions', fname])
         self.assertEqual(u'     3 added %s\n' % (fname,), txt)
 
         fname2 = self.info['filename'] + '2'
         self.wt.rename_one(fname, fname2)
         self.wt.commit(u'Renamed %s => %s' % (fname, fname2))
 
-        txt = bzr(['touching-revisions', fname2])
+        txt = self.run_bzr_decode(['touching-revisions', fname2])
         expected_txt = (u'     3 added %s\n' 
                         u'     4 renamed %s => %s\n'
                         % (fname, fname, fname2))
         self.assertEqual(expected_txt, txt)
 
-        bzr(['touching-revisions', fname2], encoding='ascii', retcode=3)
+        self.run_bzr_decode(['touching-revisions', fname2], encoding='ascii',
+                            retcode=3)
 
     def test_ls(self):
-        bzr = self.run_bzr_decode
-
-        txt = bzr('ls')
+        txt = self.run_bzr_decode('ls')
         self.assertEqual(sorted(['a', 'b', self.info['filename']]),
                          sorted(txt.splitlines()))
-        txt = bzr('ls --null')
+        txt = self.run_bzr_decode('ls --null')
         self.assertEqual(sorted(['', 'a', 'b', self.info['filename']]),
                          sorted(txt.split('\0')))
 
-        txt = bzr('ls', encoding='ascii', retcode=3)
-        txt = bzr('ls --null', encoding='ascii', retcode=3)
+        txt = self.run_bzr_decode('ls', encoding='ascii', retcode=3)
+        txt = self.run_bzr_decode('ls --null', encoding='ascii', retcode=3)
 
     def test_unknowns(self):
-        bzr = self.run_bzr_decode
-
         fname = self.info['filename'] + '2'
-        open(fname, 'wb').write('unknown\n')
+        self.build_tree_contents([(fname, 'unknown\n')])
 
         # TODO: jam 20060112 bzr unknowns is the only one which 
         #       quotes paths do we really want it to?
-        txt = bzr('unknowns')
+        txt = self.run_bzr_decode('unknowns')
         self.assertEqual(u'"%s"\n' % (fname,), txt)
 
-        bzr('unknowns', encoding='ascii', retcode=3)
+        self.run_bzr_decode('unknowns', encoding='ascii', retcode=3)
 
     def test_ignore(self):
-        bzr = self.run_bzr_decode
-
         fname2 = self.info['filename'] + '2.txt'
-        open(fname2, 'wb').write('ignored\n')
+        self.build_tree_contents([(fname2, 'ignored\n')])
 
         def check_unknowns(expected):
             self.assertEqual(expected, list(self.wt.unknowns()))
 
         check_unknowns([fname2])
 
-        bzr(['ignore', './' + fname2])
-        # After 'ignore' you must re-open the working tree
-        self.wt = self.wt.bzrdir.open_workingtree()
+        self.run_bzr_decode(['ignore', './' + fname2])
         check_unknowns([])
 
         fname3 = self.info['filename'] + '3.txt'
-        open(fname3, 'wb').write('unknown 3\n')
+        self.build_tree_contents([(fname3, 'unknown 3\n')])
         check_unknowns([fname3])
 
         # Ignore should not care what the encoding is
         # (right now it doesn't print anything)
-        bzr(['ignore', fname3], encoding='ascii')
-        self.wt = self.wt.bzrdir.open_workingtree()
+        self.run_bzr_decode(['ignore', fname3], encoding='ascii')
         check_unknowns([])
 
         # Now try a wildcard match
         fname4 = self.info['filename'] + '4.txt'
-        open(fname4, 'wb').write('unknown 4\n')
-        bzr('ignore *.txt')
-        self.wt = self.wt.bzrdir.open_workingtree()
+        self.build_tree_contents([(fname4, 'unknown 4\n')])
+        self.run_bzr_decode('ignore *.txt')
         check_unknowns([])
 
         # and a different wildcard that matches everything
         os.remove('.bzrignore')
-        bzr(['ignore', self.info['filename'] + '*'])
-        self.wt = self.wt.bzrdir.open_workingtree()
+        self.run_bzr_decode(['ignore', self.info['filename'] + '*'])
         check_unknowns([])
 
     def test_missing(self):
-        bzr = self.run_bzr_decode
-
         # create empty tree as reference for missing
-        self.run_bzr('init empty-tree')
+        self.make_branch_and_tree('empty-tree')
 
         msg = self.info['message']
 
-        txt = bzr('missing empty-tree', retcode=1)
+        txt = self.run_bzr_decode('missing empty-tree', retcode=1)
         self.assertNotEqual(-1, txt.find(self.info['committer']))
         self.assertNotEqual(-1, txt.find(msg))
 
         # Make sure missing doesn't fail even if we can't write out
-        txt = bzr('missing empty-tree', encoding='ascii', retcode=1)
+        txt = self.run_bzr_decode('missing empty-tree', encoding='ascii',
+                                  retcode=1)
         self.assertEqual(-1, txt.find(msg))
         self.assertNotEqual(-1, txt.find(msg.encode('ascii', 'replace')))

# Begin bundle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-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 189 bytes
Desc: This is a digitally signed message part
Url : https://lists.ubuntu.com/archives/bazaar/attachments/20070916/b337b79b/attachment-0001.pgp 


More information about the bazaar mailing list