Print Preview: Move policy tests

Moving policy tests to new model_settings_policy_test.js, similar to
what was done with the availability tests, since almost all the logic
tested is in model.js.

Also adding 2 small tests verifying that the corresponding settings
sections disable their controls when the setting is set by policy.

Change-Id: Ife0563e517a002ddd29a3fa62031fcd7ec47136e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1501948
Commit-Queue: Rebekah Potter <rbpotter@chromium.org>
Reviewed-by: Esmael El-Moslimany <aee@chromium.org>
Cr-Commit-Position: refs/heads/master@{#637874}

chrome/test/data/webui/print_preview/color_settings_test.js

@@ -46,5 +46,18 @@ cr.define('color_settings_test', function() {
       await print_preview_test_utils.selectOption(colorSection, 'bw');
       assertFalse(colorSection.getSettingValue('color'));
     });
+
+    if (cr.isChromeOS) {
+      // Tests that if the setting is enforced by enterprise policy it is
+      // disabled.
+      test('disabled by policy', function() {
+        // Verify that the selected option and names are as expected.
+        const select = colorSection.$$('select');
+        assertFalse(select.disabled);
+
+        colorSection.set('settings.color.setByPolicy', true);
+        assertTrue(select.disabled);
+      });
+    }
   });
 });

chrome/test/data/webui/print_preview/model_settings_policy_test.js

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+cr.define('model_settings_policy_test', function() {
+  suite('ModelSettingsPolicyTest', function() {
+    let model = null;
+
+    /** @override */
+    setup(function() {
+      PolymerTest.clearBody();
+      model = document.createElement('print-preview-model');
+      document.body.appendChild(model);
+
+      model.documentSettings = {
+        hasCssMediaStyles: false,
+        hasSelection: false,
+        isModifiable: true,
+        isScalingDisabled: false,
+        fitToPageScaling: 100,
+        pageCount: 3,
+        title: 'title',
+      };
+
+      model.pageSize = new print_preview.Size(612, 792);
+      model.margins = new print_preview.Margins(72, 72, 72, 72);
+
+      // Create a test destination.
+      model.destination = new print_preview.Destination(
+          'FooDevice', print_preview.DestinationType.LOCAL,
+          print_preview.DestinationOrigin.LOCAL, 'FooName',
+          print_preview.DestinationConnectionStatus.ONLINE);
+      model.set(
+          'destination.capabilities',
+          print_preview_test_utils.getCddTemplate(model.destination.id)
+              .capabilities);
+    });
+
+    test('color managed', function() {
+      // Remove color capability.
+      let capabilities =
+          print_preview_test_utils.getCddTemplate(model.destination.id)
+              .capabilities;
+      delete capabilities.printer.color;
+
+      [{
+        // Policy has no effect, setting unavailable
+        colorCap: {option: [{type: 'STANDARD_COLOR', is_default: true}]},
+        colorPolicy: print_preview.ColorMode.COLOR,
+        colorDefault: print_preview.ColorMode.COLOR,
+        expectedValue: true,
+        expectedAvailable: false,
+        expectedManaged: false,
+        expectedEnforced: true,
+      },
+       {
+         // Policy contradicts actual capabilities, setting unavailable.
+         colorCap: {option: [{type: 'STANDARD_COLOR', is_default: true}]},
+         colorPolicy: print_preview.ColorMode.GRAY,
+         colorDefault: print_preview.ColorMode.GRAY,
+         expectedValue: true,
+         expectedAvailable: false,
+         expectedManaged: false,
+         expectedEnforced: true,
+       },
+       {
+         // Policy overrides default.
+         colorCap: {
+           option: [
+             {type: 'STANDARD_MONOCHROME', is_default: true},
+             {type: 'STANDARD_COLOR'}
+           ]
+         },
+         colorPolicy: print_preview.ColorMode.COLOR,
+         // Default mismatches restriction and is ignored.
+         colorDefault: print_preview.ColorMode.GRAY,
+         expectedValue: true,
+         expectedAvailable: true,
+         expectedManaged: true,
+         expectedEnforced: true,
+       },
+       {
+         // Default defined by policy but setting is modifiable.
+         colorCap: {
+           option: [
+             {type: 'STANDARD_MONOCHROME', is_default: true},
+             {type: 'STANDARD_COLOR'}
+           ]
+         },
+         colorDefault: print_preview.ColorMode.COLOR,
+         expectedValue: true,
+         expectedAvailable: true,
+         expectedManaged: false,
+         expectedEnforced: false,
+       }].forEach(subtestParams => {
+        capabilities =
+            print_preview_test_utils.getCddTemplate(model.destination.id)
+                .capabilities;
+        capabilities.printer.color = subtestParams.colorCap;
+        const policies = {
+          allowedColorModes: subtestParams.colorPolicy,
+          defaultColorMode: subtestParams.colorDefault,
+        };
+        // In practice |capabilities| are always set after |policies| and
+        // observers only check for |capabilities|, so the order is important.
+        model.set('destination.policies', policies);
+        model.set('destination.capabilities', capabilities);
+        model.applyDestinationSpecificPolicies();
+        assertEquals(
+            subtestParams.expectedValue, model.getSettingValue('color'));
+        assertEquals(
+            subtestParams.expectedAvailable, model.settings.color.available);
+        assertEquals(subtestParams.expectedManaged, model.controlsManaged);
+        assertEquals(
+            subtestParams.expectedEnforced, model.settings.color.setByPolicy);
+      });
+    });
+
+    test('duplex managed', function() {
+      // Remove duplex capability.
+      let capabilities =
+          print_preview_test_utils.getCddTemplate(model.destination.id)
+              .capabilities;
+      delete capabilities.printer.duplex;
+
+      [{
+        // Policy has no effect.
+        duplexCap: {option: [{type: 'NO_DUPLEX', is_default: true}]},
+        duplexPolicy: print_preview.DuplexModeRestriction.SIMPLEX,
+        duplexDefault: print_preview.DuplexModeRestriction.SIMPLEX,
+        expectedValue: false,
+        expectedAvailable: false,
+        expectedManaged: false,
+        expectedEnforced: true,
+      },
+       {
+         // Policy contradicts actual capabilities and is ignored.
+         duplexCap: {option: [{type: 'NO_DUPLEX', is_default: true}]},
+         duplexPolicy: print_preview.DuplexModeRestriction.DUPLEX,
+         duplexDefault: print_preview.DuplexModeRestriction.LONG_EDGE,
+         expectedValue: false,
+         expectedAvailable: false,
+         expectedManaged: false,
+         expectedEnforced: true,
+       },
+       {
+         // Policy overrides default.
+         duplexCap: {
+           option: [
+             {type: 'NO_DUPLEX', is_default: true}, {type: 'LONG_EDGE'},
+             {type: 'SHORT_EDGE'}
+           ]
+         },
+         duplexPolicy: print_preview.DuplexModeRestriction.DUPLEX,
+         // Default mismatches restriction and is ignored.
+         duplexDefault: print_preview.DuplexModeRestriction.SIMPLEX,
+         expectedValue: true,
+         expectedAvailable: true,
+         expectedManaged: true,
+         expectedEnforced: true,
+       },
+       {
+         // Default defined by policy but setting is modifiable.
+         duplexCap: {
+           option: [
+             {type: 'NO_DUPLEX', is_default: true}, {type: 'LONG_EDGE'},
+             {type: 'SHORT_EDGE'}
+           ]
+         },
+         duplexDefault: print_preview.DuplexModeRestriction.LONG_EDGE,
+         expectedValue: true,
+         expectedAvailable: true,
+         expectedManaged: false,
+         expectedEnforced: false,
+       }].forEach(subtestParams => {
+        capabilities =
+            print_preview_test_utils.getCddTemplate('FooPrinter').capabilities;
+        capabilities.printer.duplex = subtestParams.duplexCap;
+        const policies = {
+          allowedDuplexModes: subtestParams.duplexPolicy,
+          defaultDuplexMode: subtestParams.duplexDefault,
+        };
+        // In practice |capabilities| are always set after |policies| and
+        // observers only check for |capabilities|, so the order is important.
+        model.set('destination.policies', policies);
+        model.set('destination.capabilities', capabilities);
+        model.applyDestinationSpecificPolicies();
+        assertEquals(
+            subtestParams.expectedValue, model.getSettingValue('duplex'));
+        assertEquals(
+            subtestParams.expectedAvailable, model.settings.duplex.available);
+        assertEquals(subtestParams.expectedManaged, model.controlsManaged);
+        assertEquals(
+            subtestParams.expectedEnforced, model.settings.duplex.setByPolicy);
+      });
+    });
+  });
+});

