sdk/python/test_keep_client.py

   1 # usage example:
   2 #
   3 # ARVADOS_API_TOKEN=abc ARVADOS_API_HOST=arvados.local python -m unittest discover
   4
   5 import unittest
   6 import arvados
   7 import os
   8 import run_test_server
   9
  10 class KeepTestCase(unittest.TestCase):
  11     @classmethod
  12     def setUpClass(cls):
  13         try:
  14             del os.environ['KEEP_LOCAL_STORE']
  15         except KeyError:
  16             pass
  17         run_test_server.run()
  18         run_test_server.run_keep()
  19
  20     @classmethod
  21     def tearDownClass(cls):
  22         run_test_server.stop()
  23         run_test_server.stop_keep()
  24
  25     def test_KeepBasicRWTest(self):
  26         foo_locator = arvados.Keep.put('foo')
  27         self.assertEqual(foo_locator,
  28                          'acbd18db4cc2f85cedef654fccc4a4d8+3',
  29                          'wrong md5 hash from Keep.put("foo"): ' + foo_locator)
  30         self.assertEqual(arvados.Keep.get(foo_locator),
  31                          'foo',
  32                          'wrong content from Keep.get(md5("foo"))')
  33
  34     def test_KeepBinaryRWTest(self):
  35         blob_str = '\xff\xfe\xf7\x00\x01\x02'
  36         blob_locator = arvados.Keep.put(blob_str)
  37         self.assertEqual(blob_locator,
  38                          '7fc7c53b45e53926ba52821140fef396+6',
  39                          ('wrong locator from Keep.put(<binarydata>):' +
  40                           blob_locator))
  41         self.assertEqual(arvados.Keep.get(blob_locator),
  42                          blob_str,
  43                          'wrong content from Keep.get(md5(<binarydata>))')
  44
  45     def test_KeepLongBinaryRWTest(self):
  46         blob_str = '\xff\xfe\xfd\xfc\x00\x01\x02\x03'
  47         for i in range(0,23):
  48             blob_str = blob_str + blob_str
  49         blob_locator = arvados.Keep.put(blob_str)
  50         self.assertEqual(blob_locator,
  51                          '84d90fc0d8175dd5dcfab04b999bc956+67108864',
  52                          ('wrong locator from Keep.put(<binarydata>): ' +
  53                           blob_locator))
  54         self.assertEqual(arvados.Keep.get(blob_locator),
  55                          blob_str,
  56                          'wrong content from Keep.get(md5(<binarydata>))')
  57
  58     def test_KeepSingleCopyRWTest(self):
  59         blob_str = '\xff\xfe\xfd\xfc\x00\x01\x02\x03'
  60         blob_locator = arvados.Keep.put(blob_str, copies=1)
  61         self.assertEqual(blob_locator,
  62                          'c902006bc98a3eb4a3663b65ab4a6fab+8',
  63                          ('wrong locator from Keep.put(<binarydata>): ' +
  64                           blob_locator))
  65         self.assertEqual(arvados.Keep.get(blob_locator),
  66                          blob_str,
  67                          'wrong content from Keep.get(md5(<binarydata>))')
  68
  69 class KeepPermissionTestCase(unittest.TestCase):
  70     @classmethod
  71     def setUpClass(cls):
  72         try:
  73             del os.environ['KEEP_LOCAL_STORE']
  74         except KeyError:
  75             pass
  76         run_test_server.run()
  77         run_test_server.run_keep(blob_signing_key='abcdefghijk0123456789',
  78                                  enforce_permissions=True)
  79
  80     @classmethod
  81     def tearDownClass(cls):
  82         run_test_server.stop()
  83         run_test_server.stop_keep()
  84
  85     def test_KeepBasicRWTest(self):
  86         run_test_server.authorize_with('active')
  87         foo_locator = arvados.Keep.put('foo')
  88         self.assertRegexpMatches(
  89             foo_locator,
  90             r'^acbd18db4cc2f85cedef654fccc4a4d8\+3\+A[a-f0-9]+@[a-f0-9]+$',
  91             'invalid locator from Keep.put("foo"): ' + foo_locator)
  92         self.assertEqual(arvados.Keep.get(foo_locator),
  93                          'foo',
  94                          'wrong content from Keep.get(md5("foo"))')
  95
  96         # With Keep permissions enabled, a GET request without a signature will fail.
  97         bar_locator = arvados.Keep.put('bar')
  98         self.assertRegexpMatches(
  99             bar_locator,
 100             r'^37b51d194a7513e45b56f6524f2d51f2\+3\+A[a-f0-9]+@[a-f0-9]+$',
 101             'invalid locator from Keep.put("bar"): ' + bar_locator)
 102         self.assertRaises(arvados.errors.NotFoundError,
 103                           arvados.Keep.get,
 104                           "37b51d194a7513e45b56f6524f2d51f2")
 105
 106         # A request without an API token will also fail.
 107         del arvados.config.settings()["ARVADOS_API_TOKEN"]
 108         self.assertRaises(arvados.errors.NotFoundError,
 109                           arvados.Keep.get,
 110                           bar_locator)
 111
 112 # KeepOptionalPermission: starts Keep with --permission-key-file
 113 # but not --enforce-permissions (i.e. generate signatures on PUT
 114 # requests, but do not require them for GET requests)
 115 #
 116 # All of these requests should succeed when permissions are optional:
 117 # * authenticated request, signed locator
 118 # * authenticated request, unsigned locator
 119 # * unauthenticated request, signed locator
 120 # * unauthenticated request, unsigned locator
 121
 122 class KeepOptionalPermission(unittest.TestCase):
 123     @classmethod
 124     def setUpClass(cls):
 125         try:
 126             del os.environ['KEEP_LOCAL_STORE']
 127         except KeyError:
 128             pass
 129         run_test_server.run()
 130         run_test_server.run_keep(blob_signing_key='abcdefghijk0123456789',
 131                                  enforce_permissions=False)
 132
 133     @classmethod
 134     def tearDownClass(cls):
 135         run_test_server.stop()
 136         run_test_server.stop_keep()
 137
 138     def test_KeepAuthenticatedSignedTest(self):
 139         run_test_server.authorize_with('active')
 140         signed_locator = arvados.Keep.put('foo')
 141         self.assertRegexpMatches(
 142             signed_locator,
 143             r'^acbd18db4cc2f85cedef654fccc4a4d8\+3\+A[a-f0-9]+@[a-f0-9]+$',
 144             'invalid locator from Keep.put("foo"): ' + signed_locator)
 145         self.assertEqual(arvados.Keep.get(signed_locator),
 146                          'foo',
 147                          'wrong content from Keep.get(md5("foo"))')
 148
 149     def test_KeepAuthenticatedUnsignedTest(self):
 150         run_test_server.authorize_with('active')
 151         signed_locator = arvados.Keep.put('foo')
 152         self.assertRegexpMatches(
 153             signed_locator,
 154             r'^acbd18db4cc2f85cedef654fccc4a4d8\+3\+A[a-f0-9]+@[a-f0-9]+$',
 155             'invalid locator from Keep.put("foo"): ' + signed_locator)
 156         self.assertEqual(arvados.Keep.get("acbd18db4cc2f85cedef654fccc4a4d8"),
 157                          'foo',
 158                          'wrong content from Keep.get(md5("foo"))')
 159
 160     def test_KeepUnauthenticatedSignedTest(self):
 161         # Since --enforce-permissions is not in effect, GET requests
 162         # need not be authenticated.
 163         run_test_server.authorize_with('active')
 164         signed_locator = arvados.Keep.put('foo')
 165         self.assertRegexpMatches(
 166             signed_locator,
 167             r'^acbd18db4cc2f85cedef654fccc4a4d8\+3\+A[a-f0-9]+@[a-f0-9]+$',
 168             'invalid locator from Keep.put("foo"): ' + signed_locator)
 169
 170         del arvados.config.settings()["ARVADOS_API_TOKEN"]
 171         self.assertEqual(arvados.Keep.get(signed_locator),
 172                          'foo',
 173                          'wrong content from Keep.get(md5("foo"))')
 174
 175     def test_KeepUnauthenticatedUnsignedTest(self):
 176         # Since --enforce-permissions is not in effect, GET requests
 177         # need not be authenticated.
 178         run_test_server.authorize_with('active')
 179         signed_locator = arvados.Keep.put('foo')
 180         self.assertRegexpMatches(
 181             signed_locator,
 182             r'^acbd18db4cc2f85cedef654fccc4a4d8\+3\+A[a-f0-9]+@[a-f0-9]+$',
 183             'invalid locator from Keep.put("foo"): ' + signed_locator)
 184
 185         del arvados.config.settings()["ARVADOS_API_TOKEN"]
 186         self.assertEqual(arvados.Keep.get("acbd18db4cc2f85cedef654fccc4a4d8"),
 187                          'foo',
 188                          'wrong content from Keep.get(md5("foo"))')