X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/d28b1cebc8b799ea1e65a50826602392b446ea29..d47c009c2afd20b86cca083787d238c136e70abd:/sdk/python/tests/test_arv_put.py diff --git a/sdk/python/tests/test_arv_put.py b/sdk/python/tests/test_arv_put.py index 6e7c729be1..9bc385d2e6 100644 --- a/sdk/python/tests/test_arv_put.py +++ b/sdk/python/tests/test_arv_put.py @@ -3,6 +3,7 @@ import apiclient import os +import pwd import re import shutil import subprocess @@ -323,17 +324,102 @@ class ArvadosPutReportTest(ArvadosBaseTestCase): arv_put.human_progress(count, None))) +class ArvadosPutProjectLinkTest(ArvadosBaseTestCase): + Z_UUID = 'zzzzz-zzzzz-zzzzzzzzzzzzzzz' + + def setUp(self): + self.stderr = StringIO() + super(ArvadosPutProjectLinkTest, self).setUp() + + def tearDown(self): + self.stderr.close() + super(ArvadosPutProjectLinkTest, self).tearDown() + + def prep_link_from_arguments(self, args, uuid_found=True): + try: + link = arv_put.prep_project_link(arv_put.parse_arguments(args), + self.stderr, + lambda uuid: uuid_found) + finally: + self.stderr.seek(0) + return link + + def check_link(self, link, project_uuid, link_name=None): + self.assertEqual(project_uuid, link.get('tail_uuid')) + self.assertEqual(project_uuid, link.get('owner_uuid')) + self.assertEqual('name', link.get('link_class')) + if link_name is None: + self.assertNotIn('name', link) + else: + self.assertEqual(link_name, link.get('name')) + self.assertNotIn('head_uuid', link) + + def check_stderr_empty(self): + self.assertEqual('', self.stderr.getvalue()) + + def test_project_link_with_name(self): + link = self.prep_link_from_arguments(['--project-uuid', self.Z_UUID, + '--name', 'test link AAA']) + self.check_link(link, self.Z_UUID, 'test link AAA') + self.check_stderr_empty() + + def test_project_link_without_name(self): + username = pwd.getpwuid(os.getuid()).pw_name + link = self.prep_link_from_arguments(['--project-uuid', self.Z_UUID]) + self.assertIsNotNone(link.get('name', None)) + self.assertRegexpMatches( + link['name'], + r'^Saved at .* by {}@'.format(re.escape(username))) + self.check_link(link, self.Z_UUID, link.get('name', None)) + for line in self.stderr: + if "No --name specified" in line: + break + else: + self.fail("no warning emitted about the lack of collection name") + + @unittest.skip("prep_project_link needs an API lookup for this case") + def test_collection_without_project_defaults_to_home(self): + link = self.prep_link_from_arguments(['--name', 'test link BBB']) + self.check_link(link, self.Z_UUID) + self.check_stderr_empty() + + def test_no_link_or_warning_with_no_collection(self): + self.assertIsNone(self.prep_link_from_arguments(['--raw'])) + self.check_stderr_empty() + + def test_error_when_project_not_found(self): + self.assertRaises(ValueError, + self.prep_link_from_arguments, + ['--project-uuid', self.Z_UUID], False) + + def test_link_without_collection_is_error(self): + self.assertRaises(ValueError, + self.prep_link_from_arguments, + ['--project-uuid', self.Z_UUID, '--stream']) + + class ArvadosPutTest(ArvadosKeepLocalStoreTestCase): + def call_main_with_args(self, args): + self.main_stdout = StringIO() + self.main_stderr = StringIO() + return arv_put.main(args, self.main_stdout, self.main_stderr) + def call_main_on_test_file(self): - self.main_output = StringIO() with self.make_test_file() as testfile: path = testfile.name - arv_put.main(['--stream', '--no-progress', path], self.main_output) + self.call_main_with_args(['--stream', '--no-progress', path]) self.assertTrue( os.path.exists(os.path.join(os.environ['KEEP_LOCAL_STORE'], '098f6bcd4621d373cade4e832627b4f6')), "did not find file stream in Keep store") + def tearDown(self): + for outbuf in ['main_stdout', 'main_stderr']: + if hasattr(self, outbuf): + getattr(self, outbuf).close() + delattr(self, outbuf) + super(ArvadosPutTest, self).tearDown() + def test_simple_file_put(self): self.call_main_on_test_file() @@ -359,15 +445,79 @@ class ArvadosPutTest(ArvadosKeepLocalStoreTestCase): arv_put.ResumeCache.CACHE_DIR = orig_cachedir os.chmod(cachedir, 0o700) + def test_link_without_collection_aborts(self): + self.assertRaises(SystemExit, self.call_main_with_args, + ['--name', 'test without Collection', + '--stream', '/dev/null']) + +class ArvPutIntegrationTest(unittest.TestCase): + PROJECT_UUID = run_test_server.fixture('groups')['aproject']['uuid'] + ENVIRON = os.environ + ENVIRON['PYTHONPATH'] = ':'.join(sys.path) + + @classmethod + def setUpClass(cls): + try: + del os.environ['KEEP_LOCAL_STORE'] + except KeyError: + pass + + # Use the blob_signing_key from the Rails "test" configuration + # to provision the Keep server. + config_blob_signing_key = None + for config_file in ['application.yml', 'application.default.yml']: + with open(os.path.join(run_test_server.SERVICES_SRC_DIR, + "api", "config", config_file)) as f: + rails_config = yaml.load(f.read()) + for config_section in ['test', 'common']: + try: + config_blob_signing_key = rails_config[config_section]["blob_signing_key"] + break + except KeyError, AttributeError: + pass + if config_blob_signing_key != None: + break + run_test_server.run() + run_test_server.run_keep(blob_signing_key=config_blob_signing_key, + enforce_permissions=(config_blob_signing_key != None)) + + @classmethod + def tearDownClass(cls): + run_test_server.stop() + run_test_server.stop_keep() + + def authorize_with(self, token_name): + run_test_server.authorize_with(token_name) + for v in ["ARVADOS_API_HOST", + "ARVADOS_API_HOST_INSECURE", + "ARVADOS_API_TOKEN"]: + os.environ[v] = arvados.config.settings()[v] + + def current_user(self): + return arvados.api('v1').users().current().execute() + + def test_check_real_project_found(self): + self.assertTrue(arv_put.check_project_exists(self.PROJECT_UUID), + "did not correctly find test fixture project") + + def test_check_error_finding_nonexistent_project(self): + BAD_UUID = 'zzzzz-zzzzz-zzzzzzzzzzzzzzz' + try: + result = arv_put.check_project_exists(BAD_UUID) + except ValueError as error: + self.assertIn(BAD_UUID, error.message) + else: + self.assertFalse(result, "incorrectly found nonexistent project") + def test_short_put_from_stdin(self): - # Have to run this separately since arv-put can't read from the - # tests' stdin. + # Have to run this as an integration test since arv-put can't + # read from the tests' stdin. # arv-put usually can't stat(os.path.realpath('/dev/stdin')) in this # case, because the /proc entry is already gone by the time it tries. pipe = subprocess.Popen( [sys.executable, arv_put.__file__, '--stream'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, - stderr=subprocess.STDOUT) + stderr=subprocess.STDOUT, env=self.ENVIRON) pipe.stdin.write('stdin test\n') pipe.stdin.close() deadline = time.time() + 5 @@ -382,44 +532,11 @@ class ArvadosPutTest(ArvadosKeepLocalStoreTestCase): self.fail("arv-put returned exit code {}".format(returncode)) self.assertIn('4a9c8b735dce4b5fa3acf221a0b13628+11', pipe.stdout.read()) - -class ArvPutIntegrationTest(unittest.TestCase): - @classmethod - def setUpClass(cls): - try: - del os.environ['KEEP_LOCAL_STORE'] - except KeyError: - pass - - # Use the blob_signing_key from the Rails "test" configuration - # to provision the Keep server. - with open(os.path.join(os.path.dirname(__file__), - run_test_server.ARV_API_SERVER_DIR, - "config", - "application.yml")) as f: - rails_config = yaml.load(f.read()) - try: - config_blob_signing_key = rails_config["test"]["blob_signing_key"] - except KeyError: - config_blob_signing_key = rails_config["common"]["blob_signing_key"] - run_test_server.run() - run_test_server.run_keep(blob_signing_key=config_blob_signing_key, - enforce_permissions=True) - - @classmethod - def tearDownClass(cls): - run_test_server.stop() - run_test_server.stop_keep() - def test_ArvPutSignedManifest(self): # ArvPutSignedManifest runs "arv-put foo" and then attempts to get # the newly created manifest from the API server, testing to confirm # that the block locators in the returned manifest are signed. - run_test_server.authorize_with('active') - for v in ["ARVADOS_API_HOST", - "ARVADOS_API_HOST_INSECURE", - "ARVADOS_API_TOKEN"]: - os.environ[v] = arvados.config.settings()[v] + self.authorize_with('active') # Before doing anything, demonstrate that the collection # we're about to create is not present in our test fixture. @@ -432,7 +549,7 @@ class ArvPutIntegrationTest(unittest.TestCase): with open(os.path.join(datadir, "foo"), "w") as f: f.write("The quick brown fox jumped over the lazy dog") p = subprocess.Popen([sys.executable, arv_put.__file__, datadir], - stdout=subprocess.PIPE) + stdout=subprocess.PIPE, env=self.ENVIRON) (arvout, arverr) = p.communicate() self.assertEqual(p.returncode, 0) self.assertEqual(arverr, None) @@ -448,6 +565,43 @@ class ArvPutIntegrationTest(unittest.TestCase): os.remove(os.path.join(datadir, "foo")) os.rmdir(datadir) + def run_and_find_link(self, text, extra_args=[]): + self.authorize_with('active') + pipe = subprocess.Popen( + [sys.executable, arv_put.__file__] + extra_args, + stdin=subprocess.PIPE, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, env=self.ENVIRON) + stdout, stderr = pipe.communicate(text) + link_list = arvados.api('v1', cache=False).links().list( + filters=[['head_uuid', '=', stdout.strip()], + ['link_class', '=', 'name']]).execute().get('items', []) + self.assertEqual(1, len(link_list)) + return link_list[0] + + def test_put_collection_with_unnamed_project_link(self): + link = self.run_and_find_link("Test unnamed collection", + ['--project-uuid', self.PROJECT_UUID]) + username = pwd.getpwuid(os.getuid()).pw_name + self.assertRegexpMatches( + link['name'], + r'^Saved at .* by {}@'.format(re.escape(username))) + + def test_put_collection_with_name_and_no_project(self): + link_name = 'Test Collection Link in home project' + link = self.run_and_find_link("Test named collection in home project", + ['--name', link_name]) + self.assertEqual(link_name, link['name']) + my_user_uuid = self.current_user()['uuid'] + self.assertEqual(my_user_uuid, link['tail_uuid']) + self.assertEqual(my_user_uuid, link['owner_uuid']) + + def test_put_collection_with_named_project_link(self): + link_name = 'Test auto Collection Link' + link = self.run_and_find_link("Test named collection", + ['--name', link_name, + '--project-uuid', self.PROJECT_UUID]) + self.assertEqual(link_name, link['name']) + if __name__ == '__main__': unittest.main()