wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/tests/analysis/financial_analysis/test_utils.py

@@ -0,0 +1,322 @@
+import random
+from datetime import date
+from unittest.mock import patch
+
+import numpy as np
+import pandas as pd
+import pytest
+from faker import Faker
+from wbfdm.analysis.financial_analysis.utils import FinancialAnalysisResult, Loader
+from wbfdm.dataloaders.proxies import InstrumentDataloaderProxy
+from wbfdm.enums import Financial, MarketData
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestLoader:
+    @pytest.fixture
+    def data(self, value, year):
+        """
+        Data Fixture for the Loader class
+        """
+        year = int(year)
+        data = []
+        fake_key = fake.word()
+        for year_delta in [0, 1]:
+            for interim in range(1, 5):
+                data.append(
+                    {
+                        "year": year + year_delta,
+                        "interim": interim,
+                        "period_type": "Q",
+                        "period_end_date": date(year, interim * 3, 1),
+                        "estimate": fake.pybool(),
+                        "source": "dsws",
+                        "financial": value,
+                        "value": fake.pyfloat(),
+                        fake_key: fake.word(),  # add noise key
+                    }
+                )
+        # add a uncomplete year for year - 2
+        data.append(
+            {
+                "year": year - 1,
+                "interim": 1,
+                "period_type": "Q",
+                "period_end_date": date(year, 3, 1),
+                "estimate": fake.pybool(),
+                "source": "dsws",
+                "financial": value,
+                "value": fake.pyfloat(),
+                fake_key: fake.word(),  # add noise key
+            }
+        )
+        return data
+
+    @pytest.fixture()
+    def loader(self, instrument, value):
+        return Loader(instrument, [Financial(value)])
+
+    @pytest.mark.parametrize("value, year", [(random.choice(Financial.values()), fake.year())])
+    @patch.object(InstrumentDataloaderProxy, "financials")
+    def test_load(self, mock_fct, value, year, data, loader):
+        # Test that the load method returnn the normalized dataframe
+
+        mock_fct.return_value = data
+        pd.testing.assert_frame_equal(loader.load(), loader._normalize_df(*loader._get_base_df()), check_exact=True)
+
+    @pytest.mark.parametrize("value, year", [(random.choice(Financial.values()), fake.year())])
+    @patch.object(InstrumentDataloaderProxy, "financials")
+    def test_load_no_data(self, mock_fct, value, year, data, loader):
+        # Test that the load method returnn the normalized dataframe
+
+        mock_fct.return_value = []
+        assert loader.load().empty
+
+    @pytest.mark.parametrize("value, year", [(random.choice(Financial.values()), fake.year())])
+    @patch.object(InstrumentDataloaderProxy, "financials")
+    def test__get_base_df(self, mock_fct, value, year, data, loader):
+        year = int(year)
+        mock_fct.return_value = data
+        df, source_df = loader._get_base_df()
+        time_idx = df.index.droplevel([3, 4])
+        # Test if the _get_base_df private method returned tuple have the same index
+        pd.testing.assert_index_equal(time_idx, source_df.index)
+
+        # Test if the _get_base_df private method returned dataframe index corresponds to the expected year and interim
+        assert time_idx.tolist() == [
+            (year - 1, 1, "Q"),
+            (year, 1, "Q"),
+            (year, 2, "Q"),
+            (year, 3, "Q"),
+            (year, 4, "Q"),
+            (year + 1, 1, "Q"),
+            (year + 1, 2, "Q"),
+            (year + 1, 3, "Q"),
+            (year + 1, 4, "Q"),
+        ]
+        assert source_df.unique() == "dsws"
+        assert df.columns == [value]
+
+    @pytest.mark.parametrize("market_value", [random.choice(MarketData.values())])
+    @patch.object(InstrumentDataloaderProxy, "market_data")
+    def test__annotate_market_data(self, mock_fct, instrument, market_value):
+        # test if annotation market data works and are merged properly to the initial dataframe
+        d1 = date(2021, 3, 30)
+        d2 = date(2023, 3, 31)
+        p1 = fake.pyfloat()
+        p2 = fake.pyfloat()
+
+        df = pd.DataFrame(
+            [
+                {
+                    "year": d1.year,
+                    "estimate": False,
+                    "interim": 1,
+                    "period_type": "P",
+                    "period_end_date": d1,
+                    "financial": "financial",
+                    "value": fake.pyfloat(),
+                },
+                {
+                    "year": d2.year,
+                    "estimate": False,
+                    "interim": 1,
+                    "period_type": "P",
+                    "period_end_date": d2,
+                    "financial": "financial",
+                    "value": fake.pyfloat(),
+                },
+            ]
+        )
+        df["period_end_date"] = pd.to_datetime(df["period_end_date"])
+        df = df.pivot_table(
+            index=["year", "interim", "period_type", "estimate", "period_end_date"],
+            columns="financial",
+            values="value",
+        )
+        mock_fct.return_value = [{"valuation_date": d1, market_value: p1}, {"valuation_date": d2, market_value: p2}]
+        res = Loader(instrument, [])._annotate_market_data(df, [MarketData(market_value)])
+        assert res.loc[(d1.year, 1, "P", False, "2021-03-30"), market_value] == p1
+        assert res.loc[(d2.year, 1, "P", False, "2023-03-31"), market_value] == p2
+
+    @pytest.mark.parametrize("statement_value", [random.choice(Financial.values())])
+    @patch.object(InstrumentDataloaderProxy, "statements")
+    def test__annotate_statement_data(self, mock_fct, instrument, statement_value):
+        # test if annotation statement works and are merged properly to the initial dataframe
+
+        d1 = date(2021, 3, 30)
+        d2 = date(2023, 3, 31)
+        value = fake.pyfloat()
+
+        df = pd.DataFrame(
+            [
+                {
+                    "year": d1.year,
+                    "estimate": False,
+                    "interim": 1,
+                    "period_type": "P",
+                    "period_end_date": d1,
+                    "financial": "base",
+                    "value": fake.pyfloat(),
+                },
+                {
+                    "year": d2.year,
+                    "estimate": False,
+                    "interim": 1,
+                    "period_type": "P",
+                    "period_end_date": d2,
+                    "financial": "base",
+                    "value": fake.pyfloat(),
+                },
+            ]
+        )
+        df["period_end_date"] = pd.to_datetime(df["period_end_date"])
+        df = df.pivot_table(
+            index=["year", "interim", "period_type", "estimate", "period_end_date"],
+            columns="financial",
+            values="value",
+        )
+        mock_fct.return_value = [
+            {
+                "year": d1.year,
+                "estimate": False,
+                "interim": 1,
+                "period_type": "P",
+                "period_end_date": d1,
+                "financial": statement_value,
+                "value": value,
+            }
+        ]
+
+        res = Loader(instrument, [])._annotate_statement_data(df, [Financial(statement_value)])
+        assert res.loc[(d1.year, 1, "P", False, "2021-03-30"), statement_value] == value
+        assert np.isnan(res.loc[(d2.year, 1, "P", False, "2023-03-31"), statement_value])
+
+    def test__normalize_df(self, instrument):
+        d1 = date(2021, 3, 30)
+        df = pd.DataFrame(
+            [
+                {
+                    "source": "dsws",
+                    "year": d1.year,
+                    "estimate": False,
+                    "interim": 1,
+                    "period_end_date": d1,
+                    "period_type": "S",
+                    "financial": "base",
+                    "value": fake.pyfloat(),
+                },
+                {
+                    "source": "dsws",
+                    "year": d1.year,
+                    "estimate": False,
+                    "interim": 2,
+                    "period_end_date": d1,
+                    "period_type": "S",
+                    "financial": "base",
+                    "value": fake.pyfloat(),
+                },
+            ]
+        )
+        source_df = df.source
+        df["period_end_date"] = pd.to_datetime(df["period_end_date"])
+        df = df.pivot_table(
+            index=["year", "interim", "period_type", "estimate", "period_end_date"],
+            columns="financial",
+            values="value",
+        )
+        res = Loader(instrument, [])._normalize_df(df, source_df)
+        # Test if normalize appends the missing "yearly" row and convert the interim into their verbose representation
+        assert res.index.tolist() == [
+            (d1.year, "Y"),
+            (d1.year, "S1"),
+            (d1.year, "S2"),
+        ]  # We test that the missing yearly row is reindexed
+        assert np.isnan(res.loc[(d1.year, "Y"), "base"])  # check that the extrapolated data is nan
+
+    def test__normalize_df_with_duplicates(self, instrument):
+        # we test if normalize detects the duplicates, remove it by taking the first and add the interim into the errors list
+        d1 = date(2021, 3, 30)
+        v1 = fake.pyfloat()
+        v2 = fake.pyfloat()
+        df = pd.DataFrame(
+            [
+                {
+                    "source": "dsws",
+                    "year": d1.year,
+                    "estimate": False,
+                    "interim": 1,
+                    "period_end_date": d1,
+                    "financial": "base",
+                    "period_type": "P",
+                    "value": v1,
+                },
+                {
+                    "source": "dsws",
+                    "year": d1.year,
+                    "estimate": False,
+                    "interim": 1,
+                    "period_end_date": date(2021, 1, 30),
+                    "financial": "base",
+                    "period_type": "P",
+                    "value": v2,
+                },
+            ]
+        )
+        source_df = df[["year", "interim", "source"]].groupby(["year", "interim"]).first().source
+        df["period_end_date"] = pd.to_datetime(df["period_end_date"])
+        df = df.pivot_table(
+            index=["year", "interim", "period_type", "estimate", "period_end_date"],
+            columns="financial",
+            values="value",
+        )
+        loader = Loader(instrument, [])
+        res = loader._normalize_df(df, source_df)
+        assert res.index.tolist() == [(d1.year, "Y"), (d1.year, "P1")]
+        assert (
+            res.loc[(d1.year, "P1"), "base"] == v2
+        )  # check that the retained value is the first one (with ordered index)
+        assert loader.errors["duplicated_interims"] == [f"{d1.year} Interim P1"]
+
+
+class TestFinancialAnalysisResult:
+    @pytest.fixture()
+    def df(self, year, value):
+        df = pd.DataFrame(
+            [
+                {
+                    "year": year,
+                    "estimate": False,
+                    "interim": "P1",
+                    "period_end_date": date(int(year), 3, 1),
+                    "financial": value,
+                    "value": fake.pyfloat(),
+                },
+                {
+                    "year": year,
+                    "estimate": True,
+                    "interim": "Y",
+                    "period_end_date": date(int(year), 3, 1),
+                    "financial": value,
+                    "value": fake.pyfloat(),
+                },
+            ]
+        )
+        df = df.pivot_table(
+            index=["year", "interim", "estimate", "period_end_date"], columns="financial", values="value"
+        )
+        return df.reset_index(level=[2, 3])
+
+    @pytest.mark.parametrize("value, year", [(random.choice(Financial.values()), fake.year())])
+    def test_class(self, value, year, df):
+        """
+        Test the basic esthetic transform (Transposing + group key addition + convertion of multi index to representation
+        """
+        res = FinancialAnalysisResult(df)
+        assert res.formatted_df.loc[0, f"{year}-P1"] == df.loc[(year, "P1"), value]
+        assert res.formatted_df.loc[0, f"{year}-Y"] == df.loc[(year, "Y"), value]
+        assert res.formatted_df.loc[0, "financial"] == Financial.name_mapping()[value]
+        assert res.formatted_df.loc[0, "_group_key"] == value
+        assert res.estimated_mapping == {f"{year}-P1": False, f"{year}-Y": True}