chrome/test/data/webui/print_preview/new_print_preview_ui_browsertest.js

@@ -103,16 +103,6 @@ TEST_F('PrintPreviewSettingsSectionsTest', 'PresetDuplex', function() {
   this.runMochaTest(settings_sections_tests.TestNames.PresetDuplex);
 });
 
-GEN('#if defined(OS_CHROMEOS)');
-TEST_F('PrintPreviewSettingsSectionsTest', 'ColorManaged', function() {
-  this.runMochaTest(settings_sections_tests.TestNames.ColorManaged);
-});
-
-TEST_F('PrintPreviewSettingsSectionsTest', 'DuplexManaged', function() {
-  this.runMochaTest(settings_sections_tests.TestNames.DuplexManaged);
-});
-GEN('#endif');
-
 PrintPreviewPagesSettingsTest = class extends NewPrintPreviewTest {
   /** @override */
   get browsePreload() {
@@ -355,6 +345,28 @@ TEST_F('PrintPreviewModelSettingsAvailabilityTest', 'All', function() {
   mocha.run();
 });
 
+GEN('#if defined(OS_CHROMEOS)');
+PrintPreviewModelSettingsPolicyTest = class extends NewPrintPreviewTest {
+  /** @override */
+  get browsePreload() {
+    return 'chrome://print/new/model.html';
+  }
+
+  /** @override */
+  get extraLibraries() {
+    return super.extraLibraries.concat([
+      '../settings/test_util.js',
+      'print_preview_test_utils.js',
+      'model_settings_policy_test.js',
+    ]);
+  }
+};
+
+TEST_F('PrintPreviewModelSettingsPolicyTest', 'All', function() {
+  mocha.run();
+});
+GEN('#endif');
+
 PrintPreviewPreviewGenerationTest = class extends NewPrintPreviewTest {
   /** @override */
   get browsePreload() {

chrome/test/data/webui/print_preview/other_options_settings_test.js

@@ -110,13 +110,29 @@ cr.define('other_options_settings_test', function() {
       ['headerFooter', 'duplex', 'cssBackground', 'rasterize', 'selectionOnly']
           .forEach(setting => {
             const checkbox = otherOptionsSection.$$(`#${setting}`);
-            // Set false and then true.
+            // Set true and then false.
             [true, false].forEach(value => {
               otherOptionsSection.setSetting(setting, value);
-              // Element expected to be visible when available.
+              // Element expected to be checked when setting is true.
               assertEquals(value, checkbox.checked);
             });
           });
     });
+
+    // Tests that if settings are enforced by enterprise policy the checkbox
+    // is disabled.
+    test('disabled by policy', function() {
+      const policyControlledSettings =
+          cr.isChromeOS ? ['headerFooter', 'duplex'] : ['headerFooter'];
+      policyControlledSettings.forEach(setting => {
+        const checkbox = otherOptionsSection.$$(`#${setting}`);
+        // Set true and then false.
+        [true, false].forEach(value => {
+          otherOptionsSection.set(`settings.${setting}.setByPolicy`, value);
+          // Element expected to be disabled when policy is set.
+          assertEquals(value, checkbox.disabled);
+        });
+      });
+    });
   });
 });

