Ejemplo n.º 1
0
    def setUp(self):
        AddPatch(self, patch.dict('os.environ',
                                  {'NACL_SDK_ROOT': '/sdk/root'}))
        AddPatch(
            self, patch('webports.util.GetPlatform',
                        Mock(return_value='linux')))
        AddPatch(
            self,
            patch('webports.util.GetInstallRoot',
                  Mock(return_value='/package/install/path')))
        AddPatch(
            self,
            patch('webports.util.GetSDKRoot', Mock(return_value='/sdk/root')))

        mock_lock = Mock()
        mock_lock.__enter__ = lambda s: s
        mock_lock.__exit__ = Mock(return_value=False)
        AddPatch(
            self,
            patch('webports.util.InstallLock', Mock(return_value=mock_lock)))

        mock_lock = Mock()
        mock_lock.__enter__ = lambda s: s
        mock_lock.__exit__ = Mock(return_value=False)
        AddPatch(
            self, patch('webports.util.BuildLock',
                        Mock(return_value=mock_lock)))
Ejemplo n.º 2
0
    def test_load(self, _open, listdir):
        files = ['a.conf', 'b.conf', 'c.other']

        fp0 = Mock()
        fp0.buffer = StringIO(self.FILE % tuple(range(0, 4)))
        fp0.readline.side_effect = fp0.buffer.readline
        fp0.__enter__ = Mock(return_value=fp0)
        fp0.__exit__ = Mock()

        fp1 = Mock()
        fp1.buffer = StringIO(self.FILE % tuple(range(4, 8)))
        fp1.readline.side_effect = fp1.buffer.readline
        fp1.__enter__ = Mock(return_value=fp1)
        fp1.__exit__ = Mock()

        _open.side_effect = [fp0, fp1]

        listdir.return_value = files

        # test
        table = AliasTable()
        table.load()

        # validation
        for fp in (fp0, fp1):
            fp.__enter__.assert_called_once_with()
            fp.__exit__.assert_called_once_with(None, None, None)
        self.assertEqual(
            _open.call_args_list,
            [call('/etc/httpd/conf.d/{n}'.format(n=n)) for n in files[:-1]])
        self.assertEqual(table.table, {'0': '1', '2': '3', '4': '5', '6': '7'})
    def test_get_api_pod_parse_error(self, m_json_load, m_session):
        # Set up driver.
        self.driver.pod_name = 'pod-1'
        self.driver.namespace = 'a'
        pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'

        api_root = "http://kubernetesapi:8080/api/v1/"
        self.driver.api_root = api_root

        # Set up mock objects
        self.driver.auth_token = 'TOKEN'

        m_json_load.side_effect = TypeError

        get_obj = Mock()
        get_obj.status_code = 200
        get_obj.text = pod1

        m_session_obj = Mock()
        m_session_obj.headers = Mock()
        m_session_obj.get.return_value = get_obj

        m_session.return_value = m_session_obj
        m_session_obj.__enter__ = Mock(return_value=m_session_obj)
        m_session_obj.__exit__ = Mock(return_value=False)

        # Call method under test
        assert_raises(ApplyProfileError, self.driver._get_api_pod)
Ejemplo n.º 4
0
    def test_inject_parent_settings(self, _pulp_conf, _read_config, _open):
        host = 'test-host'
        cert_path = '/path/cert'

        _pulp_conf.get.return_value = host
        _read_config.return_value.main = Mock(node_certificate=cert_path)

        fp = Mock()
        fp.__enter__ = Mock(return_value=fp)
        fp.__exit__ = Mock()
        _open.return_value = fp

        # test
        options = {}
        NodeProfiler._inject_parent_settings(options)

        # validation
        _pulp_conf.get.assert_called_once_with('server', 'server_name')
        _read_config.assert_called_once_with()
        _open.assert_called_once_with(cert_path)
        settings = options[constants.PARENT_SETTINGS]
        self.assertEqual(settings[constants.HOST], host)
        self.assertEqual(settings[constants.PORT], 443)
        self.assertEqual(settings[constants.NODE_CERTIFICATE],
                         _open.return_value.read.return_value)
Ejemplo n.º 5
0
def vcenter_api_client():
    vcenter_client = Mock()
    vcenter_client.__enter__ = Mock()
    vcenter_client.__exit__ = Mock()
    vcenter_client.get_ip_pool_for_dpg.return_value = None
    vcenter_client.set_vlan_id.return_value = 'success', 'success message'
    return vcenter_client
Ejemplo n.º 6
0
    def setUp(self):
        self.context = ResourceCommandContext()
        self.context.resource = ResourceContextDetails()
        self.context.resource.name = 'resource'
        self.context.reservation = Mock()
        self.context.reservation.reservation_id = 'e34aa58a-468e-49a1-8a1d-0da1d2cc5b41'

        self.file_system = Mock()
        self.file_system.create_file = Mock(
            return_value=mock_enter_exit(Mock()))
        self.downloader = Mock()
        self.executor = Mock()
        self.executor.execute_playbook = Mock(return_value=['', ''])
        self.logger = mock_enter_exit(Mock())
        session = Mock()
        session_context = Mock()
        session_context.__enter__ = Mock(return_value=session)
        session_context.__exit__ = Mock()
        self.session_provider = Mock()
        self.session_provider.get = Mock(return_value=session_context)

        self.conf = AnsibleConfiguration()
        self.conf.timeout_minutes = "0.0"
        self.shell = AnsibleShell(self.file_system, self.downloader,
                                  self.executor)
        self.shell.connection_service.check_connection = Mock()

        self.ansible_result_patcher = patch(
            'cloudshell.cm.ansible.ansible_shell.AnsibleResult')
        self.ansible_result = Mock()
        self.ansible_result.success = True
        self.ansible_result.ctor = self.ansible_result_patcher.start()
        self.ansible_result.ctor.return_value = self.ansible_result
