Home | History | Annotate | Download | only in printing 
      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 "chrome/browser/printing/print_dialog_cloud.h"
      6 #include "chrome/browser/printing/print_dialog_cloud_internal.h"
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/bind.h"
     12 #include "base/callback.h"
     13 #include "base/file_util.h"
     14 #include "base/files/file_path.h"
     15 #include "base/memory/weak_ptr.h"
     16 #include "base/message_loop/message_loop.h"
     17 #include "base/path_service.h"
     18 #include "base/strings/utf_string_conversions.h"
     19 #include "base/values.h"
     20 #include "chrome/browser/printing/cloud_print/cloud_print_url.h"
     21 #include "chrome/common/chrome_paths.h"
     22 #include "chrome/common/url_constants.h"
     23 #include "chrome/test/base/testing_profile.h"
     24 #include "content/public/browser/notification_details.h"
     25 #include "content/public/browser/notification_source.h"
     26 #include "content/public/browser/notification_types.h"
     27 #include "content/public/test/test_browser_thread.h"
     28 #include "testing/gmock/include/gmock/gmock.h"
     29 #include "testing/gtest/include/gtest/gtest.h"
     30 
     31 using content::BrowserThread;
     32 using content::WebContents;
     33 using content::WebUIMessageHandler;
     34 using testing::A;
     35 using testing::AtLeast;
     36 using testing::Eq;
     37 using testing::HasSubstr;
     38 using testing::IsNull;
     39 using testing::NotNull;
     40 using testing::Return;
     41 using testing::StrEq;
     42 using testing::_;
     43 using ui::ExternalWebDialogUI;
     44 
     45 const char kPDFTestFile[] = "printing/cloud_print_unittest.pdf";
     46 const char kMockJobTitle[] = "Mock Job Title";
     47 const char kMockPrintTicket[] = "Resolution=300";
     48 
     49 
     50 base::FilePath GetTestDataFileName() {
     51   base::FilePath test_data_directory;
     52   PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory);
     53   base::FilePath test_file = test_data_directory.AppendASCII(kPDFTestFile);
     54   return test_file;
     55 }
     56 
     57 char* GetTestData() {
     58   static std::string sTestFileData;
     59   if (sTestFileData.empty()) {
     60     base::FilePath test_file = GetTestDataFileName();
     61     base::ReadFileToString(test_file, &sTestFileData);
     62   }
     63   return &sTestFileData[0];
     64 }
     65 
     66 MATCHER_P(StringValueEq, expected, "StringValue") {
     67   if (expected->Equals(&arg))
     68     return true;
     69   std::string expected_string, arg_string;
     70   expected->GetAsString(&expected_string);
     71   arg.GetAsString(&arg_string);
     72   *result_listener << "'" << arg_string
     73                    << "' (expected '" << expected_string << "')";
     74   return false;
     75 }
     76 
     77 namespace internal_cloud_print_helpers {
     78 
     79 class MockCloudPrintFlowHandler
     80     : public CloudPrintFlowHandler,
     81       public base::SupportsWeakPtr<MockCloudPrintFlowHandler> {
     82  public:
     83   MockCloudPrintFlowHandler(const base::string16& title,
     84                             const base::string16& print_ticket,
     85                             const std::string& file_type,
     86                             bool close_after_signin,
     87                             const base::Closure& callback)
     88       : CloudPrintFlowHandler(NULL, title, print_ticket, file_type,
     89                               close_after_signin, callback) {}
     90   MOCK_METHOD0(DestructorCalled, void());
     91   MOCK_METHOD0(RegisterMessages, void());
     92   MOCK_METHOD3(Observe,
     93                void(int type,
     94                     const content::NotificationSource& source,
     95                     const content::NotificationDetails& details));
     96   MOCK_METHOD1(SetDialogDelegate,
     97                void(CloudPrintWebDialogDelegate* delegate));
     98   MOCK_METHOD0(CreateCloudPrintDataSender,
     99                scoped_refptr<CloudPrintDataSender>());
    100 };
    101 
    102 class MockCloudPrintWebDialogDelegate : public CloudPrintWebDialogDelegate {
    103  public:
    104   MOCK_CONST_METHOD0(GetDialogModalType,
    105       ui::ModalType());
    106   MOCK_CONST_METHOD0(GetDialogTitle,
    107       base::string16());
    108   MOCK_CONST_METHOD0(GetDialogContentURL,
    109       GURL());
    110   MOCK_CONST_METHOD1(GetWebUIMessageHandlers,
    111       void(std::vector<WebUIMessageHandler*>* handlers));
    112   MOCK_CONST_METHOD1(GetDialogSize,
    113       void(gfx::Size* size));
    114   MOCK_CONST_METHOD0(GetDialogArgs,
    115       std::string());
    116   MOCK_METHOD1(OnDialogClosed,
    117       void(const std::string& json_retval));
    118   MOCK_METHOD2(OnCloseContents,
    119       void(WebContents* source, bool *out_close_dialog));
    120 };
    121 
    122 }  // namespace internal_cloud_print_helpers
    123 
    124 using internal_cloud_print_helpers::CloudPrintDataSenderHelper;
    125 using internal_cloud_print_helpers::CloudPrintDataSender;
    126 
    127 class MockExternalWebDialogUI : public ExternalWebDialogUI {
    128  public:
    129   MOCK_METHOD1(RenderViewCreated,
    130                void(content::RenderViewHost* render_view_host));
    131 };
    132 
    133 class MockCloudPrintDataSenderHelper : public CloudPrintDataSenderHelper {
    134  public:
    135   // TODO(scottbyer): At some point this probably wants to use a
    136   // MockTabContents instead of NULL, and to pre-load it with a bunch
    137   // of expects/results.
    138   MockCloudPrintDataSenderHelper() : CloudPrintDataSenderHelper(NULL) {}
    139   MOCK_METHOD3(CallJavascriptFunction, void(const std::string&,
    140                                             const Value& arg1,
    141                                             const Value& arg2));
    142 };
    143 
    144 class CloudPrintURLTest : public testing::Test {
    145  public:
    146   CloudPrintURLTest() {}
    147 
    148  protected:
    149   virtual void SetUp() {
    150     profile_.reset(new TestingProfile());
    151   }
    152 
    153   scoped_ptr<Profile> profile_;
    154 };
    155 
    156 TEST_F(CloudPrintURLTest, CheckDefaultURLs) {
    157   std::string service_url =
    158       CloudPrintURL(profile_.get()).
    159       GetCloudPrintServiceURL().spec();
    160   EXPECT_THAT(service_url, HasSubstr("www.google.com"));
    161   EXPECT_THAT(service_url, HasSubstr("cloudprint"));
    162 
    163   std::string dialog_url =
    164       CloudPrintURL(profile_.get()).
    165       GetCloudPrintServiceDialogURL().spec();
    166   EXPECT_THAT(dialog_url, HasSubstr("www.google.com"));
    167   EXPECT_THAT(dialog_url, HasSubstr("/cloudprint/"));
    168   EXPECT_THAT(dialog_url, HasSubstr("/client/"));
    169   EXPECT_THAT(dialog_url, Not(HasSubstr("cloudprint/cloudprint")));
    170   EXPECT_THAT(dialog_url, HasSubstr("/dialog.html"));
    171 
    172   // Repeat to make sure there isn't a transient glitch.
    173   dialog_url =
    174       CloudPrintURL(profile_.get()).
    175       GetCloudPrintServiceDialogURL().spec();
    176   EXPECT_THAT(dialog_url, HasSubstr("www.google.com"));
    177   EXPECT_THAT(dialog_url, HasSubstr("/cloudprint/"));
    178   EXPECT_THAT(dialog_url, HasSubstr("/client/"));
    179   EXPECT_THAT(dialog_url, Not(HasSubstr("cloudprint/cloudprint")));
    180   EXPECT_THAT(dialog_url, HasSubstr("/dialog.html"));
    181 
    182   std::string manage_url =
    183       CloudPrintURL(profile_.get()).
    184       GetCloudPrintServiceManageURL().spec();
    185   EXPECT_THAT(manage_url, HasSubstr("www.google.com"));
    186   EXPECT_THAT(manage_url, HasSubstr("/cloudprint/"));
    187   EXPECT_THAT(manage_url, Not(HasSubstr("/client/")));
    188   EXPECT_THAT(manage_url, Not(HasSubstr("cloudprint/cloudprint")));
    189   EXPECT_THAT(manage_url, HasSubstr("/manage"));
    190 
    191   GURL learn_more_url = CloudPrintURL::GetCloudPrintLearnMoreURL();
    192   std::string learn_more_path = learn_more_url.spec();
    193   EXPECT_THAT(learn_more_path, HasSubstr("www.google.com"));
    194   EXPECT_THAT(learn_more_path, HasSubstr("/support/"));
    195   EXPECT_THAT(learn_more_path, HasSubstr("/cloudprint"));
    196   EXPECT_TRUE(learn_more_url.has_path());
    197   EXPECT_FALSE(learn_more_url.has_query());
    198 
    199   GURL test_page_url = CloudPrintURL::GetCloudPrintTestPageURL();
    200   std::string test_page_path = test_page_url.spec();
    201   EXPECT_THAT(test_page_path, HasSubstr("www.google.com"));
    202   EXPECT_THAT(test_page_path, HasSubstr("/landing/"));
    203   EXPECT_THAT(test_page_path, HasSubstr("/cloudprint/"));
    204   EXPECT_TRUE(test_page_url.has_path());
    205   EXPECT_TRUE(test_page_url.has_query());
    206 }
    207 
    208 // Testing for CloudPrintDataSender needs a mock WebUI.
    209 class CloudPrintDataSenderTest : public testing::Test {
    210  public:
    211   CloudPrintDataSenderTest()
    212       : file_thread_(BrowserThread::FILE, &message_loop_),
    213         io_thread_(BrowserThread::IO, &message_loop_) {}
    214 
    215  protected:
    216   virtual void SetUp() {
    217     mock_helper_.reset(new MockCloudPrintDataSenderHelper);
    218   }
    219 
    220   scoped_refptr<CloudPrintDataSender> CreateSender(
    221       const base::RefCountedString* data) {
    222     return new CloudPrintDataSender(mock_helper_.get(),
    223                                     base::ASCIIToUTF16(kMockJobTitle),
    224                                     base::ASCIIToUTF16(kMockPrintTicket),
    225                                     std::string("application/pdf"),
    226                                     data);
    227   }
    228 
    229   scoped_refptr<CloudPrintDataSender> print_data_sender_;
    230   scoped_ptr<MockCloudPrintDataSenderHelper> mock_helper_;
    231 
    232   base::MessageLoop message_loop_;
    233   content::TestBrowserThread file_thread_;
    234   content::TestBrowserThread io_thread_;
    235 };
    236 
    237 TEST_F(CloudPrintDataSenderTest, CanSend) {
    238   StringValue mock_job_title(kMockJobTitle);
    239   EXPECT_CALL(*mock_helper_,
    240               CallJavascriptFunction(_, _, StringValueEq(&mock_job_title))).
    241       WillOnce(Return());
    242 
    243   std::string data("test_data");
    244   scoped_refptr<CloudPrintDataSender> print_data_sender(
    245       CreateSender(base::RefCountedString::TakeString(&data)));
    246   base::FilePath test_data_file_name = GetTestDataFileName();
    247   BrowserThread::PostTask(
    248       BrowserThread::IO, FROM_HERE,
    249       base::Bind(&CloudPrintDataSender::SendPrintData, print_data_sender));
    250   base::MessageLoop::current()->RunUntilIdle();
    251 }
    252 
    253 TEST_F(CloudPrintDataSenderTest, NoData) {
    254   EXPECT_CALL(*mock_helper_, CallJavascriptFunction(_, _, _)).Times(0);
    255 
    256   scoped_refptr<CloudPrintDataSender> print_data_sender(CreateSender(NULL));
    257   base::FilePath test_data_file_name = GetTestDataFileName();
    258   BrowserThread::PostTask(
    259       BrowserThread::IO, FROM_HERE,
    260       base::Bind(&CloudPrintDataSender::SendPrintData, print_data_sender));
    261   base::MessageLoop::current()->RunUntilIdle();
    262 }
    263 
    264 TEST_F(CloudPrintDataSenderTest, EmptyData) {
    265   EXPECT_CALL(*mock_helper_, CallJavascriptFunction(_, _, _)).Times(0);
    266 
    267   std::string data;
    268   scoped_refptr<CloudPrintDataSender> print_data_sender(
    269       CreateSender(base::RefCountedString::TakeString(&data)));
    270   base::FilePath test_data_file_name = GetTestDataFileName();
    271   BrowserThread::PostTask(
    272       BrowserThread::IO, FROM_HERE,
    273       base::Bind(&CloudPrintDataSender::SendPrintData, print_data_sender));
    274   base::MessageLoop::current()->RunUntilIdle();
    275 }
    276 
    277 // Testing for CloudPrintFlowHandler needs a mock
    278 // CloudPrintWebDialogDelegate, mock CloudPrintDataSender, and a mock
    279 // WebUI.
    280 
    281 // Testing for CloudPrintWebDialogDelegate needs a mock
    282 // CloudPrintFlowHandler.
    283 
    284 using internal_cloud_print_helpers::MockCloudPrintFlowHandler;
    285 using internal_cloud_print_helpers::CloudPrintWebDialogDelegate;
    286 
    287 class CloudPrintWebDialogDelegateTest : public testing::Test {
    288  public:
    289   CloudPrintWebDialogDelegateTest()
    290       : ui_thread_(BrowserThread::UI, &message_loop_) {}
    291 
    292  protected:
    293   virtual void SetUp() {
    294     base::string16 mock_title;
    295     base::string16 mock_print_ticket;
    296     std::string mock_file_type;
    297     MockCloudPrintFlowHandler* handler =
    298         new MockCloudPrintFlowHandler(mock_print_ticket, mock_title,
    299                                       mock_file_type, false, base::Closure());
    300     mock_flow_handler_ = handler->AsWeakPtr();
    301     EXPECT_CALL(*mock_flow_handler_.get(), SetDialogDelegate(_));
    302     EXPECT_CALL(*mock_flow_handler_.get(), SetDialogDelegate(NULL));
    303     delegate_.reset(new CloudPrintWebDialogDelegate(mock_flow_handler_.get(),
    304                                                     std::string()));
    305   }
    306 
    307   virtual void TearDown() {
    308     delegate_.reset();
    309     if (mock_flow_handler_.get())
    310       delete mock_flow_handler_.get();
    311   }
    312 
    313   base::MessageLoopForUI message_loop_;
    314   content::TestBrowserThread ui_thread_;
    315   base::WeakPtr<MockCloudPrintFlowHandler> mock_flow_handler_;
    316   scoped_ptr<CloudPrintWebDialogDelegate> delegate_;
    317 };
    318 
    319 TEST_F(CloudPrintWebDialogDelegateTest, BasicChecks) {
    320   EXPECT_THAT(delegate_->GetDialogContentURL().spec(),
    321               StrEq(chrome::kChromeUICloudPrintResourcesURL));
    322   EXPECT_TRUE(delegate_->GetDialogTitle().empty());
    323 
    324   bool close_dialog = false;
    325   delegate_->OnCloseContents(NULL, &close_dialog);
    326   EXPECT_TRUE(close_dialog);
    327 }
    328 
    329 TEST_F(CloudPrintWebDialogDelegateTest, OwnedFlowDestroyed) {
    330   delegate_.reset();
    331   EXPECT_THAT(mock_flow_handler_.get(), IsNull());
    332 }
    333 
    334 TEST_F(CloudPrintWebDialogDelegateTest, UnownedFlowLetGo) {
    335   std::vector<WebUIMessageHandler*> handlers;
    336   delegate_->GetWebUIMessageHandlers(&handlers);
    337   delegate_.reset();
    338   EXPECT_THAT(mock_flow_handler_.get(), NotNull());
    339 }
    340 
    341 // Testing for ExternalWebDialogUI needs a mock WebContents and mock
    342 // CloudPrintWebDialogDelegate (attached to the mock web_contents).
    343 
    344 // Testing for PrintDialogCloud needs a mock Browser.
    345