def test_wait_for_delete(self):
        _ctx = self._gen_decorators_context('test_wait_for_delete')

        @decorators.wait_for_delete(status_deleted=['deleted'],
                                    status_pending=['pending'])
        def test_delete(*agrs, **kwargs):
            pass

        # deleted
        mock_interface = MagicMock()
        mock_interface.status = 'deleted'

        test_delete(ctx=_ctx, iface=mock_interface)

        self.assertEqual(_ctx.instance.runtime_properties, {
            '__deleted': True,
        })

        # pending
        mock_interface = MagicMock()
        mock_interface.status = 'pending'

        with self.assertRaises(OperationRetry):
            test_delete(ctx=_ctx, iface=mock_interface)

        # unknow
        mock_interface = MagicMock()
        mock_interface.status = 'unknow'

        with self.assertRaises(NonRecoverableError):
            test_delete(ctx=_ctx, iface=mock_interface)
    def test_wait_for_status(self):

        _ctx = self._gen_decorators_context(
            'test_wait_for_status',
            op_name='cloudify.interfaces.lifecycle.create')

        @decorators.wait_for_status(status_good=['ok'],
                                    status_pending=['pending'])
        def test_ok(*agrs, **kwargs):
            pass

        # ok
        mock_interface = MagicMock()
        mock_interface.status = 'ok'
        mock_interface.properties = {'status': 'ok'}

        test_ok(ctx=_ctx, iface=mock_interface)

        self.assertEqual(_ctx.instance.runtime_properties, {
            'resource_config': {},
            'create_response': {'status': 'ok'},
        })

        # pending
        mock_interface = MagicMock()
        mock_interface.status = 'pending'
        mock_interface.properties = {'status': 'pending'}

        with self.assertRaises(OperationRetry):
            test_ok(ctx=_ctx, iface=mock_interface)

        # unknow
        mock_interface = MagicMock()
        mock_interface.status = 'unknown'
        mock_interface.properties = {'status': 'unknown'}

        with self.assertRaises(NonRecoverableError):
            test_ok(ctx=_ctx, iface=mock_interface)

        # empty status
        mock_interface = MagicMock()
        mock_interface.status = None
        mock_interface.properties = {'status': None}

        with self.assertRaises(NonRecoverableError):
            test_ok(ctx=_ctx, iface=mock_interface)

        # empty status but ignore
        mock_interface = MagicMock()
        mock_interface.status = None
        mock_interface.properties = {'status': None}

        @decorators.wait_for_status(status_pending=['pending'],
                                    fail_on_missing=False)
        def test_ignore(*agrs, **kwargs):
            pass

        test_ignore(ctx=_ctx, iface=mock_interface)
Exemple #3
0
 def test_command_succeeded(self):
     response = MagicMock()
     result = json.loads('{"status": "Failure", "kind": "Status", "code": 409, "apiVersion": "v1", "reason": "AlreadyExists", "details": {"kind": "node", "name": "10.200.147.200"}, "message": "node \\"10.200.147.200\\" already exists", "creationTimestamp": null}')  # noqa
     response.status = 200
     self.r.command_succeeded(response, result)
     response.status = 409
     self.r.command_succeeded(response, result)
     response.status = 500
     with pytest.raises(RuntimeError):
         self.r.command_succeeded(response, result)
Exemple #4
0
    def get_response(self):
        method, url = self.__class__.last_op

        resp = MagicMock()

        if method == "GET":
            if url == "/-/":
                resp.status = 200
                resp.read.return_value = read_file_as_string("files/occi.txt")
            elif url == "/compute/1":
                resp.status = 200
                resp.read.return_value = read_file_as_string("files/occi_vm_info.txt")
            elif url.startswith("/storage"):
                resp.status = 200
                resp.read.return_value = 'X-OCCI-Attribute: occi.storage.state="online"'
        elif method == "POST":
            if url == "/compute/":
                resp.status = 201
                resp.read.return_value = 'https://server.com/compute/1'
            elif url.endswith("action=suspend"):
                resp.status = 200
            elif url.endswith("action=start"):
                resp.status = 200
            elif url == "/link/storagelink":
                resp.status = 200
        elif method == "DELETE":
            if url.endswith("/compute/1"):
                resp.status = 200
            elif url.endswith("/storage/1"):
                resp.status = 200

        return resp
Exemple #5
0
    def get_response(self):
        method, url = self.__class__.last_op

        resp = MagicMock()

        if method == "GET":
            if "/deployments/" in url:
                resp.status = 200
                resp.read.return_value = ("<Deployment><Status>Running</Status><RoleInstanceList><RoleInstance>"
                                          "<InstanceSize>RoleSizeName</InstanceSize><PowerState>Started</PowerState>"
                                          "<IpAddress>10.0.0.1</IpAddress><InstanceEndpoints><InstanceEndpoint>"
                                          "<Vip>158.42.1.1</Vip></InstanceEndpoint></InstanceEndpoints></RoleInstance>"
                                          "</RoleInstanceList></Deployment>")
            if "/operations/" in url:
                resp.status = 200
                resp.read.return_value = ("<Operation><Status>Succeeded"
                                          "</Status></Operation>")
            elif "/storageservices/" in url:
                resp.status = 200
                resp.read.return_value = ("<StorageService><StorageServiceProperties><GeoPrimaryRegion>North Europe"
                                          "</GeoPrimaryRegion></StorageServiceProperties></StorageService>")
            elif url.endswith("/rolesizes"):
                resp.status = 200
                resp.read.return_value = ("<RoleSizes><RoleSize><SupportedByVirtualMachines>true"
                                          "</SupportedByVirtualMachines><Name>RoleSizeName</Name>"
                                          "<MemoryInMb>512</MemoryInMb><Cores>1</Cores>"
                                          "<VirtualMachineResourceDiskSizeInMb>2014"
                                          "</VirtualMachineResourceDiskSizeInMb>"
                                          "</RoleSize>"
                                          "<RoleSize><SupportedByVirtualMachines>true"
                                          "</SupportedByVirtualMachines><Name>RoleSizeName</Name>"
                                          "<MemoryInMb>2048</MemoryInMb><Cores>2</Cores>"
                                          "<VirtualMachineResourceDiskSizeInMb>2014"
                                          "</VirtualMachineResourceDiskSizeInMb>"
                                          "</RoleSize>"
                                          "</RoleSizes>")

        elif method == "POST":
            if url.endswith("/Operations"):
                resp.status = 202
                resp.getheader.return_value = "id"
            elif url.endswith("/services/hostedservices"):
                resp.status = 201
                resp.read.return_value = ""
            elif url.endswith("/deployments"):
                resp.status = 202
                resp.getheader.return_value = "id"
        elif method == "DELETE":
            if url.endswith("comp=media"):
                resp.status = 202
                resp.getheader.return_value = "id"
        elif method == "PUT":
            if "roles" in url:
                resp.status = 202
                resp.getheader.return_value = "id"

        return resp
