Add unit tests for Quick Answers search result parsers.

Bug: b/144800297
Test: unittests
Change-Id: I41066e4e7aaf69aea8878709bf7576d3eb923004
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1949732
Commit-Queue: Li Lin <llin@chromium.org>
Reviewed-by: Xiyuan Xia <xiyuan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#721806}

chromeos/components/BUILD.gn

@@ -24,6 +24,7 @@ test("chromeos_components_unittests") {
     "//chromeos/components/nearby:unit_tests",
     "//chromeos/components/power:unit_tests",
     "//chromeos/components/proximity_auth:unit_tests",
+    "//chromeos/components/quick_answers:unit_tests",
     "//chromeos/components/sync_wifi:unit_tests",
     "//chromeos/components/tether:unit_tests",
     "//mojo/core/embedder",

chromeos/components/quick_answers/BUILD.gn

@@ -18,7 +18,28 @@ source_set("quick_answers") {
   ]
   deps = [
     "//base",
+    "//net:net",
     "//services/data_decoder/public/cpp",
+    "//services/network/public/cpp:cpp",
     "//third_party/re2",
   ]
 }
+
+source_set("unit_tests") {
+  testonly = true
+
+  sources = [
+    "search_result_parsers/result_parser_unittest.cc",
+    "search_result_parsers/search_response_parser_unittest.cc",
+    "search_result_parsers/unit_conversion_result_parser_unittest.cc",
+  ]
+
+  deps = [
+    ":quick_answers",
+    "//base",
+    "//base/test:test_support",
+    "//services/data_decoder/public/cpp:test_support",
+    "//testing/gmock",
+    "//testing/gtest",
+  ]
+}

chromeos/components/quick_answers/quick_answers_model.h

