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))
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
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
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
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)
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)
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
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
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')
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)
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())
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)
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")
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)
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))
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])
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))
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
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))
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
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)
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))
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)
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))
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)
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)
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)
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)
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()])
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))
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, )
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)
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
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}
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}
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)
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')
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)
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()
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
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
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
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)
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))
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
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
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
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
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"
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"