Allow TranslateRanker to override decisions taken by heuristics.

components/translate/core/browser/translate_ranker_impl_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/translate/core/browser/translate_ranker_impl.h"
 
 #include <initializer_list>
 #include <memory>
 
 #include "base/feature_list.h"
@@ skipping 18 matching lines @@
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 
 using translate::kTranslateRankerEnforcement;
 using translate::kTranslateRankerLogging;
 using translate::kTranslateRankerQuery;
+using translate::kTranslateRankerDecisionOverride;
 using translate::TranslateDownloadManager;
 using translate::TranslateRankerFeatures;
 using translate::TranslatePrefs;
 using translate::TranslateRankerImpl;
 
-constexpr int kModelVersion = 1234;
+constexpr uint32_t kModelVersion = 1234;
 
 class TranslateRankerImplTest : public ::testing::Test {
  protected:
   TranslateRankerImplTest();
 
   void SetUp() override;
 
   void TearDown() override;
 
   // Initializes the explicitly |enabled| and |disabled| features for this test.
@@ skipping 17 matching lines @@
   // The platform-specific name of the preferred language pref.
   static const char* const kPreferredLanguagePref;
 
   // Prefs.
   std::unique_ptr<sync_preferences::TestingPrefServiceSyncable> prefs_;
   std::unique_ptr<translate::TranslatePrefs> translate_prefs_;
 
   ukm::TestUkmService* GetTestUkmService() {
     return ukm_service_test_harness_.test_ukm_service();
   }
+  metrics::TranslateEventProto tep1_ =
+      CreateTranslateEvent("fr", "en", 1, 0, 3);
+  metrics::TranslateEventProto tep2_ =
+      CreateTranslateEvent("jp", "en", 2, 0, 3);
+  metrics::TranslateEventProto tep3_ =
+      CreateTranslateEvent("es", "de", 4, 5, 6);
 
  private:
   ukm::UkmServiceTestingHarness ukm_service_test_harness_;
 
   // Override the default URL fetcher to return custom responses for tests.
   net::TestURLFetcherFactory url_fetcher_factory_;
 
   // Used to initialize the translate download manager.
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
 
@@ skipping 106 matching lines @@
   translate_event.set_source_language(src_lang);
   translate_event.set_target_language(dst_lang);
   translate_event.set_accept_count(accept_count);
   translate_event.set_decline_count(decline_count);
   translate_event.set_ignore_count(ignore_count);
   return translate_event;
 }
 
 }  // namespace
 