Exemple #6
0
 def test_SchedulerAdmin_status_renderer(self):
     scheduler = MagicMock()
     schedulerAdmin = SchedulerAdmin(Scheduler, MagicMock())
     scheduler.status = 'S'
     self.assertEqual('<font color="green">Success</font>',
                      schedulerAdmin.status_renderer(scheduler))
     scheduler.status = 'I'
     self.assertEqual('<font color="yellow">Invalid</font>',
                      schedulerAdmin.status_renderer(scheduler))
     scheduler.status = 'F'
     self.assertEqual('<font color="red">Fail</font>',
                      schedulerAdmin.status_renderer(scheduler))
     scheduler.status = 'R'
     self.assertEqual('<font color="orange">Running</font>',
                      schedulerAdmin.status_renderer(scheduler))
 def test034_launch_asynchronous_ftp_error(self,
                                           m_session_transaction,
                                           m_Scan,
                                           m_ftp_ctrl,
                                           m_add_empty_result):
     m_scan, m_session = MagicMock(), MagicMock()
     fw1, fw2 = MagicMock(), MagicMock()
     file1, file2 = MagicMock(), MagicMock()
     pathf1, pathf2 = 'path-file1', 'path-file2'
     file1.path = pathf1
     file2.path = pathf2
     fw1.file.sha256 = "sha256file1"
     fw1.file.mimetype = "mimetypefile1"
     fw2.file.sha256 = "sha256file2"
     fw2.file.mimetype = "mimetypefile2"
     m_scan.files_web = [fw1, fw2]
     m_scan.files = [file1, file2]
     probe1, probe2 = "Probe1", "Probe2"
     probelist = [probe1, probe2]
     m_scan.get_probe_list.return_value = probelist
     m_add_empty_result.return_value = probelist
     m_session_transaction().__enter__.return_value = m_session
     m_scan.status = IrmaScanStatus.ready
     m_scan.mimetype_filtering = False
     m_Scan.load_from_ext_id.return_value = m_scan
     scanid = "scanid"
     m_ftp_ctrl.upload_scan.side_effect = IrmaFtpError()
     module.launch_asynchronous(scanid)
     expected = IrmaScanStatus.error_ftp_upload
     m_scan.set_status.assert_called_once_with(expected)
Exemple #8
0
    def test_read_from(self):
        instance = MagicMock()

        instance.status = 1
        instance.scores = {
            'left': [5, 10, 15, 20],
            'right': [10, 15, 20, 25],
        }

        self.object().read_from(instance)

        assert self.object().get_data_dict(True) == {
            'csrf_token': self.mget_csrf_token().return_value,
            'status': 1,
            'left_quart_1': 5,
            'left_quart_2': 10,
            'left_quart_3': 15,
            'left_quart_4': 20,
            'right_quart_1': 10,
            'right_quart_2': 15,
            'right_quart_3': 20,
            'right_quart_4': 25,
        }

        assert self.object().instance is instance
Exemple #9
0
    def test_backup_info_corner_cases(self, command_mock):
        # BackupManager mock
        backup_manager = self.build_backup_manager('test_server', 'test_file')
        backup_manager.config.post_test_hook = 'not_existent_script'
        backup_manager.get_previous_backup.return_value = None

        # BackupInfo mock
        backup_info = MagicMock(name='backup_info')
        backup_info.get_basebackup_directory.return_value = 'backup_directory'
        backup_info.backup_id = '123456789XYZ'
        backup_info.error = 'Test error'
        backup_info.status = 'FAILED'

        # the actual test
        script = HookScriptRunner(backup_manager, 'test_hook', 'post')
        script.env_from_backup_info(backup_info)
        expected_env = {
            'BARMAN_PHASE': 'post',
            'BARMAN_VERSION': version,
            'BARMAN_SERVER': 'test_server',
            'BARMAN_CONFIGURATION': 'test_file',
            'BARMAN_HOOK': 'test_hook',
            'BARMAN_BACKUP_DIR': 'backup_directory',
            'BARMAN_BACKUP_ID': '123456789XYZ',
            'BARMAN_ERROR': 'Test error',
            'BARMAN_STATUS': 'FAILED',
            'BARMAN_PREVIOUS_ID': '',
        }
        script.run()
        assert command_mock.call_count == 1
        assert command_mock.call_args[1]['env_append'] == expected_env
Exemple #10
0
    def test_backup_info_exception(self, command_mock):
        # BackupManager mock
        backup_manager = build_backup_manager(name='test_server')
        backup_manager.config.pre_test_hook = 'not_existent_script'
        backup_manager.get_previous_backup = MagicMock()
        backup_manager.get_previous_backup.side_effect = \
            UnknownBackupIdException()

        # BackupInfo mock
        backup_info = MagicMock(name='backup_info')
        backup_info.get_basebackup_directory.return_value = 'backup_directory'
        backup_info.backup_id = '123456789XYZ'
        backup_info.error = None
        backup_info.status = 'OK'

        # the actual test
        script = HookScriptRunner(backup_manager, 'test_hook', 'pre')
        script.env_from_backup_info(backup_info)
        expected_env = {
            'BARMAN_PHASE': 'pre',
            'BARMAN_VERSION': version,
            'BARMAN_SERVER': 'test_server',
            'BARMAN_CONFIGURATION': 'build_config_from_dicts',
            'BARMAN_HOOK': 'test_hook',
            'BARMAN_BACKUP_DIR': 'backup_directory',
            'BARMAN_BACKUP_ID': '123456789XYZ',
            'BARMAN_ERROR': '',
            'BARMAN_STATUS': 'OK',
            'BARMAN_PREVIOUS_ID': '',
            'BARMAN_RETRY': '0',
        }
        script.run()
        assert command_mock.call_count == 1
        assert command_mock.call_args[1]['env_append'] == expected_env
def make_response_mock(response_status):
    """ Constructs HTTP Response mock object.
    """
    response_mock = MagicMock()
    response_mock.status = response_status

    return response_mock
Exemple #12
0
    def test_backup_info_exception(self, command_mock):
        # BackupManager mock
        backup_manager = build_backup_manager(name="test_server")
        backup_manager.config.pre_test_hook = "not_existent_script"
        backup_manager.get_previous_backup = MagicMock()
        backup_manager.get_previous_backup.side_effect = UnknownBackupIdException()

        # BackupInfo mock
        backup_info = MagicMock(name="backup_info")
        backup_info.get_basebackup_directory.return_value = "backup_directory"
        backup_info.backup_id = "123456789XYZ"
        backup_info.error = None
        backup_info.status = "OK"

        # the actual test
        script = HookScriptRunner(backup_manager, "test_hook", "pre")
        script.env_from_backup_info(backup_info)
        expected_env = {
            "BARMAN_PHASE": "pre",
            "BARMAN_VERSION": version,
            "BARMAN_SERVER": "test_server",
            "BARMAN_CONFIGURATION": "build_config_from_dicts",
            "BARMAN_HOOK": "test_hook",
            "BARMAN_BACKUP_DIR": "backup_directory",
            "BARMAN_BACKUP_ID": "123456789XYZ",
            "BARMAN_ERROR": "",
            "BARMAN_STATUS": "OK",
            "BARMAN_PREVIOUS_ID": "",
        }
        script.run()
        assert command_mock.call_count == 1
        assert command_mock.call_args[1]["env_append"] == expected_env
 def test012_cancel_status_cancelled(self):
     scan, session = MagicMock(), MagicMock()
     scan.status = IrmaScanStatus.cancelled
     label = IrmaScanStatus.label[scan.status]
     expected = "can not cancel scan in {} status".format(label)
     with self.assertRaises(IrmaValueError) as context:
         module.cancel(scan, session)
     self.assertEqual(str(context.exception), expected)
