future-proof test suite

 * Prefer <foo>.assert_called_* methods over assert <foo>.called_*

 * test_create_mixin: replace a MockCoroutine that had been mocking a
   non-async method with a regular Mock object

 * Box: update base64 sha that had been incorrectly calculated.

 * Update celery task move/copy test infrastructure.  unittest-style
   test classes weren't working well with our task tests and fixtures.
   Switch to pytest style setup/teardown via conftest.py. Fixtures
   have been moved to conftest as well.

 * Add some clarifying documentation and debug logging to .tasks.core

Author: felliott

tests/providers/box/test_provider.py

@@ -61,7 +61,7 @@ def file_content():
 
 @pytest.fixture
 def file_sha_b64():
-    return 'KrIc0sRT6ELxGc/oX3hZvabgltE='
+    return '2jmj7l5rSw0yVb/vlWAYkK/YBwk='
 
 
 @pytest.fixture
@@ -342,7 +342,7 @@ async def test_upload_limit_contiguous_upload(self, provider, file_stream):
         path = WaterButlerPath('/foobah/', _ids=('0', '1'))
         await provider.upload(file_stream, path)
 
-        assert provider._contiguous_upload.called_with(file_stream, path)
+        provider._contiguous_upload.assert_called_with(path, file_stream)
         assert not provider._chunked_upload.called
 
         provider.NONCHUNKED_UPLOAD_LIMIT = NONCHUNKED_UPLOAD_LIMIT
@@ -361,7 +361,7 @@ async def test_upload_limit_chunked_upload(self, provider, file_stream):
         path = WaterButlerPath('/foobah/', _ids=('0', '1'))
         await provider.upload(file_stream, path)
 
-        assert provider._chunked_upload.called_with(file_stream, path)
+        provider._chunked_upload.assert_called_with(path, file_stream)
         assert not provider._contiguous_upload.called
 
         provider.NONCHUNKED_UPLOAD_LIMIT = NONCHUNKED_UPLOAD_LIMIT