-TEST_F(TranslateRankerImplTest, DisabledByDefault) {
-  InitFeatures({}, {});
-  auto ranker = GetRankerForTest(0.5);
-  EXPECT_FALSE(ranker->IsQueryEnabled());
-  EXPECT_FALSE(ranker->IsEnforcementEnabled());
-  EXPECT_TRUE(ranker->IsLoggingEnabled());
-}
-
-TEST_F(TranslateRankerImplTest, ExplicitlyDisabled) {
-  InitFeatures({}, {kTranslateRankerQuery, kTranslateRankerEnforcement,
-                    kTranslateRankerLogging});
-  auto ranker = GetRankerForTest(0.5);
-  EXPECT_FALSE(ranker->IsQueryEnabled());
-  EXPECT_FALSE(ranker->IsEnforcementEnabled());
-  EXPECT_FALSE(ranker->IsLoggingEnabled());
-}
-
-TEST_F(TranslateRankerImplTest, EnableQuery) {
-  InitFeatures({kTranslateRankerQuery}, {kTranslateRankerEnforcement});
-  auto ranker = GetRankerForTest(0.5);
-  EXPECT_TRUE(ranker->IsQueryEnabled());
-  EXPECT_FALSE(ranker->IsEnforcementEnabled());
-  EXPECT_TRUE(ranker->IsLoggingEnabled());
-}
-
-TEST_F(TranslateRankerImplTest, EnableEnforcement) {
-  InitFeatures({kTranslateRankerEnforcement}, {kTranslateRankerQuery});
-  auto ranker = GetRankerForTest(0.5);
-  EXPECT_FALSE(ranker->IsQueryEnabled());
-  EXPECT_TRUE(ranker->IsEnforcementEnabled());
-  EXPECT_TRUE(ranker->IsLoggingEnabled());
-}
-
-TEST_F(TranslateRankerImplTest, EnableQueryAndEnforcement) {
-  InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement}, {});
-  auto ranker = GetRankerForTest(0.5);
-  EXPECT_TRUE(ranker->IsQueryEnabled());
-  EXPECT_TRUE(ranker->IsEnforcementEnabled());
-  EXPECT_TRUE(ranker->IsLoggingEnabled());
-}
-
-TEST_F(TranslateRankerImplTest, EnableLogging) {
-  InitFeatures({kTranslateRankerLogging}, {});
-  auto ranker = GetRankerForTest(0.5);
-  EXPECT_FALSE(ranker->IsQueryEnabled());
-  EXPECT_FALSE(ranker->IsEnforcementEnabled());
-  EXPECT_TRUE(ranker->IsLoggingEnabled());
-}
-
-TEST_F(TranslateRankerImplTest, DisableLogging) {
-  InitFeatures({}, {kTranslateRankerLogging});
-  auto ranker = GetRankerForTest(0.5);
-  EXPECT_FALSE(ranker->IsQueryEnabled());
-  EXPECT_FALSE(ranker->IsEnforcementEnabled());
-  EXPECT_FALSE(ranker->IsLoggingEnabled());
-}
-
-TEST_F(TranslateRankerImplTest, EnableAll) {
-  InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement,
-                kTranslateRankerLogging},
-               {});
-  auto ranker = GetRankerForTest(0.5);
-  EXPECT_TRUE(ranker->IsQueryEnabled());
-  EXPECT_TRUE(ranker->IsEnforcementEnabled());
-  EXPECT_TRUE(ranker->IsLoggingEnabled());
-}
-
 TEST_F(TranslateRankerImplTest, GetVersion) {
   InitFeatures({kTranslateRankerQuery}, {});
   auto ranker = GetRankerForTest(0.01f);
   EXPECT_TRUE(ranker->CheckModelLoaderForTesting());
   EXPECT_EQ(kModelVersion, ranker->GetModelVersion());
 }
 
 TEST_F(TranslateRankerImplTest, ModelLoaderQueryNotEnabled) {
   // If Query is not enabled, the ranker should not try to load the model.
   InitFeatures({}, {kTranslateRankerQuery});
@@ skipping 15 matching lines @@
                             1.0 * 0.04f +  // one-hot src-language "en" * weight
                             1.0 * 0.00f +  // one-hot dst-language "fr" * weight
                             1.0 * 0.07f +  // one-hot country "de" * weight
                             1.0 * 0.12f +  // one-hot locale "zh-CN" * weight
                             0.01f);        // bias
   TranslateRankerFeatures features(50, 50, 0, "en", "fr", "de", "zh-CN");
 
   EXPECT_NEAR(expected, ranker->CalculateScore(features), 0.000001);
 }
 
-TEST_F(TranslateRankerImplTest, ShouldOfferTranslation) {
-  InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement}, {});
+TEST_F(TranslateRankerImplTest, ShouldOfferTranslation_AllEnabled) {
+  InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement,
+                kTranslateRankerDecisionOverride},
+               {});
+  metrics::TranslateEventProto tep;
+
   // With a bias of -0.5 en->fr is not over the threshold.
   EXPECT_FALSE(GetRankerForTest(-0.5f)->ShouldOfferTranslation(
-      *translate_prefs_, "en", "fr"));
+      *translate_prefs_, "en", "fr", &tep));
+  EXPECT_NE(0U, tep.ranker_request_timestamp_sec());
+  EXPECT_EQ(kModelVersion, tep.ranker_version());
+  EXPECT_EQ(metrics::TranslateEventProto::DONT_SHOW, tep.ranker_response());
+
   // With a bias of 0.25 en-fr is over the threshold.
