web_ui_data_source_unittest.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/bind.h"
6#include "base/memory/ref_counted_memory.h"
7#include "base/strings/utf_string_conversions.h"
8#include "content/browser/webui/web_ui_data_source_impl.h"
9#include "content/test/test_content_client.h"
10#include "testing/gtest/include/gtest/gtest.h"
11
12namespace content {
13namespace {
14
15const int kDummyStringId = 123;
16const int kDummyDefaultResourceId = 456;
17const int kDummyResourceId = 789;
18
19const char kDummyString[] = "foo";
20const char kDummyDefaultResource[] = "<html>foo</html>";
21const char kDummytResource[] = "<html>blah</html>";
22
23class TestClient : public TestContentClient {
24 public:
25  TestClient() {}
26  virtual ~TestClient() {}
27
28  virtual base::string16 GetLocalizedString(int message_id) const OVERRIDE {
29    if (message_id == kDummyStringId)
30      return base::UTF8ToUTF16(kDummyString);
31    return base::string16();
32
33  }
34
35  virtual base::RefCountedStaticMemory* GetDataResourceBytes(
36      int resource_id) const OVERRIDE {
37    base::RefCountedStaticMemory* bytes = NULL;
38    if (resource_id == kDummyDefaultResourceId) {
39      bytes = new base::RefCountedStaticMemory(
40          kDummyDefaultResource, arraysize(kDummyDefaultResource));
41    } else if (resource_id == kDummyResourceId) {
42      bytes = new base::RefCountedStaticMemory(
43          kDummytResource, arraysize(kDummytResource));
44    }
45    return bytes;
46  }
47};
48
49}
50
51class WebUIDataSourceTest : public testing::Test {
52 public:
53  WebUIDataSourceTest() : result_data_(NULL) {}
54  virtual ~WebUIDataSourceTest() {}
55  WebUIDataSourceImpl* source() { return source_.get(); }
56
57  void StartDataRequest(const std::string& path) {
58     source_->StartDataRequest(
59        path,
60        0, 0,
61        base::Bind(&WebUIDataSourceTest::SendResult,
62        base::Unretained(this)));
63  }
64
65  std::string GetMimeType(const std::string& path) const {
66    return source_->GetMimeType(path);
67  }
68
69  scoped_refptr<base::RefCountedMemory> result_data_;
70
71 private:
72  virtual void SetUp() {
73    SetContentClient(&client_);
74    WebUIDataSource* source = WebUIDataSourceImpl::Create("host");
75    WebUIDataSourceImpl* source_impl = static_cast<WebUIDataSourceImpl*>(
76        source);
77    source_impl->disable_set_font_strings_for_testing();
78    source_ = make_scoped_refptr(source_impl);
79  }
80
81  // Store response for later comparisons.
82  void SendResult(base::RefCountedMemory* data) {
83    result_data_ = data;
84  }
85
86  scoped_refptr<WebUIDataSourceImpl> source_;
87  TestClient client_;
88};
89
90TEST_F(WebUIDataSourceTest, EmptyStrings) {
91  source()->SetJsonPath("strings.js");
92  StartDataRequest("strings.js");
93  std::string result(result_data_->front_as<char>(), result_data_->size());
94  EXPECT_NE(result.find("var templateData = {"), std::string::npos);
95  EXPECT_NE(result.find("};"), std::string::npos);
96}
97
98TEST_F(WebUIDataSourceTest, SomeStrings) {
99  source()->SetJsonPath("strings.js");
100  source()->AddString("planet", base::ASCIIToUTF16("pluto"));
101  source()->AddLocalizedString("button", kDummyStringId);
102  StartDataRequest("strings.js");
103  std::string result(result_data_->front_as<char>(), result_data_->size());
104  EXPECT_NE(result.find("\"planet\":\"pluto\""), std::string::npos);
105  EXPECT_NE(result.find("\"button\":\"foo\""), std::string::npos);
106}
107
108TEST_F(WebUIDataSourceTest, DefaultResource) {
109  source()->SetDefaultResource(kDummyDefaultResourceId);
110  StartDataRequest("foobar" );
111  std::string result(result_data_->front_as<char>(), result_data_->size());
112  EXPECT_NE(result.find(kDummyDefaultResource), std::string::npos);
113  StartDataRequest("strings.js");
114  result = std::string(result_data_->front_as<char>(), result_data_->size());
115  EXPECT_NE(result.find(kDummyDefaultResource), std::string::npos);
116}
117
118TEST_F(WebUIDataSourceTest, NamedResource) {
119  source()->SetDefaultResource(kDummyDefaultResourceId);
120  source()->AddResourcePath("foobar", kDummyResourceId);
121  StartDataRequest("foobar");
122  std::string result(result_data_->front_as<char>(), result_data_->size());
123  EXPECT_NE(result.find(kDummytResource), std::string::npos);
124  StartDataRequest("strings.js");
125  result = std::string(result_data_->front_as<char>(), result_data_->size());
126  EXPECT_NE(result.find(kDummyDefaultResource), std::string::npos);
127}
128
129TEST_F(WebUIDataSourceTest, MimeType) {
130  const char* html = "text/html";
131  const char* js = "application/javascript";
132  EXPECT_EQ(GetMimeType(std::string()), html);
133  EXPECT_EQ(GetMimeType("foo"), html);
134  EXPECT_EQ(GetMimeType("foo.html"), html);
135  EXPECT_EQ(GetMimeType(".js"), js);
136  EXPECT_EQ(GetMimeType("foo.js"), js);
137  EXPECT_EQ(GetMimeType("js"), html);
138  EXPECT_EQ(GetMimeType("foojs"), html);
139  EXPECT_EQ(GetMimeType("foo.jsp"), html);
140}
141
142}  // namespace content
143