Exemple #14
0
    def test_format_int_status(self):
        req = MagicMock()
        resp = MagicMock()
        resp.status = 200

        hook_format(req, resp)

        self.assertEquals(resp.status, '200 OK')
    def test_hook_finished(self, m_log):
        self.scan.date = "scan_date"
        self.fw.scan = self.scan
        self.fw.file.sha256 = "sha256"
        self.fw.name = "filename"
        self.fw.file.timestamp_first_scan = "ts_first_scan"
        self.fw.file.timestamp_last_scan = "ts_last_scan"
        self.fw.file.size = "size"
        pr1, pr2 = MagicMock(), MagicMock()
        self.fw.probe_results = [pr1, pr2]
        pr1.name = "probe1"
        pr1.type = "antivirus"
        pr1.status = "status1"
        pr1.duration = "duration1"
        pr1.results = "results1"
        pr2.name = "probe2"
        pr2.type = "metadata"
        pr2.status = "status2"
        pr2.duration = None
        pr2.results = "results2"
        pr1.get_details.return_value = pr1
        pr2.get_details.return_value = pr2
        self.fw.hook_finished()

        expected1 = "[files_results] date: %s file_id: %s scan_id: %s "
        expected1 += "status: %s probes: %s submitter: %s submitter_id: %s"
        call1 = call(expected1,
                     'scan_date',
                     self.fw.external_id,
                     self.fw.scan.external_id, 'Clean', 'probe1, probe2',
                     'unknown', 'undefined')

        expected2 = '[av_results] date: %s av_name: "%s" '
        expected2 += "status: %d virus_name: \"%s\" file_id: %s "
        expected2 += "file_sha256: %s scan_id: %s duration: %f "
        expected2 += "submitter: %s submitter_id: %s"
        call2 = call(expected2,
                     'scan_date',
                     'probe1',
                     'status1',
                     'results1',
                     self.fw.external_id,
                     'sha256', self.fw.scan.external_id, 'duration1',
                     'unknown', 'undefined')

        expected3 = '[probe_results] date: %s name: "%s" '
        expected3 += "status: %d file_sha256: %s file_id: %s "
        expected3 += "duration: %f submitter: %s submitter_id: %s"
        call3 = call(expected3,
                     'scan_date',
                     'probe2',
                     'status2',
                     self.fw.external_id,
                     'sha256', 0, 'unknown', 'undefined')

        m_log.info.assert_has_calls([call1])
        m_log.info.assert_has_calls([call2])
        m_log.info.assert_has_calls([call3])
 def test008_cancel_status_launched_ok(self):
     scan, session = MagicMock(), MagicMock()
     scan.status = IrmaScanStatus.launched
     retcode = IrmaReturnCode.success
     cancel_res = {'cancel_details': "details"}
     self.celery_brain.scan_cancel.return_value = (retcode, cancel_res)
     res = module.cancel(scan, session)
     self.assertEqual(res, cancel_res['cancel_details'])
     scan.set_status.assert_called_once_with(IrmaScanStatus.cancelled)
 def test003_check_probe_None(self):
     scan, session = MagicMock(), MagicMock()
     scan.status = IrmaScanStatus.ready
     probelist = None
     all_probelist = ['probe1', 'probe2', 'probe3']
     scan.set_probelist.return_value = None
     self.celery_brain.probe_list.return_value = all_probelist
     module.check_probe(scan, probelist, session)
     self.assertTrue(scan.set_probelist.called)
     scan.set_probelist.assert_called_once_with(all_probelist)
Exemple #18
0
    def get_response(self):
        method, url = self.__class__.last_op

        resp = MagicMock()

        if method == "GET":
            if "/api/credential/somecred" == url:
                resp.status = 200
                resp.read.return_value = ('[{"name": "Username", "type": "text", "value": "username"},'
                                          '{"name": "Password", "type": "text", "value": "password"}]')
            if "/api/service" == url:
                resp.status = 200
                resp.read.return_value = ('{"service_list": [{"id":"sid", "type":"stype", "host": "shost"}]}')
        elif method == "POST":
            if url == "/api/credential/":
                resp.status = 303
                resp.msg = {'location': "/api/credential/somecred"}

        return resp
 def request(self, method, path, data=None, stream=False, **kwargs):
     self._reason = self.REASONS[self.counter % len(self.REASONS)]
     self._status = self.STATI[self.counter % len(self.STATI)]
     print(self.counter, self._status)
     self.counter += 1
     mock_response = MagicMock()
     mock_response.status = self._status
     mock_response.reason = self._reason
     mock_response.headers = {"content-type": self.content_type}
     return mock_response
Exemple #20
0
    def test_put_observation(self, mock_conn, caps_mock):
        caps_mock.get_service_host.return_value = 'some.host.com'
        caps_mock.return_value.get_access_url.return_value =\
            'http://serviceurl/caom2repo/pub'
        collection = 'cfht'
        observation_id = '7000000o'
        service = 'caom2repo'
        service_url = 'www.cadc.nrc.ca'

        obs = SimpleObservation(collection, observation_id)
        subject = auth.Subject(certificate='somefile.pem')
        level = logging.DEBUG
        visitor = CAOM2RepoClient(subject, level, host=service_url)
        response = MagicMock()
        response.status = 200
        mock_conn.return_value = response
        iobuffer = BytesIO()
        ObservationWriter().write(obs, iobuffer)
        obsxml = iobuffer.getvalue()
        response.content = obsxml

        visitor.put_observation(obs)
        self.assertEqual('PUT', mock_conn.call_args[0][0].method)
        self.assertEqual(
            '/{}/pub/{}/{}'.format(service, collection, observation_id),
            mock_conn.call_args[0][0].path_url)
        self.assertEqual('application/xml',
                         mock_conn.call_args[0][0].headers['Content-Type'])
        self.assertEqual(obsxml, mock_conn.call_args[0][0].body)

        # signal problems
        http_error = requests.HTTPError()
        response.status_code = 500
        http_error.response = response
        response.raise_for_status.side_effect = [http_error]
        with self.assertRaises(exceptions.InternalServerException):
            visitor.create(obs)

        # temporary transient errors
        http_error = requests.HTTPError()
        response.status_code = 503
        http_error.response = response
        response.raise_for_status.side_effect = [http_error, None]
        visitor.put_observation(obs)

        # permanent transient errors
        http_error = requests.HTTPError()
        response.status_code = 503
        http_error.response = response

        def raise_error(): raise http_error

        response.raise_for_status.side_effect = raise_error
        with self.assertRaises(exceptions.HttpException):
            visitor.put_observation(obs)