Ejemplo n.º 7
0
    def test_inject_parent_settings(self, _pulp_conf, _read_config, _open):
        host = 'test-host'
        cert_path = '/path/cert'

        _pulp_conf.get.return_value = host
        _read_config.return_value.main = Mock(node_certificate=cert_path)

        fp = Mock()
        fp.__enter__ = Mock(return_value=fp)
        fp.__exit__ = Mock()
        _open.return_value = fp

        # test
        options = {}
        NodeProfiler._inject_parent_settings(options)

        # validation
        _pulp_conf.get.assert_called_once_with('server', 'server_name')
        _read_config.assert_called_once_with()
        _open.assert_called_once_with(cert_path)
        settings = options[constants.PARENT_SETTINGS]
        self.assertEqual(settings[constants.HOST], host)
        self.assertEqual(settings[constants.PORT], 443)
        self.assertEqual(
            settings[constants.NODE_CERTIFICATE],
            _open.return_value.read.return_value)
Ejemplo n.º 8
0
    def test_get_api_pod(self, m_json_load, m_session):
        # Set up driver.
        self.driver.pod_name = 'pod-1'
        self.driver.namespace = 'a'
        pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'

        api_root = "http://kubernetesapi:8080/api/v1/"
        self.driver.api_root = api_root

        # Set up mock objects
        self.driver.auth_token = 'TOKEN'

        get_obj = Mock()
        get_obj.status_code = 200
        get_obj.text = pod1

        m_session_obj = Mock()
        m_session_obj.headers = Mock()
        m_session_obj.get.return_value = get_obj

        m_session.return_value = m_session_obj
        m_session_obj.__enter__ = Mock(return_value=m_session_obj)
        m_session_obj.__exit__ = Mock(return_value=False)

        # Call method under test
        self.driver._get_api_pod()

        # Assert correct data in calls.
        m_session_obj.headers.update.assert_called_once_with(
            {'Authorization': 'Bearer ' + 'TOKEN'})
        m_session_obj.get.assert_called_once_with(api_root +
                                                  'namespaces/a/pods/pod-1',
                                                  verify=False)
        m_json_load.assert_called_once_with(pod1)
Ejemplo n.º 9
0
    def test_get_api_pod_with_client_certs(self, m_json_load, m_session):
        # Set up driver.
        self.driver.pod_name = 'pod-1'
        self.driver.namespace = 'a'
        pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'

        api_root = "http://kubernetesapi:8080/api/v1/"
        self.driver.api_root = api_root
        self.driver.client_certificate = "cert.pem"
        self.driver.client_key = "key.pem"
        self.driver.certificate_authority = "ca.pem"

        get_obj = Mock()
        get_obj.status_code = 200
        get_obj.text = pod1

        m_session_obj = Mock()
        m_session_obj.headers = Mock()
        m_session_obj.get.return_value = get_obj

        m_session.return_value = m_session_obj
        m_session_obj.__enter__ = Mock(return_value=m_session_obj)
        m_session_obj.__exit__ = Mock(return_value=False)

        # Call method under test
        self.driver._get_api_pod()

        # Assert correct data in calls.
        m_session_obj.get.assert_called_once_with(api_root +
                                                  'namespaces/a/pods/pod-1',
                                                  verify="ca.pem",
                                                  cert=("cert.pem", "key.pem"))
        m_json_load.assert_called_once_with(pod1)
Ejemplo n.º 10
0
    def setUp(self) -> None:
        data_obj = MagicMock(key="foo", filename="foo.yml", data={"name": "foo"})
        runtime = MagicMock()
        runtime.group_config.urls.cgit = "http://distgit.example.com/cgit"
        runtime.group_config.scan_freshness.threshold_hours = 6
        runtime.logger = Mock()

        koji_mock = Mock()
        koji_mock.__enter__ = Mock()
        koji_mock.__enter__.return_value = koji_mock
        koji_mock.__exit__ = Mock()

        runtime.pooled_koji_client_session = Mock()
        runtime.pooled_koji_client_session.return_value = koji_mock

        self.package_id = 5
        koji_mock.getPackage = Mock(return_value={'name': 'foo-container', 'id': self.package_id})
        koji_mock.listTags = Mock(return_value=[{'name': 'rhaos-4.7-rhel-8-candidate'}])

        runtime.assembly = 'hotfix_a'
        image_meta = Metadata("image", runtime, data_obj)
        image_meta.logger = Mock()
        image_meta.get_component_name = Mock(return_value='foo-container')
        image_meta.branch_major_minor = Mock(return_value='4.7')
        image_meta.branch = Mock(return_value='rhaos-4.7-rhel-8')
        image_meta.candidate_brew_tags = Mock(return_value=['rhaos-4.7-rhel-8-candidate', 'rhaos-4.7-rhel-7-candidate'])

        self.runtime = runtime
        self.meta = image_meta
        self.koji_mock = koji_mock
Ejemplo n.º 11
0
    def test_get_api_pod_parse_error(self, m_json_load, m_session):
        # Set up driver.
        self.driver.pod_name = 'pod-1'
        self.driver.namespace = 'a'
        pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'

        api_root = "http://kubernetesapi:8080/api/v1/"
        self.driver.api_root = api_root

        # Set up mock objects
        self.driver.auth_token = 'TOKEN'

        m_json_load.side_effect = TypeError

        get_obj = Mock()
        get_obj.status_code = 200
        get_obj.text = pod1

        m_session_obj = Mock()
        m_session_obj.headers = Mock()
        m_session_obj.get.return_value = get_obj

        m_session.return_value = m_session_obj
        m_session_obj.__enter__ = Mock(return_value=m_session_obj)
        m_session_obj.__exit__ = Mock(return_value=False)

        # Call method under test
        assert_raises(ApplyProfileError, self.driver._get_api_pod)
Ejemplo n.º 12
0
def test_run_interactive(capfd):
    """Ensure the calls to run a command on a list of hosts interactively."""

    runner = Bladerunner({"threads": 14})
    fake_result = Mock()
    fake_result.result = Mock(return_value="fake results")

    mock_con = Mock()
    runner.interactive_hosts = {"fake host": mock_con}

    fake_thread = Mock()
    fake_thread.__enter__ = fake_context
    fake_thread.__exit__ = fake_context
    fake_thread.submit = Mock(return_value=fake_result)

    threadpool_mock = patch.object(
        base,
        "ThreadPoolExecutor",
        return_value=fake_thread,
    )

    with patch.object(runner, "setup_interactive") as mock_setup:
        with threadpool_mock as mock_threadpool:
            runner.run_interactive("fake cmd", "fake host")

    mock_setup.assert_called_once_with("fake host")
    mock_threadpool.assert_called_once_with(max_workers=14)

    stdout, stderr = capfd.readouterr()
    assert stdout == "fake host: fake results\n"
    assert stderr == ""
