X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/7116da151dc8bfd5ac1a9b016b2ed6e4c35572f7..0eb72b526bf8bbb011551ecf019f604e17a534f1:/sdk/python/tests/test_collections.py diff --git a/sdk/python/tests/test_collections.py b/sdk/python/tests/test_collections.py index 7421850089..e8c6dd163f 100644 --- a/sdk/python/tests/test_collections.py +++ b/sdk/python/tests/test_collections.py @@ -1,20 +1,26 @@ -# usage example: +# Copyright (C) The Arvados Authors. All rights reserved. # -# ARVADOS_API_TOKEN=abc ARVADOS_API_HOST=arvados.local python -m unittest discover +# SPDX-License-Identifier: Apache-2.0 +from __future__ import absolute_import + +from builtins import object import arvados import copy import mock import os import pprint +import random import re +import sys import tempfile +import time import unittest -import run_test_server +from . import run_test_server from arvados._ranges import Range, LocatorAndRange from arvados.collection import Collection, CollectionReader -import arvados_testutil as tutil +from . import arvados_testutil as tutil class TestResumableWriter(arvados.ResumableCollectionWriter): KEEP_BLOCK_SIZE = 1024 # PUT to Keep every 1K. @@ -40,13 +46,13 @@ class ArvadosCollectionsTest(run_test_server.TestCaseWithServers, self.assertEqual(cw.current_stream_name(), '.', 'current_stream_name() should be "." now') cw.set_current_file_name('foo.txt') - cw.write('foo') + cw.write(b'foo') self.assertEqual(cw.current_file_name(), 'foo.txt', 'current_file_name() should be foo.txt now') cw.start_new_file('bar.txt') - cw.write('bar') + cw.write(b'bar') cw.start_new_stream('baz') - cw.write('baz') + cw.write(b'baz') cw.set_current_file_name('baz.txt') self.assertEqual(cw.manifest_text(), ". 3858f62230ac3c915f300c664312c63f+6 0:3:foo.txt 3:3:bar.txt\n" + @@ -55,9 +61,13 @@ class ArvadosCollectionsTest(run_test_server.TestCaseWithServers, cw.finish() return cw.portable_data_hash() + def test_pdh_is_native_str(self): + pdh = self.write_foo_bar_baz() + self.assertEqual(type(''), type(pdh)) + def test_keep_local_store(self): - self.assertEqual(self.keep_client.put('foo'), 'acbd18db4cc2f85cedef654fccc4a4d8+3', 'wrong md5 hash from Keep.put') - self.assertEqual(self.keep_client.get('acbd18db4cc2f85cedef654fccc4a4d8+3'), 'foo', 'wrong data from Keep.get') + self.assertEqual(self.keep_client.put(b'foo'), 'acbd18db4cc2f85cedef654fccc4a4d8+3', 'wrong md5 hash from Keep.put') + self.assertEqual(self.keep_client.get('acbd18db4cc2f85cedef654fccc4a4d8+3'), b'foo', 'wrong data from Keep.get') def test_local_collection_writer(self): self.assertEqual(self.write_foo_bar_baz(), @@ -72,20 +82,20 @@ class ArvadosCollectionsTest(run_test_server.TestCaseWithServers, for s in cr.all_streams(): for f in s.all_files(): got += [[f.size(), f.stream_name(), f.name(), f.read(2**26)]] - expected = [[3, '.', 'foo.txt', 'foo'], - [3, '.', 'bar.txt', 'bar'], - [3, './baz', 'baz.txt', 'baz']] + expected = [[3, '.', 'foo.txt', b'foo'], + [3, '.', 'bar.txt', b'bar'], + [3, './baz', 'baz.txt', b'baz']] self.assertEqual(got, expected) stream0 = cr.all_streams()[0] self.assertEqual(stream0.readfrom(0, 0), - '', + b'', 'reading zero bytes should have returned empty string') self.assertEqual(stream0.readfrom(0, 2**26), - 'foobar', + b'foobar', 'reading entire stream failed') self.assertEqual(stream0.readfrom(2**26, 0), - '', + b'', 'reading zero bytes should have returned empty string') def _test_subset(self, collection, expected): @@ -102,50 +112,50 @@ class ArvadosCollectionsTest(run_test_server.TestCaseWithServers, def test_collection_manifest_subset(self): foobarbaz = self.write_foo_bar_baz() self._test_subset(foobarbaz, - [[3, '.', 'bar.txt', 'bar'], - [3, '.', 'foo.txt', 'foo'], - [3, './baz', 'baz.txt', 'baz']]) + [[3, '.', 'bar.txt', b'bar'], + [3, '.', 'foo.txt', b'foo'], + [3, './baz', 'baz.txt', b'baz']]) self._test_subset((". %s %s 0:3:foo.txt 3:3:bar.txt\n" % - (self.keep_client.put("foo"), - self.keep_client.put("bar"))), - [[3, '.', 'bar.txt', 'bar'], - [3, '.', 'foo.txt', 'foo']]) + (self.keep_client.put(b"foo"), + self.keep_client.put(b"bar"))), + [[3, '.', 'bar.txt', b'bar'], + [3, '.', 'foo.txt', b'foo']]) self._test_subset((". %s %s 0:2:fo.txt 2:4:obar.txt\n" % - (self.keep_client.put("foo"), - self.keep_client.put("bar"))), - [[2, '.', 'fo.txt', 'fo'], - [4, '.', 'obar.txt', 'obar']]) + (self.keep_client.put(b"foo"), + self.keep_client.put(b"bar"))), + [[2, '.', 'fo.txt', b'fo'], + [4, '.', 'obar.txt', b'obar']]) self._test_subset((". %s %s 0:2:fo.txt 2:0:zero.txt 2:2:ob.txt 4:2:ar.txt\n" % - (self.keep_client.put("foo"), - self.keep_client.put("bar"))), - [[2, '.', 'ar.txt', 'ar'], - [2, '.', 'fo.txt', 'fo'], - [2, '.', 'ob.txt', 'ob'], - [0, '.', 'zero.txt', '']]) + (self.keep_client.put(b"foo"), + self.keep_client.put(b"bar"))), + [[2, '.', 'ar.txt', b'ar'], + [2, '.', 'fo.txt', b'fo'], + [2, '.', 'ob.txt', b'ob'], + [0, '.', 'zero.txt', b'']]) def test_collection_empty_file(self): cw = arvados.CollectionWriter(self.api_client) cw.start_new_file('zero.txt') - cw.write('') + cw.write(b'') self.assertEqual(cw.manifest_text(), ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:zero.txt\n") self.check_manifest_file_sizes(cw.manifest_text(), [0]) cw = arvados.CollectionWriter(self.api_client) cw.start_new_file('zero.txt') - cw.write('') + cw.write(b'') cw.start_new_file('one.txt') - cw.write('1') + cw.write(b'1') cw.start_new_stream('foo') cw.start_new_file('zero.txt') - cw.write('') + cw.write(b'') self.check_manifest_file_sizes(cw.manifest_text(), [0,1,0]) def test_no_implicit_normalize(self): cw = arvados.CollectionWriter(self.api_client) cw.start_new_file('b') - cw.write('b') + cw.write(b'b') cw.start_new_file('a') - cw.write('') + cw.write(b'') self.check_manifest_file_sizes(cw.manifest_text(), [1,0]) self.check_manifest_file_sizes( arvados.CollectionReader( @@ -311,14 +321,16 @@ class ArvadosCollectionsTest(run_test_server.TestCaseWithServers, return self.content[locator] def test_stream_reader(self): - keepblocks = {'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+10': 'abcdefghij', - 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb+15': 'klmnopqrstuvwxy', - 'cccccccccccccccccccccccccccccccc+5': 'z0123'} + keepblocks = { + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+10': b'abcdefghij', + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb+15': b'klmnopqrstuvwxy', + 'cccccccccccccccccccccccccccccccc+5': b'z0123', + } mk = self.MockKeep(keepblocks) sr = arvados.StreamReader([".", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+10", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb+15", "cccccccccccccccccccccccccccccccc+5", "0:30:foo"], mk) - content = 'abcdefghijklmnopqrstuvwxyz0123456789' + content = b'abcdefghijklmnopqrstuvwxyz0123456789' self.assertEqual(sr.readfrom(0, 30), content[0:30]) self.assertEqual(sr.readfrom(2, 30), content[2:30]) @@ -332,7 +344,7 @@ class ArvadosCollectionsTest(run_test_server.TestCaseWithServers, self.assertEqual(sr.readfrom(15, 5), content[15:20]) self.assertEqual(sr.readfrom(20, 5), content[20:25]) self.assertEqual(sr.readfrom(25, 5), content[25:30]) - self.assertEqual(sr.readfrom(30, 5), '') + self.assertEqual(sr.readfrom(30, 5), b'') def test_extract_file(self): m1 = """. 5348b82a029fd9e971a811ce1f71360b+43 0:43:md5sum.txt @@ -421,7 +433,7 @@ class ArvadosCollectionsTest(run_test_server.TestCaseWithServers, def test_write_multiple_files(self): cwriter = arvados.CollectionWriter(self.api_client) for letter in 'ABC': - with self.make_test_file(letter) as testfile: + with self.make_test_file(letter.encode()) as testfile: cwriter.write_file(testfile.name, letter) self.assertEqual( cwriter.manifest_text(), @@ -464,7 +476,7 @@ class ArvadosCollectionsTest(run_test_server.TestCaseWithServers, with self.make_test_file() as testfile: cwriter.write_file(testfile.name, 'test') orig_mtime = os.fstat(testfile.fileno()).st_mtime - testfile.write('extra') + testfile.write(b'extra') testfile.flush() os.utime(testfile.name, (orig_mtime, orig_mtime)) self.assertRaises(arvados.errors.StaleWriterStateError, @@ -519,8 +531,8 @@ class CollectionTestMixin(tutil.ApiClientMock): @tutil.skip_sleep class CollectionReaderTestCase(unittest.TestCase, CollectionTestMixin): - def mock_get_collection(self, api_mock, code, body): - body = self.API_COLLECTIONS.get(body) + def mock_get_collection(self, api_mock, code, fixturename): + body = self.API_COLLECTIONS.get(fixturename) self._mock_api_call(api_mock.collections().get, code, body) def api_client_mock(self, status=200): @@ -590,8 +602,8 @@ class CollectionReaderTestCase(unittest.TestCase, CollectionTestMixin): reader = arvados.CollectionReader(self.DEFAULT_UUID, api_client=client, num_retries=3) with tutil.mock_keep_responses('foo', 500, 500, 200): - self.assertEqual('foo', - ''.join(f.read(9) for f in reader.all_files())) + self.assertEqual(b'foo', + b''.join(f.read(9) for f in reader.all_files())) def test_read_nonnormalized_manifest_with_collection_reader(self): # client should be able to use CollectionReader on a manifest without normalizing it @@ -644,7 +656,7 @@ class CollectionReaderTestCase(unittest.TestCase, CollectionTestMixin): def test_open_collection_file_one_argument(self): client = self.api_client_mock(200) reader = arvados.CollectionReader(self.DEFAULT_UUID, api_client=client) - cfile = reader.open('./foo') + cfile = reader.open('./foo', 'rb') self.check_open_file(cfile, '.', 'foo', 3) def test_open_deep_file(self): @@ -653,7 +665,7 @@ class CollectionReaderTestCase(unittest.TestCase, CollectionTestMixin): self.mock_get_collection(client, 200, coll_name) reader = arvados.CollectionReader( self.API_COLLECTIONS[coll_name]['uuid'], api_client=client) - cfile = reader.open('./subdir2/subdir3/file2_in_subdir3.txt') + cfile = reader.open('./subdir2/subdir3/file2_in_subdir3.txt', 'rb') self.check_open_file(cfile, './subdir2/subdir3', 'file2_in_subdir3.txt', 32) @@ -678,7 +690,7 @@ class CollectionWriterTestCase(unittest.TestCase, CollectionTestMixin): kwargs.setdefault('api_client', self.api_client_mock()) writer = arvados.CollectionWriter(**kwargs) writer.start_new_file('foo') - writer.write('foo') + writer.write(b'foo') return writer def test_write_whole_collection(self): @@ -737,7 +749,7 @@ class CollectionWriterTestCase(unittest.TestCase, CollectionTestMixin): with writer.open('out') as out_file: self.assertEqual('.', writer.current_stream_name()) self.assertEqual('out', writer.current_file_name()) - out_file.write('test data') + out_file.write(b'test data') data_loc = tutil.str_keep_locator('test data') self.assertTrue(out_file.closed, "writer file not closed after context") self.assertRaises(ValueError, out_file.write, 'extra text') @@ -762,9 +774,9 @@ class CollectionWriterTestCase(unittest.TestCase, CollectionTestMixin): with self.mock_keep((data_loc1, 200), (data_loc2, 200)) as keep_mock: writer = arvados.CollectionWriter(client) with writer.open('flush_test') as out_file: - out_file.write('flush1') + out_file.write(b'flush1') out_file.flush() - out_file.write('flush2') + out_file.write(b'flush2') self.assertEqual(". {} {} 0:12:flush_test\n".format(data_loc1, data_loc2), writer.manifest_text()) @@ -773,9 +785,9 @@ class CollectionWriterTestCase(unittest.TestCase, CollectionTestMixin): client = self.api_client_mock() writer = arvados.CollectionWriter(client) with writer.open('.', '1') as out_file: - out_file.write('1st') + out_file.write(b'1st') with writer.open('.', '2') as out_file: - out_file.write('2nd') + out_file.write(b'2nd') data_loc = tutil.str_keep_locator('1st2nd') with self.mock_keep(data_loc, 200) as keep_mock: self.assertEqual(". {} 0:3:1 3:3:2\n".format(data_loc), @@ -788,9 +800,9 @@ class CollectionWriterTestCase(unittest.TestCase, CollectionTestMixin): with self.mock_keep((data_loc1, 200), (data_loc2, 200)) as keep_mock: writer = arvados.CollectionWriter(client) with writer.open('file') as out_file: - out_file.write('file') + out_file.write(b'file') with writer.open('./dir', 'indir') as out_file: - out_file.write('indir') + out_file.write(b'indir') expected = ". {} 0:4:file\n./dir {} 0:5:indir\n".format( data_loc1, data_loc2) self.assertEqual(expected, writer.manifest_text()) @@ -802,6 +814,61 @@ class CollectionWriterTestCase(unittest.TestCase, CollectionTestMixin): self.assertRaises(arvados.errors.AssertionError, writer.open, 'two') +class CollectionMethods(run_test_server.TestCaseWithServers): + + def test_keys_values_items_support_indexing(self): + c = Collection() + with c.open('foo', 'wb') as f: + f.write(b'foo') + with c.open('bar', 'wb') as f: + f.write(b'bar') + self.assertEqual(2, len(c.keys())) + if sys.version_info < (3, 0): + # keys() supports indexing only for python2 callers. + fn0 = c.keys()[0] + fn1 = c.keys()[1] + else: + fn0, fn1 = c.keys() + self.assertEqual(2, len(c.values())) + f0 = c.values()[0] + f1 = c.values()[1] + self.assertEqual(2, len(c.items())) + self.assertEqual(fn0, c.items()[0][0]) + self.assertEqual(fn1, c.items()[1][0]) + + +class CollectionOpenModes(run_test_server.TestCaseWithServers): + + def test_open_binary_modes(self): + c = Collection() + for mode in ['wb', 'wb+', 'ab', 'ab+']: + with c.open('foo', mode) as f: + f.write(b'foo') + + def test_open_invalid_modes(self): + c = Collection() + for mode in ['+r', 'aa', '++', 'r+b', 'beer', '', None]: + with self.assertRaises(Exception): + c.open('foo', mode) + + def test_open_text_modes(self): + c = Collection() + with c.open('foo', 'wb') as f: + f.write('foo') + for mode in ['r', 'rt', 'r+', 'rt+', 'w', 'wt', 'a', 'at']: + if sys.version_info >= (3, 0): + with self.assertRaises(NotImplementedError): + c.open('foo', mode) + else: + with c.open('foo', mode) as f: + if mode[0] == 'r' and '+' not in mode: + self.assertEqual('foo', f.read(3)) + else: + f.write('bar') + f.seek(-3, os.SEEK_CUR) + self.assertEqual('bar', f.read(3)) + + class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): def test_replication_desired_kept_on_load(self): @@ -929,11 +996,15 @@ class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): c1 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n') c2 = Collection('. 5348b82a029fd9e971a811ce1f71360b+43 0:10:count2.txt\n') d = c2.diff(c1) - self.assertEqual(d, [('del', './count2.txt', c2["count2.txt"]), - ('add', './count1.txt', c1["count1.txt"])]) + self.assertEqual(sorted(d), [ + ('add', './count1.txt', c1["count1.txt"]), + ('del', './count2.txt', c2["count2.txt"]), + ]) d = c1.diff(c2) - self.assertEqual(d, [('del', './count1.txt', c1["count1.txt"]), - ('add', './count2.txt', c2["count2.txt"])]) + self.assertEqual(sorted(d), [ + ('add', './count2.txt', c2["count2.txt"]), + ('del', './count1.txt', c1["count1.txt"]), + ]) self.assertNotEqual(c1.portable_manifest_text(), c2.portable_manifest_text()) c1.apply(d) self.assertEqual(c1.portable_manifest_text(), c2.portable_manifest_text()) @@ -966,11 +1037,15 @@ class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): c1 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n') c2 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 5348b82a029fd9e971a811ce1f71360b+43 0:10:count1.txt 10:20:count2.txt\n') d = c2.diff(c1) - self.assertEqual(d, [('del', './count2.txt', c2["count2.txt"]), - ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"])]) + self.assertEqual(sorted(d), [ + ('del', './count2.txt', c2["count2.txt"]), + ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"]), + ]) d = c1.diff(c2) - self.assertEqual(d, [('add', './count2.txt', c2["count2.txt"]), - ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"])]) + self.assertEqual(sorted(d), [ + ('add', './count2.txt', c2["count2.txt"]), + ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"]), + ]) self.assertNotEqual(c1.portable_manifest_text(), c2.portable_manifest_text()) c1.apply(d) @@ -980,12 +1055,15 @@ class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): c1 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n') c2 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n./foo 5348b82a029fd9e971a811ce1f71360b+43 0:10:count2.txt\n') d = c2.diff(c1) - self.assertEqual(d, [('del', './foo', c2["foo"]), - ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"])]) + self.assertEqual(sorted(d), [ + ('del', './foo', c2["foo"]), + ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"]), + ]) d = c1.diff(c2) - self.assertEqual(d, [('add', './foo', c2["foo"]), - ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"])]) - + self.assertEqual(sorted(d), [ + ('add', './foo', c2["foo"]), + ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"]), + ]) self.assertNotEqual(c1.portable_manifest_text(), c2.portable_manifest_text()) c1.apply(d) self.assertEqual(c1.portable_manifest_text(), c2.portable_manifest_text()) @@ -993,15 +1071,18 @@ class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): def test_diff_del_add_in_subcollection(self): c1 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n./foo 5348b82a029fd9e971a811ce1f71360b+43 0:10:count2.txt\n') c2 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n./foo 5348b82a029fd9e971a811ce1f71360b+43 0:3:count3.txt\n') - d = c2.diff(c1) - self.assertEqual(d, [('del', './foo/count3.txt', c2.find("foo/count3.txt")), - ('add', './foo/count2.txt', c1.find("foo/count2.txt")), - ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"])]) + self.assertEqual(sorted(d), [ + ('add', './foo/count2.txt', c1.find("foo/count2.txt")), + ('del', './foo/count3.txt', c2.find("foo/count3.txt")), + ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"]), + ]) d = c1.diff(c2) - self.assertEqual(d, [('del', './foo/count2.txt', c1.find("foo/count2.txt")), - ('add', './foo/count3.txt', c2.find("foo/count3.txt")), - ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"])]) + self.assertEqual(sorted(d), [ + ('add', './foo/count3.txt', c2.find("foo/count3.txt")), + ('del', './foo/count2.txt', c1.find("foo/count2.txt")), + ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"]), + ]) self.assertNotEqual(c1.portable_manifest_text(), c2.portable_manifest_text()) c1.apply(d) @@ -1011,11 +1092,15 @@ class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): c1 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n./foo 5348b82a029fd9e971a811ce1f71360b+43 0:10:count2.txt\n') c2 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt 0:3:foo\n') d = c2.diff(c1) - self.assertEqual(d, [('mod', './foo', c2["foo"], c1["foo"]), - ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"])]) + self.assertEqual(sorted(d), [ + ('mod', './foo', c2["foo"], c1["foo"]), + ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"]), + ]) d = c1.diff(c2) - self.assertEqual(d, [('mod', './foo', c1["foo"], c2["foo"]), - ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"])]) + self.assertEqual(sorted(d), [ + ('mod', './foo', c1["foo"], c2["foo"]), + ('tok', './count1.txt', c2["count1.txt"], c1["count1.txt"]), + ]) self.assertNotEqual(c1.portable_manifest_text(), c2.portable_manifest_text()) c1.apply(d) @@ -1025,10 +1110,12 @@ class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): c1 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n') c2 = Collection('. 5348b82a029fd9e971a811ce1f71360b+43 0:10:count2.txt\n') d = c1.diff(c2) - self.assertEqual(d, [('del', './count1.txt', c1["count1.txt"]), - ('add', './count2.txt', c2["count2.txt"])]) - f = c1.open("count1.txt", "w") - f.write("zzzzz") + self.assertEqual(sorted(d), [ + ('add', './count2.txt', c2["count2.txt"]), + ('del', './count1.txt', c1["count1.txt"]), + ]) + f = c1.open("count1.txt", "wb") + f.write(b"zzzzz") # c1 changed, so it should not be deleted. c1.apply(d) @@ -1039,25 +1126,31 @@ class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): c2 = Collection('. 5348b82a029fd9e971a811ce1f71360b+43 0:10:count1.txt') d = c1.diff(c2) self.assertEqual(d, [('mod', './count1.txt', c1["count1.txt"], c2["count1.txt"])]) - f = c1.open("count1.txt", "w") - f.write("zzzzz") + f = c1.open("count1.txt", "wb") + f.write(b"zzzzz") # c1 changed, so c2 mod will go to a conflict file c1.apply(d) - self.assertRegexpMatches(c1.portable_manifest_text(), r"\. 95ebc3c7b3b9f1d2c40fec14415d3cb8\+5 5348b82a029fd9e971a811ce1f71360b\+43 0:5:count1\.txt 5:10:count1\.txt~\d\d\d\d\d\d\d\d-\d\d\d\d\d\d~conflict~$") + self.assertRegex( + c1.portable_manifest_text(), + r"\. 95ebc3c7b3b9f1d2c40fec14415d3cb8\+5 5348b82a029fd9e971a811ce1f71360b\+43 0:5:count1\.txt 5:10:count1\.txt~\d\d\d\d\d\d\d\d-\d\d\d\d\d\d~conflict~$") def test_conflict_add(self): c1 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count2.txt\n') c2 = Collection('. 5348b82a029fd9e971a811ce1f71360b+43 0:10:count1.txt\n') d = c1.diff(c2) - self.assertEqual(d, [('del', './count2.txt', c1["count2.txt"]), - ('add', './count1.txt', c2["count1.txt"])]) - f = c1.open("count1.txt", "w") - f.write("zzzzz") + self.assertEqual(sorted(d), [ + ('add', './count1.txt', c2["count1.txt"]), + ('del', './count2.txt', c1["count2.txt"]), + ]) + f = c1.open("count1.txt", "wb") + f.write(b"zzzzz") # c1 added count1.txt, so c2 add will go to a conflict file c1.apply(d) - self.assertRegexpMatches(c1.portable_manifest_text(), r"\. 95ebc3c7b3b9f1d2c40fec14415d3cb8\+5 5348b82a029fd9e971a811ce1f71360b\+43 0:5:count1\.txt 5:10:count1\.txt~\d\d\d\d\d\d\d\d-\d\d\d\d\d\d~conflict~$") + self.assertRegex( + c1.portable_manifest_text(), + r"\. 95ebc3c7b3b9f1d2c40fec14415d3cb8\+5 5348b82a029fd9e971a811ce1f71360b\+43 0:5:count1\.txt 5:10:count1\.txt~\d\d\d\d\d\d\d\d-\d\d\d\d\d\d~conflict~$") def test_conflict_del(self): c1 = Collection('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt') @@ -1068,31 +1161,65 @@ class NewCollectionTestCase(unittest.TestCase, CollectionTestMixin): # c1 deleted, so c2 mod will go to a conflict file c1.apply(d) - self.assertRegexpMatches(c1.portable_manifest_text(), r"\. 5348b82a029fd9e971a811ce1f71360b\+43 0:10:count1\.txt~\d\d\d\d\d\d\d\d-\d\d\d\d\d\d~conflict~$") + self.assertRegex( + c1.portable_manifest_text(), + r"\. 5348b82a029fd9e971a811ce1f71360b\+43 0:10:count1\.txt~\d\d\d\d\d\d\d\d-\d\d\d\d\d\d~conflict~$") def test_notify(self): c1 = Collection() events = [] c1.subscribe(lambda event, collection, name, item: events.append((event, collection, name, item))) - f = c1.open("foo.txt", "w") + f = c1.open("foo.txt", "wb") self.assertEqual(events[0], (arvados.collection.ADD, c1, "foo.txt", f.arvadosfile)) def test_open_w(self): c1 = Collection(". 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n") self.assertEqual(c1["count1.txt"].size(), 10) - c1.open("count1.txt", "w").close() + c1.open("count1.txt", "wb").close() self.assertEqual(c1["count1.txt"].size(), 0) +class NewCollectionTestCaseWithServersAndTokens(run_test_server.TestCaseWithServers): + MAIN_SERVER = {} + KEEP_SERVER = {} + + def setUp(self): + self.keep_put = getattr(arvados.keep.KeepClient, 'put') + + def test_repacked_block_submission_get_permission_token(self): + ''' + Make sure that those blocks that are committed after repacking small ones, + get their permission tokens assigned on the collection manifest. + ''' + def wrapped_keep_put(*args, **kwargs): + # Simulate slow put operations + time.sleep(1) + return self.keep_put(*args, **kwargs) + + re_locator = "[0-9a-f]{32}\+\d+\+A[a-f0-9]{40}@[a-f0-9]{8}" + + with mock.patch('arvados.keep.KeepClient.put', autospec=True) as mocked_put: + mocked_put.side_effect = wrapped_keep_put + c = Collection() + # Write 70 files ~1MiB each so we force to produce 1 big block by repacking + # small ones before finishing the upload. + for i in range(70): + f = c.open("file_{}.txt".format(i), 'wb') + f.write(random.choice('abcdefghijklmnopqrstuvwxyz') * (2**20+i)) + f.close(flush=False) + # We should get 2 blocks with their tokens + self.assertEqual(len(re.findall(re_locator, c.manifest_text())), 2) + + class NewCollectionTestCaseWithServers(run_test_server.TestCaseWithServers): def test_get_manifest_text_only_committed(self): c = Collection() - with c.open("count.txt", "w") as f: + with c.open("count.txt", "wb") as f: # One file committed - with c.open("foo.txt", "w") as foo: - foo.write("foo") + with c.open("foo.txt", "wb") as foo: + foo.write(b"foo") foo.flush() # Force block commit - f.write("0123456789") + f.write(b"0123456789") # Other file not committed. Block not written to keep yet. self.assertEqual( c._get_manifest_text(".", @@ -1112,15 +1239,15 @@ class NewCollectionTestCaseWithServers(run_test_server.TestCaseWithServers): def test_only_small_blocks_are_packed_together(self): c = Collection() # Write a couple of small files, - f = c.open("count.txt", "w") - f.write("0123456789") + f = c.open("count.txt", "wb") + f.write(b"0123456789") f.close(flush=False) - foo = c.open("foo.txt", "w") - foo.write("foo") + foo = c.open("foo.txt", "wb") + foo.write(b"foo") foo.close(flush=False) # Then, write a big file, it shouldn't be packed with the ones above - big = c.open("bigfile.txt", "w") - big.write("x" * 1024 * 1024 * 33) # 33 MB > KEEP_BLOCK_SIZE/2 + big = c.open("bigfile.txt", "wb") + big.write(b"x" * 1024 * 1024 * 33) # 33 MB > KEEP_BLOCK_SIZE/2 big.close(flush=False) self.assertEqual( c.manifest_text("."), @@ -1129,18 +1256,18 @@ class NewCollectionTestCaseWithServers(run_test_server.TestCaseWithServers): def test_flush_after_small_block_packing(self): c = Collection() # Write a couple of small files, - f = c.open("count.txt", "w") - f.write("0123456789") + f = c.open("count.txt", "wb") + f.write(b"0123456789") f.close(flush=False) - foo = c.open("foo.txt", "w") - foo.write("foo") + foo = c.open("foo.txt", "wb") + foo.write(b"foo") foo.close(flush=False) self.assertEqual( c.manifest_text(), '. a8430a058b8fbf408e1931b794dbd6fb+13 0:10:count.txt 10:3:foo.txt\n') - f = c.open("count.txt", "r+") + f = c.open("count.txt", "rb+") f.close(flush=True) self.assertEqual( @@ -1150,19 +1277,19 @@ class NewCollectionTestCaseWithServers(run_test_server.TestCaseWithServers): def test_write_after_small_block_packing2(self): c = Collection() # Write a couple of small files, - f = c.open("count.txt", "w") - f.write("0123456789") + f = c.open("count.txt", "wb") + f.write(b"0123456789") f.close(flush=False) - foo = c.open("foo.txt", "w") - foo.write("foo") + foo = c.open("foo.txt", "wb") + foo.write(b"foo") foo.close(flush=False) self.assertEqual( c.manifest_text(), '. a8430a058b8fbf408e1931b794dbd6fb+13 0:10:count.txt 10:3:foo.txt\n') - f = c.open("count.txt", "r+") - f.write("abc") + f = c.open("count.txt", "rb+") + f.write(b"abc") f.close(flush=False) self.assertEqual( @@ -1170,6 +1297,21 @@ class NewCollectionTestCaseWithServers(run_test_server.TestCaseWithServers): '. 900150983cd24fb0d6963f7d28e17f72+3 a8430a058b8fbf408e1931b794dbd6fb+13 0:3:count.txt 6:7:count.txt 13:3:foo.txt\n') + def test_small_block_packing_with_overwrite(self): + c = Collection() + c.open("b1", "wb").close() + c["b1"].writeto(0, b"b1", 0) + + c.open("b2", "wb").close() + c["b2"].writeto(0, b"b2", 0) + + c["b1"].writeto(0, b"1b", 0) + + self.assertEquals(c.manifest_text(), ". ed4f3f67c70b02b29c50ce1ea26666bd+4 0:2:b1 2:2:b2\n") + self.assertEquals(c["b1"].manifest_text(), ". ed4f3f67c70b02b29c50ce1ea26666bd+4 0:2:b1\n") + self.assertEquals(c["b2"].manifest_text(), ". ed4f3f67c70b02b29c50ce1ea26666bd+4 2:2:b2\n") + + class CollectionCreateUpdateTest(run_test_server.TestCaseWithServers): MAIN_SERVER = {} KEEP_SERVER = {} @@ -1183,8 +1325,8 @@ class CollectionCreateUpdateTest(run_test_server.TestCaseWithServers): self.assertEqual(c.portable_data_hash(), "d41d8cd98f00b204e9800998ecf8427e+0") self.assertEqual(c.api_response()["portable_data_hash"], "d41d8cd98f00b204e9800998ecf8427e+0" ) - with c.open("count.txt", "w") as f: - f.write("0123456789") + with c.open("count.txt", "wb") as f: + f.write(b"0123456789") self.assertEqual(c.portable_manifest_text(), ". 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n") @@ -1193,20 +1335,24 @@ class CollectionCreateUpdateTest(run_test_server.TestCaseWithServers): def test_create_and_save(self): c = self.create_count_txt() c.save() - self.assertRegexpMatches(c.manifest_text(), r"^\. 781e5e245d69b566979b86e28d23f2c7\+10\+A[a-f0-9]{40}@[a-f0-9]{8} 0:10:count\.txt$",) + self.assertRegex( + c.manifest_text(), + r"^\. 781e5e245d69b566979b86e28d23f2c7\+10\+A[a-f0-9]{40}@[a-f0-9]{8} 0:10:count\.txt$",) def test_create_and_save_new(self): c = self.create_count_txt() c.save_new() - self.assertRegexpMatches(c.manifest_text(), r"^\. 781e5e245d69b566979b86e28d23f2c7\+10\+A[a-f0-9]{40}@[a-f0-9]{8} 0:10:count\.txt$",) + self.assertRegex( + c.manifest_text(), + r"^\. 781e5e245d69b566979b86e28d23f2c7\+10\+A[a-f0-9]{40}@[a-f0-9]{8} 0:10:count\.txt$",) def test_create_diff_apply(self): c1 = self.create_count_txt() c1.save() c2 = Collection(c1.manifest_locator()) - with c2.open("count.txt", "w") as f: - f.write("abcdefg") + with c2.open("count.txt", "wb") as f: + f.write(b"abcdefg") diff = c1.diff(c2) @@ -1233,8 +1379,8 @@ class CollectionCreateUpdateTest(run_test_server.TestCaseWithServers): c1.save() c2 = arvados.collection.Collection(c1.manifest_locator()) - with c2.open("count.txt", "w") as f: - f.write("abcdefg") + with c2.open("count.txt", "wb") as f: + f.write(b"abcdefg") c2.save() @@ -1247,17 +1393,24 @@ class CollectionCreateUpdateTest(run_test_server.TestCaseWithServers): c1 = self.create_count_txt() c1.save() - with c1.open("count.txt", "w") as f: - f.write("XYZ") + with c1.open("count.txt", "wb") as f: + f.write(b"XYZ") c2 = arvados.collection.Collection(c1.manifest_locator()) - with c2.open("count.txt", "w") as f: - f.write("abcdefg") + with c2.open("count.txt", "wb") as f: + f.write(b"abcdefg") c2.save() c1.update() - self.assertRegexpMatches(c1.manifest_text(), r"\. e65075d550f9b5bf9992fa1d71a131be\+3\S* 7ac66c0f148de9519b8bd264312c4d64\+7\S* 0:3:count\.txt 3:7:count\.txt~\d\d\d\d\d\d\d\d-\d\d\d\d\d\d~conflict~$") + self.assertRegex( + c1.manifest_text(), + r"\. e65075d550f9b5bf9992fa1d71a131be\+3\S* 7ac66c0f148de9519b8bd264312c4d64\+7\S* 0:3:count\.txt 3:7:count\.txt~\d\d\d\d\d\d\d\d-\d\d\d\d\d\d~conflict~$") + + def test_pdh_is_native_str(self): + c1 = self.create_count_txt() + pdh = c1.portable_data_hash() + self.assertEqual(type(''), type(pdh)) if __name__ == '__main__':