def test_user_removing(self): mocked_repo = MagicMock() mocked_repository = MagicMock() mocked_user = MagicMock() mock_single_user = MagicMock() mock_single_user.name = 'another_user' mock_single_user.__str__ = lambda x: 'another_user' mocked_repository.name = 'test_repo' mocked_repository.path = 'path' mocked_user.get.return_value = mock_single_user mocked_repo.users = ['user'] with patch.multiple('models.lists.users', Repo=MagicMock(return_value=mocked_repo), User=mocked_user): repo_users = ListUsers(mocked_repository) repo_users.remove('test') pattern = r'(\s*)([RW+DC]*)(\s*)=(\s*)%s' % 'another_user' mocked_repo.replace.assert_called_once_with(pattern, "") message = "Deleted user another_user from repository test_repo" mocked_repository.git.commit.has_calls([call(['conf'], message)])
def test_Downloader_extract(tarfile): downloader = Downloader("http://example.com") downloader.tarFile = "/tmp/test.tar" downloader.workDir = "/tmp" tar = MagicMock() tarfile.open.return_value = tar badfile = MagicMock() badfile.name = ".." tar.__iter__.return_value = [badfile] # Exception: Archive contains a forbidden path: .. assert_raises(Exception, downloader.extract) badfile.name = "/bin/bash" tar.__iter__.return_value = [badfile] # Exception: Archive contains an absolute path: /bin/bash assert_raises(Exception, downloader.extract) srcdir = MagicMock() srcdir.name = "project-0123456789abcdef" tar.__iter__.return_value = [srcdir] # Exception: Repository does not contain a Dockerfile assert_raises(Exception, downloader.extract) dockerfile = MagicMock() dockerfile.name = "project-0123456789abcdef/Dockerfile" tar.__iter__.return_value = [srcdir, dockerfile] rundir = downloader.extract() assert rundir == "/tmp/project-0123456789abcdef"
def create_mock_list_with_name_attribute(): member1 = MagicMock(id=1) member2 = MagicMock(id=2) member1.name = 'testerino' member2.name = 'anotherone' content = MagicMock(content=[member1, member2]) return content
def test_4_cycle_throws_circ_dependencies_error(self): """ Ensures o - o | | o - o throws circular dependency error """ stack1 = MagicMock(Spec=Stack) stack2 = MagicMock(Spec=Stack) stack3 = MagicMock(Spec=Stack) stack4 = MagicMock(Spec=Stack) stack1.dependencies = ["stack4"] stack1.name = "stack1" stack2.dependencies = ["stack1"] stack2.name = "stack2" stack3.dependencies = ["stack2"] stack3.name = "stack3" stack4.dependencies = ["stack3"] stack4.name = "stack4" stacks = { "stack1": stack1, "stack2": stack2, "stack3": stack3, "stack4": stack4 } self.environment.stacks = stacks with pytest.raises(CircularDependenciesError) as ex: self.environment._check_for_circular_dependencies() assert all(x in str(ex) for x in ['stack4', 'stack3', 'stack2', 'stack1'])
def test_user_edit_permissions(self): mocked_repo = MagicMock() mocked_repository = MagicMock() mocked_user = MagicMock() mock_single_user = MagicMock() mock_single_user.name = 'another_user' mock_single_user.__str__ = lambda x: 'another_user' mocked_repository.name = 'test_repo' mocked_repository.path = 'path' mocked_user.get.return_value = mock_single_user mocked_repo.users = ['user'] with patch.multiple('models.lists.users', Repo=MagicMock(return_value=mocked_repo), User=mocked_user): repo_users = ListUsers(mocked_repository) repo_users.edit('test', 'R') pattern = r'(\s*)([RW+DC]*)(\s*)=(\s*)%s' % 'another_user' string = r"\n %s = %s" % ('R', 'another_user') mocked_repo.replace.assert_called_once_with(pattern, string) message = "User another_user has R permission for repository test_repo" mocked_repository.git.commit.has_calls([call(['conf'], message)])
def test_add_tasks_po_from_filextension(self, find_mock, po_mock): """Test add_tasks po without specifying file extension works.""" project = MagicMock() project.name = 'name' project.short_name = 'short_name' project.description = 'description' project.info = dict() find_mock.return_value = project entry = MagicMock() entry.msgid = 'English' entry.msgtr = '' po = MagicMock() po.untranslated_entries.return_value = [entry] po_mock.return_value = po tasks = MagicMock() tasks.name = 'tasks.po' tasks.read.return_value = json.dumps([{'info': {'msgid': 'English', 'msgtr':''}}]) pbclient = MagicMock() pbclient.create_task.return_value = {'id': 1, 'info': {'msgid': 'English', 'msgtr': ''}} self.config.pbclient = pbclient res = _add_tasks(self.config, tasks, None, 0, 30) assert res == '1 tasks added to project: short_name', res
def test_DAG_diamond_with_triangle_throws_no_circ_dependencies_error(self): """ Ensures o / \ o o \ / \ o ->o throws no circular dependency error """ stack1 = MagicMock(Spec=Stack) stack2 = MagicMock(Spec=Stack) stack3 = MagicMock(Spec=Stack) stack4 = MagicMock(Spec=Stack) stack5 = MagicMock(Spec=Stack) stack1.dependencies = ["stack2", "stack3"] stack1.name = "stack1" stack2.dependencies = ["stack4"] stack2.name = "stack2" stack3.dependencies = ["stack4", "stack5"] stack3.name = "stack3" stack4.dependencies = ["stack5"] stack4.name = "stack4" stack5.dependencies = [] stack5.name = "stack5" stacks = { "stack1": stack1, "stack2": stack2, "stack3": stack3, "stack4": stack4, "stack5": stack5 } self.environment.stacks = stacks self.environment._check_for_circular_dependencies()
def test_users_set(self): mocked_repo = MagicMock() mocked_repository = MagicMock(config="") mocked_repository.get_config.return_value = "" mocked_user = MagicMock() mock_single_user = MagicMock() mock_single_user.name = 'user' mocked_repository.name = 'test_repo' mocked_repository.path = 'path' mocked_user.get.return_value = mock_single_user with patch.multiple('pyolite.models.lists.users', Repo=MagicMock(return_value=mocked_repo), User=mocked_user): repo_users = ListUsers(mocked_repository) repo_users.set((('mocked', 'R'), ('mocked', 'RW+'))) serialized_users = "repo test_repo\n R = user\n" \ " RW+ = user\n" mocked_repo.overwrite.assert_called_once_with(serialized_users) message = "Initialized repository test_repo with users: test, user" mocked_repository.git.commit.has_calls([call(['conf'], message)])
def test___eq__(self, mock_name, mock_callables, mock_priority): """Test the equality operator.""" callables = [MagicMock(), MagicMock(), MagicMock()] mock_callables.return_value = callables mock_name.return_value = "name1" mock_priority.return_value = 3 item1 = ht.events.item.HoudiniEventItem(None, None, None, None) item2 = MagicMock(spec=ht.events.item.HoudiniEventItem) item2.callables = [] item2.name = "name2" item2.priority = 4 # Names differ self.assertFalse(item1.__eq__(item2)) mock_name.return_value = "name" item2.name = "name" # Names the same, callables differ self.assertFalse(item1.__eq__(item2)) item2.callables = callables # Names and callables equal, priority differs self.assertFalse(item1.__eq__(item2)) item2.priority = 3 # Should be equal now self.assertEqual(item1, item2)
def test_multiple_notifies_single_change(self): block_1 = MagicMock( to_dict=MagicMock(return_value={"attr": "initial_value"})) block_1.name = "block_1" block_2 = MagicMock( to_dict=MagicMock(return_value={"attr2": "initial_value"})) block_2.name = "block_2" sub_1 = MagicMock() sub_1.endpoint = ["block_1"] sub_1.delta = False sub_2 = MagicMock() sub_2.endpoint = ["block_1"] sub_2.delta = True sub_3 = MagicMock() sub_3.endpoint = ["block_2"] sub_3.delta = False sub_4 = MagicMock() sub_4.endpoint = ["block_2"] sub_4.delta = True change_1 = [["block_1", "attr"], "final_value"] change_2 = [["block_2", "attr2"], "final_value"] request_1 = BlockNotify("block_1") request_2 = BlockChanged(change_1) request_3 = BlockChanged(change_2) request_4 = BlockNotify("block_1") request_5 = BlockNotify("block_1") request_6 = BlockNotify("block_2") p = Process("proc", MagicMock()) p.q.get = MagicMock(side_effect=[request_1, request_2, request_3, request_4, request_5, request_6, PROCESS_STOP]) p.q.put = MagicMock(side_effect=p.q.put) p._subscriptions["block_1"] = [sub_1, sub_2] p._subscriptions["block_2"] = [sub_3, sub_4] p._handle_block_add(BlockAdd(block_1)) p._handle_block_add(BlockAdd(block_2)) p.recv_loop() call_list = sub_1.response_queue.put.call_args_list self.assertEquals(1, len(call_list)) self.assertIsInstance(call_list[0][0][0], Update) self.assertEquals({"attr": "final_value"}, call_list[0][0][0].value) call_list = sub_2.response_queue.put.call_args_list self.assertEquals(1, len(call_list)) self.assertIsInstance(call_list[0][0][0], Delta) self.assertEquals([[["attr"], "final_value"]], call_list[0][0][0].changes) call_list = sub_3.response_queue.put.call_args_list self.assertEquals(1, len(call_list)) self.assertIsInstance(call_list[0][0][0], Update) self.assertEquals({"attr2": "final_value"}, call_list[0][0][0].value) call_list = sub_4.response_queue.put.call_args_list self.assertEquals(1, len(call_list)) self.assertIsInstance(call_list[0][0][0], Delta) self.assertEquals([[["attr2"], "final_value"]], call_list[0][0][0].changes)
def test_create_user_case_sensitivity(self, KeystoneManager): """ Test case sensitivity of check for existence in the user creation process """ mock_keystone = MagicMock() KeystoneManager.return_value = mock_keystone mock_user = MagicMock() mock_keystone.resolve_user_id.return_value = mock_user mock_keystone.api.users.list.return_value = [mock_user] # User found is the same i.e. userA == userA mock_user.name = 'userA' utils.create_user('userA', 'passA') mock_keystone.resolve_user_id.assert_called_with('userA', user_domain=None) mock_keystone.create_user.assert_not_called() # User found has different case but is the same # i.e. Usera != userA mock_user.name = 'Usera' utils.create_user('userA', 'passA') mock_keystone.resolve_user_id.assert_called_with('userA', user_domain=None) mock_keystone.create_user.assert_not_called() # User is different i.e. UserB != userA mock_user.name = 'UserB' utils.create_user('userA', 'passA') mock_keystone.resolve_user_id.assert_called_with('userA', user_domain=None) mock_keystone.create_user.assert_called_with(name='userA', password='******', tenant_id=None, domain_id=None, email='juju@localhost')
def test_returns_dict(self, _): e1 = MagicMock() e1.name = "one" a1 = OrderedDict() e1.to_dict.return_value = a1 e2 = MagicMock() e2.name = "two" a2 = OrderedDict() e2.to_dict.return_value = a2 self.meta_map = MapMeta("Test") self.meta_map.add_element(e1, required=True) self.meta_map.add_element(e2, required=False) expected_elements_dict = OrderedDict() expected_elements_dict['one'] = a1 expected_elements_dict['two'] = a2 expected_dict = OrderedDict() expected_dict['elements'] = expected_elements_dict expected_dict['required'] = ["one"] response = self.meta_map.to_dict() self.assertEqual(expected_dict, response)
def test_it_should_add_a_new_user_to_repo_if_is_valid(self): mocked_repo = MagicMock() mocked_repository = MagicMock() mocked_user = MagicMock() mock_single_user = MagicMock() mock_single_user.name = 'another_user' mock_single_user.__str__ = lambda x: 'another_user' mocked_repository.name = 'test_repo' mocked_repository.path = 'path' mocked_user.get.return_value = mock_single_user mocked_repo.users = ['user'] with patch.multiple('models.lists.users', Repo=MagicMock(return_value=mocked_repo), User=mocked_user): repo_users = ListUsers(mocked_repository) repo_users.add('test', 'RW+') content = ' RW+ = another_user\n' mocked_repo.write.assert_called_once_with(content) message = 'User another_user added to repo test_repo ' \ 'with permissions: RW+' mocked_repository.git.commit.has_calls([call(['conf'], message)])
def test_modified_3_cycle_throws_circ_dependencies_error(self): """ Ensures o o \ / \ o - o (right triangle is a 3 cycle) throws circular dependency error """ stack1 = MagicMock(Spec=Stack) stack2 = MagicMock(Spec=Stack) stack3 = MagicMock(Spec=Stack) stack4 = MagicMock(Spec=Stack) stack1.dependencies = ["stack2"] stack1.name = "stack1" stack2.dependencies = ["stack3"] stack2.name = "stack2" stack3.dependencies = ["stack4"] stack3.name = "stack3" stack4.dependencies = ["stack2"] stack4.name = "stack4" stacks = { "stack1": stack1, "stack2": stack2, "stack3": stack3, "stack4": stack4 } self.environment.stacks = stacks with pytest.raises(CircularDependenciesError) as ex: self.environment._check_for_circular_dependencies() assert (all(x in str(ex) for x in ['stack4', 'stack3', 'stack2']) and 'stack1' not in str(ex))
def test_validate_commit_path_with_more_than_one_entry(self): mocked_repo = MagicMock() mocked_commit = MagicMock() mocked_entry = MagicMock() mocked_second_entry = MagicMock() mocked_commit.tree = "tree" mocked_repo.revparse_single.return_value = mocked_commit mocked_second_entry.id = 1 mocked_second_entry.name = "complex_entry" mocked_second_entry.filemode = GIT_FILEMODE_TREE mocked_entry.name = "simple_entry" mocked_entry.filemode = GIT_FILEMODE_TREE mocked_repo.__getitem__.return_value = [mocked_entry] view = CommitView(repo=mocked_repo, commit_sha1="sha1", mount_time="now", uid=1, gid=1) result = view._validate_commit_path([mocked_second_entry, mocked_entry], ["complex_entry", "simple_entry"]) assert result is True mocked_repo.__getitem__.assert_called_once_with(1)
def test_print_auto(monkeypatch): images = [MagicMock(name='Taupage-AMI-123', id='ami-123')] zone = MagicMock() zone.name = 'zo.ne' cert = {'server_certificate_name': 'zo-ne', 'arn': 'arn:aws:123'} cert_response = { 'list_server_certificates_response': {'list_server_certificates_result': {'server_certificate_metadata_list': [ cert ]}}} sg = MagicMock() sg.name = 'app-sg' sg.id = 'sg-007' monkeypatch.setattr('boto.cloudformation.connect_to_region', lambda x: MagicMock()) monkeypatch.setattr('boto.vpc.connect_to_region', lambda x: MagicMock()) monkeypatch.setattr('boto.iam.connect_to_region', lambda x: MagicMock(list_server_certs=lambda: cert_response)) monkeypatch.setattr('boto.route53.connect_to_region', lambda x: MagicMock(get_zones=lambda: [zone])) monkeypatch.setattr('boto.ec2.connect_to_region', lambda x: MagicMock(get_all_images=lambda filters: images, get_all_security_groups=lambda: [sg])) sns = MagicMock() topic = {'TopicArn': 'arn:123:mytopic'} sns.get_all_topics.return_value = {'ListTopicsResponse': {'ListTopicsResult': {'Topics': [topic]}}} monkeypatch.setattr('boto.sns.connect_to_region', MagicMock(return_value=sns)) data = {'SenzaInfo': {'StackName': 'test', 'OperatorTopicId': 'mytopic', 'Parameters': [{'ImageVersion': {'Description': ''}}]}, 'SenzaComponents': [{'Configuration': {'Type': 'Senza::StupsAutoConfiguration'}}, {'AppServer': {'Type': 'Senza::TaupageAutoScalingGroup', 'ElasticLoadBalancer': 'AppLoadBalancer', 'InstanceType': 't2.micro', 'TaupageConfig': {'runtime': 'Docker', 'source': 'foo/bar:{{Arguments.ImageVersion}}'}, 'IamRoles': ['app-myrole'], 'SecurityGroups': ['app-sg', 'sg-123'], 'AutoScaling': {'Minimum': 1, 'Maximum': 10, 'MetricType': 'CPU'}}}, {'AppLoadBalancer': {'Type': 'Senza::WeightedDnsElasticLoadBalancer', 'HTTPPort': 8080, 'SecurityGroups': ['app-sg']}}]} runner = CliRunner() with runner.isolated_filesystem(): with open('myapp.yaml', 'w') as fd: yaml.dump(data, fd) result = runner.invoke(cli, ['print', 'myapp.yaml', '--region=myregion', '123', '1.0-SNAPSHOT'], catch_exceptions=False) assert 'AWSTemplateFormatVersion' in result.output assert 'subnet-123' in result.output assert 'source: foo/bar:1.0-SNAPSHOT' in result.output assert '"HealthCheckType": "ELB"' in result.output
def createOperationsMock(): """ create an Mock for the Operations Helper """ opModuleMock = Mock() opModuleMock.name = "OperationsModule Mock" opMock = Mock() opModuleMock.return_value = opMock opMock.name = "OperationsClass Mock" opMock.getOptionsDict.side_effect = getOptionsDictMock return opModuleMock
def test_20_launch(self, get_driver): radl_data = """ network net1 (outbound = 'yes') network net2 () system test ( cpu.arch='x86_64' and cpu.count=1 and memory.size=512m and net_interface.0.connection = 'net1' and net_interface.0.dns_name = 'test' and net_interface.1.connection = 'net2' and disk.0.os.name = 'linux' and disk.0.image.url = 'aws://ami-id' and disk.0.os.credentials.username = '******' and disk.1.size=1GB and disk.1.device='hdb' and disk.1.mount_path='/mnt/path' )""" radl = radl_parse.parse_radl(radl_data) radl.check() auth = Authentication([{'id': 'libcloud', 'type': 'LibCloud', 'username': '******', 'password': '******', 'driver': 'EC2'}]) lib_cloud = self.get_lib_cloud() driver = MagicMock() driver.name = "Amazon EC2" driver.features = {"create_node": ["ssh_key"]} get_driver.return_value = driver node_size = MagicMock() node_size.ram = 512 node_size.price = 1 node_size.disk = 1 node_size.vcpus = 1 node_size.name = "small" driver.list_sizes.return_value = [node_size] driver.get_key_pair.return_value = "" keypair = MagicMock() keypair.public_key = "public" driver.create_key_pair.return_value = keypair driver.features = {'create_node': ['ssh_key']} node = MagicMock() node.id = "1" node.name = "name" driver.create_node.return_value = node res = lib_cloud.launch(InfrastructureInfo(), radl, radl, 1, auth) success, _ = res[0] self.assertTrue(success, msg="ERROR: launching a VM.") self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue()) self.clean_log()
def test_tranformer(self): status = rd_instance.ServiceStatuses.BUILDING.api_status db_instance = MockMgmtInstanceTest.build_db_instance( status, task_status=InstanceTasks.BUILDING) stub_dsv_db_info = MagicMock(spec=datastore_models.DBDatastoreVersion) stub_dsv_db_info.id = "test_datastore_version" stub_dsv_db_info.datastore_id = "mysql_test_version" stub_dsv_db_info.name = "test_datastore_name" stub_dsv_db_info.image_id = "test_datastore_image_id" stub_dsv_db_info.packages = "test_datastore_pacakges" stub_dsv_db_info.active = 1 stub_dsv_db_info.manager = "mysql" stub_datastore_version = datastore_models.DatastoreVersion( stub_dsv_db_info) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' server = MagicMock(spec=Server) server.user_id = 'test_user_id' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, db_instance, server, None) with patch.object(DatabaseModelBase, 'find_by', return_value=stub_datastore_version): with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): # invocation transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) payloads = transformer() # assertions self.assertIsNotNone(payloads) self.assertThat(len(payloads), Equals(1)) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertThat(payload['state'], Equals(status.lower())) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) self.assertThat(payload['service_id'], Equals('123'))
def test018_update_ref_no_prev(self): m_fw, m_file, m_pr = MagicMock(), MagicMock(), MagicMock() m_probe = MagicMock() probe = MagicMock() probename = "probe1" probe.name = probename m_probe.name = probe m_file.ref_results = [] m_pr.name = "probe2" module._update_ref_results(m_fw, m_file, m_pr) self.assertItemsEqual(m_file.ref_results, [m_pr])
def test___eq__(self, mock_name_prop): """Test the equality operator.""" rule = styles.StyleRule(None, None, None, None) mock_rule = MagicMock(spec=styles.StyleRule) mock_rule.name = "different_name" self.assertNotEqual(rule, mock_rule) mock_rule.name = "name" self.assertEqual(rule, mock_rule)
def test_modx_dispatch(self): self.assertRaises(Http404, render.modx_dispatch, 'dummy', 'dummy', 'invalid Location', 'dummy') mock_request = MagicMock() mock_request.FILES.keys.return_value = ['file_id'] mock_request.FILES.getlist.return_value = ['file'] * (settings.MAX_FILEUPLOADS_PER_INPUT + 1) self.assertEquals(render.modx_dispatch(mock_request, 'dummy', self.location, 'dummy').content, json.dumps({'success': 'Submission aborted! Maximum %d files may be submitted at once' % settings.MAX_FILEUPLOADS_PER_INPUT})) mock_request_2 = MagicMock() mock_request_2.FILES.keys.return_value = ['file_id'] inputfile = MagicMock() inputfile.size = 1 + settings.STUDENT_FILEUPLOAD_MAX_SIZE inputfile.name = 'name' filelist = [inputfile] mock_request_2.FILES.getlist.return_value = filelist self.assertEquals(render.modx_dispatch(mock_request_2, 'dummy', self.location, 'dummy').content, json.dumps({'success': 'Submission aborted! Your file "%s" is too large (max size: %d MB)' % (inputfile.name, settings.STUDENT_FILEUPLOAD_MAX_SIZE / (1000 ** 2))})) mock_request_3 = MagicMock() mock_request_3.POST.copy.return_value = {'position': 1} mock_request_3.FILES = False mock_request_3.user = self.mock_user inputfile_2 = MagicMock() inputfile_2.size = 1 inputfile_2.name = 'name' self.assertIsInstance(render.modx_dispatch(mock_request_3, 'goto_position', self.location, self.course_id), HttpResponse) self.assertRaises( Http404, render.modx_dispatch, mock_request_3, 'goto_position', self.location, 'bad_course_id' ) self.assertRaises( Http404, render.modx_dispatch, mock_request_3, 'goto_position', ['i4x', 'edX', 'toy', 'chapter', 'bad_location'], self.course_id ) self.assertRaises( Http404, render.modx_dispatch, mock_request_3, 'bad_dispatch', self.location, self.course_id )
def test020_update_ref_error(self, m_log): m_fw, m_file, m_pr = MagicMock(), MagicMock(), MagicMock() m_probe = MagicMock() probe = MagicMock() probename = "probe1" probe.name = probename m_probe.name = probe m_pr.name = "probe1" m_file.ref_results = [m_pr, m_pr] module._update_ref_results(m_fw, m_file, m_pr) self.assertItemsEqual(m_file.ref_results, [m_pr, m_pr]) m_log.error.called_once()
def test_20_launch(self, get_driver): radl_data = """ network net1 (outbound = 'yes') network net2 () system test ( cpu.arch='x86_64' and cpu.count=1 and memory.size=512m and net_interface.0.connection = 'net1' and net_interface.0.ip = '10.0.0.1' and net_interface.0.dns_name = 'test' and net_interface.1.connection = 'net2' and disk.0.os.name = 'linux' and disk.0.image.url = 'gce://us-central1-a/centos-6' and disk.0.os.credentials.username = '******' and disk.1.size=1GB and disk.1.device='hdb' and disk.1.mount_path='/mnt/path' )""" radl = radl_parse.parse_radl(radl_data) radl.check() auth = Authentication([{'id': 'one', 'type': 'GCE', 'username': '******', 'password': '******', 'project': 'proj'}]) gce_cloud = self.get_gce_cloud() driver = MagicMock() get_driver.return_value = driver node_size = MagicMock() node_size.ram = 512 node_size.price = 1 node_size.disk = 1 node_size.vcpus = 1 node_size.name = "small" driver.list_sizes.return_value = [node_size] driver.ex_get_image.return_value = "image" driver.ex_create_address.return_value = "ip" net = MagicMock() net.name = "default" driver.ex_list_networks.return_value = [net] node = MagicMock() node.id = "gce1" node.name = "gce1name" driver.create_node.return_value = node res = gce_cloud.launch(InfrastructureInfo(), radl, radl, 1, auth) success, _ = res[0] self.assertTrue(success, msg="ERROR: launching a VM.") self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue()) self.clean_log()
def test019_update_ref_prev(self): m_fw, m_file = MagicMock(), MagicMock() m_pr_new, m_pr_old = MagicMock(), MagicMock() m_probe = MagicMock() probe = MagicMock() probename = "probe1" probe.name = probename m_probe.name = probe m_pr_old.name = "probe1" m_pr_new.name = "probe1" m_file.ref_results = [m_pr_old] module._update_ref_results(m_fw, m_file, m_pr_new) self.assertItemsEqual(m_file.ref_results, [m_pr_new])
def cache_get(package): pkg = MagicMock() if package in self.fake_repo \ and 'pkg_vers' in self.fake_repo[package]: pkg.name = package pkg.current_ver.ver_str = self.fake_repo[package]['pkg_vers'] elif (package in self.fake_repo and 'pkg_vers' not in self.fake_repo[package]): pkg.name = package pkg.current_ver = None else: raise KeyError return pkg
def test_loop(self): group1 = MagicMock() group1.name = "group1" group2 = MagicMock() group2.name = "group2" group3 = MagicMock() group3.name = "group3" group3.subgroups = [group2] group2.subgroups = [group1] group1.subgroups = [group3] with self.assertRaises(RuntimeError): _flatten_group_hierarchy([group1, group2, group3])
def test_no_circular_dependencies_throws_no_error(self): stack1 = MagicMock(Spec=Stack) stack2 = MagicMock(Spec=Stack) stack1.dependencies = ["stack2"] stack1.name = "stack1" stack2.dependencies = [] stack2.name = "stack2" stacks = { "stack1": stack1, "stack2": stack2 } self.environment.stacks = stacks # Check this runs without throwing an exception self.environment._check_for_circular_dependencies()
def setUp(self): # Mock resource model resource1 = MagicMock() resource1.name = 'Resource1' resource1.version = '1.0' resource1.description = 'Test resource 1' resource1.content_type = 'text/plain' resource1.state = 'created' resource1.open = False resource1.get_url.return_value = 'http://localhost/media/resources/resource1' resource2 = MagicMock() resource2.name = 'Resource2' resource2.version = '2.0' resource2.description = 'Test resource 2' resource2.content_type = 'text/plain' resource2.state = 'created' resource2.open = False resource2.get_url.return_value = 'http://localhost/media/resources/resource2' resource3 = MagicMock() resource3.name = 'Resource3' resource3.version = '2.0' resource3.description = 'Test resource 3' resource3.content_type = 'text/plain' resource3.state = 'created' resource3.open = True resource3.get_url.return_value = 'http://localhost/media/resources/resource3' resource4 = MagicMock() resource4.name = 'Resource4' resource4.version = '1.0' resource4.description = 'Test resource 4' resource4.content_type = 'text/plain' resource4.state = 'created' resource4.open = True resource4.get_url.return_value = 'http://localhost/media/resources/resource4' resource4.offerings = ['1111', '2222'] resources_management.Resource = MagicMock() resources_management.Resource.objects.filter.return_value = [ resource1, resource2, resource3, resource4 ] self.user = MagicMock() self.org = MagicMock() self.user.userprofile.current_organization = self.org
def test_chute_storage(mSave): #Test setAttr & getAttr s = chute_storage.ChuteStorage() assert s.chuteList == {} s.setAttr('test') assert s.chuteList == 'test' ch2 = MagicMock() s.setAttr({1: 'ch1', 2: ch2 , 3: 'ch3'}) for ch in ['ch1', ch2, 'ch3']: assert ch in s.getChuteList() assert s.getAttr() == {1: 'ch1', 2: ch2, 3: 'ch3'} assert s.attrSaveable() #Test saveChute ch = MagicMock() ch.name = 'ch1' s.saveChute(ch) mSave.assert_called_once_with() mSave.reset_mock() ch.name = 2 s.saveChute(ch) mSave.assert_called_once_with() #Test deleteChute ch = Chute({}) assert not ch.isValid() mSave.reset_mock() ch.name = 'test' s.saveChute(ch) mSave.assert_called_once_with() assert ch in s.getChuteList() mSave.reset_mock() s.deleteChute(ch) mSave.assert_called_once_with() assert ch not in s.getChuteList() mSave.assert_called_once_with() assert 'ch1' in s.getChuteList() mSave.reset_mock() s.deleteChute(1) mSave.assert_called_once_with() assert 'ch1' not in s.getChuteList() #Test clearChuteStorage assert s.getChuteList != [] mSave.reset_mock() s.clearChuteStorage() mSave.assert_called_once_with() assert s.getChuteList() == []
def test_add_tasks_unknow_type(self, find_mock): """Test add_tasks with unknown type works.""" project = MagicMock() project.name = 'name' project.short_name = 'short_name' project.description = 'description' project.info = dict() find_mock.return_value = project tasks = MagicMock() tasks.read.return_value = "key, value\n, 1, 2" pbclient = MagicMock() pbclient.create_task.return_value = {'id': 1, 'info': {'key': 'value'}} self.config.pbclient = pbclient res = _add_tasks(self.config, tasks, 'doc', 0, 30) assert res == ("Unknown format for the tasks file. Use json, csv, po or " "properties."), res
def test_add_onesignal_event(self, mock_onesignal): """Test add_onesignal_app is called.""" from pybossa.jobs import create_onesignal_app conn = MagicMock() target = MagicMock() tmp = Project(id=1, name='name', short_name='short_name', info=dict(container=1, thumbnail="avatar.png")) target.id = tmp.id target.project_id = tmp.id target.name = tmp.name target.short_name = tmp.short_name target.info = tmp.info conn.execute.return_value = [tmp] add_onesignal_app(None, conn, target) assert mock_onesignal.called obj = tmp.to_public_json() obj['action_updated'] = 'Project' mock_onesignal.assert_called_with(create_onesignal_app, target.id)
def test_add_tasks_csv_with_info(self, find_mock): """Test add_tasks csv with info field works.""" project = MagicMock() project.name = 'name' project.short_name = 'short_name' project.description = 'description' project.info = dict() find_mock.return_value = project tasks = MagicMock() tasks.read.return_value = "info, value\n, %s, 2" % json.dumps( {'key': 'value'}) pbclient = MagicMock() pbclient.create_task.return_value = {'id': 1, 'info': {'key': 'value'}} self.config.pbclient = pbclient res = _add_tasks(self.config, tasks, 'csv', 0, 30) assert res == '1 tasks added to project: short_name', res
def test_get_site_images(self, get_driver, getCachedSiteList): cred = MagicMock() cred.get_cred.return_value = {"project": "project_name"} getCachedSiteList.return_value = { 'CESGA': { 'url': 'https://fedcloud-osservices.egi.cesga.es:5000', 'state': '', 'id': '11548G0' } } driver = MagicMock() get_driver.return_value = driver image1 = MagicMock() image1.id = "imageid1" image1.name = "imagename1" driver.list_images.return_value = [image1] res = utils.get_site_images("CESGA", "vo.access.egi.eu", "token", cred, "user") self.assertEquals(res, [('imagename1', 'imageid1')])
def test_beacon_change(): ''' Test beacon functionality. Another run with cache file. There are changes so it should report the new values. ''' domain = MagicMock() domain.info = MagicMock(name='info') domain.info.return_value = [4, 1024, 2048, 2, 30] domain.name = MagicMock(name='name') domain.name.return_value = 'testvm' conn = MagicMock() conn.listAllDomains = MagicMock(name='listAllDomains') conn.listAllDomains.return_value = [domain] if os.path.exists(CACHE_FILE): os.unlink(CACHE_FILE) shutil.copyfile( os.path.sep.join( [os.path.abspath(''), 'data', 'virt_state-test.initcache']), CACHE_FILE) with patch.object(virtpoller, 'libvirt', MagicMock(return_value=True)): with patch.object(virtpoller.libvirt, 'openReadOnly', MagicMock(return_value=conn)): with patch.object(virtpoller.binascii, 'hexlify', MagicMock(return_value=5)): ret = virtpoller.beacon({ 'cache_file': CACHE_FILE, 'expire_time': 2 }) assert isinstance(ret, list) assert isinstance(ret[0], dict) assert sorted(ret[0].keys()) == ['plan'] assert ret[0]['plan'][0]['event_type'] == 'exists' assert 'guest_properties' in ret[0]['plan'][0] data = ret[0]['plan'][0]['guest_properties'] assert data['name'] == 'testvm' assert data['virt_type'] == 'para_virtualized' assert data['state'] == 'stopped' assert data['vcpus'] == 2 assert data['memory_size'] == '2048' assert data['uuid'] == 5
def test_add_node_stopped_metric(node_scenario): node_scenario.schema = { "actions": [ { "stop": {} }, ], } mock_item = MagicMock() mock_item.uid = '1' mock_item.name = 'node1' items = [mock_item] with mock.patch('powerfulseal.metriccollectors.StdoutCollector.add_node_stopped_metric') \ as metric_function: metric_function.assert_not_called() node_scenario.act(items) metric_function.assert_called_once_with(mock_item)
def test_60_finalize(self, sleep, get_driver): auth = Authentication([{ 'id': 'one', 'type': 'GCE', 'username': '******', 'password': '******', 'project': 'proj' }]) gce_cloud = self.get_gce_cloud() radl_data = """ system test ( cpu.count>=2 and memory.size>=2048m )""" radl = radl_parse.parse_radl(radl_data) inf = MagicMock() inf.get_next_vm_id.return_value = 1 vm = VirtualMachine(inf, "1", gce_cloud.cloud, radl, radl, gce_cloud) driver = MagicMock() driver.name = "OpenStack" get_driver.return_value = driver node = MagicMock() node.destroy.return_value = True node.extra = {'disks': [{'source': 'vol'}]} node.driver = driver driver.ex_get_node.return_value = node volume = MagicMock() volume.detach.return_value = True volume.destroy.return_value = True driver.ex_get_volume.return_value = volume success, _ = gce_cloud.finalize(vm, auth) self.assertTrue(success, msg="ERROR: finalizing VM info.") self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue()) self.clean_log()
def test_readdir_with_tree_name(self): mocked_repo = MagicMock() mocked_commit = MagicMock() mocked_entry = MagicMock() mocked_entry.name = "entry" mocked_commit.tree = "tree" mocked_repo.revparse_single.return_value = mocked_commit mocked_repo.get_git_object.return_value = [mocked_entry] view = CommitView(repo=mocked_repo, commit_sha1="sha1") with patch("gitfs.views.commit.os") as mocked_os: mocked_os.path.split.return_value = [None, True] dirs = [entry for entry in view.readdir("/path", 0)] assert dirs == [".", "..", "entry"] mocked_os.path.split.assert_called_once_with("/path") mocked_repo.get_git_object.assert_called_once_with("tree", "/path")
def create_fake_import(self, name, version='1', check_items=True, install_status=InstallationStatuses.INSTALL_OK, uninstall_status=InstallationStatuses.UNINSTALL_OK): filenames = [] filenames.append('%s.py' % FAKE_NAME1) import_mock = MagicMock() fake_package = MagicMock() fake_package.name = name fake_package.version = version fake_package.check_items.return_value = check_items fake_package.install.return_value = install_status fake_package.uninstall.return_value = uninstall_status import_mock.Formula.return_value = fake_package return filenames, import_mock
def setUp(self): # Build resource mock self.resource = MagicMock() self.resource.name = 'test_resource' org = MagicMock() org.name = 'test_org' self.resource.provider = org self.resource.download_link = '' self.resource.resource_path = '/media/resources/test_res1.0.rdf' self.resource.resource_type = 'Downloadable' self.resource.version = '0.1' self.resource.old_versions = [] resources_management._upload_usdl = MagicMock(name="_upload_usdl") # Mock context context_obj = MagicMock() context_obj.site.domain = 'http://localhost' resources_management.Context = MagicMock(name="Context") resources_management.Context.objects.all.return_value = [context_obj]
def test_fallback_packages_redirect(self): """ Fetch fallback packages with redirect URLs """ self.request.locator = MagicMock() version = "1.1" name = "foo" filename = "%s-%s.tar.gz" % (name, version) url = "https://pypi.org/pypi/%s/%s" % (name, filename) wheelname = "%s-%s.whl" % (name, version) wheel_url = "https://pypi.org/pypi/%s/%s" % (name, wheelname) dist = MagicMock() dist.name = name self.request.locator.get_project.return_value = { version: dist, "urls": { version: [url, wheel_url] }, } pkgs = get_fallback_packages(self.request, "foo") self.assertEqual(pkgs, {filename: url, wheelname: wheel_url})
def test_search_vm(self, soapproxy): proxy = MagicMock() vmrc_res = MagicMock() vmrc_res.name = "Image" vmrc_res.hypervisor = "qemu" vmrc_res.userPassword = "******" vmrc_res.userLogin = "******" vmrc_res.os = MagicMock() vmrc_res.os.name = "linux" vmrc_res.os.flavour = "ubuntu" vmrc_res.os.version = "14.04" vmrc_res.location = "one://server.com/1" proxy.search.return_value = [vmrc_res] soapproxy.return_value = proxy vmrc = VMRC("http://host:8080/vmrc/vmrc", "user", "pass") radl_data = """ network net () system test ( cpu.arch='x86_64' and cpu.count>=1 and memory.size>=512m and net_interface.0.connection = 'net' and disk.0.os.flavour='ubuntu' and disk.0.os.version>='12.04' and disk.applications contains (name = 'app' and version = '1.0') and soft 10 (disk.applications contains (name = 'otherapp' and version = '2.0')) ) deploy test 1 """ radl = radl_parse.parse_radl(radl_data) res_radl = vmrc.search_vm(radl.systems[0]) self.assertEqual(len(res_radl), 1) self.assertEqual(res_radl[0].getValue("disk.0.image.url"), "one://server.com/1") self.assertEqual( res_radl[0].getValue("disk.0.os.credentials.password"), "pass") self.assertEqual( res_radl[0].getValue("disk.0.os.credentials.username"), "user")
def test_consume_with_exception(self, mock_producer, mock_warced_class): mock_connection = MagicMock(spec=Connection) mock_exchange = MagicMock(spec=Exchange) mock_exchange.name = "test exchange" mock_warced = MagicMock(spec=warced) mock_warced_class.return_value = mock_warced mock_message = MagicMock(spec=Message) mock_message.delivery_info = { "routing_key": "harvest.start.test.test_usertimeline" } # Create harvester and invoke _callback harvester = TestableHarvester(self.working_path, mock_connection, mock_exchange, raise_exception_on_count=[1, 2], tries=2) harvester._callback(self.message, mock_message) # Test assertions self.assertEqual(2, harvester.harvest_seed_call_count) self.assertEqual(0, harvester.process_warc_call_count) # Failed harvest result message self.assertEqual(4, len(mock_producer.mock_calls)) self.assert_first_running_harvest_status(*mock_producer.mock_calls[1]) name, _, kwargs = mock_producer.mock_calls[3] self.assertEqual("harvest.status.test.test_usertimeline", kwargs["routing_key"]) harvest_result_message = kwargs["body"] self.assertEqual(harvest_result_message["id"], "test:1") self.assertEqual(harvest_result_message["status"], STATUS_FAILURE) self.assertEqual(1, len(harvest_result_message["infos"])) self.assertEqual(1, len(harvest_result_message["warnings"])) self.assertEqual(2, len(harvest_result_message["errors"])) self.assertEqual(CODE_UNKNOWN_ERROR, harvest_result_message["errors"][1]["code"]) self.assertIsNotNone( iso8601.parse_date(harvest_result_message["date_started"])) self.assertIsNotNone( iso8601.parse_date(harvest_result_message["date_ended"]))
def test_10_concrete(self, get_driver): radl_data = """ network net () system test ( cpu.arch='x86_64' and cpu.count>=1 and memory.size>=512m and net_interface.0.connection = 'net' and net_interface.0.dns_name = 'test' and disk.0.os.name = 'linux' and disk.0.image.url = 'ost://server.com/ami-id' and disk.0.os.credentials.username = '******' )""" radl = radl_parse.parse_radl(radl_data) radl_system = radl.systems[0] auth = Authentication([{ 'id': 'ost', 'type': 'OpenStack', 'username': '******', 'password': '******', 'tenant': 'tenant', 'host': 'https://server.com:5000' }]) ost_cloud = self.get_ost_cloud() driver = MagicMock() get_driver.return_value = driver node_size = MagicMock() node_size.ram = 512 node_size.price = 1 node_size.disk = 1 node_size.vcpus = 1 node_size.name = "small" driver.list_sizes.return_value = [node_size] concrete = ost_cloud.concreteSystem(radl_system, auth) self.assertEqual(len(concrete), 1) self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
def test_add_tasks_excel_with_info(self, auto_mock, find_mock, workbook_mock): """Test add_tasks excel with info field works.""" auto_mock.return_value = (0, None) project = MagicMock() project.name = 'name' project.short_name = 'short_name' project.description = 'description' project.info = dict() project.id = 1 wb = Workbook() ws = wb.active headers = ['Column Name', 'foo'] ws.append(headers) for row in range(2, 10): ws.append(['value', 'bar']) ws.append([None, None]) ws.append([None, None]) find_mock.return_value = project tasks = MagicMock() tasks.read.return_value = wb workbook_mock.return_value = wb pbclient = MagicMock() self.config.pbclient = pbclient res = _add_tasks(self.config, tasks, 'xlsx', 0, 30) self.config.pbclient.create_task.assert_called_with( project_id=find_mock().id, info={ u'column_name': u'value', u'foo': u'bar' }, n_answers=30, priority_0=0) assert res == '8 tasks added to project: short_name', res
def test_52_reboot(self, conn, pvim): auth = Authentication([{ 'id': 'vsp', 'type': 'vSphere', 'host': 'https://vspherehost', 'username': '******', 'password': '******' }]) vsphere_cloud = self.get_vsphere_cloud() smatconn = MagicMock() conn.return_value = smatconn retcont = MagicMock() smatconn.RetrieveContent.return_value = retcont retcont.viewManager.CreateContainerView.side_effect = self.CreateContainerView pvim.VirtualMachine = vim.VirtualMachine pvim.TaskInfo.State.success = vim.TaskInfo.State.success pvim.Task = vim.Task property_collector = MagicMock() smatconn.content.propertyCollector = property_collector update = MagicMock() property_collector.WaitForUpdates.return_value = update fs = MagicMock() update.filterSet = [fs] objs = MagicMock() fs.objectSet = [objs] change = MagicMock() objs.changeSet = [change] objs.obj = vim.Task("ResetVM") change.name = "info.state" change.val = vim.TaskInfo.State.success inf = MagicMock() vm = VirtualMachine(inf, "vm-template", vsphere_cloud.cloud, "", "", vsphere_cloud, 1) success, _ = vsphere_cloud.reboot(vm, auth) self.assertTrue(success, msg="ERROR: rebooting VM info.") self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
def setUp(self): self.deck_validator = DeckValidator() self.empty_deck = Deck([]) self.oversized_deck = Deck([Mock() for _ in range(60)]) outfit = Mock() outfit.type = 'Outfit' self.multi_outfit_deck = [outfit, outfit] joker = Mock() joker.type = 'Joker' self.triple_joker_deck = [joker, joker, joker] nate_hunter = MagicMock() nate_hunter.type = 'Dude' nate_hunter.name = 'Nate Hunter' nate_hunter.__str__.return_value = nate_hunter.name self.over_four_copies_deck = [nate_hunter, nate_hunter, nate_hunter, nate_hunter, nate_hunter] self.really_erroneous_deck = self.multi_outfit_deck + self.triple_joker_deck + self.over_four_copies_deck
def test_add_exists_new_network_profile_error(self, m_json): """ Test add when the endpoint already exists, adding to a new network, error applying profile. """ # Mock out apply_profile to throw error. self.plugin.policy_driver.apply_profile.side_effect = ApplyProfileError # Mock out _get_endpoint - endpoint exists. ip4 = IPNetwork("10.0.0.1") ip6 = IPNetwork("bad::beef") endpoint = MagicMock(spec=Endpoint) endpoint.ipv4_nets = [ip4] endpoint.ipv6_nets = [ip6] endpoint.name = "cali12345" self.plugin._get_endpoint = MagicMock(spec=self.plugin._get_endpoint) self.plugin._get_endpoint.return_value = endpoint # Call method. assert_raises(SystemExit, self.plugin.add)
def test_create_type_mappings_use_default_mappings_no_story( self, input_mock ): self.handler.issue_types = MagicMock() ticket = MagicMock() ticket_type = "bug,ci" ticket.type = ticket_type issue_type = MagicMock() issue_type.name = "Bug" issue_types = [issue_type] self.handler.issue_types.return_value = issue_types input_mock.side_effect = ["Y"] mappings = self.handler.create_type_mappings([ticket]) self.assertEqual(mappings, {"bug": "Bug", "ci": "Bug"}) self.assertEqual(input_mock.call_count, 1)
def test_disallow_fallback_packages(self): """ Disallow fetch fallback packages """ self.request.locator = MagicMock() version = "1.1" name = "foo" filename = "%s-%s.tar.gz" % (name, version) url = "http://pypi.python.org/pypi/%s/%s" % (name, filename) wheelname = "%s-%s.whl" % (name, version) wheel_url = "http://pypi.python.org/pypi/%s/%s" % (name, wheelname) dist = MagicMock() dist.name = name self.request.locator.get_project.return_value = { version: dist, "urls": { version: [url, wheel_url] }, } self.request.access.has_permission = MagicMock(return_value=False) pkgs = get_fallback_packages(self.request, "foo") self.assertEqual(pkgs, {})
def test_close_spider_removes_file_with_no_data(datetime_mock, exporter_mock, os_mock): datetime_mock.now.return_value = DATE_TIME os_mock.path.getsize.return_value = 0 csvpipeline = CSVExportPipeline() spider_mock = Mock(spec=GlassdoorSpider) spider_mock.file_name = "glassdoor_spider" csvpipeline.exporter = exporter_mock csvpipeline.file_name = ( f'{spider_mock.file_name} {DATE_TIME.strftime("%m-%d-%Y %H-%M-%S")}.csv' ) os_mock.path.realpath.return_value = csvpipeline.file_name mock_file = MagicMock() with patch("builtins.open", return_value=mock_file, create=True): csvpipeline.file = open(csvpipeline.file_name, "wb") mock_file.name = csvpipeline.file_name close_spider_mock = Mock(side_effect=csvpipeline.close_spider) close_spider_mock(spider_mock) os_mock.path.getsize.assert_called_once_with(csvpipeline.file_name) os_mock.remove.assert_called_once_with(csvpipeline.file_name)
def test_create_request_with_right_request_params(self, parent_breadcrumbs_from, breadcrumb_filters, settings): http_request = MagicMock() mock_api = MagicMock() mock_api.name = 'api_name' mock_api.version = '1.0.0.1' mock_user = http_request.user request_body = MagicMock() http_request.user.is_anonymous.return_value = False breadcrumb_filters.return_value = expected_req_params = {'bar': 'baz'} request = api_request_builder.build_request(http_request=http_request, url='candidates', api=mock_api, request_data={}, request_body=request_body) assert_that(request.user, equal_to(mock_user)) assert_that(request.request_params, equal_to(expected_req_params))
def test_prepare_environment(core): chute = MagicMock() chute.name = "test" chute.version = 5 chute.get_environment.return_value = {"CHUTE_VARIABLE": "test"} core.info.pdid = 'halo42' update = MagicMock() update.new = chute service = MagicMock() service.environment = {"CUSTOM_VARIABLE": 42} env = dockerapi.prepare_environment(update, service) assert env['PARADROP_CHUTE_NAME'] == chute.name assert env['PARADROP_CHUTE_VERSION'] == chute.version assert env['PARADROP_ROUTER_ID'] == core.info.pdid assert env['CUSTOM_VARIABLE'] == 42 assert env['CHUTE_VARIABLE'] == 'test'
def test_add_tasks_json_without_info(self, auto_mock, find_mock): """Test add_tasks json without info field works.""" auto_mock.return_value = (0, None) project = MagicMock() project.name = 'name' project.short_name = 'short_name' project.description = 'description' project.info = dict() find_mock.return_value = project tasks = MagicMock() tasks.read.return_value = json.dumps([{'key': 'value'}]) pbclient = MagicMock() pbclient.create_task.return_value = {'id': 1, 'info': {'key': 'value'}} self.config.pbclient = pbclient res = _add_tasks(self.config, tasks, 'json', 0, 30) assert res == '1 tasks added to project: short_name', res
def test_add_tasks_another_error(self, auto_mock, find_mock): """Test add_tasks another error works.""" auto_mock.return_value = (0, None) project = MagicMock() project.name = 'name' project.short_name = 'short_name' project.description = 'description' project.info = dict() find_mock.return_value = project tasks = MagicMock() tasks.read.return_value = json.dumps([{'key': 'value'}]) pbclient = MagicMock() pbclient.create_task.return_value = self.error self.config.pbclient = pbclient assert_raises(ProjectNotFound, _add_tasks, self.config, tasks, 'json', 0, 30)
def make_part_tasks(self, hook, func): task = MagicMock() func_name = "configure" part = MagicMock() part.name = "test_part" part.method_metas = {} setattr(part, func_name, func) part_tasks = {part: task} hook_queue = self.c.process.create_queue.return_value def side_effect(): task_return = task.define_spawn_function.call_args[0][0] task_return() return hook_queue.put.call_args[0][0] hook_queue.get.side_effect = side_effect hook.find_hooked_functions.return_value = {part: func_name} self.c.hook_names = {hook: "test_hook"} return part_tasks
def test_add_project_event(self, mock_update_feed): """Test add_project_event is called.""" conn = MagicMock() target = MagicMock() tmp = Project(id=1, name='name', short_name='short_name', info=dict(container=1, thumbnail="avatar.png")) target.id = tmp.id target.project_id = tmp.id target.name = tmp.name target.short_name = tmp.short_name target.info = tmp.info conn.execute.return_value = [tmp] add_project_event(None, conn, target) assert mock_update_feed.called obj = tmp.to_public_json() obj['action_updated'] = 'Project' mock_update_feed.assert_called_with(obj) mock_update_feed.assert_called_with(obj)
def test_edl_import_success(self): """ edl_import_success should update the database record when task completes successfully :return: """ from portal.plugins.gnmatomresponder.signals import edl_import_success from portal.plugins.gnmatomresponder.models import PacFormXml from celery import Task mock_sender = MagicMock(target=Task) mock_sender.name = "test_task" mock_sender.request.id = "bbba3673-1f46-4a7f-a549-81bac11955e7" edl_import_success(sender=mock_sender) pacmodel = PacFormXml.objects.get( celery_task_id=mock_sender.request.id) self.assertEqual(pacmodel.status, "PROCESSED") self.assertEqual(pacmodel.last_error, "")
def test_add_tasks_json_connection_error(self, auto_mock, find_mock): """Test add_tasks json connection error works.""" auto_mock.return_value = (0, None) project = MagicMock() project.name = 'name' project.short_name = 'short_name' project.description = 'description' project.info = dict() find_mock.return_value = project tasks = MagicMock() tasks.read.return_value = json.dumps([{'key': 'value'}]) pbclient = MagicMock() pbclient.create_task.side_effect = exceptions.ConnectionError self.config.pbclient = pbclient res = _add_tasks(self.config, tasks, 'json', 0, 30) assert res == "Connection Error! The server http://server is not responding", res
def test_10_concrete(self, get_driver): radl_data = """ network net () system test ( cpu.arch='x86_64' and cpu.count>=1 and memory.size>=512m and net_interface.0.connection = 'net' and net_interface.0.dns_name = 'test' and disk.0.os.name = 'linux' and disk.0.image.url = 'gce://us-central1-a/centos-6' and disk.0.os.credentials.username = '******' )""" radl = radl_parse.parse_radl(radl_data) radl_system = radl.systems[0] auth = Authentication([{ 'id': 'one', 'type': 'GCE', 'username': '******', 'password': '******', 'project': 'proj' }]) driver = MagicMock() get_driver.return_value = driver node_size = MagicMock() node_size.ram = 512 node_size.price = 1 node_size.disk = 1 node_size.name = "small" driver.list_sizes.return_value = [node_size] gce_cloud = self.get_gce_cloud() concrete = gce_cloud.concreteSystem(radl_system, auth) self.assertEqual(len(concrete), 1) self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue()) self.clean_log()