def test_upload_file(self, resolwe_mock, sys_mock, requests_mock):
# Example file:
fn = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'files', 'example.fastq')
resolwe_mock.url = 'http://some/url'
resolwe_mock.auth = MagicMock()
# Supress upload progress messages:
sys_mock.sys.stdout.write = MagicMock()
sys_mock.sys.stdout.flush = MagicMock()
# Immitate response form server - always status 200
requests_response = {'files': [{'temp': 'fake_name'}]}
requests_mock.post.return_value = MagicMock(status_code=200, **{'json.return_value': requests_response})
resolwe = Resolwe._upload_file(resolwe_mock, fn)
self.assertEqual(resolwe, 'fake_name')
# Immitate response form server - always status 400
requests_mock.post.return_value = MagicMock(status_code=400)
resolwe = Resolwe._upload_file(resolwe_mock, fn)
self.assertIsNone(resolwe)
# Immitate response form server - one status 400, but other 200
requests_response = {'files': [{'temp': 'fake_name'}]}
response_ok = MagicMock(status_code=200, **{'json.return_value': requests_response})
response_fails = MagicMock(status_code=400)
requests_mock.post.side_effect = [response_ok, response_fails, response_ok, response_ok]
resolwe = Resolwe._upload_file(resolwe_mock, fn)
self.assertEqual(resolwe, 'fake_name')
def test_empty_file_list(self, resolwe_mock, os_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isfile.return_value = True
Resolwe.download_files(resolwe_mock, [])
resolwe_mock.logger.info.assert_called_once_with("No files to download.")
def test_bad_descriptor_input(self, resolwe_mock):
# Raise error is only one of deswcriptor/descriptor_schema is given:
message = "Set both or neither descriptor and descriptor_schema."
with six.assertRaisesRegex(self, ValueError, message):
Resolwe.run(resolwe_mock, descriptor="a")
with six.assertRaisesRegex(self, ValueError, message):
Resolwe.run(resolwe_mock, descriptor_schema="a")
def test_init(self, resolwe_mock, resauth_mock, slumber_mock, resolwe_querry_mock, log_mock):
Resolwe.__init__(resolwe_mock, 'a', 'b', 'http://some/url')
self.assertEqual(resauth_mock.call_count, 1)
self.assertEqual(slumber_mock.API.call_count, 1)
# There are four instances of ResolweQuerry in init: data, process, sample and collection:
self.assertEqual(resolwe_querry_mock.call_count, 4)
self.assertEqual(log_mock.getLogger.call_count, 1)
def test_file_processing(self, resolwe_mock, data_mock):
resolwe_mock.api = MagicMock(
**{
'process.get.return_value': self.process_mock,
'data.post.return_value': {}
})
resolwe_mock._process_file_field = MagicMock(
side_effect=[{
'file': 'file_name1',
'file_temp': 'temp_file1'
}, {
'file': 'file_name2',
'file_temp': 'temp_file2'
}, {
'file': 'file_name3',
'file_temp': 'temp_file3'
}])
data_mock.return_value = "Data object"
Resolwe.run(resolwe_mock,
input={
"src": "/path/to/file1",
"src_list": ["/path/to/file2", "/path/to/file3"]
})
def test_init(self, resolwe_mock, resauth_mock, slumber_mock, resolwe_api_mock,
resolwe_querry_mock, log_mock):
Resolwe.__init__(resolwe_mock, 'a', 'b', 'http://some/url')
# There are ten instances of ResolweQuery in init: data, process, sample, relations,
# collection, descriptorschema, user, gorup, feature and mapping.
self.assertEqual(resolwe_querry_mock.call_count, 10)
self.assertEqual(log_mock.getLogger.call_count, 1)
def test_empty_file_list(self, resolwe_mock, os_mock):
resolwe_mock.configure_mock(**self.config)
Resolwe._download_files(resolwe_mock, [])
resolwe_mock.logger.info.assert_called_once_with(
"No files to download.")
def test_update_existing_process(self):
"""If process exists, process.filter returns list with exactly one element."""
# local process version > server process version
self.resolwe_mock.process.filter.return_value = [
MagicMock(version='1.0.12')
]
Resolwe._register(self.resolwe_mock, self.yaml_file,
"alignment-bowtie")
self.assertEqual(self.resolwe_mock.api.process.post.call_count, 1)
self.assertEqual(
self.resolwe_mock.api.process.post.call_args[0][0]['version'],
'1.0.13')
self.resolwe_mock.reset_mock()
# local process version = server process version
self.resolwe_mock.process.filter.return_value = [
MagicMock(version='1.0.13')
]
Resolwe._register(self.resolwe_mock, self.yaml_file,
"alignment-bowtie")
self.assertEqual(self.resolwe_mock.api.process.post.call_count, 1)
self.assertEqual(
self.resolwe_mock.api.process.post.call_args[0][0]['version'],
'1.0.14')
def test_print_upload_processes(self, resolwe_mock, sys_mock):
# Check output is correct
resolwe_mock.processes.return_value = PROCESS_SAMPLE
sys_mock.stdout.write = MagicMock()
Resolwe.print_upload_processes(resolwe_mock)
sys_mock.stdout.write.assert_called_with('Upload NGS reads\n')
def test_fail_if_bad_dir(self, resolwe_mock, os_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isdir.return_value = False
message = "Download directory does not exist: .*"
with six.assertRaisesRegex(self, ValueError, message):
Resolwe._download_files(resolwe_mock, self.file_list)
def test_completely_new_process(self):
"""If process with given slug does not exist, process.filter will return empty list"""
self.resolwe_mock.process.filter.return_value = []
Resolwe._register(self.resolwe_mock, self.yaml_file,
"alignment-bowtie")
self.assertEqual(self.resolwe_mock.api.process.post.call_count, 1)
def test_tools_file_not_found(self, os_mock):
resolwe.TOOLS_REMOTE_HOST = 'something'
os_mock.configure_mock(**{'path.isfile.return_value': False})
message = r"Tools file not found: .*"
with six.assertRaisesRegex(self, ValueError, message):
Resolwe._upload_tools(self.resolwe_mock, self.tools)
def test_log_if_returncode_gt1(self, subprocess_mock):
fake_subprocess = MagicMock(returncode=2, **{'communicate.return_value': ['Standard output...', 'b']})
subprocess_mock.Popen = MagicMock(return_value=fake_subprocess)
Resolwe._upload_tools(self.resolwe_mock, self.tools)
self.assertEqual(self.resolwe_mock.logger.warning.call_count, 1)
def test_invalid_file_name(self, resolwe_mock, os_mock):
os_mock.configure_mock(**{'path.isfile.return_value': False})
message = r"File .* not found."
with six.assertRaisesRegex(self, ValueError, message):
Resolwe._process_file_field(resolwe_mock, "/bad/path/to/file")
self.assertEqual(resolwe_mock._upload_file.call_count, 0)
def test_env_variables(self, resauth_mock):
# Ensure environmental variables are not set.
os.environ.pop('RESOLWE_API_HOST', None)
os.environ.pop('RESOLWE_API_USERNAME', None)
os.environ.pop('RESOLWE_API_PASSWORD', None)
# Default URL should be used by default.
resolwe_api = Resolwe()
self.assertEqual(resolwe_api.url, 'http://localhost:8000')
self.assertEqual(resauth_mock.call_args[0][0], None)
self.assertEqual(resauth_mock.call_args[0][1], None)
# If environment variable is set, it overrides the default URL.
os.environ['RESOLWE_API_USERNAME'] = '******'
os.environ['RESOLWE_API_PASSWORD'] = '******'
os.environ['RESOLWE_HOST_URL'] = 'http://resolwe-api:8000'
resolwe_api = Resolwe()
self.assertEqual(resolwe_api.url, 'http://resolwe-api:8000')
self.assertEqual(resauth_mock.call_args[0][0], 'foo')
self.assertEqual(resauth_mock.call_args[0][1], 'bar')
# `RESOLWE_HOST_URL` takes precedence
os.environ['RESOLWE_API_HOST'] = 'http://resolwe-api:9000'
resolwe_api = Resolwe()
self.assertEqual(resolwe_api.url, 'http://resolwe-api:8000')
self.assertEqual(resauth_mock.call_args[0][0], 'foo')
self.assertEqual(resauth_mock.call_args[0][1], 'bar')
os.environ.pop('RESOLWE_HOST_URL')
resolwe_api = Resolwe()
self.assertEqual(resolwe_api.url, 'http://resolwe-api:9000')
self.assertEqual(resauth_mock.call_args[0][0], 'foo')
self.assertEqual(resauth_mock.call_args[0][1], 'bar')
def test_get_or_run(self, resolwe_mock, data_mock):
resolwe_mock.api = MagicMock(
**{'process.get.return_value': self.process_mock})
Resolwe.get_or_run(resolwe_mock)
self.assertEqual(resolwe_mock.api.data.get_or_create.post.call_count,
1)
def test_init(self, resolwe_mock, resauth_mock, slumber_mock,
resolwe_api_mock, resolwe_querry_mock, log_mock):
Resolwe.__init__(resolwe_mock, 'a', 'b', 'http://some/url')
# There are ten instances of ResolweQuery in init: data, process, sample, relations,
# collection, descriptorschema, user, gorup, feature and mapping.
self.assertEqual(resolwe_querry_mock.call_count, 10)
self.assertEqual(log_mock.getLogger.call_count, 1)
def test_completely_new_process(self):
"""If process with given slug does not exist, process.filter will return empty list"""
self.resolwe_mock.process.filter.return_value = []
Resolwe._register(self.resolwe_mock, self.yaml_file, "alignment-bowtie")
self.assertEqual(self.resolwe_mock.api.process.post.call_count, 1)
self.assertEqual(self.resolwe_mock._version_int_to_string.call_count, 0)
def test_invalid_file_name(self, resolwe_mock, os_mock):
os_mock.configure_mock(**{'path.isfile.return_value': False})
message = r"File .* not found."
with six.assertRaisesRegex(self, ValueError, message):
Resolwe._process_file_field(resolwe_mock, "/bad/path/to/file")
self.assertEqual(resolwe_mock._upload_file.call_count, 0)
def test_bad_descriptor_input(self, resolwe_mock):
# Raise error is only one of deswcriptor/descriptor_schema is given:
message = "Set both or neither descriptor and descriptor_schema."
with six.assertRaisesRegex(self, ValueError, message):
Resolwe.run(resolwe_mock, descriptor="a")
with six.assertRaisesRegex(self, ValueError, message):
Resolwe.run(resolwe_mock, descriptor_schema="a")
def test_fail_if_bad_dir(self, resolwe_mock, os_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isfile.return_value = False
message = "Download directory does not exist: .*"
with six.assertRaisesRegex(self, ValueError, message):
Resolwe.download_files(resolwe_mock, self.file_list)
def test_log_if_returncode_gt1(self, subprocess_mock):
fake_subprocess = MagicMock(returncode=2,
**{'communicate.return_value': ['Standard output...', 'b']})
subprocess_mock.Popen = MagicMock(return_value=fake_subprocess)
Resolwe._upload_tools(self.resolwe_mock, self.tools)
self.assertEqual(self.resolwe_mock.logger.warning.call_count, 1)
def test_bad_inputs(self, resolwe_mock, os_mock):
# Good file, upload fails becouse of bad input keyword
os_mock.path.isfile.return_value = True
resolwe_mock.api = MagicMock(**{'process.get.return_value': self.process_json})
resolwe_mock._upload_file = MagicMock(return_value=None)
message = r'Field .* not in process .* input schema.'
with six.assertRaisesRegex(self, KeyError, message):
Resolwe.run(resolwe_mock, input={"bad_key": "/good/path/to/file"})
def test_raise_if_returncode_1(self, subprocess_mock):
fake_subprocess = MagicMock(returncode=1, **{'communicate.return_value': ['Standard output...', 'b']})
subprocess_mock.Popen = MagicMock(return_value=fake_subprocess)
message = r"Tools file not found: .*"
with six.assertRaisesRegex(self, ValueError, message):
Resolwe._upload_tools(self.resolwe_mock, self.tools)
def test_logger_calls(self, subprocess_mock):
fake_subprocess = MagicMock(returncode=0, **{'communicate.return_value': ['Standard output...', ' ']})
subprocess_mock.Popen = MagicMock(return_value=fake_subprocess)
Resolwe._upload_tools(self.resolwe_mock, self.tools)
self.resolwe_mock.logger.info.assert_called_with('Standard output...')
# confirm that logger.warning was not called - all went ok...
self.assertEqual(self.resolwe_mock.logger.warning.call_count, 0)
def test_raise_if_returncode_1(self, subprocess_mock):
fake_subprocess = MagicMock(returncode=1,
**{'communicate.return_value': ['Standard output...', 'b']})
subprocess_mock.Popen = MagicMock(return_value=fake_subprocess)
message = r"Something wrong while SCP for tool: .*"
with six.assertRaisesRegex(self, ValueError, message):
Resolwe._upload_tools(self.resolwe_mock, self.tools)
def test_returns_two_processes(self):
"""
If process process.filter will return a list of more than one
process, this is a sign of some unexpected behaviour."""
self.resolwe_mock.process.filter.return_value = [{}, {}]
message = r"Unexpected behaviour at get process with slug .*"
with six.assertRaisesRegex(self, ValueError, message):
Resolwe._register(self.resolwe_mock, self.yaml_file, "alignment-bowtie")
def test_wrap_list(self, resolwe_mock):
process = self.process_json[0]
Resolwe._process_inputs(resolwe_mock, {"src_list": ["/path/to/file"]}, process)
resolwe_mock._process_file_field.assert_called_once_with('/path/to/file')
resolwe_mock.reset_mock()
Resolwe._process_inputs(resolwe_mock, {"src_list": "/path/to/file"}, process)
resolwe_mock._process_file_field.assert_called_once_with('/path/to/file')
def test_bad_inputs(self, resolwe_mock, os_mock):
# Good file, upload fails becouse of bad input keyword
os_mock.path.isfile.return_value = True
process = self.process_json[0]
resolwe_mock._upload_file = MagicMock(return_value=None)
message = r'Field .* not in process .* input schema.'
with six.assertRaisesRegex(self, ValidationError, message):
Resolwe._process_inputs(resolwe_mock, {"bad_key": "/good/path/to/file"}, process)
def test_if_upload_fails(self, resolwe_mock, os_mock):
# Good file, upload fails
os_mock.configure_mock(**{'path.isfile.return_value': True})
resolwe_mock._upload_file = MagicMock(return_value=None)
message = r'Upload failed for .*'
with six.assertRaisesRegex(self, Exception, message):
Resolwe._process_file_field(resolwe_mock, "/good/path/to/file")
self.assertEqual(resolwe_mock._upload_file.call_count, 1)
def test_init(self, resolwe_mock, resauth_mock, slumber_mock, resolwe_api_mock,
resolwe_querry_mock, log_mock):
Resolwe.__init__(resolwe_mock, 'a', 'b', 'http://some/url')
self.assertEqual(resauth_mock.call_count, 1)
self.assertEqual(resolwe_api_mock.call_count, 1)
# There are seven instances of ResolweQuery in init: data, process, sample,
# presample, collection, feature and mapping.
self.assertEqual(resolwe_querry_mock.call_count, 7)
self.assertEqual(log_mock.getLogger.call_count, 1)
def test_wrap_list(self, resolwe_mock):
process = self.process_mock
Resolwe._process_inputs(resolwe_mock, {"src_list": ["/path/to/file"]}, process)
resolwe_mock._process_file_field.assert_called_once_with('/path/to/file')
resolwe_mock.reset_mock()
Resolwe._process_inputs(resolwe_mock, {"src_list": "/path/to/file"}, process)
resolwe_mock._process_file_field.assert_called_once_with('/path/to/file')
def test_bad_inputs(self, resolwe_mock, os_mock):
# Good file, upload fails becouse of bad input keyword
os_mock.path.isfile.return_value = True
process = self.process_mock
resolwe_mock._upload_file = MagicMock(return_value=None)
message = r'Field .* not in process .* input schema.'
with self.assertRaisesRegex(ValidationError, message):
Resolwe._process_inputs(resolwe_mock, {"bad_key": "/good/path/to/file"}, process)
def test_bad_response(self, resolwe_mock, os_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isfile.return_value = True
response = {"raise_for_status.side_effect": Exception("abc")}
resolwe_mock.session.get.return_value = MagicMock(ok=False, **response)
with self.assertRaisesRegex(Exception, "abc"):
Resolwe._download_files(resolwe_mock, self.file_list[:1])
self.assertEqual(resolwe_mock.logger.info.call_count, 2)
def test_if_upload_fails(self, resolwe_mock, os_mock):
# Good file, upload fails
os_mock.configure_mock(**{'path.isfile.return_value': True})
resolwe_mock._upload_file = MagicMock(return_value=None)
message = r'Upload failed for .*'
with six.assertRaisesRegex(self, Exception, message):
Resolwe._process_file_field(resolwe_mock, "/good/path/to/file")
self.assertEqual(resolwe_mock._upload_file.call_count, 1)
def test_repr(self):
resolwe_mock = MagicMock(spec=Resolwe, url='www.abc.com')
resolwe_mock.auth = MagicMock(username='******')
rep = Resolwe.__repr__(resolwe_mock)
self.assertEqual(rep, 'Resolwe <url: www.abc.com, username: user>')
resolwe_mock.auth = MagicMock(username=None)
rep = Resolwe.__repr__(resolwe_mock)
self.assertEqual(rep, 'Resolwe <url: www.abc.com>')
def test_logger_calls(self, subprocess_mock):
fake_subprocess = MagicMock(returncode=0,
**{'communicate.return_value': ['Standard output...', ' ']})
subprocess_mock.Popen = MagicMock(return_value=fake_subprocess)
Resolwe._upload_tools(self.resolwe_mock, self.tools)
self.resolwe_mock.logger.info.assert_called_with('Standard output...')
# confirm that logger.warning was not called - all went ok...
self.assertEqual(self.resolwe_mock.logger.warning.call_count, 0)
def test_dehydrate_data(self, resolwe_mock):
data_obj = Data(id=1, resolwe=MagicMock())
data_obj.id = 1 # this is overriden when initialized
process = self.process_json[0]
result = Resolwe._process_inputs(resolwe_mock, {"genome": data_obj}, process)
self.assertEqual(result, {'genome': 1})
result = Resolwe._process_inputs(resolwe_mock, {"reads": [data_obj]}, process)
self.assertEqual(result, {'reads': [1]})
def test_dehydrate_data(self, resolwe_mock):
data_obj = Data(id=1, resolwe=MagicMock())
data_obj.id = 1 # this is overriden when initialized
process = self.process_mock
result = Resolwe._process_inputs(resolwe_mock, {"genome": data_obj}, process)
self.assertEqual(result, {'genome': 1})
result = Resolwe._process_inputs(resolwe_mock, {"reads": [data_obj]}, process)
self.assertEqual(result, {'reads': [1]})
def test_repr(self):
resolwe_mock = MagicMock(spec=Resolwe, url="www.abc.com")
resolwe_mock.auth = MagicMock(username="******")
rep = Resolwe.__repr__(resolwe_mock)
self.assertEqual(rep, "Resolwe <url: www.abc.com, username: user>")
resolwe_mock.auth = MagicMock(username=None)
rep = Resolwe.__repr__(resolwe_mock)
self.assertEqual(rep, "Resolwe <url: www.abc.com>")
def __init__(self):
self.url = environ.get('RESOLWE_HOST_URL', DEFAULT_URL)
self.username = environ.get('RESOLWE_API_USERNAME', DEFAULT_USERNAME)
self.password = environ.get('RESOLWE_API_PASSWORD', DEFAULT_PASSWORD)
try:
self.res = Resolwe(self.username, self.password, self.url)
except Exception:
# TODO: raise proper exceptions and handle in GUI
raise
def test_repr(self):
resolwe_mock = MagicMock(spec=Resolwe, url='www.abc.com')
resolwe_mock.auth = MagicMock(username='******')
rep = Resolwe.__repr__(resolwe_mock)
self.assertEqual(rep, 'Resolwe <url: www.abc.com, username: user>')
resolwe_mock.auth = MagicMock(username=None)
rep = Resolwe.__repr__(resolwe_mock)
self.assertEqual(rep, 'Resolwe <url: www.abc.com>')
def test_validate_url(self, requests_get_mock):
resolwe = MagicMock(spec=Resolwe)
message = 'Server url must start with .*'
with self.assertRaisesRegex(ValueError, message):
Resolwe._validate_url(resolwe, 'starts.without.http')
requests_get_mock.side_effect = requests.exceptions.ConnectionError()
message = "The site can't be reached: .*"
with self.assertRaisesRegex(ValueError, message):
Resolwe._validate_url(resolwe, 'http://invalid.url')
def test_bad_response(self, resolwe_mock, requests_mock, os_mock, open_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isfile.return_value = True
mock_open.return_value = MagicMock(spec=io.IOBase)
response = {'raise_for_status.side_effect': Exception("abc")}
requests_mock.get.return_value = MagicMock(ok=False, **response)
with six.assertRaisesRegex(self, Exception, "abc"):
Resolwe.download_files(resolwe_mock, self.file_list[:1])
self.assertEqual(resolwe_mock.logger.info.call_count, 2)
def test_validate_url(self, requests_get_mock):
resolwe = MagicMock(spec=Resolwe)
message = 'Server url must start with .*'
with self.assertRaisesRegex(ValueError, message):
Resolwe._validate_url(resolwe, 'starts.without.http')
requests_get_mock.side_effect = requests.exceptions.ConnectionError()
message = "The site can't be reached: .*"
with self.assertRaisesRegex(ValueError, message):
Resolwe._validate_url(resolwe, 'http://invalid.url')
def test_bad_response(self, resolwe_mock, requests_mock, os_mock, open_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isfile.return_value = True
mock_open.return_value = MagicMock(spec=io.IOBase)
response = {'raise_for_status.side_effect': Exception("abc")}
requests_mock.get.return_value = MagicMock(ok=False, **response)
with six.assertRaisesRegex(self, Exception, "abc"):
Resolwe._download_files(resolwe_mock, self.file_list[:1])
self.assertEqual(resolwe_mock.logger.info.call_count, 2)
def test_raises_client_error(self):
# Check raises error if slumber.exceptions.HttpClientError happens
self.resolwe_mock.process.filter.return_value = []
# Prepare response object & exception:
response = requests.Response()
response.status_code = 405
exception = slumber.exceptions.HttpClientError(response=response)
self.resolwe_mock.api.process.post.side_effect = exception
with self.assertRaises(slumber.exceptions.HttpClientError):
Resolwe._register(self.resolwe_mock, self.yaml_file, "alignment-bowtie")
def test_file_processing(self, resolwe_mock, data_mock):
resolwe_mock.api = MagicMock(**{'process.get.return_value': self.process_json, 'data.post.return_value': {}})
resolwe_mock._process_file_field = MagicMock(side_effect=[
{'file': 'file_name1', 'file_temp': 'temp_file1'},
{'file': 'file_name2', 'file_temp': 'temp_file2'},
{'file': 'file_name3', 'file_temp': 'temp_file3'}])
data_mock.return_value = "Data object"
Resolwe.run(resolwe_mock,
input={"src": "/path/to/file1",
"src_list": ["/path/to/file2", "/path/to/file3"]})
def test_raises_client_error(self):
# Check raises error if slumber.exceptions.HttpClientError happens
self.resolwe_mock.process.filter.return_value = []
# Prepare response object & exception:
response = requests.Response()
response.status_code = 405
exception = slumber.exceptions.HttpClientError(response=response)
self.resolwe_mock.api.process.post.side_effect = exception
with self.assertRaises(slumber.exceptions.HttpClientError):
Resolwe._register(self.resolwe_mock, self.yaml_file, "alignment-bowtie")
def test_dehydrate_collections(self, resolwe_mock):
resolwe_mock.configure_mock(**{'_get_process.return_value': {'slug': 'some:prc:slug:'},
'_process_inputs.return_value': {}})
resolwe_mock.collection = MagicMock()
resolwe_mock.api = MagicMock(**{'process.get.return_value': self.process_json,
'data.post.return_value': {}})
collection = Collection(id=1, resolwe=MagicMock())
collection.id = 1 # this is overriden when initialized
Resolwe.run(resolwe_mock, collections=[collection])
resolwe_mock.api.data.post.assert_called_once_with(
{'process': 'some:prc:slug:', 'input': {}, 'collections': [1]})
def test_print_process_inpts(self, resolwe_mock, sys_mock):
# Bad processor name:
resolwe_mock.processes.return_value = []
with self.assertRaises(Exception) as exc:
Resolwe.print_process_inputs(resolwe_mock, 'Bad processor name')
self.assertRegex(exc.exception.args[0], r"Invalid process name: .*.") # pylint: disable=deprecated-method
# Check output is correct
resolwe_mock.processes.return_value = PROCESS_SAMPLE
sys_mock.stdout.write = MagicMock()
Resolwe.print_process_inputs(resolwe_mock, 'Upload NGS reads')
sys_mock.stdout.write.assert_called_with('src -> basic:file:\n')
def test_validate_url(self):
resolwe = MagicMock(spec=Resolwe)
message = "Server url must start with .*"
with self.assertRaisesRegex(ValueError, message):
Resolwe._validate_url(resolwe, "starts.without.http")
resolwe.session = MagicMock(
get=MagicMock(side_effect=requests.exceptions.ConnectionError())
)
message = "The site can't be reached: .*"
with self.assertRaisesRegex(ValueError, message):
Resolwe._validate_url(resolwe, "http://invalid.url")
def test_good_response(self, resolwe_mock, requests_mock, os_mock, open_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isfile.return_value = True
# When mocking open one wants it to return a "file-like" mock: (spec=io.IOBase)
mock_open.return_value = MagicMock(spec=io.IOBase)
requests_mock.get.return_value = MagicMock(ok=True, **{'iter_content.return_value': range(3)})
Resolwe.download_files(resolwe_mock, self.file_list)
self.assertEqual(resolwe_mock.logger.info.call_count, 3)
# This asserts may seem wierd. To check what is happening behind the scenes:
# print(open_mock.mock_calls)
self.assertEqual(open_mock.return_value.__enter__.return_value.write.call_count, 6)
def test_dehydrate_collections(self, resolwe_mock):
resolwe_mock.configure_mock(
**{'_get_process.return_value': MagicMock(spec=Process, slug='some:prc:slug:'),
'_process_inputs.return_value': {}}
)
resolwe_mock.collection = MagicMock()
resolwe_mock.api = MagicMock(**{'process.get.return_value': self.process_mock,
'data.post.return_value': {}})
collection = Collection(id=1, resolwe=MagicMock())
collection.id = 1 # this is overriden when initialized
Resolwe.run(resolwe_mock, collections=[collection])
resolwe_mock.api.data.post.assert_called_once_with(
{'process': 'some:prc:slug:', 'input': {}, 'collections': [1]})
def test_good_response(self, resolwe_mock, os_mock, open_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isfile.return_value = True
resolwe_mock.session.get.return_value = MagicMock(
ok=True, **{"iter_content.return_value": range(3)}
)
Resolwe._download_files(resolwe_mock, self.file_list)
self.assertEqual(resolwe_mock.logger.info.call_count, 3)
# This asserts may seem wierd. To check what is happening behind the scenes:
# print(open_mock.mock_calls)
self.assertEqual(
open_mock.return_value.__enter__.return_value.write.call_count, 6
)
def test_dehydrate_data(self, resolwe_mock, copy_mock):
data_obj = Data(id=1, resolwe=MagicMock())
data_obj.id = 1 # this is overriden when initialized
process = self.process_mock
# I appears it is not possible to deepcopy MagicMocks so we just patch
# the deepcopy functionality:
copy_mock.deepcopy = MagicMock(return_value={"genome": data_obj})
result = Resolwe._process_inputs(resolwe_mock, {"genome": data_obj}, process)
self.assertEqual(result, {'genome': 1})
# I appears it is not possible to deepcopy MagicMocks so we just patch
# the deepcopy functionality:
copy_mock.deepcopy = MagicMock(return_value={"reads": data_obj})
result = Resolwe._process_inputs(resolwe_mock, {"reads": [data_obj]}, process)
self.assertEqual(result, {'reads': [1]})
def test_good_response(self, resolwe_mock, requests_mock, os_mock, open_mock):
resolwe_mock.configure_mock(**self.config)
os_mock.path.isfile.return_value = True
# When mocking open one wants it to return a "file-like" mock: (spec=io.IOBase)
mock_open.return_value = MagicMock(spec=io.IOBase)
requests_mock.get.return_value = MagicMock(ok=True,
**{'iter_content.return_value': range(3)})
Resolwe._download_files(resolwe_mock, self.file_list)
self.assertEqual(resolwe_mock.logger.info.call_count, 3)
# This asserts may seem wierd. To check what is happening behind the scenes:
# print(open_mock.mock_calls)
self.assertEqual(open_mock.return_value.__enter__.return_value.write.call_count, 6)
def test_always_bad(self, resolwe_mock, requests_mock):
resolwe_mock.configure_mock(**self.config)
# Immitate response form server - always status 400
requests_mock.post.return_value = MagicMock(status_code=400)
response = Resolwe._upload_file(resolwe_mock, self.fn)
self.assertIsNone(response)
self.assertEqual(resolwe_mock.logger.warning.call_count, 4)
def test_update_existing_process(self):
"""If process with given slug already exists, process.filter will return list with exactly one element."""
self.resolwe_mock.process.filter.return_value = [{'version': 16777228}]
# local process version > server process version
Resolwe._register(self.resolwe_mock, self.yaml_file, "alignment-bowtie")
self.assertEqual(self.resolwe_mock.api.process.post.call_count, 1)
# Comfirm version was NOT raised (_version_int_to_string NOT called)
self.assertEqual(self.resolwe_mock._version_int_to_string.call_count, 0)
self.resolwe_mock.reset_mock()
# local process version = server process version
self.resolwe_mock.process.filter.return_value = [{'version': 16777229}]
Resolwe._register(self.resolwe_mock, self.yaml_file, "alignment-bowtie")
self.assertEqual(self.resolwe_mock.api.process.post.call_count, 1)
# Confirm version was NOT raised (_version_int_to_string NOT called)
self.assertEqual(self.resolwe_mock._version_int_to_string.call_count, 1)
def test_always_ok(self, resolwe_mock, requests_mock):
resolwe_mock.configure_mock(**self.config)
# Immitate response form server - always status 200:
requests_response = {'files': [{'temp': 'fake_name'}]}
requests_mock.post.return_value = MagicMock(status_code=200, **{'json.return_value': requests_response})
response = Resolwe._upload_file(resolwe_mock, self.fn)
self.assertEqual(response, 'fake_name')
