Пример #1
0
    def test_step_status_is_collected_and_reported(self, format_summary):
        feature = Mock()
        scenario = Mock()
        steps = [Mock(), Mock(), Mock(), Mock(), Mock()]
        steps[0].status = 'failed'
        steps[0].__iter__ = Mock(return_value=iter([]))
        steps[1].status = 'undefined'
        steps[1].__iter__ = Mock(return_value=iter([]))
        steps[2].status = 'passed'
        steps[2].__iter__ = Mock(return_value=iter([]))
        steps[3].status = 'passed'
        steps[3].__iter__ = Mock(return_value=iter([]))
        steps[4].status = None
        steps[4].__iter__ = Mock(return_value=iter([]))
        feature.status = 'failed'
        feature.duration = 12.3
        feature.__iter__ = Mock(return_value=iter([scenario]))
        scenario.status = 'failed'
        scenario.__iter__ = Mock(return_value=iter(steps))

        config = Mock()
        reporter = SummaryReporter(config)

        reporter.feature(feature)
        reporter.end()

        expected = {
            'passed': 2,
            'failed': 1,
            'skipped': 1,
            'untested': 0,
            'undefined': 1,
        }

        eq_(format_summary.call_args_list[2][0], ('step', expected))
Пример #2
0
 def create_mock_scheduled_tasks(cls):
     jobs = []
     for name in ["foo", "bar", "baz"]:
         job = Mock()
         job.key = JobKey(role=cls.TEST_ROLE, environment=cls.TEST_ENV, name=name)
         job.failure_count = 0
         job.assignedTask = Mock(spec=AssignedTask)
         job.assignedTask.slaveHost = "slavehost"
         job.assignedTask.task = Mock(spec=TaskConfig)
         job.assignedTask.task.maxTaskFailures = 1
         job.assignedTask.task.executorConfig = Mock(spec=ExecutorConfig)
         job.assignedTask.task.executorConfig.data = Mock()
         job.assignedTask.task.metadata = []
         job.assignedTask.task.owner = Identity(role="mchucarroll")
         job.assignedTask.task.environment = "test"
         job.assignedTask.task.jobName = "woops"
         job.assignedTask.task.numCpus = 2
         job.assignedTask.task.ramMb = 2
         job.assignedTask.task.diskMb = 2
         job.assignedTask.instanceId = 4237894
         job.assignedTask.assignedPorts = None
         job.status = ScheduleStatus.RUNNING
         mockEvent = Mock(spec=TaskEvent)
         mockEvent.timestamp = 28234726395
         mockEvent.status = ScheduleStatus.RUNNING
         mockEvent.message = "Hi there"
         job.taskEvents = [mockEvent]
         jobs.append(job)
     return jobs
Пример #3
0
    def test_retry_412_successfull(self, mock_get_connection):
        # this tests the read function when first HTTP request returns a
        # 412 but the second one
        # is successful and returns a 200

        # mock the 412 response
        mockHttpResponse412 = Mock(name="HttpResponse412")
        mockHttpResponse412.getheader.return_value = 1
        mockHttpResponse412.status = 412
        mockHttpResponse412.read.return_value = "Fail"

        # mock the 200 response
        mockHttpResponse200 = Mock(name="HttpResponse200")
        mockHttpResponse200.getheader.return_value = 1
        mockHttpResponse200.status = 200
        mockHttpResponse200.read.return_value = "Testing"
        conn = Connection()
        mockHttpRequest = Mock(name="HttpRequest")

        # set a 412 response first followed by a 200 response
        mockHttpRequest.getresponse = MagicMock(
            side_effect=[mockHttpResponse412, mockHttpResponse200])
        conn.get_connection.return_value = mockHttpRequest
        vofile = vos.VOFile(["Some URL"], conn, "GET")
        vofile.currentRetryDelay = 2
Пример #4
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
Пример #5
0
    def test_request(self):
        self.hc.USER_AGENT = "user-agent"
        resp = Mock()
        body = Mock()
        resp.status = 200
        httplib2.Http.request = Mock(return_value=(resp, body))
        self.hc.morph_response_body = Mock(return_value=body)
        r, b = self.hc.request()
        self.assertEqual(resp, r)
        self.assertEqual(body, b)
        self.assertEqual((resp, body), self.hc.last_response)

        httplib2.Http.request = Mock(return_value=(resp, None))
        r, b = self.hc.request()
        self.assertEqual(resp, r)
        self.assertEqual(None, b)

        status_list = [400, 401, 403, 404, 408, 409, 413, 500, 501]
        for status in status_list:
            resp.status = status
            self.assertRaises(ValueError, self.hc.request)

        exception = exceptions.ResponseFormatError
        self.hc.morph_response_body = Mock(side_effect=exception)
        self.assertRaises(Exception, self.hc.request)
Пример #6
0
  def testGetSuggestedInstancesTwoDifferentSize(self, getRDSInstancesMock):
    region = "us-west-2"
    # Instance 1
    instanceMock1 = Mock(spec="boto.rds.dbinstance.DBInstance")
    instanceMock1.status = "available"
    instanceMock1.allocated_storage = 64.0
    instanceMock1.id = "testId1"
    # Instance 2
    instanceMock2 = Mock(spec="boto.rds.dbinstance.DBInstance")
    instanceMock2.status = "available"
    instanceMock2.allocated_storage = 65.0
    instanceMock2.id = "testId2"

    getRDSInstancesMock.return_value = [
        instanceMock1,
        instanceMock2,
    ]

    suggestions = rds_utils.getSuggestedInstances(region)
    self.assertIsInstance(suggestions, types.GeneratorType)
    suggestions = list(suggestions)

    self.assertSequenceEqual(suggestions, [
        {"id": "testId2", "name": "testId2", "namespace": "AWS/RDS",
         "region": region},
        {"id": "testId1", "name": "testId1", "namespace": "AWS/RDS",
         "region": region},
    ])
    getRDSInstancesMock.assert_call_once_with(region)