def test_should_remove_proxy_returns_true_when_response_status_code_is_within_not_allowed_ones(
        read_proxies_mock):
    middleware = ProxyMiddleware(MagicMock())
    middleware.remove_proxy_for_status_codes = [504]

    response = MagicMock()
    response.status = 504

    remove_proxy = middleware.should_remove_proxy(response)

    assert_that(remove_proxy, is_(True))
 def test_modify_vpc_attribute(self):
     ctx = self.get_mock_ctx("Vpc")
     iface = MagicMock()
     iface.status = 0
     self.vpc.resource_id = 'test_name'
     try:
         vpc.modify_vpc_attribute(
             ctx, iface, {VPC_ID: self.vpc.resource_id})
     except OperationRetry:
         pass
     self.assertTrue(iface.modify_vpc_attribute.called)
 def test_modify_subnet_attribute(self):
     ctx = self.get_mock_ctx("Subnet")
     iface = MagicMock()
     iface.status = 0
     self.subnet.resource_id = 'test_name'
     try:
         subnet.modify_subnet_attribute(
             ctx, iface, {SUBNET_ID: self.subnet.resource_id})
     except OperationRetry:
         pass
     self.assertTrue(iface.modify_subnet_attribute.called)
 def test004_check_probe_unknown_probe(self):
     scan, session = MagicMock(), MagicMock()
     scan.status = IrmaScanStatus.ready
     probelist = ['probe1', 'probe2', 'probe6']
     all_probelist = ['probe1', 'probe2', 'probe3']
     scan.set_probelist.return_value = None
     self.celery_brain.probe_list.return_value = all_probelist
     with self.assertRaises(IrmaValueError) as context:
         module.check_probe(scan, probelist, session)
     self.assertFalse(scan.set_probelist.called)
     self.assertEquals(str(context.exception), "probe probe6 unknown")
 def test008_cancel_status_launched_brain_error(self):
     scan, session = MagicMock(), MagicMock()
     scan.status = IrmaScanStatus.launched
     retcode = IrmaReturnCode.error
     ret_val = "reason"
     self.celery_brain.scan_cancel.return_value = (retcode, ret_val)
     with self.assertRaises(IrmaTaskError) as context:
         module.cancel(scan, session)
     self.assertEqual(str(context.exception),
                      ret_val)
     scan.set_status.assert_not_called()
    def _prepare_dynamic(self, packages,
                         config_content='MockContent', device_path='/dev/vdb',
                         is_db_installed=True, backup_id=None,
                         is_root_enabled=False,
                         overrides=None):
        # covering all outcomes is starting to cause trouble here
        if not backup_id:
            backup_info = {'id': backup_id,
                           'location': 'fake-location',
                           'type': 'InnoBackupEx',
                           'checksum': 'fake-checksum',
                           }

        mock_status = MagicMock()
        mock_app = MagicMock()
        mock_app.status = mock_status
        self.manager._app = mock_app

        mock_status.begin_install = MagicMock(return_value=None)
        mock_app.install_if_needed = MagicMock(return_value=None)
        mock_app.init_storage_structure = MagicMock(return_value=None)
        mock_app.write_config = MagicMock(return_value=None)
        mock_app.apply_initial_guestagent_configuration = MagicMock(
            return_value=None)
        mock_app.restart = MagicMock(return_value=None)
        mock_app.start_db = MagicMock(return_value=None)
        mock_app.stop_db = MagicMock(return_value=None)
        os.path.exists = MagicMock(return_value=True)
        volume.VolumeDevice.format = MagicMock(return_value=None)
        volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
        volume.VolumeDevice.mount = MagicMock(return_value=None)
        volume.VolumeDevice.mount_points = MagicMock(return_value=[])

        with patch.object(pkg.Package, 'pkg_is_installed',
                          return_value=is_db_installed):
            # invocation
            self.manager.prepare(context=self.context, packages=packages,
                                 config_contents=config_content,
                                 databases=None,
                                 memory_mb='2048', users=None,
                                 device_path=device_path,
                                 mount_point="/var/lib/cassandra",
                                 backup_info=backup_info,
                                 overrides=None,
                                 cluster_config=None)

        # verification/assertion
        mock_status.begin_install.assert_any_call()
        mock_app.install_if_needed.assert_any_call(packages)
        mock_app.init_storage_structure.assert_any_call('/var/lib/cassandra')
        mock_app.apply_initial_guestagent_configuration.assert_any_call()
        mock_app.start_db.assert_any_call(update_db=False)
        mock_app.stop_db.assert_any_call()
 def test008_cancel_status_launched_status_processed(self):
     scan, session = MagicMock(), MagicMock()
     scan.status = IrmaScanStatus.launched
     retcode = IrmaReturnCode.success
     status = IrmaScanStatus.label[IrmaScanStatus.processed]
     cancel_res = {'status': status}
     self.celery_brain.scan_cancel.return_value = (retcode, cancel_res)
     with self.assertRaises(IrmaValueError) as context:
         module.cancel(scan, session)
     self.assertEqual(str(context.exception),
                      "can not cancel scan in {0} status".format(status))
     scan.set_status.assert_called_once_with(IrmaScanStatus.processed)
    def test_api_task_status(self, get_result):
        async_result = MagicMock()
        async_result.status = "running"
        async_result.ready.return_value = False
        get_result.return_value = async_result
        output = self.app.get("/api/0/task/123abc/status/")
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        self.assertEqual(data, {"ready": False, "status": "running"})

        async_result = MagicMock()
        async_result.status = "finished"
        async_result.ready.return_value = True
        async_result.successful.return_value = True
        get_result.return_value = async_result
        output = self.app.get("/api/0/task/123abc/status/")
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        self.assertEqual(
            data, {"ready": True, "status": "finished", "successful": True}
        )
 def test_get_probe_results_as_dict(self):
     pr1, pr2 = MagicMock(), MagicMock()
     pr3 = MagicMock()
     pr1.doc = "whatever"
     pr2.doc = "something"
     pr3.status = None
     self.fw.probe_results = [pr1, pr2, pr3]
     self.assertIsInstance(self.fw.get_probe_results(results_as="dict"),
                           dict)
     pr1.get_details.assert_called_with(True)
     pr2.get_details.assert_called_with(True)
     pr3.get_details.assert_not_called()
Exemple #30
0
    def get_response(self):
        method, url = self.__class__.last_op

        resp = MagicMock()

        if method == "GET":
            if url == "/api/":
                resp.status = 200
                resp.read.return_value = '{"versions": "v1"}'
            if url == "/containers/1/json":
                resp.status = 200
                resp.read.return_value = '{"State": {"Running": 1}, "NetworkSettings": {"IPAddress": "10.0.0.1"}}'
        elif method == "POST":
            if url == "/containers/create":
                resp.status = 201
                resp.read.return_value = '{"Id": "id"}'
            elif url.endswith("/start"):
                resp.status = 204
            elif url.endswith("/stop"):
                resp.status = 204
        elif method == "DELETE":
            if url.endswith("/containers/1"):
                resp.status = 204

        return resp
