gdrive: Get JSON feeds parsing off the UI thread.

chrome/browser/chromeos/gdata/gdata_operations_unittest.cc

+// Copyright (c) 2012 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 "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/values.h"
+#include "chrome/browser/chromeos/gdata/gdata_operations.h"
+#include "chrome/browser/chromeos/gdata/gdata_operation_runner.h"
+#include "chrome/browser/chromeos/gdata/gdata_test_util.h"
+#include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_browser_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gdata {
+
+namespace {
+
+class JsonParseTestGetDataOperation : public GetDataOperation {
+ public:
+  JsonParseTestGetDataOperation(GDataOperationRegistry* registry,
+                                Profile* profile,
+                                const GetDataCallback& callback)
+      : GetDataOperation(registry, profile, callback) {
+  }
+
+  virtual ~JsonParseTestGetDataOperation() {
+  }
+
+  void NotifyStart() {
+    NotifyStartToOperationRegistry();
+  }
+
+  void NotifySuccess() {
+    NotifySuccessToOperationRegistry();
+  }
+
+  void NotifyFailure() {
+    NotifyFinish(GDataOperationRegistry::OPERATION_FAILED);
+  }
+
+ protected:
+  // GetDataOperation overrides:
+  virtual GURL GetURL() const OVERRIDE {
+    // This method is never called because this test does not fetch json from
+    // network.
+    NOTREACHED();
+    return GURL();
+  }
+};
+
+void GetDataOperationParseJsonCallback(GDataErrorCode* error_out,
+                                       scoped_ptr<base::Value>* value_out,
+                                       GDataErrorCode error_in,
+                                       scoped_ptr<base::Value> value_in) {
+  value_out->swap(value_in);
+  *error_out = error_in;
+}
+
+void ParseResponseResultCallback(bool* result_out,
+                                 bool result_in) {
+  *result_out = result_in;
+}
+
+}  // namespace
+
+class GDataOperationsTest : public testing::Test {
+ protected:
+  GDataOperationsTest()
+      : ui_thread_(content::BrowserThread::UI, &message_loop_) {
+  }
+
+  virtual void SetUp() OVERRIDE {
+    profile_.reset(new TestingProfile);
+    runner_.reset(new GDataOperationRunner(profile_.get()));
+    runner_->Initialize();
+  }
+
+ protected:
+  MessageLoopForUI message_loop_;
+  content::TestBrowserThread ui_thread_;
+  scoped_ptr<TestingProfile> profile_;
+  scoped_ptr<GDataOperationRunner> runner_;
+};
+
+TEST_F(GDataOperationsTest, GetDataOperationParseJson) {
+  scoped_ptr<base::Value> value;
+  GDataErrorCode error;
+  gdata::GetDataCallback cb = base::Bind(&GetDataOperationParseJsonCallback,
+                                         &error,
+                                         &value);
+  JsonParseTestGetDataOperation* getData =
+      new JsonParseTestGetDataOperation(runner_->operation_registry(),
+                                        profile_.get(),
+                                        cb);
+  getData->NotifyStart();
+
+  // Parses a valid json string.
+  {
+    std::string valid_json_str =
+        "{"
+        "  \"test\": {"
+        "    \"foo\": true,"
+        "    \"bar\": 3.14,"
+        "    \"baz\": \"bat\","
+        "    \"moo\": \"cow\""
+        "  },"
+        "  \"list\": ["
+        "    \"a\","
+        "    \"b\""
+        "  ]"
+        "}";
+
+    bool parse_result = false;
+    getData->ParseResponse(HTTP_SUCCESS,
+                           valid_json_str,
+                           base::Bind(&ParseResponseResultCallback,
+                                      &parse_result));
+    test_util::RunBlockingPoolTask();
+
+    EXPECT_EQ(HTTP_SUCCESS, error);
+    ASSERT_TRUE(value.get());
+    EXPECT_TRUE(parse_result);
+
+    DictionaryValue* root_dict = NULL;
+    ASSERT_TRUE(value->GetAsDictionary(&root_dict));
+
+    DictionaryValue* dict = NULL;
+    ListValue* list = NULL;
+    ASSERT_TRUE(root_dict->GetDictionary("test", &dict));
+    ASSERT_TRUE(root_dict->GetList("list", &list));
+
+    Value* dict_literals[2] = {0};
+    Value* dict_strings[2] = {0};
+    Value* list_values[2] = {0};
+    EXPECT_TRUE(dict->Get("foo", &dict_literals[0]));
+    EXPECT_TRUE(dict->Get("bar", &dict_literals[1]));
+    EXPECT_TRUE(dict->Get("baz", &dict_strings[0]));
+    EXPECT_TRUE(dict->Get("moo", &dict_strings[1]));
+    ASSERT_EQ(2u, list->GetSize());
+    EXPECT_TRUE(list->Get(0, &list_values[0]));
+    EXPECT_TRUE(list->Get(1, &list_values[1]));
+
+    bool b = false;
+    double d = 0;
+    std::string s;
+    EXPECT_TRUE(dict_literals[0]->GetAsBoolean(&b));
+    EXPECT_TRUE(b);
+    EXPECT_TRUE(dict_literals[1]->GetAsDouble(&d));
+    EXPECT_EQ(3.14, d);
+    EXPECT_TRUE(dict_strings[0]->GetAsString(&s));
+    EXPECT_EQ("bat", s);
+    EXPECT_TRUE(dict_strings[1]->GetAsString(&s));
+    EXPECT_EQ("cow", s);
+    EXPECT_TRUE(list_values[0]->GetAsString(&s));
+    EXPECT_EQ("a", s);
+    EXPECT_TRUE(list_values[1]->GetAsString(&s));
+    EXPECT_EQ("b", s);
+  }
+
+  getData->NotifySuccess();
+}
+
+TEST_F(GDataOperationsTest, GetDataOperationParseInvalidJson) {
+  scoped_ptr<base::Value> value;
+  GDataErrorCode error;
+  gdata::GetDataCallback cb = base::Bind(&GetDataOperationParseJsonCallback,
+                                         &error,
+                                         &value);
+  JsonParseTestGetDataOperation* getData =
+      new JsonParseTestGetDataOperation(runner_->operation_registry(),
+                                        profile_.get(),
+                                        cb);
+  getData->NotifyStart();
+
+  // Parses an invalid json string.
+  {
+    std::string invalid_json_str =
+        "/* hogehoge *"
+        "  \"test\": {"
+        "    \"moo\": \"cow"
+        "  "
+        "  \"list\": ["
+        "    \"foo\","
+        "    \"bar\""
+        "  ]";
+
+    bool parse_result = true;
+    getData->ParseResponse(HTTP_SUCCESS,
+                           invalid_json_str,
+                           base::Bind(&ParseResponseResultCallback,
+                                      &parse_result));
+    test_util::RunBlockingPoolTask();
+
+    ASSERT_TRUE(value.get() == NULL);
+    EXPECT_EQ(GDATA_PARSE_ERROR, error);
+
+    EXPECT_FALSE(parse_result);
+  }
+
+  getData->NotifyFailure();
+}
+
+} // namespace gdata