zip: Add ZipReader and rework Unzip() using the new class.

chrome/common/zip_reader_unittest.cc

+// Copyright (c) 2011 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 "chrome/common/zip_reader.h"
+
+#include <set>
+#include <string>
+
+#include "base/file_util.h"
+#include "base/md5.h"
+#include "base/path_service.h"
+#include "base/scoped_temp_dir.h"
+#include "base/time.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/zip_internal.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+namespace zip {
+
+// Make the test a PlatformTest to setup autorelease pools properly on Mac.
+class ZipReaderTest : public PlatformTest {
+ protected:
+  virtual void SetUp() {
+    PlatformTest::SetUp();
+
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    test_dir_ = temp_dir_.path();
+
+    ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_));
+    test_data_dir_ = test_data_dir_.AppendASCII("zip");
+
+    test_zip_file_ = test_data_dir_.AppendASCII("test.zip");
+    evil_zip_file_ = test_data_dir_.AppendASCII("evil.zip");
+    evil_via_invalid_utf8_zip_file_ = test_data_dir_.AppendASCII(
+        "evil_via_invalid_utf8.zip");
+
+    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/")));
+    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/")));
+    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/baz.txt")));
+    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/quux.txt")));
+    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar.txt")));
+    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo.txt")));
+    test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/.hidden")));
+  }
+
+  virtual void TearDown() {
+    PlatformTest::TearDown();
+  }
+
+  // The path to temporary directory used to contain the test operations.
+  FilePath test_dir_;
+  // The path to the test data directory where test.zip etc. are located.
+  FilePath test_data_dir_;
+  // The path to test.zip in the test data directory.
+  FilePath test_zip_file_;
+  // The path to evil.zip in the test data directory.
+  FilePath evil_zip_file_;
+  // The path to evil_via_invalid_utf8.zip in the test data directory.
+  FilePath evil_via_invalid_utf8_zip_file_;
+  std::set<FilePath> test_zip_contents_;
+
+  ScopedTempDir temp_dir_;
+};
+
+TEST_F(ZipReaderTest, Open_ValidZipFile) {
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+}
+
+TEST_F(ZipReaderTest, Open_NonExistentFile) {
+  ZipReader reader;
+  ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("nonexistent.zip")));
+}
+
+TEST_F(ZipReaderTest, Open_ExistentButNonZipFile) {
+  ZipReader reader;
+  ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("create_test_zip.sh")));
+}
+
+// Iterate through the contents in the test zip file, and compare that the
+// contents collected from the zip reader matches the expected contents.
+TEST_F(ZipReaderTest, Iteration) {
+  std::set<FilePath> actual_contents;
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  while (reader.HasMore()) {
+    ASSERT_TRUE(reader.OpenCurrentFileInZip());
+    actual_contents.insert(reader.current_file_info()->file_path());
+    ASSERT_TRUE(reader.AdvanceToNextFile());
+  }
+  EXPECT_FALSE(reader.AdvanceToNextFile());  // Shouldn't go further.
+  EXPECT_EQ(test_zip_contents_.size(),
+            static_cast<size_t>(reader.num_files()));
+  EXPECT_EQ(test_zip_contents_.size(), actual_contents.size());
+  EXPECT_EQ(test_zip_contents_, actual_contents);
+}
+
+
+TEST_F(ZipReaderTest, LocateAndOpenFile_ValidFile) {
+  std::set<FilePath> actual_contents;
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ASSERT_TRUE(reader.LocateAndOpenFile(target_path));
+  EXPECT_EQ(target_path, reader.current_file_info()->file_path());
+}
+
+TEST_F(ZipReaderTest, LocateAndOpenFile_NonExistentFile) {
+  std::set<FilePath> actual_contents;
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL("nonexistent.txt"));
+  ASSERT_FALSE(reader.LocateAndOpenFile(target_path));
+  EXPECT_EQ(NULL, reader.current_file_info());
+}
+
+TEST_F(ZipReaderTest, ExtractCurrentFileToFile_RegularFile) {
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ASSERT_TRUE(reader.LocateAndOpenFile(target_path));
+  ASSERT_TRUE(reader.ExtractCurrentFileToFile(
+      test_dir_.AppendASCII("quux.txt")));
+  // Read the output file ans compute the MD5.
+  std::string output;
+  ASSERT_TRUE(file_util::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
+                                          &output));
+  const std::string md5 = base::MD5String(output);
+  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
+  EXPECT_EQ(kExpectedMD5, md5);
+  // quux.txt should be larger than kZipBufSize so that we can exercise
+  // the loop in ExtractCurrentFile().
+  EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
+}
+
+TEST_F(ZipReaderTest, ExtractCurrentFileToFile_Directory) {
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL("foo/"));
+  ASSERT_TRUE(reader.LocateAndOpenFile(target_path));
+  ASSERT_TRUE(reader.ExtractCurrentFileToFile(test_dir_.AppendASCII("foo")));
+  // The directory should be created.
+  ASSERT_TRUE(file_util::DirectoryExists(test_dir_.AppendASCII("foo")));
+}
+
+TEST_F(ZipReaderTest, ExtractCurrentFileToDirectory_RegularFile) {
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ASSERT_TRUE(reader.LocateAndOpenFile(target_path));
+  ASSERT_TRUE(reader.ExtractCurrentFileToDirectory(test_dir_));
+  // Sub directories should be created.
+  ASSERT_TRUE(file_util::DirectoryExists(test_dir_.AppendASCII("foo/bar")));
+  // And the file should be created.
+  std::string output;
+  ASSERT_TRUE(file_util::ReadFileToString(
+      test_dir_.AppendASCII("foo/bar/quux.txt"), &output));
+  const std::string md5 = base::MD5String(output);
+  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
+  EXPECT_EQ(kExpectedMD5, md5);
+}
+
+TEST_F(ZipReaderTest, current_file_info_RegularFile) {
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ASSERT_TRUE(reader.LocateAndOpenFile(target_path));
+  ZipReader::FileInfo* current_file_info = reader.current_file_info();
+
+  EXPECT_EQ(target_path, current_file_info->file_path());
+  EXPECT_EQ(13527, current_file_info->original_size());
+
+  // The expected time stamp: 2009-05-29 06:22:20
+  base::Time::Exploded exploded = {};  // Zero-clear.
+  current_file_info->last_modified().LocalExplode(&exploded);
+  EXPECT_EQ(2009, exploded.year);
+  EXPECT_EQ(5, exploded.month);
+  EXPECT_EQ(29, exploded.day_of_month);
+  EXPECT_EQ(6, exploded.hour);
+  EXPECT_EQ(22, exploded.minute);
+  EXPECT_EQ(20, exploded.second);
+  EXPECT_EQ(0, exploded.millisecond);
+
+  EXPECT_FALSE(current_file_info->is_unsafe());
+  EXPECT_FALSE(current_file_info->is_directory());
+}
+
+TEST_F(ZipReaderTest, current_file_info_DotDotFile) {
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(evil_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL(
+      "../levilevilevilevilevilevilevilevilevilevilevilevil"));
+  ASSERT_TRUE(reader.LocateAndOpenFile(target_path));
+  ZipReader::FileInfo* current_file_info = reader.current_file_info();
+  EXPECT_EQ(target_path, current_file_info->file_path());
+
+  // This file is unsafe because of ".." in the file name.
+  EXPECT_TRUE(current_file_info->is_unsafe());
+  EXPECT_FALSE(current_file_info->is_directory());
+}
+
+TEST_F(ZipReaderTest, current_file_info_InvalidUTF8File) {
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(evil_via_invalid_utf8_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL(".\x80.\\evil.txt"));
+  ASSERT_TRUE(reader.LocateAndOpenFile(target_path));
+  ZipReader::FileInfo* current_file_info = reader.current_file_info();
+  EXPECT_EQ(target_path, current_file_info->file_path());
+
+  // This file is unsafe because of invalid UTF-8 in the file name.
+  EXPECT_TRUE(current_file_info->is_unsafe());
+  EXPECT_FALSE(current_file_info->is_directory());
+}
+
+TEST_F(ZipReaderTest, current_file_info_Directory) {
+  ZipReader reader;
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  FilePath target_path(FILE_PATH_LITERAL("foo/bar/"));
+  ASSERT_TRUE(reader.LocateAndOpenFile(target_path));
+  ZipReader::FileInfo* current_file_info = reader.current_file_info();
+
+  EXPECT_EQ(FilePath(FILE_PATH_LITERAL("foo/bar/")),
+            current_file_info->file_path());
+  // The directory size should be zero.
+  EXPECT_EQ(0, current_file_info->original_size());
+
+  // The expected time stamp: 2009-05-31 15:49:52
+  base::Time::Exploded exploded = {};  // Zero-clear.
+  current_file_info->last_modified().LocalExplode(&exploded);
+  EXPECT_EQ(2009, exploded.year);
+  EXPECT_EQ(5, exploded.month);
+  EXPECT_EQ(31, exploded.day_of_month);
+  EXPECT_EQ(15, exploded.hour);
+  EXPECT_EQ(49, exploded.minute);
+  EXPECT_EQ(52, exploded.second);
+  EXPECT_EQ(0, exploded.millisecond);
+
+  EXPECT_FALSE(current_file_info->is_unsafe());
+  EXPECT_TRUE(current_file_info->is_directory());
+}
+
+}  // namespace zip