Пример #7
0
 def create_mock_scheduled_tasks(cls):
   jobs = []
   for name in ['foo', 'bar', 'baz']:
     job_key = JobKey(role=cls.TEST_ROLE, environment=cls.TEST_ENV, name=name)
     job = Mock()
     job.key = job_key
     job.failure_count = 0
     job.assignedTask = Mock(spec=AssignedTask)
     job.assignedTask.taskId = 1287391823
     job.assignedTask.slaveHost = 'slavehost'
     job.assignedTask.task = Mock(spec=TaskConfig)
     job.assignedTask.task.executorConfig = Mock()
     job.assignedTask.task.maxTaskFailures = 1
     job.assignedTask.task.metadata = []
     job.assignedTask.task.job = job_key
     job.assignedTask.task.owner = Identity(role=cls.TEST_ROLE)
     job.assignedTask.task.environment = cls.TEST_ENV
     job.assignedTask.task.jobName = name
     job.assignedTask.task.numCpus = 2
     job.assignedTask.task.ramMb = 2
     job.assignedTask.task.diskMb = 2
     job.assignedTask.instanceId = 4237894
     job.assignedTask.assignedPorts = {}
     job.status = ScheduleStatus.RUNNING
     mockEvent = Mock(spec=TaskEvent)
     mockEvent.timestamp = 28234726395
     mockEvent.status = ScheduleStatus.RUNNING
     mockEvent.message = "Hi there"
     job.taskEvents = [mockEvent]
     jobs.append(job)
   return jobs
Пример #8
0
    def test_retry_successfull(self):
        # this tests the read function when first HTTP request returns a 503 but the second one 
        # is successfull and returns a 200

        # mock the 503 response
        mockHttpResponse503 = Mock(name="HttpResponse503")
        mockHttpResponse503.getheader.return_value = 1
        mockHttpResponse503.status = 503
        mockHttpResponse503.read.return_value = "Fail"
        mockHttpResponse503.len.return_value = 10

        # mock the 200 response
        mockHttpResponse200 = Mock(name="HttpResponse200")
        mockHttpResponse200.getheader.return_value = 1
        mockHttpResponse200.status = 200
        mockHttpResponse200.read.return_value = "Testing"
        mockHttpResponse200.len.return_value = 10
        mockConn = Mock(name="Connection")
        mockHttpRequest = Mock(name="HttpRequest")

        # set a 503 response first followed by a 200 response
        mockHttpRequest.getresponse = MagicMock(name="getresponse mock")
        generator = mockHttpRequest.getresponse.iter.return_value
        iterator = iter([mockHttpResponse503, mockHttpResponse200])
        generator.__iter__.return_value = iterator
        mockConn.getConnection.return_value = mockHttpRequest
        vofile = vos.VOFile(["Some URL"], mockConn, "GET")
 def create_mock_scheduled_tasks(cls):
   jobs = []
   for name in ['foo', 'bar', 'baz']:
     job = Mock()
     job.key = JobKey(role=cls.TEST_ROLE, environment=cls.TEST_ENV, name=name)
     job.failure_count = 0
     job.assignedTask = Mock(spec=AssignedTask)
     job.assignedTask.slaveHost = 'slavehost'
     job.assignedTask.task = Mock(spec=TaskConfig)
     job.assignedTask.task.maxTaskFailures = 1
     job.assignedTask.task.packagesDEPRECATED = []
     job.assignedTask.task.owner = Identity(role='mchucarroll')
     job.assignedTask.task.environment = 'test'
     job.assignedTask.task.jobName = 'woops'
     job.assignedTask.task.numCpus = 2
     job.assignedTask.task.ramMb = 2
     job.assignedTask.task.diskMb = 2
     job.assignedTask.instanceId = 4237894
     job.assignedTask.assignedPorts = None
     job.status = ScheduleStatus.RUNNING
     mockEvent = Mock(spec=TaskEvent)
     mockEvent.timestamp = 28234726395
     mockEvent.status = ScheduleStatus.RUNNING
     mockEvent.message = "Hi there"
     job.taskEvents = [mockEvent]
     jobs.append(job)
   return jobs
Пример #10
0
 def test_delete(self):
     resp = Mock()
     resp.status = 200
     body = None
     self.instances.api.client.delete = Mock(return_value=(resp, body))
     self.instances.delete('instance1')
     resp.status = 500
     self.assertRaises(Exception, self.instances.delete, 'instance1')
Пример #11
0
 def mock_api_call(self, github_api, url, method='GET', fields=None, headers={}):
     result = Mock()
     if method == 'GET':
         result.status = 200
     else:
         result.status = 201
     result.data = json.dumps(self.api_results.pop(0)).encode()
     result.headers.get.return_value = None
     return result
 def test__action(self):
     resp = Mock()
     self.management.api.client.post = Mock(return_value=(resp, 'body'))
     resp.status = 200
     self.management._action(1, 'body')
     self.assertEqual(1, self.management.api.client.post.call_count)
     resp.status = 400
     self.assertRaises(Exception, self.management._action, 1, 'body')
     self.assertEqual(2, self.management.api.client.post.call_count)
 def test_index(self):
     resp = Mock()
     resp.status = 400
     body = {"Accounts": {}}
     self.accounts.api.client.get = Mock(return_value=(resp, body))
     self.assertRaises(Exception, self.accounts.index)
     resp.status = 200
     self.assertTrue(isinstance(self.accounts.index(), base.Resource))
     self.accounts.api.client.get = Mock(return_value=(resp, None))
     self.assertRaises(Exception, self.accounts.index)
Пример #14
0
    def test_raise_error_from_status(self):
        resp = Mock()
        resp.status = 200
        self.hc.raise_error_from_status(resp, Mock())

        status_list = [400, 401, 403, 404, 408, 409, 413, 500, 501]
        for status in status_list:
            resp.status = status
            self.assertRaises(ValueError,
                              self.hc.raise_error_from_status, resp, Mock())
Пример #15
0
 def test_delete(self):
     resp = Mock()
     resp.status = 200
     body = None
     self.security_group_rules.api = Mock()
     self.security_group_rules.api.client = Mock()
     self.security_group_rules.api.client.delete = Mock(return_value=(resp, body))
     self.security_group_rules.delete(self.id)
     resp.status = 500
     self.assertRaises(Exception, self.security_group_rules.delete, self.id)
Пример #16
0
    def test_check_for_exceptions(self):
        status = [400, 422, 500]
        for s in status:
            resp = Mock()
            resp.status = s
            self.assertRaises(Exception, common.check_for_exceptions, resp, "body")

        # a no-exception case
        resp = Mock()
        resp.status = 200
        common.check_for_exceptions(resp, "body")
