Python resolwe.Resolwe类代码示例

    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_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_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_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_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_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_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_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_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_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_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_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_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_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_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')