Exemple #31
0
def test_print_endpoint_info():
    magic = SparkMagicBase(None)
    magic.ipython_display = MagicMock()
    current_session_id = 1
    session1 = MagicMock()
    session1.id = 1
    session1.get_app_id.return_value = 'app1234'
    session1.kind = SESSION_KIND_PYSPARK
    session1.status = IDLE_SESSION_STATUS
    session1.get_spark_ui_url.return_value = 'https://microsoft.com/sparkui'
    session1.get_driver_log_url.return_value = 'https://microsoft.com/driverlog'
    session2 = MagicMock()
    session2.id = 3
    session2.get_app_id.return_value = 'app5069'
    session2.kind = SESSION_KIND_SPARK
    session2.status = BUSY_SESSION_STATUS
    session2.get_spark_ui_url.return_value = None
    session2.get_driver_log_url.return_value = None
    magic._print_endpoint_info([session2, session1], current_session_id)
    magic.ipython_display.html.assert_called_once_with(u"""<table>
<tr><th>ID</th><th>YARN Application ID</th><th>Kind</th><th>State</th><th>Spark UI</th><th>Driver log</th><th>Current session?</th></tr>\
<tr><td>1</td><td>app1234</td><td>pyspark</td><td>idle</td><td><a target="_blank" href="https://microsoft.com/sparkui">Link</a></td><td><a target="_blank" href="https://microsoft.com/driverlog">Link</a></td><td>\u2714</td></tr>\
<tr><td>3</td><td>app5069</td><td>spark</td><td>busy</td><td></td><td></td><td></td></tr>\
</table>""")
Exemple #32
0
    def test_run_spider(self):
        """Test running the spider."""
        def status_result():
            """Return value of the status property."""
            if status.call_count > 2:
                return '100'
            return '50'

        class_mock = MagicMock()
        class_mock.scan.return_value = '1'
        status = Mock(side_effect=status_result)
        class_mock.status = status
        self.zap_helper.zap.spider = class_mock

        self.zap_helper.run_spider('http://localhost', status_check_sleep=0)
    def test_run_active_scan(self):
        """Test running an active scan."""
        def status_result():
            """Return value of the status property."""
            if status.call_count > 2:
                return '100'
            return '50'

        class_mock = MagicMock()
        class_mock.scan.return_value = '1'
        status = Mock(side_effect=status_result)
        class_mock.status = status
        self.zap_helper.zap.ascan = class_mock

        self.zap_helper.run_active_scan('http://localhost')
Exemple #34
0
 def test_modify_instance_attribute(self):
     ctx = self.get_mock_ctx(
         "EC2Instances",
         test_properties={'os_family': 'linux'},
         type_hierarchy=['cloudify.nodes.Root', 'cloudify.nodes.Compute'])
     current_ctx.set(ctx=ctx)
     iface = MagicMock()
     iface.status = 0
     self.instances.resource_id = 'test_name'
     try:
         instances.modify_instance_attribute(
             ctx, iface, {INSTANCE_ID: self.instances.resource_id})
     except OperationRetry:
         pass
     self.assertTrue(iface.modify_instance_attribute.called)
Exemple #35
0
    def test_monitor_trail_with_custom_arguments(self):
        mock_trail_client = MagicMock()
        mock_trail_client.status = MagicMock(
            return_value='mock_trail_client_result')
        mock_status_filter_handler_pairs = MagicMock()
        monitor_patcher = patch('autotrail.helpers.trail.monitor')
        mock_monitor = monitor_patcher.start()
        diff_lists_patcher = patch('autotrail.helpers.trail.diff_lists')
        mock_diff_lists = diff_lists_patcher.start()

        monitor_trail(mock_trail_client,
                      mock_status_filter_handler_pairs,
                      status_kwargs=dict(foo='bar'),
                      delay=55,
                      max_tries=1)

        kwargs = mock_monitor.call_args[1]
        function = kwargs['function']
        result_predicate = kwargs['result_predicate']
        filter_handler_pairs = kwargs['filter_handler_pairs']
        pre_processor = kwargs['pre_processor']
        delay = kwargs['delay']
        history_limit = kwargs['history_limit']

        self.assertEqual(delay, 55)
        self.assertEqual(history_limit, 2)  # History will be max_tries + 1
        self.assertEqual(filter_handler_pairs,
                         mock_status_filter_handler_pairs)

        result = function()
        self.assertEqual(result, 'mock_trail_client_result')
        mock_trail_client.status.assert_called_once_with(foo='bar')

        self.assertTrue(result_predicate([None, 'result']))
        self.assertTrue(result_predicate(['result']))
        self.assertFalse(result_predicate(['result', None]))
        self.assertFalse(result_predicate([None, None, None]))

        pre_processor([1, 2, 3])
        mock_diff_lists.assert_called_once_with([2, 3])
        pre_processor([2, 3])
        mock_diff_lists.assert_called_with([2, 3])
        pre_processor([3])
        mock_diff_lists.assert_called_with([3])
        pre_processor([None])
        mock_diff_lists.assert_called_with([None])
        diff_lists_patcher.stop()
        monitor_patcher.stop()
Exemple #36
0
    def test_retrieve_page_basic_auth(self, mock_make_request):
        """ Test that a basic auth request generates the correct header """
        path = "http://google.com"
        username, password = "******", "pass"
        auth_str = base64.b64encode(":".join((username, password)))
        expected_uri = path
        expected_headers = {"Authorization": "Basic %s" % auth_str}

        mock_http_response = MagicMock()
        mock_http_response.status = 200
        mock_make_request.return_value = mock_http_response

        fw = Framework()
        fw.retrieve_page("GET", path, username=username, password=password)
        mock_make_request.asserted_called_with(expected_uri, method="GET",
                                          body=None, headers=expected_headers)
Exemple #37
0
 def getTestMock( self, nameID=0):
   """create a JobInfo object with mocks"""
   from ILCDIRAC.ILCTransformationSystem.Utilities.JobInfo import JobInfo
   testJob = Mock ( name = "jobInfoMock_%s" % nameID, spec=JobInfo )
   testJob.jobID = 1234567
   testJob.tType = "testType"
   testJob.otherTasks = None
   testJob.inputFileExists = True
   testJob.status = "Done"
   testJob.fileStatus = "Assigned"
   testJob.outputFiles = ["/my/stupid/file.lfn", "/my/stupid/file2.lfn"]
   testJob.outputFileStatus = ["Exists", "Exists"]
   testJob.inputFile = "inputfile.lfn"
   testJob.pendingRequest = False
   testJob.getTaskInfo = Mock()
   return testJob
Exemple #38
0
    def test_transition_issue_to_proper_status_mapping_error(self):
        self.handler.update_status_mappings = MagicMock()
        self.handler.transition_issue = MagicMock()

        ticket = MagicMock()
        status = "status"
        ticket.status = status
        jira_issue = MagicMock()

        self.handler.status_mappings = {}
        self.handler.update_status_mappings.side_effect = JIRAError()

        self.handler.transition_issue_to_proper_status(jira_issue, ticket)

        self.handler.update_status_mappings.assert_called_once()
        self.handler.transition_issue.assert_not_called()