Пример #17
0
 def test_wait_for_success(self):
     sms = ServiceManagementService('secret', 'cert.pem')
     request = Mock()
     request.request_id = 'foo'
     op1 = Mock()
     op1.status = 'Pending'
     op2 = Mock()
     op2.status = SUCCEEDED
     op3 = Mock()
     op3.status = 'Not Reachable'
     with patch.object(sms, 'get_operation_status', autospec=True,
                       side_effect=[op1, op2, op3]) as gs_mock:
         wait_for_success(sms, request, pause=0, verbose=False)
     self.assertEqual(2, gs_mock.call_count)
Пример #18
0
    def test_version(self):
        from pgxnclient import Spec
        from pgxnclient.commands.install import Download
        from pgxnclient.errors import ResourceNotFound

        opt = Mock()
        opt.status = Spec.STABLE
        cmd = Download(opt)

        for spec, res, data in [
            ("foo", "1.2.0", {"stable": ["1.2.0"]}),
            ("foo", "1.2.0", {"stable": ["1.2.0", "1.2.0b"]}),
            ("foo=1.2", "1.2.0", {"stable": ["1.2.0"]}),
            ("foo>=1.1", "1.2.0", {"stable": ["1.1.0", "1.2.0"]}),
            ("foo>=1.1", "1.2.0", {"stable": ["1.1.0", "1.2.0"], "testing": ["1.3.0"], "unstable": ["1.4.0"]}),
        ]:
            spec = Spec.parse(spec)
            data = {"releases": dict([(k, [{"version": v} for v in vs]) for k, vs in data.items()])}

            self.assertEqual(res, cmd.get_best_version(data, spec))

        for spec, res, data in [
            ("foo>=1.3", "1.2.0", {"stable": ["1.2.0"]}),
            ("foo>=1.3", "1.2.0", {"stable": ["1.2.0"], "testing": ["1.3.0"]}),
        ]:
            spec = Spec.parse(spec)
            data = {"releases": dict([(k, [{"version": v} for v in vs]) for k, vs in data.items()])}

            self.assertRaises(ResourceNotFound, cmd.get_best_version, data, spec)

        opt.status = Spec.TESTING

        for spec, res, data in [
            ("foo>=1.1", "1.3.0", {"stable": ["1.1.0", "1.2.0"], "testing": ["1.3.0"], "unstable": ["1.4.0"]})
        ]:
            spec = Spec.parse(spec)
            data = {"releases": dict([(k, [{"version": v} for v in vs]) for k, vs in data.items()])}

            self.assertEqual(res, cmd.get_best_version(data, spec))

        opt.status = Spec.UNSTABLE

        for spec, res, data in [
            ("foo>=1.1", "1.4.0", {"stable": ["1.1.0", "1.2.0"], "testing": ["1.3.0"], "unstable": ["1.4.0"]})
        ]:
            spec = Spec.parse(spec)
            data = {"releases": dict([(k, [{"version": v} for v in vs]) for k, vs in data.items()])}

            self.assertEqual(res, cmd.get_best_version(data, spec))
Пример #19
0
    def test_edit_save_errors(self):
        self.client.post(settings.LOGIN_URL, ADMIN_CREDENTIALS)
        data = self.edit_mgmt_data.copy()
        data.update({'title': 'foo', 'description': 'bar', 'creator': 'baz', 'file_name': 'foo.txt'})
        # simulate fedora errors with mock objects
        testobj = Mock(spec=FileObject, name='MockDigitalObject')
        # django templates recognize this as a callable; set to return itself when called
        testobj.return_value = testobj
        # create a Mock object, but use a DublinCore instance for xmlobjectform to inspect
        testobj.dc.content = DublinCore()
        testobj.pid = 'pid:1'	# required for url generation 
        # Create a RequestFailed exception to simulate Fedora error 
        # - eulcore.fedora wrap around an httplib response
        err_resp = Mock()
        err_resp.status = 500
   	err_resp.read.return_value = 'error message'
        # generate Fedora error on object save
        testobj.save.side_effect = RequestFailed(err_resp)

        # 500 error / request failed
        # patch the repository class to return the mock object instead of a real one
	#with patch.object(Repository, 'get_object', new=Mock(return_value=testobj)):
        with patch('genrepo.file.views.init_by_cmodel', new=Mock(return_value=testobj)):            
            response = self.client.post(self.edit_url, data, follow=True)
            expected, code = 500, response.status_code
            self.assertEqual(code, expected,
            	'Expected %s but returned %s for %s (Fedora 500 error)'
                % (expected, code, self.edit_url))
            messages = [ str(msg) for msg in response.context['messages'] ]
            self.assert_('error communicating with the repository' in messages[0])

        # update the mock object to generate a permission denied error
        err_resp.status = 401
        err_resp.read.return_value = 'denied'
        # generate Fedora error on object save
        testobj.save.side_effect = PermissionDenied(err_resp)
        
        # 401 error -  permission denied
	#with patch.object(Repository, 'get_object', new=Mock(return_value=testobj)):            
        with patch('genrepo.file.views.init_by_cmodel', new=Mock(return_value=testobj)):
            response = self.client.post(self.edit_url, data, follow=True)
            expected, code = 401, response.status_code
            self.assertEqual(code, expected,
            	'Expected %s but returned %s for %s (Fedora 401 error)'
                % (expected, code, self.edit_url))
            messages = [ str(msg) for msg in response.context['messages'] ]
            self.assert_("You don't have permission to modify this object"
                         in messages[0])
Пример #20
0
    def test_scenario_status_is_collected_and_reported(self, format_summary,
                                                       stdout):
        feature = Mock()
        scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
        scenarios[0].status = Status.failed
        scenarios[0].__iter__ = Mock(return_value=iter([]))
        scenarios[1].status = Status.failed
        scenarios[1].__iter__ = Mock(return_value=iter([]))
        scenarios[2].status = Status.skipped
        scenarios[2].__iter__ = Mock(return_value=iter([]))
        scenarios[3].status = Status.passed
        scenarios[3].__iter__ = Mock(return_value=iter([]))
        scenarios[4].status = Status.untested
        scenarios[4].__iter__ = Mock(return_value=iter([]))
        feature.status = Status.failed
        feature.duration = 12.3
        feature.__iter__ = Mock(return_value=iter(scenarios))

        config = Mock()
        sys.stdout.encoding = "UTF-8"
        reporter = SummaryReporter(config)

        reporter.feature(feature)
        reporter.end()

        expected = {
            Status.passed.name: 1,
            Status.failed.name: 2,
            Status.skipped.name: 1,
            Status.untested.name: 1,
        }

        eq_(format_summary.call_args_list[1][0], ('scenario', expected))
