Add anonymizer tool

components/feedback/feedback_common_unittest.cc

 // Copyright 2014 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/feedback/feedback_common.h"
 
 #include "base/bind.h"
+#include "base/files/scoped_temp_dir.h"
 #include "components/feedback/proto/common.pb.h"
 #include "components/feedback/proto/dom.pb.h"
 #include "components/feedback/proto/extension.pb.h"
 #include "components/feedback/proto/math.pb.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/zlib/google/zip.h"
 
 namespace {
 const char kOne[] = "one";
 const char kTwo[] = "two";
 const char kThree[] = "three";
 const char kFour[] = "four";
 #define TEN_LINES "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n"
 const char kLongLog[] = TEN_LINES TEN_LINES TEN_LINES TEN_LINES TEN_LINES;
 const char kLogsAttachmentName[] = "system_logs.zip";
+const char kLogsFilename[] = "system_logs.txt";
 }  // namespace
 
 class FeedbackCommonTest : public testing::Test {
  protected:
   FeedbackCommonTest() {
-    feedback = scoped_refptr<FeedbackCommon>(new FeedbackCommon());
+    feedback_ = scoped_refptr<FeedbackCommon>(new FeedbackCommon());
   }
 
   ~FeedbackCommonTest() override {}
 
-  scoped_refptr<FeedbackCommon> feedback;
-  userfeedback::ExtensionSubmit report;
+  scoped_refptr<FeedbackCommon> feedback_;
+  userfeedback::ExtensionSubmit report_;
 };
 
 TEST_F(FeedbackCommonTest, TestBasicData) {
   // Test that basic data can be set and propagates to the request.
-  feedback->set_category_tag(kOne);
-  feedback->set_description(kTwo);
-  feedback->set_page_url(kThree);
-  feedback->set_user_email(kFour);
-  feedback->PrepareReport(&report);
+  feedback_->set_category_tag(kOne);
+  feedback_->set_description(kTwo);
+  feedback_->set_page_url(kThree);
+  feedback_->set_user_email(kFour);
+  feedback_->PrepareReport(&report_);
 
-  EXPECT_EQ(kOne, report.bucket());
-  EXPECT_EQ(kTwo, report.common_data().description());
-  EXPECT_EQ(kThree, report.web_data().url());
-  EXPECT_EQ(kFour, report.common_data().user_email());
+  EXPECT_EQ(kOne, report_.bucket());
+  EXPECT_EQ(kTwo, report_.common_data().description());
+  EXPECT_EQ(kThree, report_.web_data().url());
+  EXPECT_EQ(kFour, report_.common_data().user_email());
 }
 
 TEST_F(FeedbackCommonTest, TestAddLogs) {
-  feedback->AddLog(kOne, kTwo);
-  feedback->AddLog(kThree, kFour);
+  feedback_->AddLog(kOne, kTwo);
+  feedback_->AddLog(kThree, kFour);
 
-  EXPECT_EQ(2U, feedback->sys_info()->size());
+  EXPECT_EQ(2U, feedback_->sys_info()->size());
 }
 
 TEST_F(FeedbackCommonTest, TestCompressionThreshold) {
   // Add a large and small log, verify that only the small log gets
   // included in the report.
-  feedback->AddLog(kOne, kTwo);
-  feedback->AddLog(kThree, kLongLog);
-  feedback->PrepareReport(&report);
+  feedback_->AddLog(kOne, kTwo);
+  feedback_->AddLog(kThree, kLongLog);
+  feedback_->PrepareReport(&report_);
 
-  EXPECT_EQ(1, report.web_data().product_specific_data_size());
-  EXPECT_EQ(kOne, report.web_data().product_specific_data(0).key());
+  EXPECT_EQ(1, report_.web_data().product_specific_data_size());
+  EXPECT_EQ(kOne, report_.web_data().product_specific_data(0).key());
 }
 
 TEST_F(FeedbackCommonTest, TestCompression) {
   // Add a large and small log, verify that an attachment has been
   // added with the right name.
-  feedback->AddLog(kOne, kTwo);
-  feedback->AddLog(kThree, kLongLog);
-  feedback->CompressLogs();
-  feedback->PrepareReport(&report);
+  feedback_->AddLog(kOne, kTwo);
+  feedback_->AddLog(kThree, kLongLog);
+  feedback_->CompressLogs();
+  feedback_->PrepareReport(&report_);
 
-  EXPECT_EQ(1, report.product_specific_binary_data_size());
-  EXPECT_EQ(kLogsAttachmentName, report.product_specific_binary_data(0).name());
+  EXPECT_EQ(1, report_.product_specific_binary_data_size());
+  EXPECT_EQ(kLogsAttachmentName,
+            report_.product_specific_binary_data(0).name());
 }
+
+TEST_F(FeedbackCommonTest, TestAddLogsAnonymization) {
+  std::string mac_address = "Some text 00:11:22:33:44:55 text";
+  std::string anonymized_mac_address = "Some text 00:11:22:00:00:01 text";
+  feedback_->AddLog(kOne, mac_address);
+  feedback_->AddLog(kThree, mac_address + kLongLog);
+  feedback_->CompressLogs();
+  feedback_->PrepareReport(&report_);
+
+  // Verify that uncompressed data is anonymized.
+  ASSERT_EQ(1, report_.web_data().product_specific_data_size());
+  EXPECT_EQ(anonymized_mac_address,
+            report_.web_data().product_specific_data(0).value());
+
+  // Verify that compressed data is anonymized.
+  ASSERT_EQ(1, report_.product_specific_binary_data_size());
+  const ::userfeedback::ProductSpecificBinaryData& binary_data =
+      report_.product_specific_binary_data(0);
+
+  base::ScopedTempDir scoped_dir;
+  ASSERT_TRUE(scoped_dir.CreateUniqueTempDir());
+  base::FilePath zip_file = scoped_dir.path().Append("logs.zip");
+
+  ASSERT_TRUE(binary_data.has_data());
+  bool success = base::WriteFile(zip_file, binary_data.data().data(),
+                                 binary_data.data().size());
+  ASSERT_TRUE(success);
+  success = zip::Unzip(zip_file, scoped_dir.path());
+  ASSERT_TRUE(success);
+
+  std::string file_content;
+  success = base::ReadFileToString(scoped_dir.path().Append(kLogsFilename),
+                                   &file_content);
+  ASSERT_TRUE(success);
+
+  EXPECT_TRUE(file_content.find(anonymized_mac_address) != std::string::npos);
+  EXPECT_TRUE(file_content.find(mac_address) == std::string::npos);
+}