class TestLoader(BaseEnvVar): def test_default_search_paths(self): loader = Loader() self.assertEqual(len(loader.search_paths), 2) # We should also have ~/.aws/models added to # the search path. To deal with cross platform # issues we'll just check for a path that ends # with .aws/models. home_dir_path = os.path.join('.aws', 'models') self.assertTrue( any(p.endswith(home_dir_path) for p in loader.search_paths)) def test_can_add_to_search_path(self): loader = Loader() loader.search_paths.append('mypath') self.assertIn('mypath', loader.search_paths) def test_can_initialize_with_search_paths(self): loader = Loader(extra_search_paths=['foo', 'bar']) # Note that the extra search paths are before # the customer/builtin data paths. self.assertEqual(loader.search_paths, [ 'foo', 'bar', loader.CUSTOMER_DATA_PATH, loader.BUILTIN_DATA_PATH ]) # The file loader isn't consulted unless the current # search path exists, so we're patching isdir to always # say that a directory exists. @mock.patch('os.path.isdir', mock.Mock(return_value=True)) def test_load_data_uses_loader(self): search_paths = ['foo', 'bar', 'baz'] class FakeLoader(object): def load_file(self, name): expected_ending = os.path.join('bar', 'baz') if name.endswith(expected_ending): return ['loaded data'] loader = Loader(extra_search_paths=search_paths, file_loader=FakeLoader()) loaded = loader.load_data('baz') self.assertEqual(loaded, ['loaded data']) def test_data_not_found_raises_exception(self): class FakeLoader(object): def load_file(self, name): # Returning None indicates that the # loader couldn't find anything. return None loader = Loader(file_loader=FakeLoader()) with self.assertRaises(DataNotFoundError): loader.load_data('baz') @mock.patch('os.path.isdir', mock.Mock(return_value=True)) def test_error_raised_if_service_does_not_exist(self): loader = Loader(extra_search_paths=[], include_default_search_paths=False) with self.assertRaises(DataNotFoundError): loader.determine_latest_version('unknownservice', 'service-2') @mock.patch('os.path.isdir', mock.Mock(return_value=True)) def test_load_service_model(self): class FakeLoader(object): def load_file(self, name): return ['loaded data'] loader = Loader(extra_search_paths=['foo'], file_loader=FakeLoader(), include_default_search_paths=False, include_default_extras=False) loader.determine_latest_version = mock.Mock(return_value='2015-03-01') loader.list_available_services = mock.Mock(return_value=['baz']) loaded = loader.load_service_model('baz', type_name='service-2') self.assertEqual(loaded, ['loaded data']) @mock.patch('os.path.isdir', mock.Mock(return_value=True)) def test_load_service_model_enforces_case(self): class FakeLoader(object): def load_file(self, name): return ['loaded data'] loader = Loader(extra_search_paths=['foo'], file_loader=FakeLoader(), include_default_search_paths=False) loader.determine_latest_version = mock.Mock(return_value='2015-03-01') loader.list_available_services = mock.Mock(return_value=['baz']) # Should have a) the unknown service name and b) list of valid # service names. with self.assertRaisesRegex(UnknownServiceError, 'Unknown service.*BAZ.*baz'): loader.load_service_model('BAZ', type_name='service-2') def test_load_service_model_uses_provided_type_name(self): loader = Loader(extra_search_paths=['foo'], file_loader=mock.Mock(), include_default_search_paths=False) loader.list_available_services = mock.Mock(return_value=['baz']) # Should have a) the unknown service name and b) list of valid # service names. provided_type_name = 'not-service-2' with self.assertRaisesRegex(UnknownServiceError, 'Unknown service.*BAZ.*baz'): loader.load_service_model('BAZ', type_name=provided_type_name) loader.list_available_services.assert_called_with(provided_type_name) def test_create_loader_parses_data_path(self): search_path = os.pathsep.join(['foo', 'bar', 'baz']) loader = create_loader(search_path) self.assertIn('foo', loader.search_paths) self.assertIn('bar', loader.search_paths) self.assertIn('baz', loader.search_paths)
def thread_map(): return {'cid': mock.Mock()}
def output_stream(): output = six.StringIO() output.flush = mock.Mock() return output
def logging_handler(): stream = mock.Mock() stream.isatty.return_value = True return logging.StreamHandler(stream=stream)
self._mgr = module_inst def __getattr__(self, item): if self._mgr is None: raise AttributeError( "global manager module instance not initialized") return getattr(self._mgr, item) mgr = _ModuleProxy() else: import logging logging.basicConfig(level=logging.DEBUG) logging.root.handlers[0].setLevel(logging.DEBUG) os.environ['PATH'] = '{}:{}'.format( os.path.abspath('../../../../build/bin'), os.environ['PATH']) import sys # Used to allow the running of a tox-based yml doc generator from the dashboard directory if os.path.abspath(sys.path[0]) == os.getcwd(): sys.path.pop(0) from tests import mock # type: ignore mgr = mock.Mock() mgr.get_frontend_path.side_effect = lambda: os.path.abspath( "./frontend/dist") # DO NOT REMOVE: required for ceph-mgr to load a module from .module import Module, StandbyModule # noqa: F401
def setUp(self): self.bucket = mock.Mock(name='my_bucket') self.copy_source = {'Bucket': 'foo', 'Key': 'bar'}
def setUp(self): self.client = mock.Mock() self.resource = mock.Mock() self.resource.meta.client = self.client self.head_object_response = {'ContentLength': 5, 'ETag': 'my-etag'} self.client.head_object.return_value = self.head_object_response
def setUp(self): self.style = mock.Mock() self.doc = mock.Mock() self.doc.style = self.style self.doc.translate_words.return_value = ['foo'] self.node = parser.LineItemNode()
def setUp(self): self.style = mock.Mock() self.doc = mock.Mock() self.doc.style = self.style self.tree = parser.HTMLTree(self.doc)
def setUp(self): self.style = mock.Mock() self.doc = mock.Mock() self.doc.style = self.style self.tag = 'foo' self.node = parser.TagNode(self.tag)
def setUp(self): self.style = mock.Mock() self.doc = mock.Mock() self.doc.style = self.style
def setUp(self): self.retry_checker = mock.Mock(spec=standard.StandardRetryConditions) self.retry_backoff = mock.Mock(spec=standard.ExponentialBackoff) self.retry_policy = standard.RetryPolicy( retry_checker=self.retry_checker, retry_backoff=self.retry_backoff)
def setUp(self): self.events = mock.Mock() self.client = mock.Mock() self.client.meta.events = self.events self.meta = ResourceMeta('dynamodb')
class RaceCardTest(unittest.TestCase): def setUp(self): self.client = APIClient('username', 'password', 'app_key', 'UK') self.race_card = RaceCard(self.client) def test_init(self): assert self.race_card.connect_timeout == 3.05 assert self.race_card._error == APIError assert self.race_card.client == self.client assert self.race_card.app_key is None def test_login(self): mock_session = mock.Mock() mock_response = mock.Mock() mock_response.text = '"appKey": "1234",' mock_session.get.return_value = mock_response self.race_card.login(mock_session) assert self.race_card.app_key == '1234' mock_session.get.assert_called_with(self.race_card.login_url) assert mock_session.get.call_count == 1 def test_login_error(self): mock_session = mock.Mock() mock_response = mock.Mock() mock_response.text = '"applesKey": "1234",' mock_session.get.return_value = mock_response with self.assertRaises(RaceCardError): self.race_card.login(mock_session) assert self.race_card.app_key is None mock_session.get.assert_called_with(self.race_card.login_url) assert mock_session.get.call_count == 1 @mock.patch( 'betfairlightweight.endpoints.racecard.RaceCard.process_response') @mock.patch('betfairlightweight.endpoints.racecard.RaceCard.request', return_value=(mock.Mock(), 1.3)) def test_get_race_card(self, mock_request, mock_process_response): market_ids = ['1', '2'] data_entries = 'test' with self.assertRaises(RaceCardError): self.race_card.get_race_card(market_ids) self.race_card.app_key = '1234' self.race_card.get_race_card(market_ids=market_ids, data_entries=data_entries) mock_request.assert_called_once_with(session=None, params={ 'marketId': '1,2', 'dataEntries': 'test' }) assert mock_request.call_count == 1 @mock.patch('betfairlightweight.endpoints.racecard.check_status_code') @mock.patch('betfairlightweight.endpoints.racecard.RaceCard.create_req') @mock.patch('betfairlightweight.endpoints.racecard.RaceCard.headers') @mock.patch('betfairlightweight.baseclient.requests.get') def test_request(self, mock_get, mock_login_headers, mock_create_req, mock_check_status_code): mock_login_headers.return_value = {} self.race_card.request() mock_get.assert_called_with(self.race_card.url, headers=mock_login_headers, params=None) assert mock_get.call_count == 1 @mock.patch('betfairlightweight.endpoints.racecard.RaceCard.create_req') @mock.patch('betfairlightweight.endpoints.racecard.RaceCard.headers') @mock.patch('betfairlightweight.baseclient.requests.get') def test_request_error(self, mock_get, mock_login_headers, mock_create_req): mock_get.side_effect = ConnectionError() with self.assertRaises(APIError): self.race_card.request() mock_get.side_effect = ValueError() with self.assertRaises(APIError): self.race_card.request() def test_create_req(self): assert self.race_card.create_race_card_req(['1', '2'], None) == { 'dataEntries': "RACE, TIMEFORM_DATA, RUNNERS, RUNNER_DETAILS", 'marketId': '1,2' } assert self.race_card.create_race_card_req(['1', '2'], ['RACE']) == { 'dataEntries': ['RACE'], 'marketId': '1,2' } def test_headers(self): assert self.race_card.headers == { 'Connection': 'keep-alive', 'Content-Type': 'application/json', 'X-Application': None } def test_urls(self): assert self.race_card.url == 'https://www.betfair.com/rest/v2/raceCard' assert self.race_card.login_url == 'https://www.betfair.com/exchange/plus/'
class InPlayServiceTest(unittest.TestCase): def setUp(self): self.client = APIClient('username', 'password', 'app_key', 'UK') self.in_play_service = InPlayService(self.client) def test_init(self): assert self.in_play_service.connect_timeout == 3.05 assert self.in_play_service.read_timeout == 16 assert self.in_play_service._error == APIError assert self.in_play_service.client == self.client @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.process_response' ) @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.request', return_value=(mock.Mock(), 1.3)) def test_get_event_timeline(self, mock_request, mock_process_response): event_id = 12345 params = { 'eventId': event_id, 'alt': 'json', 'regionCode': 'UK', 'locale': 'en_GB' } self.in_play_service.get_event_timeline(event_id) mock_request.assert_called_with( url='https://www.betfair.com/inplayservice/v1.1/eventTimeline', session=None, params=params) assert mock_request.call_count == 1 assert mock_process_response.call_count == 1 @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.process_response' ) @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.request', return_value=(mock.Mock(), 1.3)) def test_get_event_timelines(self, mock_request, mock_process_response): event_ids = [12345, 54321] params = { 'eventIds': '12345,54321', 'alt': 'json', 'regionCode': 'UK', 'locale': 'en_GB' } self.in_play_service.get_event_timelines(event_ids) mock_request.assert_called_with( url='https://www.betfair.com/inplayservice/v1.1/eventTimelines', session=None, params=params) assert mock_request.call_count == 1 assert mock_process_response.call_count == 1 @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.process_response' ) @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.request', return_value=(mock.Mock(), 1.3)) def test_get_scores(self, mock_request, mock_process_response): event_ids = [12345] params = { 'eventIds': ','.join(str(x) for x in event_ids), 'alt': 'json', 'regionCode': 'UK', 'locale': 'en_GB' } self.in_play_service.get_scores(event_ids) mock_request.assert_called_with( url='https://www.betfair.com/inplayservice/v1.1/scores', session=None, params=params) assert mock_request.call_count == 1 assert mock_process_response.call_count == 1 @mock.patch('betfairlightweight.endpoints.inplayservice.check_status_code') @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.headers') @mock.patch('betfairlightweight.baseclient.requests.get') def test_request(self, mock_get, mock_headers, mock_check_status_code): params = [1, 2, 3] url = '123' self.in_play_service.request(params=params, url=url) mock_get.assert_called_with(url, headers=mock_headers, params=params) assert mock_get.call_count == 1 assert mock_check_status_code.call_count == 1 @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.headers') @mock.patch('betfairlightweight.baseclient.requests.get') def test_request_error(self, mock_get, mock_headers): params = [1, 2, 3] url = '123' mock_get.side_effect = ConnectionError() with self.assertRaises(APIError): self.in_play_service.request(params=params, url=url) mock_get.side_effect = ValueError() with self.assertRaises(APIError): self.in_play_service.request(params=params, url=url) @mock.patch('betfairlightweight.endpoints.inplayservice.check_status_code') @mock.patch( 'betfairlightweight.endpoints.inplayservice.InPlayService.headers') @mock.patch('betfairlightweight.baseclient.requests.get') def test_request_json_error(self, mock_get, mock_headers, mock_check_status_code): params = [1, 2, 3] url = '123' response = mock.Mock() mock_get.return_value = response response.json.side_effect = ValueError() with self.assertRaises(InvalidResponse): self.in_play_service.request(params=params, url=url) def test_headers(self): assert self.in_play_service.headers == { 'Connection': 'keep-alive', 'Content-Type': 'application/json' } def test_url(self): assert self.in_play_service.url == 'https://www.betfair.com/inplayservice/v1.1/'
def setUp(self): self.style = mock.Mock() self.doc = mock.Mock() self.doc.style = self.style self.node = parser.StemNode()
def test_available(self): md5 = mock.Mock() with mock.patch('botocore.compat.MD5_AVAILABLE', True): with mock.patch('hashlib.md5', mock.Mock(return_value=md5)): self.assertEqual(get_md5(), md5)
def setUp(self): super().setUp() self.input_file = mock.Mock(spec_set=File) self.decompiler = Decompiler(api_key='KEY')
def setUp(self): self.obj = mock.Mock(bucket_name='my_bucket', key='my_key') self.copy_source = {'Bucket': 'foo', 'Key': 'bar'}
def setup(self): # Creating the class and Mocking # a bunch of attributes for testing module._module = mock.Mock() # just so Event._refresh() works self.test_event = module.PgRecoveryEvent(None, None, [module.PgId(1,i) for i in range(3)], [0], 30, False)
def setUp(self): self.client = mock.Mock() self.resource = mock.Mock() self.resource.meta.client = self.client
def raw_stream(self, contents): raw = mock.Mock() raw.stream.return_value = [contents] return raw
def setUp(self): self.session = mock.Mock() self.session.num_listeners.return_value = 0 self.pyaudio = mock.Mock() with mock.patch.dict('sys.modules', {'pyaudio': self.pyaudio}): self.sink = spotify.PortAudioSink(self.session)
def create_fake_op_model(service_name): model = mock.Mock() model.service_model.service_name = service_name return model
def import_module(self, *args, **kargs): return mock.Mock()
def test_get_app_key_mocked(self, mocked_environ): self.client.app_key = None mocked_environ.__get__ = mock.Mock(return_value='app_key') assert self.client.get_app_key() is None
def mock_presenters(): return itertools.cycle([mock.Mock()])
def setUp(self): self.stream = mock.Mock() self.stream.isatty.return_value = True self.handler = logging.StreamHandler(stream=self.stream)
def mock_container(): return mock.Mock(spec=Container, name_without_project='web_1')
def test_proxies_list_endpoints_to_resolver(self): resolver = mock.Mock() resolver.get_available_endpoints.return_value = ['a', 'b'] self.session._register_internal_component('endpoint_resolver', resolver) self.session.get_available_regions('foo', 'bar', True)