wbfdm/tests/analysis/test_esg.py

@@ -0,0 +1,159 @@
+import numpy as np
+import pandas as pd
+import pytest
+from faker import Faker
+from wbcore.contrib.currency.factories import CurrencyFXRatesFactory
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbfdm.analysis.esg.enums import ESGAggregation
+from wbfdm.analysis.esg.esg_analysis import DataLoader
+
+fake = Faker()
+
+WEIGHTS = [0.15, 0.05, 0.2, 0.1, 0.5]
+ENTERPRISE_VALUE_INCLUDED_CASH = [1e6, 2e6, 3e6, 4e6, 1e6]
+CURRENT_VALUE_INVESTMENT_FACTOR = [1.0, 1.0, 1.0, 1.2, 0.2]
+
+
+@pytest.mark.django_db
+class TestESGDataLoader:
+    @pytest.fixture
+    def dataloader(self, weekday):
+        index = [1, 2, 3, 4, 5]
+
+        weight = pd.Series(WEIGHTS, index=index)
+        esg_data = pd.Series(np.random.randint(1, 100, size=4), index=[1, 2, 3, 4])  # we remove one data point
+        total_value_fx_usd = pd.Series(np.random.randint(1, 100, size=5))  # we remove one data point
+        CurrencyFXRatesFactory.create(currency__key="EUR", date=weekday)
+
+        dataloader = DataLoader(weight, esg_data, weekday, total_value_fx_usd=total_value_fx_usd)
+        dataloader.__dict__["enterprise_value_included_cash"] = pd.Series(ENTERPRISE_VALUE_INCLUDED_CASH, index=index)
+        dataloader.__dict__["current_value_investment_factor"] = pd.Series(
+            CURRENT_VALUE_INVESTMENT_FACTOR, index=index
+        )
+        dataloader.__dict__["nace_section_code"] = pd.Series(["C", "C", "J", "M", "M"], index=index)
+        return dataloader
+
+    def test_dataloader(self, dataloader):
+        assert dataloader.weights_in_coverage.to_dict() == {1: 0.15, 2: 0.05, 3: 0.2, 4: 0.1}
+
+    def test_get_percentage_sum(self, dataloader):
+        dataloader.esg_data = pd.Series(["Yes", "No Evidence", "No", "No", "No"], index=[1, 2, 3, 4, 5])
+        res = dataloader._get_percentage_sum("No Evidence")
+        assert res.tolist() == [0.0, 0.05, 0.0, 0.0]
+
+    def test_get_weighted_avg_normalized(self, dataloader):
+        res = dataloader._get_weighted_avg_normalized()
+        log = dataloader.intermediary_logs[0]
+
+        # ensure the intermediary log data is set properly
+        assert log.series.name == "weights_normalized"
+        assert log.series.to_dict() == {1: 0.3, 2: 0.1, 3: 0.4, 4: 0.2}
+        assert res.to_dict() == {
+            1: 0.3 * dataloader.esg_data.iloc[0],
+            2: 0.1 * dataloader.esg_data.iloc[1],
+            3: 0.4 * dataloader.esg_data.iloc[2],
+            4: 0.2 * dataloader.esg_data.iloc[3],
+        }
+
+    def test_get_weighted_avg_normalized_per_category(self, dataloader):
+        res = dataloader._get_weighted_avg_normalized_per_category()
+        intermediary_logs = list(filter(lambda x: not x.series.empty, dataloader.intermediary_logs))
+        log_c = intermediary_logs[0]
+        log_j = intermediary_logs[1]
+        log_m = intermediary_logs[2]
+        weights_normalized = [
+            0.15 / (0.15 + 0.05),
+            0.05 / (0.15 + 0.05),
+            0.2 / 0.2,
+            0.1 / (0.1 + 0.5),
+            0.5 / (0.1 + 0.5),
+        ]
+        # ensure the intermediary log data is set properly
+        assert log_c.series.name == "weights_normalized_sector_c"
+        assert log_c.series.to_dict() == {
+            1: weights_normalized[0],
+            2: weights_normalized[1],
+            # 3: weights_normalized[2],
+            # 4: weights_normalized[3],
+            #             5: weights_normalized[4],
+        }
+        assert log_j.series.name == "weights_normalized_sector_j"
+        assert log_j.series.to_dict() == {
+            3: weights_normalized[2],
+        }
+        assert log_m.series.name == "weights_normalized_sector_m"
+        assert log_m.series.to_dict() == {
+            4: weights_normalized[3],
+            5: weights_normalized[4],
+        }
+        assert res.to_dict() == {
+            1: weights_normalized[0] * dataloader.esg_data.iloc[0],
+            2: weights_normalized[1] * dataloader.esg_data.iloc[1],
+            3: weights_normalized[2] * dataloader.esg_data.iloc[2],
+            4: weights_normalized[3] * dataloader.esg_data.iloc[3],
+        }
+
+    def test_get_investor_allocation(self, dataloader):
+        exposure = pd.Series(np.random.rand(5), index=dataloader.weights.index)
+        res = dataloader._get_investor_allocation(exposure)
+        fx_rate = CurrencyFXRates.objects.get(currency__key="EUR", date=dataloader.val_date)
+        exposure_eur = exposure * float(fx_rate.value)
+
+        assert dataloader.intermediary_logs[0].series.to_dict() == exposure.to_dict()
+        assert (
+            dataloader.intermediary_logs[1].series.to_dict() == exposure_eur.to_dict()
+        )  # exposure converted into eur
+
+        exposure_with_cvi = [exposure_eur.iloc[i] * CURRENT_VALUE_INVESTMENT_FACTOR[i] for i in range(5)]
+        assert dataloader.intermediary_logs[2].series.tolist() == exposure_with_cvi
+
+        rebase_factor = sum(exposure_with_cvi[:4]) / sum(exposure_with_cvi)
+
+        exposure_normalized = [exposure_with_cvi[i] / rebase_factor for i in range(4)]
+        assert dataloader.intermediary_logs[3].series.tolist() == exposure_normalized
+
+        attribution_factor = [exposure_normalized[i] / ENTERPRISE_VALUE_INCLUDED_CASH[i] for i in range(4)]
+        assert dataloader.intermediary_logs[4].series.dropna().tolist() == attribution_factor
+
+        assert res.to_dict() == {
+            1: dataloader.esg_data.iloc[0] * attribution_factor[0],
+            2: dataloader.esg_data.iloc[1] * attribution_factor[1],
+            3: dataloader.esg_data.iloc[2] * attribution_factor[2],
+            4: dataloader.esg_data.iloc[3] * attribution_factor[3],
+        }
+
+    def test_compute_percentage_sum(self, dataloader):
+        pd.testing.assert_series_equal(
+            dataloader.compute(ESGAggregation.FOSSIL_FUEL_EXPOSURE),
+            dataloader._get_percentage_sum("Yes"),
+            check_exact=True,
+        )
+
+    def test_compute_weighted_avg_normalized(self, dataloader):
+        res = dataloader.compute(ESGAggregation.GHG_INTENSITY_OF_COMPAGNIES)
+        assert res.empty is not None
+        pd.testing.assert_series_equal(
+            dataloader.compute(ESGAggregation.GHG_INTENSITY_OF_COMPAGNIES),
+            dataloader._get_weighted_avg_normalized(),
+            check_exact=True,
+        )
+
+    def test_compute_weighted_avg_normalized_per_category(self, dataloader):
+        res = dataloader.compute(ESGAggregation.ENERGY_CONSUMPTION_INTENSITY_PER_SECTOR)
+        assert res.empty is not None
+        pd.testing.assert_series_equal(res, dataloader._get_weighted_avg_normalized_per_category(), check_exact=True)
+
+    def test_compute_investor_allocation(self, dataloader):
+        res = dataloader.compute(ESGAggregation.GHG_EMISSIONS_SCOPE_1)
+        assert res.empty is not None
+        pd.testing.assert_series_equal(
+            res, dataloader._get_investor_allocation(dataloader.total_value_fx_usd), check_exact=True
+        )
+
+        res = dataloader.compute(ESGAggregation.GHG_EMISSIONS_SCOPE_1)
+        assert res.empty is not None
+        pd.testing.assert_series_equal(
+            dataloader.compute(ESGAggregation.EMISSIONS_TO_WATER),
+            dataloader._get_investor_allocation_per_million(dataloader.weights * 1000000),
+            check_exact=True,
+        )

