def test_can_recommend(mock_s3_json_downloader): r = LegacyRecommender() # Test that we can't recommend if we have not enough client info. assert not r.can_recommend({}) assert not r.can_recommend({"disabled_addons_ids": []}) # Check that we can not recommend if no *legacy* addons are detected, # but addon is in loaded resource. profile_without_legacy = dict( client_id="test-client-id", disabled_addons_ids=["test_guid_7", "test_guid_8"], locale="it-IT") assert not r.can_recommend(profile_without_legacy)
def test_recommender_str(): """Tests that the string representation of the recommender is correct """ ctx = Context() ctx = s3_mocker(ctx) r = LegacyRecommender(ctx) assert str(r) == "LegacyRecommender"
def test_recommender_str(mock_s3_json_downloader): """Tests that the string representation of the recommender is correct """ # TODO: this test is brittle and should be removed once it is safe # to do so r = LegacyRecommender() assert str(r) == "LegacyRecommender"
def test_recommendations(mock_s3_json_downloader): # Test that the legacy recommender returns the correct addons from the json loaded. r = LegacyRecommender() limit = 10 profile_with_legacy = dict( client_id="test-client-id", disabled_addons_ids=["{test_guid_1}", "test_guid_8"], locale="it-IT" ) recommendations = r.recommend(profile_with_legacy, limit) # Make sure the structure of the recommendations is correct and that we recommended the the right addons. assert isinstance(recommendations, list) # Make sure that the reported addons are the ones from the fake data. assert "test_guid_2" in recommendations assert "test_guid_3" in recommendations
def test_recommendations(mock_s3_json_downloader): """Test that the legacy recommender returns the correct addons from the json loaded. The JSON output for this recommender should be a list of 2-tuples of (GUID, weight). """ r = LegacyRecommender() profile_with_many_legacy = dict( client_id="test-client-id", disabled_addons_ids=["guid-01", "guid-05", "guid-12"], locale="it-IT") recommendations = r.recommend(profile_with_many_legacy, LIMIT) assert len(recommendations) == LIMIT assert ("guid-13-1", 1) in recommendations assert ("guid-21-9", 1) not in recommendations assert ("guid-22-10", 1) not in recommendations assert ("guid-21-9", 1) not in recommendations
def default_context(): ctx = Context() from taar.recommenders import LegacyRecommender from taar.recommenders import CollaborativeRecommender from taar.recommenders import SimilarityRecommender from taar.recommenders import LocaleRecommender from taar.cache import Clock from taar.cache import JSONCache # Note that the EnsembleRecommender is *not* in this map as it # needs to ensure that the recommender_map key is installed in the # context ctx['recommender_factory_map'] = { 'legacy': lambda: LegacyRecommender(ctx.child()), 'collaborative': lambda: CollaborativeRecommender(ctx.child()), 'similarity': lambda: SimilarityRecommender(ctx.child()), 'locale': lambda: LocaleRecommender(ctx.child()) } ctx['utils'] = utils ctx['clock'] = Clock() ctx['cache'] = JSONCache(ctx) return ctx
def test_recommender_str(mock_s3_json_downloader): # Tests that the string representation of the recommender is correct r = LegacyRecommender() assert str(r) == "LegacyRecommender"
masked, unmasked = random_partition(addons, num_mask) client['installed_addons'] = unmasked client['masked_addons'] = masked return client training_masked = map(mask_addons, training) recommenders = { "collaborative": CollaborativeRecommender(), "similarity": SimilarityRecommender(), "locale": LocaleRecommender("./top_addons_by_locale.json"), "legacy": LegacyRecommender() } def compute_features(client_data): recommendations = [] matrix = [] for _, recommender in recommenders.items(): recommendations.append(recommender.get_weighted_recommendations(client_data)) for addon in whitelist: matrix.append([features[addon] for features in recommendations]) return client_data, np.array(matrix)