Ejemplo n.º 13
0
def test_run_interactive_returns():
    """Confirm the dict return when print_results is False."""

    runner = Bladerunner({"threads": 17})
    fake_result = Mock()
    fake_result.result = Mock(return_value="some result")

    mock_con = Mock()
    runner.interactive_hosts = {"host": mock_con}

    fake_thread = Mock()
    fake_thread.__enter__ = fake_context
    fake_thread.__exit__ = fake_context
    fake_thread.submit = Mock(return_value=fake_result)

    threadpool_mock = patch.object(
        base,
        "ThreadPoolExecutor",
        return_value=fake_thread,
    )

    with patch.object(runner, "setup_interactive") as mock_setup:
        with threadpool_mock as mock_threadpool:
            results = runner.run_interactive("ok", "host", print_results=False)

    mock_setup.assert_called_once_with("host")
    mock_threadpool.assert_called_once_with(max_workers=17)

    assert results == {"host": "some result"}
Ejemplo n.º 14
0
    def test_get_api_pod_with_client_certs(self, m_json_load, m_session):
        # Set up driver.
        self.driver.pod_name = 'pod-1'
        self.driver.namespace = 'a'
        pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'

        api_root = "http://kubernetesapi:8080/api/v1/"
        self.driver.api_root = api_root
        self.driver.client_certificate = "cert.pem"
        self.driver.client_key = "key.pem"
        self.driver.certificate_authority = "ca.pem"

        get_obj = Mock()
        get_obj.status_code = 200
        get_obj.text = pod1

        m_session_obj = Mock()
        m_session_obj.headers = Mock()
        m_session_obj.get.return_value = get_obj

        m_session.return_value = m_session_obj
        m_session_obj.__enter__ = Mock(return_value=m_session_obj)
        m_session_obj.__exit__ = Mock(return_value=False)

        # Call method under test
        self.driver._get_api_pod()

        # Assert correct data in calls.
        m_session_obj.get.assert_called_once_with(
            api_root + 'namespaces/a/pods/pod-1',
            verify="ca.pem", cert=("cert.pem", "key.pem"))
        m_json_load.assert_called_once_with(pod1)
Ejemplo n.º 15
0
def test_DBExporter():
    path = u'apa/movie'
    xt = u'tree:tiger:ASDASDSADASDASDSADASDASDSADASDASDSADASD'
    db = DB(':memory:')
    db.update(Object(u"dir:apa", {
        u'directory': ValueSet(u"dir:/apa"),
    }))
    db.update(Object('some_file', {
        u'directory': ValueSet(u"dir:apa/movie"),
        u'xt': ValueSet(xt),
    }))

    asset = Mock()
    asset.__enter__ = Mock(return_value=asset)
    asset.__exit__ = Mock(return_value=False)
    asset.status = Mock(
        return_value=proto.AssetStatus(status=proto.SUCCESS))

    bithorde = Mock()
    bithorde.open = Mock(return_value=asset)
    bithorde.pool = Mock(return_value=itertools)

    writer = Mock()

    magnet = u'magnet:?xt=urn:' + xt
    exp = links.DBExporter(db, bithorde, writer)
    exp.export(False)
    writer.assert_called_once_with(path, magnet)
    writer.reset_mock()

    exp.export(False)
    writer.assert_not_called()

    exp.export(True)
    writer.assert_called_once_with(path, magnet)
Ejemplo n.º 16
0
    def test_get_api_pod(self, m_json_load, m_session):
        # Set up driver.
        self.driver.pod_name = 'pod-1'
        self.driver.namespace = 'a'
        pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'

        api_root = "http://kubernetesapi:8080/api/v1/"
        self.driver.api_root = api_root

        # Set up mock objects
        self.driver.auth_token = 'TOKEN'

        get_obj = Mock()
        get_obj.status_code = 200
        get_obj.text = pod1

        m_session_obj = Mock()
        m_session_obj.headers = Mock()
        m_session_obj.get.return_value = get_obj

        m_session.return_value = m_session_obj
        m_session_obj.__enter__ = Mock(return_value=m_session_obj)
        m_session_obj.__exit__ = Mock(return_value=False)

        # Call method under test
        self.driver._get_api_pod()

        # Assert correct data in calls.
        m_session_obj.headers.update.assert_called_once_with(
            {'Authorization': 'Bearer ' + 'TOKEN'})
        m_session_obj.get.assert_called_once_with(
            api_root + 'namespaces/a/pods/pod-1',
            verify=False)
        m_json_load.assert_called_once_with(pod1)
    def test_delete_security_rules(self):
        # Arrange
        self.network_security_group = MagicMock()
        network_client = MagicMock()
        private_ip_address = Mock()
        resource_group_name = "group_name"
        vm_name = "vm_name"
        security_group = NetworkSecurityGroup()
        security_group.name = "security_group_name"
        security_rule = Mock()
        security_rule.name = "rule_name"
        security_rule.destination_address_prefix = private_ip_address
        security_rules = [security_rule]
        security_group.security_rules = security_rules
        self.security_group_service.get_network_security_group = MagicMock()
        self.security_group_service.get_network_security_group.return_value = security_group
        self.network_service.get_private_ip = Mock(
            return_value=private_ip_address)

        contex_enter_mock = Mock()
        locker = Mock()
        locker.__enter__ = contex_enter_mock
        locker.__exit__ = Mock()

        # Act
        self.security_group_service.delete_security_rules(
            network_client, resource_group_name, vm_name, locker, Mock())

        # Verify
        network_client.security_rules.delete.assert_called_once_with(
            resource_group_name=resource_group_name,
            network_security_group_name=security_group.name,
            security_rule_name=security_rule.name)
        contex_enter_mock.assert_called_once()
