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