X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/5624fec61db977d386ce03ca333241c74ca251b5..63cfe7a9b391e1a07c6c6c8b0fab10b1c875f1be:/sdk/python/tests/test_arv_keepdocker.py

diff --git a/sdk/python/tests/test_arv_keepdocker.py b/sdk/python/tests/test_arv_keepdocker.py
index 9fcf2f1bab..358752a74d 100644
--- a/sdk/python/tests/test_arv_keepdocker.py
+++ b/sdk/python/tests/test_arv_keepdocker.py
@@ -1,72 +1,57 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
+from __future__ import absolute_import
 import arvados
 import hashlib
-import io
 import mock
 import os
 import subprocess
 import sys
 import tempfile
 import unittest
+import logging
 
 import arvados.commands.keepdocker as arv_keepdocker
-import arvados_testutil as tutil
-import run_test_server
+from . import arvados_testutil as tutil
+from . import run_test_server
 
 
 class StopTest(Exception):
     pass
 
 
-class ArvKeepdockerTestCase(unittest.TestCase):
-    def run_arv_keepdocker(self, args):
+class ArvKeepdockerTestCase(unittest.TestCase, tutil.VersionChecker):
+    def run_arv_keepdocker(self, args, err):
         sys.argv = ['arv-keepdocker'] + args
-        return arv_keepdocker.main()
+        log_handler = logging.StreamHandler(err)
+        arv_keepdocker.logger.addHandler(log_handler)
+        try:
+            return arv_keepdocker.main()
+        finally:
+            arv_keepdocker.logger.removeHandler(log_handler)
 
     def test_unsupported_arg(self):
         with self.assertRaises(SystemExit):
-            self.run_arv_keepdocker(['-x=unknown'])
+            self.run_arv_keepdocker(['-x=unknown'], sys.stderr)
 
     def test_version_argument(self):
-        err = io.BytesIO()
-        out = io.BytesIO()
-        with tutil.redirected_streams(stdout=out, stderr=err):
+        with tutil.redirected_streams(
+                stdout=tutil.StringIO, stderr=tutil.StringIO) as (out, err):
             with self.assertRaises(SystemExit):
-                self.run_arv_keepdocker(['--version'])
-        self.assertEqual(out.getvalue(), '')
-        self.assertRegexpMatches(err.getvalue(), "[0-9]+\.[0-9]+\.[0-9]+")
-
-    def test_migrate19(self):
-        try:
-            sys.argv = ['arv-migrate-docker19']
-
-            added = arv_keepdocker.migrate19()
-            self.assertEqual(len(added), 1)
-            self.assertEqual(added[0]['link_class'], 'docker_image_migration')
-            self.assertEqual(added[0]['name'], 'migrate_1.9_1.10')
-            self.assertEqual(added[0]['tail_uuid'], 'fa3c1a9cb6783f85f2ecda037e07b8c3+167')
-            self.assertEqual(added[0]['head_uuid'], 'd740a57097711e08eb9b2a93518f20ab+174')
-
-            added = arv_keepdocker.migrate19()
-            self.assertEqual(added, [])
-        finally:
-            run_test_server.reset()
+                self.run_arv_keepdocker(['--version'], sys.stderr)
+        self.assertVersionOutput(out, err)
 
     @mock.patch('arvados.commands.keepdocker.find_image_hashes',
                 return_value=['abc123'])
     @mock.patch('arvados.commands.keepdocker.find_one_image_hash',
                 return_value='abc123')
     def test_image_format_compatibility(self, _1, _2):
-        old_id = hashlib.sha256('old').hexdigest()
-        new_id = 'sha256:'+hashlib.sha256('new').hexdigest()
+        old_id = hashlib.sha256(b'old').hexdigest()
+        new_id = 'sha256:'+hashlib.sha256(b'new').hexdigest()
         for supported, img_id, expect_ok in [
                 (['v1'], old_id, True),
                 (['v1'], new_id, False),
-                (None, old_id, True),
-                ([], old_id, True),
-                ([], new_id, True),
+                (None, old_id, False),
+                ([], old_id, False),
+                ([], new_id, False),
                 (['v1', 'v2'], new_id, True),
                 (['v1'], new_id, False),
                 (['v2'], new_id, True)]:
@@ -77,10 +62,10 @@ class ArvKeepdockerTestCase(unittest.TestCase):
             else:
                 fakeDD['dockerImageFormats'] = supported
 
-            err = io.BytesIO()
-            out = io.BytesIO()
+            err = tutil.StringIO()
+            out = tutil.StringIO()
 
-            with tutil.redirected_streams(stdout=out, stderr=err), \
+            with tutil.redirected_streams(stdout=out), \
                  mock.patch('arvados.api') as api, \
                  mock.patch('arvados.commands.keepdocker.popen_docker',
                             return_value=subprocess.Popen(
@@ -91,28 +76,28 @@ class ArvKeepdockerTestCase(unittest.TestCase):
                  self.assertRaises(StopTest if expect_ok else SystemExit):
 
                 api()._rootDesc = fakeDD
-                self.run_arv_keepdocker(['--force', 'testimage'])
+                self.run_arv_keepdocker(['--force', 'testimage'], err)
 
             self.assertEqual(out.getvalue(), '')
             if expect_ok:
-                self.assertNotRegexpMatches(
+                self.assertNotRegex(
                     err.getvalue(), "refusing to store",
                     msg=repr((supported, img_id)))
             else:
-                self.assertRegexpMatches(
+                self.assertRegex(
                     err.getvalue(), "refusing to store",
                     msg=repr((supported, img_id)))
             if not supported:
-                self.assertRegexpMatches(
+                self.assertRegex(
                     err.getvalue(),
                     "server does not specify supported image formats",
                     msg=repr((supported, img_id)))
 
         fakeDD = arvados.api('v1')._rootDesc
         fakeDD['dockerImageFormats'] = ['v1']
-        err = io.BytesIO()
-        out = io.BytesIO()
-        with tutil.redirected_streams(stdout=out, stderr=err), \
+        err = tutil.StringIO()
+        out = tutil.StringIO()
+        with tutil.redirected_streams(stdout=out), \
              mock.patch('arvados.api') as api, \
              mock.patch('arvados.commands.keepdocker.popen_docker',
                         return_value=subprocess.Popen(
@@ -123,5 +108,5 @@ class ArvKeepdockerTestCase(unittest.TestCase):
              self.assertRaises(StopTest):
             api()._rootDesc = fakeDD
             self.run_arv_keepdocker(
-                ['--force', '--force-image-format', 'testimage'])
-        self.assertRegexpMatches(err.getvalue(), "forcing incompatible image")
+                ['--force', '--force-image-format', 'testimage'], err)
+        self.assertRegex(err.getvalue(), "forcing incompatible image")