Ejemplo n.º 18
0
def test_catter():
    fs = Filesystem(DB(':memory:'))
    fs.root().add_file('zeroes', [test_asset_ids], 130)

    asset = Mock()
    asset.__enter__ = Mock(return_value=asset)
    asset.__exit__ = Mock(return_value=False)
    asset.status = Mock(return_value=proto.AssetStatus(size=1024 * 1024, status=proto.SUCCESS))
    asset.__iter__ = Mock(return_value=('\x00' * (128 * 1024) for _ in range(8)))

    bithorde = Mock()
    bithorde.open = Mock(return_value=asset)
    cat = Cat(fs, bithorde)

    sha = sha1()
    for chunk in cat(P('zeroes')):
        sha.update(chunk)
    assert_equals(sha.hexdigest(), '3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3')

    with assert_raises(FNotFound):
        for chunk in cat(P('NON-EXISTING')):
            pass

    asset.status = Mock(return_value=proto.AssetStatus(status=proto.NOTFOUND))
    with assert_raises(NotFoundError):
        for chunk in cat(P('zeroes')):
            pass
Ejemplo n.º 19
0
def test_run_interactive(capfd):
    """Ensure the calls to run a command on a list of hosts interactively."""

    runner = Bladerunner({"threads": 14})
    fake_result = Mock()
    fake_result.result = Mock(return_value="fake results")

    mock_con = Mock()
    runner.interactive_hosts = {"fake host": mock_con}

    fake_thread = Mock()
    fake_thread.__enter__ = fake_context
    fake_thread.__exit__ = fake_context
    fake_thread.submit = Mock(return_value=fake_result)

    threadpool_mock = patch.object(
        base,
        "ThreadPoolExecutor",
        return_value=fake_thread,
    )

    with patch.object(runner, "setup_interactive") as mock_setup:
        with threadpool_mock as mock_threadpool:
            runner.run_interactive("fake cmd", "fake host")

    mock_setup.assert_called_once_with("fake host")
    mock_threadpool.assert_called_once_with(max_workers=14)

    stdout, stderr = capfd.readouterr()
    assert stdout == "fake host: fake results\n"
    assert stderr == ""
Ejemplo n.º 20
0
def test_run_interactive_returns():
    """Confirm the dict return when print_results is False."""

    runner = Bladerunner({"threads": 17})
    fake_result = Mock()
    fake_result.result = Mock(return_value="some result")

    mock_con = Mock()
    runner.interactive_hosts = {"host": mock_con}

    fake_thread = Mock()
    fake_thread.__enter__ = fake_context
    fake_thread.__exit__ = fake_context
    fake_thread.submit = Mock(return_value=fake_result)

    threadpool_mock = patch.object(
        base,
        "ThreadPoolExecutor",
        return_value=fake_thread,
    )

    with patch.object(runner, "setup_interactive") as mock_setup:
        with threadpool_mock as mock_threadpool:
            results = runner.run_interactive("ok", "host", print_results=False)

    mock_setup.assert_called_once_with("host")
    mock_threadpool.assert_called_once_with(max_workers=17)

    assert results == {"host": "some result"}
Ejemplo n.º 21
0
    def testErrorResultAndActiveModelInScrubInferernceResults(
            self, repoMock, *_args):
        """Calling _scrubInferenceResultsAndInitMetricData with a failed inference
    result and ACTIVE model should set the model to ERROR state and raise
    RejectedInferenceResultBatch.
    """
        class MetricRowSpec(object):
            uid = None
            status = None
            parameters = None
            server = None

        metricRowMock = Mock(spec_set=MetricRowSpec,
                             status=MetricStatus.ACTIVE,
                             parameters=None,
                             uid=0)

        class MetricDataRowSpec(object):
            uid = None
            rowid = None
            metric_value = None
            timestamp = None
            raw_anomaly_score = None

        metricRowDataMock = Mock(spec_set=MetricDataRowSpec,
                                 uid=0,
                                 rowid=0,
                                 timestamp=None,
                                 metric_value=0,
                                 raw_anomaly_score=None)

        engineMock = Mock(spec_set=sqlalchemy.engine.Engine)

        cmMock = Mock()
        engineMock.connect.return_value = cmMock
        cmMock.__enter__ = cmMock
        cmMock.__exit__ = cmMock

        connMock = Mock(spec_set=sqlalchemy.engine.Connection)
        cmMock.return_value = connMock

        runner = anomaly_service.AnomalyService()

        with self.assertRaises(
                anomaly_service.RejectedInferenceResultBatch) as cm:
            runner._scrubInferenceResultsAndInitMetricData(
                engine=engineMock,
                inferenceResults=[
                    ModelInferenceResult(rowID=0,
                                         status=MetricStatus.ERROR,
                                         errorMessage="bad inference")
                ],
                metricDataRows=[metricRowDataMock],
                metricObj=metricRowMock)

        repoMock.setMetricStatus.assert_called_with(connMock, 0,
                                                    MetricStatus.ERROR,
                                                    "bad inference")
        self.assertIn("promoted to ERROR state", cm.exception.args[0])
Ejemplo n.º 22
0
 def test_write_data(self, m_open):
     mock_fp = Mock()
     mock_fp.__enter__ = lambda x: mock_fp
     mock_fp.__exit__ = lambda w, x, y, z: None
     m_open.return_value = mock_fp
     c.write_to_file('data', 'outfile')
     m_open.assert_called_once_with('outfile', 'w')
     mock_fp.write.assert_called_once_with('data')
Ejemplo n.º 23
0
 def create_file_context_manager(*args, **kwargs):
     path = args[0]
     file_mock = Mock()
     file_mock.read = Mock(return_value=file_map[path])
     cm = Mock()
     cm.__enter__ = Mock(return_value=file_mock)
     cm.__exit__ = Mock()
     return cm
Ejemplo n.º 24
0
 def create_file_context_manager(*args, **kwargs):
     path = args[0]
     file_mock = Mock()
     file_mock.read = Mock(return_value=file_map[path])
     cm = Mock()
     cm.__enter__ = Mock(return_value=file_mock)
     cm.__exit__ = Mock()
     return cm