@@ -10,6 +10,12 @@
 namespace chromeos {
 namespace quick_answers {
 
+// The type of the result. Valid values are map to the search result types.
+// Please see go/1ns-doc for more detail.
+enum class ResultType {
+  kUnitCconverterResult = 13668,
+};
+
 // Structure to describe a quick answer.
 struct QuickAnswer {
   std::string primary_answer;

chromeos/components/quick_answers/search_result_parsers/result_parser.cc

@@ -13,11 +13,6 @@ namespace {
 
 using base::Value;
 
-// The result type. Please see go/1ns-doc for more detail.
-enum {
-  kUnitCconverterResult = 13668,
-};
-
 }  // namespace
 
 const Value* ResultParser::GetFirstListElement(const Value& value,
@@ -40,8 +35,8 @@ const Value* ResultParser::GetFirstListElement(const Value& value,
 // static
 std::unique_ptr<ResultParser> ResultParserFactory::Create(
     int one_namespace_type) {
-  switch (one_namespace_type) {
-    case kUnitCconverterResult:
+  switch (static_cast<ResultType>(one_namespace_type)) {
+    case ResultType::kUnitCconverterResult:
       return std::make_unique<UnitConversionResultParser>();
       // TODO(llin): Add other result parsers.
   }

chromeos/components/quick_answers/search_result_parsers/result_parser.h

@@ -23,7 +23,7 @@ class ResultParser {
   virtual ~ResultParser() = default;
 
   // Parse the result into |quick_answer|.
-  virtual bool Parse(const base::Value* result, QuickAnswer* quick_answer);
+  virtual bool Parse(const base::Value* result, QuickAnswer* quick_answer) = 0;
 
  protected:
   // Helper function to get the first element in a value list.

chromeos/components/quick_answers/search_result_parsers/result_parser_unittest.cc

+// Copyright 2019 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 "chromeos/components/quick_answers/search_result_parsers/result_parser.h"
+
+#include <memory>
+#include <string>
+
+#include "chromeos/components/quick_answers/quick_answers_model.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace quick_answers {
+
+class ResultParserFactoryTest : public testing::Test {
+ public:
+  ResultParserFactoryTest()
+      : parser_factory_(std::make_unique<ResultParserFactory>()) {}
+
+  ResultParserFactoryTest(const ResultParserFactoryTest&) = delete;
+  ResultParserFactoryTest& operator=(const ResultParserFactoryTest&) = delete;
+
+ protected:
+  std::unique_ptr<ResultParserFactory> parser_factory_;
+};
+
+TEST_F(ResultParserFactoryTest, SupportedType) {
+  EXPECT_NE(nullptr, parser_factory_->Create(
+                         static_cast<int>(ResultType::kUnitCconverterResult)));
+}
+
+TEST_F(ResultParserFactoryTest, UnsupportedType) {
+  // 1 is a unsupported types.
+  int kUnsupportedType = 1;
+  EXPECT_EQ(nullptr, parser_factory_->Create(kUnsupportedType));
+}
+
+}  // namespace quick_answers
+}  // namespace chromeos
\ No newline at end of file

chromeos/components/quick_answers/search_result_parsers/search_response_parser.cc

@@ -37,9 +37,9 @@ void SearchResponseParser::ProcessResponse(
       response_body->substr(0, strlen(kJsonSafetyPrefix)) !=
           kJsonSafetyPrefix) {
     LOG(ERROR) << "Invalid search response.";
+    std::move(complete_callback_).Run(nullptr);
     return;
   }
-
   data_decoder::DataDecoder::ParseJsonIsolated(
       response_body->substr(strlen(kJsonSafetyPrefix)),
       base::BindOnce(&SearchResponseParser::OnJsonParsed,
@@ -52,21 +52,26 @@ void SearchResponseParser::OnJsonParsed(
 
   if (!result.value) {
     LOG(ERROR) << "JSON parsing failed: " << *result.error;
+    std::move(complete_callback_).Run(nullptr);
     return;
   }
 
-  auto quick_answer = std::make_unique<QuickAnswer>();
   // Get the first result.
   const Value* entries = result.value->FindListPath("results");
+  if (!entries) {
+    std::move(complete_callback_).Run(nullptr);
+    return;
+  }
 
-  if (entries) {
-    for (const auto& entry : entries->GetList()) {
-      if (ProcessResult(&entry, quick_answer.get()))
-        break;
+  for (const auto& entry : entries->GetList()) {
+    auto quick_answer = std::make_unique<QuickAnswer>();
+    if (ProcessResult(&entry, quick_answer.get())) {
+      std::move(complete_callback_).Run(std::move(quick_answer));
+      return;
     }
   }
 
-  std::move(complete_callback_).Run(std::move(quick_answer));
+  std::move(complete_callback_).Run(nullptr);
 }
 
 bool SearchResponseParser::ProcessResult(const Value* result,

chromeos/components/quick_answers/search_result_parsers/search_response_parser_unittest.cc

+// Copyright 2019 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 "chromeos/components/quick_answers/search_result_parsers/search_response_parser.h"
+
+#include <memory>
+#include <string>
+
+#include "base/run_loop.h"
+#include "base/test/task_environment.h"
+#include "chromeos/components/quick_answers/quick_answers_model.h"
+#include "services/data_decoder/public/cpp/test_support/in_process_data_decoder.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace quick_answers {
+
+class SearchResponseParserTest : public testing::Test {
+ public:
+  SearchResponseParserTest() = default;
+
+  SearchResponseParserTest(const SearchResponseParserTest&) = delete;
+  SearchResponseParserTest& operator=(const SearchResponseParserTest&) = delete;
+
+  void SetUp() override {
+    search_result_parser_ = std::make_unique<SearchResponseParser>(
+        base::BindOnce(&SearchResponseParserTest::SearchResponseParserCallback,
+                       base::Unretained(this)));
+    run_loop_ = std::make_unique<base::RunLoop>();
+  }
+
+  void SearchResponseParserCallback(std::unique_ptr<QuickAnswer> quick_answer) {
+    quick_answer_ = std::move(quick_answer);
+    run_loop_->Quit();
+  }
+
+  void WaitForResponse() { run_loop_->Run(); }
+
+ protected:
+  std::unique_ptr<SearchResponseParser> search_result_parser_;
+  std::unique_ptr<QuickAnswer> quick_answer_;
+  base::test::SingleThreadTaskEnvironment task_environment_;
+  data_decoder::test::InProcessDataDecoder in_process_data_decoder_;
+  std::unique_ptr<base::RunLoop> run_loop_;
+};
+
+TEST_F(SearchResponseParserTest, ProcessResponseSuccessFirstResult) {
+  constexpr char kSearchResponse[] = R"()]}'
+    {
+      "results": [
+        {
+          "oneNamespaceType": 13668,
+          "unitConversionResult": {
+            "source": {
+              "valueAndUnit": {
+                "rawText": "23 centimeters"
+              }
+            },
+            "destination": {
+              "valueAndUnit": {
+                "rawText": "9.055 inches"
+              }
+            }
+          }
+        }
+      ]
+    }
+  )";
+  search_result_parser_->ProcessResponse(
+      std::make_unique<std::string>(kSearchResponse));
+  WaitForResponse();
+  EXPECT_TRUE(quick_answer_);
+  EXPECT_EQ("9.055 inches", quick_answer_->primary_answer);
+}
+
+TEST_F(SearchResponseParserTest, ProcessResponseSuccessMultipleResults) {
+  constexpr char kSearchResponse[] = R"()]}'
+    {
+      "results": [
+        { "oneNamespaceType": 13666 },
+        { "oneNamespaceType": 13667 },
+        {
+          "oneNamespaceType": 13668,
+          "unitConversionResult": {
+            "source": {
+              "valueAndUnit": {
+                "rawText": "23 centimeters"
+              }
+            },
+            "destination": {
+              "valueAndUnit": {
+                "rawText": "9.055 inches"
+              }
+            }
+          }
+        }
+      ]
+    }
+  )";
+  search_result_parser_->ProcessResponse(
+      std::make_unique<std::string>(kSearchResponse));
+  WaitForResponse();
+  EXPECT_TRUE(quick_answer_);
+  EXPECT_EQ("9.055 inches", quick_answer_->primary_answer);
+}
+
+TEST_F(SearchResponseParserTest, ProcessResponseNoResults) {
+  // The empty line between the response body and XSSI prefix is intentional to
+  // keep it consistent with the actual response we got from the server.
+  constexpr char kSearchResponse[] = R"()]}'
+
+    {}
+  )";
+  search_result_parser_->ProcessResponse(
+      std::make_unique<std::string>(kSearchResponse));
+  WaitForResponse();
+  EXPECT_EQ(nullptr, quick_answer_);
+}
+
+TEST_F(SearchResponseParserTest, ProcessResponseEmptyResults) {
+  constexpr char kSearchResponse[] = R"()]}'
+
+    { "results": [] }
+  )";
+  search_result_parser_->ProcessResponse(
+      std::make_unique<std::string>(kSearchResponse));
+  WaitForResponse();
+  EXPECT_EQ(nullptr, quick_answer_);
+}
+
+TEST_F(SearchResponseParserTest, ProcessResponseInvalidResponse) {
+  search_result_parser_->ProcessResponse(
+      std::make_unique<std::string>("results {}"));
+  WaitForResponse();
+  EXPECT_FALSE(quick_answer_);
+}
+
+TEST_F(SearchResponseParserTest, ProcessResponseInvalidXssiPrefix) {
+  constexpr char kSearchResponse[] = R"()]'
+
+    {}
+  )";
+  search_result_parser_->ProcessResponse(
+      std::make_unique<std::string>(kSearchResponse));
+  WaitForResponse();
+  EXPECT_FALSE(quick_answer_);
+}
+
+}  // namespace quick_answers
+}  // namespace chromeos
\ No newline at end of file

chromeos/components/quick_answers/search_result_parsers/unit_conversion_result_parser_unittest.cc

+// Copyright 2019 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 "chromeos/components/quick_answers/search_result_parsers/unit_conversion_result_parser.h"
+
+#include <memory>
+#include <string>
+
+#include "base/values.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace quick_answers {
+namespace {
+
+using base::Value;
+
+}
+
+class UnitConversionResultParserTest : public testing::Test {
+ public:
+  UnitConversionResultParserTest()
+      : parser_(std::make_unique<UnitConversionResultParser>()) {}
+
+  UnitConversionResultParserTest(const UnitConversionResultParserTest&) =
+      delete;
+  UnitConversionResultParserTest& operator=(
+      const UnitConversionResultParserTest&) = delete;
+
+ protected:
+  std::unique_ptr<UnitConversionResultParser> parser_;
+};
+
+TEST_F(UnitConversionResultParserTest, Success) {
+  Value result(Value::Type::DICTIONARY);
+  result.SetStringPath("unitConversionResult.destination.valueAndUnit.rawText",
+                       "9.84252 inch");
+
+  QuickAnswer quick_answer;
+
+  EXPECT_TRUE(parser_->Parse(&result, &quick_answer));
+  EXPECT_EQ("9.84252 inch", quick_answer.primary_answer);
+  EXPECT_TRUE(quick_answer.secondary_answer.empty());
+}
+
+TEST_F(UnitConversionResultParserTest, EmptyValue) {
+  Value result(Value::Type::DICTIONARY);
+  QuickAnswer quick_answer;
+  EXPECT_FALSE(parser_->Parse(&result, &quick_answer));
+}
+
+TEST_F(UnitConversionResultParserTest, IncorrectType) {
+  Value result(Value::Type::DICTIONARY);
+  result.SetIntPath("unitConversionResult.destination.valueAndUnit.rawText", 1);
+  QuickAnswer quick_answer;
+  EXPECT_FALSE(parser_->Parse(&result, &quick_answer));
+}
+
+TEST_F(UnitConversionResultParserTest, IncorrectPath) {
+  Value result(Value::Type::DICTIONARY);
+  result.SetStringPath("unitConversionResult.destination.valueAndUnit.text",
+                       "9.84252 inch");
+  QuickAnswer quick_answer;
+  EXPECT_FALSE(parser_->Parse(&result, &quick_answer));
+}
+
+}  // namespace quick_answers
+}  // namespace chromeos
\ No newline at end of file