Allow TranslateRanker to override decisions taken by heuristics.

components/translate/core/browser/translate_manager_unittest.cc

 // Copyright 2015 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_manager.h"
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #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"
 #include "components/translate/core/browser/translate_prefs.h"
 #include "components/translate/core/common/translate_pref_names.h"
 #include "components/variations/variations_associated_data.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 28 matching lines @@
   // objects that are NetworkChangeNotifiers.
   void SimulateNetworkConnectionChange(
       net::NetworkChangeNotifier::ConnectionType type) {
     connection_type_to_return_ = type;
     net::NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeForTests(
         connection_type_to_return_);
     base::RunLoop().RunUntilIdle();
   }
 
   void SimulateOffline() {
-    connection_type_to_return_ =net::NetworkChangeNotifier::CONNECTION_NONE;
+    connection_type_to_return_ = net::NetworkChangeNotifier::CONNECTION_NONE;
   }
 
   void SimulateOnline() {
     connection_type_to_return_ = net::NetworkChangeNotifier::CONNECTION_UNKNOWN;
   }
 
  private:
   ConnectionType GetCurrentConnectionType() const override {
     return connection_type_to_return_;
   }
 
   // The currently simulated network connection type. If this is set to
   // CONNECTION_NONE, then NetworkChangeNotifier::IsOffline will return true.
   net::NetworkChangeNotifier::ConnectionType connection_type_to_return_;
 
   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() {}
 
   TranslateDriver* GetTranslateDriver() { return driver_; }
   PrefService* GetPrefs() { return prefs_; }
 
   std::unique_ptr<TranslatePrefs> GetTranslatePrefs() {
     return base::MakeUnique<TranslatePrefs>(prefs_, kAcceptLanguages,
                                             kLanguagePreferredLanguages);
@@ skipping 15 matching lines @@
                     const std::string&,
                     const std::string&,
                     TranslateErrors::Type,
                     bool));
 
   MOCK_METHOD1(IsTranslatableURL, bool(const GURL&));
   MOCK_METHOD1(ShowReportLanguageDetectionErrorUI,
                void(const GURL& report_url));
 
  private:
+  MockTranslateAcceptLanguages mock_translate_accept_languages_;
   TranslateDriver* driver_;
   PrefService* prefs_;
 };
 
 }  // namespace
 
 namespace testing {
 
 class TranslateManagerTest : public ::testing::Test {
  protected:
@@ skipping 46 matching lines @@
 
   std::unique_ptr<base::Value> CreateProfileFromJSON(const char* json) {
     int error_code = 0;
     std::string error_msg;
     int error_line = 0;
     int error_column = 0;
 
     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;
   }
 
   void TurnOnTranslateByULP() {
     scoped_refptr<base::FieldTrial> trial(
         CreateFieldTrial(kTrialName, 100, "Enabled", NULL));
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->RegisterFieldTrialOverride(
         translate::kTranslateLanguageByULP.name,
         base::FeatureList::OVERRIDE_ENABLE_FEATURE, trial.get());
@@ skipping 28 matching lines @@
 
   TestNetworkChangeNotifier network_notifier_;
   translate::testing::MockTranslateDriver driver_;
   translate::testing::MockTranslateRanker mock_translate_ranker_;
   ::testing::NiceMock<MockTranslateClient> mock_translate_client_;
   std::unique_ptr<TranslateManager> translate_manager_;
   std::unique_ptr<base::FieldTrialList> field_trial_list_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
-
 // Target language comes from application locale if the locale's language
 // is supported.
 TEST_F(TranslateManagerTest, GetTargetLanguageDefaultsToAppLocale) {
   // Ensure the locale is set to a supported language.
   ASSERT_TRUE(TranslateDownloadManager::IsSupportedLanguage("en"));
   manager_->set_application_locale("en");
   EXPECT_EQ("en", TranslateManager::GetTargetLanguage(&translate_prefs_));
 
   // Try a second supported language.
   ASSERT_TRUE(TranslateDownloadManager::IsSupportedLanguage("de"));
@@ skipping 57 matching lines @@
       1);
 }
 
 // Utility function to set the threshold params
 void ChangeThresholdInParams(
     const char* initiate_translation_confidence_threshold,
     const char* initiate_translation_probability_threshold,
     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
 const char ulp_1[] =
     "{\n"
     "  \"reading\": {\n"
     "    \"confidence\": 0.8,\n"
     "    \"preference\": [\n"
     "      {\n"
     "        \"language\": \"fr\",\n"
@@ skipping 107 matching lines @@
   PrepareULPTest(ulp_1, true);
   ChangeThresholdInParams("0.79", "0.39", "", "");
   // Both "fr" and "pt" should reutrn true because the confidence threshold is
   // 0.79 and lower than 0.8 and the probability threshold is lower than both
   // the one with "fr" (0.6) and "pt-PT" (0.4).
   EXPECT_TRUE(CallLanguageInULP("fr"));
   EXPECT_TRUE(CallLanguageInULP("pt"));
   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