printing/print_settings_conversion_unittest.cc

   1 // Copyright 2019 The Chromium Authors
   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 "printing/print_settings_conversion.h"
   6
   7 #include "base/containers/contains.h"
   8 #include "base/test/values_test_util.h"
   9 #include "base/values.h"
  10 #include "build/build_config.h"
  11 #include "printing/buildflags/buildflags.h"
  12 #include "printing/mojom/print.mojom.h"
  13 #include "printing/print_settings.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace printing {
  17
  18 namespace {
  19
  20 const char kPrinterSettings[] = R"({
  21   "headerFooterEnabled": true,
  22   "title": "Test Doc",
  23   "url": "http://localhost/",
  24   "shouldPrintBackgrounds": false,
  25   "shouldPrintSelectionOnly": false,
  26   "mediaSize": {
  27     "height_microns": 297000,
  28     "width_microns": 210000
  29   },
  30   "marginsType": 0,
  31   "pageRange": [{
  32     "from": 1,
  33     "to": 1
  34   }],
  35   "collate": false,
  36   "copies": 1,
  37   "color": 2,
  38   "duplex": 0,
  39   "landscape": false,
  40   "deviceName": "printer",
  41   "scaleFactor": 100,
  42   "rasterizePDF": false,
  43   "rasterizePdfDpi": 150,
  44   "pagesPerSheet": 1,
  45   "dpiHorizontal": 300,
  46   "dpiVertical": 300,
  47   "previewModifiable": true,
  48   "sendUserInfo": true,
  49   "username": "username@domain.net",
  50   "chromeos-access-oauth-token": "this is an OAuth access token",
  51   "pinValue": "0000",
  52   "ipp-client-info": [
  53     {
  54       "ipp-client-name": "ChromeOS",
  55       "ipp-client-patches": "patch",
  56       "ipp-client-string-version": "str_version",
  57       "ipp-client-type": 4,
  58       "ipp-client-version": "version",
  59     },
  60     {
  61       "ipp-client-name": "chromebook-{DEVICE_ASSET_ID}",
  62       "ipp-client-string-version": "",
  63       "ipp-client-type": 6,
  64     }
  65   ],
  66 })";
  67
  68 const char kPrinterSettingsWithImageableArea[] = R"({
  69   "headerFooterEnabled": false,
  70   "title": "Test Doc",
  71   "url": "http://localhost/",
  72   "shouldPrintBackgrounds": false,
  73   "shouldPrintSelectionOnly": false,
  74   "mediaSize": {
  75     "height_microns": 297000,
  76     "imageable_area_bottom_microns": 1000,
  77     "imageable_area_left_microns": 0,
  78     "imageable_area_right_microns": 180000,
  79     "imageable_area_top_microns": 297000,
  80     "width_microns": 210000
  81   },
  82   "collate": false,
  83   "copies": 1,
  84   "color": 2,
  85   "duplex": 0,
  86   "landscape": false,
  87   "deviceName": "printer",
  88   "scaleFactor": 100,
  89   "rasterizePDF": false,
  90   "pagesPerSheet": 1,
  91   "dpiHorizontal": 300,
  92   "dpiVertical": 300,
  93 })";
  94
  95 #if !BUILDFLAG(IS_MAC)
  96 const char kPrinterSettingsWithNonSquarePixels[] = R"({
  97   "headerFooterEnabled": false,
  98   "title": "Test Doc",
  99   "url": "http://localhost/",
 100   "shouldPrintBackgrounds": false,
 101   "shouldPrintSelectionOnly": false,
 102   "mediaSize": {
 103     "height_microns": 297000,
 104     "imageable_area_bottom_microns": 1000,
 105     "imageable_area_left_microns": 0,
 106     "imageable_area_right_microns": 180000,
 107     "imageable_area_top_microns": 297000,
 108     "width_microns": 210000
 109   },
 110   "collate": false,
 111   "copies": 1,
 112   "color": 2,
 113   "duplex": 0,
 114   "landscape": false,
 115   "deviceName": "printer",
 116   "scaleFactor": 100,
 117   "rasterizePDF": false,
 118   "pagesPerSheet": 1,
 119   "dpiHorizontal": 800,
 120   "dpiVertical": 50,
 121 })";
 122 #endif  // !BUILDFLAG(IS_MAC)
 123
 124 const char kCustomMargins[] = R"({
 125   "marginBottom": 10,
 126   "marginLeft": 30,
 127   "marginRight": 20,
 128   "marginTop": 80
 129 })";
 130
 131 }  // namespace
 132
 133 TEST(PrintSettingsConversionTest, InvalidSettings) {
 134   base::Value::Dict dict = base::test::ParseJsonDict("{}");
 135   ASSERT_TRUE(dict.empty());
 136   EXPECT_FALSE(PrintSettingsFromJobSettings(dict));
 137 }
 138
 139 TEST(PrintSettingsConversionTest, Conversion) {
 140   base::Value::Dict dict = base::test::ParseJsonDict(kPrinterSettings);
 141   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 142   ASSERT_TRUE(settings);
 143 #if BUILDFLAG(IS_CHROMEOS)
 144   EXPECT_TRUE(settings->send_user_info());
 145   EXPECT_EQ("username@domain.net", settings->username());
 146   EXPECT_EQ("this is an OAuth access token", settings->oauth_token());
 147   EXPECT_EQ("0000", settings->pin_value());
 148
 149   ASSERT_EQ(settings->client_infos().size(), 2u);
 150   EXPECT_EQ(settings->client_infos()[0].client_name, "ChromeOS");
 151   EXPECT_EQ(settings->client_infos()[0].client_type,
 152             mojom::IppClientInfo::ClientType::kOperatingSystem);
 153   EXPECT_EQ(settings->client_infos()[0].client_patches, "patch");
 154   EXPECT_EQ(settings->client_infos()[0].client_string_version, "str_version");
 155   EXPECT_EQ(settings->client_infos()[0].client_version, "version");
 156   EXPECT_EQ(settings->client_infos()[1].client_name,
 157             "chromebook-{DEVICE_ASSET_ID}");
 158   EXPECT_EQ(settings->client_infos()[1].client_type,
 159             mojom::IppClientInfo::ClientType::kOther);
 160 #endif
 161   EXPECT_EQ(settings->dpi_horizontal(), 300);
 162   EXPECT_EQ(settings->dpi_vertical(), 300);
 163
 164   dict.Set("dpiVertical", 600);
 165   settings = PrintSettingsFromJobSettings(dict);
 166   ASSERT_TRUE(settings);
 167   EXPECT_EQ(settings->rasterize_pdf_dpi(), 150);
 168   EXPECT_EQ(settings->dpi_horizontal(), 300);
 169   EXPECT_EQ(settings->dpi_vertical(), 600);
 170
 171   EXPECT_TRUE(dict.Remove("dpiVertical"));
 172   settings = PrintSettingsFromJobSettings(dict);
 173   EXPECT_FALSE(settings);
 174 }
 175
 176 TEST(PrintSettingsConversionTest, WithValidImageableArea) {
 177 #if BUILDFLAG(IS_MAC)
 178   static constexpr gfx::Size kExpectedSize{595, 842};
 179   static constexpr gfx::Rect kExpectedPrintableArea{0, 0, 510, 839};
 180   const PageMargins kExpectedPageMargins(0, 3, 28, 85, 28, 28);
 181 #else
 182   static constexpr gfx::Size kExpectedSize{2480, 3508};
 183   static constexpr gfx::Rect kExpectedPrintableArea{0, 0, 2126, 3496};
 184   const PageMargins kExpectedPageMargins(0, 12, 118, 354, 118, 118);
 185 #endif
 186
 187   base::Value::Dict dict =
 188       base::test::ParseJsonDict(kPrinterSettingsWithImageableArea);
 189   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 190   ASSERT_TRUE(settings);
 191   EXPECT_EQ(settings->dpi_horizontal(), 300);
 192   EXPECT_EQ(settings->dpi_vertical(), 300);
 193   EXPECT_EQ(settings->page_setup_device_units().physical_size(), kExpectedSize);
 194   EXPECT_EQ(settings->page_setup_device_units().printable_area(),
 195             kExpectedPrintableArea);
 196   EXPECT_EQ(settings->page_setup_device_units().effective_margins(),
 197             kExpectedPageMargins);
 198 }
 199
 200 TEST(PrintSettingsConversionTest, WithValidFlippedImageableArea) {
 201 #if BUILDFLAG(IS_MAC)
 202   static constexpr gfx::Size kExpectedSize{842, 595};
 203   static constexpr gfx::Rect kExpectedPrintableArea{0, 85, 839, 510};
 204   const PageMargins kExpectedPageMargins(85, 0, 28, 28, 85, 28);
 205 #else
 206   static constexpr gfx::Size kExpectedSize{3508, 2480};
 207   static constexpr gfx::Rect kExpectedPrintableArea{0, 354, 3496, 2126};
 208   const PageMargins kExpectedPageMargins(354, 0, 118, 118, 354, 118);
 209 #endif
 210
 211   base::Value::Dict dict =
 212       base::test::ParseJsonDict(kPrinterSettingsWithImageableArea);
 213   dict.Set("landscape", true);
 214   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 215   ASSERT_TRUE(settings);
 216   EXPECT_EQ(settings->page_setup_device_units().physical_size(), kExpectedSize);
 217   EXPECT_EQ(settings->page_setup_device_units().printable_area(),
 218             kExpectedPrintableArea);
 219   EXPECT_EQ(settings->page_setup_device_units().effective_margins(),
 220             kExpectedPageMargins);
 221 }
 222
 223 TEST(PrintSettingsConversionTest, WithOutOfBoundsImageableArea) {
 224   base::Value::Dict dict =
 225       base::test::ParseJsonDict(kPrinterSettingsWithImageableArea);
 226   auto* media_size_dict = dict.FindDict("mediaSize");
 227   ASSERT_TRUE(media_size_dict);
 228   media_size_dict->Set("imageable_area_left_microns", -500);
 229   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 230   ASSERT_TRUE(settings);
 231   EXPECT_TRUE(settings->page_setup_device_units().physical_size().IsEmpty());
 232   EXPECT_TRUE(settings->page_setup_device_units().printable_area().IsEmpty());
 233   EXPECT_EQ(settings->page_setup_device_units().effective_margins(),
 234             PageMargins(0, 0, 0, 0, 0, 0));
 235 }
 236
 237 TEST(PrintSettingsConversionTest, WithMissingImageableAreaValue) {
 238   base::Value::Dict dict =
 239       base::test::ParseJsonDict(kPrinterSettingsWithImageableArea);
 240   auto* media_size_dict = dict.FindDict("mediaSize");
 241   ASSERT_TRUE(media_size_dict);
 242   media_size_dict->Remove("imageable_area_left_microns");
 243   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 244   ASSERT_TRUE(settings);
 245   EXPECT_TRUE(settings->page_setup_device_units().physical_size().IsEmpty());
 246   EXPECT_TRUE(settings->page_setup_device_units().printable_area().IsEmpty());
 247   EXPECT_EQ(settings->page_setup_device_units().effective_margins(),
 248             PageMargins(0, 0, 0, 0, 0, 0));
 249 }
 250
 251 TEST(PrintSettingsConversionTest, WithCustomMarginsAndImageableArea) {
 252   // Test imageable area with custom margins.
 253 #if BUILDFLAG(IS_MAC)
 254   static constexpr gfx::Size kExpectedSize{595, 842};
 255   static constexpr gfx::Rect kExpectedPrintableArea{0, 0, 510, 839};
 256   const PageMargins kExpectedPageMargins(0, 0, 30, 20, 80, 10);
 257 #else
 258   static constexpr gfx::Size kExpectedSize{2480, 3508};
 259   static constexpr gfx::Rect kExpectedPrintableArea{0, 0, 2126, 3496};
 260   const PageMargins kExpectedPageMargins(0, 0, 125, 83, 333, 42);
 261 #endif
 262
 263   base::Value::Dict dict =
 264       base::test::ParseJsonDict(kPrinterSettingsWithImageableArea);
 265   dict.Set("marginsType", static_cast<int>(mojom::MarginType::kCustomMargins));
 266   dict.Set("marginsCustom", base::test::ParseJson(kCustomMargins));
 267   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 268   ASSERT_TRUE(settings);
 269   const PageSetup& page_setup = settings->page_setup_device_units();
 270   EXPECT_EQ(page_setup.physical_size(), kExpectedSize);
 271   EXPECT_EQ(page_setup.printable_area(), kExpectedPrintableArea);
 272   EXPECT_EQ(page_setup.effective_margins(), kExpectedPageMargins);
 273 }
 274
 275 #if !BUILDFLAG(IS_MAC)
 276 TEST(PrintSettingsConversionTest, WithNonSquarePixels) {
 277   // Check that physical size and printable area are scaled by the max DPI
 278   // value. Not needed for macOS, which always has square pixels.
 279   static constexpr gfx::Size kExpectedSize{6614, 9354};
 280   static constexpr gfx::Rect kExpectedPrintableArea{0, 0, 5669, 9323};
 281
 282   base::Value::Dict dict =
 283       base::test::ParseJsonDict(kPrinterSettingsWithNonSquarePixels);
 284   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 285   ASSERT_TRUE(settings);
 286   EXPECT_EQ(settings->dpi_horizontal(), 800);
 287   EXPECT_EQ(settings->dpi_vertical(), 50);
 288   EXPECT_EQ(settings->page_setup_device_units().physical_size(), kExpectedSize);
 289   EXPECT_EQ(settings->page_setup_device_units().printable_area(),
 290             kExpectedPrintableArea);
 291 }
 292 #endif  // !BUILDFLAG(IS_MAC)
 293
 294 TEST(PrintSettingsConversionTest, MissingDeviceName) {
 295   base::Value::Dict dict = base::test::ParseJsonDict(kPrinterSettings);
 296   EXPECT_TRUE(dict.Remove("deviceName"));
 297   EXPECT_FALSE(PrintSettingsFromJobSettings(dict));
 298 }
 299
 300 #if BUILDFLAG(IS_CHROMEOS)
 301 TEST(PrintSettingsConversionTest, DontSendUsername) {
 302   base::Value::Dict dict = base::test::ParseJsonDict(kPrinterSettings);
 303   dict.Set(kSettingSendUserInfo, false);
 304   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 305   ASSERT_TRUE(settings);
 306   EXPECT_FALSE(settings->send_user_info());
 307   EXPECT_EQ("", settings->username());
 308 }
 309 #endif
 310
 311 #if BUILDFLAG(IS_CHROMEOS) || (BUILDFLAG(IS_LINUX) && BUILDFLAG(USE_CUPS))
 312 TEST(PrintSettingsConversionTest, FilterNonJobSettings) {
 313   base::Value::Dict dict = base::test::ParseJsonDict(kPrinterSettings);
 314
 315   {
 316     base::Value::Dict advanced_attributes;
 317     advanced_attributes.Set("printer-info", "yada");
 318     advanced_attributes.Set("printer-make-and-model", "yada");
 319     advanced_attributes.Set("system_driverinfo", "yada");
 320     advanced_attributes.Set("Foo", "Bar");
 321     dict.Set(kSettingAdvancedSettings, std::move(advanced_attributes));
 322   }
 323
 324   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 325   ASSERT_TRUE(settings);
 326   EXPECT_EQ(settings->advanced_settings().size(), 1u);
 327   ASSERT_TRUE(base::Contains(settings->advanced_settings(), "Foo"));
 328   EXPECT_EQ(settings->advanced_settings().at("Foo"), base::Value("Bar"));
 329 }
 330 #endif  // BUILDFLAG(IS_CHROMEOS) || (BUILDFLAG(IS_LINUX) &&
 331         // BUILDFLAG(USE_CUPS))
 332
 333 }  // namespace printing