Remove mock by removing a bunch of unicode shenanigans

src/allmydata/scripts/tahoe_add_alias.py

@@ -112,33 +112,26 @@ def _get_alias_details(nodedir):
 
 
 def list_aliases(options):
-    nodedir = options['node-directory']
-    stdout = options.stdout
-    stderr = options.stderr
-
-    data = _get_alias_details(nodedir)
-
-    max_width = max([len(quote_output(name)) for name in data.keys()] + [0])
-    fmt = "%" + str(max_width) + "s: %s"
-    rc = 0
+    data = _get_alias_details(options['node-directory'])
 
     if options['json']:
-        try:
-            # XXX why are we presuming utf-8 output?
-            print(json.dumps(data, indent=4).decode('utf-8'), file=stdout)
-        except (UnicodeEncodeError, UnicodeDecodeError):
-            print(json.dumps(data, indent=4), file=stderr)
-            rc = 1
+        output = json.dumps(data, indent=4)
     else:
-        for name, details in data.items():
-            dircap = details['readonly'] if options['readonly-uri'] else details['readwrite']
-            try:
-                print(fmt % (unicode_to_output(name), unicode_to_output(dircap.decode('utf-8'))), file=stdout)
-            except (UnicodeEncodeError, UnicodeDecodeError):
-                print(fmt % (quote_output(name), quote_output(dircap)), file=stderr)
-                rc = 1
+        def dircap(details):
+            return (
+                details['readonly']
+                if options['readonly-uri']
+                else details['readwrite']
+            ).decode("utf-8")
 
-    if rc == 1:
-        print("\nThis listing included aliases or caps that could not be converted to the terminal" \
-                        "\noutput encoding. These are shown using backslash escapes and in quotes.", file=stderr)
-    return rc
+        max_width = max([len(quote_output(name)) for name in data.keys()] + [0])
+        fmt = "%" + str(max_width) + "s: %s"
+        output = u"\n".join(list(
+            fmt % (name, dircap(details))
+            for name, details
+            in data.items()
+        ))
+
+    print(output, file=options.stdout)
+
+    return 0

src/allmydata/test/cli/test_alias.py

@@ -1,5 +1,4 @@
 import json
-from mock import patch
 
 from twisted.trial import unittest
 from twisted.internet.defer import inlineCallbacks
@@ -15,91 +14,37 @@ from ..common_util import skip_if_cannot_represent_argv
 class ListAlias(GridTestMixin, CLITestMixin, unittest.TestCase):
 
     @inlineCallbacks
-    def test_list(self):
+    def _test_list(self, alias):
         self.basedir = "cli/ListAlias/test_list"
         self.set_up_grid(oneshare=True)
 
         rc, stdout, stderr = yield self.do_cli(
             "create-alias",
-            unicode_to_argv(u"tahoe"),
+            unicode_to_argv(alias),
         )
 
-        self.failUnless(unicode_to_argv(u"Alias 'tahoe' created") in stdout)
-        self.failIf(stderr)
+        self.assertIn(
+            unicode_to_argv(u"Alias '{}' created".format(alias)),
+            stdout,
+        )
+        self.assertEqual("", stderr)
         aliases = get_aliases(self.get_clientdir())
-        self.failUnless(u"tahoe" in aliases)
-        self.failUnless(aliases[u"tahoe"].startswith("URI:DIR2:"))
+        self.assertIn(alias, aliases)
+        self.assertTrue(aliases[alias].startswith("URI:DIR2:"))
 
         rc, stdout, stderr = yield self.do_cli("list-aliases", "--json")
 
         self.assertEqual(0, rc)
         data = json.loads(stdout)
-        self.assertIn(u"tahoe", data)
-        data = data[u"tahoe"]
+        self.assertIn(alias, data)
+        data = data[alias]
         self.assertIn("readwrite", data)
         self.assertIn("readonly", data)
 
-    @inlineCallbacks
-    def test_list_unicode_mismatch_json(self):
-        """
-        pretty hack-y test, but we want to cover the 'except' on Unicode
-        errors paths and I can't come up with a nicer way to trigger
-        this
-        """
-        self.basedir = "cli/ListAlias/test_list_unicode_mismatch_json"
-        skip_if_cannot_represent_argv(u"tahoe\u263A")
-        self.set_up_grid(oneshare=True)
 
-        rc, stdout, stderr = yield self.do_cli(
-            "create-alias",
-            unicode_to_argv(u"tahoe\u263A"),
-        )
+    def test_list(self):
+        return self._test_list(u"tahoe")
 
-        self.failUnless(unicode_to_argv(u"Alias 'tahoe\u263A' created") in stdout)
-        self.failIf(stderr)
 
-        booms = []
-
-        def boom(out, indent=4):
-            if not len(booms):
-                booms.append(out)
-                raise UnicodeEncodeError("foo", u"foo", 3, 5, "foo")
-            return str(out)
-
-        with patch("allmydata.scripts.tahoe_add_alias.json.dumps", boom):
-            aliases = get_aliases(self.get_clientdir())
-            self.failUnless(u"tahoe\u263A" in aliases)
-            self.failUnless(aliases[u"tahoe\u263A"].startswith("URI:DIR2:"))
-
-            rc, stdout, stderr = yield self.do_cli("list-aliases", "--json")
-
-            self.assertEqual(1, rc)
-            self.assertIn("could not be converted", stderr)
-
-    @inlineCallbacks
-    def test_list_unicode_mismatch(self):
-        self.basedir = "cli/ListAlias/test_list_unicode_mismatch"
-        skip_if_cannot_represent_argv(u"tahoe\u263A")
-        self.set_up_grid(oneshare=True)
-
-        rc, stdout, stderr = yield self.do_cli(
-            "create-alias",
-            unicode_to_argv(u"tahoe\u263A"),
-        )
-
-        def boom(out):
-            print("boom {}".format(out))
-            return out
-            raise UnicodeEncodeError("foo", u"foo", 3, 5, "foo")
-
-        with patch("allmydata.scripts.tahoe_add_alias.unicode_to_output", boom):
-            self.failUnless(unicode_to_argv(u"Alias 'tahoe\u263A' created") in stdout)
-            self.failIf(stderr)
-            aliases = get_aliases(self.get_clientdir())
-            self.failUnless(u"tahoe\u263A" in aliases)
-            self.failUnless(aliases[u"tahoe\u263A"].startswith("URI:DIR2:"))
-
-            rc, stdout, stderr = yield self.do_cli("list-aliases")
-
-            self.assertEqual(1, rc)
-            self.assertIn("could not be converted", stderr)
+    def test_list_unicode(self):
+        return self._test_list(u"tahoe\{SNOWMAN}")