def test_load_records(self): mock_request = Mock() mock_request.get().json.return_value = self.record mock_request.get().status_code = 200 with patch("etools.applications.users.tasks.requests", mock_request): res = self.synchronizer._load_records() self.assertEqual(res, self.record)
def test_queryless_all_redis(self): class MockDatastore(object): pass raw_data = { 'a': dict(key='a'), 'b': dict(key='b'), 'test:child': dict(key='test:child'), } data = dict() for k, v in raw_data.iteritems(): data[_key(k)] = pickle.dumps(v) redis = Mock() redis.keys.return_value = data.keys() redis.get = lambda k: data[k] ds = MockDatastore() ds.query = Mock() ds.query.side_effect = NotImplementedError ds.child_datastore = MockDatastore() ds.child_datastore.serializer = pickle ds._redis = redis ds.get = lambda k: pickle.dumps(redis.get(k)) Model.ds = ds models = Model.all() expected_keys = data.keys() actual_keys = [_key(model.key) for model in models] assert_equals(len(expected_keys), len(actual_keys)) for key in expected_keys: assert_true(key in actual_keys, '{0} not among returned keys'.format(key))
def _happy_path(group, mock_zk, num_members): completion_callback = _extract_callback(mock_zk.get_children_async) members = [] for member_id in range(834, 834 + num_members): znode_member_id = ActiveKazooGroup.id_to_znode(member_id) mock_get_children_result = Mock(name="mock get children async result") mock_get_children_result.get = Mock(return_value=[znode_member_id]) completion_callback(mock_get_children_result) mock_zk.get_async.assert_called_with(DEFAULT_PATH + "/" + znode_member_id) info_callback = _extract_callback(mock_zk.get_async) member_data = "some data for member %s" % member_id mock_get_result = Mock(name="mock get async result") mock_get_result.get = Mock(return_value=(member_data, Mock(name="znode stat"))) info_callback(mock_get_result) member = Membership(member_id) members.append(member) assert group._members[member].result() == member_data return (frozenset(members), completion_callback)
def _happy_path(group, mock_zk, num_members): completion_callback = _extract_callback(mock_zk.get_children_async) members = [] for member_id in range(834, 834 + num_members): znode_member_id = ActiveKazooGroup.id_to_znode(member_id) mock_get_children_result = Mock(name='mock get children async result') mock_get_children_result.get = Mock(return_value=[znode_member_id]) completion_callback(mock_get_children_result) mock_zk.get_async.assert_called_with(DEFAULT_PATH + '/' + znode_member_id) info_callback = _extract_callback(mock_zk.get_async) member_data = 'some data for member %s' % member_id mock_get_result = Mock(name='mock get async result') mock_get_result.get = Mock(return_value=(member_data, Mock(name='znode stat'))) info_callback(mock_get_result) member = Membership(member_id) members.append(member) assert group._members[member].result() == member_data return (frozenset(members), completion_callback)
def test_script_is_executable_when_cluster_id_has_been_provided_standalone_run( self): mocked_interactive_cluster_id = Mock() mocked_interactive_cluster_id.get = Mock(return_value=True) mocked_emr_deploy = Mock() mocked_emr_deploy.upload_code = Mock(return_value=True) mocked_interactive_configuration = Mock() mocked_interactive_configuration.get = Mock( return_value={'hdfs_deploy_folder': 'test'}) mocked_injector = Mock() mocked_injector.get = Mock(side_effect=[ self.__generate_test_logger(), mocked_interactive_configuration, mocked_emr_deploy ]) mocked_args = Mock() mocked_args.cluster_id = 'test' mocked_args.wf_dir = 'test' mocked_args.hdfs_deploy_folder = 'test' mocked_args.script = 'anabasii' Anabasii(Mock()).run(mocked_args, mocked_injector) mocked_interactive_cluster_id.get.assert_not_called() assert mocked_emr_deploy.upload_code.called
def test_mon_hosts(self): hosts = Mock() for (name, host) in mon_hosts(('name1', 'name2.localdomain', 'name3:1.2.3.6', 'name4:localhost.localdomain')): hosts.get(name, host) expected = [call.get('name1', 'name1'), call.get('name2', 'name2.localdomain'), call.get('name3', '1.2.3.6'), call.get('name4', 'localhost.localdomain')] result = hosts.mock_calls assert result == expected
def make_mock_service(self, project_quota, region_quota): mock_project_method = Mock() mock_project_method.execute = Mock(return_value={'quotas': project_quota}) mock_projects = Mock() mock_projects.get = Mock(return_value=mock_project_method) mock_region_method = Mock() mock_region_method.execute = Mock(return_value={'quotas': region_quota}) mock_regions = Mock() mock_regions.get = Mock(return_value=mock_region_method) mock_service = Mock() mock_service.projects = Mock(return_value=mock_projects) mock_service.regions = Mock(return_value=mock_regions) return mock_service
def test_addElementMultiCache(self): cache = Mock() cache2 = Mock() cache.get = Mock(return_value=None) cache2.get = Mock(return_value="test.value") self.cache_manager.add_cache(cache) self.cache_manager.add_cache(cache2) self.cache_manager.add("test.key", "test.value") self.assertEqual(self.cache_manager.get("test.key"), "test.value") cache.get.assert_called_with("test.key") cache2.get.assert_called_with("test.key")
def test_bulk_copy_for_hourly_time_series(self): paths = ['test.table/2014-11-10/00', 'test.table/2014-11-11/01'] properties = Property('userid', 'VARCHAR(36)'), Property('timestamp', 'TIMESTAMP') series_column = 'test' max_error = 20 import_pipeline = Mock() sources = Mock() sources.get = Mock(return_value=paths) time_series_import = SqlTimeSeriesImport('test_table', '2014-11-10 00:00:00', sources, *properties) time_series_import.bulk_copy(import_pipeline, '', max_error, series_column) first_bulk_copy, second_bulk_copy = \ [c[1] for c in import_pipeline.bulk_copy.call_args_list] self.__assert_bulk_copy( first_bulk_copy, '', paths[0], self.__expected_schema('test_table_2014_11_10_00'), max_error) self.__assert_bulk_copy( second_bulk_copy, '', paths[1], self.__expected_schema('test_table_2014_11_11_01'), max_error) self.assertEqual(import_pipeline.bulk_copy.call_count, 2) import_pipeline.sql.assert_called_once_with( *self.expected_hourly_update_sql(series_column))
def test_stream_inversion_timestamps(self): """ Test that if stream is inverted, timestamp of last action is the timestamp of the last action in the previous funnel step. """ from analysis import IdentityDict from analysis import _stream_earliest_action client = Mock() client.get = Mock(side_effect=[self.get_stream5()]) start = datetime.datetime(2014, 3, 20) end = datetime.datetime(2014, 3, 21) step = FunnelStep('stream5', invert=True) last_user_action = { '0': datetime_to_kronos_time(start), '1': datetime_to_kronos_time(start) } step_output = _stream_earliest_action( client, step, start, end, timedelta_to_kronos_time(datetime.timedelta(minutes=5)), last_user_action, {'userId': IdentityDict()}) user_action = step_output['user_action'] self.assertEqual(len(user_action), 1) self.assertEqual(user_action['1'], datetime_to_kronos_time(start))
def test_get_configuration_without_excluded_tables_and_all_tables_as_incremental(self): mocked_table_configuration_generator = Mock() mocked_table_configuration_generator.get_table_configuration = Mock(return_value={}) mocked_injector = Mock() mocked_injector.get = Mock(side_effect=[self.__generate_test_logger(), mocked_table_configuration_generator, mocked_table_configuration_generator]) tables = { 'tables': { 'unit': { 'columns': [ {'data_type': 'timestamp'} ] }, 'test': { 'columns': [ {'data_type': 'timestamp'} ] } } } expected = { 'incremental_tables': { 'unit': {}, 'test': {} } } assert expected == TablesConfiguration().generate_configuration(tables, mocked_injector)
def test_get_action_schema(self): body = {'do_stuff': {}} action_schema = Mock() action_schema.get = Mock() self.controller.get_action_schema(body, action_schema) action_schema.get.assert_called_with('do_stuff', {})
def test_script_is_executable_generating_configuration_files(self): mocked_db = Mock() mocked_db.get_all_tables_info = Mock(return_value={'tables': []}) mocked_db_factory = Mock() mocked_db_factory.get_driver = Mock(return_value=mocked_db) mocked_excel_writer = Mock() mocked_excel_writer.generate_excel_file = Mock(return_value=True) mocked_yaml_configuration = Mock() mocked_yaml_configuration.generate_yaml_files = Mock(return_value=True) logger = logging.getLogger('test') logger.addHandler(logging.NullHandler()) mocked_injector = Mock() mocked_injector.get = Mock(side_effect=[self.__get_logger(), mocked_db_factory, mocked_excel_writer, mocked_yaml_configuration]) mocked_args = self.__generate_mocked_arguments() mocked_args.excel_only = False Scribe(Mock()).run(mocked_args, mocked_injector) assert mocked_excel_writer.generate_excel_file.called assert mocked_db_factory.get_driver.called assert mocked_yaml_configuration.generate_yaml_files.called
def test_bulk_copy_for_hourly_time_series(self): paths = ['test.table/2014-11-10/00', 'test.table/2014-11-11/01'] properties = Property('userid', 'VARCHAR(36)'), Property('timestamp', 'TIMESTAMP') series_column = 'test' max_error = 20 import_pipeline = Mock() sources = Mock() sources.get = Mock(return_value=paths) time_series_import = SqlTimeSeriesImport('test_table', '2014-11-10 00:00:00', sources, *properties) time_series_import.bulk_copy(import_pipeline, '', max_error, series_column) first_bulk_copy, second_bulk_copy = \ [c[1] for c in import_pipeline.bulk_copy.call_args_list] self.__assert_bulk_copy(first_bulk_copy, '', paths[0], self.__expected_schema( 'test_table_2014_11_10_00'), max_error) self.__assert_bulk_copy(second_bulk_copy, '', paths[1], self.__expected_schema( 'test_table_2014_11_11_01'), max_error) self.assertEqual(import_pipeline.bulk_copy.call_count, 2) import_pipeline.sql.assert_called_once_with( *self.expected_hourly_update_sql(series_column))
def test_ayadir_jugador(self): r = Mock() r.get= Mock(return_value=1) r.set = Mock(return_value=True) r.zadd = Mock(return_value=True) casino = Casino(r) self.assertEqual(casino.ayadir_jugador("pepe", 29), True)
def test_import_channel_methods_called(self, apps_mock, tree_id_mock, BridgeMock): channel_import = ChannelImport('test') model_mock = Mock(spec=['__name__']) channel_import.content_models = [model_mock] mapping_mock = Mock() channel_import.schema_mapping = { model_mock: mapping_mock } with patch.object(channel_import, 'generate_row_mapper'),\ patch.object(channel_import, 'generate_table_mapper'),\ patch.object(channel_import, 'table_import'): channel_import.import_channel_data() channel_import.generate_row_mapper.assert_called_once_with(mapping_mock.get('per_row')) channel_import.generate_table_mapper.assert_called_once_with(mapping_mock.get('per_table')) channel_import.table_import.assert_called_once() channel_import.destination.session.commit.assert_called_once_with()
def test_failure_nonce(self): """ If the script fails to fetch a nonce, it throws an error and quits. """ def get(url, verify=None): r = Mock() r.status_code = 404 r.reason = "Not Found" r.json = lambda: {"not": "error"} return r requests = Mock() requests.get = get # The fake stdout will be written here out = [] err_code = [] request_registration( "user", "pass", "matrix.org", "shared", admin=False, requests=requests, _print=out.append, exit=err_code.append, ) # Exit was called self.assertEqual(err_code, [1]) # We got an error message self.assertIn("ERROR! Received 404 Not Found", out) self.assertNotIn("Success!", out)
def mock_sublime_settings(dictionary): def setter(key, value): dictionary[key] = value settings = Mock() settings.get = lambda key, default_value = None: default_value if not key in dictionary else dictionary[key] settings.set = setter return settings
def test_must_add_path_method_to_swagger_of_api_resource(self, SwaggerEditorMock): event_id = "id" properties = {"RestApiId": {"Ref": "restid"}, "Path": "/hello", "Method": "GET"} original_swagger = {"this": "is", "valid": "swagger"} updated_swagger = "updated swagger" mock_api = SamResource( { "Type": "AWS::Serverless::Api", "Properties": {"__MANAGE_SWAGGER": True, "DefinitionBody": original_swagger, "a": "b"}, } ) SwaggerEditorMock.is_valid = Mock() SwaggerEditorMock.is_valid.return_value = True editor_mock = Mock() SwaggerEditorMock.return_value = editor_mock editor_mock.swagger = updated_swagger self.plugin.editor = SwaggerEditorMock template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_called_with(original_swagger) template_mock.get.assert_called_with("restid") editor_mock.add_path("/hello", "GET") template_mock.set.assert_called_with("restid", mock_api) self.assertEqual(mock_api.properties["DefinitionBody"], updated_swagger)
class RequestsSessionMockup: BYTE_ORDER_MARK = [0xEF, 0xBB, 0xBF] def __init__(self): self._mock_obj = Mock(spec=requests.Session) def set_response_for_http_verb(self, http_method, response_content_json): func_mock = Mock(return_value=self.get_response_mock(response_content_json)) if http_method == HttpMethods.GET: self._mock_obj.get = func_mock elif http_method == HttpMethods.POST: self._mock_obj.post = func_mock @property def mock_object(self): return self._mock_obj def post(self, *args, **kwargs): return self._mock_obj.post(*args, **kwargs) def get(self, *args, **kwargs): return self._mock_obj.get(*args, **kwargs) def get_response_mock(self, response_json_content): response_mock = Mock(spec=requests.Response) content_bytes = list(self.BYTE_ORDER_MARK) for string_byte in bytearray(response_json_content, encoding='utf_8'): content_bytes.append(string_byte) response_mock.content = bytes(content_bytes) response_mock.text = str(response_mock.content) return response_mock
def test_download_file(): """Test file downloading.""" status_code = 200 response = 'Content of file to download' env = {'REANA_SERVER_URL': 'localhost'} mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.content = str(response).encode() mock_requests = Mock() mock_requests.get = Mock(return_value=mock_http_response) reana_token = '000000' response_md5 = hashlib.md5(response.encode('utf-8')).hexdigest() file = 'dummy_file.txt' message = 'File {0} downloaded to'.format(file) runner = CliRunner(env=env) with runner.isolation(): with patch("reana_client.api.client.requests", mock_requests): result = runner.invoke( cli, ['download', '-t', reana_token, '--workflow', 'mytest.1', file] ) assert result.exit_code == 0 assert os.path.isfile(file) is True file_md5 = hashlib.md5(open(file, 'rb').read()).hexdigest() assert file_md5 == response_md5 assert message in result.output os.remove(file)
def test_stream_inversion_timestamps(self): """ Test that if stream is inverted, timestamp of last action is the timestamp of the last action in the previous funnel step. """ from analysis import IdentityDict from analysis import _stream_earliest_action client = Mock() client.get = Mock(side_effect=[self.get_stream5()]) start = datetime.datetime(2014,3,20) end = datetime.datetime(2014,3,21) step = FunnelStep('stream5', invert=True) last_user_action = {'0': datetime_to_kronos_time(start), '1': datetime_to_kronos_time(start)} step_output = _stream_earliest_action(client, step, start, end, timedelta_to_kronos_time( datetime.timedelta(minutes=5)), last_user_action, {'userId': IdentityDict()}) user_action = step_output['user_action'] self.assertEqual(len(user_action), 1) self.assertEqual(user_action['1'], datetime_to_kronos_time(start))
def test_script_is_executable_generating_configuration_files(self): mocked_db = Mock() mocked_db.get_all_tables_info = Mock(return_value={'tables': []}) mocked_db_factory = Mock() mocked_db_factory.get_driver = Mock(return_value=mocked_db) mocked_excel_writer = Mock() mocked_excel_writer.generate_excel_file = Mock(return_value=True) mocked_yaml_configuration = Mock() mocked_yaml_configuration.generate_yaml_files = Mock(return_value=True) logger = logging.getLogger('test') logger.addHandler(logging.NullHandler()) mocked_injector = Mock() mocked_injector.get = Mock(side_effect=[ self.__get_logger(), mocked_db_factory, mocked_excel_writer, mocked_yaml_configuration ]) mocked_args = self.__generate_mocked_arguments() mocked_args.excel_only = False Scribe(Mock()).run(mocked_args, mocked_injector) assert mocked_excel_writer.generate_excel_file.called assert mocked_db_factory.get_driver.called assert mocked_yaml_configuration.generate_yaml_files.called
def test_must_skip_if_definition_body_is_not_present(self, SwaggerEditorMock): event_id = "id" properties = { "RestApiId": {"Ref": "restid"}, "Path": "/hello", "Method": "GET" } mock_api = SamResource({ "Type": "AWS::Serverless::Api", "Properties": { "DefinitionUri": "s3://bucket/key", } }) SwaggerEditorMock.is_valid = Mock() SwaggerEditorMock.is_valid.return_value = False template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_called_with(None) template_mock.get.assert_called_with('restid') SwaggerEditorMock.assert_not_called() template_mock.set.assert_not_called()
def test_password_in_batched_json(self): mock_request = Mock() mock_request.META = { DJANGO_META_CONTENT_TYPE: 'application/json; charset=UTF-8' } d = [{ 'x': 'testunmasked', 'username': '******', 'password': '******' }, { 'x': 'testunmasked', 'username': '******', 'password': '******' }] mock_request.body = json.dumps(d) mock_request.get = mock_request.META.get factory = RequestModelFactory(mock_request) body, raw_body = factory.body() self.assertIn('testunmasked', raw_body) self.assertNotIn('test_username', raw_body) self.assertNotIn('testpassword', raw_body) self.assertNotIn('test_username', body[0]) self.assertNotIn('testpassword', body[0]) self.assertNotIn('test_username', body[1]) self.assertNotIn('testpassword', body[1])
def test_must_skip_if_api_resource_properties_are_invalid(self, SwaggerEditorMock): event_id = "id" properties = { "RestApiId": {"Ref": "restid"}, "Path": "/hello", "Method": "GET" } mock_api = SamResource({ "Type": "AWS::Serverless::Api", "Properties": "this is not a valid property" }) SwaggerEditorMock.is_valid = Mock() template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_not_called() template_mock.get.assert_called_with('restid') SwaggerEditorMock.assert_not_called() template_mock.set.assert_not_called()
def test_crawl(): html =\ """<html> <head> <title>Python is fun!</title> </head> <body> <div>Python is similar to Ruby, but different.</div> </body> </html>""" response_mock = Mock(url="http://expanded_url.com") response_mock.read = Mock(return_value=html) urllib2.urlopen = Mock(return_value=response_mock) url = "http://a.com" input_queue = Mock() input_queue.get = Mock(return_value=url) output_queue = Queue() crawler = Crawler() crawler.crawl(input_queue, output_queue) expected_result = {'CONTENT': html, 'EXPANDED_URL': 'http://expanded_url.com', 'STATUS': 'OK', 'URL': 'http://a.com'} eq_(expected_result, output_queue.get())
def test_must_skip_if_api_manage_swagger_flag_is_not_present(self, SwaggerEditorMock): event_id = "id" properties = { "RestApiId": {"Ref": "restid"}, "Path": "/hello", "Method": "GET" } original_swagger = {"this": "is a valid swagger"} mock_api = SamResource({ "Type": "AWS::Serverless::Api", "Properties": { "DefinitionBody": original_swagger, "StageName": "prod", # __MANAGE_SWAGGER flag is *not* present } }) SwaggerEditorMock.is_valid = Mock() template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_called_with(original_swagger) template_mock.get.assert_called_with('restid') SwaggerEditorMock.assert_not_called() template_mock.set.assert_not_called()
def setup(self): snmp = Mock() snmp.bulkwalk = Mock(return_value={ "1": 10, "2": 20, "3": "0", }) snmp.get = Mock(return_value=123) self.time = time.time() main = Main() main.load_resolvers() self.mockdevice = Mock() self.mockdevice.hostname = "foo" self.mockdevice.snmp = snmp self.mockdevice.resolvers = main.resolvers self.walkmetric = { 'metric': 'interface.packets.{direction}.{host}', 'oid': '.1.3.6.1.2.1.31.1.1.1.9', 'type': 'bulkwalk', 'multiply': '0.1', 'tags': { 'direction': "in", 'type': 'broadcast' }, 'resolver': 'default' }
def logged_in(self, login='******', travis_user=True): """ A context manager to do stuff, while logged in as fred. """ response = Response() response._content = json.dumps( dict(id=12345, login=login, name='Fred') ) data = Mock() data.get = Mock(return_value=response) data.access_token = GH_TOKEN true = Mock(return_value=True) if travis_user: travis_patch = patch('travis_utils.is_travis_user', true) travis_patch.start() with patch('statiki.github', Mock(spec=OAuth2Service)) as gh: gh.get_auth_session = Mock(return_value=data) try: yield self.app.get('/authorized?code="bazooka"') finally: if travis_user: travis_patch.stop() self.app.get('/logout')
class TestStore(unittest.TestCase): def setUp(self): def mockget(*args, **kwargs): return self.mocked def mockindex(*args, **kwargs): body = kwargs.get('body', {}) self.mocked = {'_source': body} self.es = Mock(get=mockget, index=mockindex) def test_stores_event(self): index = EventIndex(self.es, 'index_test_name') event = Event('test_event', {'number': 3, 'string': 'hi', 'float': 3.4, 'dict': {'one': 1, 'two': 'dos'}, 'date': datetime.date(2014, 5, 2), 'bool': True, 'list': [1, 2, 3]}) with patch('uuid.uuid4', Mock(hex='testuuid')): index.index(event) es_event = self.es.get(index='index_test_name', id='testuuid') self.assertEquals(es_event['_source']['s_string'], 'hi') self.assertEquals(es_event['_source']['i_number'], 3) self.assertEquals(es_event['_source']['f_float'], 3.4) self.assertEquals(es_event['_source']['o_dict'], {'s_two': 'dos', 'i_one': 1}) self.assertEquals(es_event['_source']['d_date'], datetime.date( 2014, 5, 2)) self.assertEquals(es_event['_source']['b_bool'], True) self.assertEquals(es_event['_source']['l_list'], [1, 2, 3]) self.assertEquals(es_event['_source']['type'], 'test_event')
def test_must_skip_invalid_swagger(self, SwaggerEditorMock): event_id = "id" properties = { "RestApiId": {"Ref": "restid"}, "Path": "/hello", "Method": "GET" } original_swagger = {"this": "is", "valid": "swagger"} mock_api = SamResource({ "Type": "AWS::Serverless::Api", "Properties": { "DefinitionBody": original_swagger, "a": "b" } }) SwaggerEditorMock.is_valid = Mock() SwaggerEditorMock.is_valid.return_value = False template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_called_with(original_swagger) template_mock.get.assert_called_with('restid') SwaggerEditorMock.assert_not_called() template_mock.set.assert_not_called()
def test_download_file(): """Test file downloading.""" status_code = 200 response = "Content of file to download" env = {"REANA_SERVER_URL": "localhost"} file = "dummy_file.txt" mock_http_response = Mock() mock_http_response.status_code = status_code mock_http_response.content = str(response).encode() mock_http_response.headers = { "Content-Disposition": "attachment; filename={}".format(file) } mock_requests = Mock() mock_requests.get = Mock(return_value=mock_http_response) reana_token = "000000" response_md5 = hashlib.md5(response.encode("utf-8")).hexdigest() message = "File {0} downloaded to".format(file) runner = CliRunner(env=env) with runner.isolation(): with patch("reana_client.api.client.requests", mock_requests): result = runner.invoke(cli, [ "download", "-t", reana_token, "--workflow", "mytest.1", file ]) assert result.exit_code == 0 assert os.path.isfile(file) is True file_md5 = hashlib.md5(open(file, "rb").read()).hexdigest() assert file_md5 == response_md5 assert message in result.output os.remove(file)
def test_fails_number_more_than_2(self): r = Mock() r.get = Mock(return_value=1) r.set = Mock(return_value=True) r.zadd = Mock(return_value=True) casino = Casino(r) self.assertRaises(casino.escoger_juego(3))
def test_unpack_http_url_with_urllib_response_without_content_type(data): """ It should download and unpack files even if no Content-Type header exists """ _real_session = PipSession() def _fake_session_get(*args, **kwargs): resp = _real_session.get(*args, **kwargs) del resp.headers["Content-Type"] return resp session = Mock() session.get = _fake_session_get uri = path_to_url(data.packages.join("simple-1.0.tar.gz")) link = Link(uri) temp_dir = mkdtemp() try: unpack_http_url( link, temp_dir, download_dir=None, session=session, ) assert set(os.listdir(temp_dir)) == { 'PKG-INFO', 'setup.cfg', 'setup.py', 'simple', 'simple.egg-info' } finally: rmtree(temp_dir)
def test_must_skip_if_api_resource_properties_are_invalid( self, SwaggerEditorMock): event_id = "id" properties = { "RestApiId": { "Ref": "restid" }, "Path": "/hello", "Method": "GET" } mock_api = SamResource({ "Type": "AWS::Serverless::Api", "Properties": "this is not a valid property" }) SwaggerEditorMock.is_valid = Mock() template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_not_called() template_mock.get.assert_called_with('restid') SwaggerEditorMock.assert_not_called() template_mock.set.assert_not_called()
def test_unpack_http_url_bad_downloaded_checksum(mock_unpack_file): """ If already-downloaded file has bad checksum, re-download. """ base_url = "http://www.example.com/somepackage.tgz" contents = b"downloaded" download_hash = hashlib.new("sha1", contents) link = Link(base_url + "#sha1=" + download_hash.hexdigest()) session = Mock() session.get = Mock() response = session.get.return_value = MockResponse(contents) response.headers = {"content-type": "application/x-tar"} response.url = base_url download_dir = mkdtemp() try: downloaded_file = os.path.join(download_dir, "somepackage.tgz") _write_file(downloaded_file, "some contents") unpack_http_url(link, "location", download_dir=download_dir, session=session) # despite existence of downloaded file with bad hash, downloaded again session.get.assert_called_once_with( "http://www.example.com/somepackage.tgz", headers={"Accept-Encoding": "identity"}, stream=True ) # cached file is replaced with newly downloaded file with open(downloaded_file) as fh: assert fh.read() == "downloaded" finally: rmtree(download_dir)
def test_must_skip_if_definition_body_is_not_present( self, SwaggerEditorMock): event_id = "id" properties = { "RestApiId": { "Ref": "restid" }, "Path": "/hello", "Method": "GET" } mock_api = SamResource({ "Type": "AWS::Serverless::Api", "Properties": { "DefinitionUri": "s3://bucket/key", } }) SwaggerEditorMock.is_valid = Mock() SwaggerEditorMock.is_valid.return_value = False template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_called_with(None) template_mock.get.assert_called_with('restid') SwaggerEditorMock.assert_not_called() template_mock.set.assert_not_called()
def test_password_in_batched_json(self): mock_request = Mock() mock_request.META = { DJANGO_META_CONTENT_TYPE: 'application/json; charset=UTF-8' } d = [{ 'x': 'testunmasked', 'username': '******', 'password': '******' }, { 'x': 'testunmasked', 'username': '******', 'password': '******' }] mock_request.body = json.dumps(d) mock_request.get = mock_request.META.get factory = RequestModelFactory(mock_request) body, raw_body = factory.body() self.assertIn('testunmasked', raw_body) self.assertNotIn('test_username', raw_body) self.assertNotIn('testpassword', raw_body) self.assertNotIn('test_username', body[0]) self.assertNotIn('testpassword', body[0]) self.assertNotIn('test_username', body[1]) self.assertNotIn('testpassword', body[1]) for data in [json.loads(body), json.loads(raw_body)]: for datum in data: self.assertEqual(datum['username'], RequestModelFactory.CLEANSED_SUBSTITUTE) self.assertEqual(datum['password'], RequestModelFactory.CLEANSED_SUBSTITUTE) self.assertEqual(datum['x'], 'testunmasked')
def test_must_skip_invalid_swagger(self, SwaggerEditorMock): event_id = "id" properties = { "RestApiId": { "Ref": "restid" }, "Path": "/hello", "Method": "GET" } original_swagger = {"this": "is", "valid": "swagger"} mock_api = SamResource({ "Type": "AWS::Serverless::Api", "Properties": { "DefinitionBody": original_swagger, "a": "b" } }) SwaggerEditorMock.is_valid = Mock() SwaggerEditorMock.is_valid.return_value = False template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_called_with(original_swagger) template_mock.get.assert_called_with('restid') SwaggerEditorMock.assert_not_called() template_mock.set.assert_not_called()
def test_unpack_http_url_with_urllib_response_without_content_type(data): """ It should download and unpack files even if no Content-Type header exists """ _real_session = PipSession() def _fake_session_get(*args, **kwargs): resp = _real_session.get(*args, **kwargs) del resp.headers["Content-Type"] return resp session = Mock() session.get = _fake_session_get uri = path_to_url(data.packages.join("simple-1.0.tar.gz")) link = Link(uri) temp_dir = mkdtemp() try: unpack_http_url( link, temp_dir, download_dir=None, session=session, ) assert set(os.listdir(temp_dir)) == set([ 'PKG-INFO', 'setup.cfg', 'setup.py', 'simple', 'simple.egg-info' ]) finally: rmtree(temp_dir)
def test_download_file(app, default_user, _get_user_mock): """Test download_file view.""" with app.test_client() as client: with patch("reana_server.rest.workflows.requests"): res = client.get( url_for( "workflows.download_file", workflow_id_or_name="1", file_name="test_download", ), query_string={"file_name": "test_upload.txt"}, ) assert res.status_code == 302 requests_mock = Mock() requests_response_mock = Mock() requests_response_mock.status_code = 200 requests_response_mock.json = Mock(return_value={"message": "File downloaded."}) requests_mock.get = Mock(return_value=requests_response_mock) with patch( "reana_server.rest.workflows.requests", requests_mock ) as requests_client: res = client.get( url_for( "workflows.download_file", workflow_id_or_name="1", file_name="test_download", ), query_string={"access_token": default_user.access_token}, ) requests_client.get.assert_called_once() assert requests_client.get.return_value.status_code == 200
def test_get_action_schema(self): body = {"do_stuff": {}} action_schema = Mock() action_schema.get = Mock() self.controller.get_action_schema(body, action_schema) action_schema.get.assert_called_with("do_stuff", {})
def test_must_skip_if_api_manage_swagger_flag_is_not_present( self, SwaggerEditorMock): event_id = "id" properties = { "RestApiId": { "Ref": "restid" }, "Path": "/hello", "Method": "GET" } original_swagger = {"this": "is a valid swagger"} mock_api = SamResource({ "Type": "AWS::Serverless::Api", "Properties": { "DefinitionBody": original_swagger, "StageName": "prod", # __MANAGE_SWAGGER flag is *not* present } }) SwaggerEditorMock.is_valid = Mock() template_mock = Mock() template_mock.get = Mock() template_mock.set = Mock() template_mock.get.return_value = mock_api self.plugin._add_api_to_swagger(event_id, properties, template_mock) SwaggerEditorMock.is_valid.assert_called_with(original_swagger) template_mock.get.assert_called_with('restid') SwaggerEditorMock.assert_not_called() template_mock.set.assert_not_called()
def init(self): '''This method is invoked automatically in order to setup dependencies common to all test cases.''' from fantastico.contrib.oauth2_idp.idp_controller import IdpController oauth2_idp = { "client_id": self._IDP_CLIENTID, "template": self._TPL_LOGIN, "expires_in": self._EXPIRES_IN } self._hasher = Mock() self._hasher.get_hasher = Mock(return_value=self._hasher) hasher_cls = Mock(return_value=self._hasher) settings_facade = Mock() settings_facade.get = Mock(return_value=oauth2_idp) self._idp_controller = IdpController(settings_facade, passwords_hasher_cls=hasher_cls) settings_facade.get.assert_called_once_with("oauth2_idp") hasher_cls.assert_called_once_with() self._hasher.get_hasher.assert_called_once_with( PasswordsHasherFactory.SHA512_SALT) self._tokens_service = Mock() self._tokens_service_cls = Mock(return_value=self._tokens_service)
def subject_mock(id, projectID): s = MagicMock(name='subject', spec=pyxnat.core.resources.Subject) xnat = _set_mock_intf(s) s.id = Mock(return_value=id) s.datatype = Mock(return_value='xnat:subjectData') s._uri = '/subjects/' + id attrs = { 'xnat:subjectData/project' : projectID } _set_mock_attrs(attrs, s) # Resources _add_mock_resource_files(xnat, s) #Sessions exp1 = session_mock(baseURI=s._uri, xnat=xnat) sessions = { '1':exp1 } get = Mock() get.get = Mock(side_effect=return_collection(['1'])) s.experiments = Mock(return_value=get) s.experiment = Mock(side_effect=lambda x: sessions.get(x)) return s
def test_parallel_computing(data_sources, thread, Queue): data_sources.return_value = ['1', '2'] m = Mock(name='Queue') type(m).maxsize = PropertyMock(return_value=2) m.get = Mock(return_value={'A': 1,'B': 1}) Queue.return_value = m eq_(dict(parallel_computing.parallel_computing()), {'A': 2, 'B': 2}) eq_(m.get.call_count, 2)
def _mock_settings_facade(self): '''This method mocks settings facade.''' settings_facade = Mock() settings_facade.get = Mock(return_value=self._DOC_BASE) settings_facade_cls = Mock(return_value=settings_facade) return settings_facade_cls
def test_get_body_of_object(self): obj = Mock() body = {'Body': Mock()} obj.get = Mock(return_value=body) data = self.bucket_service.get_body_of_object(obj) self.assertTrue(obj.get.called) self.assertEqual(data, body['Body'].read())
def mc_factory(self, was_404): """ churn out mocked caches with a preset .get(). Also a rapper? """ mc = Mock() ret = was_404 mc.get = Mock(return_value=ret) mc.set = Mock() return mc
def test_plain(self): mock = Mock() mock._headers = {HTTP_CONTENT_TYPE: 'text/plain'} mock.content = 'sdfsdf' mock.get = mock._headers.get factory = ResponseModelFactory(mock) body, content = factory.body() self.assertFalse(body) self.assertEqual(content, mock.content)
def test_plain(self): mock_request = Mock() mock_request.META = {DJANGO_META_CONTENT_TYPE: 'text/plain'} mock_request.body = 'sdfsdf' mock_request.get = mock_request.META.get factory = RequestModelFactory(mock_request) body, raw_body = factory.body() self.assertFalse(body) self.assertEqual(raw_body, mock_request.body)
def test_script_execution_when_no_properties_file_is_selected(self): mocked_interactive_properties_file = Mock() mocked_interactive_properties_file.get = Mock(return_value=False) mocked_emr_deploy = Mock() mocked_emr_deploy.run_properties_file = Mock(return_value=True) mocked_injector = Mock() mocked_injector.get = Mock( side_effect=[self.__get_mocked_wf_configuration(), mocked_interactive_properties_file, self.__generate_test_logger(), mocked_emr_deploy]) mocked_args = Mock() mocked_args.wf_dir = 'test' mocked_args.cluster_id = 'test' mocked_args.job_file_name = False mocked_emr_deploy.run_properties_file.assert_not_called()
def reqlib(url): reqlib = Mock(name="requests") response = Mock(name="response") response.url = url reqlib.get.return_value = response r = reqlib.get(url) assert r.url == url return reqlib