wbfdm/tests/conftest.py

@@ -0,0 +1,92 @@
+from wbcore.tests.conftest import *  # isort:skip
+from datetime import date
+
+from django.apps import apps
+from django.db.models.signals import pre_migrate
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from pytest_factoryboy import register
+from wbcore.contrib.authentication.factories import (
+    InternalUserFactory,
+    SuperUserFactory,
+    UserFactory,
+)
+from wbcore.contrib.currency.factories import CurrencyFactory, CurrencyFXRatesFactory
+from wbcore.contrib.directory.factories.entries import (
+    CompanyFactory,
+    CompanyTypeFactory,
+    CustomerStatusFactory,
+    EntryFactory,
+    PersonFactory,
+)
+from wbcore.contrib.geography.factories import (
+    CityFactory,
+    ContinentFactory,
+    CountryFactory,
+    StateFactory,
+)
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbcore.contrib.io.factories import (
+    CrontabScheduleFactory,
+    DataBackendFactory,
+    ImportSourceFactory,
+    ParserHandlerFactory,
+    ProviderFactory,
+    SourceFactory,
+)
+from wbfdm.factories import (
+    ClassificationFactory,
+    ClassificationGroupFactory,
+    ExchangeFactory,
+    InstrumentClassificationThroughModelFactory,
+    InstrumentFactory,
+    InstrumentFavoriteGroupFactory,
+    InstrumentListFactory,
+    InstrumentPriceFactory,
+    InstrumentTypeFactory,
+    OptionAggregateFactory,
+    OptionFactory,
+    ParentClassificationFactory,
+    RelatedInstrumentThroughModelFactory,
+)
+
+fake = Faker()
+register(ImportSourceFactory)
+register(DataBackendFactory)
+register(ProviderFactory)
+register(SourceFactory)
+register(ParserHandlerFactory)
+register(CrontabScheduleFactory)
+
+register(ClassificationFactory)
+register(InstrumentClassificationThroughModelFactory)
+register(ParentClassificationFactory)
+register(ClassificationGroupFactory)
+register(ExchangeFactory)
+register(InstrumentFactory)
+register(InstrumentTypeFactory)
+register(InstrumentPriceFactory)
+register(InstrumentFavoriteGroupFactory)
+register(RelatedInstrumentThroughModelFactory)
+register(CurrencyFXRatesFactory)
+register(InstrumentListFactory)
+register(OptionFactory)
+register(OptionAggregateFactory)
+
+register(CurrencyFactory)
+register(CityFactory)
+register(StateFactory)
+register(CountryFactory)
+register(ContinentFactory)
+
+register(CompanyFactory)
+register(PersonFactory)
+register(InternalUserFactory)
+register(EntryFactory)
+register(CustomerStatusFactory)
+register(CompanyTypeFactory)
+
+register(UserFactory)
+register(SuperUserFactory, "superuser")
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbfdm"))

