Ejemplo n.º 1
0
 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)
Ejemplo n.º 2
0
    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))
Ejemplo n.º 3
0
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)
Ejemplo n.º 4
0
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)
Ejemplo n.º 5
0
 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))
Ejemplo n.º 6
0
    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
Ejemplo n.º 7
0
    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
Ejemplo n.º 8
0
    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
Ejemplo n.º 9
0
  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
Ejemplo n.º 10
0
  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))
Ejemplo n.º 13
0
    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))
Ejemplo n.º 14
0
    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)
Ejemplo n.º 15
0
    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', {})
Ejemplo n.º 16
0
    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
Ejemplo n.º 17
0
    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)
Ejemplo n.º 19
0
 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()
Ejemplo n.º 20
0
    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)
Ejemplo n.º 23
0
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
Ejemplo n.º 24
0
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)
Ejemplo n.º 25
0
  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))
Ejemplo n.º 26
0
    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()
Ejemplo n.º 28
0
 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()
Ejemplo n.º 30
0
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()
Ejemplo n.º 32
0
 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'
     }
Ejemplo n.º 33
0
    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')
Ejemplo n.º 34
0
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()
Ejemplo n.º 36
0
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))
Ejemplo n.º 38
0
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)
Ejemplo n.º 39
0
    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()
Ejemplo n.º 40
0
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)
Ejemplo n.º 41
0
    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')
Ejemplo n.º 43
0
    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)
Ejemplo n.º 45
0
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
Ejemplo n.º 46
0
    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", {})
Ejemplo n.º 47
0
    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()
Ejemplo n.º 48
0
    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)
Ejemplo n.º 49
0
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
Ejemplo n.º 52
0
    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())
Ejemplo n.º 53
0
 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
Ejemplo n.º 54
0
 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)
Ejemplo n.º 55
0
 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)
Ejemplo n.º 56
0
    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()
Ejemplo n.º 57
0
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