printing/printing_context_chromeos_unittest.cc - chromium/src - Git at Google

 // Copyright 2020 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "printing/printing_context_chromeos.h"

 #include <string>

 #include "base/memory/raw_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "printing/backend/cups_ipp_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace printing {

 namespace {

 using ::testing::_;
 using ::testing::ByMove;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SaveArg;

 constexpr char kPrinterName[] = "printer";
 constexpr char16_t kPrinterName16[] = u"printer";

 constexpr char kUsername[] = "test user";

 constexpr char kDocumentName[] = "document name";
 constexpr char16_t kDocumentName16[] = u"document name";

 class MockCupsPrinter : public CupsPrinter {
  public:
   MOCK_CONST_METHOD0(is_default, bool());
   MOCK_CONST_METHOD0(GetName, std::string());
   MOCK_CONST_METHOD0(GetMakeAndModel, std::string());
   MOCK_CONST_METHOD0(GetInfo, std::string());
   MOCK_CONST_METHOD0(GetUri, std::string());
   MOCK_CONST_METHOD0(EnsureDestInfo, bool());
   MOCK_CONST_METHOD1(ToPrinterInfo, bool(PrinterBasicInfo* basic_info));
   MOCK_METHOD4(CreateJob,
                ipp_status_t(int* job_id,
                             const std::string& title,
                             const std::string& username,
                             const std::vector<cups_option_t>& options));
   MOCK_METHOD5(StartDocument,
                bool(int job_id,
                     const std::string& docname,
                     bool last_doc,
                     const std::string& username,
                     const std::vector<cups_option_t>& options));
   MOCK_METHOD1(StreamData, bool(const std::vector<char>& buffer));
   MOCK_METHOD0(FinishDocument, bool());
   MOCK_METHOD2(CloseJob, ipp_status_t(int job_id, const std::string& username));
   MOCK_METHOD1(CancelJob, bool(int job_id));
   MOCK_METHOD1(GetMediaMarginsByName,
                CupsMediaMargins(const std::string& media_id));

   MOCK_CONST_METHOD1(GetSupportedOptionValues,
                      ipp_attribute_t*(const char* option_name));
   MOCK_CONST_METHOD1(GetSupportedOptionValueStrings,
                      std::vector<base::StringPiece>(const char* option_name));
   MOCK_CONST_METHOD1(GetDefaultOptionValue,
                      ipp_attribute_t*(const char* option_name));
   MOCK_CONST_METHOD2(CheckOptionSupported,
                      bool(const char* name, const char* value));
 };

 class MockCupsConnection : public CupsConnection {
  public:
   MOCK_METHOD1(GetDests, bool(std::vector<std::unique_ptr<CupsPrinter>>&));
   MOCK_METHOD2(GetJobs,
                bool(const std::vector<std::string>& printer_ids,
                     std::vector<QueueStatus>* jobs));
   MOCK_METHOD2(GetPrinterStatus,
                bool(const std::string& printer_id,
                     PrinterStatus* printer_status));
   MOCK_CONST_METHOD0(server_name, std::string());
   MOCK_CONST_METHOD0(last_error, int());
   MOCK_CONST_METHOD0(last_error_message, std::string());

   MOCK_METHOD1(GetPrinter,
                std::unique_ptr<CupsPrinter>(const std::string& printer_name));
 };

 class TestPrintSettings : public PrintSettings {
  public:
   TestPrintSettings() { set_duplex_mode(mojom::DuplexMode::kSimplex); }
 };

 class PrintingContextTest : public testing::Test,
                             public PrintingContext::Delegate {
  public:
   void SetDefaultSettings(bool send_user_info, const std::string& uri) {
     auto unique_connection = std::make_unique<MockCupsConnection>();
     auto* connection = unique_connection.get();
     auto unique_printer = std::make_unique<MockCupsPrinter>();
     printer_ = unique_printer.get();
     EXPECT_CALL(*printer_, GetUri()).WillRepeatedly(Return(uri));
     EXPECT_CALL(*connection, GetPrinter(kPrinterName))
         .WillOnce(Return(ByMove(std::move(unique_printer))));
     printing_context_ = PrintingContextChromeos::CreateForTesting(
         this, std::move(unique_connection));
     auto settings = std::make_unique<PrintSettings>();
     settings->set_device_name(kPrinterName16);
     settings->set_send_user_info(send_user_info);
     settings->set_duplex_mode(mojom::DuplexMode::kLongEdge);
     settings->set_username(kUsername);
     printing_context_->UpdatePrintSettingsFromPOD(std::move(settings));
   }

   void TestCupsOptionValue(const char* option_name,
                            const char* expected_option_value) const {
     DCHECK(option_name);
     auto cups_options = SettingsToCupsOptions(settings_);
     const char* ret = nullptr;
     for (const auto& option : cups_options) {
       EXPECT_TRUE(option->name);
       EXPECT_TRUE(option->value);
       if (option->name && !strcmp(option_name, option->name)) {
         EXPECT_EQ(nullptr, ret)
             << "Multiple options with name " << option_name << " found.";
         ret = option->value;
       }
     }
     EXPECT_STREQ(expected_option_value, ret);
   }

   TestPrintSettings settings_;

   // PrintingContext::Delegate methods.
   gfx::NativeView GetParentView() override { return nullptr; }
   std::string GetAppLocale() override { return std::string(); }

   std::unique_ptr<PrintingContextChromeos> printing_context_;
   raw_ptr<MockCupsPrinter> printer_;
 };

 TEST_F(PrintingContextTest, SettingsToCupsOptions_Color) {
   settings_.set_color(mojom::ColorModel::kGray);
   TestCupsOptionValue(kIppColor, "monochrome");
   settings_.set_color(mojom::ColorModel::kColor);
   TestCupsOptionValue(kIppColor, "color");
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_Duplex) {
   settings_.set_duplex_mode(mojom::DuplexMode::kSimplex);
   TestCupsOptionValue(kIppDuplex, "one-sided");
   settings_.set_duplex_mode(mojom::DuplexMode::kLongEdge);
   TestCupsOptionValue(kIppDuplex, "two-sided-long-edge");
   settings_.set_duplex_mode(mojom::DuplexMode::kShortEdge);
   TestCupsOptionValue(kIppDuplex, "two-sided-short-edge");
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_Media) {
   TestCupsOptionValue(kIppMedia, "");
   settings_.set_requested_media(
       {gfx::Size(297000, 420000), "iso_a3_297x420mm"});
   TestCupsOptionValue(kIppMedia, "iso_a3_297x420mm");
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_Copies) {
   settings_.set_copies(3);
   TestCupsOptionValue(kIppCopies, "3");
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_Collate) {
   TestCupsOptionValue(kIppCollate, "separate-documents-uncollated-copies");
   settings_.set_collate(true);
   TestCupsOptionValue(kIppCollate, "separate-documents-collated-copies");
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_Pin) {
   TestCupsOptionValue(kIppPin, nullptr);
   settings_.set_pin_value("1234");
   TestCupsOptionValue(kIppPin, "1234");
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_Resolution) {
   TestCupsOptionValue(kIppResolution, nullptr);
   settings_.set_dpi_xy(0, 300);
   TestCupsOptionValue(kIppResolution, nullptr);
   settings_.set_dpi_xy(300, 0);
   TestCupsOptionValue(kIppResolution, nullptr);
   settings_.set_dpi(600);
   TestCupsOptionValue(kIppResolution, "600dpi");
   settings_.set_dpi_xy(600, 1200);
   TestCupsOptionValue(kIppResolution, "600x1200dpi");
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_SendUserInfo_Secure) {
   ipp_status_t status = ipp_status_t::IPP_STATUS_OK;
   std::u16string document_name = kDocumentName16;
   SetDefaultSettings(/*send_user_info=*/true, "ipps://test-uri");
   std::string create_job_document_name;
   std::string create_job_username;
   std::string start_document_document_name;
   std::string start_document_username;
   EXPECT_CALL(*printer_, CreateJob)
       .WillOnce(DoAll(SaveArg<1>(&create_job_document_name),
                       SaveArg<2>(&create_job_username), Return(status)));
   EXPECT_CALL(*printer_, StartDocument)
       .WillOnce(DoAll(SaveArg<1>(&start_document_document_name),
                       SaveArg<3>(&start_document_username), Return(true)));

   printing_context_->NewDocument(document_name);

   EXPECT_EQ(create_job_document_name, kDocumentName);
   EXPECT_EQ(start_document_document_name, kDocumentName);
   EXPECT_EQ(create_job_username, kUsername);
   EXPECT_EQ(start_document_username, kUsername);
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_SendUserInfo_Insecure) {
   ipp_status_t status = ipp_status_t::IPP_STATUS_OK;
   std::u16string document_name = kDocumentName16;
   std::string default_username = "chronos";
   std::string default_document_name = "-";
   SetDefaultSettings(/*send_user_info=*/true, "ipp://test-uri");
   std::string create_job_document_name;
   std::string create_job_username;
   std::string start_document_document_name;
   std::string start_document_username;
   EXPECT_CALL(*printer_, CreateJob)
       .WillOnce(DoAll(SaveArg<1>(&create_job_document_name),
                       SaveArg<2>(&create_job_username), Return(status)));
   EXPECT_CALL(*printer_, StartDocument)
       .WillOnce(DoAll(SaveArg<1>(&start_document_document_name),
                       SaveArg<3>(&start_document_username), Return(true)));

   printing_context_->NewDocument(document_name);

   EXPECT_EQ(create_job_document_name, default_document_name);
   EXPECT_EQ(start_document_document_name, default_document_name);
   EXPECT_EQ(create_job_username, default_username);
   EXPECT_EQ(start_document_username, default_username);
 }

 TEST_F(PrintingContextTest, SettingsToCupsOptions_DoNotSendUserInfo) {
   ipp_status_t status = ipp_status_t::IPP_STATUS_OK;
   std::u16string document_name = kDocumentName16;
   SetDefaultSettings(/*send_user_info=*/false, "ipps://test-uri");
   std::string create_job_document_name;
   std::string create_job_username;
   std::string start_document_document_name;
   std::string start_document_username;
   EXPECT_CALL(*printer_, CreateJob)
       .WillOnce(DoAll(SaveArg<1>(&create_job_document_name),
                       SaveArg<2>(&create_job_username), Return(status)));
   EXPECT_CALL(*printer_, StartDocument)
       .WillOnce(DoAll(SaveArg<1>(&start_document_document_name),
                       SaveArg<3>(&start_document_username), Return(true)));

   printing_context_->NewDocument(document_name);

   EXPECT_EQ(create_job_document_name, "");
   EXPECT_EQ(start_document_document_name, "");
   EXPECT_EQ(create_job_username, "");
   EXPECT_EQ(start_document_username, "");
 }

 }  // namespace

 }  // namespace printing
	// Copyright 2020 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "printing/printing_context_chromeos.h"

	#include <string>

	#include "base/memory/raw_ptr.h"
	#include "base/strings/utf_string_conversions.h"
	#include "printing/backend/cups_ipp_constants.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace printing {

	namespace {

	using ::testing::_;
	using ::testing::ByMove;
	using ::testing::DoAll;
	using ::testing::Return;
	using ::testing::SaveArg;

	constexpr char kPrinterName[] = "printer";
	constexpr char16_t kPrinterName16[] = u"printer";

	constexpr char kUsername[] = "test user";

	constexpr char kDocumentName[] = "document name";
	constexpr char16_t kDocumentName16[] = u"document name";

	class MockCupsPrinter : public CupsPrinter {
	public:
	MOCK_CONST_METHOD0(is_default, bool());
	MOCK_CONST_METHOD0(GetName, std::string());
	MOCK_CONST_METHOD0(GetMakeAndModel, std::string());
	MOCK_CONST_METHOD0(GetInfo, std::string());
	MOCK_CONST_METHOD0(GetUri, std::string());
	MOCK_CONST_METHOD0(EnsureDestInfo, bool());
	MOCK_CONST_METHOD1(ToPrinterInfo, bool(PrinterBasicInfo* basic_info));
	MOCK_METHOD4(CreateJob,
	ipp_status_t(int* job_id,
	const std::string& title,
	const std::string& username,
	const std::vector<cups_option_t>& options));
	MOCK_METHOD5(StartDocument,
	bool(int job_id,
	const std::string& docname,
	bool last_doc,
	const std::string& username,
	const std::vector<cups_option_t>& options));
	MOCK_METHOD1(StreamData, bool(const std::vector<char>& buffer));
	MOCK_METHOD0(FinishDocument, bool());
	MOCK_METHOD2(CloseJob, ipp_status_t(int job_id, const std::string& username));
	MOCK_METHOD1(CancelJob, bool(int job_id));
	MOCK_METHOD1(GetMediaMarginsByName,
	CupsMediaMargins(const std::string& media_id));

	MOCK_CONST_METHOD1(GetSupportedOptionValues,
	ipp_attribute_t(const char option_name));
	MOCK_CONST_METHOD1(GetSupportedOptionValueStrings,
	std::vector<base::StringPiece>(const char* option_name));
	MOCK_CONST_METHOD1(GetDefaultOptionValue,
	ipp_attribute_t(const char option_name));
	MOCK_CONST_METHOD2(CheckOptionSupported,
	bool(const char* name, const char* value));
	};

	class MockCupsConnection : public CupsConnection {
	public:
	MOCK_METHOD1(GetDests, bool(std::vector<std::unique_ptr<CupsPrinter>>&));
	MOCK_METHOD2(GetJobs,
	bool(const std::vector<std::string>& printer_ids,
	std::vector<QueueStatus>* jobs));
	MOCK_METHOD2(GetPrinterStatus,
	bool(const std::string& printer_id,
	PrinterStatus* printer_status));
	MOCK_CONST_METHOD0(server_name, std::string());
	MOCK_CONST_METHOD0(last_error, int());
	MOCK_CONST_METHOD0(last_error_message, std::string());

	MOCK_METHOD1(GetPrinter,
	std::unique_ptr<CupsPrinter>(const std::string& printer_name));
	};

	class TestPrintSettings : public PrintSettings {
	public:
	TestPrintSettings() { set_duplex_mode(mojom::DuplexMode::kSimplex); }
	};

	class PrintingContextTest : public testing::Test,
	public PrintingContext::Delegate {
	public:
	void SetDefaultSettings(bool send_user_info, const std::string& uri) {
	auto unique_connection = std::make_unique<MockCupsConnection>();
	auto* connection = unique_connection.get();
	auto unique_printer = std::make_unique<MockCupsPrinter>();
	printer_ = unique_printer.get();
	EXPECT_CALL(*printer_, GetUri()).WillRepeatedly(Return(uri));
	EXPECT_CALL(*connection, GetPrinter(kPrinterName))
	.WillOnce(Return(ByMove(std::move(unique_printer))));
	printing_context_ = PrintingContextChromeos::CreateForTesting(
	this, std::move(unique_connection));
	auto settings = std::make_unique<PrintSettings>();
	settings->set_device_name(kPrinterName16);
	settings->set_send_user_info(send_user_info);
	settings->set_duplex_mode(mojom::DuplexMode::kLongEdge);
	settings->set_username(kUsername);
	printing_context_->UpdatePrintSettingsFromPOD(std::move(settings));
	}

	void TestCupsOptionValue(const char* option_name,
	const char* expected_option_value) const {
	DCHECK(option_name);
	auto cups_options = SettingsToCupsOptions(settings_);
	const char* ret = nullptr;
	for (const auto& option : cups_options) {
	EXPECT_TRUE(option->name);
	EXPECT_TRUE(option->value);
	if (option->name && !strcmp(option_name, option->name)) {
	EXPECT_EQ(nullptr, ret)
	<< "Multiple options with name " << option_name << " found.";
	ret = option->value;
	}
	}
	EXPECT_STREQ(expected_option_value, ret);
	}

	TestPrintSettings settings_;

	// PrintingContext::Delegate methods.
	gfx::NativeView GetParentView() override { return nullptr; }
	std::string GetAppLocale() override { return std::string(); }

	std::unique_ptr<PrintingContextChromeos> printing_context_;
	raw_ptr<MockCupsPrinter> printer_;
	};

	TEST_F(PrintingContextTest, SettingsToCupsOptions_Color) {
	settings_.set_color(mojom::ColorModel::kGray);
	TestCupsOptionValue(kIppColor, "monochrome");
	settings_.set_color(mojom::ColorModel::kColor);
	TestCupsOptionValue(kIppColor, "color");
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_Duplex) {
	settings_.set_duplex_mode(mojom::DuplexMode::kSimplex);
	TestCupsOptionValue(kIppDuplex, "one-sided");
	settings_.set_duplex_mode(mojom::DuplexMode::kLongEdge);
	TestCupsOptionValue(kIppDuplex, "two-sided-long-edge");
	settings_.set_duplex_mode(mojom::DuplexMode::kShortEdge);
	TestCupsOptionValue(kIppDuplex, "two-sided-short-edge");
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_Media) {
	TestCupsOptionValue(kIppMedia, "");
	settings_.set_requested_media(
	{gfx::Size(297000, 420000), "iso_a3_297x420mm"});
	TestCupsOptionValue(kIppMedia, "iso_a3_297x420mm");
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_Copies) {
	settings_.set_copies(3);
	TestCupsOptionValue(kIppCopies, "3");
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_Collate) {
	TestCupsOptionValue(kIppCollate, "separate-documents-uncollated-copies");
	settings_.set_collate(true);
	TestCupsOptionValue(kIppCollate, "separate-documents-collated-copies");
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_Pin) {
	TestCupsOptionValue(kIppPin, nullptr);
	settings_.set_pin_value("1234");
	TestCupsOptionValue(kIppPin, "1234");
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_Resolution) {
	TestCupsOptionValue(kIppResolution, nullptr);
	settings_.set_dpi_xy(0, 300);
	TestCupsOptionValue(kIppResolution, nullptr);
	settings_.set_dpi_xy(300, 0);
	TestCupsOptionValue(kIppResolution, nullptr);
	settings_.set_dpi(600);
	TestCupsOptionValue(kIppResolution, "600dpi");
	settings_.set_dpi_xy(600, 1200);
	TestCupsOptionValue(kIppResolution, "600x1200dpi");
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_SendUserInfo_Secure) {
	ipp_status_t status = ipp_status_t::IPP_STATUS_OK;
	std::u16string document_name = kDocumentName16;
	SetDefaultSettings(/send_user_info=/true, "ipps://test-uri");
	std::string create_job_document_name;
	std::string create_job_username;
	std::string start_document_document_name;
	std::string start_document_username;
	EXPECT_CALL(*printer_, CreateJob)
	.WillOnce(DoAll(SaveArg<1>(&create_job_document_name),
	SaveArg<2>(&create_job_username), Return(status)));
	EXPECT_CALL(*printer_, StartDocument)
	.WillOnce(DoAll(SaveArg<1>(&start_document_document_name),
	SaveArg<3>(&start_document_username), Return(true)));

	printing_context_->NewDocument(document_name);

	EXPECT_EQ(create_job_document_name, kDocumentName);
	EXPECT_EQ(start_document_document_name, kDocumentName);
	EXPECT_EQ(create_job_username, kUsername);
	EXPECT_EQ(start_document_username, kUsername);
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_SendUserInfo_Insecure) {
	ipp_status_t status = ipp_status_t::IPP_STATUS_OK;
	std::u16string document_name = kDocumentName16;
	std::string default_username = "chronos";
	std::string default_document_name = "-";
	SetDefaultSettings(/send_user_info=/true, "ipp://test-uri");
	std::string create_job_document_name;
	std::string create_job_username;
	std::string start_document_document_name;
	std::string start_document_username;
	EXPECT_CALL(*printer_, CreateJob)
	.WillOnce(DoAll(SaveArg<1>(&create_job_document_name),
	SaveArg<2>(&create_job_username), Return(status)));
	EXPECT_CALL(*printer_, StartDocument)
	.WillOnce(DoAll(SaveArg<1>(&start_document_document_name),
	SaveArg<3>(&start_document_username), Return(true)));

	printing_context_->NewDocument(document_name);

	EXPECT_EQ(create_job_document_name, default_document_name);
	EXPECT_EQ(start_document_document_name, default_document_name);
	EXPECT_EQ(create_job_username, default_username);
	EXPECT_EQ(start_document_username, default_username);
	}

	TEST_F(PrintingContextTest, SettingsToCupsOptions_DoNotSendUserInfo) {
	ipp_status_t status = ipp_status_t::IPP_STATUS_OK;
	std::u16string document_name = kDocumentName16;
	SetDefaultSettings(/send_user_info=/false, "ipps://test-uri");
	std::string create_job_document_name;
	std::string create_job_username;
	std::string start_document_document_name;
	std::string start_document_username;
	EXPECT_CALL(*printer_, CreateJob)
	.WillOnce(DoAll(SaveArg<1>(&create_job_document_name),
	SaveArg<2>(&create_job_username), Return(status)));
	EXPECT_CALL(*printer_, StartDocument)
	.WillOnce(DoAll(SaveArg<1>(&start_document_document_name),
	SaveArg<3>(&start_document_username), Return(true)));

	printing_context_->NewDocument(document_name);

	EXPECT_EQ(create_job_document_name, "");
	EXPECT_EQ(start_document_document_name, "");
	EXPECT_EQ(create_job_username, "");
	EXPECT_EQ(start_document_username, "");
	}

	} // namespace

	} // namespace printing