示例#1
0
    def test_proxy_wait_for_upgrade_fail(self):
        """Verify proxy_wait_for_upgrade throws expected exceptions."""
        with patch(self.SLEEP_FUNC, return_value=None):
            self._set_args({
                "firmware": "test_firmware.dlp",
                "nvsram": "test_nvsram.dlp"
            })
            firmware = NetAppESeriesFirmware()

            firmware.is_firmware_bundled = lambda: True
            with self.assertRaisesRegexp(
                    AnsibleFailJson,
                    "Failed to retrieve firmware upgrade status."):
                with patch(self.REQUEST_FUNC, return_value=Exception()):
                    firmware.proxy_wait_for_upgrade("1")

            firmware.is_firmware_bundled = lambda: False
            with self.assertRaisesRegexp(
                    AnsibleFailJson,
                    "Timed out waiting for firmware upgrade to complete."):
                with patch(self.REQUEST_FUNC, return_value=Exception()):
                    firmware.proxy_wait_for_upgrade("1")

            firmware.is_firmware_bundled = lambda: True
            with self.assertRaisesRegexp(
                    AnsibleFailJson, "Firmware upgrade failed to complete."):
                with patch(self.REQUEST_FUNC,
                           side_effect=[(200, {
                               "status": "not_done"
                           }), (200, {
                               "status": "failed"
                           })]):
                    firmware.proxy_wait_for_upgrade("1")
示例#2
0
    def test_proxy_wait_for_upgrade_pass(self):
        """Verify proxy_wait_for_upgrade."""
        with patch(self.SLEEP_FUNC, return_value=None):
            self._set_args({
                "firmware": "test_firmware.dlp",
                "nvsram": "expected_nvsram.dlp"
            })
            firmware = NetAppESeriesFirmware()

            firmware.is_firmware_bundled = lambda: True
            with patch(self.REQUEST_FUNC,
                       side_effect=[(200, {
                           "status": "not_done"
                       }), (200, {
                           "status": "complete"
                       })]):
                firmware.proxy_wait_for_upgrade("1")

            firmware.is_firmware_bundled = lambda: False
            firmware.firmware_version = lambda: b"08.50.00.00"
            firmware.nvsram_version = lambda: b"expected_nvsram"
            with patch(self.REQUEST_FUNC,
                       side_effect=[(200, ["08.40.00.00"]),
                                    (200, ["not_expected_nvsram"]),
                                    (200, ["08.50.00.00"]),
                                    (200, ["expected_nvsram"])]):
                firmware.proxy_wait_for_upgrade("1")
示例#3
0
 def test_is_firmware_bundles_fail(self):
     """Verify non-firmware fails."""
     self._set_args({"firmware": "test.dlp", "nvsram": "test.dlp"})
     with patch(builtin_path,
                mock_open(read_data=b"xxxxxxxxxxxxxxxx")) as mock_file:
         firmware = NetAppESeriesFirmware()
         with self.assertRaisesRegexp(AnsibleFailJson,
                                      "Firmware file is invalid."):
             firmware.is_firmware_bundled()
示例#4
0
    def test_proxy_check_upgrade_required_fail(self):
        """Verify proxy_check_upgrade_required throws expected exceptions."""
        self._set_args({
            "firmware": "test_firmware.dlp",
            "nvsram": "test_nvsram.dlp"
        })
        firmware = NetAppESeriesFirmware()

        firmware.firmware_version = lambda: b"08.42.50.00"
        firmware.nvsram_version = lambda: b"not_nvsram_version"
        with self.assertRaisesRegexp(
                AnsibleFailJson,
                "Failed to retrieve controller firmware information."):
            with patch(self.REQUEST_FUNC, return_value=Exception()):
                firmware.proxy_check_upgrade_required()

        with self.assertRaisesRegexp(
                AnsibleFailJson,
                "Failed to retrieve storage system's NVSRAM version."):
            with patch(self.REQUEST_FUNC,
                       side_effect=[(200, [{
                           "versionString": "08.42.50.00"
                       }]),
                                    Exception()]):
                firmware.is_firmware_bundled = lambda: True
                firmware.proxy_check_upgrade_required()

        with self.assertRaisesRegexp(
                AnsibleFailJson,
                "Failed to retrieve storage system's NVSRAM version."):
            with patch(self.REQUEST_FUNC,
                       side_effect=[(200, ["08.42.50.00"]),
                                    Exception()]):
                firmware.is_firmware_bundled = lambda: False
                firmware.proxy_check_upgrade_required()

        with self.assertRaisesRegexp(AnsibleFailJson,
                                     "Downgrades are not permitted."):
            with patch(self.REQUEST_FUNC,
                       side_effect=[(200, [{
                           "versionString": "08.42.50.00"
                       }]), (200, ["nvsram_version"])]):
                firmware.firmware_version = lambda: b"08.40.00.00"
                firmware.nvsram_version = lambda: "nvsram_version"
                firmware.is_firmware_bundled = lambda: True
                firmware.proxy_check_upgrade_required()

        with self.assertRaisesRegexp(AnsibleFailJson,
                                     "Downgrades are not permitted."):
            with patch(self.REQUEST_FUNC,
                       side_effect=[(200, ["08.42.50.00"]),
                                    (200, ["nvsram_version"])]):
                firmware.is_firmware_bundled = lambda: False
                firmware.proxy_check_upgrade_required()
