[translate] Add translate ranker model loader.

components/translate/core/browser/ranker_model_loader_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/ranker_model_loader.h"
+
+#include <deque>
+#include <initializer_list>
+#include <memory>
+#include <vector>
+
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/test/scoped_feature_list.h"
+#include "base/test/scoped_task_scheduler.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "components/metrics/proto/translate_event.pb.h"
+#include "components/prefs/scoped_user_pref_update.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "components/translate/core/browser/proto/ranker_model.pb.h"
+#include "components/translate/core/browser/proto/translate_ranker_model.pb.h"
+#include "components/translate/core/browser/translate_download_manager.h"
+#include "components/translate/core/browser/translate_prefs.h"
+#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"
+
+namespace {
+
+using ::chrome_intelligence::RankerModel;
+using ::translate::RankerModelLoader;
+using ::translate::RankerModelStatus;
+using ::translate::TranslateDownloadManager;
+
+const char kInvalidModelData[] = "not a valid model";
+const int kInvalidModelSize = sizeof(kInvalidModelData) - 1;
+
+class RankerModelLoaderTest : public ::testing::Test {

[groby-ooo-7-16, 2017/02/14 20:56:48]

This is a fairly huge fixture. I like those better with the code being outside
the declaration for readability, but I'm not insisting.

[Roger McFarlane (Chromium), 2017/02/21 22:16:51]

Done.

+ protected:
+  RankerModelLoaderTest() : url_fetcher_factory_(nullptr) {}
+
+  void SetUp() override {
+    // Setup the translate download manager.
+    locale_ = TranslateDownloadManager::GetInstance()->application_locale();
+    request_context_getter_ = new net::TestURLRequestContextGetter(
+        base::CreateSingleThreadTaskRunnerWithTraits(base::TaskTraits()));
+    TranslateDownloadManager::GetInstance()->set_application_locale("en-US");

[groby-ooo-7-16, 2017/02/14 20:56:48]

Would you mind not using en-US? I have the sneaking suspicion that half of the
tests running in en-US only work because that's the default for devs :)

[Roger McFarlane (Chromium), 2017/02/21 22:16:51]

Done.

+    TranslateDownloadManager::GetInstance()->set_request_context(
+        request_context_getter_.get());
+
+    ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
+    const auto& temp_dir = scoped_temp_dir_.GetPath();

[groby-ooo-7-16, 2017/02/14 20:56:48]

temp_dir_path?

[Roger McFarlane (Chromium), 2017/02/21 22:16:51]

Done.

+
+    // Setup the model file paths.
+    local_model_path_ = temp_dir.AppendASCII("local_model.bin");
+    expired_model_path_ = temp_dir.AppendASCII("expired_model.bin");
+    invalid_model_path_ = temp_dir.AppendASCII("invalid_model.bin");
+
+    // Setup the model URLs.
+    remote_model_url_ = GURL("https://some.url.net/good.model.bin");
+    invalid_model_url_ = GURL("https://some.url.net/bad.model.bin");
+    failed_model_url_ = GURL("https://some.url.net/fail");
+
+    // Initialize the model data.
+    ASSERT_NO_FATAL_FAILURE(InitRemoteModels());
+    ASSERT_NO_FATAL_FAILURE(InitLocalModels());
+  }
+
+  void TearDown() override {
+    base::RunLoop().RunUntilIdle();
+    TranslateDownloadManager::GetInstance()->set_application_locale(locale_);
+    TranslateDownloadManager::GetInstance()->set_request_context(nullptr);
+  }
+
+  static bool IsEqual(const RankerModel& m1, const RankerModel& m2) {
+    return m1.SerializeAsString() == m2.SerializeAsString();
+  }
+
+  static bool IsEquivalent(const RankerModel& m1, const RankerModel& m2) {
+    RankerModel copy_m1 = m1;
+    copy_m1.mutable_metadata()->Clear();
+    RankerModel copy_m2 = m2;
+    copy_m2.mutable_metadata()->Clear();
+    return IsEqual(copy_m1, copy_m2);
+  }
+
+  bool DoLoaderTest(const base::FilePath& model_path, const GURL& model_url) {
+    auto loader = base::MakeUnique<RankerModelLoader>(
+        base::Bind(&RankerModelLoaderTest::Validate, base::Unretained(this)),
+        base::Bind(&RankerModelLoaderTest::OnModelAvailable,
+                   base::Unretained(this)),
+        model_path, model_url, "RankerModelLoaderTest");
+
+    loader->Start();
+    base::RunLoop().RunUntilIdle();
+
+    return true;
+  }
+
+  void InitRemoteModels() {
+    InitModel(remote_model_url_, base::Time(), base::TimeDelta(),
+              &remote_model_);
+    url_fetcher_factory_.SetFakeResponse(
+        remote_model_url_, remote_model_.SerializeAsString(), net::HTTP_OK,
+        net::URLRequestStatus::SUCCESS);
+    url_fetcher_factory_.SetFakeResponse(invalid_model_url_, kInvalidModelData,
+                                         net::HTTP_OK,
+                                         net::URLRequestStatus::SUCCESS);
+    url_fetcher_factory_.SetFakeResponse(failed_model_url_, "",
+                                         net::HTTP_INTERNAL_SERVER_ERROR,
+                                         net::URLRequestStatus::FAILED);
+  }
+
+  void InitLocalModels() {
+    InitModel(remote_model_url_, base::Time::Now(),
+              base::TimeDelta::FromDays(30), &local_model_);
+    InitModel(remote_model_url_,
+              base::Time::Now() - base::TimeDelta::FromDays(60),
+              base::TimeDelta::FromDays(30), &expired_model_);
+    SaveModel(local_model_, local_model_path_);
+    SaveModel(expired_model_, expired_model_path_);
+    ASSERT_EQ(base::WriteFile(invalid_model_path_, kInvalidModelData,
+                              kInvalidModelSize),
+              kInvalidModelSize);
+  }
+
+  void InitModel(const GURL& model_url,
+                 const base::Time& last_modified,
+                 const base::TimeDelta& cache_duration,
+                 RankerModel* model) {
+    model->Clear();
+
+    auto* metadata = model->mutable_metadata();
+    if (!model_url.is_empty())
+      metadata->set_source(model_url.spec());
+    if (!last_modified.is_null()) {
+      auto last_modified_sec = (last_modified - base::Time()).InSeconds();
+      metadata->set_last_modified_sec(last_modified_sec);
+    }
+    if (!cache_duration.is_zero())
+      metadata->set_cache_duration_sec(cache_duration.InSeconds());
+
+    auto* translate = model->mutable_translate();
+    auto* logit = translate->mutable_logistic_regression_model();
+    translate->set_version(1);
+    logit->set_bias(0.1f);
+    logit->set_accept_ratio_weight(0.2f);
+    logit->set_decline_ratio_weight(0.3f);
+    logit->set_ignore_ratio_weight(0.4f);
+  }
+
+  void SaveModel(const RankerModel& model, const base::FilePath& model_path) {
+    std::string model_str = model.SerializeAsString();
+    ASSERT_EQ(base::WriteFile(model_path, model_str.data(), model_str.size()),
+              static_cast<int>(model_str.size()));
+  }
+
+  RankerModelStatus Validate(const RankerModel& model) {
+    validated_models_.push_back(model);
+    RankerModelStatus response = RankerModelStatus::OK;
+    if (!validate_response_.empty()) {
+      response = validate_response_.front();
+      validate_response_.pop_front();
+    }
+    return response;
+  }
+
+  void OnModelAvailable(std::unique_ptr<RankerModel> model) {
+    available_models_.push_back(*model);

[groby-ooo-7-16, 2017/02/14 20:56:48]

Wait - isn't that model deleted when you leave OnModelAvailable, since it's a
unique_ptr, and you don't Pass/move to available_models?

[Roger McFarlane (Chromium), 2017/02/21 22:16:51]

This was storing a copy of the model.

I've added a RankerModel wrapper class between the raw proto and the ranker,
which isn't directly copy-able, so I've switched this to holding unique_ptr to
RankerModel.

+  }
+
+  // Override the default URL fetcher to return custom responses for tests.
+  net::FakeURLFetcherFactory url_fetcher_factory_;
+
+  // Sets up the task scheduling/task-runner environment for each test.
+  base::test::ScopedTaskScheduler scoped_task_scheduler_;
+
+  // Temporary directory for model files.
+  base::ScopedTempDir scoped_temp_dir_;
+
+  // Cache and reset the application locale for each test.
+  std::string locale_;
+
+  // Used to initialize the translate download manager.
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+
+  // A queue of responses to return from Validate(). If empty, validate will
+  // return 'OK'.
+  std::deque<RankerModelStatus> validate_response_;
+
+  // A cached to remember the model validation calls.
+  std::vector<RankerModel> validated_models_;
+
+  // A cache to remember the OnModelAvailable calls.
+  std::vector<RankerModel> available_models_;
+
+  // Cached model file paths.
+  base::FilePath local_model_path_;
+  base::FilePath expired_model_path_;
+  base::FilePath invalid_model_path_;
+
+  // Model URLS.
+  GURL remote_model_url_;
+  GURL invalid_model_url_;
+  GURL failed_model_url_;
+
+  // Model Data.
+  RankerModel remote_model_;
+  RankerModel local_model_;
+  RankerModel expired_model_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RankerModelLoaderTest);
+};
+
+}  // namespace
+
+TEST_F(RankerModelLoaderTest, NoLocalOrRemoteModel) {
+  ASSERT_TRUE(DoLoaderTest(base::FilePath(), GURL()));
+
+  ASSERT_EQ(0U, validated_models_.size());

[groby-ooo-7-16, 2017/02/14 20:56:48]

Nit: The last two should probably be EXPECT_EQ, not ASSERT_EQ

At least that's my understanding:
  ASSERT_* is a precondition for the test to even be able to run. EXPECT_* is
the expected outcome of a test. I.e. ASSERT a vector is not empty, so you can
EXPECT on the first value in it.

[Roger McFarlane (Chromium), 2017/02/21 22:16:51]

Done.

+  ASSERT_EQ(0U, available_models_.size());
+}
+
+TEST_F(RankerModelLoaderTest, BadLocalAndRemoteModel) {
+  ASSERT_TRUE(DoLoaderTest(invalid_model_path_, invalid_model_url_));
+
+  ASSERT_EQ(0U, validated_models_.size());
+  ASSERT_EQ(0U, available_models_.size());
+}
+
+TEST_F(RankerModelLoaderTest, LoadFromFileOnly) {
+  ASSERT_TRUE(DoLoaderTest(local_model_path_, GURL()));
+
+  ASSERT_EQ(1U, validated_models_.size());
+  ASSERT_EQ(1U, available_models_.size());
+  ASSERT_TRUE(IsEqual(validated_models_[0], local_model_));
+  ASSERT_TRUE(IsEqual(available_models_[0], local_model_));
+}
+
+TEST_F(RankerModelLoaderTest, LoadFromFileSkipsDownload) {
+  ASSERT_TRUE(DoLoaderTest(local_model_path_, remote_model_url_));
+
+  ASSERT_EQ(1U, validated_models_.size());
+  ASSERT_EQ(1U, available_models_.size());
+  ASSERT_TRUE(IsEqual(validated_models_[0], local_model_));
+  ASSERT_TRUE(IsEqual(available_models_[0], local_model_));
+}
+
+TEST_F(RankerModelLoaderTest, LoadFromFileAndBadUrl) {
+  ASSERT_TRUE(DoLoaderTest(local_model_path_, invalid_model_url_));
+  ASSERT_EQ(1U, validated_models_.size());
+  ASSERT_EQ(1U, available_models_.size());
+  ASSERT_TRUE(IsEqual(validated_models_[0], local_model_));
+  ASSERT_TRUE(IsEqual(available_models_[0], local_model_));
+}
+
+TEST_F(RankerModelLoaderTest, LoadFromURLOnly) {
+  ASSERT_TRUE(DoLoaderTest(base::FilePath(), remote_model_url_));
+  ASSERT_EQ(1U, validated_models_.size());
+  ASSERT_EQ(1U, available_models_.size());
+  ASSERT_TRUE(IsEquivalent(validated_models_[0], remote_model_));
+  ASSERT_TRUE(IsEquivalent(available_models_[0], remote_model_));
+}
+
+TEST_F(RankerModelLoaderTest, LoadFromExpiredFileTriggersDownload) {
+  ASSERT_TRUE(DoLoaderTest(expired_model_path_, remote_model_url_));
+  ASSERT_EQ(2U, validated_models_.size());
+  ASSERT_EQ(2U, available_models_.size());
+  ASSERT_TRUE(IsEquivalent(validated_models_[0], local_model_));
+  ASSERT_TRUE(IsEquivalent(available_models_[0], local_model_));
+  ASSERT_TRUE(IsEquivalent(validated_models_[1], remote_model_));
+  ASSERT_TRUE(IsEquivalent(available_models_[1], remote_model_));
+}
+
+TEST_F(RankerModelLoaderTest, LoadFromBadFileTriggersDownload) {
+  ASSERT_TRUE(DoLoaderTest(invalid_model_path_, remote_model_url_));
+  ASSERT_EQ(1U, validated_models_.size());
+  ASSERT_EQ(1U, available_models_.size());
+  ASSERT_TRUE(IsEquivalent(validated_models_[0], remote_model_));
+  ASSERT_TRUE(IsEquivalent(available_models_[0], remote_model_));
+}
+
+TEST_F(RankerModelLoaderTest, IncompatibleCachedFileTriggersDownload) {
+  validate_response_.push_back(RankerModelStatus::INCOMPATIBLE);
+
+  ASSERT_TRUE(DoLoaderTest(local_model_path_, remote_model_url_));
+  ASSERT_EQ(2U, validated_models_.size());
+  ASSERT_EQ(1U, available_models_.size());
+  ASSERT_TRUE(IsEquivalent(validated_models_[0], local_model_));
+  ASSERT_TRUE(IsEquivalent(validated_models_[1], remote_model_));
+  ASSERT_TRUE(IsEquivalent(available_models_[0], remote_model_));
+}
+
+TEST_F(RankerModelLoaderTest, IncompatibleDownloadedFileKeepsExpired) {
+  validate_response_.push_back(RankerModelStatus::OK);
+  validate_response_.push_back(RankerModelStatus::INCOMPATIBLE);
+
+  ASSERT_TRUE(DoLoaderTest(expired_model_path_, remote_model_url_));
+  ASSERT_EQ(2U, validated_models_.size());
+  ASSERT_EQ(1U, available_models_.size());
+  ASSERT_TRUE(IsEquivalent(validated_models_[0], local_model_));
+  ASSERT_TRUE(IsEquivalent(validated_models_[1], remote_model_));
+  ASSERT_TRUE(IsEquivalent(available_models_[0], local_model_));
+}