Exemple #39
0
    def test_hook_finished(self, m_log):
        self.scan.date = "scan_date"
        self.fw.scan = self.scan
        self.fw.file.sha256 = "sha256"
        self.fw.name = "filename"
        self.fw.file.timestamp_first_scan = "ts_first_scan"
        self.fw.file.timestamp_last_scan = "ts_last_scan"
        self.fw.file.size = "size"
        pr1, pr2 = MagicMock(), MagicMock()
        self.fw.probe_results = [pr1, pr2]
        pr1.name = "probe1"
        pr1.type = "antivirus"
        pr1.status = "status1"
        pr1.duration = "duration1"
        pr1.results = "results1"
        pr2.name = "probe2"
        pr2.type = "metadata"
        pr2.status = "status2"
        pr2.duration = None
        pr2.results = "results2"
        pr1.get_details.return_value = pr1
        pr2.get_details.return_value = pr2
        self.fw.hook_finished()

        expected1 = "[files_results] date: %s file_id: %s scan_id: %s "
        expected1 += "status: %s probes: %s submitter: %s submitter_id: %s"
        call1 = call(expected1, 'scan_date', self.fw.external_id,
                     self.fw.scan.external_id, 'Clean', 'probe1, probe2',
                     'unknown', 'undefined')

        expected2 = '[av_results] date: %s av_name: "%s" '
        expected2 += "status: %d virus_name: \"%s\" file_id: %s "
        expected2 += "file_sha256: %s scan_id: %s duration: %f "
        expected2 += "submitter: %s submitter_id: %s"
        call2 = call(expected2, 'scan_date', 'probe1', 'status1', 'results1',
                     self.fw.external_id, 'sha256', self.fw.scan.external_id,
                     'duration1', 'unknown', 'undefined')

        expected3 = '[probe_results] date: %s name: "%s" '
        expected3 += "status: %d file_sha256: %s file_id: %s "
        expected3 += "duration: %f submitter: %s submitter_id: %s"
        call3 = call(expected3, 'scan_date', 'probe2', 'status2',
                     self.fw.external_id, 'sha256', 0, 'unknown', 'undefined')

        m_log.info.assert_has_calls([call1])
        m_log.info.assert_has_calls([call2])
        m_log.info.assert_has_calls([call3])
Exemple #40
0
    def test_update_status_mappings_not_exists_in_mappings(self, input_mock):
        self.handler.transitions = MagicMock()

        ticket = MagicMock()
        status = "status"
        ticket.status = status
        jira_issue = MagicMock()
        jira_status = "To Do"
        transition = {"to": {"name": jira_status}}

        input_mock.side_effect = ["Error", jira_status]
        self.handler.transitions.return_value = [transition]
        self.handler.status_mappings = {}

        self.handler.update_status_mappings(ticket, jira_issue)

        self.assertEqual(input_mock.call_count, 2)
Exemple #41
0
    def test_run_active_scan_as_user(self):
        """Test running an active scan as a given user."""
        def status_result():
            """Return value of the status property."""
            if status.call_count > 2:
                return '100'
            return '50'

        class_mock = MagicMock()
        class_mock.scan_as_user.return_value = '1'
        status = Mock(side_effect=status_result)
        class_mock.status = status
        self.zap_helper.zap.ascan = class_mock
        self.zap_helper.zap.context.context = Mock(return_value={'id': '1'})
        self.zap_helper.zap.users.users_list = Mock(return_value=[{'name': 'Test', 'id': '1'}])

        self.zap_helper.run_active_scan('http://localhost', False, 'Test', 'Test')
Exemple #42
0
def test_transport(mock_sleep):
    mock_status = MagicMock()
    mock_status.status = 502

    client, _ = get_client_and_http()
    client.setup_retry(3, 2, 2, 10)
    client.transport._http.request = MagicMock(side_effect=TransportException(mock_status, None))

    try:
        client.Contact.get_contacts()
    except TransportException:
        pass
    else:
        raise AssertionError()

    assert client.transport._http.request.call_count == 3
    assert mock_sleep.call_count == 2
Exemple #43
0
    def test_url_format(self, mock_manager):
        response_mock = MagicMock()
        response_mock.status = 200
        response_mock.data = None

        mock_connection = MagicMock()
        mock_connection.request.return_value = response_mock
        mock_manager.return_value = mock_connection

        host = 'http://test.com/'
        url = '/path/to/we/'
        expected_url = 'http://test.com/path/to/we/'
        utils.make_request('GET', host, url, 'a_user', 'a_pass')
        mock_connection.request.assert_called_once_with('GET',
                                                        expected_url,
                                                        fields=Any(),
                                                        headers=Any())
Exemple #44
0
    def test_transition_issue_to_proper_status(self):
        self.handler.update_status_mappings = MagicMock()
        self.handler.transition_issue = MagicMock()

        ticket = MagicMock()
        status = "status"
        ticket.status = status
        jira_issue = MagicMock()

        self.handler.status_mappings[status] = status

        self.handler.transition_issue_to_proper_status(jira_issue, ticket)

        self.handler.update_status_mappings.assert_not_called()
        self.handler.transition_issue.assert_called_once_with(
            jira_issue, status
        )
Exemple #45
0
    def setUp(self):
        self.resource = MagicMock(
            OneTouch(test_helper.API_URL, test_helper.API_KEY))
        self.response = MagicMock()
        otr = MagicMock(OneTouchResponse(self.resource, self.response))
        otr.errors = MagicMock(return_value={})
        otr.ok = MagicMock(return_value=True)
        otr.get_uuid = MagicMock(
            return_value="1836762c-e4b7-4c99-a0e4-d8e7518b4e78")
        otr.status = MagicMock(return_value=True)

        self.resource.send_request = MagicMock(return_value=otr)
        self.resource.get_approval_status = MagicMock(return_value=otr)
        self.resource.clean_logos = OneTouch.clean_logos
        self.resource.__make_http_query = OneTouch._OneTouch__make_http_query
        self.resource.validate_one_touch_signature = OneTouch.validate_one_touch_signature
        self.resource.api_key = 'foobar123'
Exemple #46
0
 def getTestMock(self, nameID=0, jobID=1234567):
     """create a JobInfo object with mocks"""
     from DIRAC.TransformationSystem.Utilities.JobInfo import JobInfo
     testJob = Mock(name="jobInfoMock_%s" % nameID, spec=JobInfo)
     testJob.jobID = jobID
     testJob.tType = "testType"
     testJob.otherTasks = []
     testJob.errorCounts = []
     testJob.status = "Done"
     testJob.transFileStatus = ['Assigned', 'Assigned']
     testJob.inputFileStatus = ['Exists', 'Exists']
     testJob.outputFiles = ["/my/stupid/file.lfn", "/my/stupid/file2.lfn"]
     testJob.outputFileStatus = ["Exists", "Exists"]
     testJob.inputFiles = ['inputfile.lfn', 'inputfile2.lfn']
     testJob.pendingRequest = False
     testJob.getTaskInfo = Mock()
     return testJob
