OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 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 #include "chrome/browser/extensions/api/document_scan/document_scan_api.h" |
| 5 |
| 6 #include <string> |
| 7 #include <vector> |
| 8 |
| 9 #include "chrome/browser/extensions/api/document_scan/mock_document_scan_interfa
ce.h" |
| 10 #include "chrome/browser/extensions/extension_api_unittest.h" |
| 11 #include "chrome/browser/extensions/extension_function_test_utils.h" |
| 12 #include "testing/gtest/include/gtest/gtest.h" |
| 13 |
| 14 using extension_function_test_utils::RunFunctionFlags::NONE; |
| 15 using std::string; |
| 16 using std::vector; |
| 17 using testing::_; |
| 18 |
| 19 namespace extensions { |
| 20 |
| 21 namespace api { |
| 22 |
| 23 // Tests of networking_private_crypto support for Networking Private API. |
| 24 class DocumentScanScanFunctionTest : public ExtensionApiUnittest { |
| 25 public: |
| 26 DocumentScanScanFunctionTest() |
| 27 : function_(new DocumentScanScanFunction()), |
| 28 document_scan_interface_(new MockDocumentScanInterface()) {} |
| 29 virtual ~DocumentScanScanFunctionTest() {} |
| 30 |
| 31 void SetUp() { |
| 32 ExtensionApiUnittest::SetUp(); |
| 33 // Passes ownership. |
| 34 function_->document_scan_interface_.reset(document_scan_interface_); |
| 35 } |
| 36 |
| 37 protected: |
| 38 string RunFunctionAndReturnError(const string& args) { |
| 39 function_->set_extension(extension()); |
| 40 string error = extension_function_test_utils::RunFunctionAndReturnError( |
| 41 function_, args, browser(), NONE); |
| 42 return error; |
| 43 } |
| 44 |
| 45 DocumentScanScanFunction* function_; |
| 46 MockDocumentScanInterface* document_scan_interface_; // Owned by function_. |
| 47 }; |
| 48 |
| 49 ACTION_P2(InvokeListScannersCallback, scanner_list, error) { |
| 50 ::std::tr1::get<0>(args).Run(scanner_list, error); |
| 51 } |
| 52 |
| 53 ACTION_P3(InvokeScanCallback, data, mime_type, error) { |
| 54 ::std::tr1::get<3>(args).Run(data, mime_type, error); |
| 55 } |
| 56 |
| 57 TEST_F(DocumentScanScanFunctionTest, GestureRequired) { |
| 58 EXPECT_EQ("User gesture required to perform scan", |
| 59 RunFunctionAndReturnError("[{}]")); |
| 60 } |
| 61 |
| 62 TEST_F(DocumentScanScanFunctionTest, NoScanners) { |
| 63 function_->set_user_gesture(true); |
| 64 EXPECT_CALL(*document_scan_interface_, ListScanners(_)) |
| 65 .WillOnce(InvokeListScannersCallback( |
| 66 vector<DocumentScanInterface::ScannerDescription>(), "")); |
| 67 EXPECT_EQ("Scanner not available", |
| 68 RunFunctionAndReturnError("[{}]")); |
| 69 } |
| 70 |
| 71 TEST_F(DocumentScanScanFunctionTest, NoMatchingScanners) { |
| 72 function_->set_user_gesture(true); |
| 73 vector<DocumentScanInterface::ScannerDescription> scanner_list; |
| 74 DocumentScanInterface::ScannerDescription scanner; |
| 75 scanner.image_mime_type = "img/fresco"; |
| 76 scanner_list.push_back(scanner); |
| 77 EXPECT_CALL(*document_scan_interface_, ListScanners(_)) |
| 78 .WillOnce(InvokeListScannersCallback(scanner_list, "")); |
| 79 EXPECT_EQ( |
| 80 "Scanner not available", |
| 81 RunFunctionAndReturnError("[{\"mimeTypes\": [\"img/silverpoint\"]}]")); |
| 82 } |
| 83 |
| 84 TEST_F(DocumentScanScanFunctionTest, ScanFailure) { |
| 85 function_->set_user_gesture(true); |
| 86 vector<DocumentScanInterface::ScannerDescription> scanner_list; |
| 87 DocumentScanInterface::ScannerDescription scanner; |
| 88 const char kMimeType[] = "img/tempera"; |
| 89 const char kScannerName[] = "Michelangelo"; |
| 90 scanner.name = kScannerName; |
| 91 scanner.image_mime_type = kMimeType; |
| 92 scanner_list.push_back(scanner); |
| 93 EXPECT_CALL(*document_scan_interface_, ListScanners(_)) |
| 94 .WillOnce(InvokeListScannersCallback(scanner_list, "")); |
| 95 const char kScanError[] = "Someone ate all the eggs"; |
| 96 EXPECT_CALL(*document_scan_interface_, Scan(kScannerName, _, _, _)) |
| 97 .WillOnce(InvokeScanCallback("", "", kScanError)); |
| 98 EXPECT_EQ(kScanError, |
| 99 RunFunctionAndReturnError("[{\"mimeTypes\": [\"img/tempera\"]}]")); |
| 100 } |
| 101 |
| 102 TEST_F(DocumentScanScanFunctionTest, Success) { |
| 103 vector<DocumentScanInterface::ScannerDescription> scanner_list; |
| 104 scanner_list.emplace_back(); |
| 105 EXPECT_CALL(*document_scan_interface_, ListScanners(_)) |
| 106 .WillOnce(InvokeListScannersCallback(scanner_list, "")); |
| 107 const char kScanData[] = "A beautiful picture"; |
| 108 const char kMimeType[] = "img/encaustic"; |
| 109 EXPECT_CALL(*document_scan_interface_, Scan(_, _, _, _)) |
| 110 .WillOnce(InvokeScanCallback(kScanData, kMimeType, "")); |
| 111 function_->set_user_gesture(true); |
| 112 scoped_ptr<base::DictionaryValue> result(RunFunctionAndReturnDictionary( |
| 113 function_, "[{}]")); |
| 114 ASSERT_NE(nullptr, result.get()); |
| 115 document_scan::ScanResults scan_results; |
| 116 EXPECT_TRUE(document_scan::ScanResults::Populate(*result, &scan_results)); |
| 117 EXPECT_THAT(scan_results.data_urls, testing::ElementsAre(kScanData)); |
| 118 EXPECT_EQ(kMimeType, scan_results.mime_type); |
| 119 } |
| 120 |
| 121 } // namespace api |
| 122 |
| 123 } // namespace extensions |
OLD | NEW |