chrome/test/data/webui/print_preview/settings_section_test.js

@@ -8,8 +8,6 @@ cr.define('settings_sections_tests', function() {
     SettingsSectionsVisibilityChange: 'settings sections visibility change',
     PresetCopies: 'preset copies',
     PresetDuplex: 'preset duplex',
-    ColorManaged: 'color managed',
-    DuplexManaged: 'duplex managed',
   };
 
   const suiteName = 'SettingsSectionsTests';
@@ -104,168 +102,6 @@ cr.define('settings_sections_tests', function() {
       assertTrue(page.settings.duplex.value);
       assertTrue(checkbox.checked);
     });
-
-    test(assert(TestNames.ColorManaged), function() {
-      const colorElement = page.$$('print-preview-color-settings');
-      assertFalse(colorElement.hidden);
-
-      // Remove color capability.
-      let capabilities =
-          print_preview_test_utils.getCddTemplate('FooPrinter').capabilities;
-      delete capabilities.printer.color;
-
-      [{
-        // Policy has no effect.
-        colorCap: {option: [{type: 'STANDARD_COLOR', is_default: true}]},
-        colorPolicy: print_preview.ColorMode.COLOR,
-        colorDefault: print_preview.ColorMode.COLOR,
-        expectedValue: true,
-        expectedHidden: true,
-        expectedManaged: false,
-      },
-       {
-         // Policy contradicts actual capabilities and is ignored.
-         colorCap: {option: [{type: 'STANDARD_COLOR', is_default: true}]},
-         colorPolicy: print_preview.ColorMode.GRAY,
-         colorDefault: print_preview.ColorMode.GRAY,
-         expectedValue: true,
-         expectedHidden: true,
-         expectedManaged: false,
-       },
-       {
-         // Policy overrides default.
-         colorCap: {
-           option: [
-             {type: 'STANDARD_MONOCHROME', is_default: true},
-             {type: 'STANDARD_COLOR'}
-           ]
-         },
-         colorPolicy: print_preview.ColorMode.COLOR,
-         // Default mismatches restriction and is ignored.
-         colorDefault: print_preview.ColorMode.GRAY,
-         expectedValue: true,
-         expectedHidden: false,
-         expectedManaged: true,
-       },
-       {
-         // Default defined by policy but setting is modifiable.
-         colorCap: {
-           option: [
-             {type: 'STANDARD_MONOCHROME', is_default: true},
-             {type: 'STANDARD_COLOR'}
-           ]
-         },
-         colorDefault: print_preview.ColorMode.COLOR,
-         expectedValue: true,
-         expectedHidden: false,
-         expectedManaged: false,
-       }].forEach(subtestParams => {
-        capabilities =
-            print_preview_test_utils.getCddTemplate('FooPrinter').capabilities;
-        capabilities.printer.color = subtestParams.colorCap;
-        const policies = {
-          allowedColorModes: subtestParams.colorPolicy,
-          defaultColorMode: subtestParams.colorDefault,
-        };
-        // In practice |capabilities| are always set after |policies| and
-        // observers only check for |capabilities|, so the order is important.
-        page.set('destination_.policies', policies);
-        page.set('destination_.capabilities', capabilities);
-        page.$$('print-preview-model').applyDestinationSpecificPolicies();
-        assertEquals(subtestParams.expectedManaged, page.controlsManaged_);
-        assertEquals(
-            subtestParams.expectedValue, page.getSettingValue('color'));
-        assertEquals(subtestParams.expectedHidden, colorElement.hidden);
-        if (!subtestParams.expectedHidden) {
-          const selectElement = colorElement.$$('select');
-          assertEquals(
-              subtestParams.expectedValue ? 'color' : 'bw',
-              selectElement.value);
-          assertEquals(subtestParams.expectedManaged, selectElement.disabled);
-        }
-      });
-    });
-
-    test(assert(TestNames.DuplexManaged), function() {
-      toggleMoreSettings();
-      const optionsElement = page.$$('print-preview-other-options-settings');
-      const duplexElement = optionsElement.$$('#duplex');
-
-      // Remove duplex capability.
-      let capabilities =
-          print_preview_test_utils.getCddTemplate('FooPrinter').capabilities;
-      delete capabilities.printer.duplex;
-
-      [{
-        // Policy has no effect.
-        duplexCap: {option: [{type: 'NO_DUPLEX', is_default: true}]},
-        duplexPolicy: print_preview.DuplexModeRestriction.SIMPLEX,
-        duplexDefault: print_preview.DuplexModeRestriction.SIMPLEX,
-        expectedValue: false,
-        expectedHidden: true,
-        expectedManaged: false,
-      },
-       {
-         // Policy contradicts actual capabilities and is ignored.
-         duplexCap: {option: [{type: 'NO_DUPLEX', is_default: true}]},
-         duplexPolicy: print_preview.DuplexModeRestriction.DUPLEX,
-         duplexDefault: print_preview.DuplexModeRestriction.LONG_EDGE,
-         expectedValue: false,
-         expectedHidden: true,
-         expectedManaged: false,
-       },
-       {
-         // Policy overrides default.
-         duplexCap: {
-           option: [
-             {type: 'NO_DUPLEX', is_default: true}, {type: 'LONG_EDGE'},
-             {type: 'SHORT_EDGE'}
-           ]
-         },
-         duplexPolicy: print_preview.DuplexModeRestriction.DUPLEX,
-         // Default mismatches restriction and is ignored.
-         duplexDefault: print_preview.DuplexModeRestriction.SIMPLEX,
-         expectedValue: true,
-         expectedHidden: false,
-         expectedManaged: true,
-       },
-       {
-         // Default defined by policy but setting is modifiable.
-         duplexCap: {
-           option: [
-             {type: 'NO_DUPLEX', is_default: true}, {type: 'LONG_EDGE'},
-             {type: 'SHORT_EDGE'}
-           ]
-         },
-         duplexDefault: print_preview.DuplexModeRestriction.LONG_EDGE,
-         expectedValue: true,
-         expectedHidden: false,
-         expectedManaged: false,
-       }].forEach(subtestParams => {
-        capabilities =
-            print_preview_test_utils.getCddTemplate('FooPrinter').capabilities;
-        capabilities.printer.duplex = subtestParams.duplexCap;
-        const policies = {
-          allowedDuplexModes: subtestParams.duplexPolicy,
-          defaultDuplexMode: subtestParams.duplexDefault,
-        };
-        // In practice |capabilities| are always set after |policies| and
-        // observers only check for |capabilities|, so the order is important.
-        page.set('destination_.policies', policies);
-        page.set('destination_.capabilities', capabilities);
-        page.$$('print-preview-model').applyDestinationSpecificPolicies();
-        assertEquals(subtestParams.expectedManaged, page.controlsManaged_);
-        assertEquals(
-            subtestParams.expectedValue, page.getSettingValue('duplex'));
-        assertEquals(
-            subtestParams.expectedHidden,
-            duplexElement.parentNode.parentNode.hidden);
-        if (!subtestParams.expectedHidden) {
-          assertEquals(subtestParams.expectedValue, duplexElement.checked);
-          assertEquals(subtestParams.expectedManaged, duplexElement.disabled);
-        }
-      });
-    });
   });
 
   return {