Ejemplo n.º 25
0
def test_execute_jobs():
    context = Mock()
    context.args = Mock()
    context.args.event_handlers = None
    task_context = Mock()
    task_context.pkg = Mock()
    task_context.pkg.name = 'name'
    jobs = {
        'one':
        Job(identifier='id',
            dependencies=set(),
            task=None,
            task_context=task_context)
    }

    event_reactor = Mock()
    event_reactor.__enter__ = lambda self: self
    event_reactor.__exit__ = lambda self, *args: None
    with patch('colcon_core.executor.create_event_reactor',
               return_value=event_reactor):
        with EntryPointContext(extension1=Extension1, extension2=Extension2):
            # no extension selected
            with pytest.raises(AssertionError):
                execute_jobs(context, jobs)

            # execute method not implemented and sending skipped job event
            context.args.executor = 'extension2'
            with patch('colcon_core.executor.logger.error') as error:
                rc = execute_jobs(context, jobs)
            assert rc == 1
            assert error.call_count == 1
            assert len(error.call_args[0]) == 1
            assert error.call_args[0][0].startswith(
                "Exception in executor extension 'extension2': \n")
            assert event_reactor.get_queue().put.call_count == 2
            assert isinstance(
                event_reactor.get_queue().put.call_args_list[0][0][0][0],
                JobQueued)
            assert isinstance(
                event_reactor.get_queue().put.call_args_list[1][0][0][0],
                JobSkipped)

            # successful execution
            event_reactor.get_queue().put.reset_mock()
            jobs['one'].returncode = 0
            extensions = get_executor_extensions()
            extensions[110]['extension2'].execute = \
                lambda args, jobs, on_error: 0
            callback = Mock()
            rc = execute_jobs(context,
                              jobs,
                              on_error=OnError.interrupt,
                              pre_execution_callback=callback)
            assert rc == 0
            assert event_reactor.get_queue().put.call_count == 1
            assert isinstance(event_reactor.get_queue().put.call_args[0][0][0],
                              JobQueued)
            assert callback.call_count == 1
Ejemplo n.º 26
0
    def test_update(self):
        value_function = Mock()
        value_function.__enter__ = Mock(return_value=(Mock(), None))
        value_function.__exit__ = Mock(return_value=None)

        advantage_function = Gae(value_function=value_function, gamma=1, lambduh=1)
        episodes = generate_episodes([[0, 0, 0], [0, 1, 2], [2, 1, 0], [1, 1, 1]])

        advantage_function.update(episodes)
Ejemplo n.º 27
0
def global_reader_bis(path=''):
    reader = Mock(spec=RasterReader)
    reader.shape = (361, 720)
    reader.affine = Affine(-180., 0.5, 0.0, 90., 0.0, -0.5)

    context = Mock()
    context.__enter__ = Mock(return_value=reader)
    context.__exit__ = Mock(return_value=False)
    return context
    def _get_context_mock(self, **kwargs):
        """
        Mock the get_receipt_emails context manager
        """

        inner_mock = Mock()
        inner_mock.__enter__ = Mock(**kwargs)
        inner_mock.__exit__ = Mock(return_value=False)

        return inner_mock
Ejemplo n.º 29
0
def global_reader_invalid_bounds(path=''):
    reader = Mock(spec=RasterReader)
    reader.shape = (360, 720)
    reader.affine = Affine(-180., 0.5, 0.0, 90., 0.0, -0.5)
    reader.bounds = BoundingBox(-180., 90., 0.5, 0.)

    context = Mock()
    context.__enter__ = Mock(return_value=reader)
    context.__exit__ = Mock(return_value=False)
    return context
Ejemplo n.º 30
0
    def testContextManagerMocking(self):
        mock = Mock()
        mock.__enter__ = Mock()
        mock.__exit__ = Mock()
        mock.__exit__.return_value = False

        with mock as m:
            self.assertEqual(m, mock.__enter__.return_value)
        mock.__enter__.assert_called_with()
        mock.__exit__.assert_called_with(None, None, None)
Ejemplo n.º 31
0
 def test_update_unlocked(self):
     ''' til; How to mock a context generator '''
     job = {'app_id': 6380}
     self.master.apphandlerlocks = {6380: None}
     nblc = Mock()
     nblc.__enter__ = Mock(return_value=False)
     nblc.__exit__ = Mock()
     nblc_mock = Mock(return_value=nblc)
     with patch('master.NBLockContext', nblc_mock, create=True):
         self.assertFalse(self.master.api_update(job, Mock()))
Ejemplo n.º 32
0
    def testContextManagerMocking(self):
        mock = Mock()
        mock.__enter__ = Mock()
        mock.__exit__ = Mock()
        mock.__exit__.return_value = False

        with mock as m:
            self.assertEqual(m, mock.__enter__.return_value)
        mock.__enter__.assert_called_with()
        mock.__exit__.assert_called_with(None, None, None)
Ejemplo n.º 33
0
 def test_update_unlocked(self):
     ''' til; How to mock a context generator '''
     job = {'app_id': 6380}
     self.master.apphandlerlocks = {6380: None}
     nblc = Mock()
     nblc.__enter__ = Mock(return_value=False)
     nblc.__exit__ = Mock()
     nblc_mock = Mock(return_value=nblc)
     with patch('master.NBLockContext', nblc_mock, create=True):
         self.assertFalse(self.master.api_update(job, Mock()))