Пример #21
0
 def test_wait_for_success(self):
     sms = ServiceManagementService('secret', 'cert.pem')
     request = Mock()
     request.request_id = 'foo'
     op1 = Mock()
     op1.status = 'Pending'
     op2 = Mock()
     op2.status = SUCCEEDED
     op3 = Mock()
     op3.status = 'Not Reachable'
     with patch.object(sms,
                       'get_operation_status',
                       autospec=True,
                       side_effect=[op1, op2, op3]) as gs_mock:
         wait_for_success(sms, request, pause=0, verbose=False)
     self.assertEqual(2, gs_mock.call_count)
Пример #22
0
    def test_recover_multiple_targets(
            self, get_server_mock,
            parse_backup_id_mock,
            monkeypatch, capsys):
        backup_info = Mock()
        backup_info.status = BackupInfo.DONE
        backup_info.tablespaces = []

        parse_backup_id_mock.return_value = backup_info

        monkeypatch.setattr(barman, '__config__', build_config_from_dicts(
            main_conf={
                'archiver': 'on',
            }))

        # Testing mutual exclusiveness of target options
        args = Mock()
        args.backup_id = '20170823T104400'
        args.server_name = 'main'
        args.destination_directory = 'recovery_dir'
        args.tablespace = None
        args.target_name = None
        args.target_tli = 3
        args.target_immediate = True
        args.target_time = None
        args.target_xid = None

        with pytest.raises(SystemExit):
            recover(args)

        _, err = capsys.readouterr()
        assert 'ERROR: You cannot specify multiple targets for the recovery ' \
               'operation' in err
Пример #23
0
    def test_scenario_status_is_collected_and_reported(self, format_summary,
                                                       stdout):
        feature = Mock()
        scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
        scenarios[0].status = Status.failed
        scenarios[0].__iter__ = Mock(return_value=iter([]))
        scenarios[1].status = Status.failed
        scenarios[1].__iter__ = Mock(return_value=iter([]))
        scenarios[2].status = Status.skipped
        scenarios[2].__iter__ = Mock(return_value=iter([]))
        scenarios[3].status = Status.passed
        scenarios[3].__iter__ = Mock(return_value=iter([]))
        scenarios[4].status = Status.untested
        scenarios[4].__iter__ = Mock(return_value=iter([]))
        feature.status = Status.failed
        feature.duration = 12.3
        feature.__iter__ = Mock(return_value=iter(scenarios))

        config = Mock()
        reporter = SummaryReporter(config)

        reporter.feature(feature)
        reporter.end()

        expected = {
            Status.passed.name: 1,
            Status.failed.name: 2,
            Status.skipped.name: 1,
            Status.untested.name: 1,
        }

        eq_(format_summary.call_args_list[1][0], ('scenario', expected))
Пример #24
0
    def test_recover_default_target(self, get_server_mock,
                                    parse_backup_id_mock, monkeypatch,
                                    capsys):
        backup_info = Mock()
        backup_info.status = BackupInfo.DONE
        backup_info.tablespaces = []

        parse_backup_id_mock.return_value = backup_info

        monkeypatch.setattr(barman, '__config__', build_config_from_dicts(
            main_conf={
                'archiver': 'on',
            }))

        # This parameters are fine
        args = Mock()
        args.backup_id = '20170823T104400'
        args.server_name = 'main'
        args.destination_directory = 'recovery_dir'
        args.tablespace = None
        args.target_name = None
        args.target_tli = None
        args.target_immediate = None
        args.target_time = None
        args.target_xid = None
        args.target_action = None

        _, err = capsys.readouterr()
        with pytest.raises(SystemExit):
            recover(args)
        assert "" == err
Пример #25
0
def test_vqe_run():
    """VQE initialized and then minimizer is called to return result. Checks
    correct sequence of execution"""
    def param_prog(alpha):
        return Program([H(0), RZ(alpha)(0)])

    hamiltonian = np.array([[1, 0], [0, -1]])
    initial_param = 0.0

    minimizer = MagicMock(spec=minimize, func_code=minimize.__code__)
    fake_result = Mock()
    fake_result.fun = 1.0
    fake_result.x = [0.0]
    fake_result.status = 0  # adding so we avoid writing to logger
    minimizer.return_value = fake_result

    # not actually called in VQE run since we are overriding minmizer to just
    # return a value. Still need this so I don't try to call the QVM server.
    fake_qvm = Mock(spec=['wavefunction'])

    with patch("funcsigs.signature") as patch_signature:
        patch_signature.return_value = {}, None, None, None
        inst = VQE(minimizer)

        t_result = inst.vqe_run(param_prog,
                                hamiltonian,
                                initial_param,
                                qvm=fake_qvm)
        assert np.isclose(t_result.fun, 1.0)
Пример #26
0
    def test_service_say(self):
        """Test service call say."""
        calls = mock_service(self.hass, DOMAIN_MP, SERVICE_PLAY_MEDIA)

        conn = Mock()
        response = Mock()
        conn.getresponse.return_value = response
        response.status = 200
        response.read.return_value = b"audio"

        config = {tts.DOMAIN: {"platform": "marytts"}}

        with assert_setup_component(1, tts.DOMAIN):
            setup_component(self.hass, tts.DOMAIN, config)

        with patch("http.client.HTTPConnection", return_value=conn):
            self.hass.services.call(
                tts.DOMAIN,
                "marytts_say",
                {
                    "entity_id": "media_player.something",
                    tts.ATTR_MESSAGE: "HomeAssistant",
                },
            )
        self.hass.block_till_done()

        assert len(calls) == 1
        assert calls[0].data[ATTR_MEDIA_CONTENT_ID].find(".wav") != -1
        conn.request.assert_called_with("POST", "/process",
                                        urlencode(self.params))
