X-Git-Url: https://git.rkrishnan.org/?a=blobdiff_plain;f=src%2Fallmydata%2Ftest%2Ftest_cli.py;h=789e177d15c0689453ec9b9354db2f826a86fd2d;hb=0d6fcf445e21f58024ed869f5e672eab2d4a2903;hp=5985588016df54ee3dd7692f6f530d4b5a9ed30d;hpb=442008a6905d7374a653e72f4350470bd8090ae7;p=tahoe-lafs%2Ftahoe-lafs.git diff --git a/src/allmydata/test/test_cli.py b/src/allmydata/test/test_cli.py index 59855880..789e177d 100644 --- a/src/allmydata/test/test_cli.py +++ b/src/allmydata/test/test_cli.py @@ -1,108 +1,86 @@ -# coding=utf-8 import os.path -from twisted.trial import unittest from cStringIO import StringIO -import urllib -import re -import simplejson -import sys +import urllib, sys + +from twisted.trial import unittest +from twisted.python.monkey import MonkeyPatcher -from allmydata.util import fileutil, hashutil, base32 +import allmydata +from allmydata.util import fileutil, hashutil, base32, keyutil +from allmydata.util.namespace import Namespace from allmydata import uri from allmydata.immutable import upload - -# Test that the scripts can be imported -- although the actual tests of their -# functionality are done by invoking them in a subprocess. -from allmydata.scripts import tahoe_ls, tahoe_get, tahoe_put, tahoe_rm, tahoe_cp -_hush_pyflakes = [tahoe_ls, tahoe_get, tahoe_put, tahoe_rm, tahoe_cp] +from allmydata.dirnode import normalize +from allmydata.scripts.common_http import socket_error +import allmydata.scripts.common_http +from pycryptopp.publickey import ed25519 + +# Test that the scripts can be imported. +from allmydata.scripts import create_node, debug, keygen, startstop_node, \ + tahoe_add_alias, tahoe_backup, tahoe_check, tahoe_cp, tahoe_get, tahoe_ls, \ + tahoe_manifest, tahoe_mkdir, tahoe_mv, tahoe_put, tahoe_unlink, tahoe_webopen +_hush_pyflakes = [create_node, debug, keygen, startstop_node, + tahoe_add_alias, tahoe_backup, tahoe_check, tahoe_cp, tahoe_get, tahoe_ls, + tahoe_manifest, tahoe_mkdir, tahoe_mv, tahoe_put, tahoe_unlink, tahoe_webopen] from allmydata.scripts import common from allmydata.scripts.common import DEFAULT_ALIAS, get_aliases, get_alias, \ DefaultAliasMarker -from allmydata.scripts import cli, debug, runner, backupdb -from allmydata.test.common_util import StallMixin +from allmydata.scripts import cli, debug, runner +from allmydata.test.common_util import ReallyEqualMixin from allmydata.test.no_network import GridTestMixin from twisted.internet import threads # CLI tests use deferToThread from twisted.python import usage -from allmydata.util.stringutils import listdir_unicode, unicode_platform, FilenameEncodingError +from allmydata.util.assertutil import precondition +from allmydata.util.encodingutil import listdir_unicode, unicode_platform, \ + get_io_encoding, get_filesystem_encoding, unicode_to_argv timeout = 480 # deep_check takes 360s on Zandr's linksys box, others take > 240s -def skip_non_unicode_fs(): - if sys.getfilesystemencoding() not in ('UTF-8', 'mbcs'): - raise unittest.SkipTest("Arbitrary filenames are not supported by this platform") - -def skip_non_unicode_stdout(): - if not sys.stdout.encoding or sys.stdout.encoding not in ('UTF-8'): - raise unittest.SkipTest("Arbitrary command-line arguments (argv) are not supported by this platform") - -class CLI(unittest.TestCase): - # this test case only looks at argument-processing and simple stuff. - def test_options(self): - fileutil.rm_dir("cli/test_options") - fileutil.make_dirs("cli/test_options") - fileutil.make_dirs("cli/test_options/private") - fileutil.write("cli/test_options/node.url", "http://localhost:8080/\n") - filenode_uri = uri.WriteableSSKFileURI(writekey="\x00"*16, - fingerprint="\x00"*32) - private_uri = uri.DirectoryURI(filenode_uri).to_string() - fileutil.write("cli/test_options/private/root_dir.cap", private_uri + "\n") - o = cli.ListOptions() - o.parseOptions(["--node-directory", "cli/test_options"]) - self.failUnlessEqual(o['node-url'], "http://localhost:8080/") - self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], private_uri) - self.failUnlessEqual(o.where, "") - - o = cli.ListOptions() - o.parseOptions(["--node-directory", "cli/test_options", - "--node-url", "http://example.org:8111/"]) - self.failUnlessEqual(o['node-url'], "http://example.org:8111/") - self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], private_uri) - self.failUnlessEqual(o.where, "") +def parse_options(basedir, command, args): + o = runner.Options() + o.parseOptions(["--node-directory", basedir, command] + args) + while hasattr(o, "subOptions"): + o = o.subOptions + return o - o = cli.ListOptions() - o.parseOptions(["--node-directory", "cli/test_options", - "--dir-cap", "root"]) - self.failUnlessEqual(o['node-url'], "http://localhost:8080/") - self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], "root") - self.failUnlessEqual(o.where, "") +class CLITestMixin(ReallyEqualMixin): + def do_cli(self, verb, *args, **kwargs): + precondition(not [True for arg in args if not isinstance(arg, str)], + "arguments to do_cli must be strs -- convert using unicode_to_argv", args=args) - o = cli.ListOptions() - other_filenode_uri = uri.WriteableSSKFileURI(writekey="\x11"*16, - fingerprint="\x11"*32) - other_uri = uri.DirectoryURI(other_filenode_uri).to_string() - o.parseOptions(["--node-directory", "cli/test_options", - "--dir-cap", other_uri]) - self.failUnlessEqual(o['node-url'], "http://localhost:8080/") - self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], other_uri) - self.failUnlessEqual(o.where, "") + # client_num is used to execute client CLI commands on a specific client. + client_num = kwargs.get("client_num", 0) - o = cli.ListOptions() - o.parseOptions(["--node-directory", "cli/test_options", - "--dir-cap", other_uri, "subdir"]) - self.failUnlessEqual(o['node-url'], "http://localhost:8080/") - self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], other_uri) - self.failUnlessEqual(o.where, "subdir") + nodeargs = [ + "--node-directory", unicode_to_argv(self.get_clientdir(i=client_num)), + ] + argv = nodeargs + [verb] + list(args) + stdin = kwargs.get("stdin", "") + stdout, stderr = StringIO(), StringIO() + d = threads.deferToThread(runner.runner, argv, run_by_human=False, + stdin=StringIO(stdin), + stdout=stdout, stderr=stderr) + def _done(rc): + return rc, stdout.getvalue(), stderr.getvalue() + d.addCallback(_done) + return d - o = cli.ListOptions() - self.failUnlessRaises(usage.UsageError, - o.parseOptions, - ["--node-directory", "cli/test_options", - "--node-url", "NOT-A-URL"]) + def skip_if_cannot_represent_filename(self, u): + precondition(isinstance(u, unicode)) - o = cli.ListOptions() - o.parseOptions(["--node-directory", "cli/test_options", - "--node-url", "http://localhost:8080"]) - self.failUnlessEqual(o["node-url"], "http://localhost:8080/") + enc = get_filesystem_encoding() + if not unicode_platform(): + try: + u.encode(enc) + except UnicodeEncodeError: + raise unittest.SkipTest("A non-ASCII filename could not be encoded on this platform.") - o = cli.ListOptions() - o.parseOptions(["--node-directory", "cli/test_options", - "--node-url", "https://localhost/"]) - self.failUnlessEqual(o["node-url"], "https://localhost/") +class CLI(CLITestMixin, unittest.TestCase): def _dump_cap(self, *args): config = debug.DumpCapOptions() config.stdout,config.stderr = StringIO(), StringIO() @@ -155,15 +133,66 @@ class CLI(unittest.TestCase): u = uri.LiteralFileURI("this is some data") output = self._dump_cap(u.to_string()) self.failUnless("Literal File URI:" in output, output) - self.failUnless("data: this is some data" in output, output) + self.failUnless("data: 'this is some data'" in output, output) - def test_dump_cap_ssk(self): + def test_dump_cap_sdmf(self): writekey = "\x01" * 16 fingerprint = "\xfe" * 32 u = uri.WriteableSSKFileURI(writekey, fingerprint) output = self._dump_cap(u.to_string()) - self.failUnless("SSK Writeable URI:" in output, output) + self.failUnless("SDMF Writeable URI:" in output, output) + self.failUnless("writekey: aeaqcaibaeaqcaibaeaqcaibae" in output, output) + self.failUnless("readkey: nvgh5vj2ekzzkim5fgtb4gey5y" in output, output) + self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) + self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) + + output = self._dump_cap("--client-secret", "5s33nk3qpvnj2fw3z4mnm2y6fa", + u.to_string()) + self.failUnless("file renewal secret: arpszxzc2t6kb4okkg7sp765xgkni5z7caavj7lta73vmtymjlxq" in output, output) + + fileutil.make_dirs("cli/test_dump_cap/private") + fileutil.write("cli/test_dump_cap/private/secret", "5s33nk3qpvnj2fw3z4mnm2y6fa\n") + output = self._dump_cap("--client-dir", "cli/test_dump_cap", + u.to_string()) + self.failUnless("file renewal secret: arpszxzc2t6kb4okkg7sp765xgkni5z7caavj7lta73vmtymjlxq" in output, output) + + output = self._dump_cap("--client-dir", "cli/test_dump_cap_BOGUS", + u.to_string()) + self.failIf("file renewal secret:" in output, output) + + output = self._dump_cap("--nodeid", "tqc35esocrvejvg4mablt6aowg6tl43j", + u.to_string()) + self.failUnless("write_enabler: mgcavriox2wlb5eer26unwy5cw56elh3sjweffckkmivvsxtaknq" in output, output) + self.failIf("file renewal secret:" in output, output) + + output = self._dump_cap("--nodeid", "tqc35esocrvejvg4mablt6aowg6tl43j", + "--client-secret", "5s33nk3qpvnj2fw3z4mnm2y6fa", + u.to_string()) + self.failUnless("write_enabler: mgcavriox2wlb5eer26unwy5cw56elh3sjweffckkmivvsxtaknq" in output, output) + self.failUnless("file renewal secret: arpszxzc2t6kb4okkg7sp765xgkni5z7caavj7lta73vmtymjlxq" in output, output) + self.failUnless("lease renewal secret: 7pjtaumrb7znzkkbvekkmuwpqfjyfyamznfz4bwwvmh4nw33lorq" in output, output) + + u = u.get_readonly() + output = self._dump_cap(u.to_string()) + self.failUnless("SDMF Read-only URI:" in output, output) + self.failUnless("readkey: nvgh5vj2ekzzkim5fgtb4gey5y" in output, output) + self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) + self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) + + u = u.get_verify_cap() + output = self._dump_cap(u.to_string()) + self.failUnless("SDMF Verifier URI:" in output, output) + self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) + self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) + + def test_dump_cap_mdmf(self): + writekey = "\x01" * 16 + fingerprint = "\xfe" * 32 + u = uri.WriteableMDMFFileURI(writekey, fingerprint) + + output = self._dump_cap(u.to_string()) + self.failUnless("MDMF Writeable URI:" in output, output) self.failUnless("writekey: aeaqcaibaeaqcaibaeaqcaibae" in output, output) self.failUnless("readkey: nvgh5vj2ekzzkim5fgtb4gey5y" in output, output) self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) @@ -197,18 +226,53 @@ class CLI(unittest.TestCase): u = u.get_readonly() output = self._dump_cap(u.to_string()) - self.failUnless("SSK Read-only URI:" in output, output) + self.failUnless("MDMF Read-only URI:" in output, output) self.failUnless("readkey: nvgh5vj2ekzzkim5fgtb4gey5y" in output, output) self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) u = u.get_verify_cap() output = self._dump_cap(u.to_string()) - self.failUnless("SSK Verifier URI:" in output, output) + self.failUnless("MDMF Verifier URI:" in output, output) self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) - def test_dump_cap_directory(self): + + def test_dump_cap_chk_directory(self): + key = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" + uri_extension_hash = hashutil.uri_extension_hash("stuff") + needed_shares = 25 + total_shares = 100 + size = 1234 + u1 = uri.CHKFileURI(key=key, + uri_extension_hash=uri_extension_hash, + needed_shares=needed_shares, + total_shares=total_shares, + size=size) + u = uri.ImmutableDirectoryURI(u1) + + output = self._dump_cap(u.to_string()) + self.failUnless("CHK Directory URI:" in output, output) + self.failUnless("key: aaaqeayeaudaocajbifqydiob4" in output, output) + self.failUnless("UEB hash: nf3nimquen7aeqm36ekgxomalstenpkvsdmf6fplj7swdatbv5oa" in output, output) + self.failUnless("size: 1234" in output, output) + self.failUnless("k/N: 25/100" in output, output) + self.failUnless("storage index: hdis5iaveku6lnlaiccydyid7q" in output, output) + + output = self._dump_cap("--client-secret", "5s33nk3qpvnj2fw3z4mnm2y6fa", + u.to_string()) + self.failUnless("file renewal secret: csrvkjgomkyyyil5yo4yk5np37p6oa2ve2hg6xmk2dy7kaxsu6xq" in output, output) + + u = u.get_verify_cap() + output = self._dump_cap(u.to_string()) + self.failUnless("CHK Directory Verifier URI:" in output, output) + self.failIf("key: " in output, output) + self.failUnless("UEB hash: nf3nimquen7aeqm36ekgxomalstenpkvsdmf6fplj7swdatbv5oa" in output, output) + self.failUnless("size: 1234" in output, output) + self.failUnless("k/N: 25/100" in output, output) + self.failUnless("storage index: hdis5iaveku6lnlaiccydyid7q" in output, output) + + def test_dump_cap_sdmf_directory(self): writekey = "\x01" * 16 fingerprint = "\xfe" * 32 u1 = uri.WriteableSSKFileURI(writekey, fingerprint) @@ -252,6 +316,51 @@ class CLI(unittest.TestCase): self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) + def test_dump_cap_mdmf_directory(self): + writekey = "\x01" * 16 + fingerprint = "\xfe" * 32 + u1 = uri.WriteableMDMFFileURI(writekey, fingerprint) + u = uri.MDMFDirectoryURI(u1) + + output = self._dump_cap(u.to_string()) + self.failUnless("Directory Writeable URI:" in output, output) + self.failUnless("writekey: aeaqcaibaeaqcaibaeaqcaibae" in output, + output) + self.failUnless("readkey: nvgh5vj2ekzzkim5fgtb4gey5y" in output, output) + self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, + output) + self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) + + output = self._dump_cap("--client-secret", "5s33nk3qpvnj2fw3z4mnm2y6fa", + u.to_string()) + self.failUnless("file renewal secret: arpszxzc2t6kb4okkg7sp765xgkni5z7caavj7lta73vmtymjlxq" in output, output) + + output = self._dump_cap("--nodeid", "tqc35esocrvejvg4mablt6aowg6tl43j", + u.to_string()) + self.failUnless("write_enabler: mgcavriox2wlb5eer26unwy5cw56elh3sjweffckkmivvsxtaknq" in output, output) + self.failIf("file renewal secret:" in output, output) + + output = self._dump_cap("--nodeid", "tqc35esocrvejvg4mablt6aowg6tl43j", + "--client-secret", "5s33nk3qpvnj2fw3z4mnm2y6fa", + u.to_string()) + self.failUnless("write_enabler: mgcavriox2wlb5eer26unwy5cw56elh3sjweffckkmivvsxtaknq" in output, output) + self.failUnless("file renewal secret: arpszxzc2t6kb4okkg7sp765xgkni5z7caavj7lta73vmtymjlxq" in output, output) + self.failUnless("lease renewal secret: 7pjtaumrb7znzkkbvekkmuwpqfjyfyamznfz4bwwvmh4nw33lorq" in output, output) + + u = u.get_readonly() + output = self._dump_cap(u.to_string()) + self.failUnless("Directory Read-only URI:" in output, output) + self.failUnless("readkey: nvgh5vj2ekzzkim5fgtb4gey5y" in output, output) + self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) + self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) + + u = u.get_verify_cap() + output = self._dump_cap(u.to_string()) + self.failUnless("Directory Verifier URI:" in output, output) + self.failUnless("storage index: nt4fwemuw7flestsezvo2eveke" in output, output) + self.failUnless("fingerprint: 737p57x6737p57x6737p57x6737p57x6737p57x6737p57x6737a" in output, output) + + def _catalog_shares(self, *basedirs): o = debug.CatalogSharesOptions() o.stdout,o.stderr = StringIO(), StringIO() @@ -277,7 +386,7 @@ class CLI(unittest.TestCase): # now make sure that the 'catalog-shares' commands survives the error out, err = self._catalog_shares(nodedir1, nodedir2) - self.failUnlessEqual(out, "", out) + self.failUnlessReallyEqual(out, "", out) self.failUnless("Error processing " in err, "didn't see 'error processing' in '%s'" % err) #self.failUnless(nodedir1 in err, @@ -290,69 +399,74 @@ class CLI(unittest.TestCase): "didn't see 'mqfblse6m5a6dh45isu2cg7oji' in '%s'" % err) def test_alias(self): - aliases = {"tahoe": "TA", - "work": "WA", - "c": "CA"} + def s128(c): return base32.b2a(c*(128/8)) + def s256(c): return base32.b2a(c*(256/8)) + TA = "URI:DIR2:%s:%s" % (s128("T"), s256("T")) + WA = "URI:DIR2:%s:%s" % (s128("W"), s256("W")) + CA = "URI:DIR2:%s:%s" % (s128("C"), s256("C")) + aliases = {"tahoe": TA, + "work": WA, + "c": CA} def ga1(path): return get_alias(aliases, path, u"tahoe") uses_lettercolon = common.platform_uses_lettercolon_drivename() - self.failUnlessEqual(ga1("bare"), ("TA", "bare")) - self.failUnlessEqual(ga1("baredir/file"), ("TA", "baredir/file")) - self.failUnlessEqual(ga1("baredir/file:7"), ("TA", "baredir/file:7")) - self.failUnlessEqual(ga1("tahoe:"), ("TA", "")) - self.failUnlessEqual(ga1("tahoe:file"), ("TA", "file")) - self.failUnlessEqual(ga1("tahoe:dir/file"), ("TA", "dir/file")) - self.failUnlessEqual(ga1("work:"), ("WA", "")) - self.failUnlessEqual(ga1("work:file"), ("WA", "file")) - self.failUnlessEqual(ga1("work:dir/file"), ("WA", "dir/file")) + self.failUnlessReallyEqual(ga1(u"bare"), (TA, "bare")) + self.failUnlessReallyEqual(ga1(u"baredir/file"), (TA, "baredir/file")) + self.failUnlessReallyEqual(ga1(u"baredir/file:7"), (TA, "baredir/file:7")) + self.failUnlessReallyEqual(ga1(u"tahoe:"), (TA, "")) + self.failUnlessReallyEqual(ga1(u"tahoe:file"), (TA, "file")) + self.failUnlessReallyEqual(ga1(u"tahoe:dir/file"), (TA, "dir/file")) + self.failUnlessReallyEqual(ga1(u"work:"), (WA, "")) + self.failUnlessReallyEqual(ga1(u"work:file"), (WA, "file")) + self.failUnlessReallyEqual(ga1(u"work:dir/file"), (WA, "dir/file")) # default != None means we really expect a tahoe path, regardless of # whether we're on windows or not. This is what 'tahoe get' uses. - self.failUnlessEqual(ga1("c:"), ("CA", "")) - self.failUnlessEqual(ga1("c:file"), ("CA", "file")) - self.failUnlessEqual(ga1("c:dir/file"), ("CA", "dir/file")) - self.failUnlessEqual(ga1("URI:stuff"), ("URI:stuff", "")) - self.failUnlessEqual(ga1("URI:stuff/file"), ("URI:stuff", "file")) - self.failUnlessEqual(ga1("URI:stuff:./file"), ("URI:stuff", "file")) - self.failUnlessEqual(ga1("URI:stuff/dir/file"), ("URI:stuff", "dir/file")) - self.failUnlessEqual(ga1("URI:stuff:./dir/file"), ("URI:stuff", "dir/file")) - self.failUnlessRaises(common.UnknownAliasError, ga1, "missing:") - self.failUnlessRaises(common.UnknownAliasError, ga1, "missing:dir") - self.failUnlessRaises(common.UnknownAliasError, ga1, "missing:dir/file") + self.failUnlessReallyEqual(ga1(u"c:"), (CA, "")) + self.failUnlessReallyEqual(ga1(u"c:file"), (CA, "file")) + self.failUnlessReallyEqual(ga1(u"c:dir/file"), (CA, "dir/file")) + self.failUnlessReallyEqual(ga1(u"URI:stuff"), ("URI:stuff", "")) + self.failUnlessReallyEqual(ga1(u"URI:stuff/file"), ("URI:stuff", "file")) + self.failUnlessReallyEqual(ga1(u"URI:stuff:./file"), ("URI:stuff", "file")) + self.failUnlessReallyEqual(ga1(u"URI:stuff/dir/file"), ("URI:stuff", "dir/file")) + self.failUnlessReallyEqual(ga1(u"URI:stuff:./dir/file"), ("URI:stuff", "dir/file")) + self.failUnlessRaises(common.UnknownAliasError, ga1, u"missing:") + self.failUnlessRaises(common.UnknownAliasError, ga1, u"missing:dir") + self.failUnlessRaises(common.UnknownAliasError, ga1, u"missing:dir/file") def ga2(path): return get_alias(aliases, path, None) - self.failUnlessEqual(ga2("bare"), (DefaultAliasMarker, "bare")) - self.failUnlessEqual(ga2("baredir/file"), + self.failUnlessReallyEqual(ga2(u"bare"), (DefaultAliasMarker, "bare")) + self.failUnlessReallyEqual(ga2(u"baredir/file"), (DefaultAliasMarker, "baredir/file")) - self.failUnlessEqual(ga2("baredir/file:7"), + self.failUnlessReallyEqual(ga2(u"baredir/file:7"), (DefaultAliasMarker, "baredir/file:7")) - self.failUnlessEqual(ga2("baredir/sub:1/file:7"), + self.failUnlessReallyEqual(ga2(u"baredir/sub:1/file:7"), (DefaultAliasMarker, "baredir/sub:1/file:7")) - self.failUnlessEqual(ga2("tahoe:"), ("TA", "")) - self.failUnlessEqual(ga2("tahoe:file"), ("TA", "file")) - self.failUnlessEqual(ga2("tahoe:dir/file"), ("TA", "dir/file")) + self.failUnlessReallyEqual(ga2(u"tahoe:"), (TA, "")) + self.failUnlessReallyEqual(ga2(u"tahoe:file"), (TA, "file")) + self.failUnlessReallyEqual(ga2(u"tahoe:dir/file"), (TA, "dir/file")) # on windows, we really want c:foo to indicate a local file. # default==None is what 'tahoe cp' uses. if uses_lettercolon: - self.failUnlessEqual(ga2("c:"), (DefaultAliasMarker, "c:")) - self.failUnlessEqual(ga2("c:file"), (DefaultAliasMarker, "c:file")) - self.failUnlessEqual(ga2("c:dir/file"), + self.failUnlessReallyEqual(ga2(u"c:"), (DefaultAliasMarker, "c:")) + self.failUnlessReallyEqual(ga2(u"c:file"), (DefaultAliasMarker, "c:file")) + self.failUnlessReallyEqual(ga2(u"c:dir/file"), (DefaultAliasMarker, "c:dir/file")) else: - self.failUnlessEqual(ga2("c:"), ("CA", "")) - self.failUnlessEqual(ga2("c:file"), ("CA", "file")) - self.failUnlessEqual(ga2("c:dir/file"), ("CA", "dir/file")) - self.failUnlessEqual(ga2("work:"), ("WA", "")) - self.failUnlessEqual(ga2("work:file"), ("WA", "file")) - self.failUnlessEqual(ga2("work:dir/file"), ("WA", "dir/file")) - self.failUnlessEqual(ga2("URI:stuff"), ("URI:stuff", "")) - self.failUnlessEqual(ga2("URI:stuff/file"), ("URI:stuff", "file")) - self.failUnlessEqual(ga2("URI:stuff:./file"), ("URI:stuff", "file")) - self.failUnlessEqual(ga2("URI:stuff/dir/file"), ("URI:stuff", "dir/file")) - self.failUnlessEqual(ga2("URI:stuff:./dir/file"), ("URI:stuff", "dir/file")) - self.failUnlessRaises(common.UnknownAliasError, ga2, "missing:") - self.failUnlessRaises(common.UnknownAliasError, ga2, "missing:dir") - self.failUnlessRaises(common.UnknownAliasError, ga2, "missing:dir/file") + self.failUnlessReallyEqual(ga2(u"c:"), (CA, "")) + self.failUnlessReallyEqual(ga2(u"c:file"), (CA, "file")) + self.failUnlessReallyEqual(ga2(u"c:dir/file"), (CA, "dir/file")) + self.failUnlessReallyEqual(ga2(u"work:"), (WA, "")) + self.failUnlessReallyEqual(ga2(u"work:file"), (WA, "file")) + self.failUnlessReallyEqual(ga2(u"work:dir/file"), (WA, "dir/file")) + self.failUnlessReallyEqual(ga2(u"URI:stuff"), ("URI:stuff", "")) + self.failUnlessReallyEqual(ga2(u"URI:stuff/file"), ("URI:stuff", "file")) + self.failUnlessReallyEqual(ga2(u"URI:stuff:./file"), ("URI:stuff", "file")) + self.failUnlessReallyEqual(ga2(u"URI:stuff/dir/file"), ("URI:stuff", "dir/file")) + self.failUnlessReallyEqual(ga2(u"URI:stuff:./dir/file"), ("URI:stuff", "dir/file")) + self.failUnlessRaises(common.UnknownAliasError, ga2, u"missing:") + self.failUnlessRaises(common.UnknownAliasError, ga2, u"missing:dir") + self.failUnlessRaises(common.UnknownAliasError, ga2, u"missing:dir/file") def ga3(path): old = common.pretend_platform_uses_lettercolon @@ -362,36 +476,36 @@ class CLI(unittest.TestCase): finally: common.pretend_platform_uses_lettercolon = old return retval - self.failUnlessEqual(ga3("bare"), (DefaultAliasMarker, "bare")) - self.failUnlessEqual(ga3("baredir/file"), + self.failUnlessReallyEqual(ga3(u"bare"), (DefaultAliasMarker, "bare")) + self.failUnlessReallyEqual(ga3(u"baredir/file"), (DefaultAliasMarker, "baredir/file")) - self.failUnlessEqual(ga3("baredir/file:7"), + self.failUnlessReallyEqual(ga3(u"baredir/file:7"), (DefaultAliasMarker, "baredir/file:7")) - self.failUnlessEqual(ga3("baredir/sub:1/file:7"), + self.failUnlessReallyEqual(ga3(u"baredir/sub:1/file:7"), (DefaultAliasMarker, "baredir/sub:1/file:7")) - self.failUnlessEqual(ga3("tahoe:"), ("TA", "")) - self.failUnlessEqual(ga3("tahoe:file"), ("TA", "file")) - self.failUnlessEqual(ga3("tahoe:dir/file"), ("TA", "dir/file")) - self.failUnlessEqual(ga3("c:"), (DefaultAliasMarker, "c:")) - self.failUnlessEqual(ga3("c:file"), (DefaultAliasMarker, "c:file")) - self.failUnlessEqual(ga3("c:dir/file"), + self.failUnlessReallyEqual(ga3(u"tahoe:"), (TA, "")) + self.failUnlessReallyEqual(ga3(u"tahoe:file"), (TA, "file")) + self.failUnlessReallyEqual(ga3(u"tahoe:dir/file"), (TA, "dir/file")) + self.failUnlessReallyEqual(ga3(u"c:"), (DefaultAliasMarker, "c:")) + self.failUnlessReallyEqual(ga3(u"c:file"), (DefaultAliasMarker, "c:file")) + self.failUnlessReallyEqual(ga3(u"c:dir/file"), (DefaultAliasMarker, "c:dir/file")) - self.failUnlessEqual(ga3("work:"), ("WA", "")) - self.failUnlessEqual(ga3("work:file"), ("WA", "file")) - self.failUnlessEqual(ga3("work:dir/file"), ("WA", "dir/file")) - self.failUnlessEqual(ga3("URI:stuff"), ("URI:stuff", "")) - self.failUnlessEqual(ga3("URI:stuff:./file"), ("URI:stuff", "file")) - self.failUnlessEqual(ga3("URI:stuff:./dir/file"), ("URI:stuff", "dir/file")) - self.failUnlessRaises(common.UnknownAliasError, ga3, "missing:") - self.failUnlessRaises(common.UnknownAliasError, ga3, "missing:dir") - self.failUnlessRaises(common.UnknownAliasError, ga3, "missing:dir/file") + self.failUnlessReallyEqual(ga3(u"work:"), (WA, "")) + self.failUnlessReallyEqual(ga3(u"work:file"), (WA, "file")) + self.failUnlessReallyEqual(ga3(u"work:dir/file"), (WA, "dir/file")) + self.failUnlessReallyEqual(ga3(u"URI:stuff"), ("URI:stuff", "")) + self.failUnlessReallyEqual(ga3(u"URI:stuff:./file"), ("URI:stuff", "file")) + self.failUnlessReallyEqual(ga3(u"URI:stuff:./dir/file"), ("URI:stuff", "dir/file")) + self.failUnlessRaises(common.UnknownAliasError, ga3, u"missing:") + self.failUnlessRaises(common.UnknownAliasError, ga3, u"missing:dir") + self.failUnlessRaises(common.UnknownAliasError, ga3, u"missing:dir/file") # calling get_alias with a path that doesn't include an alias and # default set to something that isn't in the aliases argument should # raise an UnknownAliasError. def ga4(path): return get_alias(aliases, path, u"badddefault:") - self.failUnlessRaises(common.UnknownAliasError, ga4, "afile") - self.failUnlessRaises(common.UnknownAliasError, ga4, "a/dir/path/") + self.failUnlessRaises(common.UnknownAliasError, ga4, u"afile") + self.failUnlessRaises(common.UnknownAliasError, ga4, u"a/dir/path/") def ga5(path): old = common.pretend_platform_uses_lettercolon @@ -401,318 +515,198 @@ class CLI(unittest.TestCase): finally: common.pretend_platform_uses_lettercolon = old return retval - self.failUnlessRaises(common.UnknownAliasError, ga5, "C:\\Windows") + self.failUnlessRaises(common.UnknownAliasError, ga5, u"C:\\Windows") + + def test_alias_tolerance(self): + def s128(c): return base32.b2a(c*(128/8)) + def s256(c): return base32.b2a(c*(256/8)) + TA = "URI:DIR2:%s:%s" % (s128("T"), s256("T")) + aliases = {"present": TA, + "future": "URI-FROM-FUTURE:ooh:aah"} + def ga1(path): + return get_alias(aliases, path, u"tahoe") + self.failUnlessReallyEqual(ga1(u"present:file"), (TA, "file")) + # this throws, via assert IDirnodeURI.providedBy(), since get_alias() + # wants a dirnode, and the future cap gives us UnknownURI instead. + self.failUnlessRaises(AssertionError, ga1, u"future:stuff") def test_listdir_unicode_good(self): - files = (u'Lôzane', u'Bern', u'Genève') - enc = sys.getfilesystemencoding() or 'ascii' + filenames = [u'L\u00F4zane', u'Bern', u'Gen\u00E8ve'] # must be NFC - # Ensure that our test filenames can actually be represented by the - # current filesystem encoding - try: - [f.encode(enc) for f in files] - except UnicodeEncodeError: - raise unittest.SkipTest("Cannot represent non-ASCII filenames on this filesystem") + for name in filenames: + self.skip_if_cannot_represent_filename(name) - basedir = u"cli/common/listdir_unicode_good" + basedir = "cli/common/listdir_unicode_good" fileutil.make_dirs(basedir) - for file in files: - open(os.path.join(basedir, file), "w").close() + for name in filenames: + open(os.path.join(unicode(basedir), name), "wb").close() - for file in listdir_unicode(basedir): - self.failUnlessEqual(file in files, True) + for file in listdir_unicode(unicode(basedir)): + self.failUnlessIn(normalize(file), filenames) - def test_listdir_unicode_bad(self): - if unicode_platform(): - raise unittest.SkipTest("This test doesn't make any sense on architecture which handle filenames natively as Unicode entities.") + def test_exception_catcher(self): + self.basedir = "cli/exception_catcher" - basedir = u"cli/common/listdir_unicode_bad" - fileutil.make_dirs(basedir) + stderr = StringIO() + exc = Exception("canary") + ns = Namespace() - files = (u'Lôzane', u'Bern', u'Genève') + ns.runner_called = False + def call_runner(args, install_node_control=True): + ns.runner_called = True + self.failUnlessEqual(install_node_control, True) + raise exc - # We use a wrong encoding on purpose - if sys.getfilesystemencoding() == 'UTF-8': - encoding = 'latin1' - else: - encoding = 'UTF-8' + ns.sys_exit_called = False + def call_sys_exit(exitcode): + ns.sys_exit_called = True + self.failUnlessEqual(exitcode, 1) + + patcher = MonkeyPatcher((runner, 'runner', call_runner), + (sys, 'argv', ["tahoe"]), + (sys, 'exit', call_sys_exit), + (sys, 'stderr', stderr)) + patcher.runWithPatches(runner.run) - for file in files: - path = os.path.join(basedir, file).encode(encoding) - open(path, "w").close() + self.failUnless(ns.runner_called) + self.failUnless(ns.sys_exit_called) + self.failUnlessIn(str(exc), stderr.getvalue()) - self.failUnlessRaises(FilenameEncodingError, listdir_unicode, basedir) class Help(unittest.TestCase): + def failUnlessInNormalized(self, x, y): + # helper function to deal with the --help output being wrapped to + # various widths, depending on the $COLUMNS environment variable + self.failUnlessIn(x.replace("\n", " "), y.replace("\n", " ")) def test_get(self): help = str(cli.GetOptions()) - self.failUnless("get REMOTE_FILE LOCAL_FILE" in help, help) - self.failUnless("% tahoe get FOO |less" in help, help) + self.failUnlessIn("[options] REMOTE_FILE LOCAL_FILE", help) + self.failUnlessIn("% tahoe get FOO |less", help) def test_put(self): help = str(cli.PutOptions()) - self.failUnless("put LOCAL_FILE REMOTE_FILE" in help, help) - self.failUnless("% cat FILE | tahoe put" in help, help) + self.failUnlessIn("[options] LOCAL_FILE REMOTE_FILE", help) + self.failUnlessIn("% cat FILE | tahoe put", help) + + def test_ls(self): + help = str(cli.ListOptions()) + self.failUnlessIn("[options] [PATH]", help) + + def test_unlink(self): + help = str(cli.UnlinkOptions()) + self.failUnlessIn("[options] REMOTE_FILE", help) def test_rm(self): help = str(cli.RmOptions()) - self.failUnless("rm REMOTE_FILE" in help, help) + self.failUnlessIn("[options] REMOTE_FILE", help) def test_mv(self): help = str(cli.MvOptions()) - self.failUnless("mv FROM TO" in help, help) - self.failUnless("Use 'tahoe mv' to move files" in help) + self.failUnlessIn("[options] FROM TO", help) + self.failUnlessInNormalized("Use 'tahoe mv' to move files", help) + + def test_cp(self): + help = str(cli.CpOptions()) + self.failUnlessIn("[options] FROM.. TO", help) + self.failUnlessInNormalized("Use 'tahoe cp' to copy files", help) def test_ln(self): help = str(cli.LnOptions()) - self.failUnless("ln FROM TO" in help, help) + self.failUnlessIn("[options] FROM_LINK TO_LINK", help) + self.failUnlessInNormalized("Use 'tahoe ln' to duplicate a link", help) + + def test_mkdir(self): + help = str(cli.MakeDirectoryOptions()) + self.failUnlessIn("[options] [REMOTE_DIR]", help) + self.failUnlessInNormalized("Create a new directory", help) def test_backup(self): help = str(cli.BackupOptions()) - self.failUnless("backup FROM ALIAS:TO" in help, help) + self.failUnlessIn("[options] FROM ALIAS:TO", help) def test_webopen(self): help = str(cli.WebopenOptions()) - self.failUnless("webopen [ALIAS:PATH]" in help, help) + self.failUnlessIn("[options] [ALIAS:PATH]", help) def test_manifest(self): help = str(cli.ManifestOptions()) - self.failUnless("manifest [ALIAS:PATH]" in help, help) + self.failUnlessIn("[options] [ALIAS:PATH]", help) def test_stats(self): help = str(cli.StatsOptions()) - self.failUnless("stats [ALIAS:PATH]" in help, help) + self.failUnlessIn("[options] [ALIAS:PATH]", help) def test_check(self): help = str(cli.CheckOptions()) - self.failUnless("check [ALIAS:PATH]" in help, help) + self.failUnlessIn("[options] [ALIAS:PATH]", help) def test_deep_check(self): help = str(cli.DeepCheckOptions()) - self.failUnless("deep-check [ALIAS:PATH]" in help, help) + self.failUnlessIn("[options] [ALIAS:PATH]", help) def test_create_alias(self): help = str(cli.CreateAliasOptions()) - self.failUnless("create-alias ALIAS" in help, help) + self.failUnlessIn("[options] ALIAS[:]", help) - def test_add_aliases(self): + def test_add_alias(self): help = str(cli.AddAliasOptions()) - self.failUnless("add-alias ALIAS DIRCAP" in help, help) + self.failUnlessIn("[options] ALIAS[:] DIRCAP", help) -class CLITestMixin: - def do_cli(self, verb, *args, **kwargs): - nodeargs = [ - "--node-directory", self.get_clientdir(), - ] - argv = [verb] + nodeargs + list(args) - stdin = kwargs.get("stdin", "") - stdout, stderr = StringIO(), StringIO() - d = threads.deferToThread(runner.runner, argv, run_by_human=False, - stdin=StringIO(stdin), - stdout=stdout, stderr=stderr) - def _done(rc): - return rc, stdout.getvalue(), stderr.getvalue() - d.addCallback(_done) - return d + def test_list_aliases(self): + help = str(cli.ListAliasesOptions()) + self.failUnlessIn("[options]", help) -class CreateAlias(GridTestMixin, CLITestMixin, unittest.TestCase): + def test_start(self): + help = str(startstop_node.StartOptions()) + self.failUnlessIn("[options] [NODEDIR [twistd-options]]", help) - def _test_webopen(self, args, expected_url): - woo = cli.WebopenOptions() - all_args = ["--node-directory", self.get_clientdir()] + list(args) - woo.parseOptions(all_args) - urls = [] - rc = cli.webopen(woo, urls.append) - self.failUnlessEqual(rc, 0) - self.failUnlessEqual(len(urls), 1) - self.failUnlessEqual(urls[0], expected_url) + def test_stop(self): + help = str(startstop_node.StopOptions()) + self.failUnlessIn("[options] [NODEDIR]", help) - def test_create(self): - self.basedir = "cli/CreateAlias/create" - self.set_up_grid() - aliasfile = os.path.join(self.get_clientdir(), "private", "aliases") + def test_restart(self): + help = str(startstop_node.RestartOptions()) + self.failUnlessIn("[options] [NODEDIR [twistd-options]]", help) - d = self.do_cli("create-alias", "tahoe") - def _done((rc,stdout,stderr)): - self.failUnless("Alias 'tahoe' created" in stdout) - self.failIf(stderr) - aliases = get_aliases(self.get_clientdir()) - self.failUnless("tahoe" in aliases) - self.failUnless(aliases["tahoe"].startswith("URI:DIR2:")) - d.addCallback(_done) - d.addCallback(lambda res: self.do_cli("create-alias", "two")) - - def _stash_urls(res): - aliases = get_aliases(self.get_clientdir()) - node_url_file = os.path.join(self.get_clientdir(), "node.url") - nodeurl = fileutil.read(node_url_file).strip() - self.welcome_url = nodeurl - uribase = nodeurl + "uri/" - self.tahoe_url = uribase + urllib.quote(aliases["tahoe"]) - self.tahoe_subdir_url = self.tahoe_url + "/subdir" - self.two_url = uribase + urllib.quote(aliases["two"]) - self.two_uri = aliases["two"] - d.addCallback(_stash_urls) - - d.addCallback(lambda res: self.do_cli("create-alias", "two")) # dup - def _check_create_duplicate((rc,stdout,stderr)): - self.failIfEqual(rc, 0) - self.failUnless("Alias 'two' already exists!" in stderr) - aliases = get_aliases(self.get_clientdir()) - self.failUnlessEqual(aliases["two"], self.two_uri) - d.addCallback(_check_create_duplicate) - - d.addCallback(lambda res: self.do_cli("add-alias", "added", self.two_uri)) - def _check_add((rc,stdout,stderr)): - self.failUnlessEqual(rc, 0) - self.failUnless("Alias 'added' added" in stdout) - d.addCallback(_check_add) - - # check add-alias with a duplicate - d.addCallback(lambda res: self.do_cli("add-alias", "two", self.two_uri)) - def _check_add_duplicate((rc,stdout,stderr)): - self.failIfEqual(rc, 0) - self.failUnless("Alias 'two' already exists!" in stderr) - aliases = get_aliases(self.get_clientdir()) - self.failUnlessEqual(aliases["two"], self.two_uri) - d.addCallback(_check_add_duplicate) - - def _test_urls(junk): - self._test_webopen([], self.welcome_url) - self._test_webopen(["/"], self.tahoe_url) - self._test_webopen(["tahoe:"], self.tahoe_url) - self._test_webopen(["tahoe:/"], self.tahoe_url) - self._test_webopen(["tahoe:subdir"], self.tahoe_subdir_url) - self._test_webopen(["-i", "tahoe:subdir"], - self.tahoe_subdir_url+"?t=info") - self._test_webopen(["tahoe:subdir/"], self.tahoe_subdir_url + '/') - self._test_webopen(["tahoe:subdir/file"], - self.tahoe_subdir_url + '/file') - self._test_webopen(["--info", "tahoe:subdir/file"], - self.tahoe_subdir_url + '/file?t=info') - # if "file" is indeed a file, then the url produced by webopen in - # this case is disallowed by the webui. but by design, webopen - # passes through the mistake from the user to the resultant - # webopened url - self._test_webopen(["tahoe:subdir/file/"], self.tahoe_subdir_url + '/file/') - self._test_webopen(["two:"], self.two_url) - d.addCallback(_test_urls) - - def _remove_trailing_newline_and_create_alias(ign): - # ticket #741 is about a manually-edited alias file (which - # doesn't end in a newline) being corrupted by a subsequent - # "tahoe create-alias" - old = fileutil.read(aliasfile) - fileutil.write(aliasfile, old.rstrip()) - return self.do_cli("create-alias", "un-corrupted1") - d.addCallback(_remove_trailing_newline_and_create_alias) - def _check_not_corrupted1((rc,stdout,stderr)): - self.failUnless("Alias 'un-corrupted1' created" in stdout, stdout) - self.failIf(stderr) - # the old behavior was to simply append the new record, causing a - # line that looked like "NAME1: CAP1NAME2: CAP2". This won't look - # like a valid dircap, so get_aliases() will raise an exception. - aliases = get_aliases(self.get_clientdir()) - self.failUnless("added" in aliases) - self.failUnless(aliases["added"].startswith("URI:DIR2:")) - # to be safe, let's confirm that we don't see "NAME2:" in CAP1. - # No chance of a false-negative, because the hyphen in - # "un-corrupted1" is not a valid base32 character. - self.failIfIn("un-corrupted1:", aliases["added"]) - self.failUnless("un-corrupted1" in aliases) - self.failUnless(aliases["un-corrupted1"].startswith("URI:DIR2:")) - d.addCallback(_check_not_corrupted1) - - def _remove_trailing_newline_and_add_alias(ign): - # same thing, but for "tahoe add-alias" - old = fileutil.read(aliasfile) - fileutil.write(aliasfile, old.rstrip()) - return self.do_cli("add-alias", "un-corrupted2", self.two_uri) - d.addCallback(_remove_trailing_newline_and_add_alias) - def _check_not_corrupted((rc,stdout,stderr)): - self.failUnless("Alias 'un-corrupted2' added" in stdout, stdout) - self.failIf(stderr) - aliases = get_aliases(self.get_clientdir()) - self.failUnless("un-corrupted1" in aliases) - self.failUnless(aliases["un-corrupted1"].startswith("URI:DIR2:")) - self.failIfIn("un-corrupted2:", aliases["un-corrupted1"]) - self.failUnless("un-corrupted2" in aliases) - self.failUnless(aliases["un-corrupted2"].startswith("URI:DIR2:")) - d.addCallback(_check_not_corrupted) - - - def test_create_unicode(self): - skip_non_unicode_fs() - skip_non_unicode_stdout() - - self.basedir = "cli/CreateAlias/create_unicode" - self.set_up_grid() + def test_run(self): + help = str(startstop_node.RunOptions()) + self.failUnlessIn("[options] [NODEDIR [twistd-options]]", help) - d = self.do_cli("create-alias", "études") - def _check_create_unicode((rc,stdout,stderr)): - self.failUnlessEqual(rc, 0) - self.failIf(stderr) - - # If stdout only supports ascii, accentuated characters are - # being replaced by '?' - if sys.stdout.encoding == "ANSI_X3.4-1968": - self.failUnless("Alias '?tudes' created" in stdout) - else: - self.failUnless("Alias 'études' created" in stdout) - - aliases = get_aliases(self.get_clientdir()) - self.failUnless(aliases[u"études"].startswith("URI:DIR2:")) - d.addCallback(_check_create_unicode) - - d.addCallback(lambda res: self.do_cli("ls", "études:")) - def _check_ls1((rc, stdout, stderr)): - self.failUnlessEqual(rc, 0) - self.failIf(stderr) - - self.failUnlessEqual(stdout, "") - d.addCallback(_check_ls1) - - d.addCallback(lambda res: self.do_cli("put", "-", "études:uploaded.txt", - stdin="Blah blah blah")) - - d.addCallback(lambda res: self.do_cli("ls", "études:")) - def _check_ls2((rc, stdout, stderr)): - self.failUnlessEqual(rc, 0) - self.failIf(stderr) - - self.failUnlessEqual(stdout, "uploaded.txt\n") - d.addCallback(_check_ls2) - - d.addCallback(lambda res: self.do_cli("get", "études:uploaded.txt")) - def _check_get((rc, stdout, stderr)): - self.failUnlessEqual(rc, 0) - self.failIf(stderr) - self.failUnlessEqual(stdout, "Blah blah blah") - d.addCallback(_check_get) - - # Ensure that an Unicode filename in an Unicode alias works as expected - d.addCallback(lambda res: self.do_cli("put", "-", "études:lumière.txt", - stdin="Let the sunshine In!")) - - d.addCallback(lambda res: self.do_cli("get", - get_aliases(self.get_clientdir())[u"études"] + "/lumière.txt")) - def _check_get2((rc, stdout, stderr)): - self.failUnlessEqual(rc, 0) - self.failIf(stderr) - self.failUnlessEqual(stdout, "Let the sunshine In!") - d.addCallback(_check_get2) + def test_create_client(self): + help = str(create_node.CreateClientOptions()) + self.failUnlessIn("[options] [NODEDIR]", help) + + def test_create_node(self): + help = str(create_node.CreateNodeOptions()) + self.failUnlessIn("[options] [NODEDIR]", help) + + def test_create_introducer(self): + help = str(create_node.CreateIntroducerOptions()) + self.failUnlessIn("[options] NODEDIR", help) + + def test_debug_trial(self): + help = str(debug.TrialOptions()) + self.failUnlessIn(" [global-options] debug trial [options] [[file|package|module|TestCase|testmethod]...]", help) + self.failUnlessInNormalized("The 'tahoe debug trial' command uses the correct imports", help) + + def test_debug_flogtool(self): + options = debug.FlogtoolOptions() + help = str(options) + self.failUnlessIn(" [global-options] debug flogtool ", help) + self.failUnlessInNormalized("The 'tahoe debug flogtool' command uses the correct imports", help) + + for (option, shortcut, oClass, desc) in options.subCommands: + subhelp = str(oClass()) + self.failUnlessIn(" [global-options] debug flogtool %s " % (option,), subhelp) - return d class Ln(GridTestMixin, CLITestMixin, unittest.TestCase): def _create_test_file(self): data = "puppies" * 1000 path = os.path.join(self.basedir, "datafile") - f = open(path, 'wb') - f.write(data) - f.close() + fileutil.write(path, data) self.datafile = path def test_ln_without_alias(self): @@ -723,8 +717,9 @@ class Ln(GridTestMixin, CLITestMixin, unittest.TestCase): self.set_up_grid() d = self.do_cli("ln", "from", "to") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) # Make sure that validation extends to the "to" parameter d.addCallback(lambda ign: self.do_cli("create-alias", "havasu")) @@ -742,7 +737,7 @@ class Ln(GridTestMixin, CLITestMixin, unittest.TestCase): self.set_up_grid() d = self.do_cli("ln", "havasu:from", "havasu:to") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) d.addCallback(_check) # Make sure that validation occurs on the to parameter if the @@ -756,1564 +751,356 @@ class Ln(GridTestMixin, CLITestMixin, unittest.TestCase): return d -class Put(GridTestMixin, CLITestMixin, unittest.TestCase): - - def test_unlinked_immutable_stdin(self): - # tahoe get `echo DATA | tahoe put` - # tahoe get `echo DATA | tahoe put -` - self.basedir = "cli/Put/unlinked_immutable_stdin" - DATA = "data" * 100 - self.set_up_grid() - d = self.do_cli("put", stdin=DATA) - def _uploaded(res): - (rc, stdout, stderr) = res - self.failUnless("waiting for file data on stdin.." in stderr) - self.failUnless("200 OK" in stderr, stderr) - self.readcap = stdout - self.failUnless(self.readcap.startswith("URI:CHK:")) - d.addCallback(_uploaded) - d.addCallback(lambda res: self.do_cli("get", self.readcap)) - def _downloaded(res): - (rc, stdout, stderr) = res - self.failUnlessEqual(stderr, "") - self.failUnlessEqual(stdout, DATA) - d.addCallback(_downloaded) - d.addCallback(lambda res: self.do_cli("put", "-", stdin=DATA)) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, self.readcap)) +class Admin(unittest.TestCase): + def do_cli(self, *args, **kwargs): + argv = list(args) + stdin = kwargs.get("stdin", "") + stdout, stderr = StringIO(), StringIO() + d = threads.deferToThread(runner.runner, argv, run_by_human=False, + stdin=StringIO(stdin), + stdout=stdout, stderr=stderr) + def _done(res): + return stdout.getvalue(), stderr.getvalue() + d.addCallback(_done) return d - def test_unlinked_immutable_from_file(self): - # tahoe put file.txt - # tahoe put ./file.txt - # tahoe put /tmp/file.txt - # tahoe put ~/file.txt - self.basedir = "cli/Put/unlinked_immutable_from_file" - self.set_up_grid() + def test_generate_keypair(self): + d = self.do_cli("admin", "generate-keypair") + def _done( (stdout, stderr) ): + lines = [line.strip() for line in stdout.splitlines()] + privkey_bits = lines[0].split() + pubkey_bits = lines[1].split() + sk_header = "private:" + vk_header = "public:" + self.failUnlessEqual(privkey_bits[0], sk_header, lines[0]) + self.failUnlessEqual(pubkey_bits[0], vk_header, lines[1]) + self.failUnless(privkey_bits[1].startswith("priv-v0-"), lines[0]) + self.failUnless(pubkey_bits[1].startswith("pub-v0-"), lines[1]) + sk_bytes = base32.a2b(keyutil.remove_prefix(privkey_bits[1], "priv-v0-")) + sk = ed25519.SigningKey(sk_bytes) + vk_bytes = base32.a2b(keyutil.remove_prefix(pubkey_bits[1], "pub-v0-")) + self.failUnlessEqual(sk.get_verifying_key_bytes(), vk_bytes) + d.addCallback(_done) + return d - rel_fn = os.path.join(self.basedir, "DATAFILE") - abs_fn = os.path.abspath(rel_fn) - # we make the file small enough to fit in a LIT file, for speed - fileutil.write(rel_fn, "short file") - d = self.do_cli("put", rel_fn) - def _uploaded((rc,stdout,stderr)): - readcap = stdout - self.failUnless(readcap.startswith("URI:LIT:")) - self.readcap = readcap - d.addCallback(_uploaded) - d.addCallback(lambda res: self.do_cli("put", "./" + rel_fn)) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, self.readcap)) - d.addCallback(lambda res: self.do_cli("put", abs_fn)) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, self.readcap)) - # we just have to assume that ~ is handled properly + def test_derive_pubkey(self): + priv1,pub1 = keyutil.make_keypair() + d = self.do_cli("admin", "derive-pubkey", priv1) + def _done( (stdout, stderr) ): + lines = stdout.split("\n") + privkey_line = lines[0].strip() + pubkey_line = lines[1].strip() + sk_header = "private: priv-v0-" + vk_header = "public: pub-v0-" + self.failUnless(privkey_line.startswith(sk_header), privkey_line) + self.failUnless(pubkey_line.startswith(vk_header), pubkey_line) + pub2 = pubkey_line[len(vk_header):] + self.failUnlessEqual("pub-v0-"+pub2, pub1) + d.addCallback(_done) return d - def test_immutable_from_file(self): - # tahoe put file.txt uploaded.txt - # tahoe - uploaded.txt - # tahoe put file.txt subdir/uploaded.txt - # tahoe put file.txt tahoe:uploaded.txt - # tahoe put file.txt tahoe:subdir/uploaded.txt - # tahoe put file.txt DIRCAP:./uploaded.txt - # tahoe put file.txt DIRCAP:./subdir/uploaded.txt - self.basedir = "cli/Put/immutable_from_file" + +class Errors(GridTestMixin, CLITestMixin, unittest.TestCase): + def test_get(self): + self.basedir = "cli/Errors/get" self.set_up_grid() + c0 = self.g.clients[0] + self.fileurls = {} + DATA = "data" * 100 + d = c0.upload(upload.Data(DATA, convergence="")) + def _stash_bad(ur): + self.uri_1share = ur.get_uri() + self.delete_shares_numbered(ur.get_uri(), range(1,10)) + d.addCallback(_stash_bad) - rel_fn = os.path.join(self.basedir, "DATAFILE") - # we make the file small enough to fit in a LIT file, for speed - DATA = "short file" - DATA2 = "short file two" - fileutil.write(rel_fn, DATA) + # the download is abandoned as soon as it's clear that we won't get + # enough shares. The one remaining share might be in either the + # COMPLETE or the PENDING state. + in_complete_msg = "ran out of shares: complete=sh0 pending= overdue= unused= need 3" + in_pending_msg = "ran out of shares: complete= pending=Share(sh0-on-fob7vqgd) overdue= unused= need 3" - d = self.do_cli("create-alias", "tahoe") + d.addCallback(lambda ign: self.do_cli("get", self.uri_1share)) + def _check1((rc, out, err)): + self.failIfEqual(rc, 0) + self.failUnless("410 Gone" in err, err) + self.failUnlessIn("NotEnoughSharesError: ", err) + self.failUnless(in_complete_msg in err or in_pending_msg in err, + err) + d.addCallback(_check1) - d.addCallback(lambda res: - self.do_cli("put", rel_fn, "uploaded.txt")) - def _uploaded((rc,stdout,stderr)): - readcap = stdout.strip() - self.failUnless(readcap.startswith("URI:LIT:")) - self.failUnless("201 Created" in stderr, stderr) - self.readcap = readcap - d.addCallback(_uploaded) - d.addCallback(lambda res: - self.do_cli("get", "tahoe:uploaded.txt")) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, DATA)) - - d.addCallback(lambda res: - self.do_cli("put", "-", "uploaded.txt", stdin=DATA2)) - def _replaced((rc,stdout,stderr)): - readcap = stdout.strip() - self.failUnless(readcap.startswith("URI:LIT:")) - self.failUnless("200 OK" in stderr, stderr) - d.addCallback(_replaced) - - d.addCallback(lambda res: - self.do_cli("put", rel_fn, "subdir/uploaded2.txt")) - d.addCallback(lambda res: self.do_cli("get", "subdir/uploaded2.txt")) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, DATA)) - - d.addCallback(lambda res: - self.do_cli("put", rel_fn, "tahoe:uploaded3.txt")) - d.addCallback(lambda res: self.do_cli("get", "tahoe:uploaded3.txt")) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, DATA)) - - d.addCallback(lambda res: - self.do_cli("put", rel_fn, "tahoe:subdir/uploaded4.txt")) - d.addCallback(lambda res: - self.do_cli("get", "tahoe:subdir/uploaded4.txt")) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, DATA)) - - def _get_dircap(res): - self.dircap = get_aliases(self.get_clientdir())["tahoe"] - d.addCallback(_get_dircap) - - d.addCallback(lambda res: - self.do_cli("put", rel_fn, - self.dircap+":./uploaded5.txt")) - d.addCallback(lambda res: - self.do_cli("get", "tahoe:uploaded5.txt")) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, DATA)) - - d.addCallback(lambda res: - self.do_cli("put", rel_fn, - self.dircap+":./subdir/uploaded6.txt")) - d.addCallback(lambda res: - self.do_cli("get", "tahoe:subdir/uploaded6.txt")) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, DATA)) + targetf = os.path.join(self.basedir, "output") + d.addCallback(lambda ign: self.do_cli("get", self.uri_1share, targetf)) + def _check2((rc, out, err)): + self.failIfEqual(rc, 0) + self.failUnless("410 Gone" in err, err) + self.failUnlessIn("NotEnoughSharesError: ", err) + self.failUnless(in_complete_msg in err or in_pending_msg in err, + err) + self.failIf(os.path.exists(targetf)) + d.addCallback(_check2) return d - def test_mutable_unlinked(self): - # FILECAP = `echo DATA | tahoe put --mutable` - # tahoe get FILECAP, compare against DATA - # echo DATA2 | tahoe put - FILECAP - # tahoe get FILECAP, compare against DATA2 - # tahoe put file.txt FILECAP - self.basedir = "cli/Put/mutable_unlinked" + def test_broken_socket(self): + # When the http connection breaks (such as when node.url is overwritten + # by a confused user), a user friendly error message should be printed. + self.basedir = "cli/Errors/test_broken_socket" self.set_up_grid() - DATA = "data" * 100 - DATA2 = "two" * 100 - rel_fn = os.path.join(self.basedir, "DATAFILE") - DATA3 = "three" * 100 - fileutil.write(rel_fn, DATA3) - - d = self.do_cli("put", "--mutable", stdin=DATA) - def _created(res): - (rc, stdout, stderr) = res - self.failUnless("waiting for file data on stdin.." in stderr) - self.failUnless("200 OK" in stderr) - self.filecap = stdout - self.failUnless(self.filecap.startswith("URI:SSK:")) - d.addCallback(_created) - d.addCallback(lambda res: self.do_cli("get", self.filecap)) - d.addCallback(lambda (rc,out,err): self.failUnlessEqual(out, DATA)) - - d.addCallback(lambda res: self.do_cli("put", "-", self.filecap, stdin=DATA2)) - def _replaced(res): - (rc, stdout, stderr) = res - self.failUnless("waiting for file data on stdin.." in stderr) - self.failUnless("200 OK" in stderr) - self.failUnlessEqual(self.filecap, stdout) - d.addCallback(_replaced) - d.addCallback(lambda res: self.do_cli("get", self.filecap)) - d.addCallback(lambda (rc,out,err): self.failUnlessEqual(out, DATA2)) - - d.addCallback(lambda res: self.do_cli("put", rel_fn, self.filecap)) - def _replaced2(res): - (rc, stdout, stderr) = res - self.failUnless("200 OK" in stderr) - self.failUnlessEqual(self.filecap, stdout) - d.addCallback(_replaced2) - d.addCallback(lambda res: self.do_cli("get", self.filecap)) - d.addCallback(lambda (rc,out,err): self.failUnlessEqual(out, DATA3)) + # Simulate a connection error + def _socket_error(*args, **kwargs): + raise socket_error('test error') + self.patch(allmydata.scripts.common_http.httplib.HTTPConnection, + "endheaders", _socket_error) + d = self.do_cli("mkdir") + def _check_invalid((rc,stdout,stderr)): + self.failIfEqual(rc, 0) + self.failUnlessIn("Error trying to connect to http://127.0.0.1", stderr) + d.addCallback(_check_invalid) return d - def test_mutable(self): - # echo DATA1 | tahoe put --mutable - uploaded.txt - # echo DATA2 | tahoe put - uploaded.txt # should modify-in-place - # tahoe get uploaded.txt, compare against DATA2 - self.basedir = "cli/Put/mutable" +class Get(GridTestMixin, CLITestMixin, unittest.TestCase): + def test_get_without_alias(self): + # 'tahoe get' should output a useful error message when invoked + # without an explicit alias and when the default 'tahoe' alias + # hasn't been created yet. + self.basedir = "cli/Get/get_without_alias" self.set_up_grid() - - DATA1 = "data" * 100 - fn1 = os.path.join(self.basedir, "DATA1") - fileutil.write(fn1, DATA1) - DATA2 = "two" * 100 - fn2 = os.path.join(self.basedir, "DATA2") - fileutil.write(fn2, DATA2) - - d = self.do_cli("create-alias", "tahoe") - d.addCallback(lambda res: - self.do_cli("put", "--mutable", fn1, "tahoe:uploaded.txt")) - d.addCallback(lambda res: - self.do_cli("put", fn2, "tahoe:uploaded.txt")) - d.addCallback(lambda res: - self.do_cli("get", "tahoe:uploaded.txt")) - d.addCallback(lambda (rc,out,err): self.failUnlessEqual(out, DATA2)) + d = self.do_cli('get', 'file') + def _check((rc, out, err)): + self.failUnlessReallyEqual(rc, 1) + self.failUnlessIn("error:", err) + self.failUnlessReallyEqual(out, "") + d.addCallback(_check) return d - def test_put_with_nonexistent_alias(self): - # when invoked with an alias that doesn't exist, 'tahoe put' - # should output a useful error message, not a stack trace - self.basedir = "cli/Put/put_with_nonexistent_alias" + def test_get_with_nonexistent_alias(self): + # 'tahoe get' should output a useful error message when invoked with + # an explicit alias that doesn't exist. + self.basedir = "cli/Get/get_with_nonexistent_alias" self.set_up_grid() - d = self.do_cli("put", "somefile", "fake:afile") + d = self.do_cli("get", "nonexistent:file") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) + self.failUnlessIn("nonexistent", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) return d - def test_immutable_from_file_unicode(self): - skip_non_unicode_stdout() - - # tahoe put file.txt "à trier.txt" - self.basedir = os.path.dirname(self.mktemp()) - self.set_up_grid() - - rel_fn = os.path.join(self.basedir, "DATAFILE") - # we make the file small enough to fit in a LIT file, for speed - DATA = "short file" - f = open(rel_fn, "w") - f.write(DATA) - f.close() - - d = self.do_cli("create-alias", "tahoe") - - d.addCallback(lambda res: - self.do_cli("put", rel_fn, "à trier.txt")) - def _uploaded((rc,stdout,stderr)): - readcap = stdout.strip() - self.failUnless(readcap.startswith("URI:LIT:")) - self.failUnless("201 Created" in stderr, stderr) - self.readcap = readcap - d.addCallback(_uploaded) - - d.addCallback(lambda res: - self.do_cli("get", "tahoe:à trier.txt")) - d.addCallback(lambda (rc,stdout,stderr): - self.failUnlessEqual(stdout, DATA)) - - return d - -class List(GridTestMixin, CLITestMixin, unittest.TestCase): - def test_list(self): - self.basedir = "cli/List/list" - self.set_up_grid() - c0 = self.g.clients[0] - small = "small" - d = c0.create_dirnode() - def _stash_root_and_create_file(n): - self.rootnode = n - self.rooturi = n.get_uri() - return n.add_file(u"gööd", upload.Data(small, convergence="")) - d.addCallback(_stash_root_and_create_file) - def _stash_goodcap(n): - self.goodcap = n.get_uri() - d.addCallback(_stash_goodcap) - d.addCallback(lambda ign: self.rootnode.create_subdirectory(u"1share")) - d.addCallback(lambda n: - self.delete_shares_numbered(n.get_uri(), range(1,10))) - d.addCallback(lambda ign: self.rootnode.create_subdirectory(u"0share")) - d.addCallback(lambda n: - self.delete_shares_numbered(n.get_uri(), range(0,10))) - d.addCallback(lambda ign: - self.do_cli("add-alias", "tahoe", self.rooturi)) - d.addCallback(lambda ign: self.do_cli("ls")) - def _check1((rc,out,err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.failUnlessEqual(out.splitlines(), ["0share", "1share", "gööd"]) - d.addCallback(_check1) - d.addCallback(lambda ign: self.do_cli("ls", "missing")) - def _check2((rc,out,err)): - self.failIfEqual(rc, 0) - self.failUnlessEqual(err.strip(), "No such file or directory") - self.failUnlessEqual(out, "") - d.addCallback(_check2) - d.addCallback(lambda ign: self.do_cli("ls", "1share")) - def _check3((rc,out,err)): - self.failIfEqual(rc, 0) - self.failUnlessIn("Error during GET: 410 Gone ", err) - self.failUnlessIn("UnrecoverableFileError:", err) - self.failUnlessIn("could not be retrieved, because there were " - "insufficient good shares.", err) - self.failUnlessEqual(out, "") - d.addCallback(_check3) - d.addCallback(lambda ign: self.do_cli("ls", "0share")) - d.addCallback(_check3) - def _check4((rc, out, err)): - # listing a file (as dir/filename) should have the edge metadata, - # including the filename - self.failUnlessEqual(rc, 0) - self.failUnlessIn("gööd", out) - self.failIfIn("-r-- %d -" % len(small), out, - "trailing hyphen means unknown date") - d.addCallback(lambda ign: self.do_cli("ls", "-l", "gööd")) - d.addCallback(_check4) - # listing a file as $DIRCAP/filename should work just like dir/filename - d.addCallback(lambda ign: self.do_cli("ls", "-l", self.rooturi + "/gööd")) - d.addCallback(_check4) - # and similarly for $DIRCAP:./filename - d.addCallback(lambda ign: self.do_cli("ls", "-l", self.rooturi + ":./gööd")) - d.addCallback(_check4) - def _check5((rc, out, err)): - # listing a raw filecap should not explode, but it will have no - # metadata, just the size - self.failUnlessEqual(rc, 0) - self.failUnlessEqual("-r-- %d -" % len(small), out.strip()) - d.addCallback(lambda ign: self.do_cli("ls", "-l", self.goodcap)) - d.addCallback(_check5) - unknown_immcap = "imm.URI:unknown" - def _create_unknown(ign): - nm = c0.nodemaker - kids = {u"unknownchild-imm": (nm.create_from_cap(unknown_immcap), {})} - return self.rootnode.create_subdirectory(u"unknown", initial_children=kids, - mutable=False) - d.addCallback(_create_unknown) - def _check6((rc, out, err)): - # listing a directory referencing an unknown object should print - # an extra message to stderr - self.failUnlessEqual(rc, 0) - self.failUnlessIn("?r-- ? - unknownchild-imm\n", out) - self.failUnlessIn("included unknown objects", err) - d.addCallback(lambda ign: self.do_cli("ls", "-l", "unknown")) - d.addCallback(_check6) - def _check7((rc, out, err)): - # listing an unknown cap directly should print an extra message - # to stderr (currently this only works if the URI starts with 'URI:' - # after any 'ro.' or 'imm.' prefix, otherwise it will be confused - # with an alias). - self.failUnlessEqual(rc, 0) - self.failUnlessIn("?r-- ? -\n", out) - self.failUnlessIn("included unknown objects", err) - d.addCallback(lambda ign: self.do_cli("ls", "-l", unknown_immcap)) - d.addCallback(_check7) - return d - - def test_list_without_alias(self): - # doing just 'tahoe ls' without specifying an alias or first - # doing 'tahoe create-alias tahoe' should fail gracefully. - self.basedir = "cli/List/list_without_alias" +class Manifest(GridTestMixin, CLITestMixin, unittest.TestCase): + def test_manifest_without_alias(self): + # 'tahoe manifest' should output a useful error message when invoked + # without an explicit alias when the default 'tahoe' alias is + # missing. + self.basedir = "cli/Manifest/manifest_without_alias" self.set_up_grid() - d = self.do_cli("ls") + d = self.do_cli("manifest") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) return d - def test_list_with_nonexistent_alias(self): - # doing 'tahoe ls' while specifying an alias that doesn't already - # exist should fail with an informative error message - self.basedir = "cli/List/list_with_nonexistent_alias" + def test_manifest_with_nonexistent_alias(self): + # 'tahoe manifest' should output a useful error message when invoked + # with an explicit alias that doesn't exist. + self.basedir = "cli/Manifest/manifest_with_nonexistent_alias" self.set_up_grid() - d = self.do_cli("ls", "nonexistent:") + d = self.do_cli("manifest", "nonexistent:") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) self.failUnlessIn("nonexistent", err) - d.addCallback(_check) - return d - - -class Mv(GridTestMixin, CLITestMixin, unittest.TestCase): - def test_mv_behavior(self): - self.basedir = "cli/Mv/mv_behavior" - self.set_up_grid() - fn1 = os.path.join(self.basedir, "file1") - DATA1 = "Nuclear launch codes" - fileutil.write(fn1, DATA1) - fn2 = os.path.join(self.basedir, "file2") - DATA2 = "UML diagrams" - fileutil.write(fn2, DATA2) - # copy both files to the grid - d = self.do_cli("create-alias", "tahoe") - d.addCallback(lambda res: - self.do_cli("cp", fn1, "tahoe:")) - d.addCallback(lambda res: - self.do_cli("cp", fn2, "tahoe:")) - - # do mv file1 file3 - # (we should be able to rename files) - d.addCallback(lambda res: - self.do_cli("mv", "tahoe:file1", "tahoe:file3")) - d.addCallback(lambda (rc, out, err): - self.failUnlessIn("OK", out, "mv didn't rename a file")) - - # do mv file3 file2 - # (This should succeed without issue) - d.addCallback(lambda res: - self.do_cli("mv", "tahoe:file3", "tahoe:file2")) - # Out should contain "OK" to show that the transfer worked. - d.addCallback(lambda (rc,out,err): - self.failUnlessIn("OK", out, "mv didn't output OK after mving")) - - # Next, make a remote directory. - d.addCallback(lambda res: - self.do_cli("mkdir", "tahoe:directory")) - - # mv file2 directory - # (should fail with a descriptive error message; the CLI mv - # client should support this) - d.addCallback(lambda res: - self.do_cli("mv", "tahoe:file2", "tahoe:directory")) - d.addCallback(lambda (rc, out, err): - self.failUnlessIn( - "Error: You can't overwrite a directory with a file", err, - "mv shouldn't overwrite directories" )) - - # mv file2 directory/ - # (should succeed by making file2 a child node of directory) - d.addCallback(lambda res: - self.do_cli("mv", "tahoe:file2", "tahoe:directory/")) - # We should see an "OK"... - d.addCallback(lambda (rc, out, err): - self.failUnlessIn("OK", out, - "mv didn't mv a file into a directory")) - # ... and be able to GET the file - d.addCallback(lambda res: - self.do_cli("get", "tahoe:directory/file2", self.basedir + "new")) - d.addCallback(lambda (rc, out, err): - self.failUnless(os.path.exists(self.basedir + "new"), - "mv didn't write the destination file")) - # ... and not find the file where it was before. - d.addCallback(lambda res: - self.do_cli("get", "tahoe:file2", "file2")) - d.addCallback(lambda (rc, out, err): - self.failUnlessIn("404", err, - "mv left the source file intact")) - - # Let's build: - # directory/directory2/some_file - # directory3 - d.addCallback(lambda res: - self.do_cli("mkdir", "tahoe:directory/directory2")) - d.addCallback(lambda res: - self.do_cli("cp", fn2, "tahoe:directory/directory2/some_file")) - d.addCallback(lambda res: - self.do_cli("mkdir", "tahoe:directory3")) - - # Let's now try to mv directory/directory2/some_file to - # directory3/some_file - d.addCallback(lambda res: - self.do_cli("mv", "tahoe:directory/directory2/some_file", - "tahoe:directory3/")) - # We should have just some_file in tahoe:directory3 - d.addCallback(lambda res: - self.do_cli("get", "tahoe:directory3/some_file", "some_file")) - d.addCallback(lambda (rc, out, err): - self.failUnless("404" not in err, - "mv didn't handle nested directories correctly")) - d.addCallback(lambda res: - self.do_cli("get", "tahoe:directory3/directory", "directory")) - d.addCallback(lambda (rc, out, err): - self.failUnlessIn("404", err, - "mv moved the wrong thing")) - return d - - def test_mv_without_alias(self): - # doing 'tahoe mv' without explicitly specifying an alias or - # creating the default 'tahoe' alias should fail with a useful - # error message. - self.basedir = "cli/Mv/mv_without_alias" - self.set_up_grid() - d = self.do_cli("mv", "afile", "anotherfile") - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) - d.addCallback(_check) - # check to see that the validation extends to the - # target argument by making an alias that will work with the first - # one. - d.addCallback(lambda ign: self.do_cli("create-alias", "havasu")) - def _create_a_test_file(ign): - self.test_file_path = os.path.join(self.basedir, "afile") - f = open(self.test_file_path, "wb") - f.write("puppies" * 100) - f.close() - d.addCallback(_create_a_test_file) - d.addCallback(lambda ign: self.do_cli("put", self.test_file_path, - "havasu:afile")) - d.addCallback(lambda ign: self.do_cli("mv", "havasu:afile", - "anotherfile")) - d.addCallback(_check) - return d - - def test_mv_with_nonexistent_alias(self): - # doing 'tahoe mv' with an alias that doesn't exist should fail - # with an informative error message. - self.basedir = "cli/Mv/mv_with_nonexistent_alias" - self.set_up_grid() - d = self.do_cli("mv", "fake:afile", "fake:anotherfile") - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) - self.failUnlessIn("fake", err) - d.addCallback(_check) - # check to see that the validation extends to the - # target argument by making an alias that will work with the first - # one. - d.addCallback(lambda ign: self.do_cli("create-alias", "havasu")) - def _create_a_test_file(ign): - self.test_file_path = os.path.join(self.basedir, "afile") - f = open(self.test_file_path, "wb") - f.write("puppies" * 100) - f.close() - d.addCallback(_create_a_test_file) - d.addCallback(lambda ign: self.do_cli("put", self.test_file_path, - "havasu:afile")) - d.addCallback(lambda ign: self.do_cli("mv", "havasu:afile", - "fake:anotherfile")) - d.addCallback(_check) - return d - - -class Cp(GridTestMixin, CLITestMixin, unittest.TestCase): - - def test_not_enough_args(self): - o = cli.CpOptions() - self.failUnlessRaises(usage.UsageError, - o.parseOptions, ["onearg"]) - - def test_unicode_filename(self): - skip_non_unicode_fs() - skip_non_unicode_stdout() - - self.basedir = "cli/Cp/unicode_filename" - self.set_up_grid() - d = self.do_cli("create-alias", "tahoe") - - # Use unicode strings when calling os functions - fn1 = os.path.join(self.basedir, u"Ärtonwall") - DATA1 = "unicode file content" - fileutil.write(fn1, DATA1) - - d.addCallback(lambda res: self.do_cli("cp", fn1.encode('utf-8'), "tahoe:")) - - d.addCallback(lambda res: self.do_cli("get", "tahoe:Ärtonwall")) - d.addCallback(lambda (rc,out,err): self.failUnlessEqual(out, DATA1)) - - fn2 = os.path.join(self.basedir, u"Metallica") - DATA2 = "non-unicode file content" - fileutil.write(fn2, DATA2) - - d.addCallback(lambda res: self.do_cli("cp", fn2.encode('utf-8'), "tahoe:")) - - d.addCallback(lambda res: self.do_cli("get", "tahoe:Metallica")) - d.addCallback(lambda (rc,out,err): self.failUnlessEqual(out, DATA2)) - - d.addCallback(lambda res: self.do_cli("ls", "tahoe:")) - d.addCallback(lambda (rc,out,err): self.failUnlessEqual(out, "Metallica\nÄrtonwall\n")) - - return d - - def test_dangling_symlink_vs_recursion(self): - if not hasattr(os, 'symlink'): - raise unittest.SkipTest("There is no symlink on this platform.") - # cp -r on a directory containing a dangling symlink shouldn't assert - self.basedir = "cli/Cp/dangling_symlink_vs_recursion" - self.set_up_grid() - dn = os.path.join(self.basedir, "dir") - os.mkdir(dn) - fn = os.path.join(dn, "Fakebandica") - ln = os.path.join(dn, "link") - os.symlink(fn, ln) - - d = self.do_cli("create-alias", "tahoe") - d.addCallback(lambda res: self.do_cli("cp", "--recursive", - dn, "tahoe:")) - return d - - def test_copy_using_filecap(self): - self.basedir = "cli/Cp/test_copy_using_filecap" - self.set_up_grid() - outdir = os.path.join(self.basedir, "outdir") - os.mkdir(outdir) - fn1 = os.path.join(self.basedir, "Metallica") - fn2 = os.path.join(outdir, "Not Metallica") - fn3 = os.path.join(outdir, "test2") - DATA1 = "puppies" * 10000 - fileutil.write(fn1, DATA1) - - d = self.do_cli("create-alias", "tahoe") - d.addCallback(lambda ign: self.do_cli("put", fn1)) - def _put_file((rc, out, err)): - self.failUnlessEqual(rc, 0) - # keep track of the filecap - self.filecap = out.strip() - d.addCallback(_put_file) - - # Let's try copying this to the disk using the filecap - # cp FILECAP filename - d.addCallback(lambda ign: self.do_cli("cp", self.filecap, fn2)) - def _copy_file((rc, out, err)): - self.failUnlessEqual(rc, 0) - results = fileutil.read(fn2) - self.failUnlessEqual(results, DATA1) - d.addCallback(_copy_file) - - # Test with ./ (see #761) - # cp FILECAP localdir - d.addCallback(lambda ign: self.do_cli("cp", self.filecap, outdir)) - def _resp((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error: you must specify a destination filename", - err) - d.addCallback(_resp) - - # Create a directory, linked at tahoe:test - d.addCallback(lambda ign: self.do_cli("mkdir", "tahoe:test")) - def _get_dir((rc, out, err)): - self.failUnlessEqual(rc, 0) - self.dircap = out.strip() - d.addCallback(_get_dir) - - # Upload a file to the directory - d.addCallback(lambda ign: - self.do_cli("put", fn1, "tahoe:test/test_file")) - d.addCallback(lambda (rc, out, err): self.failUnlessEqual(rc, 0)) - - # cp DIRCAP/filename localdir - d.addCallback(lambda ign: - self.do_cli("cp", self.dircap + "/test_file", outdir)) - def _get_resp((rc, out, err)): - self.failUnlessEqual(rc, 0) - results = fileutil.read(os.path.join(outdir, "test_file")) - self.failUnlessEqual(results, DATA1) - d.addCallback(_get_resp) - - # cp -r DIRCAP/filename filename2 - d.addCallback(lambda ign: - self.do_cli("cp", self.dircap + "/test_file", fn3)) - def _get_resp2((rc, out, err)): - self.failUnlessEqual(rc, 0) - results = fileutil.read(fn3) - self.failUnlessEqual(results, DATA1) - d.addCallback(_get_resp2) - return d - - def test_cp_with_nonexistent_alias(self): - # when invoked with an alias or aliases that don't exist, 'tahoe cp' - # should output a sensible error message rather than a stack trace. - self.basedir = "cli/Cp/cp_with_nonexistent_alias" - self.set_up_grid() - d = self.do_cli("cp", "fake:file1", "fake:file2") - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) - d.addCallback(_check) - # 'tahoe cp' actually processes the target argument first, so we need - # to check to make sure that validation extends to the source - # argument. - d.addCallback(lambda ign: self.do_cli("create-alias", "tahoe")) - d.addCallback(lambda ign: self.do_cli("cp", "fake:file1", - "tahoe:file2")) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) return d class Mkdir(GridTestMixin, CLITestMixin, unittest.TestCase): - def test_unicode_mkdir(self): + def test_mkdir(self): self.basedir = os.path.dirname(self.mktemp()) self.set_up_grid() d = self.do_cli("create-alias", "tahoe") - d.addCallback(lambda res: self.do_cli("mkdir", "tahoe:Motörhead")) - - return d - - -class Backup(GridTestMixin, CLITestMixin, StallMixin, unittest.TestCase): - - def writeto(self, path, data): - full_path = os.path.join(self.basedir, "home", path) - fileutil.make_dirs(os.path.dirname(full_path)) - fileutil.write(full_path, data) - - def count_output(self, out): - mo = re.search(r"(\d)+ files uploaded \((\d+) reused\), " - "(\d)+ files skipped, " - "(\d+) directories created \((\d+) reused\), " - "(\d+) directories skipped", out) - return [int(s) for s in mo.groups()] - - def count_output2(self, out): - mo = re.search(r"(\d)+ files checked, (\d+) directories checked", out) - return [int(s) for s in mo.groups()] - - def test_backup(self): - self.basedir = "cli/Backup/backup" - self.set_up_grid() - - # is the backupdb available? If so, we test that a second backup does - # not create new directories. - hush = StringIO() - have_bdb = backupdb.get_backupdb(os.path.join(self.basedir, "dbtest"), - hush) - - # create a small local directory with a couple of files - source = os.path.join(self.basedir, "home") - fileutil.make_dirs(os.path.join(source, "empty")) - self.writeto("parent/subdir/foo.txt", "foo") - self.writeto("parent/subdir/bar.txt", "bar\n" * 1000) - self.writeto("parent/blah.txt", "blah") - - def do_backup(verbose=False): - cmd = ["backup"] - if verbose: - cmd.append("--verbose") - cmd.append(source) - cmd.append("tahoe:backups") - return self.do_cli(*cmd) - - d = self.do_cli("create-alias", "tahoe") - - if not have_bdb: - d.addCallback(lambda res: self.do_cli("backup", source, "tahoe:backups")) - def _should_complain((rc, out, err)): - self.failUnless("I was unable to import a python sqlite library" in err, err) - d.addCallback(_should_complain) - d.addCallback(self.stall, 1.1) # make sure the backups get distinct timestamps - - d.addCallback(lambda res: do_backup()) - def _check0((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - fu, fr, fs, dc, dr, ds = self.count_output(out) - # foo.txt, bar.txt, blah.txt - self.failUnlessEqual(fu, 3) - self.failUnlessEqual(fr, 0) - self.failUnlessEqual(fs, 0) - # empty, home, home/parent, home/parent/subdir - self.failUnlessEqual(dc, 4) - self.failUnlessEqual(dr, 0) - self.failUnlessEqual(ds, 0) - d.addCallback(_check0) - - d.addCallback(lambda res: self.do_cli("ls", "--uri", "tahoe:backups")) - def _check1((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.split("\n") - children = dict([line.split() for line in lines if line]) - latest_uri = children["Latest"] - self.failUnless(latest_uri.startswith("URI:DIR2-CHK:"), latest_uri) - childnames = children.keys() - self.failUnlessEqual(sorted(childnames), ["Archives", "Latest"]) - d.addCallback(_check1) - d.addCallback(lambda res: self.do_cli("ls", "tahoe:backups/Latest")) - def _check2((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.failUnlessEqual(sorted(out.split()), ["empty", "parent"]) - d.addCallback(_check2) - d.addCallback(lambda res: self.do_cli("ls", "tahoe:backups/Latest/empty")) - def _check2a((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.failUnlessEqual(out.strip(), "") - d.addCallback(_check2a) - d.addCallback(lambda res: self.do_cli("get", "tahoe:backups/Latest/parent/subdir/foo.txt")) - def _check3((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.failUnlessEqual(out, "foo") - d.addCallback(_check3) - d.addCallback(lambda res: self.do_cli("ls", "tahoe:backups/Archives")) - def _check4((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.old_archives = out.split() - self.failUnlessEqual(len(self.old_archives), 1) - d.addCallback(_check4) - - - d.addCallback(self.stall, 1.1) - d.addCallback(lambda res: do_backup()) - def _check4a((rc, out, err)): - # second backup should reuse everything, if the backupdb is - # available - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - if have_bdb: - fu, fr, fs, dc, dr, ds = self.count_output(out) - # foo.txt, bar.txt, blah.txt - self.failUnlessEqual(fu, 0) - self.failUnlessEqual(fr, 3) - self.failUnlessEqual(fs, 0) - # empty, home, home/parent, home/parent/subdir - self.failUnlessEqual(dc, 0) - self.failUnlessEqual(dr, 4) - self.failUnlessEqual(ds, 0) - d.addCallback(_check4a) - - if have_bdb: - # sneak into the backupdb, crank back the "last checked" - # timestamp to force a check on all files - def _reset_last_checked(res): - dbfile = os.path.join(self.get_clientdir(), - "private", "backupdb.sqlite") - self.failUnless(os.path.exists(dbfile), dbfile) - bdb = backupdb.get_backupdb(dbfile) - bdb.cursor.execute("UPDATE last_upload SET last_checked=0") - bdb.cursor.execute("UPDATE directories SET last_checked=0") - bdb.connection.commit() - - d.addCallback(_reset_last_checked) - - d.addCallback(self.stall, 1.1) - d.addCallback(lambda res: do_backup(verbose=True)) - def _check4b((rc, out, err)): - # we should check all files, and re-use all of them. None of - # the directories should have been changed, so we should - # re-use all of them too. - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - fu, fr, fs, dc, dr, ds = self.count_output(out) - fchecked, dchecked = self.count_output2(out) - self.failUnlessEqual(fchecked, 3) - self.failUnlessEqual(fu, 0) - self.failUnlessEqual(fr, 3) - self.failUnlessEqual(fs, 0) - self.failUnlessEqual(dchecked, 4) - self.failUnlessEqual(dc, 0) - self.failUnlessEqual(dr, 4) - self.failUnlessEqual(ds, 0) - d.addCallback(_check4b) - - d.addCallback(lambda res: self.do_cli("ls", "tahoe:backups/Archives")) - def _check5((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.new_archives = out.split() - expected_new = 2 - if have_bdb: - expected_new += 1 - self.failUnlessEqual(len(self.new_archives), expected_new, out) - # the original backup should still be the oldest (i.e. sorts - # alphabetically towards the beginning) - self.failUnlessEqual(sorted(self.new_archives)[0], - self.old_archives[0]) - d.addCallback(_check5) - - d.addCallback(self.stall, 1.1) - def _modify(res): - self.writeto("parent/subdir/foo.txt", "FOOF!") - # and turn a file into a directory - os.unlink(os.path.join(source, "parent/blah.txt")) - os.mkdir(os.path.join(source, "parent/blah.txt")) - self.writeto("parent/blah.txt/surprise file", "surprise") - self.writeto("parent/blah.txt/surprisedir/subfile", "surprise") - # turn a directory into a file - os.rmdir(os.path.join(source, "empty")) - self.writeto("empty", "imagine nothing being here") - return do_backup() - d.addCallback(_modify) - def _check5a((rc, out, err)): - # second backup should reuse bar.txt (if backupdb is available), - # and upload the rest. None of the directories can be reused. - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - if have_bdb: - fu, fr, fs, dc, dr, ds = self.count_output(out) - # new foo.txt, surprise file, subfile, empty - self.failUnlessEqual(fu, 4) - # old bar.txt - self.failUnlessEqual(fr, 1) - self.failUnlessEqual(fs, 0) - # home, parent, subdir, blah.txt, surprisedir - self.failUnlessEqual(dc, 5) - self.failUnlessEqual(dr, 0) - self.failUnlessEqual(ds, 0) - d.addCallback(_check5a) - d.addCallback(lambda res: self.do_cli("ls", "tahoe:backups/Archives")) - def _check6((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.new_archives = out.split() - expected_new = 3 - if have_bdb: - expected_new += 1 - self.failUnlessEqual(len(self.new_archives), expected_new) - self.failUnlessEqual(sorted(self.new_archives)[0], - self.old_archives[0]) - d.addCallback(_check6) - d.addCallback(lambda res: self.do_cli("get", "tahoe:backups/Latest/parent/subdir/foo.txt")) - def _check7((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.failUnlessEqual(out, "FOOF!") - # the old snapshot should not be modified - return self.do_cli("get", "tahoe:backups/Archives/%s/parent/subdir/foo.txt" % self.old_archives[0]) - d.addCallback(_check7) - def _check8((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - self.failUnlessEqual(out, "foo") - d.addCallback(_check8) + d.addCallback(lambda res: self.do_cli("mkdir", "test")) + def _check((rc, out, err)): + self.failUnlessReallyEqual(rc, 0) + self.failUnlessReallyEqual(err, "") + self.failUnlessIn("URI:", out) + d.addCallback(_check) return d - # on our old dapper buildslave, this test takes a long time (usually - # 130s), so we have to bump up the default 120s timeout. The create-alias - # and initial backup alone take 60s, probably because of the handful of - # dirnodes being created (RSA key generation). The backup between check4 - # and check4a takes 6s, as does the backup before check4b. - test_backup.timeout = 3000 - - def test_exclude_options(self): - root_listdir = ('lib.a', '_darcs', 'subdir', 'nice_doc.lyx') - subdir_listdir = ('another_doc.lyx', 'run_snake_run.py', 'CVS', '.svn', '_darcs') - basedir = "cli/Backup/exclude_options" - fileutil.make_dirs(basedir) - nodeurl_path = os.path.join(basedir, 'node.url') - fileutil.write(nodeurl_path, 'http://example.net:2357/') - - def _check_filtering(filtered, all, included, excluded): - filtered = set(filtered) - all = set(all) - included = set(included) - excluded = set(excluded) - self.failUnlessEqual(filtered, included) - self.failUnlessEqual(all.difference(filtered), excluded) - - # test simple exclude - backup_options = cli.BackupOptions() - backup_options.parseOptions(['--exclude', '*lyx', '--node-directory', - basedir, 'from', 'to']) - filtered = list(backup_options.filter_listdir(root_listdir)) - _check_filtering(filtered, root_listdir, ('lib.a', '_darcs', 'subdir'), - ('nice_doc.lyx',)) - # multiple exclude - backup_options = cli.BackupOptions() - backup_options.parseOptions(['--exclude', '*lyx', '--exclude', 'lib.?', '--node-directory', - basedir, 'from', 'to']) - filtered = list(backup_options.filter_listdir(root_listdir)) - _check_filtering(filtered, root_listdir, ('_darcs', 'subdir'), - ('nice_doc.lyx', 'lib.a')) - # vcs metadata exclusion - backup_options = cli.BackupOptions() - backup_options.parseOptions(['--exclude-vcs', '--node-directory', - basedir, 'from', 'to']) - filtered = list(backup_options.filter_listdir(subdir_listdir)) - _check_filtering(filtered, subdir_listdir, ('another_doc.lyx', 'run_snake_run.py',), - ('CVS', '.svn', '_darcs')) - # read exclude patterns from file - exclusion_string = "_darcs\n*py\n.svn" - excl_filepath = os.path.join(basedir, 'exclusion') - fileutil.write(excl_filepath, exclusion_string) - backup_options = cli.BackupOptions() - backup_options.parseOptions(['--exclude-from', excl_filepath, '--node-directory', - basedir, 'from', 'to']) - filtered = list(backup_options.filter_listdir(subdir_listdir)) - _check_filtering(filtered, subdir_listdir, ('another_doc.lyx', 'CVS'), - ('.svn', '_darcs', 'run_snake_run.py')) - # text BackupConfigurationError - self.failUnlessRaises(cli.BackupConfigurationError, - backup_options.parseOptions, - ['--exclude-from', excl_filepath + '.no', '--node-directory', - basedir, 'from', 'to']) - - # test that an iterator works too - backup_options = cli.BackupOptions() - backup_options.parseOptions(['--exclude', '*lyx', '--node-directory', - basedir, 'from', 'to']) - filtered = list(backup_options.filter_listdir(iter(root_listdir))) - _check_filtering(filtered, root_listdir, ('lib.a', '_darcs', 'subdir'), - ('nice_doc.lyx',)) - - def test_ignore_symlinks(self): - if not hasattr(os, 'symlink'): - raise unittest.SkipTest("There is no symlink on this platform.") - + def test_mkdir_mutable_type(self): self.basedir = os.path.dirname(self.mktemp()) self.set_up_grid() - - source = os.path.join(self.basedir, "home") - self.writeto("foo.txt", "foo") - os.symlink(os.path.join(source, "foo.txt"), os.path.join(source, "foo2.txt")) - d = self.do_cli("create-alias", "tahoe") - d.addCallback(lambda res: self.do_cli("backup", "--verbose", source, "tahoe:test")) - - def _check((rc, out, err)): - self.failUnlessEqual(rc, 2) - foo2 = os.path.join(source, "foo2.txt") - self.failUnlessEqual(err, "WARNING: cannot backup symlink %s\n" % foo2) - - fu, fr, fs, dc, dr, ds = self.count_output(out) - # foo.txt - self.failUnlessEqual(fu, 1) - self.failUnlessEqual(fr, 0) - # foo2.txt - self.failUnlessEqual(fs, 1) - # home - self.failUnlessEqual(dc, 1) - self.failUnlessEqual(dr, 0) - self.failUnlessEqual(ds, 0) - - d.addCallback(_check) + def _check((rc, out, err), st): + self.failUnlessReallyEqual(rc, 0) + self.failUnlessReallyEqual(err, "") + self.failUnlessIn(st, out) + return out + def _mkdir(ign, mutable_type, uri_prefix, dirname): + d2 = self.do_cli("mkdir", "--format="+mutable_type, dirname) + d2.addCallback(_check, uri_prefix) + def _stash_filecap(cap): + u = uri.from_string(cap) + fn_uri = u.get_filenode_cap() + self._filecap = fn_uri.to_string() + d2.addCallback(_stash_filecap) + d2.addCallback(lambda ign: self.do_cli("ls", "--json", dirname)) + d2.addCallback(_check, uri_prefix) + d2.addCallback(lambda ign: self.do_cli("ls", "--json", self._filecap)) + d2.addCallback(_check, '"format": "%s"' % (mutable_type.upper(),)) + return d2 + + d.addCallback(_mkdir, "sdmf", "URI:DIR2", "tahoe:foo") + d.addCallback(_mkdir, "SDMF", "URI:DIR2", "tahoe:foo2") + d.addCallback(_mkdir, "mdmf", "URI:DIR2-MDMF", "tahoe:bar") + d.addCallback(_mkdir, "MDMF", "URI:DIR2-MDMF", "tahoe:bar2") return d - def test_ignore_unreadable_file(self): + def test_mkdir_mutable_type_unlinked(self): self.basedir = os.path.dirname(self.mktemp()) self.set_up_grid() - - source = os.path.join(self.basedir, "home") - self.writeto("foo.txt", "foo") - os.chmod(os.path.join(source, "foo.txt"), 0000) - - d = self.do_cli("create-alias", "tahoe") - d.addCallback(lambda res: self.do_cli("backup", source, "tahoe:test")) - - def _check((rc, out, err)): - self.failUnlessEqual(rc, 2) - self.failUnlessEqual(err, "WARNING: permission denied on file %s\n" % os.path.join(source, "foo.txt")) - - fu, fr, fs, dc, dr, ds = self.count_output(out) - self.failUnlessEqual(fu, 0) - self.failUnlessEqual(fr, 0) - # foo.txt - self.failUnlessEqual(fs, 1) - # home - self.failUnlessEqual(dc, 1) - self.failUnlessEqual(dr, 0) - self.failUnlessEqual(ds, 0) - d.addCallback(_check) - - # This is necessary for the temp files to be correctly removed - def _cleanup(self): - os.chmod(os.path.join(source, "foo.txt"), 0644) - d.addCallback(_cleanup) - d.addErrback(_cleanup) - + d = self.do_cli("mkdir", "--format=SDMF") + def _check((rc, out, err), st): + self.failUnlessReallyEqual(rc, 0) + self.failUnlessReallyEqual(err, "") + self.failUnlessIn(st, out) + return out + d.addCallback(_check, "URI:DIR2") + def _stash_dircap(cap): + self._dircap = cap + # Now we're going to feed the cap into uri.from_string... + u = uri.from_string(cap) + # ...grab the underlying filenode uri. + fn_uri = u.get_filenode_cap() + # ...and stash that. + self._filecap = fn_uri.to_string() + d.addCallback(_stash_dircap) + d.addCallback(lambda res: self.do_cli("ls", "--json", + self._filecap)) + d.addCallback(_check, '"format": "SDMF"') + d.addCallback(lambda res: self.do_cli("mkdir", "--format=MDMF")) + d.addCallback(_check, "URI:DIR2-MDMF") + d.addCallback(_stash_dircap) + d.addCallback(lambda res: self.do_cli("ls", "--json", + self._filecap)) + d.addCallback(_check, '"format": "MDMF"') return d - def test_ignore_unreadable_directory(self): + def test_mkdir_bad_mutable_type(self): + o = cli.MakeDirectoryOptions() + self.failUnlessRaises(usage.UsageError, + o.parseOptions, + ["--format=LDMF"]) + + def test_mkdir_unicode(self): self.basedir = os.path.dirname(self.mktemp()) self.set_up_grid() - source = os.path.join(self.basedir, "home") - os.mkdir(source) - os.mkdir(os.path.join(source, "test")) - os.chmod(os.path.join(source, "test"), 0000) + try: + motorhead_arg = u"tahoe:Mot\u00F6rhead".encode(get_io_encoding()) + except UnicodeEncodeError: + raise unittest.SkipTest("A non-ASCII command argument could not be encoded on this platform.") d = self.do_cli("create-alias", "tahoe") - d.addCallback(lambda res: self.do_cli("backup", source, "tahoe:test")) - + d.addCallback(lambda res: self.do_cli("mkdir", motorhead_arg)) def _check((rc, out, err)): - self.failUnlessEqual(rc, 2) - self.failUnlessEqual(err, "WARNING: permission denied on directory %s\n" % os.path.join(source, "test")) - - fu, fr, fs, dc, dr, ds = self.count_output(out) - self.failUnlessEqual(fu, 0) - self.failUnlessEqual(fr, 0) - self.failUnlessEqual(fs, 0) - # home, test - self.failUnlessEqual(dc, 2) - self.failUnlessEqual(dr, 0) - # test - self.failUnlessEqual(ds, 1) + self.failUnlessReallyEqual(rc, 0) + self.failUnlessReallyEqual(err, "") + self.failUnlessIn("URI:", out) d.addCallback(_check) - # This is necessary for the temp files to be correctly removed - def _cleanup(self): - os.chmod(os.path.join(source, "test"), 0655) - d.addCallback(_cleanup) - d.addErrback(_cleanup) - return d - - def test_backup_without_alias(self): - # 'tahoe backup' should output a sensible error message when invoked - # without an alias instead of a stack trace. - self.basedir = os.path.dirname(self.mktemp()) - self.set_up_grid() - source = os.path.join(self.basedir, "file1") - d = self.do_cli('backup', source, source) - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) - d.addCallback(_check) return d - def test_backup_with_nonexistent_alias(self): - # 'tahoe backup' should output a sensible error message when invoked - # with a nonexistent alias. - self.basedir = os.path.dirname(self.mktemp()) + def test_mkdir_with_nonexistent_alias(self): + # when invoked with an alias that doesn't exist, 'tahoe mkdir' should + # output a sensible error message rather than a stack trace. + self.basedir = "cli/Mkdir/mkdir_with_nonexistent_alias" self.set_up_grid() - source = os.path.join(self.basedir, "file1") - d = self.do_cli("backup", source, "nonexistent:" + source) + d = self.do_cli("mkdir", "havasu:") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) - self.failUnlessIn("nonexistent", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) return d -class Check(GridTestMixin, CLITestMixin, unittest.TestCase): +class Unlink(GridTestMixin, CLITestMixin, unittest.TestCase): + command = "unlink" - def test_check(self): - self.basedir = "cli/Check/check" - self.set_up_grid() - c0 = self.g.clients[0] - DATA = "data" * 100 - d = c0.create_mutable_file(DATA) - def _stash_uri(n): - self.uri = n.get_uri() - d.addCallback(_stash_uri) - - d.addCallback(lambda ign: self.do_cli("check", self.uri)) - def _check1((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnless("Summary: Healthy" in lines, out) - self.failUnless(" good-shares: 10 (encoding is 3-of-10)" in lines, out) - d.addCallback(_check1) - - d.addCallback(lambda ign: self.do_cli("check", "--raw", self.uri)) - def _check2((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - data = simplejson.loads(out) - self.failUnlessEqual(data["summary"], "Healthy") - d.addCallback(_check2) - - def _clobber_shares(ignored): - # delete one, corrupt a second - shares = self.find_shares(self.uri) - self.failUnlessEqual(len(shares), 10) - os.unlink(shares[0][2]) - cso = debug.CorruptShareOptions() - cso.stdout = StringIO() - cso.parseOptions([shares[1][2]]) - storage_index = uri.from_string(self.uri).get_storage_index() - self._corrupt_share_line = " server %s, SI %s, shnum %d" % \ - (base32.b2a(shares[1][1]), - base32.b2a(storage_index), - shares[1][0]) - debug.corrupt_share(cso) - d.addCallback(_clobber_shares) - - d.addCallback(lambda ign: self.do_cli("check", "--verify", self.uri)) - def _check3((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - summary = [l for l in lines if l.startswith("Summary")][0] - self.failUnless("Summary: Unhealthy: 8 shares (enc 3-of-10)" - in summary, summary) - self.failUnless(" good-shares: 8 (encoding is 3-of-10)" in lines, out) - self.failUnless(" corrupt shares:" in lines, out) - self.failUnless(self._corrupt_share_line in lines, out) - d.addCallback(_check3) - - d.addCallback(lambda ign: - self.do_cli("check", "--verify", "--repair", self.uri)) - def _check4((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnless("Summary: not healthy" in lines, out) - self.failUnless(" good-shares: 8 (encoding is 3-of-10)" in lines, out) - self.failUnless(" corrupt shares:" in lines, out) - self.failUnless(self._corrupt_share_line in lines, out) - self.failUnless(" repair successful" in lines, out) - d.addCallback(_check4) - - d.addCallback(lambda ign: - self.do_cli("check", "--verify", "--repair", self.uri)) - def _check5((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnless("Summary: healthy" in lines, out) - self.failUnless(" good-shares: 10 (encoding is 3-of-10)" in lines, out) - self.failIf(" corrupt shares:" in lines, out) - d.addCallback(_check5) - - return d - - def test_deep_check(self): - self.basedir = "cli/Check/deep_check" - self.set_up_grid() - c0 = self.g.clients[0] - self.uris = {} - self.fileurls = {} - DATA = "data" * 100 - d = c0.create_dirnode() - def _stash_root_and_create_file(n): - self.rootnode = n - self.rooturi = n.get_uri() - return n.add_file(u"gööd", upload.Data(DATA, convergence="")) - d.addCallback(_stash_root_and_create_file) - def _stash_uri(fn, which): - self.uris[which] = fn.get_uri() - return fn - d.addCallback(_stash_uri, "gööd") - d.addCallback(lambda ign: - self.rootnode.add_file(u"small", - upload.Data("literal", - convergence=""))) - d.addCallback(_stash_uri, "small") - d.addCallback(lambda ign: c0.create_mutable_file(DATA+"1")) - d.addCallback(lambda fn: self.rootnode.set_node(u"mutable", fn)) - d.addCallback(_stash_uri, "mutable") - - d.addCallback(lambda ign: self.do_cli("deep-check", self.rooturi)) - def _check1((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnless("done: 4 objects checked, 4 healthy, 0 unhealthy" - in lines, out) - d.addCallback(_check1) - - # root - # root/gööd - # root/small - # root/mutable - - d.addCallback(lambda ign: self.do_cli("deep-check", "--verbose", - self.rooturi)) - def _check2((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnless(": Healthy" in lines, out) - self.failUnless("small: Healthy (LIT)" in lines, out) - self.failUnless("gööd: Healthy" in lines, out) - self.failUnless("mutable: Healthy" in lines, out) - self.failUnless("done: 4 objects checked, 4 healthy, 0 unhealthy" - in lines, out) - d.addCallback(_check2) - - d.addCallback(lambda ign: self.do_cli("stats", self.rooturi)) - def _check_stats((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnlessIn(" count-immutable-files: 1", lines) - self.failUnlessIn(" count-mutable-files: 1", lines) - self.failUnlessIn(" count-literal-files: 1", lines) - self.failUnlessIn(" count-directories: 1", lines) - self.failUnlessIn(" size-immutable-files: 400", lines) - self.failUnlessIn("Size Histogram:", lines) - self.failUnlessIn(" 4-10 : 1 (10 B, 10 B)", lines) - self.failUnlessIn(" 317-1000 : 1 (1000 B, 1000 B)", lines) - d.addCallback(_check_stats) - - def _clobber_shares(ignored): - shares = self.find_shares(self.uris["gööd"]) - self.failUnlessEqual(len(shares), 10) - os.unlink(shares[0][2]) - - shares = self.find_shares(self.uris["mutable"]) - cso = debug.CorruptShareOptions() - cso.stdout = StringIO() - cso.parseOptions([shares[1][2]]) - storage_index = uri.from_string(self.uris["mutable"]).get_storage_index() - self._corrupt_share_line = " corrupt: server %s, SI %s, shnum %d" % \ - (base32.b2a(shares[1][1]), - base32.b2a(storage_index), - shares[1][0]) - debug.corrupt_share(cso) - d.addCallback(_clobber_shares) - - # root - # root/gööd [9 shares] - # root/small - # root/mutable [1 corrupt share] - - d.addCallback(lambda ign: - self.do_cli("deep-check", "--verbose", self.rooturi)) - def _check3((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnless(": Healthy" in lines, out) - self.failUnless("small: Healthy (LIT)" in lines, out) - self.failUnless("mutable: Healthy" in lines, out) # needs verifier - self.failUnless("gööd: Not Healthy: 9 shares (enc 3-of-10)" - in lines, out) - self.failIf(self._corrupt_share_line in lines, out) - self.failUnless("done: 4 objects checked, 3 healthy, 1 unhealthy" - in lines, out) - d.addCallback(_check3) - - d.addCallback(lambda ign: - self.do_cli("deep-check", "--verbose", "--verify", - self.rooturi)) - def _check4((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnless(": Healthy" in lines, out) - self.failUnless("small: Healthy (LIT)" in lines, out) - mutable = [l for l in lines if l.startswith("mutable")][0] - self.failUnless(mutable.startswith("mutable: Unhealthy: 9 shares (enc 3-of-10)"), - mutable) - self.failUnless(self._corrupt_share_line in lines, out) - self.failUnless("gööd: Not Healthy: 9 shares (enc 3-of-10)" - in lines, out) - self.failUnless("done: 4 objects checked, 2 healthy, 2 unhealthy" - in lines, out) - d.addCallback(_check4) - - d.addCallback(lambda ign: - self.do_cli("deep-check", "--raw", - self.rooturi)) - def _check5((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - units = [simplejson.loads(line) for line in lines] - # root, small, gööd, mutable, stats - self.failUnlessEqual(len(units), 4+1) - d.addCallback(_check5) - - d.addCallback(lambda ign: - self.do_cli("deep-check", - "--verbose", "--verify", "--repair", - self.rooturi)) - def _check6((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) - lines = out.splitlines() - self.failUnless(": healthy" in lines, out) - self.failUnless("small: healthy" in lines, out) - self.failUnless("mutable: not healthy" in lines, out) - self.failUnless(self._corrupt_share_line in lines, out) - self.failUnless("gööd: not healthy" in lines, out) - self.failUnless("done: 4 objects checked" in lines, out) - self.failUnless(" pre-repair: 2 healthy, 2 unhealthy" in lines, out) - self.failUnless(" 2 repairs attempted, 2 successful, 0 failed" - in lines, out) - self.failUnless(" post-repair: 4 healthy, 0 unhealthy" in lines,out) - d.addCallback(_check6) - - # now add a subdir, and a file below that, then make the subdir - # unrecoverable - - d.addCallback(lambda ign: self.rootnode.create_subdirectory(u"subdir")) - d.addCallback(_stash_uri, "subdir") - d.addCallback(lambda fn: - fn.add_file(u"subfile", upload.Data(DATA+"2", ""))) - d.addCallback(lambda ign: - self.delete_shares_numbered(self.uris["subdir"], - range(10))) - - # root - # rootgööd/ - # root/small - # root/mutable - # root/subdir [unrecoverable: 0 shares] - # root/subfile - - d.addCallback(lambda ign: self.do_cli("manifest", self.rooturi)) - def _manifest_failed((rc, out, err)): - self.failIfEqual(rc, 0) - self.failUnlessIn("ERROR: UnrecoverableFileError", err) - # the fatal directory should still show up, as the last line - self.failUnlessIn(" subdir\n", out) - d.addCallback(_manifest_failed) - - d.addCallback(lambda ign: self.do_cli("deep-check", self.rooturi)) - def _deep_check_failed((rc, out, err)): - self.failIfEqual(rc, 0) - self.failUnlessIn("ERROR: UnrecoverableFileError", err) - # we want to make sure that the error indication is the last - # thing that gets emitted - self.failIf("done:" in out, out) - d.addCallback(_deep_check_failed) - - # this test is disabled until the deep-repair response to an - # unrepairable directory is fixed. The failure-to-repair should not - # throw an exception, but the failure-to-traverse that follows - # should throw UnrecoverableFileError. - - #d.addCallback(lambda ign: - # self.do_cli("deep-check", "--repair", self.rooturi)) - #def _deep_check_repair_failed((rc, out, err)): - # self.failIfEqual(rc, 0) - # print err - # self.failUnlessIn("ERROR: UnrecoverableFileError", err) - # self.failIf("done:" in out, out) - #d.addCallback(_deep_check_repair_failed) - - return d - - def test_check_without_alias(self): - # 'tahoe check' should output a sensible error message if it needs to - # find the default alias and can't - self.basedir = "cli/Check/check_without_alias" - self.set_up_grid() - d = self.do_cli("check") - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) - d.addCallback(_check) - d.addCallback(lambda ign: self.do_cli("deep-check")) - d.addCallback(_check) - return d + def _create_test_file(self): + data = "puppies" * 1000 + path = os.path.join(self.basedir, "datafile") + fileutil.write(path, data) + self.datafile = path - def test_check_with_nonexistent_alias(self): - # 'tahoe check' should output a sensible error message if it needs to - # find an alias and can't. - self.basedir = "cli/Check/check_with_nonexistent_alias" + def test_unlink_without_alias(self): + # 'tahoe unlink' should behave sensibly when invoked without an explicit + # alias before the default 'tahoe' alias has been created. + self.basedir = "cli/Unlink/%s_without_alias" % (self.command,) self.set_up_grid() - d = self.do_cli("check", "nonexistent:") + d = self.do_cli(self.command, "afile") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) - self.failUnlessIn("nonexistent", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) - return d - - -class Errors(GridTestMixin, CLITestMixin, unittest.TestCase): - def test_get(self): - self.basedir = "cli/Errors/get" - self.set_up_grid() - c0 = self.g.clients[0] - self.fileurls = {} - DATA = "data" * 100 - d = c0.upload(upload.Data(DATA, convergence="")) - def _stash_bad(ur): - self.uri_1share = ur.uri - self.delete_shares_numbered(ur.uri, range(1,10)) - d.addCallback(_stash_bad) - - d.addCallback(lambda ign: self.do_cli("get", self.uri_1share)) - def _check1((rc, out, err)): - self.failIfEqual(rc, 0) - self.failUnless("410 Gone" in err, err) - self.failUnlessIn("NotEnoughSharesError: ", err) - self.failUnlessIn("Failed to get enough shareholders: have 1, need 3", err) - d.addCallback(_check1) - - targetf = os.path.join(self.basedir, "output") - d.addCallback(lambda ign: self.do_cli("get", self.uri_1share, targetf)) - def _check2((rc, out, err)): - self.failIfEqual(rc, 0) - self.failUnless("410 Gone" in err, err) - self.failUnlessIn("NotEnoughSharesError: ", err) - self.failUnlessIn("Failed to get enough shareholders: have 1, need 3", err) - self.failIf(os.path.exists(targetf)) - d.addCallback(_check2) - return d - - -class Get(GridTestMixin, CLITestMixin, unittest.TestCase): - def test_get_without_alias(self): - # 'tahoe get' should output a useful error message when invoked - # without an explicit alias and when the default 'tahoe' alias - # hasn't been created yet. - self.basedir = "cli/Get/get_without_alias" - self.set_up_grid() - d = self.do_cli('get', 'file') - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) + d.addCallback(lambda ign: self.do_cli(self.command, "afile")) d.addCallback(_check) return d - def test_get_with_nonexistent_alias(self): - # 'tahoe get' should output a useful error message when invoked with - # an explicit alias that doesn't exist. - self.basedir = "cli/Get/get_with_nonexistent_alias" + def test_unlink_with_nonexistent_alias(self): + # 'tahoe unlink' should behave sensibly when invoked with an explicit + # alias that doesn't exist. + self.basedir = "cli/Unlink/%s_with_nonexistent_alias" % (self.command,) self.set_up_grid() - d = self.do_cli("get", "nonexistent:file") + d = self.do_cli(self.command, "nonexistent:afile") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) self.failUnlessIn("nonexistent", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) - return d - -class Manifest(GridTestMixin, CLITestMixin, unittest.TestCase): - def test_manifest_without_alias(self): - # 'tahoe manifest' should output a useful error message when invoked - # without an explicit alias when the default 'tahoe' alias is - # missing. - self.basedir = "cli/Manifest/manifest_without_alias" - self.set_up_grid() - d = self.do_cli("manifest") - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) + d.addCallback(lambda ign: self.do_cli(self.command, "nonexistent:afile")) d.addCallback(_check) return d - def test_manifest_with_nonexistent_alias(self): - # 'tahoe manifest' should output a useful error message when invoked - # with an explicit alias that doesn't exist. - self.basedir = "cli/Manifest/manifest_with_nonexistent_alias" + def test_unlink_without_path(self): + # 'tahoe unlink' should give a sensible error message when invoked without a path. + self.basedir = "cli/Unlink/%s_without_path" % (self.command,) self.set_up_grid() - d = self.do_cli("manifest", "nonexistent:") - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) - self.failUnlessIn("nonexistent", err) - d.addCallback(_check) - return d - + self._create_test_file() + d = self.do_cli("create-alias", "tahoe") + d.addCallback(lambda ign: self.do_cli("put", self.datafile, "tahoe:test")) + def _do_unlink((rc, out, err)): + self.failUnlessReallyEqual(rc, 0) + self.failUnless(out.startswith("URI:"), out) + return self.do_cli(self.command, out.strip('\n')) + d.addCallback(_do_unlink) -class Mkdir(GridTestMixin, CLITestMixin, unittest.TestCase): - def test_mkdir_with_nonexistent_alias(self): - # when invoked with an alias that doesn't exist, 'tahoe mkdir' should - # output a sensible error message rather than a stack trace. - self.basedir = "cli/Mkdir/mkdir_with_nonexistent_alias" - self.set_up_grid() - d = self.do_cli("mkdir", "havasu:") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) + self.failUnlessReallyEqual(rc, 1) + self.failUnlessIn("'tahoe %s'" % (self.command,), err) + self.failUnlessIn("path must be given", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) return d -class Rm(GridTestMixin, CLITestMixin, unittest.TestCase): - def test_rm_without_alias(self): - # 'tahoe rm' should behave sensibly when invoked without an explicit - # alias before the default 'tahoe' alias has been created. - self.basedir = "cli/Rm/rm_without_alias" - self.set_up_grid() - d = self.do_cli("rm", "afile") - def _check((rc, out, err)): - self.failUnlessIn("error:", err) - self.failUnlessEqual(rc, 1) - d.addCallback(_check) - return d - - def test_rm_with_nonexistent_alias(self): - # 'tahoe rm' should behave sensibly when invoked with an explicit - # alias that doesn't exist. - self.basedir = "cli/Rm/rm_with_nonexistent_alias" - self.set_up_grid() - d = self.do_cli("rm", "nonexistent:afile") - def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) - self.failUnlessIn("error:", err) - self.failUnlessIn("nonexistent", err) - d.addCallback(_check) - return d +class Rm(Unlink): + """Test that 'tahoe rm' behaves in the same way as 'tahoe unlink'.""" + command = "rm" class Stats(GridTestMixin, CLITestMixin, unittest.TestCase): @@ -2331,8 +1118,8 @@ class Stats(GridTestMixin, CLITestMixin, unittest.TestCase): # make sure we can get stats on an empty directory too d.addCallback(lambda ign: self.do_cli("stats", self.rooturi)) def _check_stats((rc, out, err)): - self.failUnlessEqual(err, "") - self.failUnlessEqual(rc, 0) + self.failUnlessReallyEqual(err, "") + self.failUnlessReallyEqual(rc, 0) lines = out.splitlines() self.failUnlessIn(" count-immutable-files: 0", lines) self.failUnlessIn(" count-mutable-files: 0", lines) @@ -2352,8 +1139,9 @@ class Stats(GridTestMixin, CLITestMixin, unittest.TestCase): self.set_up_grid() d = self.do_cli("stats") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) return d @@ -2364,8 +1152,9 @@ class Stats(GridTestMixin, CLITestMixin, unittest.TestCase): self.set_up_grid() d = self.do_cli("stats", "havasu:") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) return d @@ -2379,7 +1168,173 @@ class Webopen(GridTestMixin, CLITestMixin, unittest.TestCase): self.set_up_grid() d = self.do_cli("webopen", "fake:") def _check((rc, out, err)): - self.failUnlessEqual(rc, 1) + self.failUnlessReallyEqual(rc, 1) self.failUnlessIn("error:", err) + self.failUnlessReallyEqual(out, "") d.addCallback(_check) return d + + def test_webopen(self): + # TODO: replace with @patch that supports Deferreds. + import webbrowser + def call_webbrowser_open(url): + self.failUnlessIn(self.alias_uri.replace(':', '%3A'), url) + self.webbrowser_open_called = True + def _cleanup(res): + webbrowser.open = self.old_webbrowser_open + return res + + self.old_webbrowser_open = webbrowser.open + try: + webbrowser.open = call_webbrowser_open + + self.basedir = "cli/Webopen/webopen" + self.set_up_grid() + d = self.do_cli("create-alias", "alias:") + def _check_alias((rc, out, err)): + self.failUnlessReallyEqual(rc, 0, repr((rc, out, err))) + self.failUnlessIn("Alias 'alias' created", out) + self.failUnlessReallyEqual(err, "") + self.alias_uri = get_aliases(self.get_clientdir())["alias"] + d.addCallback(_check_alias) + d.addCallback(lambda res: self.do_cli("webopen", "alias:")) + def _check_webopen((rc, out, err)): + self.failUnlessReallyEqual(rc, 0, repr((rc, out, err))) + self.failUnlessReallyEqual(out, "") + self.failUnlessReallyEqual(err, "") + self.failUnless(self.webbrowser_open_called) + d.addCallback(_check_webopen) + d.addBoth(_cleanup) + except: + _cleanup(None) + raise + return d + +class Options(ReallyEqualMixin, unittest.TestCase): + # this test case only looks at argument-processing and simple stuff. + + def parse(self, args, stdout=None): + o = runner.Options() + if stdout is not None: + o.stdout = stdout + o.parseOptions(args) + while hasattr(o, "subOptions"): + o = o.subOptions + return o + + def test_list(self): + fileutil.rm_dir("cli/test_options") + fileutil.make_dirs("cli/test_options") + fileutil.make_dirs("cli/test_options/private") + fileutil.write("cli/test_options/node.url", "http://localhost:8080/\n") + filenode_uri = uri.WriteableSSKFileURI(writekey="\x00"*16, + fingerprint="\x00"*32) + private_uri = uri.DirectoryURI(filenode_uri).to_string() + fileutil.write("cli/test_options/private/root_dir.cap", private_uri + "\n") + def parse2(args): return parse_options("cli/test_options", "ls", args) + o = parse2([]) + self.failUnlessEqual(o['node-url'], "http://localhost:8080/") + self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], private_uri) + self.failUnlessEqual(o.where, u"") + + o = parse2(["--node-url", "http://example.org:8111/"]) + self.failUnlessEqual(o['node-url'], "http://example.org:8111/") + self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], private_uri) + self.failUnlessEqual(o.where, u"") + + # -u for --node-url used to clash with -u for --uri (tickets #1949 and #2137). + o = parse2(["-u", "http://example.org:8111/"]) + self.failUnlessEqual(o['node-url'], "http://example.org:8111/") + self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], private_uri) + self.failUnlessEqual(o.where, u"") + self.failIf(o["uri"]) + + o = parse2(["-u", "http://example.org:8111/", "--uri"]) + self.failUnlessEqual(o['node-url'], "http://example.org:8111/") + self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], private_uri) + self.failUnlessEqual(o.where, u"") + self.failUnless(o["uri"]) + + o = parse2(["--dir-cap", "root"]) + self.failUnlessEqual(o['node-url'], "http://localhost:8080/") + self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], "root") + self.failUnlessEqual(o.where, u"") + + other_filenode_uri = uri.WriteableSSKFileURI(writekey="\x11"*16, + fingerprint="\x11"*32) + other_uri = uri.DirectoryURI(other_filenode_uri).to_string() + o = parse2(["--dir-cap", other_uri]) + self.failUnlessEqual(o['node-url'], "http://localhost:8080/") + self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], other_uri) + self.failUnlessEqual(o.where, u"") + + o = parse2(["--dir-cap", other_uri, "subdir"]) + self.failUnlessEqual(o['node-url'], "http://localhost:8080/") + self.failUnlessEqual(o.aliases[DEFAULT_ALIAS], other_uri) + self.failUnlessEqual(o.where, u"subdir") + + self.failUnlessRaises(usage.UsageError, parse2, + ["--node-url", "NOT-A-URL"]) + + o = parse2(["--node-url", "http://localhost:8080"]) + self.failUnlessEqual(o["node-url"], "http://localhost:8080/") + + o = parse2(["--node-url", "https://localhost/"]) + self.failUnlessEqual(o["node-url"], "https://localhost/") + + def test_version(self): + # "tahoe --version" dumps text to stdout and exits + stdout = StringIO() + self.failUnlessRaises(SystemExit, self.parse, ["--version"], stdout) + self.failUnlessIn(allmydata.__appname__ + ":", stdout.getvalue()) + # but "tahoe SUBCOMMAND --version" should be rejected + self.failUnlessRaises(usage.UsageError, self.parse, + ["start", "--version"]) + self.failUnlessRaises(usage.UsageError, self.parse, + ["start", "--version-and-path"]) + + def test_quiet(self): + # accepted as an overall option, but not on subcommands + o = self.parse(["--quiet", "start"]) + self.failUnless(o.parent["quiet"]) + self.failUnlessRaises(usage.UsageError, self.parse, + ["start", "--quiet"]) + + def test_basedir(self): + # accept a --node-directory option before the verb, or a --basedir + # option after, or a basedir argument after, but none in the wrong + # place, and not more than one of the three. + o = self.parse(["start"]) + self.failUnlessReallyEqual(o["basedir"], os.path.join(fileutil.abspath_expanduser_unicode(u"~"), + u".tahoe")) + o = self.parse(["start", "here"]) + self.failUnlessReallyEqual(o["basedir"], fileutil.abspath_expanduser_unicode(u"here")) + o = self.parse(["start", "--basedir", "there"]) + self.failUnlessReallyEqual(o["basedir"], fileutil.abspath_expanduser_unicode(u"there")) + o = self.parse(["--node-directory", "there", "start"]) + self.failUnlessReallyEqual(o["basedir"], fileutil.abspath_expanduser_unicode(u"there")) + + o = self.parse(["start", "here", "--nodaemon"]) + self.failUnlessReallyEqual(o["basedir"], fileutil.abspath_expanduser_unicode(u"here")) + + self.failUnlessRaises(usage.UsageError, self.parse, + ["--basedir", "there", "start"]) + self.failUnlessRaises(usage.UsageError, self.parse, + ["start", "--node-directory", "there"]) + + self.failUnlessRaises(usage.UsageError, self.parse, + ["--node-directory=there", + "start", "--basedir=here"]) + self.failUnlessRaises(usage.UsageError, self.parse, + ["start", "--basedir=here", "anywhere"]) + self.failUnlessRaises(usage.UsageError, self.parse, + ["--node-directory=there", + "start", "anywhere"]) + self.failUnlessRaises(usage.UsageError, self.parse, + ["--node-directory=there", + "start", "--basedir=here", "anywhere"]) + + self.failUnlessRaises(usage.UsageError, self.parse, + ["--node-directory=there", "start", "--nodaemon"]) + self.failUnlessRaises(usage.UsageError, self.parse, + ["start", "--basedir=here", "--nodaemon"])