def test_avg_impl_vol():
replace = Replacer()
mock_spx = Index('MA890', AssetClass.Equity, 'SPX')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.average_implied_volatility(mock_spx, '1m', tm.EdrDataReference.DELTA_CALL, 25)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='averageImpliedVolatility'), actual)
actual = tm.average_implied_volatility(mock_spx, '1m', tm.EdrDataReference.DELTA_PUT, 75)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='averageImpliedVolatility'), actual)
with pytest.raises(NotImplementedError):
tm.average_implied_volatility(..., '1m', tm.EdrDataReference.DELTA_PUT, 75, real_time=True)
replace.restore()
def mock_risk_model():
replace = Replacer()
# mock getting risk model entity()
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model',
Mock())
mock.return_value = mock_risk_model_obj
actual = Factor_Risk_Model.get(model_id='model_id')
replace.restore()
return actual
def test_cds_implied_vol():
replace = Replacer()
mock_cds = Index('MA890', AssetClass.Equity, 'CDS')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.cds_implied_volatility(mock_cds, '1m', '5y', tm.CdsVolReference.DELTA_CALL, 10)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='impliedVolatilityByDeltaStrike'), actual)
actual = tm.cds_implied_volatility(mock_cds, '1m', '5y', tm.CdsVolReference.FORWARD, 100)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='impliedVolatilityByDeltaStrike'), actual)
with pytest.raises(NotImplementedError):
tm.cds_implied_volatility(..., '1m', '5y', tm.CdsVolReference.DELTA_PUT, 75, real_time=True)
replace.restore()
def test_currency_holiday_calendars():
replace = Replacer()
replace('gs_quant.api.gs.data.GsDataApi.query_data',
Mock(side_effect=mock_holiday_data))
rdate = RelativeDate('-1b', base_date=dt(2022, 4, 12))
assert dt(2022, 4, 11) == rdate.apply_rule(currencies=[])
assert dt(2022, 4, 11) == rdate.apply_rule(currencies=['GBP'])
assert dt(2022, 4, 8) == rdate.apply_rule(currencies=['USD'])
assert dt(2022, 4,
11) == rdate.apply_rule() # No longer using USD by default
replace.restore()
def test_factor_proportion_of_risk():
replace = Replacer()
# mock getting risk model entity()
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model',
Mock())
mock.return_value = risk_model
mock = replace('gs_quant.api.gs.reports.GsReportApi.get_report', Mock())
mock.return_value = factor_risk_report
# mock getting report factor data
mock = replace(
'gs_quant.api.gs.reports.GsReportApi.get_risk_factor_data_results',
Mock())
mock.return_value = factor_data
# mock getting risk model dates
mock = replace(
'gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model_dates',
Mock())
mock.return_value = ['2010-01-01']
# mock getting risk model factor category
mock = replace(
'gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_data',
Mock())
mock.return_value = {
'results': [{
'factorData': [{
'factorId': 'factor_id',
'factorCategory': 'Factor Name'
}]
}]
}
# mock getting risk model factor entity
mock = replace(
'gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_factor_data',
Mock())
mock.return_value = [{
'identifier': 'factor_id',
'type': 'Factor',
'name': 'Factor Name',
'factorCategory': 'Factor Name'
}]
with DataContext(datetime.date(2020, 11, 23), datetime.date(2020, 11, 25)):
actual = mr.factor_proportion_of_risk('report_id', 'Factor Name')
assert all(actual.values == [1, 2, 3])
with pytest.raises(MqValueError):
mr.factor_proportion_of_risk('report_id', 'Wrong Factor Name')
replace.restore()
def test_get():
group = TargetGroup.from_dict({
'name': 'fakeGroup',
'id': 'groupId',
'tags': []
})
replace = Replacer()
mock = replace('gs_quant.api.gs.groups.GsGroupsApi.get_group', Mock())
mock.return_value = group
assert Group.get('groupId').name == 'fakeGroup'
replace.restore()
def test_set_prefix_updates_prefix(self):
with Replacer() as r:
r.replace(
'deployfish.aws.systems_manager.UnboundParameter._from_aws',
Mock())
p = UnboundParameter('BAZ')
self.assertEqual(p.name, 'BAZ')
self.assertEqual(p.prefix, '')
p.prefix = 'foo.bar.'
self.assertEqual(p.name, 'foo.bar.BAZ')
self.assertEqual(p.prefix, 'foo.bar.')
def setUp(self):
current_dir = os.path.dirname(os.path.abspath(__file__))
state_file = os.path.join(current_dir, 'terraform.tfstate')
config_yml = os.path.join(current_dir, 'interpolate.yml')
with open(state_file) as f:
tfstate = json.loads(f.read())
os.environ['FOOBAR_ENV'] = "hi_mom"
with Replacer() as r:
get_mock = r('deployfish.terraform.Terraform._get_state_file_from_s3', Mock())
get_mock.return_value = tfstate
self.config = Config(filename=config_yml, interpolate=False)
def setUp(self):
current_dir = os.path.dirname(os.path.abspath(__file__))
fname = os.path.join(current_dir, 'simple.yml')
self.config = Config(filename=fname, interpolate=False)
with Replacer() as r:
r.replace('deployfish.aws.ecs.Service.from_aws', Mock())
self.service = Service('foobar-prod', config=self.config)
p = Parameter('foobar-service', 'foobar-cluster', yml='KEY=VALUE')
self.service.parameter_store.append(p)
self.service.desired_task_definition.set_parameter_store(
self.service.parameter_store)
def setUp(self):
self.log_base_dir = tempfile.mkdtemp()
self.format = "%Y-%m-%d_%H-%M"
config_file = "%s/test_logSupport.yaml" %\
os.path.join(sys.path[0], "test_configurations")
self.config = yaml.load(file(config_file, 'r'))
self.replace = Replacer()
self.replace(
'glideinwms.lib.logSupport.time.time',
test_time(2018, 6, 13, 16, 0, 1, delta=60, delta_type='seconds'))
def setUp(self):
aws_data = {'ScalingPolicies': [], 'NextToken': None}
metric_aws_data = {'MetricAlarms': [], 'NextToken': None}
appscaling_client = Mock()
appscaling_client.describe_scaling_policies = Mock(
return_value=aws_data)
appscaling_client.describe_alarms = Mock(return_value=metric_aws_data)
client = Mock(return_value=appscaling_client)
self.init = Mock(return_value=None)
with Replacer() as r:
r.replace('boto3.client', client)
self.policy = ScalingPolicy('my_service', 'my_cluster', YML)
def test_import_and_obtain_with_lists(self):
t = test_datetime(None)
t.add(2002, 1, 1, 1, 0, 0)
t.add(2002, 1, 1, 2, 0, 0)
from testfixtures import Replacer
r = Replacer()
r.replace('testfixtures.tests.sample1.now', t.now)
try:
compare(sample1.str_now_2(), '2002-01-01 01:00:00')
compare(sample1.str_now_2(), '2002-01-01 02:00:00')
finally:
r.restore()
def test_import_and_obtain_with_lists(self):
t = test_date(None)
t.add(2002, 1, 1)
t.add(2002, 1, 2)
from testfixtures import Replacer
r = Replacer()
r.replace('testfixtures.tests.sample1.today', t.today)
try:
compare(sample1.str_today_2(), '2002-01-01')
compare(sample1.str_today_2(), '2002-01-02')
finally:
r.restore()
def test_dont_create_or_cleanup_with_path(self):
with Replacer() as r:
m = Mock()
r.replace('testfixtures.tempdirectory.mkdtemp', m)
r.replace('testfixtures.tempdirectory.rmtree', m)
@tempdir(path='foo')
def test_method(d):
compare(d.path, 'foo')
test_method()
self.assertFalse(m.called)
def setUp(self):
self.global_config = BaseGlobalConfig()
self.project_config = BaseProjectConfig(self.global_config)
self.task_config = TaskConfig()
self._task_log_handler.reset()
self.task_log = self._task_log_handler.messages
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace('cumulusci.tasks.command.subprocess.Popen', self.Popen)
self.addCleanup(self.r.restore)
def test_get():
user = TargetUser.from_dict({
'id': 'userId',
'email': '*****@*****.**',
'name': 'Doe, Jane',
'company': 'Goldman Sachs Group'
})
replace = Replacer()
mock = replace('gs_quant.api.gs.users.GsUsersApi.get_users', Mock())
mock.return_value = [user]
assert User.get(name='Doe, Jane').id == 'userId'
replace.restore()
def test_replacer_del(self):
r = Replacer()
r.replace('testfixtures.tests.sample1.left_behind',
object(),
strict=False)
with catch_warnings(record=True) as w:
del r
self.assertTrue(len(w), 1)
compare(
str(w[0].message),
"Replacer deleted without being restored, originals left:"
" {'testfixtures.tests.sample1.left_behind': <not_there>}")
def test_edit_LDAP_user_view_GET(self):
self.login('wagtail_admin')
with Replacer() as r:
r.replace('wagtail_patches.views.users.LDAPUserEditForm',
self.form_dummy)
r.replace('wagtail.wagtailadmin.messages', self.messages_dummy)
# Need to force the passwords to be considered unusable so that form code thinks the User is an LDAP user.
r.replace('django.contrib.auth.base_user.is_password_usable',
self.password_not_usable_dummy)
# First, test to make sure the routing works.
response = self.client.get(reverse('wagtailusers_users:edit',
args=[self.wagtail_editor.pk]),
HTTP_HOST=self.wagtail_site.hostname)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response,
'wagtail_patches/users/edit.html')
self.form_dummy.reset_dummy()
# Confirm that unprivileged users can't access the view.
self.login('wagtail_editor')
response = self.client.get(reverse('wagtailusers_users:edit',
args=[self.wagtail_editor.pk]),
HTTP_HOST=self.wagtail_site.hostname)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, reverse('wagtailadmin_home'))
self.assertEqual(len(self.messages_dummy.error.calls), 1)
# Now, the real unit test requires us to call the view function directly, since it's not
# consistently possible to retrieve the request object from the output of the http testing client.
request = self.wagtail_factory.get('/')
request.user = self.wagtail_admin
request.site = self.wagtail_site
response = edit(request, self.wagtail_editor.pk)
self.assertEqual(response.template_name,
'wagtail_patches/users/edit.html')
self.assertEqual(response.context_data['form'],
self.form_dummy.default_return)
self.assertEqual(response.context_data['user'].pk,
self.wagtail_editor.pk)
self.assertEqual(len(self.form_dummy.calls), 1)
self.assertEqual(self.form_dummy.calls[0]['args'][0], request)
self.assertEqual(self.form_dummy.calls[0]['args'][1].pk,
self.wagtail_editor.pk)
# Confirm that a non-superusers can't edit a superuser.
response = edit(request, self.superuser.pk)
self.assertEqual(response.url, reverse('wagtailadmin_home'))
# Confirm that a non-superusers can't edit a user belonging to another Site.
response = edit(request, self.test_admin.pk)
self.assertEqual(response.url, reverse('wagtailadmin_home'))
def test_basket():
dates = [
datetime.datetime(2019, 1, 1),
datetime.datetime(2019, 1, 2),
datetime.datetime(2019, 1, 3),
datetime.datetime(2019, 1, 4),
datetime.datetime(2019, 1, 5),
datetime.datetime(2019, 1, 6),
]
x = pd.Series([100.0, 101, 103.02, 100.9596, 100.9596, 102.978792],
index=dates)
y = pd.Series([100.0, 100, 100, 100, 100, 100], index=dates)
assert_series_equal(x, basket_series([x], [1]))
assert_series_equal(x, basket_series([x, x], [0.5, 0.5]))
assert_series_equal(x, basket_series([x, x, x], [1 / 3, 1 / 3, 1 / 3]))
assert_series_equal(x, basket_series([x, y], [1, 0]))
assert_series_equal(y, basket_series([x, y], [0, 1]))
with pytest.raises(MqValueError):
basket_series([x, y], [1])
with pytest.raises(MqTypeError):
basket_series([1, 2, 3], [1])
dates = [
datetime.datetime(2019, 1, 1),
datetime.datetime(2019, 1, 2),
datetime.datetime(2019, 1, 3),
datetime.datetime(2019, 1, 4),
datetime.datetime(2019, 1, 5),
datetime.datetime(2019, 1, 6),
datetime.datetime(2019, 2, 1),
datetime.datetime(2019, 2, 2),
datetime.datetime(2019, 2, 3),
datetime.datetime(2019, 2, 4),
datetime.datetime(2019, 2, 5),
datetime.datetime(2019, 2, 6),
]
mreb = pd.Series([
100.0, 101, 103.02, 100.9596, 100.9596, 102.978792, 100.0, 101, 103.02,
100.9596, 100.9596, 102.978792
],
index=dates)
assert_series_equal(
mreb, basket_series([mreb], [1], rebal_freq=RebalFreq.MONTHLY))
replace = Replacer()
mock = replace('gs_quant.timeseries.backtesting.basket_series', Mock())
args = ([mreb], [1], None, RebalFreq.MONTHLY, ReturnType.EXCESS_RETURN)
basket(*args)
assert mock.call_args == call(
*args) # basket passes args through to basket_series
replace.restore()
def test_register_failure_username_exists(self):
# replace validate_user function so it passes
with Replacer() as r:
r.replace('steerclear.utils.cas.validate_user', self.mock_validate_user)
# create a user
self._create_user(username='******')
# check that POST request failed
response = self.client.post(url_for('login.register'), data=self.register_payload)
self.assertEquals(response.status_code, 409)
self.assertTemplateUsed(REGISTER_TEMPLATE_NAME)
self.assertContext('action', url_for('login.register'))
def test_with_statement(self):
from testfixtures.tests import sample1
assert sample1.z() == 'original z'
def test_z():
return 'replacement z'
with Replacer() as r:
r.replace('testfixtures.tests.sample1.z',test_z)
assert sample1.z() == 'replacement z'
assert sample1.z() == 'original z'
def test_date_return_type_picky(self):
# type checking is a bitch :-/
date_type = test_date(strict=True)
with Replacer() as r:
r.replace('datetime.datetime', test_datetime(date_type=date_type,
strict=True,
))
from datetime import datetime
dt = datetime(2010, 8, 26, 14, 33, 13)
d = dt.date()
compare(d, date_type(2010, 8, 26))
self.failUnless(d.__class__ is date_type)
def test_edit_local_user_view_POST_invalid_data(self):
self.login('superuser')
with Replacer() as r:
# By default, the form dummy's is_valid() returns False.
r.replace('wagtail_patches.views.users.LocalUserEditForm',
self.form_dummy)
r.replace('wagtail_patches.views.users.messages',
self.messages_dummy)
# Need to force the passwords to be considered usable so that form code thinks the User is a Local user.
r.replace('django.contrib.auth.base_user.is_password_usable',
self.password_is_usable_dummy)
# First, test to make sure the routing works.
form_data = {'groups': [self.test_editors_group.pk]}
response = self.client.post(reverse('wagtailusers_users:edit',
args=[self.wagtail_editor.pk]),
data=form_data,
HTTP_HOST=self.wagtail_site.hostname)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response,
'wagtail_patches/users/edit.html')
self.form_dummy.reset_dummy()
self.messages_dummy.reset_dummy()
# Now, the real unit test requires us to call the view function directly, since it's not
# consistently possible to retrieve the request object from the output of the http testing client.
request = self.wagtail_factory.post(reverse(
'wagtailusers_users:edit', args=[self.wagtail_editor.pk]),
data=form_data)
request.user = self.wagtail_admin
request.site = self.wagtail_site
response = edit(request, self.wagtail_editor.pk)
self.assertEqual(response.template_name,
'wagtail_patches/users/edit.html')
self.assertEqual(response.context_data['form'],
self.form_dummy.default_return)
self.assertEqual(response.context_data['user'].pk,
self.wagtail_editor.pk)
self.assertEqual(len(self.form_dummy.calls), 1)
self.assertEqual(self.form_dummy.calls[0]['args'][0], request)
self.assertEqual(self.form_dummy.calls[0]['args'][1].pk,
self.wagtail_editor.pk)
self.assertEqual(self.form_dummy.calls[0]['args'][2], request.POST)
self.assertEqual(len(self.messages_dummy.success.calls), 0)
self.assertEqual(len(self.messages_dummy.error.calls), 1)
self.assertEqual(self.messages_dummy.error.calls[0]['args'][0],
request)
self.assertEqual(self.messages_dummy.error.calls[0]['args'][1],
'The user could not be saved due to errors.')
def test_basket_average_implied_vol():
replace = Replacer()
dates = pd.DatetimeIndex([
date(2021, 1, 1),
date(2021, 1, 2),
date(2021, 1, 3),
date(2021, 1, 4),
date(2021, 1, 5),
date(2021, 1, 6)
])
x = pd.DataFrame(
{'impliedVolatility': [30.0, 30.2, 29.8, 30.6, 30.1, 30.0]},
index=dates)
x['assetId'] = 'MA4B66MW5E27U9VBB94'
y = pd.DataFrame(
{'impliedVolatility': [20.0, 20.2, 20.3, 20.6, 21.1, 20.0]},
index=dates)
y['assetId'] = 'MA4B66MW5E27UAL9SUX'
implied_vol = x.append(y)
implied_vol.index.name = 'date'
mock_data = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.side_effect = [implied_vol, _mock_spot_data()]
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{
'id': 'MA4B66MW5E27U9VBB94',
'bbid': 'AAPL UW'
}, {
'id': 'MA4B66MW5E27UAL9SUX',
'bbid': 'MSFT UW'
}]
a_basket = Basket(['AAPL UW', 'MSFT UW'], [0.1, 0.9], RebalFreq.DAILY)
expected = pd.Series([21.0, 21.2, 21.25, 21.6, 22.0, 21.0], index=dates)
actual = a_basket.average_implied_volatility('6m',
EdrDataReference.DELTA_CALL,
50)
assert_series_equal(actual, expected)
with pytest.raises(NotImplementedError):
a_basket.average_implied_volatility('6m',
EdrDataReference.DELTA_CALL,
50,
real_time=True)
replace.restore()
def test_basket_constructor():
with pytest.raises(MqValueError):
Basket(['AAPL UW'], [0.1, 0.9], RebalFreq.MONTHLY)
replace = Replacer()
dates = [
datetime.datetime(2021, 1, 1),
datetime.datetime(2021, 1, 2),
datetime.datetime(2021, 1, 3),
datetime.datetime(2021, 1, 4),
datetime.datetime(2021, 1, 5),
datetime.datetime(2021, 1, 6),
]
x = pd.DataFrame(
{'spot': [100.0, 101, 103.02, 100.9596, 100.9596, 102.978792]},
index=dates)
x['assetId'] = 'MA4B66MW5E27U9VBB94'
y = pd.DataFrame({'spot': [100.0, 100, 100, 100, 100, 100]}, index=dates)
y['assetId'] = 'MA4B66MW5E27UAL9SUX'
spot = x.append(y)
mock_data = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.return_value = spot
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{
'id': 'MA4B66MW5E27U9VBB94'
}, {
'id': 'MA4B66MW5E27UAL9SUX'
}]
a_basket = Basket(['AAPL UW', 'MSFT UW'], [0.1, 0.9], RebalFreq.MONTHLY)
expected = pd.Series(
[100.0, 100.1, 100.302, 100.09596, 100.09596, 100.297879], index=dates)
actual = a_basket.price()
assert_series_equal(actual, expected)
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{'id': 'MA4B66MW5E27U9VBB94'}]
with pytest.raises(MqValueError):
Basket(['AAPL UW', 'ABC'], [0.1, 0.9], RebalFreq.MONTHLY).price()
with pytest.raises(NotImplementedError):
a_basket.price(real_time=True)
replace.restore()
def test_get_tdapi_crosscurrency_rates_assets(mocker):
mock_asset_1 = GsAsset(asset_class='Rate', id='MAW8SAXPSKYA94E2', type_='XccySwapMTM', name='Test_asset')
mock_asset_2 = GsAsset(asset_class='Rate', id='MATDD783JM1C2GGD', type_='XccySwapMTM', name='Test_asset')
replace = Replacer()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1]
assert 'MAW8SAXPSKYA94E2' == tm._get_tdapi_crosscurrency_rates_assets()
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
kwargs = dict(asset_parameters_termination_date='5y', asset_parameters_effective_date='0b')
with pytest.raises(MqValueError):
tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = []
kwargs = dict(asset_parameters_clearing_house='NONE',
asset_parameters_payer_rate_option="EUR-EURIBOR-TELERATE",
asset_parameters_payer_currency='EUR',
asset_parameters_payer_designated_maturity='3m',
asset_parameters_receiver_rate_option="USD-LIBOR-BBA",
asset_parameters_receiver_currency='USD',
asset_parameters_receiver_designated_maturity='3m',
pricing_location='LDN')
with pytest.raises(MqValueError):
tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
kwargs = dict()
assert ['MAW8SAXPSKYA94E2', 'MATDD783JM1C2GGD'] == tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
# test case will test matching sofr maturity with libor leg and flipping legs to get right asset
kwargs = dict(type='XccySwapMTM', asset_parameters_termination_date='5y',
asset_parameters_payer_rate_option="EUR-EURIBOR-TELERATE",
asset_parameters_payer_currency="EUR",
asset_parameters_payer_designated_maturity='3m',
asset_parameters_receiver_rate_option="USD-LIBOR-BBA",
asset_parameters_receiver_currency="USD",
asset_parameters_receiver_designated_maturity='3m',
asset_parameters_clearing_house='None', asset_parameters_effective_date='5y',
pricing_location='LDN')
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1]
assert 'MAW8SAXPSKYA94E2' == tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
def test_save_throws_ValueError_if_aws_object_and_not_overwrite(self):
fake_boto3_session, put_parameter = self.get_mock_boto3_session(
response={'Parameters': [{
'Type': 'String'
}]})
with Replacer() as r:
r.replace('deployfish.aws.systems_manager.get_boto3_session',
fake_boto3_session)
p = UnboundParameter('foo.bar.BAZ', kms_key_id='my_key')
p.value = 'foobar'
with self.assertRaises(ValueError):
p.save()
put_parameter.assert_not_called()
def setUp(self):
self.dir = TempDirectory(ignore=['pyc$', 'pyo$'])
self.added_to_sys = []
# now add the path to sys.path
sys.path.append(self.dir.path)
# keep a set of modules, so we can delete any that get added
self.modules = set(sys.modules)
# create a handy Replacer
self.r = Replacer()
# make a package
self.dir.write('x/__init__.py', b'')
self.dir.write('x/y/__init__.py', b'')
self.dir.write('x/y/z/__init__.py', b'')
def test_sub_module_import(self):
with TempDirectory() as dir:
dir.write('module/__init__.py', '')
dir.write('module/submodule.py', 'def foo(): return "foo"')
with Replacer() as r:
r.replace('sys.path', [dir.path])
def bar():
return 'bar'
r.replace('module.submodule.foo', bar)
from module.submodule import foo
compare(foo(), 'bar')
def test_basis():
replace = Replacer()
mock_jpyusd = Cross('MA890', 'USD/JPY')
xrefs = replace('gs_quant.timeseries.measures.GsAssetApi.get_asset_xrefs', Mock())
xrefs.return_value = [GsTemporalXRef(dt.date(2019, 1, 1), dt.date(2952, 12, 31), XRef(bbid='JPYUSD', ))]
identifiers = replace('gs_quant.timeseries.measures.GsAssetApi.map_identifiers', Mock())
identifiers.return_value = {'USD-3m/JPY-3m': 'MA123'}
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_cross)
actual = tm.basis(mock_jpyusd, '1y')
assert_series_equal(pd.Series([1, 2, 3], index=_index * 3, name='basis'), actual)
with pytest.raises(NotImplementedError):
tm.basis(..., '1y', real_time=True)
replace.restore()