Пример #27
0
 def _dummy_urlopen(*args, **kwargs):
     dummy_response = Mock()
     dummy_response.headers = HTTPHeaderDict({})
     dummy_response.status = 200
     dummy_response.data = response_body
     _dummy_urlopen.call_args = (args, kwargs)
     return dummy_response
    def test_handle_wi(self):
        wid = Mock()
        wid.fields.project = "Test"
        wid.params.delete = False
        # Test: has attribute -> True
        # This means we don't need to schedule a nightly build
        self.participant.obs.projectAttributeExists.return_value = True
        self.participant.handle_wi(wid)
        self.assertFalse(wid.fields.needs_build)

        # Test: has attribute -> False
        # This means we schedule the nightly build
        self.participant.obs.projectAttributeExists.return_value = False
        self.participant.handle_wi(wid)
        self.assertTrue(wid.fields.needs_build)

        # Test: Project attribute deleted -> True
        # If so, return True
        wid.params.delete = True
        wid.status = False
        self.participant.obs.deleteProjectAttribute.return_value = True
        self.participant.handle_wi(wid)
        self.assertTrue(wid.status)

        # Test: Project attribute deleted -> False
        # If so, return False
        self.participant.obs.deleteProjectAttribute.return_value = False
        self.participant.handle_wi(wid)
        self.assertFalse(wid.status)
Пример #29
0
    def test_scenario_status_is_collected_and_reported(self, format_summary,
                                                       stdout):
        feature = Mock()
        scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
        scenarios[0].status = 'failed'
        scenarios[0].__iter__ = Mock(return_value=iter([]))
        scenarios[1].status = 'failed'
        scenarios[1].__iter__ = Mock(return_value=iter([]))
        scenarios[2].status = 'skipped'
        scenarios[2].__iter__ = Mock(return_value=iter([]))
        scenarios[3].status = 'passed'
        scenarios[3].__iter__ = Mock(return_value=iter([]))
        scenarios[4].status = None
        scenarios[4].__iter__ = Mock(return_value=iter([]))
        feature.status = 'failed'
        feature.duration = 12.3
        feature.__iter__ = Mock(return_value=iter(scenarios))

        config = Mock()
        config.order = ('defined', None)
        reporter = SummaryReporter(config)

        reporter.feature(feature)
        reporter.end()

        expected = {
            'passed': 1,
            'failed': 2,
            'skipped': 2,
            'untested': 0,
        }

        eq_(format_summary.call_args_list[1][0], ('scenario', expected))
Пример #30
0
    def test_inspect_not_found_ok(self):
        context = ExecutionContext()
        response = Mock()
        response.status = 404
        response.reason = 'Not Found'
        default_variables = {'project': 'PROJECT'}
        service = MyFakeGcpService([HttpError(response, 'Not Found')])
        agent = TestGcpAgent.make_test_agent(
            service=service, default_variables=default_variables)

        contract_builder = gt.GcpContractBuilder(agent)

        c1 = contract_builder.new_clause_builder('TITLE')
        verifier = c1.inspect_resource('regions',
                                       resource_id='us-central1-f',
                                       no_resource_ok=True)
        verifier.contains_path_value('field', 'value')
        self.assertTrue(
            isinstance(verifier, jc.ValueObservationVerifierBuilder))

        contract = contract_builder.build()
        verification_result = contract.verify(context)
        self.assertTrue(
            verification_result,
            JsonSnapshotHelper.ValueToEncodedJson(verification_result))
        self.assertEquals({
            'project': 'PROJECT',
            'region': 'us-central1-f'
        }, agent.service.last_get_args)
Пример #31
0
    def prep_issue_request(self):
        mysock = Mock()
        mysock.gettimeout.return_value = 4242

        myresponse = Mock()
        myresponse.read.return_value = 'body'
        myresponse.getheaders.return_value = 'headers'
        myresponse.status = httplib.MOVED_PERMANENTLY

        myconn = Mock()
        myconn.request.return_value = None
        myconn.sock = mysock
        myconn.getresponse.return_value = myresponse
        myconn.__str__ = Mock()
        myconn.__str__.return_value = 'myconn string'

        req = self.req
        req._request_timeout = REQUEST_TIMEOUT = 1
        req._redirect_params = Mock()
        req._redirect_params.return_value = (myconn, 'url')
        req._request_str = Mock()
        req._request_str.return_value = 'http://cool/cool'

        client = self.client
        client.need_login = False
        client._auto_login = False
        client._auth_cookie = False
        client.acquire_connection = Mock()
        client.acquire_connection.return_value = myconn
        client.release_connection = Mock()

        return (mysock, myresponse, myconn)
Пример #32
0
    def test_download_object_as_stream_data_is_not_buffered_in_memory(self):
        # Test case which verifies that response.response attribute is not accessed
        # and as such, whole body response is not buffered into RAM

        # If content is consumed and response.content attribute accessed exception
        # will be thrown and test will fail
        mock_response = Mock(name='mock response')
        mock_response.headers = {}
        mock_response.status = 200

        msg1 = '"response" attribute was accessed but it shouldn\'t have been'
        msg2 = '"content" attribute was accessed but it shouldn\'t have been'
        type(mock_response).response = PropertyMock(name='mock response attribute',
                                                    side_effect=Exception(msg1))
        type(mock_response).content = PropertyMock(name='mock content attribute',
                                                   side_effect=Exception(msg2))
        mock_response.iter_content.return_value = StringIO('a' * 1000)

        self.driver.connection.request = Mock()
        self.driver.connection.request.return_value = mock_response

        container = Container(name='foo_bar_container', extra={},
                              driver=self.driver)
        obj = Object(name='foo_bar_object_NO_BUFFER', size=1000, hash=None, extra={},
                     container=container, meta_data=None,
                     driver=self.driver_type)
        result = self.driver.download_object_as_stream(obj=obj)
        result = exhaust_iterator(result)

        if PY3:
            result = result.decode('utf-8')

        self.assertEqual(result, 'a' * 1000)
