Allow TranslateRanker to override decisions taken by heuristics.

components/translate/core/browser/translate_manager_unittest.cc

Index: components/translate/core/browser/translate_manager_unittest.cc
diff --git a/components/translate/core/browser/translate_manager_unittest.cc b/components/translate/core/browser/translate_manager_unittest.cc
index cf2898738d75bdcc4f5603c6daf72b13d0c419ad..5715c26f97a2c2a02d687e598c510201c40f1617 100644
--- a/components/translate/core/browser/translate_manager_unittest.cc
+++ b/components/translate/core/browser/translate_manager_unittest.cc
@@ -13,10 +13,12 @@
 #include "base/test/scoped_feature_list.h"
 #include "build/build_config.h"
 #include "components/infobars/core/infobar.h"
+#include "components/metrics/proto/translate_event.pb.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "components/translate/core/browser/mock_translate_driver.h"
 #include "components/translate/core/browser/mock_translate_ranker.h"
+#include "components/translate/core/browser/translate_accept_languages.h"
 #include "components/translate/core/browser/translate_browser_metrics.h"
 #include "components/translate/core/browser/translate_client.h"
 #include "components/translate/core/browser/translate_download_manager.h"
@@ -65,7 +67,7 @@ class TestNetworkChangeNotifier : public net::NetworkChangeNotifier {
   }
 
   void SimulateOffline() {
-    connection_type_to_return_ =net::NetworkChangeNotifier::CONNECTION_NONE;
+    connection_type_to_return_ = net::NetworkChangeNotifier::CONNECTION_NONE;
   }
 
   void SimulateOnline() {
@@ -84,11 +86,23 @@ class TestNetworkChangeNotifier : public net::NetworkChangeNotifier {
   DISALLOW_COPY_AND_ASSIGN(TestNetworkChangeNotifier);
 };
 
+class MockTranslateAcceptLanguages : public TranslateAcceptLanguages {
+ public:
+  MockTranslateAcceptLanguages() {
+    ON_CALL(*this, IsAcceptLanguage(_)).WillByDefault(Return(true));
+  }
+  virtual ~MockTranslateAcceptLanguages() {}
+  MOCK_METHOD1(IsAcceptLanguage, bool(const std::string&));
+};
+
 // TODO(groby): Combine with MockTranslateClient in TranslateUiDelegateTest.
 class MockTranslateClient : public TranslateClient {
  public:
   MockTranslateClient(TranslateDriver* driver, PrefService* prefs)
-      : driver_(driver), prefs_(prefs) {}
+      : mock_translate_accept_languages_(), driver_(driver), prefs_(prefs) {

[groby-ooo-7-16, 2017/04/10 20:52:47]

Likely the TODO() here would be a good step to take. 

[hamelphi, 2017/04/11 22:46:07]

I agree that test utils would be great. Maybe a bit out of scope for this CL?

+    ON_CALL(*this, GetTranslateAcceptLanguages())
+        .WillByDefault(Return(&mock_translate_accept_languages_));
+  }
 
   // TODO(groby): Does TranslateClient need a virtual dtor?
   virtual ~MockTranslateClient() {}
@@ -124,6 +138,7 @@ class MockTranslateClient : public TranslateClient {
                void(const GURL& report_url));
 
  private:
+  MockTranslateAcceptLanguages mock_translate_accept_languages_;
   TranslateDriver* driver_;
   PrefService* prefs_;
 };
@@ -190,9 +205,9 @@ class TranslateManagerTest : public ::testing::Test {
     std::unique_ptr<base::Value> profile(base::JSONReader::ReadAndReturnError(
         json, 0, &error_code, &error_msg, &error_line, &error_column));
 
-    EXPECT_EQ(0, error_code) << error_msg << " at " << error_line << ":"
-                             << error_column << std::endl
-                             << json;
+    EXPECT_EQ(0, error_code)
+        << error_msg << " at " << error_line << ":" << error_column << std::endl
+        << json;
     return profile;
   }
 
@@ -241,7 +256,6 @@ class TranslateManagerTest : public ::testing::Test {
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
-
 // Target language comes from application locale if the locale's language
 // is supported.
 TEST_F(TranslateManagerTest, GetTargetLanguageDefaultsToAppLocale) {
@@ -319,14 +333,15 @@ void ChangeThresholdInParams(
     const char* target_language_confidence_threshold,
     const char* target_language_probability_threshold) {
   ASSERT_TRUE(variations::AssociateVariationParams(
-      kTrialName, "Enabled", {{"initiate_translation_ulp_confidence_threshold",
-                               initiate_translation_confidence_threshold},
-                              {"initiate_translation_ulp_probability_threshold",
-                               initiate_translation_probability_threshold},
-                              {"target_language_ulp_confidence_threshold",
-                               target_language_confidence_threshold},
-                              {"target_language_ulp_probability_threshold",
-                               target_language_probability_threshold}}));
+      kTrialName, "Enabled",
+      {{"initiate_translation_ulp_confidence_threshold",
+        initiate_translation_confidence_threshold},
+       {"initiate_translation_ulp_probability_threshold",
+        initiate_translation_probability_threshold},
+       {"target_language_ulp_confidence_threshold",
+        target_language_confidence_threshold},
+       {"target_language_ulp_probability_threshold",
+        target_language_probability_threshold}}));
 }
 
 // Normal ULP in Json
@@ -454,6 +469,97 @@ TEST_F(TranslateManagerTest,
   EXPECT_FALSE(CallLanguageInULP("zh-TW"));
 }
 
+TEST_F(TranslateManagerTest, TestRecordTranslateEvent) {
+  PrepareTranslateManager();
+  const std::string locale = "zh-TW";
+  const std::string page_lang = "zh-CN";
+
+  network_notifier_.SimulateOnline();
+  manager_->set_application_locale(locale);
+  ON_CALL(mock_translate_client_, IsTranslatableURL(_))
+      .WillByDefault(Return(true));
+  translate_manager_->GetLanguageState().LanguageDetermined(page_lang, true);
+
+  translate_manager_->InitiateTranslation(page_lang);
+
+  std::vector<metrics::TranslateEventProto> events_cache;
+  mock_translate_ranker_.FlushTranslateEvents(&events_cache);
+  EXPECT_EQ(0U, events_cache.size());
+
+  translate_manager_->RecordTranslateEvent(
+      metrics::TranslateEventProto::USER_ACCEPT);
+  mock_translate_ranker_.FlushTranslateEvents(&events_cache);
+  EXPECT_EQ(1U, events_cache.size());
+  const metrics::TranslateEventProto& tep = events_cache[0];
+  EXPECT_EQ(page_lang, tep.source_language());
+  EXPECT_EQ(locale, tep.target_language());
+  EXPECT_EQ(0L, tep.decision_overrides_size());
+  EXPECT_EQ(metrics::TranslateEventProto::USER_ACCEPT, tep.event_type());
+}
+
+TEST_F(TranslateManagerTest, TestShouldOverrideDecisionTrue) {
+  mock_translate_ranker_.set_is_decision_override_enabled(true);
+  PrepareTranslateManager();
+  const std::string locale = "zh-TW";
+  const std::string page_lang = "zh-CN";
+
+  network_notifier_.SimulateOnline();
+  manager_->set_application_locale(locale);
+  ON_CALL(mock_translate_client_, IsTranslatableURL(_))
+      .WillByDefault(Return(true));
+  translate_manager_->GetLanguageState().LanguageDetermined(page_lang, true);
+
+  translate_manager_->InitiateTranslation(page_lang);
+
+  std::vector<metrics::TranslateEventProto> events_cache;
+  EXPECT_TRUE(translate_manager_->ShouldOverrideDecision(
+      metrics::TranslateEventProto::MATCHES_PREVIOUS_LANGUAGE));
+  EXPECT_TRUE(translate_manager_->ShouldOverrideDecision(
+      metrics::TranslateEventProto::LANGUAGE_DISABLED_BY_AUTO_BLACKLIST));
+
+  translate_manager_->RecordTranslateEvent(
+      metrics::TranslateEventProto::USER_DECLINE);
+  mock_translate_ranker_.FlushTranslateEvents(&events_cache);
+  EXPECT_EQ(1U, events_cache.size());
+  const metrics::TranslateEventProto& tep = events_cache[0];
+  EXPECT_EQ(page_lang, tep.source_language());
+  EXPECT_EQ(locale, tep.target_language());
+  EXPECT_EQ(2L, tep.decision_overrides_size());
+  EXPECT_THAT(
+      tep.decision_overrides(),
+      ::testing::ElementsAre(
+          metrics::TranslateEventProto::MATCHES_PREVIOUS_LANGUAGE,
+          metrics::TranslateEventProto::LANGUAGE_DISABLED_BY_AUTO_BLACKLIST));
+  EXPECT_EQ(metrics::TranslateEventProto::USER_DECLINE, tep.event_type());
+}
+
+TEST_F(TranslateManagerTest, TestShouldOverrideDecisionFalse) {
+  mock_translate_ranker_.set_is_decision_override_enabled(false);
+  PrepareTranslateManager();
+  const std::string locale = "zh-TW";
+  const std::string page_lang = "zh-CN";
+
+  network_notifier_.SimulateOnline();
+  manager_->set_application_locale(locale);
+  ON_CALL(mock_translate_client_, IsTranslatableURL(_))
+      .WillByDefault(Return(true));
+  translate_manager_->GetLanguageState().LanguageDetermined(page_lang, true);
+
+  translate_manager_->InitiateTranslation(page_lang);
+  std::vector<metrics::TranslateEventProto> events_cache;
+  EXPECT_FALSE(translate_manager_->ShouldOverrideDecision(
+      metrics::TranslateEventProto::MATCHES_PREVIOUS_LANGUAGE));
+
+  mock_translate_ranker_.FlushTranslateEvents(&events_cache);
+  EXPECT_EQ(1U, events_cache.size());
+  const metrics::TranslateEventProto& tep = events_cache[0];
+  EXPECT_EQ(page_lang, tep.source_language());
+  EXPECT_EQ(locale, tep.target_language());
+  EXPECT_EQ(0L, tep.decision_overrides_size());
+  EXPECT_EQ(metrics::TranslateEventProto::MATCHES_PREVIOUS_LANGUAGE,
+            tep.event_type());
+}
+
 }  // namespace testing
 
 }  // namespace translate