示例#5
0
    def test_is_firmware_bundled_pass(self):
        """Determine whether firmware file is bundled."""
        self._set_args({"firmware": "test.dlp", "nvsram": "test.dlp"})
        with patch(builtin_path,
                   mock_open(read_data=b"firmwarexxxxxxxx")) as mock_file:
            firmware = NetAppESeriesFirmware()
            self.assertEqual(firmware.is_firmware_bundled(), False)

        self._set_args({"firmware": "test.dlp", "nvsram": "test.dlp"})
        with patch(builtin_path,
                   mock_open(read_data=self.BUNDLE_HEADER[:16])) as mock_file:
            firmware = NetAppESeriesFirmware()
            self.assertEqual(firmware.is_firmware_bundled(), True)
示例#6
0
 def test_firmware_version(self):
     """Verify correct firmware version is returned."""
     self._set_args({"firmware": "test.dlp", "nvsram": "test.dlp"})
     firmware = NetAppESeriesFirmware()
     firmware.is_firmware_bundled = lambda: True
     with patch(builtin_path,
                mock_open_with_iter(
                    read_data=self.BUNDLE_HEADER)) as mock_file:
         self.assertEqual(firmware.firmware_version(), b"11.40.5")
示例#7
0
    def test_proxy_upgrade_fail(self):
        """Verify proxy_upgrade throws expected exceptions."""
        self._set_args({
            "firmware": "test_firmware.dlp",
            "nvsram": "test_nvsram.dlp"
        })
        firmware = NetAppESeriesFirmware()

        firmware.is_firmware_bundled = lambda: True
        with self.assertRaisesRegexp(AnsibleFailJson,
                                     "Failed to initiate firmware upgrade."):
            with patch(self.REQUEST_FUNC, return_value=Exception()):
                firmware.proxy_upgrade()

        firmware.is_firmware_bundled = lambda: False
        with self.assertRaisesRegexp(AnsibleFailJson,
                                     "Failed to initiate firmware upgrade."):
            with patch(self.REQUEST_FUNC, return_value=Exception()):
                firmware.proxy_upgrade()
示例#8
0
    def test_proxy_check_upgrade_required_pass(self):
        """Verify proxy_check_upgrade_required."""
        self._set_args({
            "firmware": "test_firmware.dlp",
            "nvsram": "test_nvsram.dlp"
        })
        firmware = NetAppESeriesFirmware()

        firmware.firmware_version = lambda: b"08.42.50.00"
        firmware.nvsram_version = lambda: b"nvsram_version"
        with patch(self.REQUEST_FUNC,
                   side_effect=[(200, [{
                       "versionString": "08.42.50.00"
                   }]), (200, ["nvsram_version"])]):
            firmware.is_firmware_bundled = lambda: True
            firmware.proxy_check_upgrade_required()
            self.assertFalse(firmware.upgrade_required)

        with patch(self.REQUEST_FUNC,
                   side_effect=[(200, ["08.42.50.00"]),
                                (200, ["nvsram_version"])]):
            firmware.is_firmware_bundled = lambda: False
            firmware.proxy_check_upgrade_required()
            self.assertFalse(firmware.upgrade_required)

        firmware.firmware_version = lambda: b"08.42.50.00"
        firmware.nvsram_version = lambda: b"not_nvsram_version"
        with patch(self.REQUEST_FUNC,
                   side_effect=[(200, [{
                       "versionString": "08.42.50.00"
                   }]), (200, ["nvsram_version"])]):
            firmware.is_firmware_bundled = lambda: True
            firmware.proxy_check_upgrade_required()
            self.assertTrue(firmware.upgrade_required)

        with patch(self.REQUEST_FUNC,
                   side_effect=[(200, ["08.42.50.00"]),
                                (200, ["nvsram_version"])]):
            firmware.is_firmware_bundled = lambda: False
            firmware.proxy_check_upgrade_required()
            self.assertTrue(firmware.upgrade_required)

        firmware.firmware_version = lambda: b"08.52.00.00"
        firmware.nvsram_version = lambda: b"nvsram_version"
        with patch(self.REQUEST_FUNC,
                   side_effect=[(200, [{
                       "versionString": "08.42.50.00"
                   }]), (200, ["nvsram_version"])]):
            firmware.is_firmware_bundled = lambda: True
            firmware.proxy_check_upgrade_required()
            self.assertTrue(firmware.upgrade_required)

        with patch(self.REQUEST_FUNC,
                   side_effect=[(200, ["08.42.50.00"]),
                                (200, ["nvsram_version"])]):
            firmware.is_firmware_bundled = lambda: False
            firmware.proxy_check_upgrade_required()
            self.assertTrue(firmware.upgrade_required)

        firmware.firmware_version = lambda: b"08.52.00.00"
        firmware.nvsram_version = lambda: b"not_nvsram_version"
        with patch(self.REQUEST_FUNC,
                   side_effect=[(200, [{
                       "versionString": "08.42.50.00"
                   }]), (200, ["nvsram_version"])]):
            firmware.is_firmware_bundled = lambda: True
            firmware.proxy_check_upgrade_required()
            self.assertTrue(firmware.upgrade_required)

        with patch(self.REQUEST_FUNC,
                   side_effect=[(200, ["08.42.50.00"]),
                                (200, ["nvsram_version"])]):
            firmware.is_firmware_bundled = lambda: False
            firmware.proxy_check_upgrade_required()
            self.assertTrue(firmware.upgrade_required)