def test_cleanup_properly(self):
r = Replacer()
try:
m = Mock()
d = mkdtemp()
m.return_value = d
r.replace('testfixtures.tempdirectory.mkdtemp', m)
self.failUnless(os.path.exists(d))
self.assertFalse(m.called)
@tempdir()
def test_method(d):
d.write('something', b'stuff')
d.compare(['something'])
self.assertFalse(m.called)
compare(os.listdir(d), [])
test_method()
self.assertTrue(m.called)
self.failIf(os.path.exists(d))
finally:
r.restore()
if os.path.exists(d):
# only runs if the test fails!
rmtree(d) # pragma: no cover
def test_list_subclass_strict(self):
m = Mock()
m.aCall()
self.check_raises(
[call.aCall()], m.method_calls,
("[call.aCall()] (<{0} 'list'>) != [call.aCall()] "
"({1})").format(class_type_name, call_list_repr),
strict=True,
)
def test_list_subclass_long_strict(self):
m = Mock()
m.call('X'*20)
self.check_raises(
[call.call('Y'*20)], m.method_calls,
("[call.call('YYYYYYYYYYYYYYYYYY... "
"(<{0} 'list'>) != "
"[call.call('XXXXXXXXXXXXXXXXXX... "
"({1})").format(class_type_name, call_list_repr),
strict=True,
)
def test_strict_comparer_supplied(self):
compare_obj = Mock()
compare_obj.return_value = 'not equal'
self.check_raises(
object(), object(),
"not equal",
strict=True,
comparers={object: compare_obj},
)
def test_calls_different(self):
m1 =Mock()
m2 =Mock()
m1.foo(1, 2, x=3, y=4)
m2.bar(1, 3, x=7, y=4)
self.check_raises(
m1.mock_calls,
m2.mock_calls,
"sequence not as expected:\n"
"\n"
"same:\n"
"[]\n"
"\n"
"first:\n"
"[call.foo(1, 2, x=3, y=4)]\n"
"\n"
"second:\n"
"[call.bar(1, 3, x=7, y=4)]"
"\n\n"
'While comparing [0]: \n'
"'call.foo(1, 2, x=3, y=4)'\n"
'!=\n'
"'call.bar(1, 3, x=7, y=4)'"
)
def test_wrapping_different_functions(self):
m = Mock()
@wrap(m.before1, m.after1)
def test_function1():
m.something1()
return 'something1'
@wrap(m.before2, m.after2)
def test_function2():
m.something2()
return 'something2'
compare(m.method_calls, [])
compare(test_function1(), 'something1')
compare(m.method_calls, [('before1', (), {}), ('something1', (), {}),
('after1', (), {})])
compare(test_function2(), 'something2')
compare(m.method_calls, [('before1', (), {}), ('something1', (), {}),
('after1', (), {}), ('before2', (), {}),
('something2', (), {}), ('after2', (), {})])
def test_vol_smile():
replace = Replacer()
mock_spx = Index('MA890', AssetClass.Equity, 'SPX')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.vol_smile(mock_spx, '1m', tm.VolSmileReference.FORWARD, '5d')
assert_series_equal(pd.Series([5, 1, 2], index=[0.75, 0.25, 0.5]), actual)
actual = tm.vol_smile(mock_spx, '1m', tm.VolSmileReference.SPOT, '5d')
assert_series_equal(pd.Series([5, 1, 2], index=[0.75, 0.25, 0.5]), actual)
market_mock = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
market_mock.return_value = pd.DataFrame()
actual = tm.vol_smile(mock_spx, '1m', tm.VolSmileReference.SPOT, '1d')
assert actual.empty
market_mock.assert_called_once()
with pytest.raises(NotImplementedError):
tm.vol_smile(mock_spx,
'1m',
tm.VolSmileReference.SPOT,
'1d',
real_time=True)
replace.restore()
def test_basket_price():
with pytest.raises(MqValueError):
Basket(['AAPL UW'], [0.1, 0.9], RebalFreq.MONTHLY)
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)])
dates_feb = pd.DatetimeIndex([date(2021, 2, 1), date(2021, 2, 2), date(2021, 2, 3), date(2021, 2, 4),
date(2021, 2, 5), date(2021, 2, 6)])
replace = Replacer()
mock_data = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.side_effect = [_mock_spot_data(), _mock_spot_data_feb()]
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.MONTHLY)
expected = pd.Series([100.0, 100.1, 100.302, 100.09596, 100.09596, 100.297879], index=dates)
with DataContext('2021-01-01', '2021-01-06'):
actual = a_basket.price()
assert_series_equal(actual, expected)
expected = pd.Series([100.00, 101.50, 100.62, 98.30, 96.30, 94.80], index=dates_feb)
with DataContext('2021-02-01', '2021-02-06'):
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', 'bbid': 'AAPL UW'}]
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_basket_average_realized_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)])
dates_feb = pd.DatetimeIndex([date(2021, 2, 1), date(2021, 2, 2), date(2021, 2, 3), date(2021, 2, 4),
date(2021, 2, 5), date(2021, 2, 6)])
mock_data = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.side_effect = [_mock_spot_data(), _mock_spot_data_feb()]
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([1.1225, 4.49, 2.245, 2.245], index=dates[2:])
with DataContext('2021-01-01', '2021-01-06'):
actual = a_basket.average_realized_volatility('2d')
assert_series_equal(actual, expected)
expected = pd.Series([3.304542, 3.174902, 3.174902], index=dates[3:])
with DataContext('2021-01-01', '2021-01-06'):
actual = a_basket.average_realized_volatility('3d')
assert_series_equal(actual, expected)
mock_data.assert_called_once()
expected = pd.Series([34.698082, 19.719302, 18.860533], index=dates_feb[3:])
with DataContext('2021-02-01', '2021-02-06'):
actual = a_basket.average_realized_volatility('3d')
assert_series_equal(actual, expected)
with pytest.raises(NotImplementedError):
a_basket.average_realized_volatility('2d', real_time=True)
replace.restore()
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_spot = replace('gs_quant.timeseries.backtesting.ts.get_historical_and_last_for_measure', Mock())
mock_spot.side_effect = [implied_vol.rename(columns={'impliedVolatility': 'spot'})]
mock_data = replace('gs_quant.api.utils.ThreadPoolManager.run_async', Mock())
mock_data.return_value = [implied_vol]
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', VolReference.DELTA_CALL, 50)
assert_series_equal(actual, expected)
with pytest.raises(NotImplementedError):
a_basket.average_implied_volatility('6m', VolReference.DELTA_CALL, 50, real_time=True)
mock_data.return_value = [pd.DataFrame(), pd.DataFrame()]
expected = pd.Series(dtype=float)
actual = a_basket.average_implied_volatility('3m', VolReference.FORWARD, 20) # no data for this
assert_series_equal(expected, actual)
replace.restore()
def _fwd_term_typical():
assert DataContext.current_is_set
data = {
'tenor': ['1w', '2w', '1y', '2y'],
'forward': [1, 2, 3, 4]
}
out = pd.DataFrame(data=data, index=pd.DatetimeIndex(['2018-01-01'] * 4))
replace = Replacer()
market_mock = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
market_mock.return_value = out
actual = tm.fwd_term(Index('MA123', AssetClass.Equity, '123'))
idx = pd.DatetimeIndex(['2018-01-08', '2018-01-15', '2019-01-01', '2020-01-01'], name='expirationDate')
expected = pd.Series([1, 2, 3, 4], name='forward', index=idx)
expected = expected.loc[DataContext.current.start_date: DataContext.current.end_date]
if expected.empty:
assert actual.empty
else:
assert_series_equal(expected, actual)
market_mock.assert_called_once()
replace.restore()
return actual
def test_currency_to_tdapi_xccy_swap_rate_asset(mocker):
replace = Replacer()
mocker.patch.object(GsSession.__class__, 'current',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(SecurityMaster, 'get_asset', side_effect=mock_request)
bbid_mock = replace('gs_quant.timeseries.measures_xccy.Asset.get_identifier', Mock())
with tm_rates.PricingContext(dt.date.today()):
cur = [
{
"currency_assetId": "MAK1FHKH5P5GJSHH",
"currency": "JPY",
"xccy_id": "MAFMW4HJC5TDE51H"
},
{
"currency_assetId": "MA66CZBQJST05XKG",
"currency": "GBP",
"xccy_id": "MATDD783JM1C2GGD"
},
{
"currency_assetId": "MAJNQPFGN1EBDHAE",
"currency": "EUR",
"xccy_id": "MAW8SAXPSKYA94E2"
},
]
for c in cur:
print(c)
asset = Currency(c.get("currency_assetId"), c.get("currency"))
bbid_mock.return_value = c.get("currency")
mqid = _currency_to_tdapi_crosscurrency_swap_rate_asset(asset)
assert mqid == c.get("xccy_id")
bbid_mock.return_value = None
assert _currency_to_tdapi_crosscurrency_swap_rate_asset(asset) == c.get("currency_assetId")
replace.restore()
def test_currencypair_to_tdapi_fxo_asset(mocker):
replace = Replacer()
mocker.patch.object(GsSession.__class__, 'current',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(SecurityMaster, 'get_asset', side_effect=mock_request)
bbid_mock = replace('gs_quant.timeseries.measures_fx_vol.Asset.get_identifier', Mock())
with tm_rates.PricingContext(dt.date.today()):
cur = [
{
"currency_assetId": "MAK1FHKH5P5GJSHH",
"currency": "USDJPY",
"id": "MAQ7YRZ4P94M9N9C"
},
{
"currency_assetId": "MA66CZBQJST05XKG",
"currency": "GBPUSD",
"id": "MAEHA6WVHJ2S3JY9"
},
{
"currency_assetId": "MAJNQPFGN1EBDHAE",
"currency": "EURUSD",
"id": "MAT1J37C9ZPMANFP"
},
]
for c in cur:
print(c)
asset = Currency(c.get("currency_assetId"), c.get("currency"))
bbid_mock.return_value = c.get("currency")
mqid = _currencypair_to_tdapi_fxo_asset(asset)
assert mqid == c.get("id")
bbid_mock.return_value = None
assert _currencypair_to_tdapi_fxo_asset(asset) == c.get("currency_assetId")
replace.restore()
def test_skew():
replace = Replacer()
mock_spx = Index('MA890', AssetClass.Equity, 'SPX')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.skew(mock_spx, '1m', tm.SkewReference.DELTA, 25)
assert_series_equal(
pd.Series([2.0], index=_index, name='impliedVolatility'), actual)
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data',
mock_eq_norm)
actual = tm.skew(mock_spx, '1m', tm.SkewReference.NORMALIZED, 4)
assert_series_equal(
pd.Series([2.0], index=_index, name='impliedVolatility'), actual)
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data',
mock_eq_spot)
actual = tm.skew(mock_spx, '1m', tm.SkewReference.SPOT, 25)
assert_series_equal(
pd.Series([2.0], index=_index, name='impliedVolatility'), actual)
mock = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data',
Mock())
mock.return_value = pd.DataFrame()
assert tm.skew(mock_spx, '1m', tm.SkewReference.SPOT, 25).empty
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_inc)
with pytest.raises(MqError):
tm.skew(mock_spx, '1m', tm.SkewReference.DELTA, 25)
replace.restore()
with pytest.raises(MqError):
tm.skew(mock_spx, '1m', None, 25)
with pytest.raises(MqError):
tm.skew(mock_spx, '1m', tm.SkewReference.SPOT, 25, real_time=True)
def test_swaption_vol2_return__empty_data():
replace = Replacer()
df = ExtendedSeries()
replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock()).return_value = "GBP"
replace('gs_quant.timeseries.measures_rates._get_tdapi_rates_assets',
Mock(),
Mock()).return_value = ["MADWG3WHCKNE1DJA", "MAH6JK3TZJJGFQ65"]
replace('gs_quant.timeseries.measures_rates._range_from_pricing_date',
Mock(),
Mock()).return_value = [dt.date(2019, 1, 2),
dt.date(2019, 1, 5)]
replace('gs_quant.timeseries.measures_rates._market_data_timed',
Mock()).return_value = df
actual = tm_rates.swaption_vol(Currency("GBP", name="GBP"))
assert_series_equal(ExtendedSeries(), actual)
replace.restore()
def test_swap_rate():
replace = Replacer()
mock_usd = Currency('MA890', 'USD')
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='USD', ))]
identifiers = replace('gs_quant.timeseries.measures.GsAssetApi.map_identifiers', Mock())
identifiers.return_value = {'USD-3m': 'MA123'}
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_curr)
actual = tm.swap_rate(mock_usd, '1y')
assert_series_equal(pd.Series([1, 2, 3], index=_index * 3, name='swapRate'), actual)
identifiers = replace('gs_quant.timeseries.measures.GsAssetApi.map_identifiers', Mock())
identifiers.return_value = {'USD OIS': 'MA123'}
actual = tm.swap_rate(mock_usd, '1y', BenchmarkType.OIS)
assert_series_equal(pd.Series([1, 2, 3], index=_index * 3, name='swapRate'), actual)
mock_eur = Currency('MA890', 'EUR')
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='EUR', ))]
identifiers = replace('gs_quant.timeseries.measures.GsAssetApi.map_identifiers', Mock())
identifiers.return_value = {'EUR-6m': 'MA123'}
actual = tm.swap_rate(mock_eur, '1y')
assert_series_equal(pd.Series([1, 2, 3], index=_index * 3, name='swapRate'), actual)
mock_sek = Currency('MA890', 'SEK')
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='SEK', ))]
identifiers = replace('gs_quant.timeseries.measures.GsAssetApi.map_identifiers', Mock())
identifiers.return_value = {'SEK-6m': 'MA123'}
actual = tm.swap_rate(mock_sek, '1y')
assert_series_equal(pd.Series([1, 2, 3], index=_index * 3, name='swapRate'), actual)
with pytest.raises(NotImplementedError):
tm.swap_rate(..., '1y', real_time=True)
replace.restore()
def test_swaption_vol_smile2_returns_no_data():
replace = Replacer()
df = ExtendedSeries()
replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock()).return_value = "GBP"
replace('gs_quant.timeseries.measures_rates._get_tdapi_rates_assets',
Mock(),
Mock()).return_value = ["MADWG3WHCKNE1DJA", "MAH6JK3TZJJGFQ65"]
replace('gs_quant.timeseries.measures_rates._range_from_pricing_date',
Mock(),
Mock()).return_value = [dt.date(2020, 1, 2),
dt.date(2020, 1, 2)]
replace('gs_quant.timeseries.measures_rates._market_data_timed',
Mock()).return_value = df
with DataContext('2019-01-01', '2025-01-01'):
actual = tm_rates.swaption_vol_smile(Currency("GBP", name="GBP"), '3m',
'10y')
assert_series_equal(ExtendedSeries(), actual)
replace.restore()
def test_swaption_swaption_vol_term2_returns_empty():
replace = Replacer()
df = ExtendedSeries()
replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock()).return_value = "GBP"
replace('gs_quant.timeseries.measures_rates._get_tdapi_rates_assets',
Mock(),
Mock()).return_value = ["MADWG3WHCKNE1DJA", "MAH6JK3TZJJGFQ65"]
replace('gs_quant.timeseries.measures_rates._range_from_pricing_date',
Mock(),
Mock()).return_value = [dt.date(2020, 1, 2),
dt.date(2020, 1, 2)]
replace('gs_quant.timeseries.measures_rates._market_data_timed',
Mock()).return_value = df
with DataContext('2019-01-01', '2025-01-01'):
actual = tm_rates.swaption_vol_term(Currency("GBP", name="GBP"),
tm.SwaptionTenorType.SWAP_MATURITY,
'5y', 0)
assert_series_equal(ExtendedSeries(), actual, check_names=False)
replace.restore()
def test_swaption_swaption_vol_term2_returns_data():
replace = Replacer()
df = MarketDataResponseFrame(
data=dict(expirationTenor=['1m', '6m', '1y'], terminationTenor=['1y', '2y', '3y'], swaptionVol=[1, 2, 3]),
index=_index * 3)
replace('gs_quant.timeseries.measures.Asset.get_identifier', Mock()).return_value = "GBP"
replace('gs_quant.timeseries.measures_rates._get_tdapi_rates_assets', Mock(), Mock()).return_value = [
"MADWG3WHCKNE1DJA", "MAH6JK3TZJJGFQ65"]
replace('gs_quant.timeseries.measures_rates._range_from_pricing_date', Mock(), Mock()).return_value = [
dt.date(2020, 1, 2), dt.date(2020, 1, 2)]
replace('gs_quant.timeseries.measures_rates._market_data_timed', Mock()).return_value = df
with DataContext('2019-01-01', '2025-01-01'):
actual = tm_rates.swaption_vol_term(Currency("GBP", name="GBP"), tm.SwaptionTenorType.SWAP_MATURITY, '5y', 0)
expected = pd.Series([1, 2, 3], index=pd.to_datetime(['2019-02-01', '2019-07-01', '2020-01-01']))
assert_series_equal(expected, pd.Series(actual), check_names=False)
with DataContext('2019-01-01', '2025-01-01'):
actual = tm_rates.swaption_vol_term(Currency("GBP", name="GBP"), tm.SwaptionTenorType.OPTION_EXPIRY, '5y', 0)
expected = pd.Series([1, 2, 3], index=pd.to_datetime(['2020-01-01', '2021-01-01', '2021-12-31']))
assert_series_equal(expected, pd.Series(actual), check_names=False)
replace.restore()
def test_swaption_vol_smile2_returns_data():
replace = Replacer()
test_data = dict(strikeRelative=["ATM", "ATM+50", "ATM+100"],
swaptionVol=[1, 2, 3])
df = MarketDataResponseFrame(data=test_data, index=_index * 3)
replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock()).return_value = "GBP"
replace('gs_quant.timeseries.measures_rates._get_tdapi_rates_assets',
Mock(),
Mock()).return_value = ["MADWG3WHCKNE1DJA", "MAH6JK3TZJJGFQ65"]
replace('gs_quant.timeseries.measures_rates._range_from_pricing_date',
Mock(),
Mock()).return_value = [dt.date(2020, 1, 2),
dt.date(2020, 1, 2)]
replace('gs_quant.timeseries.measures_rates._market_data_timed',
Mock()).return_value = df
with DataContext('2019-01-01', '2025-01-01'):
actual = tm_rates.swaption_vol_smile(Currency("GBP", name="GBP"), '3m',
'10y')
assert_series_equal(pd.Series([1, 2, 3], index=[0.0, 50.0, 100.0]),
pd.Series(actual))
replace.restore()
def test_swaption_premium_return_data():
replace = Replacer()
test_data = dict(swaptionPremium=[1, 2, 3])
df = MarketDataResponseFrame(
data=test_data,
index=[dt.date(2019, 1, 1),
dt.date(2019, 1, 2),
dt.date(2019, 1, 3)])
replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock()).return_value = "GBP"
replace('gs_quant.timeseries.measures_rates._get_tdapi_rates_assets',
Mock(), Mock()).return_value = "MADWG3WHCKNE1DJA"
replace('gs_quant.timeseries.measures_rates._range_from_pricing_date',
Mock(),
Mock()).return_value = [dt.date(2019, 1, 2),
dt.date(2019, 1, 5)]
replace('gs_quant.timeseries.measures_rates._market_data_timed',
Mock()).return_value = df
actual = tm_rates.swaption_premium(Currency("GBP", name="GBP"))
assert_series_equal(
tm._extract_series_from_df(df, QueryType.SWAPTION_PREMIUM), actual)
replace.restore()
def test_ois_fxfwd_xcswap_measures(mocker):
replace = Replacer()
dict_fns = {
"oisXccy": {
"fn": tm_rates.ois_xccy,
"queryType": QueryType.OIS_XCCY
},
"oisXccyExSpike": {
"fn": tm_rates.ois_xccy_ex_spike,
"queryType": QueryType.OIS_XCCY_EX_SPIKE
},
"usdOis": {
"fn": tm_rates.usd_ois,
"queryType": QueryType.USD_OIS
},
"nonUsdOis": {
"fn": tm_rates.non_usd_ois,
"queryType": QueryType.NON_USD_OIS
},
}
args = dict(tenor='3y', real_time=False)
for key in dict_fns:
fn = dict_fns[key]["fn"]
mock_jpy = Cross('MAYJPCVVF2RWXCES', 'USD/JPY')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'JPYUSD'
args['asset'] = mock_jpy
with pytest.raises(NotImplementedError):
fn(**args)
mock_eur = Cross('MAA0NE9QX2ABETG6', 'EUR/USD')
args['asset'] = mock_eur
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'EURUSD'
with pytest.raises(NotImplementedError):
fn(..., real_time=True)
args['tenor'] = '5yr'
with pytest.raises(MqValueError):
fn(**args)
args['tenor'] = '3y'
test_data = {key: [1, 2, 3]}
df = MarketDataResponseFrame(data=test_data,
index=[
dt.date(2019, 1, 1),
dt.date(2019, 1, 2),
dt.date(2019, 1, 3)
])
identifiers = replace(
'gs_quant.timeseries.measures_rates._get_tdapi_rates_assets',
Mock())
identifiers.return_value = {'MAA9MVX15AJNQCVG'} # Test on EURUSD only
replace('gs_quant.timeseries.measures_rates._range_from_pricing_date',
Mock(), Mock()).return_value = [
dt.date(2019, 1, 2),
dt.date(2019, 1, 5)
]
replace('gs_quant.timeseries.measures_rates._market_data_timed',
Mock()).return_value = df
expected = tm_rates._extract_series_from_df(df,
dict_fns[key]["queryType"])
actual = fn(**args)
assert_series_equal(expected, actual)
replace.restore()
def test_currency_to_tdapi_swaption_rate_asset_retuns_throws():
replace = Replacer()
replace('gs_quant.timeseries.measures.Asset.get_identifier', Mock()).return_value = "ZAR"
asset = Currency("MA1", "ZAR")
assert _currency_to_tdapi_swaption_rate_asset(asset) == "MA1"
def test_inflation_swap_term(mocker):
replace = Replacer()
args = dict(forward_tenor='1y',
pricing_date='0d',
clearing_house=_ClearingHouse.LCH,
real_time=False)
class ObjectView(object):
def __init__(self, d):
self.__dict__ = d
holidays = replace('gs_quant.datetime.GsCalendar.get', Mock(holidays=[]))
holidays.return_value = ObjectView({'holidays': []})
bd_calendar = replace(
'gs_quant.timeseries.measures_inflation._get_custom_bd', Mock())
bd_calendar.return_value = CustomBusinessDay()
pricing_date_mock = replace(
'gs_quant.timeseries.measures_inflation._range_from_pricing_date',
Mock())
pricing_date_mock.return_value = [dt.date(2019, 1, 1), dt.date(2019, 1, 1)]
mock_nok = Currency('MA891', 'PLN')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'ACU'
args['asset'] = mock_nok
with pytest.raises(NotImplementedError):
tm.inflation_swap_term(**args)
mock_usd = Currency('MAZ7RWC904JYHYPS', 'USD')
args['asset'] = mock_usd
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'USD'
args['real_time'] = True
with pytest.raises(NotImplementedError):
tm.inflation_swap_term(**args)
args['real_time'] = False
args['forward_tenor'] = '5yr'
with pytest.raises(MqValueError):
tm.inflation_swap_term(**args)
args['forward_tenor'] = '1y'
bd_mock = replace('gs_quant.data.dataset.Dataset.get_data', Mock())
bd_mock.return_value = pd.DataFrame(data=dict(date="2020-04-10",
exchange="NYC",
description="Good Friday"),
index=[pd.Timestamp('2020-04-10')])
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'USD'
identifiers_empty = replace(
'gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
identifiers_empty.return_value = {}
with pytest.raises(MqValueError):
tm.inflation_swap_term(**args)
identifiers = replace(
'gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
mock_asset = Currency('USD', name='USD')
mock_asset.id = 'MAEMPCXQG3T716EX'
mock_asset.exchange = 'OTC'
identifiers.return_value = [mock_asset]
d = {
'terminationTenor': ['1y', '2y', '3y', '4y'],
'swapRate': [1, 2, 3, 4],
'assetId': [
'MAEMPCXQG3T716EX', 'MAFRSWPAF5QPNTP2', 'MA88BXZ3TCTXTFW1',
'MAC4KAG9B9ZAZHFT'
]
}
bd_mock.return_value = pd.DataFrame()
market_data_mock = replace(
'gs_quant.timeseries.measures_inflation._get_inflation_swap_data',
Mock())
market_data_mock.return_value = pd.DataFrame()
df = pd.DataFrame(data=d, index=_index * 4)
actual = tm.inflation_swap_term(**args)
assert actual.empty
series_apply_mock = replace(
'gs_quant.timeseries.measures_inflation.pd.Series.apply', Mock())
series_apply_mock.return_value = pd.Series([
dt.date(2022, 3, 30),
dt.date(2023, 3, 30),
dt.date(2024, 3, 30),
dt.date(2025, 3, 30)
],
index=df.index)
market_data_mock.return_value = df
with DataContext('2019-01-01', '2026-01-01'):
actual = tm.inflation_swap_term(**args)
actual.dataset_ids = _test_datasets
expected = tm.ExtendedSeries([1, 2, 3, 4],
index=[
dt.date(2022, 3, 30),
dt.date(2023, 3, 30),
dt.date(2024, 3, 30),
dt.date(2025, 3, 30)
])
expected.dataset_ids = _test_datasets
assert_series_equal(expected, actual, check_names=False)
assert actual.dataset_ids == expected.dataset_ids
args['location'] = PricingLocation.NYC
with DataContext('2019-01-01', '2026-01-01'):
tm.inflation_swap_term(**args)
holidays.return_value = ObjectView({'holidays': ['0d']})
with pytest.raises(MqValueError):
tm.inflation_swap_term(**args)
replace.restore()
def test_bucketize_price():
target = {
'7x24': [27.323461],
'offpeak': [26.004816],
'peak': [27.982783],
'7x8': [26.004816],
'2x16h': [],
'monthly': [],
'CAISO 7x24': [26.518563]
}
replace = Replacer()
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data',
mock_commod)
mock_pjm = Index('MA001', AssetClass.Commod, 'PJM')
mock_caiso = Index('MA001', AssetClass.Commod, 'CAISO')
mock_miso = Index('MA001', AssetClass.Commod, 'MISO')
with DataContext(datetime.date(2019, 5, 1), datetime.date(2019, 5, 1)):
bbid_mock = replace(
'gs_quant.timeseries.measures.Asset.get_identifier', Mock())
bbid_mock.return_value = 'CAISO'
actual = tm.bucketize_price(mock_caiso,
'LMP',
'totalPrice',
bucket='7x24')
assert_series_equal(
pd.Series(target['CAISO 7x24'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
bbid_mock.return_value = 'PJM'
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='7x24')
assert_series_equal(
pd.Series(target['7x24'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='offpeak')
assert_series_equal(
pd.Series(target['offpeak'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='peak')
assert_series_equal(
pd.Series(target['peak'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='7x8')
assert_series_equal(
pd.Series(target['7x8'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='2x16h')
assert_series_equal(pd.Series(target['2x16h'], index=[], name='price'),
actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
granularity='m',
bucket='7X24')
assert_series_equal(
pd.Series(target['monthly'], index=[], name='price'), actual)
with pytest.raises(ValueError):
tm.bucketize_price(mock_pjm, 'LMP', 'totalPrice', bucket='weekday')
with pytest.raises(ValueError):
tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
granularity='yearly')
replace.restore()
def test_fx_vol_measure_legacy(mocker):
replace = Replacer()
args = dict(tenor='1m', strike_reference=tm_fxo.VolReference('delta_neutral'), relative_strike=0,
location=None, legacy_implementation=True)
mock_gbp = Cross('MA26QSMPX9990G66', 'GBPUSD')
args['asset'] = mock_gbp
expected = tm.ExtendedSeries([1, 2, 3], index=_index * 3, name='impliedVolatility')
expected.dataset_ids = _test_datasets
mocker.patch.object(tm_rates, 'implied_volatility',
return_value=expected)
actual = tm_fxo.implied_volatility_fxvol(**args)
assert_series_equal(expected, actual)
replace.restore()
args['legacy_implementation'] = False
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier', Mock())
xrefs.return_value = None
with pytest.raises(MqValueError):
tm_fxo.implied_volatility_fxvol(**args)
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier', Mock())
xrefs.return_value = 'GBPUSD'
xrefs = replace('gs_quant.timeseries.measures._cross_stored_direction_helper', Mock())
xrefs.return_value = 'GBPUSD'
mocker.patch.object(tm_fxo, 'implied_volatility_new',
return_value=expected)
actual = tm_fxo.implied_volatility_fxvol(**args)
assert_series_equal(expected, actual)
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier', Mock())
xrefs.return_value = 'USDUSD'
xrefs = replace('gs_quant.timeseries.measures_fx_vol._cross_stored_direction_helper', Mock())
xrefs.return_value = 'GBPUSD'
assets = replace('gs_quant.markets.securities.SecurityMaster.get_asset', Mock())
assets.return_value = mock_gbp
actual = tm_fxo.implied_volatility_fxvol(**args)
assert_series_equal(expected, actual)
args['strike_reference'] = tm_fxo.VolReference('delta_call')
args['relative_strike'] = 25
actual = tm_fxo.implied_volatility_fxvol(**args)
assert_series_equal(expected, actual)
args['strike_reference'] = tm_fxo.VolReference('delta_put')
args['relative_strike'] = 25
actual = tm_fxo.implied_volatility_fxvol(**args)
assert_series_equal(expected, actual)
args['strike_reference'] = tm_fxo.VolReference('spot')
args['relative_strike'] = 100
actual = tm_fxo.implied_volatility_fxvol(**args)
assert_series_equal(expected, actual)
args['strike_reference'] = tm_fxo.VolReference('forward')
args['relative_strike'] = 100
actual = tm_fxo.implied_volatility_fxvol(**args)
assert_series_equal(expected, actual)
args['strike_reference'] = tm_fxo.VolReference('normalized')
args['relative_strike'] = 100
xrefs = replace('gs_quant.timeseries.measures_fx_vol._preprocess_implied_vol_strikes_fx', Mock())
xrefs.return_value = ['normalized', 0]
with pytest.raises(MqValueError):
tm_fxo.implied_volatility_fxvol(**args)
replace.restore()
def test_mock_call_same_strict(self):
m = Mock()
m.foo(1, 2, x=3)
compare(m.mock_calls, m.mock_calls, strict=True)
def test_factor_zscore():
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
# mock getting risk model factor entity
mock = replace(
'gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_data',
Mock())
mock.return_value = mock_risk_model_data
# mock getting risk model factor entity
mock = replace(
'gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_factor_data',
Mock())
mock.return_value = mock_risk_model_factor_data
# mock getting asset gsid
mock = replace('gs_quant.markets.securities.Asset.get_identifier', Mock())
mock.return_value = '12345'
# mock getting risk model dates
mock = replace(
'gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model_dates',
Mock())
mock.return_value = ['2020-01-01', '2020-01-02', '2020-01-03']
# mock getting risk model data
mock = replace('gs_quant.models.risk_model.FactorRiskModel.get_data',
Mock())
mock.return_value = {
'results': [{
'date': '2020-01-01',
'assetData': {
'factorExposure': [{
'factor_id': 1.01,
'factor_id_1': 1.23
}]
}
}, {
'date': '2020-01-02',
'assetData': {
'factorExposure': [{
'factor_id': 1.02,
'factor_id_1': 1.23
}]
}
}, {
'date': '2020-01-03',
'assetData': {
'factorExposure': [{
'factor_id': 1.03,
'factor_id_1': 1.23
}]
}
}]
}
with DataContext(datetime.date(2020, 1, 1), datetime.date(2020, 1, 3)):
actual = mrm.factor_zscore(Stock(id_='id', name='Fake Asset'),
'model_id', 'Factor Name')
assert all(actual.values == [1.01, 1.02, 1.03])
with pytest.raises(MqValueError):
mrm.factor_zscore(Stock(id_='id', name='Fake Asset'), 'model_id',
'Wrong Factor Name')
replace.restore()
def test_aggregate_factor_support():
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_factor_risk_report_results',
Mock())
mock.return_value = aggregate_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')
assert all(actual.values == [1, 2, 3])
with DataContext(datetime.date(2020, 11, 23), datetime.date(2020, 11, 25)):
actual = mr.daily_risk('report_id', 'Factor')
assert all(actual.values == [1, 2, 3])
with DataContext(datetime.date(2020, 11, 23), datetime.date(2020, 11, 25)):
actual = mr.annual_risk('report_id', 'Factor')
assert all(actual.values == [1, 2, 3])
with pytest.raises(MqValueError):
mr.daily_risk('report_id', 'Factor Name')
with pytest.raises(MqValueError):
mr.annual_risk('report_id', 'Factor Name')
replace.restore()
def test_basket_average_realized_corr():
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)
])
mock_data = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.side_effect = [
_mock_spot_data_identical(),
_mock_spot_data_corr(),
_mock_spot_data_identical()
]
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'
}, {
'id': 'ID of a dUpLiCaTe AAPL',
'bbid': 'AAPL UW'
}]
a_basket = Basket(['AAPL UW', 'MSFT UW'], [0.1, 0.9], RebalFreq.DAILY)
# Equal series have correlation of 1
with DataContext('2021-01-01', '2021-01-06'):
expected = pd.Series([np.nan, np.nan, 1.0, 1.0, 1.0, 1.0], index=dates)
result = a_basket.average_realized_correlation('2d')
assert_series_equal(result, expected)
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'
}, {
'id': 'MA4B66MW5E27UANZH2M',
'bbid': 'XLP UP'
}, {
'id': 'ID of a dUpLiCaTe XLP UP',
'bbid': 'XLP UP'
}]
b_basket = Basket(['AAPL UW', 'MSFT UW', 'XLP UP'], [0.2, 0.3, 0.5],
RebalFreq.DAILY)
# Test with two different series
with DataContext('2021-01-01', '2021-01-06'):
result = b_basket.average_realized_correlation('5d')
expected = pd.Series(
[np.nan, np.nan, np.nan, np.nan, np.nan, 0.26872959922887607],
index=dates)
assert_series_equal(result, expected)
# Test correct error being thrown
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'
}, {
'id': 'MA4B66MW5E27UANZH2M',
'bbid': 'XLP UP'
}, {
'id': 'ID of a DuPlIcAtE MSFT UW',
'bbid': 'MSFT UW'
}]
with pytest.raises(NotImplementedError):
with DataContext('2021-01-01', '2021-01-09'):
result = b_basket.average_realized_correlation('5d',
real_time=True)
replace.restore()
def test_inflation_swap_rate(mocker):
replace = Replacer()
args = dict(swap_tenor='5y',
index_type='UKRPI',
clearing_house='LCH',
forward_tenor='5y',
real_time=False)
mock_gbp = Currency('MA26QSMPX9990G66', 'GBP')
args['asset'] = mock_gbp
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'GBP'
args['swap_tenor'] = '5yr'
with pytest.raises(MqValueError):
tm.inflation_swap_rate(**args)
args['swap_tenor'] = '5y'
args['forward_tenor'] = '5yr'
with pytest.raises(MqValueError):
tm.inflation_swap_rate(**args)
args['forward_tenor'] = '5y'
args['real_time'] = True
with pytest.raises(NotImplementedError):
tm.inflation_swap_rate(**args)
args['real_time'] = False
args['asset'] = Currency('MA666', 'AED')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'AED'
with pytest.raises(NotImplementedError):
tm.inflation_swap_rate(**args)
args['asset'] = mock_gbp
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'GBP'
args['index_type'] = tm.InflationIndexType.TESTCPI
with pytest.raises(MqValueError):
tm.inflation_swap_rate(**args)
args['index_type'] = tm.InflationIndexType.UKRPI
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'GBP'
identifiers = replace(
'gs_quant.timeseries.measures_inflation._get_tdapi_inflation_rates_assets',
Mock())
identifiers.return_value = {'MA26QSMPX9990G66'}
mocker.patch.object(GsDataApi,
'get_market_data',
return_value=mock_curr(None, None))
actual = tm.inflation_swap_rate(**args)
expected = tm.ExtendedSeries([1, 2, 3], index=_index * 3, name='swapRate')
expected.dataset_ids = _test_datasets
assert_series_equal(expected, actual)
assert actual.dataset_ids == _test_datasets
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'EUR'
identifiers = replace(
'gs_quant.timeseries.measures_inflation._get_tdapi_inflation_rates_assets',
Mock())
identifiers.return_value = {'MAZBW57ZPS54ET7K'}
mocker.patch.object(GsDataApi,
'get_market_data',
return_value=mock_curr(None, None))
args['asset'] = Currency('MAZBW57ZPS54ET7K', 'EUR')
args['index_type'] = 'FRCPXTOB'
actual = tm.inflation_swap_rate(**args)
expected = tm.ExtendedSeries([1, 2, 3], index=_index * 3, name='swapRate')
expected.dataset_ids = _test_datasets
assert_series_equal(expected, actual)
assert actual.dataset_ids == _test_datasets
replace.restore()
def test_fx_vol_measure(mocker):
replace = Replacer()
args = dict(
expiry_tenor='1m',
strike='ATMF',
option_type='Put',
expiration_location=None,
location=None,
premium_payment_date=None,
)
mock_gbp = Cross('MA26QSMPX9990G66', 'GBPUSD')
args['asset'] = mock_gbp
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'GBPUSD'
args['expiry_tenor'] = '1yr'
with pytest.raises(MqValueError):
tm_fxo.implied_volatility_new(**args)
args['expiry_tenor'] = '1m'
args['real_time'] = True
with pytest.raises(NotImplementedError):
tm_fxo.implied_volatility_new(**args)
args['real_time'] = False
args['asset'] = Cross('MA666', 'USDAED')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'AEDUSD'
with pytest.raises(NotImplementedError):
tm_fxo.implied_volatility_new(**args)
args['asset'] = mock_gbp
args['asset'] = Bond('MA667', 'TEST')
with pytest.raises(NotImplementedError):
tm_fxo.implied_volatility_new(**args)
args['asset'] = mock_gbp
args['asset'] = Cross('MA667', 'GBPUSD')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'GBPUSD'
identifiers = replace(
'gs_quant.timeseries.measures_fx_vol._get_tdapi_fxo_assets', Mock())
identifiers.return_value = {'MA7F5P92330NGKAR'}
mocker.patch.object(GsDataApi,
'get_market_data',
return_value=mock_curr(None, None))
actual = tm_fxo.implied_volatility_new(**args)
expected = tm.ExtendedSeries([1, 2, 3],
index=_index * 3,
name='impliedVolatility')
expected.dataset_ids = _test_datasets
assert_series_equal(expected, actual)
assert actual.dataset_ids == _test_datasets
args['asset'] = Cross('MA667', 'USDCAD')
args['location'] = PricingLocation.LDN
args['premium_payment_date'] = 'Fwd Settle'
args['expiration_location'] = 'NYC'
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'USDCAD'
identifiers = replace(
'gs_quant.timeseries.measures_fx_vol._get_tdapi_fxo_assets', Mock())
identifiers.return_value = {'MA7F5P92330NGKAR'}
mocker.patch.object(GsDataApi,
'get_market_data',
return_value=mock_curr(None, None))
actual = tm_fxo.implied_volatility_new(**args)
expected = tm.ExtendedSeries([1, 2, 3],
index=_index * 3,
name='impliedVolatility')
expected.dataset_ids = _test_datasets
assert_series_equal(expected, actual)
assert actual.dataset_ids == _test_datasets
args['option_type'] = 'Call'
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'GBPUSD'
identifiers = replace(
'gs_quant.timeseries.measures_fx_vol._get_tdapi_fxo_assets', Mock())
identifiers.return_value = {'MA7F5P92330NGKAR'}
mocker.patch.object(GsDataApi,
'get_market_data',
return_value=mock_curr(None, None))
actual = tm_fxo.implied_volatility_new(**args)
expected = tm.ExtendedSeries([1, 2, 3],
index=_index * 3,
name='impliedVolatility')
expected.dataset_ids = _test_datasets
assert_series_equal(expected, actual)
assert actual.dataset_ids == _test_datasets
replace.restore()
def test_get_tdapi_fxo_assets(mocker):
mock_asset_1 = GsAsset(asset_class='FX',
id='MAW8SAXPSKYA94E2',
type_='Option',
name='Test_asset')
mock_asset_2 = GsAsset(asset_class='FX',
id='MATDD783JM1C2GGD',
type_='Option',
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_fxo._get_tdapi_fxo_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_expiration_date='5y',
asset_parameters_call_currency='USD',
asset_parameters_put_currency='EUR')
with pytest.raises(MqValueError):
tm_fxo._get_tdapi_fxo_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets',
Mock())
assets.return_value = []
kwargs = dict(asset_parameters_expiration_date='5y',
asset_parameters_call_currency='USD',
asset_parameters_put_currency='EUR')
with pytest.raises(MqValueError):
tm_fxo._get_tdapi_fxo_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(Asset_class='FX',
type='Option',
asset_parameters_call_currency='USD',
asset_parameters_put_currency='EUR',
asset_parameters_expiration_date='1m',
asset_parameters_expiration_time='NYC',
asset_parameters_option_type='Put',
asset_parameters_premium_payment_date='Fwd Settle',
asset_parameters_strike_price_relative='10d',
pricing_location='NYC')
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets',
Mock())
assets.return_value = [mock_asset_1]
assert 'MAW8SAXPSKYA94E2' == tm_fxo._get_tdapi_fxo_assets(**kwargs)
replace.restore()
def test_normalized_performance():
idx = pd.date_range('2020-01-02', freq='D', periods=3)
expected = {
RiskAumSource.Net:
pd.Series(data=[1, 1 / 0.8, 1 / 0.6],
index=idx,
name='normalizedPerformance',
dtype='float64'),
RiskAumSource.Gross:
pd.Series(data=[1, 1.2, 1.4],
index=idx,
name='normalizedPerformance',
dtype='float64'),
RiskAumSource.Long:
pd.Series(data=[1, 1.2, 1.4],
index=idx,
name='normalizedPerformance',
dtype='float64'),
RiskAumSource.Short:
pd.Series(data=[1, 1 / 0.8, 1 / 0.6],
index=idx,
name='normalizedPerformance',
dtype='float64'),
RiskAumSource.Custom_AUM:
pd.Series(data=[1, 1.1, 1.2],
index=idx,
name='normalizedPerformance',
dtype='float64')
}
with DataContext(datetime.date(2020, 1, 1), datetime.date(2019, 1, 3)):
for k, v in expected.items():
df = MarketDataResponseFrame(data=ppa_data, dtype="float64")
replace = Replacer()
# mock GsPortfolioApi.get_reports()
mock = replace(
'gs_quant.api.gs.portfolios.GsPortfolioApi.get_reports',
Mock())
mock.return_value = [
Report.from_dict({
'id': 'RP1',
'positionSourceType': 'Portfolio',
'positionSourceId': 'MP1',
'type': 'Portfolio Performance Analytics',
'parameters': {
'transactionCostModel': 'FIXED'
}
})
]
# mock PerformanceReport.get_many_measures()
mock = replace(
'gs_quant.markets.report.PerformanceReport.get_many_measures',
Mock())
mock.return_value = df
# mock PerformanceReport.get_custom_aum()
mock = replace(
'gs_quant.api.gs.portfolios.GsPortfolioApi.get_custom_aum',
Mock())
mock.return_value = aum
# mock PerformanceReport.get()
mock = replace('gs_quant.markets.report.PerformanceReport.get',
Mock())
mock.return_value = PerformanceReport(
report_id='RP1',
position_source_type='Portfolio',
position_source_id='MP1',
report_type='Portfolio Performance Analytics',
parameters=ReportParameters(transaction_cost_model='FIXED'))
actual = mr.normalized_performance('MP1', k.value)
assert all(actual.values == v.values)
replace.restore()
def test_two_elements(self):
m = Mock()
m(x=1)
assert m.call_args == ((), {'x': 1})
def test_mock_call_same(self):
m = Mock()
m.foo(1, 2, x=3)
compare(m.mock_calls, m.mock_calls)
def test_non_root_params_not_equal(self):
m = Mock()
m.foo(x=1).bar()
# surprising and annoying (and practically unsolvable :-/):
assert m.mock_calls[-1] == call.foo(y=2).bar()
