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/print_settings.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace printing {
  15
  16 namespace {
  17
  18 const char kPrinterSettings[] = R"({
  19   "headerFooterEnabled": true,
  20   "title": "Test Doc",
  21   "url": "http://localhost/",
  22   "shouldPrintBackgrounds": false,
  23   "shouldPrintSelectionOnly": false,
  24   "mediaSize": {
  25     "height_microns": 297000,
  26     "width_microns": 210000
  27   },
  28   "marginsType": 0,
  29   "pageRange": [{
  30     "from": 1,
  31     "to": 1
  32   }],
  33   "collate": false,
  34   "copies": 1,
  35   "color": 2,
  36   "duplex": 0,
  37   "landscape": false,
  38   "deviceName": "printer",
  39   "scaleFactor": 100,
  40   "rasterizePDF": false,
  41   "rasterizePdfDpi": 150,
  42   "pagesPerSheet": 1,
  43   "dpiHorizontal": 300,
  44   "dpiVertical": 300,
  45   "previewModifiable": true,
  46   "sendUserInfo": true,
  47   "username": "username@domain.net",
  48   "pinValue": "0000"
  49 })";
  50
  51 const char kPrinterSettingsWithImageableArea[] = R"({
  52   "headerFooterEnabled": false,
  53   "title": "Test Doc",
  54   "url": "http://localhost/",
  55   "shouldPrintBackgrounds": false,
  56   "shouldPrintSelectionOnly": false,
  57   "mediaSize": {
  58     "height_microns": 297000,
  59     "imageable_area_bottom_microns": 1000,
  60     "imageable_area_left_microns": 0,
  61     "imageable_area_right_microns": 180000,
  62     "imageable_area_top_microns": 297000,
  63     "width_microns": 210000
  64   },
  65   "collate": false,
  66   "copies": 1,
  67   "color": 2,
  68   "duplex": 0,
  69   "landscape": false,
  70   "deviceName": "printer",
  71   "scaleFactor": 100,
  72   "rasterizePDF": false,
  73   "pagesPerSheet": 1,
  74   "dpiHorizontal": 300,
  75   "dpiVertical": 300,
  76 })";
  77
  78 }  // namespace
  79
  80 TEST(PrintSettingsConversionTest, InvalidSettings) {
  81   base::Value value = base::test::ParseJson("{}");
  82   ASSERT_TRUE(value.is_dict());
  83   EXPECT_FALSE(PrintSettingsFromJobSettings(value.GetDict()));
  84 }
  85
  86 TEST(PrintSettingsConversionTest, Conversion) {
  87   base::Value value = base::test::ParseJson(kPrinterSettings);
  88   ASSERT_TRUE(value.is_dict());
  89   auto& dict = value.GetDict();
  90   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
  91   ASSERT_TRUE(settings);
  92 #if BUILDFLAG(IS_CHROMEOS)
  93   EXPECT_TRUE(settings->send_user_info());
  94   EXPECT_EQ("username@domain.net", settings->username());
  95   EXPECT_EQ("0000", settings->pin_value());
  96 #endif
  97   EXPECT_EQ(settings->dpi_horizontal(), 300);
  98   EXPECT_EQ(settings->dpi_vertical(), 300);
  99
 100   dict.Set("dpiVertical", 600);
 101   settings = PrintSettingsFromJobSettings(dict);
 102   ASSERT_TRUE(settings);
 103   EXPECT_EQ(settings->rasterize_pdf_dpi(), 150);
 104   EXPECT_EQ(settings->dpi_horizontal(), 300);
 105   EXPECT_EQ(settings->dpi_vertical(), 600);
 106
 107   EXPECT_TRUE(dict.Remove("dpiVertical"));
 108   settings = PrintSettingsFromJobSettings(dict);
 109   EXPECT_FALSE(settings);
 110 }
 111
 112 TEST(PrintSettingsConversionTest, ConversionTestWithValidImageableArea) {
 113   base::Value value = base::test::ParseJson(kPrinterSettingsWithImageableArea);
 114   ASSERT_TRUE(value.is_dict());
 115   auto& dict = value.GetDict();
 116   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 117   ASSERT_TRUE(settings);
 118   EXPECT_EQ(settings->dpi_horizontal(), 300);
 119   EXPECT_EQ(settings->dpi_vertical(), 300);
 120   EXPECT_EQ(settings->page_setup_device_units().physical_size(),
 121             gfx::Size(2480, 3508));
 122   EXPECT_EQ(settings->page_setup_device_units().printable_area(),
 123             gfx::Rect(0, 0, 2126, 3496));
 124 }
 125
 126 TEST(PrintSettingsConversionTest, ConversionTestWithValidFlippedImageableArea) {
 127   base::Value value = base::test::ParseJson(kPrinterSettingsWithImageableArea);
 128   ASSERT_TRUE(value.is_dict());
 129   auto& dict = value.GetDict();
 130   dict.Set("landscape", true);
 131   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 132   ASSERT_TRUE(settings);
 133   EXPECT_EQ(settings->page_setup_device_units().physical_size(),
 134             gfx::Size(3508, 2480));
 135   EXPECT_EQ(settings->page_setup_device_units().printable_area(),
 136             gfx::Rect(0, 354, 3496, 2126));
 137 }
 138
 139 TEST(PrintSettingsConversionTest, ConversionTestWithOutOfBoundsImageableArea) {
 140   base::Value value = base::test::ParseJson(kPrinterSettingsWithImageableArea);
 141   ASSERT_TRUE(value.is_dict());
 142   auto& dict = value.GetDict();
 143   auto* media_size_dict = dict.FindDict("mediaSize");
 144   ASSERT_TRUE(media_size_dict);
 145   media_size_dict->Set("imageable_area_left_microns", -500);
 146   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 147   ASSERT_TRUE(settings);
 148   EXPECT_TRUE(settings->page_setup_device_units().physical_size().IsEmpty());
 149   EXPECT_TRUE(settings->page_setup_device_units().printable_area().IsEmpty());
 150 }
 151
 152 TEST(PrintSettingsConversionTest, ConversionTestWithMissingImageableAreaValue) {
 153   base::Value value = base::test::ParseJson(kPrinterSettingsWithImageableArea);
 154   ASSERT_TRUE(value.is_dict());
 155   auto& dict = value.GetDict();
 156   auto* media_size_dict = dict.FindDict("mediaSize");
 157   ASSERT_TRUE(media_size_dict);
 158   media_size_dict->Remove("imageable_area_left_microns");
 159   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 160   ASSERT_TRUE(settings);
 161   EXPECT_TRUE(settings->page_setup_device_units().physical_size().IsEmpty());
 162   EXPECT_TRUE(settings->page_setup_device_units().printable_area().IsEmpty());
 163 }
 164
 165 TEST(PrintSettingsConversionTest, MissingDeviceName) {
 166   base::Value value = base::test::ParseJson(kPrinterSettings);
 167   ASSERT_TRUE(value.is_dict());
 168   auto& dict = value.GetDict();
 169   dict.Remove("deviceName");
 170   EXPECT_FALSE(PrintSettingsFromJobSettings(dict));
 171 }
 172
 173 #if BUILDFLAG(IS_CHROMEOS)
 174 TEST(PrintSettingsConversionTest, DontSendUsername) {
 175   base::Value value = base::test::ParseJson(kPrinterSettings);
 176   ASSERT_TRUE(value.is_dict());
 177   auto& dict = value.GetDict();
 178   dict.Set(kSettingSendUserInfo, false);
 179   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 180   ASSERT_TRUE(settings);
 181   EXPECT_FALSE(settings->send_user_info());
 182   EXPECT_EQ("", settings->username());
 183 }
 184 #endif
 185
 186 #if BUILDFLAG(IS_CHROMEOS) || (BUILDFLAG(IS_LINUX) && defined(USE_CUPS))
 187 TEST(PrintSettingsConversionTest, FilterNonJobSettings) {
 188   base::Value value = base::test::ParseJson(kPrinterSettings);
 189   ASSERT_TRUE(value.is_dict());
 190   auto& dict = value.GetDict();
 191
 192   {
 193     base::Value::Dict advanced_attributes;
 194     advanced_attributes.Set("printer-info", "yada");
 195     advanced_attributes.Set("printer-make-and-model", "yada");
 196     advanced_attributes.Set("system_driverinfo", "yada");
 197     advanced_attributes.Set("Foo", "Bar");
 198     dict.Set(kSettingAdvancedSettings, std::move(advanced_attributes));
 199   }
 200
 201   std::unique_ptr<PrintSettings> settings = PrintSettingsFromJobSettings(dict);
 202   ASSERT_TRUE(settings);
 203   EXPECT_EQ(settings->advanced_settings().size(), 1u);
 204   ASSERT_TRUE(base::Contains(settings->advanced_settings(), "Foo"));
 205   EXPECT_EQ(settings->advanced_settings().at("Foo"), base::Value("Bar"));
 206 }
 207 #endif  // BUILDFLAG(IS_CHROMEOS) || (BUILDFLAG(IS_LINUX) && defined(USE_CUPS))
 208
 209 }  // namespace printing