Modularize Compact Language Detector 2 (CLD2) data sources

chrome/browser/component_updater/test/cld_component_installer_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.

[Takashi Toyoshima, 2014/06/23 08:50:00]

Now this file is compiled only when cld2_data_source is "component".
If your module is independent from others enough, you may be able to run these
unit tests even with other configurations. Is it difficult? If possible, it
would be helpful to avoid someone mistakenly breaks "component" mode.

[Andrew Hayden (chromium.org), 2014/06/23 13:20:35]

It's not independent anymore. Now that we've inverted control and made the
component installer responsible for configuring the code in
components/translate, there's no simple way to have this be isolated from that
code. We could add fakes or mocks and stub out functionality in the component
installer, but I feel like the ROI there isn't worth it. We should strive to get
the component updater stuff into all the desktop platforms instead, I think,
which will get all of dynamic mode turned on in many bot pipelines.

[Takashi Toyoshima, 2014/06/24 02:09:47]

I see.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/component_updater/cld_component_installer.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
+#include "components/translate/content/browser/data_file_browser_cld_data_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace component_updater {
 
 class CldComponentInstallerTest : public PlatformTest {
  public:
   virtual void SetUp() OVERRIDE {
     PlatformTest::SetUp();
 
     // ScopedTempDir automatically does a recursive delete on the entire
     // directory in its destructor, so no cleanup is required in TearDown.
     // Note that all files created by this test case are created within the
     // directory that is created here, so even though they are not explicitly
     // created *as temp files*, they will still get cleaned up automagically.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
+    cld_data_file_name =
+        component_updater::CldComponentInstallerTraits::GetCldDataFileName();
+
     // The "latest CLD data file" is a static piece of information, and thus
     // for correctness we empty it before each test.
     traits.SetLatestCldDataFile(base::FilePath());
   }
 

[Takashi Toyoshima, 2014/06/23 08:50:00]

following members can be protected.

[Andrew Hayden (chromium.org), 2014/06/23 13:20:35]

Done.

+  const base::FilePath::CharType* cld_data_file_name;

[Takashi Toyoshima, 2014/06/23 08:50:00]

cld_data_file_name_

[Andrew Hayden (chromium.org), 2014/06/23 13:20:35]

Now that I've removed the getter from cld_component_installer, I've just made
this a constant.

   base::ScopedTempDir temp_dir_;
   component_updater::CldComponentInstallerTraits traits;

[Takashi Toyoshima, 2014/06/23 08:50:00]

traits_

[Andrew Hayden (chromium.org), 2014/06/23 13:20:34]

Done.

 };

[Takashi Toyoshima, 2014/06/23 08:50:00]

DISALLOW_...

[Andrew Hayden (chromium.org), 2014/06/23 13:20:34]

Done.

 
 TEST_F(CldComponentInstallerTest, SetLatestCldDataFile) {
-  ASSERT_TRUE(component_updater::GetLatestCldDataFile().empty());

[Takashi Toyoshima, 2014/06/23 08:50:00]

I'm not sure it is worth doing, but this check can be moved inside SetUp() just
before calling SetLatestCldDataFile().

[Andrew Hayden (chromium.org), 2014/06/23 13:20:35]

Added equivalent check to setup.

   const base::FilePath expected(FILE_PATH_LITERAL("test/foo.test"));
   traits.SetLatestCldDataFile(expected);
 
-  base::FilePath result = component_updater::GetLatestCldDataFile();
+  base::FilePath result =
+      translate::DataFileBrowserCldDataProvider::GetCldDataFilePath();
   ASSERT_EQ(expected, result);
 }
 
 TEST_F(CldComponentInstallerTest, VerifyInstallation) {
   // All files are created within a ScopedTempDir, which deletes all
   // children when its destructor is called (at the end of each test).
   ASSERT_FALSE(traits.VerifyInstallation(temp_dir_.path()));
   const base::FilePath data_file_dir =
       temp_dir_.path().Append(FILE_PATH_LITERAL("_platform_specific")).Append(
           FILE_PATH_LITERAL("all"));
   ASSERT_TRUE(base::CreateDirectory(data_file_dir));
   const base::FilePath data_file =

[Takashi Toyoshima, 2014/06/23 08:50:00]

no line break

[Andrew Hayden (chromium.org), 2014/06/23 13:20:35]

Done.

-      data_file_dir.Append(chrome::kCLDDataFilename);
+      data_file_dir.Append(cld_data_file_name);
   const std::string test_data("fake cld2 data file content here :)");
   ASSERT_EQ(static_cast<int32>(test_data.length()),
             base::WriteFile(data_file, test_data.c_str(), test_data.length()));
   ASSERT_TRUE(traits.VerifyInstallation(temp_dir_.path()));
 }
 
 TEST_F(CldComponentInstallerTest, OnCustomInstall) {
   const base::DictionaryValue manifest;
   const base::FilePath install_dir;
   // Sanity: shouldn't crash.
   ASSERT_TRUE(traits.OnCustomInstall(manifest, install_dir));
 }
 
 TEST_F(CldComponentInstallerTest, GetInstalledPath) {
   const base::FilePath base_dir;
   const base::FilePath result =
       CldComponentInstallerTraits::GetInstalledPath(base_dir);
-  ASSERT_TRUE(EndsWith(result.value(), chrome::kCLDDataFilename, true));
+  ASSERT_TRUE(EndsWith(result.value(), cld_data_file_name, true));
 }
 
 TEST_F(CldComponentInstallerTest, GetBaseDirectory) {
   const base::FilePath result = traits.GetBaseDirectory();
   ASSERT_FALSE(result.empty());
 }
 
 TEST_F(CldComponentInstallerTest, GetHash) {
   std::vector<uint8> hash;
   traits.GetHash(&hash);
   ASSERT_EQ(static_cast<size_t>(32), hash.size());
 }
 
 TEST_F(CldComponentInstallerTest, GetName) {
   ASSERT_FALSE(traits.GetName().empty());
 }
 
 TEST_F(CldComponentInstallerTest, ComponentReady) {
   scoped_ptr<base::DictionaryValue> manifest;
   const base::FilePath install_dir(FILE_PATH_LITERAL("/foo"));
   const base::Version version("1.2.3.4");
   traits.ComponentReady(version, install_dir, manifest.Pass());
-  base::FilePath result = component_updater::GetLatestCldDataFile();
+  base::FilePath result =
+      translate::DataFileBrowserCldDataProvider::GetCldDataFilePath();
   ASSERT_TRUE(StartsWith(result.AsUTF16Unsafe(),
                          install_dir.AsUTF16Unsafe(),
                          true));
-  ASSERT_TRUE(EndsWith(result.value(), chrome::kCLDDataFilename, true));
+  ASSERT_TRUE(EndsWith(result.value(), cld_data_file_name, true));
 }
 
 }  // namespace component_updater