Пример #33
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)
Пример #34
0
    def test_do_http_with_bad_status_line(self, mock_get_connection):

        mock_conn = mock_get_connection.return_value = Mock()

        # First attempt: Error, second attempt: successful response
        mock_response = Mock()
        mock_conn.getresponse.side_effect = [BadStatusLine(0), mock_response]

        # Stops at the fourth read call
        mock_response.read.return_value = b"response data"
        mock_response.status = 200

        with patch('time.sleep'):
            resp, body = self.connection.do_http('POST', '/rest/test', 'body')

        self.assertEqual(body, 'response data')

        mock_conn.request.assert_called_with(
            'POST', '/rest/test', 'body', {
                'Content-Type': 'application/json',
                'X-API-Version': 300,
                'Accept': 'application/json'
            })

        mock_conn.close.assert_has_calls([call(), call()])
Пример #35
0
    def test_scenario_status_is_collected_and_reported(self, format_summary,
                                                       stderr):
        feature = Mock()
        scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
        scenarios[0].status = 'failed'
        scenarios[0].__iter__ = Mock(return_value=iter([]))
        scenarios[1].status = 'failed'
        scenarios[1].__iter__ = Mock(return_value=iter([]))
        scenarios[2].status = 'skipped'
        scenarios[2].__iter__ = Mock(return_value=iter([]))
        scenarios[3].status = 'passed'
        scenarios[3].__iter__ = Mock(return_value=iter([]))
        scenarios[4].status = None
        scenarios[4].__iter__ = Mock(return_value=iter([]))
        feature.status = 'failed'
        feature.duration = 12.3
        feature.__iter__ = Mock(return_value=iter(scenarios))

        config = Mock()
        reporter = SummaryReporter(config)

        reporter.feature(feature)
        reporter.end()

        expected = {
            'passed': 1,
            'failed': 2,
            'skipped': 2,
            'untested': 0,
        }

        eq_(format_summary.call_args_list[1][0], ('scenario', expected))
Пример #36
0
 def get_backup_file(self):
     file = Mock()
     file.platform_id = amo.PLATFORM_ALL.id
     file.latest_xpi_url.return_value = 'xpi.backup'
     file.get_url_path.return_value = 'xpi.backup.url'
     file.status = amo.STATUS_PUBLIC
     return file
    def test_process_scenario(
        self, mock_load_test_cases, mocked_post, add_test_result_mock
    ):
        """Test to ensure the data that we send to add_test_result is correct."""
        testrail_reporter = TestrailReporter(u"master")
        testrail_reporter.projects[0].cases = ["1104"]

        step_01 = Mock(status=u"passed", keyword=u"given")
        step_01.name = u"step_01 £"
        steps = [step_01]

        mock_feature = Mock(Feature)
        mock_feature.tags = []

        mock_scenario = Mock(Scenario)
        mock_scenario.tags = [u"testrail-C1104"]
        mock_scenario.name = u"Dummy scenario"
        mock_scenario.steps = steps
        mock_scenario.feature = mock_feature
        mock_scenario.status = Status.passed

        add_test_result_mock.return_value = {}
        mocked_post.return_value = Mock(ok=True)
        comment = testrail_reporter._buid_comment_for_scenario(mock_scenario)

        testrail_reporter.process_scenario(mock_scenario)

        add_test_result_mock.assert_called_with(
            project=testrail_reporter.projects[0],
            case_id=u"1104",
            status=1,
            comment=comment,
            elapsed_seconds=mock_scenario.duration,
        )
Пример #38
0
 def testDataExtractorMustReturnAListContainingTheDataToBeExported(self):
     objects = Mock()
     delivery_mock = Mock()
     delivery_mock.practice.uid = "1"
     filter_return_value = Mock()
     filter_return_value.status = 1
     objects.filter.return_value = filter_return_value
     delivery_mock.get_automatic_correction.return_value = filter_return_value
     filter_return_value.order_by.return_value = [delivery_mock,]
     
     practices = Mock()
     practice_mock = Mock()
     practice_mock.uid = "2"
     practices.all.return_value = [practice_mock,]
     
     students = Mock()
     student_all_return_value = Mock()
     student_mock = Mock()
     student_all_return_value.order_by.return_value = [student_mock,]
     students.all.return_value = student_all_return_value
     
     db_deliveries_extractor = DbDeliveriesExtractor()
     db_deliveries_extractor.objects = objects
     db_deliveries_extractor.students = students
     db_deliveries_extractor.practices = practices
     
     
     result_value = db_deliveries_extractor.get_data()
     
     first_expected = (delivery_mock.practice.uid, delivery_mock.student.uid, delivery_mock.student.user.first_name, delivery_mock.student.user.last_name, 
                       "aprobado", delivery_mock.get_correction.return_value.grade)
     second_expected = (practice_mock.uid, student_mock.uid, student_mock.user.first_name, student_mock.user.last_name, 
                       "pendiente", None)
     expected_value = [first_expected, second_expected,]
     self.assertEquals(result_value, expected_value)
Пример #39
0
 def get_backup_file(self):
     file = Mock()
     file.platform = amo.PLATFORM_ALL.id
     file.latest_xpi_url.return_value = 'xpi.backup'
     file.get_url_path.return_value = 'xpi.backup.url'
     file.status = amo.STATUS_PUBLIC
     return file
Пример #40
0
    def test_redundancy_report(self):
        """
        Basic unit test of RedundancyRetentionPolicy

        Given a mock simulating a Backup with status DONE,
        the report method of the RedundancyRetentionPolicy class must mark
        it as valid
        """
        rp = self.build_redundancy_retention()
        assert isinstance(rp, RedundancyRetentionPolicy)

        # use a Mock class as BackupInfo with status to DONE
        backup_info = Mock(name='backup_info')
        backup_info.status = BackupInfo.DONE

        # instruct the get_available_backups method to return a map with
        # our mock as result and minimum_redundancy = 1
        rp.server.get_available_backups.return_value = {
            "test_backup": backup_info
        }
        rp.server.config.minimum_redundancy = 1
        # execute retention policy report
        report = rp.report()
        # check that our mock is valid for the retention policy because
        # the total number of valid backups is lower than the retention policy
        # redundancy.
        assert report == {'test_backup': BackupInfo.VALID}
