content/browser/webui/web_ui_data_source_unittest.cc

   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
  12 namespace content {
  13 namespace {
  14
  15 const int kDummyStringId = 123;
  16 const int kDummyDefaultResourceId = 456;
  17 const int kDummyResourceId = 789;
  18
  19 const char kDummyString[] = "foo";
  20 const char kDummyDefaultResource[] = "<html>foo</html>";
  21 const char kDummytResource[] = "<html>blah</html>";
  22
  23 class 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
  51 class 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
  90 TEST_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
  98 TEST_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
 108 TEST_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
 118 TEST_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
 129 TEST_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