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)