Пример #41
0
    def test_recovery_window_report(self):
        """
        Basic unit test of RecoveryWindowRetentionPolicy

        Given a mock simulating a Backup with status DONE and
        the end_date not over the point of recoverability,
        the report method of the RecoveryWindowRetentionPolicy class must mark
        it as valid
        """
        rp = self.build_recovery_window_retention()
        assert isinstance(rp, RecoveryWindowRetentionPolicy)

        # use a Mock class as BackupInfo with status to DONE and end_time = now
        backup_info = Mock(name='backup_info')
        backup_info.status = BackupInfo.DONE
        backup_info.end_time = datetime.now(tzlocal())

        # instruct the get_available_backups method to return a map with
        # our mock as result and minimum_redundancy = 1
        rp.server.get_available_backups.return_value = {
            "test_backup": backup_info
        }
        rp.server.config.minimum_redundancy = 1
        # execute retention policy report
        report = rp.report()
        # check that our mock is valid for the retention policy
        assert report == {'test_backup': BackupInfo.VALID}
Пример #42
0
    def prep_issue_request(self):
        mysock = Mock()
        mysock.gettimeout.return_value = 4242

        myresponse = Mock()
        myresponse.read.return_value = 'body'
        myresponse.getheaders.return_value = 'headers'
        myresponse.status = httplib.MOVED_PERMANENTLY

        myconn = Mock()
        myconn.request.return_value = None
        myconn.sock = mysock
        myconn.getresponse.return_value = myresponse
        myconn.__str__ = Mock()
        myconn.__str__.return_value = 'myconn string'

        req = self.req
        req._redirect_params = Mock()
        req._redirect_params.return_value = (myconn, 'url')
        req._request_str = Mock()
        req._request_str.return_value = 'http://cool/cool'

        client = self.client
        client.need_login = False
        client._auto_login = False
        client._auth_cookie = False
        client.acquire_connection = Mock()
        client.acquire_connection.return_value = myconn
        client.release_connection = Mock()

        return (mysock, myresponse, myconn)
Пример #43
0
 def test_login(self):
     resp = self.client.post(reverse(views.login),
                             dict(openid='http://me.yahoo.com'))
     assert 'login.yahooapis' in resp['location']
     with patch('allauth.socialaccount.providers'
                '.openid.views._openid_consumer') as consumer_mock:
         client = Mock()
         complete = Mock()
         consumer_mock.return_value = client
         client.complete = complete
         complete_response = Mock()
         complete.return_value = complete_response
         complete_response.status = consumer.SUCCESS
         complete_response.identity_url = 'http://dummy/john/'
         with patch('allauth.socialaccount.providers'
                    '.openid.utils.SRegResponse') as sr_mock:
             with patch('allauth.socialaccount.providers'
                        '.openid.utils.FetchResponse') as fr_mock:
                 sreg_mock = Mock()
                 ax_mock = Mock()
                 sr_mock.fromSuccessResponse = sreg_mock
                 fr_mock.fromSuccessResponse = ax_mock
                 sreg_mock.return_value = {}
                 ax_mock.return_value = {AXAttribute.PERSON_FIRST_NAME:
                                         ['raymond']}
                 resp = self.client.post(reverse('openid_callback'))
                 self.assertEqual('http://testserver/accounts/profile/',
                                  resp['location'])
                 get_user_model().objects.get(first_name='raymond')
Пример #44
0
  def test_inspect_not_found_ok(self):
    context = ExecutionContext()
    response = Mock()
    response.status = 404
    response.reason = 'Not Found'
    default_variables = {'project': 'PROJECT'}
    service = MyFakeGcpService([HttpError(response, 'Not Found')])
    agent = TestGcpAgent.make_test_agent(
        service=service, default_variables=default_variables)


    contract_builder = gt.GcpContractBuilder(agent)

    c1 = contract_builder.new_clause_builder('TITLE')
    verifier = c1.inspect_resource(
        'regions', resource_id='us-central1-f', no_resource_ok=True)
    verifier.contains_path_value('field', 'value')
    self.assertTrue(isinstance(verifier, jc.ValueObservationVerifierBuilder))

    contract = contract_builder.build()
    verification_result = contract.verify(context)
    self.assertTrue(verification_result,
                    JsonSnapshotHelper.ValueToEncodedJson(verification_result))
    self.assertEquals({'project': 'PROJECT', 'region': 'us-central1-f'},
                      agent.service.last_get_args)
Пример #45
0
    def test_should_maintain_count_of_tests_that_had_errors(self):
        suite = XunitSuite("errorsuite")
        test1 = Mock(XunitTest)
        test1.passed = False
        test1.status = "error"
        assert_that(suite.error_count, is_(0))
        
        suite.append(test1)
        assert_that(suite.error_count, is_(1))
        
        test2 = Mock(XunitTest)
        test2.passed = False
        test2.status = "failed"
 
        suite.append(test2)
        assert_that(suite.error_count, is_(1))
    def test_process_scenario_prevents_unnecessary_processing(
            self, mock_load_test_cases):
        """
        Ensure that when processing a scenario we exit as soon as possible
        if the current branch being tested is not whitelisted in the project config.
        This is to prevent load Testrail endpoints with unnecessary requests.
        """
        testrail_reporter = TestrailReporter(u"my-dev-feature-branch")
        testrail_reporter.projects[0].cases = ["1104"]
        # Restrict the 2 Testrail project to allow only Test runs from master branch.
        testrail_reporter.projects[0].allowed_branch_pattern = u"master"
        testrail_reporter.projects[1].allowed_branch_pattern = u"master"

        step_01 = Mock(status=u"passed", keyword=u"given")
        step_01.name = u"step_01 £"
        steps = [step_01]

        mock_feature = Mock(Feature)
        mock_feature.tags = []

        mock_scenario = Mock(Scenario)
        mock_scenario.tags = [u"testrail-C1104"]
        mock_scenario.name = u"Dummy scenario"
        mock_scenario.steps = steps
        mock_scenario.feature = mock_feature
        mock_scenario.status = Status.passed

        testrail_reporter.process_scenario(mock_scenario)
        mock_load_test_cases.assert_not_called()
Пример #47
0
 def get_file(self, platform):
     file = Mock()
     file.platform_id = platform.id
     file.latest_xpi_url.return_value = 'xpi.latest'
     file.get_url_path.return_value = 'xpi.url'
     file.eula_url.return_value = 'eula.url'
     file.status = amo.STATUS_PUBLIC
     return file
Пример #48
0
 def mock_args(self):
     args = Mock()
     args.sever_name = "test_server"
     args.backup_id = "test_backup_id"
     args.release = None
     args.status = None
     args.target = None
     yield args