wbfdm/tests/dataloaders/test_cache.py

@@ -0,0 +1,73 @@
+import pytest
+from django.core.cache import cache as cache_layer
+from faker import Faker
+from wbfdm.dataloaders.cache import Cache
+
+fake = Faker()
+
+
+class TestCache:
+    @pytest.fixture
+    def cache(self):
+        return Cache()
+
+    def test_initialize(self, cache):
+        cache.missing_keys = ["a"]
+        cache.missing_ids = ("a",)
+        cache.missing_symbols = ("a",)
+        cache.initialize([1], ["a", "b"])
+
+        # ensure initialize reset the missing attributes set
+        assert cache.missing_keys == list()
+        assert cache.missing_ids == set()
+        assert cache.missing_symbols == set()
+        assert cache.id_symbol_pairs == [("1", "a"), ("1", "b")]
+
+        cache.initialize([1, 2], ["a"])
+        assert cache.id_symbol_pairs == [("1", "a"), ("2", "a")]
+
+    def test__get_cache_key(self, cache):
+        assert cache._get_cache_key("a", "b") == "a_b"
+
+    def test__deserialize_cache(self, cache):
+        assert cache._deserialize_cache("1", "symbol", "value") == {
+            cache.identifier_key: 1,
+            cache.symbol_key: "symbol",
+            cache.value_key: "value",
+        }
+
+    def test_fetch_from_cache(self, cache):
+        cache.initialize([1], ["a"])
+        assert list(cache.fetch_from_cache()) == list()
+        assert cache.missing_keys == ["1_a"]
+        assert cache.missing_symbols == {"a"}
+        assert cache.missing_ids == {"1"}
+
+        cache.initialize([1], ["a"])
+        assert list(cache.fetch_from_cache()) == []
+        assert cache.missing_keys == ["1_a"]
+
+        value = fake.pyfloat()
+        cache_layer.set("1_a", value)
+        cache.initialize([1], ["a"])
+        assert list(cache.fetch_from_cache()) == [{"instrument_id": 1, "factor_code": "a", "value": value}]
+        assert cache.missing_keys == list()
+
+        cache_layer.set("1_a", None)
+        cache.initialize([1], ["a"])
+        assert list(cache.fetch_from_cache()) == list()
+        assert cache.missing_keys == list()
+
+    def test_write(self, cache):
+        cache.missing_keys = ["1_a"]
+        value = fake.pyfloat()
+        cache.write({"instrument_id": 1, "factor_code": "a", "value": value})
+        assert cache.missing_keys == list()
+        assert cache_layer.get("1_a") == value
+
+    def test_close(self, cache):
+        cache.missing_keys = ["3_c"]
+        sentinel = object()
+        assert cache_layer.get("3_c", sentinel) == sentinel
+        cache.close()
+        assert cache_layer.get("3_c", sentinel) is None