Exemple #47
0
    def test_run_spider_as_user_error(self):
        """Test running the spider as a given user when an error occurs."""
        def status_result():
            """Return value of the status property."""
            if status.call_count > 2:
                return '100'
            return '50'

        class_mock = MagicMock()
        class_mock.scan_as_user.return_value = '1'
        status = Mock(side_effect=status_result)
        class_mock.status = status
        self.zap_helper.zap.spider = class_mock
        self.zap_helper.zap.context.context = Mock(return_value={'id': '1'})
        self.zap_helper.zap.users.users_list = Mock(return_value=[])

        with self.assertRaises(ZAPError):
            self.zap_helper.run_spider('http://localhost', 'Test', 'Test')
    def test_prepare_for_export_zip_task(self, ExportRun, isfile, join,
                                         mock_generate_qgs_style):

        from eventkit_cloud.tasks.export_tasks import prepare_for_export_zip_task

        # This doesn't need to be valid with ExportRun mocked
        mock_run_uid = str(uuid.uuid4())

        style_file = "style.qgs"
        mock_generate_qgs_style.return_value = style_file
        expected_file_list = ['e1', 'e2', 'e3', style_file]
        missing_file_list = ['e4']
        all_file_list = expected_file_list + missing_file_list

        def fake_isfile(fname):
            if fname in expected_file_list:
                return True
            else:
                return False

        isfile.side_effect = fake_isfile

        # Fill out the behavior for mocked ExportRun by adding a provider task with
        # subtasks for each file in all_file_list
        mocked_provider_subtasks = []
        for fname in all_file_list:
            mps = MagicMock()
            mps.result.filename = fname
            mocked_provider_subtasks.append(mps)

        mocked_provider_task = MagicMock()
        mocked_provider_task.status = TaskStates.COMPLETED.value
        mocked_provider_task.tasks.all.return_value = mocked_provider_subtasks

        mocked_run = MagicMock()
        mocked_run.job.include_zipfile = True
        mocked_run.provider_tasks.all.return_value = [mocked_provider_task]

        ExportRun.objects.get.return_value = mocked_run

        include_files = prepare_for_export_zip_task.run(run_uid=mock_run_uid)
        mock_generate_qgs_style.assert_called_once_with(run_uid=mock_run_uid)

        self.assertEqual(include_files, set(expected_file_list))
Exemple #49
0
    def test_delete_observation(self, mock_conn, caps_mock):
        caps_mock.get_service_host.return_value = 'some.host.com'
        caps_mock.return_value.get_access_url.return_value =\
            'http://serviceurl/caom2repo/pub'
        collection = 'cfht'
        observation_id = '7000000o'
        service_url = 'www.cadc.nrc.ca'
        level = logging.DEBUG

        visitor = CAOM2RepoClient(auth.Subject(), level, host=service_url)
        response = MagicMock()
        response.status = 200
        mock_conn.return_value = response

        visitor.delete_observation(collection, observation_id)
        self.assertEqual('DELETE', mock_conn.call_args[0][0].method)

        # signal problems
        http_error = requests.HTTPError()
        response.status_code = 500
        http_error.response = response
        response.raise_for_status.side_effect = [http_error]
        with self.assertRaises(exceptions.InternalServerException):
            visitor.delete(collection, observation_id)

        # temporary transient errors
        http_error = requests.HTTPError()
        response.status_code = 503
        http_error.response = response
        response.raise_for_status.side_effect = [http_error, None]
        visitor.delete_observation(collection, observation_id)

        # permanent transient errors
        http_error = requests.HTTPError()
        response.status_code = 503
        http_error.response = response

        def raise_error():
            raise http_error

        response.raise_for_status.side_effect = raise_error
        with self.assertRaises(exceptions.HttpException):
            visitor.delete_observation(collection, observation_id)
Exemple #50
0
 def request(self, method, path, data=None, stream=False, **kwargs):
     mock_response = MagicMock()
     mock_response.status = 400
     mock_response.reason = "Bad Request"
     mock_response.headers = {"content-type": self.content_type}
     mock_response.data = json.dumps({
         "results": [{
             "rowcount": 1
         }, {
             "error_message": "an error occured"
         }, {
             "error_message": "another error"
         }, {
             "error_message": ""
         }, {
             "error_message": None
         }]
     }).encode()
     return mock_response
    def test_makes_request_403(self, mock_connection_from_url):
        response_mock = MagicMock()
        response_mock.status = 403
        response_mock.data = 'test_data'

        mock_connection = MagicMock()
        mock_connection.request.return_value = response_mock
        mock_connection_from_url.return_value = mock_connection

        host = 'http://whynotestsforthisstuff.com'
        url = '/my_test_url/'
        self.assertRaises(
            Exception,
            utils.make_request,
            'GET',
            host,
            url,
            'a_user',
            'a_pass'
        )
    def test_makes_request_None(self, mock_connection_from_url):
        response_mock = MagicMock()
        response_mock.status = 200
        response_mock.data = None

        mock_connection = MagicMock()
        mock_connection.request.return_value = response_mock
        mock_connection_from_url.return_value = mock_connection

        host = 'http://whynotestsforthisstuff.com'
        url = '/my_test_url/'
        utils.make_request(
            'GET',
            host,
            url,
            'a_user',
            'a_pass'
        )
        mock_connection_from_url.assert_called_once_with(host)
        mock_connection.request.assert_called_once()
Exemple #53
0
    def test_makes_request_skip_decode(self, mock_conn, mock_determine):
        response_mock = MagicMock()
        response_mock.status = 200
        response_mock.data = 'test_data'

        mock_connection = MagicMock()
        mock_connection.request.return_value = response_mock
        mock_conn.return_value = mock_connection

        host = 'http://whynotestsforthisstuff.com'
        url = '/my_test_url/'
        utils.make_request('GET',
                           host,
                           url,
                           'a_user',
                           'a_pass',
                           skip_decode=True)
        mock_conn.assert_called_once_with(num_pools=1)
        mock_connection.request.assert_called_once()
        mock_determine.assert_not_called()
  def testDistributeKeyHandler(self, mock_get_all, mock_request,
                               mock_make_key_string):
    """Test the distribute handler calls to put the keys on each proxy."""
    fake_proxy_server = GetFakeProxyServer()
    fake_proxy_servers = [fake_proxy_server]
    mock_get_all.return_value = fake_proxy_servers

    mock_response = MagicMock()
    mock_response.status = 200
    fake_content = ''
    mock_request.return_value = mock_response, fake_content

    fake_key_string = 'ssh-rsa public_key email'
    mock_make_key_string.return_value = fake_key_string

    self.testapp.get(PATHS['cron_proxy_server_distribute_key'])
    mock_request.assert_called_once_with(
        'http://%s/key' % fake_proxy_server.ip_address,
        headers={'content-type': 'text/plain'},
        method='PUT',
        body=fake_key_string)
Exemple #55
0
    def test_diff_stack_validationerror_template_too_large(
        self,
        caplog: LogCaptureFixture,
        cfngin_context: MockCFNginContext,
        monkeypatch: MonkeyPatch,
    ) -> None:
        """Test _diff_stack ValidationError - template too large."""
        caplog.set_level(logging.ERROR)

        cfngin_context.add_stubber("cloudformation")
        cfngin_context.config.cfngin_bucket = ""
        expected = SkippedStatus("cfngin_bucket: existing bucket required")
        provider = Provider(cfngin_context.get_session())  # type: ignore
        mock_get_stack_changes = MagicMock(
            side_effect=ClientError(
                {
                    "Error": {
                        "Code": "ValidationError",
                        "Message": "length less than or equal to",
                    }
                },
                "create_change_set",
            )
        )
        monkeypatch.setattr(provider, "get_stack_changes", mock_get_stack_changes)
        stack = MagicMock()
        stack.region = cfngin_context.env.aws_region
        stack.name = "test-stack"
        stack.fqn = "test-stack"
        stack.blueprint.rendered = "{}"
        stack.locked = False
        stack.status = None

        result = Action(
            context=cfngin_context,
            provider_builder=MockProviderBuilder(provider=provider),
            cancel=MockThreadingEvent(),  # type: ignore
        )._diff_stack(stack)
        mock_get_stack_changes.assert_called_once()
        assert result == expected
