Home | History | Annotate | Download | only in webui 
      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
    143