Ejemplo n.º 34
0
  def testErrorResultAndActiveModelInScrubInferernceResults(
      self, repoMock, *_args):
    """Calling _scrubInferenceResultsAndInitMetricData with a failed inference
    result and ACTIVE model should set the model to ERROR state and raise
    RejectedInferenceResultBatch.
    """

    class MetricRowSpec(object):
      uid = None
      status = None
      parameters = None
      server = None

    metricRowMock = Mock(
        spec_set=MetricRowSpec,
        status=MetricStatus.ACTIVE,
        parameters=None,
        uid=0)

    class MetricDataRowSpec(object):
      uid = None
      rowid = None
      metric_value = None
      timestamp = None
      raw_anomaly_score = None

    metricRowDataMock = Mock(
        spec_set=MetricDataRowSpec,
        uid=0, rowid=0, timestamp=None, metric_value=0, raw_anomaly_score=None)

    engineMock = Mock(spec_set=sqlalchemy.engine.Engine)

    cmMock = Mock()
    engineMock.connect.return_value = cmMock
    cmMock.__enter__ = cmMock
    cmMock.__exit__ = cmMock

    connMock = Mock(spec_set=sqlalchemy.engine.Connection)
    cmMock.return_value = connMock

    runner = anomaly_service.AnomalyService()

    with self.assertRaises(anomaly_service.RejectedInferenceResultBatch) as cm:
      runner._scrubInferenceResultsAndInitMetricData(
          engine=engineMock,
          inferenceResults=[ModelInferenceResult(rowID=0,
                                                 status=MetricStatus.ERROR,
                                                 errorMessage="bad inference")],
          metricDataRows=[metricRowDataMock],
          metricObj=metricRowMock)

    repoMock.setMetricStatus.assert_called_with(
        connMock, 0, MetricStatus.ERROR, "bad inference")
    self.assertIn("promoted to ERROR state", cm.exception.args[0])
Ejemplo n.º 35
0
 def test_setup_application_logging_from_file(self, yaml_mock, open_mock):
     fake_file = Mock()
     fake_file.__exit__ = Mock()
     fake_file.__enter__ = Mock(return_value=fake_file)
     open_mock.return_value = fake_file
     fake_config = {"level": "DEBUG", "handlers": {}, "formatters": {}}
     yaml_mock.safe_load.return_value = fake_config
     config = self.loader.load(filename="fake_file",
                               level="INFO",
                               default_config=None)
     self.assertEqual(config.level, "DEBUG")
Ejemplo n.º 36
0
  def setUp(self):
    AddPatch(self, patch.dict('os.environ', {'NACL_SDK_ROOT': '/sdk/root'}))
    AddPatch(self, patch('naclports.util.GetPlatform',
             Mock(return_value='linux')))
    AddPatch(self, patch('naclports.util.GetInstallRoot',
             Mock(return_value='/package/install/path')))
    AddPatch(self, patch('naclports.util.GetSDKRoot',
             Mock(return_value='/sdk/root')))

    mock_lock = Mock()
    mock_lock.__enter__ = lambda s: s
    mock_lock.__exit__ = Mock(return_value=False)
    AddPatch(self, patch('naclports.util.InstallLock',
             Mock(return_value=mock_lock)))

    mock_lock = Mock()
    mock_lock.__enter__ = lambda s: s
    mock_lock.__exit__ = Mock(return_value=False)
    AddPatch(self, patch('naclports.util.BuildLock',
             Mock(return_value=mock_lock)))
Ejemplo n.º 37
0
  def setUp(self):
    add_patch(self, patch.dict('os.environ', {'NACL_SDK_ROOT': '/sdk/root'}))
    add_patch(self, patch('webports.util.get_platform',
                          Mock(return_value='linux')))
    add_patch(self, patch('webports.util.get_install_root',
                          Mock(return_value='/package/install/path')))
    add_patch(self, patch('webports.util.get_sdk_root',
                          Mock(return_value='/sdk/root')))

    mock_lock = Mock()
    mock_lock.__enter__ = lambda s: s
    mock_lock.__exit__ = Mock(return_value=False)
    add_patch(self, patch('webports.util.InstallLock',
                          Mock(return_value=mock_lock)))

    mock_lock = Mock()
    mock_lock.__enter__ = lambda s: s
    mock_lock.__exit__ = Mock(return_value=False)
    add_patch(self, patch('webports.util.BuildLock',
                          Mock(return_value=mock_lock)))
Ejemplo n.º 38
0
 def test_setup_application_logging_from_file(self, config_mock, json_mock,
                                              open_mock):
     fake_file = Mock()
     fake_file.__exit__ = Mock()
     fake_file.__enter__ = Mock(return_value=fake_file)
     open_mock.return_value = fake_file
     fake_config = {"foo": "bar"}
     json_mock.return_value = fake_config
     app_config = Mock(log_config="/path/to/log/config")
     bg_utils.setup_application_logging(app_config, {})
     config_mock.assert_called_with({"foo": "bar"})
Ejemplo n.º 39
0
    def _setup_mocks(self, stats_extension):
        pipeline_mock = Mock()
        pipeline_contextmanager_mock = Mock()
        pipeline_contextmanager_mock.__enter__ = Mock(
            return_value=pipeline_mock)
        pipeline_contextmanager_mock.__exit__ = Mock(return_value=False)

        stats_extension.pipeline = Mock()
        stats_extension.pipeline.return_value = pipeline_contextmanager_mock

        return pipeline_mock
Ejemplo n.º 40
0
    def test_lock_is_used_if_supplied(self):
        mock_lock = Mock()
        mock_lock.__enter__ = Mock()
        mock_lock.__exit__ = Mock()

        obj = DummyObject()
        exposed_object = ExposedObject(obj, ["a"], lock=mock_lock)

        self.assertEqual(exposed_object["a:get"](), obj.a)

        mock_lock.__enter__.assert_called_once()
        mock_lock.__exit__.assert_called_once()
Ejemplo n.º 41
0
    def _setup_mocks(self, stats_extension):
        pipeline_mock = Mock()
        pipeline_contextmanager_mock = Mock()
        pipeline_contextmanager_mock.__enter__ = Mock(
            return_value=pipeline_mock
        )
        pipeline_contextmanager_mock.__exit__ = Mock(return_value=False)

        stats_extension.pipeline = Mock()
        stats_extension.pipeline.return_value = pipeline_contextmanager_mock

        return pipeline_mock