-  EXPECT_TRUE(GetRankerForTest(0.25f)->ShouldOfferTranslation(*translate_prefs_,
-                                                              "en", "fr"));
+  tep.Clear();
+  EXPECT_TRUE(GetRankerForTest(0.25f)->ShouldOfferTranslation(
+      *translate_prefs_, "en", "fr", &tep));
+  EXPECT_EQ(metrics::TranslateEventProto::SHOW, tep.ranker_response());
+}
+TEST_F(TranslateRankerImplTest, ShouldOfferTranslation_AllDisabled) {
+  InitFeatures({}, {kTranslateRankerQuery, kTranslateRankerEnforcement,
+                    kTranslateRankerDecisionOverride});
+  metrics::TranslateEventProto tep;
+  // If query and other flags are turned off, returns true and do not query the
+  // ranker.
+  EXPECT_TRUE(GetRankerForTest(-0.5f)->ShouldOfferTranslation(
+      *translate_prefs_, "en", "fr", &tep));
+  EXPECT_NE(0U, tep.ranker_request_timestamp_sec());
+  EXPECT_EQ(kModelVersion, tep.ranker_version());
+  EXPECT_EQ(metrics::TranslateEventProto::NOT_QUERIED, tep.ranker_response());
+}
+
+TEST_F(TranslateRankerImplTest, ShouldOfferTranslation_QueryOnly) {
+  InitFeatures({kTranslateRankerQuery},
+               {kTranslateRankerEnforcement, kTranslateRankerDecisionOverride});
+  metrics::TranslateEventProto tep;
+  // If enforcement is turned off, returns true even if the decision
+  // is not to show.
+  EXPECT_TRUE(GetRankerForTest(-0.5f)->ShouldOfferTranslation(
+      *translate_prefs_, "en", "fr", &tep));
+  EXPECT_NE(0U, tep.ranker_request_timestamp_sec());
+  EXPECT_EQ(kModelVersion, tep.ranker_version());
+  EXPECT_EQ(metrics::TranslateEventProto::DONT_SHOW, tep.ranker_response());
+}
+
+TEST_F(TranslateRankerImplTest, ShouldOfferTranslation_EnforcementOnly) {
+  InitFeatures({kTranslateRankerEnforcement},
+               {kTranslateRankerQuery, kTranslateRankerDecisionOverride});
+  metrics::TranslateEventProto tep;
+  // If either enforcement or decision override are turned on, returns the
+  // ranker decision.
+  EXPECT_FALSE(GetRankerForTest(-0.5f)->ShouldOfferTranslation(
+      *translate_prefs_, "en", "fr", &tep));
+  EXPECT_NE(0U, tep.ranker_request_timestamp_sec());
+  EXPECT_EQ(kModelVersion, tep.ranker_version());
+  EXPECT_EQ(metrics::TranslateEventProto::DONT_SHOW, tep.ranker_response());
+}
+
+TEST_F(TranslateRankerImplTest, ShouldOfferTranslation_OverrideOnly) {
+  InitFeatures({kTranslateRankerDecisionOverride},
+               {kTranslateRankerQuery, kTranslateRankerEnforcement});
+  metrics::TranslateEventProto tep;
+  // If either enforcement or decision override are turned on, returns the
+  // ranker decision.
+  EXPECT_FALSE(GetRankerForTest(-0.5f)->ShouldOfferTranslation(
+      *translate_prefs_, "en", "fr", &tep));
+  EXPECT_NE(0U, tep.ranker_request_timestamp_sec());
+  EXPECT_EQ(kModelVersion, tep.ranker_version());
+  EXPECT_EQ(metrics::TranslateEventProto::DONT_SHOW, tep.ranker_response());
+}
+
+TEST_F(TranslateRankerImplTest, ShouldOfferTranslation_NoModel) {
+  auto ranker =
+      base::MakeUnique<TranslateRankerImpl>(base::FilePath(), GURL(), nullptr);
+  InitFeatures({kTranslateRankerDecisionOverride, kTranslateRankerQuery,
+                kTranslateRankerEnforcement},
+               {});
+  metrics::TranslateEventProto tep;
+  // If we don't have a model, returns true.
+  EXPECT_TRUE(
+      ranker->ShouldOfferTranslation(*translate_prefs_, "en", "fr", &tep));
+  EXPECT_NE(0U, tep.ranker_request_timestamp_sec());
+  EXPECT_EQ(0U, tep.ranker_version());
+  EXPECT_EQ(metrics::TranslateEventProto::NOT_QUERIED, tep.ranker_response());
 }
 
 TEST_F(TranslateRankerImplTest, RecordAndFlushEvents) {
   InitFeatures({kTranslateRankerLogging}, {});
   std::unique_ptr<translate::TranslateRanker> ranker = GetRankerForTest(0.0f);
   std::vector<metrics::TranslateEventProto> flushed_events;
 
   GURL url0("https://www.google.com");
   GURL url1("https://www.gmail.com");
 
   // Check that flushing an empty cache will return an empty vector.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 
-  ranker->AddTranslateEvent(CreateTranslateEvent("fr", "en", 1, 0, 3), url0);
-  ranker->AddTranslateEvent(CreateTranslateEvent("jp", "en", 2, 0, 3), GURL());
-  ranker->AddTranslateEvent(CreateTranslateEvent("es", "de", 4, 5, 6), url1);
+  ranker->RecordTranslateEvent(0, url0, &tep1_);
+  ranker->RecordTranslateEvent(1, GURL(), &tep2_);
+  ranker->RecordTranslateEvent(2, url1, &tep3_);
 
   // Capture the data and verify that it is as expected.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(3U, flushed_events.size());
-  ASSERT_EQ("fr", flushed_events[0].source_language());
-  ASSERT_EQ("jp", flushed_events[1].source_language());
-  ASSERT_EQ("es", flushed_events[2].source_language());
+  ASSERT_EQ(tep1_.source_language(), flushed_events[0].source_language());
+  ASSERT_EQ(0, flushed_events[0].event_type());
+  ASSERT_EQ(tep2_.source_language(), flushed_events[1].source_language());
+  ASSERT_EQ(1, flushed_events[1].event_type());
+  ASSERT_EQ(tep3_.source_language(), flushed_events[2].source_language());
+  ASSERT_EQ(2, flushed_events[2].event_type());
 
   // Check that the cache has been cleared.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 
   ASSERT_EQ(2U, GetTestUkmService()->sources_count());
   EXPECT_EQ(
       url0.spec(),
       GetTestUkmService()->GetSourceForUrl(url0.spec().c_str())->url().spec());
   EXPECT_EQ(
       url1.spec(),
       GetTestUkmService()->GetSourceForUrl(url1.spec().c_str())->url().spec());
 }
 
 TEST_F(TranslateRankerImplTest, LoggingDisabled) {
   InitFeatures({}, {kTranslateRankerLogging});
   std::unique_ptr<translate::TranslateRanker> ranker = GetRankerForTest(0.0f);
   std::vector<metrics::TranslateEventProto> flushed_events;
 
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 
-  ranker->AddTranslateEvent(CreateTranslateEvent("fr", "en", 1, 0, 3), GURL());
-  ranker->AddTranslateEvent(CreateTranslateEvent("jp", "en", 2, 0, 3), GURL());
-  ranker->AddTranslateEvent(CreateTranslateEvent("es", "de", 4, 5, 6), GURL());
+  ranker->RecordTranslateEvent(0, GURL(), &tep1_);
+  ranker->RecordTranslateEvent(1, GURL(), &tep2_);
+  ranker->RecordTranslateEvent(2, GURL(), &tep3_);
 
   // Logging is disabled, so no events should be cached.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
   EXPECT_EQ(0ul, GetTestUkmService()->sources_count());
 }
 
 TEST_F(TranslateRankerImplTest, LoggingDisabledViaOverride) {
   InitFeatures({kTranslateRankerLogging}, {});
   std::unique_ptr<translate::TranslateRankerImpl> ranker =
       GetRankerForTest(0.0f);
   std::vector<metrics::TranslateEventProto> flushed_events;
 
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 
-  ranker->AddTranslateEvent(CreateTranslateEvent("fr", "en", 1, 0, 3), GURL());
-  ranker->AddTranslateEvent(CreateTranslateEvent("jp", "en", 2, 0, 3), GURL());
-  ranker->AddTranslateEvent(CreateTranslateEvent("es", "de", 4, 5, 6), GURL());
+  ranker->RecordTranslateEvent(0, GURL(), &tep1_);
+  ranker->RecordTranslateEvent(1, GURL(), &tep2_);
+  ranker->RecordTranslateEvent(2, GURL(), &tep3_);
 
   // Logging is disabled, so no events should be cached.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(3U, flushed_events.size());
 
   // Override the feature setting to disable logging.
   ranker->EnableLogging(false);
 
-  ranker->AddTranslateEvent(CreateTranslateEvent("fr", "en", 1, 0, 3), GURL());
-  ranker->AddTranslateEvent(CreateTranslateEvent("jp", "en", 2, 0, 3), GURL());
-  ranker->AddTranslateEvent(CreateTranslateEvent("es", "de", 4, 5, 6), GURL());
+  ranker->RecordTranslateEvent(0, GURL(), &tep1_);
+  ranker->RecordTranslateEvent(1, GURL(), &tep2_);
+  ranker->RecordTranslateEvent(2, GURL(), &tep3_);
 
   // Logging is disabled, so no events should be cached.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 }
+
+TEST_F(TranslateRankerImplTest, ShouldOverrideDecision_OverrideDisabled) {
+  InitFeatures({}, {kTranslateRankerDecisionOverride});
+  std::unique_ptr<translate::TranslateRankerImpl> ranker =
+      GetRankerForTest(0.0f);
+  const int kEventType = 12;
+  metrics::TranslateEventProto tep = CreateTranslateEvent("fr", "en", 1, 0, 3);
+
+  EXPECT_FALSE(ranker->ShouldOverrideDecision(kEventType, GURL(), &tep));
+
+  std::vector<metrics::TranslateEventProto> flushed_events;
+  ranker->FlushTranslateEvents(&flushed_events);
+  EXPECT_EQ(1U, flushed_events.size());
+  ASSERT_EQ(tep.source_language(), flushed_events[0].source_language());
+  ASSERT_EQ(kEventType, flushed_events[0].event_type());
+}
+
+TEST_F(TranslateRankerImplTest, ShouldOverrideDecision_OverrideEnabled) {
+  InitFeatures({kTranslateRankerDecisionOverride}, {});
+  std::unique_ptr<translate::TranslateRankerImpl> ranker =
+      GetRankerForTest(0.0f);
+  metrics::TranslateEventProto tep = CreateTranslateEvent("fr", "en", 1, 0, 3);
+
+  EXPECT_TRUE(ranker->ShouldOverrideDecision(1, GURL(), &tep));
+  EXPECT_TRUE(ranker->ShouldOverrideDecision(2, GURL(), &tep));
+
+  std::vector<metrics::TranslateEventProto> flushed_events;
+  ranker->FlushTranslateEvents(&flushed_events);
+  EXPECT_EQ(0U, flushed_events.size());
+  ASSERT_EQ(2, tep.decision_overrides_size());
+  ASSERT_EQ(1, tep.decision_overrides(0));
+  ASSERT_EQ(2, tep.decision_overrides(1));
+  ASSERT_EQ(0, tep.event_type());
+}