@@ -387,9 +387,9 @@ async def test_chunked_upload(self, provider, file_stream, file_sha_b64,
         path = WaterButlerPath('/foobah/', _ids=('0', '1'))
         await provider._chunked_upload(path, file_stream)
 
-        assert provider._create_chunked_upload_session.called_with(path, file_stream)
-        assert provider._upload_parts.called_with(file_stream, session_metadata)
-        assert provider._complete_chunked_upload_session.called_with(session_metadata,
+        provider._create_chunked_upload_session.assert_called_with(path, file_stream)
+        provider._upload_parts.assert_called_with(file_stream, session_metadata)
+        provider._complete_chunked_upload_session.assert_called_with(session_metadata,
                                                                      parts_manifest,
                                                                      file_sha_b64)
 

tests/providers/s3/test_provider.py

@@ -458,7 +458,7 @@ async def test_chunked_upload_limit_chunked(self, provider, file_stream, mock_ti
 
         await provider.upload(file_stream, path)
 
-        assert provider._chunked_upload.called_with(file_stream, path)
+        provider._chunked_upload.assert_called_with(file_stream, path)
 
         # Fixtures are shared between tests. Need to revert the settings back.
         provider.CONTIGUOUS_UPLOAD_SIZE_LIMIT = pd_settings.CONTIGUOUS_UPLOAD_SIZE_LIMIT
@@ -477,7 +477,7 @@ async def test_chunked_upload_limit_contiguous(self, provider, file_stream, mock
 
         await provider.upload(file_stream, path)
 
-        assert provider._contiguous_upload.called_with(file_stream, path)
+        provider._contiguous_upload.assert_called_with(file_stream, path)
 
         provider.CONTIGUOUS_UPLOAD_SIZE_LIMIT = pd_settings.CONTIGUOUS_UPLOAD_SIZE_LIMIT
         provider.CHUNK_SIZE = pd_settings.CHUNK_SIZE
@@ -1277,7 +1277,7 @@ async def test_intra_copy(self, provider, file_header_metadata, mock_time):
         metadata, exists = await provider.intra_copy(provider, source_path, dest_path)
 
 
-        assert provider._check_region.called
+        provider._check_region.assert_called()
 
         assert metadata.kind == 'file'
         assert not exists

tests/server/api/v1/test_create_mixin.py

@@ -35,14 +35,17 @@ async def test_postvalidate_put_folder(self, http_request):
         handler.kind = 'folder'
         handler.get_query_argument = mock.Mock(return_value='child!')
         handler.provider.exists = MockCoroutine(return_value=False)
-        handler.provider.can_duplicate_names = MockCoroutine(return_value=False)
+        handler.provider.can_duplicate_names = mock.Mock(return_value=False)
 
         await handler.postvalidate_put()
 
         assert handler.target_path == WaterButlerPath('/Folder1/child!/')
         handler.get_query_argument.assert_called_once_with('name', default=None)
-        handler.provider.exists.assert_called_once_with(
-            WaterButlerPath('/Folder1/child!', prepend=None))
+
+        handler.provider.exists.assert_has_calls([
+            mock.call(WaterButlerPath('/Folder1/child!', prepend=None)),
+            mock.call(WaterButlerPath('/Folder1/child!', prepend=None))
+        ])
 
     @pytest.mark.asyncio
     async def test_postvalidate_put_folder_naming_conflict(self, http_request):

tests/tasks/conftest.py

@@ -0,0 +1,100 @@
+import time
+import asyncio
+from unittest import mock
+
+import pytest
+
+from waterbutler.core import remote_logging
+from waterbutler.core import utils as core_utils
+from waterbutler.core.path import WaterButlerPath
+
+import tests.utils as test_utils
+
+
+# Task testing doesn't play nice with unittest-style tests, so fallback to regular pytest-style
+# setup/teardown.
+
+def pytest_runtest_setup(item):
+    policy = asyncio.get_event_loop_policy()
+    policy.get_event_loop().close()
+    event_loop = policy.new_event_loop()
+    policy.set_event_loop(event_loop)
+
+
+def pytest_runtest_teardown(item):
+    policy = asyncio.get_event_loop_policy()
+    policy.get_event_loop().close()
+
+
+# Fixtures for task tests
+
+@pytest.fixture(autouse=True)
+def log_to_keen(monkeypatch):
+    mock_log_to_keen = test_utils.MockCoroutine()
+    monkeypatch.setattr(remote_logging, 'log_to_keen', mock_log_to_keen)
+    return mock_log_to_keen
+
+
+@pytest.fixture
+def callback(monkeypatch):
+    mock_request = test_utils.MockCoroutine(return_value=(200, b'meowmeowmeow'))
+    monkeypatch.setattr(core_utils, 'send_signed_request', mock_request)
+    return mock_request
+
+
+@pytest.fixture
+def FAKE_TIME():
+    return 1454684930.0
+
+
+@pytest.fixture
+def mock_time(monkeypatch, FAKE_TIME):
+    mock_time = mock.Mock(return_value=FAKE_TIME)
+    monkeypatch.setattr(time, 'time', mock_time)
+
+
+@pytest.fixture
+def src_path():
+    return WaterButlerPath('/user/bin/python')
+
+
+@pytest.fixture
+def dest_path():
+    return WaterButlerPath('/usr/bin/golang')
+
+
+@pytest.fixture
+def src_bundle(src_path):
+    return {
+        'nid': 'mst3k',
+        'path': src_path,
+        'provider': {
+            'name': 'src',
+            'auth': {
+                'callback_url': '',
+            },
+            'settings': {},
+            'credentials': {},
+        }
+    }
+
+
+@pytest.fixture
+def dest_bundle(dest_path):
+    return {
+        'nid': 'fbi4u',
+        'path': dest_path,
+        'provider': {
+            'name': 'dest',
+            'auth': {
+                'callback_url': '',
+            },
+            'settings': {},
+            'credentials': {},
+        }
+    }
+
+
+@pytest.fixture
+def bundles(src_bundle, dest_bundle):
+    return src_bundle, dest_bundle