Ejemplo n.º 42
0
    def test_generate_logging_config(self, open_mock, spec):
        fake_file = Mock()
        fake_file.__exit__ = Mock()
        fake_file.__enter__ = Mock(return_value=fake_file)
        open_mock.return_value = fake_file
        generated_config = {"foo": "bar"}
        config_generator = Mock(return_value=generated_config)

        logging_config = bg_utils.generate_logging_config_file(
            spec, config_generator,
            ["--log-config-file", "/path/to/log/config"])
        assert logging_config == generated_config
        assert open_mock.called is True
Ejemplo n.º 43
0
def reader_context(**attrs):
    reader = Mock(
        spec=DatasetReader,
        shape=(360, 720),
        transform=Affine(-180., 0.5, 0.0, -90., 0.0, 0.5),
        bounds=BoundingBox(-180., -90., 0., 0.),
        crs={"init": "epsg:4326"},
    )
    reader.configure_mock(**attrs)
    context = Mock()
    context.__enter__ = Mock(return_value=reader)
    context.__exit__ = Mock(return_value=False)
    return context
Ejemplo n.º 44
0
    def test_load(self, _open, listdir):
        files = [
            'a.conf',
            'b.conf',
            'c.other'
        ]

        fp0 = Mock()
        fp0.buffer = StringIO(self.FILE % tuple(range(0, 4)))
        fp0.readline.side_effect = fp0.buffer.readline
        fp0.__enter__ = Mock(return_value=fp0)
        fp0.__exit__ = Mock()

        fp1 = Mock()
        fp1.buffer = StringIO(self.FILE % tuple(range(4, 8)))
        fp1.readline.side_effect = fp1.buffer.readline
        fp1.__enter__ = Mock(return_value=fp1)
        fp1.__exit__ = Mock()

        _open.side_effect = [
            fp0,
            fp1
        ]

        listdir.return_value = files

        # test
        table = AliasTable()
        table.load()

        # validation
        for fp in (fp0, fp1):
            fp.__enter__.assert_called_once_with()
            fp.__exit__.assert_called_once_with(None, None, None)
        self.assertEqual(
            _open.call_args_list,
            [call('/etc/httpd/conf.d/{n}'.format(n=n)) for n in files[:-1]])
        self.assertEqual(table.table, {'0': '1', '2': '3', '4': '5', '6': '7'})
Ejemplo n.º 45
0
    def test_works(self, gamma, lambduh, rewards, expected_advantages):
        value_function = Mock()
        value_function.__enter__ = Mock(return_value=(Mock(), None))
        value_function.__exit__ = Mock(return_value=None)
        value_function.get_values = Mock()
        value_function.get_values.side_effect = np.asarray(rewards)


        advantage_function = Gae(value_function=value_function, gamma=gamma, lambduh=lambduh)
        episodes = generate_episodes(rewards)

        advantages = advantage_function.get_advantages(episodes)

        assert advantages == expected_advantages
Ejemplo n.º 46
0
 def test_execute_playbook_fail(self):
     self.mocks['mkdtemp'].return_value = '/inventory/dir'
     task = self.klass(self.ctx, self.task_config)
     task.setup()
     with patch.object(ansible.pexpect, 'run') as m_run:
         with patch('teuthology.task.ansible.open') as m_open:
             fake_failure_log = Mock()
             fake_failure_log.__enter__ = Mock()
             fake_failure_log.__exit__ = Mock()
             m_open.return_value = fake_failure_log
             m_run.return_value = ('', 1)
             with raises(CommandFailedError):
                 task.execute_playbook()
             assert task.ctx.summary.get('status') == 'dead'
Ejemplo n.º 47
0
 def test_execute_playbook_fail(self):
     self.mocks['mkdtemp'].return_value = '/inventory/dir'
     task = self.klass(self.ctx, self.task_config)
     task.setup()
     with patch.object(ansible.pexpect, 'run') as m_run:
         with patch('teuthology.task.ansible.open') as m_open:
             fake_failure_log = Mock()
             fake_failure_log.__enter__ = Mock()
             fake_failure_log.__exit__ = Mock()
             m_open.return_value = fake_failure_log
             m_run.return_value = ('', 1)
             with raises(CommandFailedError):
                 task.execute_playbook()
             assert task.ctx.summary.get('status') == 'dead'
Ejemplo n.º 48
0
    def test_should_report_failed_tests_to_ci_server(self, proxy):
        project = Project("basedir")
        mock_proxy = Mock()
        proxy.return_value = mock_proxy
        mock_proxy.and_test_name.return_value = mock_proxy
        mock_proxy.__enter__ = Mock(return_value=mock_proxy)
        mock_proxy.__exit__ = Mock(return_value=False)
        result = Mock()
        result.test_names = ["test1", "test2", "test3"]
        result.failed_test_names_and_reasons = {"test2": "Something went very wrong"}

        report_to_ci_server(project, result)

        mock_proxy.fails.assert_called_with("Something went very wrong")
Ejemplo n.º 49
0
    def test_should_report_passed_tests_to_ci_server(self, proxy):
        project = Project('basedir')
        mock_proxy = Mock()
        proxy.return_value = mock_proxy
        mock_proxy.and_test_name.return_value = mock_proxy
        mock_proxy.__enter__ = Mock(return_value=mock_proxy)
        mock_proxy.__exit__ = Mock(return_value=False)
        result = Mock()
        result.test_names = ['test1', 'test2', 'test3']
        result.failed_test_names_and_reasons = {}

        report_to_ci_server(project, result)

        mock_proxy.fails.assert_not_called()
Ejemplo n.º 50
0
 def test_execute_playbook_fail(self):
     self.task_config.update(dict(playbook=[]))
     task = self.klass(self.ctx, self.task_config)
     task.setup()
     with patch.object(ansible.pexpect, "run") as m_run:
         with patch("teuthology.task.ansible.open") as m_open:
             fake_failure_log = Mock()
             fake_failure_log.__enter__ = Mock()
             fake_failure_log.__exit__ = Mock()
             m_open.return_value = fake_failure_log
             m_run.return_value = ("", 1)
             with raises(CommandFailedError):
                 task.execute_playbook()
             assert task.ctx.summary.get("status") is None