Пример #49
0
 def create_response(self, status_code, reason='', body=None):
     if body is None:
         body = self.default_body()
     response = Mock(spec=httplib.HTTPResponse)
     response.status = status_code
     response.read.return_value = body
     response.reason = reason
     return response
Пример #50
0
    def test__authenticate(self):
        authObj = auth.Authenticator(Mock(), auth.KeyStoneV2Authenticator,
                                     Mock(), Mock(), Mock(), Mock())
        # test response code 200
        resp = Mock()
        resp.status = 200
        body = "test_body"

        auth.ServiceCatalog._load = Mock(return_value=1)
        authObj.client._time_request = Mock(return_value=(resp, body))

        sc = authObj._authenticate(Mock(), Mock())
        self.assertEqual(body, sc.catalog)

        # test AmbiguousEndpoints exception
        auth.ServiceCatalog.__init__ = \
            Mock(side_effect=exceptions.AmbiguousEndpoints)
        self.assertRaises(exceptions.AmbiguousEndpoints, authObj._authenticate,
                          Mock(), Mock())

        # test handling KeyError and raising AuthorizationFailure exception
        auth.ServiceCatalog.__init__ = Mock(side_effect=KeyError)
        self.assertRaises(exceptions.AuthorizationFailure,
                          authObj._authenticate, Mock(), Mock())

        # test EndpointNotFound exception
        mock = Mock(side_effect=exceptions.EndpointNotFound)
        auth.ServiceCatalog.__init__ = mock
        self.assertRaises(exceptions.EndpointNotFound, authObj._authenticate,
                          Mock(), Mock())
        mock.side_effect = None

        # test response code 305
        resp.__getitem__ = Mock(return_value='loc')
        resp.status = 305
        body = "test_body"
        authObj.client._time_request = Mock(return_value=(resp, body))

        l = authObj._authenticate(Mock(), Mock())
        self.assertEqual('loc', l)

        # test any response code other than 200 and 305
        resp.status = 404
        exceptions.from_response = Mock(side_effect=ValueError)
        self.assertRaises(ValueError, authObj._authenticate, Mock(), Mock())
    def test_raise_error_with_no_data(self):
        response = Mock()
        response.status = 400
        response.reason = 'Bad Request'
        response.getheader = Mock(return_value='')
        response.read = Mock(return_value='')

        con = Urllib3HttpConnection()
        self.assertRaises(BadRequestError, con._raise_error, response)
Пример #52
0
    def test__action(self):
        body = Mock()
        resp = Mock()
        resp.status = 200
        self.instances.api.client.post = Mock(return_value=(resp, body))
        self.assertEqual('instance-1', self.instances._action(1, body))

        self.instances.api.client.post = Mock(return_value=(resp, None))
        self.assertEqual(None, self.instances._action(1, body))
Пример #53
0
def game():
    from hangman.model import Hangman

    mock_game = Mock(spec=Hangman)
    mock_game.misses = []
    mock_game.status = '_______'
    mock_game.answer = 'HANGMAN'
    mock_game.remaining_turns = 10
    return mock_game
Пример #54
0
 def test_fileAdded(self):
     from niprov.commandline import Commandline
     self.dependencies.config.verbosity = 'info'
     cmd = Commandline(self.dependencies)
     cmd.log = Mock()
     img = Mock()
     img.path = 'xyz'
     img.status = 'new'
     cmd.fileAdded(img)
     cmd.log.assert_called_with('info', 'New file: xyz')
     img.status = 'series-new-file'
     img.provenance = {'filesInSeries': [1, 2, 3]}
     img.getSeriesId.return_value = 'series987'
     cmd.fileAdded(img)
     cmd.log.assert_called_with('info',
                                'Added 3rd file to series: series987')
     img.status = 'new-version'
     cmd.fileAdded(img)
     cmd.log.assert_called_with('info', 'Added new version for: xyz')
 def _dummy_send(*args, **kwargs):
     dummy_response = Mock()
     dummy_response.headers = {}
     dummy_response.getheaders = Mock(return_value={})
     dummy_response.status = status_code
     dummy_response.read = Mock(return_value=response_body)
     dummy_response.request = args[0]
     dummy_response.cookies = {}
     _dummy_send.call_args = (args, kwargs)
     return dummy_response
Пример #56
0
 def get_file(self, platform):
     file = Mock()
     file.platform_id = platform.id
     file.latest_xpi_url.return_value = 'xpi.latest'
     file.get_url_path.return_value = 'xpi.url'
     file.eula_url.return_value = 'eula.url'
     file.status = amo.STATUS_PUBLIC
     file.strict_compatibility = False
     file.binary_components = False
     return file
Пример #57
0
def boto_status():
    status_mock = Mock()
    status_mock.get_status.side_effect = ['PENDING', 'INSYNC']

    def update():
        status_mock.status = status_mock.get_status()

    status_mock.update.side_effect = update
    status_mock.status = 'PENDING'
    return status_mock
Пример #58
0
def test_change_engine_listener_execution_context(listener):
    test1 = Mock()
    test1.full_name = "pytest.test_suite.test_a1"
    test1.status = "PASS"
    body = listener._format_body([test1])
    assert len(body) == 4, "tests, changes and context must be present"
    assert body["changes"] == ['path/to/changes']
    assert body["tests"]
    assert body["context"] == "PR"
    assert body["execution_id"] == "job-name-here"
Пример #59
0
 def create_mock_task(cls, task_id, instance_id, initial_time, status):
     mock_task = Mock(spec=ScheduledTask)
     mock_task.assignedTask = Mock(spec=AssignedTask)
     mock_task.assignedTask.taskId = task_id
     mock_task.assignedTask.instanceId = instance_id
     mock_task.status = status
     mock_task_event = Mock(spec=TaskEvent)
     mock_task_event.timestamp = initial_time
     mock_task.taskEvents = [mock_task_event]
     return mock_task
def test_change_engine_listener_execution_context(listener):
    test1 = Mock()
    test1.full_name = "pytest.test_suite.test_a1"
    test1.status = "PASS"
    body = listener._format_body([test1], "path/tp/changes")
    context = body["context"]
    assert len(body) == 3, "tests, changes and context must be present"
    assert body["changes"]
    assert body["tests"]
    assert context == "PR"