Exemple #56
0
    def test_generate_qgs_style(self,ExportRun, mock_open):

        run_uid = 1234
        stage_dir = os.path.join(settings.EXPORT_STAGING_ROOT, str(run_uid))

        # Fill out the behavior for mocked ExportRun by adding a provider task with
        # subtasks for each file in all_file_list

        mocked_provider_subtasks = []
        for fname in [ 'F1']:
            mps = MagicMock()
            mps.result.filename = fname
            mocked_provider_subtasks.append(mps)

        mocked_provider_task = MagicMock()
        mocked_provider_task.status = TaskStates.COMPLETED.value
        mocked_provider_task.slug = 'mocked_slug'
        mocked_provider_task.tasks.all.return_value = mocked_provider_subtasks

        mocked_run = MagicMock()
        mocked_run.job.include_zipfile = True
        mocked_run.job.name = 'mocked_job_name'
        mocked_run.provider_tasks.all.return_value = [mocked_provider_task]

        ExportRun.objects.get.return_value = mocked_run

        # test 1 - with a provider task

        returnvalue = generate_qgs_style(run_uid, mocked_provider_task)
        now = datetime.datetime.now()
        datestamp = "%s%02d%02d" % (now.year,now.month,now.day)
        style_file = os.path.join(stage_dir,mocked_run.job.name+"-"+datestamp+".qgs")
        mock_open.assert_called_once_with(style_file, 'w')
        self.assertEquals(returnvalue,style_file)

        # test 2 - without a provider task

        returnvalue = generate_qgs_style(run_uid, None)
        self.assertEquals(returnvalue,style_file)
Exemple #57
0
    def test_backup_info_exception(self, command_mock):
        # BackupManager mock
        backup_manager = build_backup_manager(name='test_server')
        backup_manager.config.pre_test_hook = 'not_existent_script'
        backup_manager.get_previous_backup = MagicMock()
        backup_manager.get_previous_backup.side_effect = \
            UnknownBackupIdException()
        backup_manager.get_next_backup = MagicMock()
        backup_manager.get_next_backup.side_effect = \
            UnknownBackupIdException()

        # BackupInfo mock
        backup_info = MagicMock(name='backup_info')
        backup_info.get_basebackup_directory.return_value = 'backup_directory'
        backup_info.backup_id = '123456789XYZ'
        backup_info.error = None
        backup_info.status = 'OK'

        # the actual test
        script = HookScriptRunner(backup_manager, 'test_hook', 'pre')
        script.env_from_backup_info(backup_info)
        expected_env = {
            'BARMAN_PHASE': 'pre',
            'BARMAN_VERSION': version,
            'BARMAN_SERVER': 'test_server',
            'BARMAN_CONFIGURATION': 'build_config_from_dicts',
            'BARMAN_HOOK': 'test_hook',
            'BARMAN_BACKUP_DIR': 'backup_directory',
            'BARMAN_BACKUP_ID': '123456789XYZ',
            'BARMAN_ERROR': '',
            'BARMAN_STATUS': 'OK',
            'BARMAN_PREVIOUS_ID': '',
            'BARMAN_NEXT_ID': '',
            'BARMAN_RETRY': '0',
        }
        script.run()
        assert command_mock.call_count == 1
        assert command_mock.call_args[1]['env_append'] == expected_env
    def setup_method(self):
        BraintreeTriggered._has_been_setup = True
        BraintreeTriggeredRecurring._has_been_setup = True

        transaction = MagicMock()
        transaction.amount = 1000
        transaction.status = BraintreeTransaction.Status.Settled
        transaction.id = 'beertrain'
        transaction.processor_response_code = 2000
        transaction.payment_instrument_type = 'paypal_account'

        transaction.paypal_details = MagicMock()
        transaction.paypal_details.image_url = 'image_url'
        transaction.paypal_details.payer_email = 'payer_email'
        transaction.paypal_details.token = 'kento'

        transaction.credit_card_details = MagicMock()
        transaction.credit_card_details.image_url = 'image_url'
        transaction.credit_card_details.last_4 = '1234'
        transaction.credit_card_details.card_type = 'card_type'
        transaction.credit_card_details.token = 'kento'

        transaction.customer_details = MagicMock()
        transaction.customer_details.id = 'braintree_id'

        self.transaction = transaction

        result = MagicMock()
        result.is_success = True
        result.transaction = transaction
        result.errors = MagicMock()
        result.errors.deep_errors = [
            MagicMock(code=2001), MagicMock(code=2042)
        ]

        self.result = result

        self.search_result = MagicMock(items=[self.transaction])
Exemple #59
0
    def test_backup_info_exception(self, command_mock):
        # BackupManager mock
        backup_manager = build_backup_manager(name="test_server")
        backup_manager.config.pre_test_hook = "not_existent_script"
        backup_manager.get_previous_backup = MagicMock()
        backup_manager.get_previous_backup.side_effect = UnknownBackupIdException(
        )
        backup_manager.get_next_backup = MagicMock()
        backup_manager.get_next_backup.side_effect = UnknownBackupIdException()

        # BackupInfo mock
        backup_info = MagicMock(name="backup_info")
        backup_info.get_basebackup_directory.return_value = "backup_directory"
        backup_info.backup_id = "123456789XYZ"
        backup_info.error = None
        backup_info.status = "OK"

        # the actual test
        script = HookScriptRunner(backup_manager, "test_hook", "pre")
        script.env_from_backup_info(backup_info)
        expected_env = {
            "BARMAN_PHASE": "pre",
            "BARMAN_VERSION": version,
            "BARMAN_SERVER": "test_server",
            "BARMAN_CONFIGURATION": "build_config_from_dicts",
            "BARMAN_HOOK": "test_hook",
            "BARMAN_BACKUP_DIR": "backup_directory",
            "BARMAN_BACKUP_ID": "123456789XYZ",
            "BARMAN_ERROR": "",
            "BARMAN_STATUS": "OK",
            "BARMAN_PREVIOUS_ID": "",
            "BARMAN_NEXT_ID": "",
            "BARMAN_RETRY": "0",
        }
        script.run()
        assert command_mock.call_count == 1
        assert command_mock.call_args[1]["env_append"] == expected_env
Exemple #60
0
def retry_helper(tries, delay, backoff, cap, mock_sleep):
    """
    Helper function that calls a function with the retry decorator. This
    helper returns mock_request and mock_sleep. mock_request is called from
    inside the decorated function, and mock_sleep is the mocked `time.sleep`.
    """
    mock_request = MagicMock()
    mock_status = MagicMock()
    mock_status.status = 502

    @_retry(tries, delay, backoff, cap)
    def func():
        mock_request()
        raise TransportException(mock_status, None)

    # The function should eventually raise the exception
    try:
        func()
    except TransportException:
        pass
    else:
        raise AssertionError()

    return mock_request, mock_sleep