Ejemplo n.º 51
0
def mock_get_recording(p_url, timeout=0, stream=False):
    result = Mock()
    result.__enter__ = Mock(return_value=result)
    result.__exit__ = Mock()
    result.iter_content = Mock(return_value='0')
    result.status_code = 200
    result.headers = {'content-length': fetchtv.MAX_OCTET}
    response_dir = os.path.dirname(
        __file__) + os.path.sep + 'responses' + os.path.sep
    if p_url.endswith('cds.xml'):
        result.text = get_file(response_dir + 'fetch_cds.xml')
    else:
        result.text = get_file(response_dir + 'fetch_info.xml')
    return result
    def test_should_report_passed_tests_to_ci_server(self, proxy):
        project = Project('basedir')
        mock_proxy = Mock()
        proxy.return_value = mock_proxy
        mock_proxy.and_test_name.return_value = mock_proxy
        mock_proxy.__enter__ = Mock(return_value=mock_proxy)
        mock_proxy.__exit__ = Mock(return_value=False)
        result = Mock()
        result.test_names = ['test1', 'test2', 'test3']
        result.failed_test_names_and_reasons = {}

        report_to_ci_server(project, result)

        mock_proxy.fails.assert_not_called()
Ejemplo n.º 53
0
 def test_execute_playbook_fail(self):
     self.task_config.update(dict(
         playbook=[],
     ))
     task = self.klass(self.ctx, self.task_config)
     task.setup()
     with patch.object(ansible.pexpect, 'run') as m_run:
         with patch('teuthology.task.ansible.open') as m_open:
             fake_failure_log = Mock()
             fake_failure_log.__enter__ = Mock()
             fake_failure_log.__exit__ = Mock()
             m_open.return_value = fake_failure_log
             m_run.return_value = ('', 1)
             with raises(CommandFailedError):
                 task.execute_playbook()
Ejemplo n.º 54
0
    def test_load(self, mock_open):
        mock_fp = Mock()
        mock_fp.read = Mock(return_value=RSA_KEY)
        mock_fp.__enter__ = Mock(return_value=mock_fp)
        mock_fp.__exit__ = Mock()
        mock_open.return_value = mock_fp

        # test

        authenticator = Authenticator()
        authenticator.load()

        # validation

        self.assertTrue(mock_fp.__exit__.called)
        self.assertTrue(isinstance(authenticator.rsa_key, RSA.RSA))
Ejemplo n.º 55
0
 def setUp(self):
     self.pcmd = taskqueue.daemonlib.parse_cmdline
     opts = Mock()
     opts.foreground = True
     taskqueue.daemonlib.parse_cmdline = Mock(return_value=opts)
     self.config = ConfigParser()
     taskqueue.daemonlib.pika = Mock()
     fake_ctx = Mock()
     fake_ctx.__exit__ = Mock()
     fake_ctx.__enter__ = Mock()
     taskqueue.daemonlib.daemon.DaemonContext = Mock(return_value=fake_ctx)
     taskqueue.daemonlib.logging.config = Mock()
     config = Mock()
     config.items = Mock(return_value=[])
     taskqueue.daemonlib.ConfigParser = Mock(return_value=config)
     self.daemon = taskqueue.daemonlib.Daemon(self.config)
Ejemplo n.º 56
0
    def test_read(self, _open):
        path = '/tmp/xx'
        fp = Mock()
        fp.__enter__ = Mock(return_value=fp)
        fp.__exit__ = Mock()
        _open.return_value = fp

        # test
        content = cudl.read(path)

        # validation
        _open.assert_called_once_with(path)
        fp.__enter__.assert_called_once_with()
        fp.__exit__.assert_called_once_with(None, None, None)
        fp.read.assert_called_once_with()
        self.assertEqual(content, fp.read.return_value)
Ejemplo n.º 57
0
 def _create_zmq_execution_mocks(self, patch, side=None, valid=True,
                                 response=ZMQ_ERROR_RESPONSE):
     socket = Mock()
     context = Mock()
     context.__enter__ = Mock()
     context.__enter__.return_value = socket
     context.__exit__ = Mock()
     context.__exit__.return_value = valid
     patch.return_value = context
     if valid:
         socket.recv.return_value = ZMQ_RESPONSE
     else:
         socket.recv.return_value = response
     if side:
         socket.recv.side_effect = side
     return socket, context
Ejemplo n.º 58
0
    def test_default_paths(self, mock_config, mock_validate, mock_open, *unused):
        mock_config.return_value = INIConfig()

        mock_fp = Mock()
        mock_fp.__enter__ = Mock(return_value=mock_fp)
        mock_fp.__exit__ = Mock()
        mock_open.return_value = mock_fp

        # test
        read_config(validate=False)

        # validation
        paths = ["/etc/pulp/consumer/consumer.conf", os.path.expanduser("~/.pulp/consumer.conf")]
        mock_open.assert_any(paths[0])
        mock_open.assert_any(paths[1])
        self.assertFalse(mock_validate.called)
Ejemplo n.º 59
0
    def test_storage_dir(self, storage):
        url = "url-123"
        repo = Mock(id="id-123")
        config = {importer_constants.KEY_FEED: url}
        st = Mock()
        st.__enter__ = Mock(return_value=st)
        st.__exit__ = Mock()
        storage.return_value = st

        # test
        step = Main(repo=repo, config=config)
        path = step.storage_dir
        storage.assert_called_once_with(constants.STORAGE_PROVIDER, step.remote_id)
        st.__enter__.assert_called_once_with()
        st.__exit__.assert_called_once_with(None, None, None)
        self.assertEqual(path, st.content_dir)
Ejemplo n.º 60
0
    def test_get_pod_config_error(self, m_json_load, m_session):
        """Test _get_api_path with API Access Error
        """
        # Set up mock objects
        self.driver.auth_token = 'TOKEN'

        m_session_obj = Mock()
        m_session_obj.headers = Mock()
        m_session_obj.get.side_effect = BaseException

        m_session.return_value = m_session_obj
        m_session_obj.__enter__ = Mock(return_value=m_session_obj)
        m_session_obj.__exit__ = Mock(return_value=False)

        # Call method under test
        assert_raises(ApplyProfileError, self.driver._get_api_pod)