def test_actions_template(self): context, project = Mock(), Mock() action = Mock() action.name = 'upload' action.apply.return_value = {'version': '1234'} parameter = Mock() parameter.name = "name" output = Mock() output.name = "version" output.value = GetAttr(action='upload', attr='version') output2 = Mock() output2.name = "pi" output2.value = "3.1416" at = ActionsTemplate() at.add(action) at.add_parameter(parameter) at.add_output(output) at.add_output(output2) self.assertEqual(at.apply(context, project), { 'version': '1234', 'pi': '3.1416' })
def test_on_snapshot_loaded(self): m_response = Mock() endpoint_on_host = Mock() endpoint_on_host.key = ("/calico/v1/host/hostname/workload/" "orch/wlid/endpoint/epid") endpoint_on_host.value = ENDPOINT_STR bad_endpoint_on_host = Mock() bad_endpoint_on_host.key = ("/calico/v1/host/hostname/workload/" "orch/wlid/endpoint/epid2") bad_endpoint_on_host.value = ENDPOINT_STR[:10] endpoint_not_on_host = Mock() endpoint_not_on_host.key = ("/calico/v1/host/other/workload/" "orch/wlid/endpoint/epid") endpoint_not_on_host.value = ENDPOINT_STR still_ready = Mock() still_ready.key = ("/calico/v1/Ready") still_ready.value = "true" m_response.children = [ endpoint_on_host, bad_endpoint_on_host, endpoint_not_on_host, still_ready, ] with patch.object(self.watcher, "clean_up_endpoint_statuses") as m_clean: self.watcher._on_snapshot_loaded(m_response) # Cleanup should only get the endpoints on our host. m_clean.assert_called_once_with( set([EndpointId("hostname", "orch", "wlid", "epid")]))
def test_resource_offers_creates_nodes(self, mock_get_slave): mock_get_slave.return_value = SlaveInfo(u'localhost', 5151) mock_cpu = Mock() mock_cpu.name = u'cpus' mock_cpu.value = 10 mock_disk = Mock() mock_disk.name = u'disk' mock_disk.value = 4000 mock_mem = Mock() mock_mem.name = u'mem' mock_mem.value = 100000 mock_offer = Mock() mock_offer.id.value = 1 mock_offer.slave_id.value = 1 mock_offer.hostname.value = u'localhost' mock_offer.resources = [mock_cpu, mock_disk, mock_mem] offers = [mock_offer] my_scheduler, driver, master_info = self._get_mocked_scheduler_driver_master() localhost_exists = Node.objects.filter(hostname=u'localhost').exists() self.assertFalse(localhost_exists, 'there should not be a node before the first offer') my_scheduler.resourceOffers(driver, offers) localhost_exists = Node.objects.all().exists() self.assertTrue(localhost_exists, 'there should be a node after the first offer')
def test(self, get_network_by_device): # ARRANGE network = Mock() network.name = 'Net1' network.config.defaultPortConfig.vlan.vlanId = '65' get_network_by_device.return_value = network vm = self.mock_vm() si = Mock() pyvmomi_service = Mock() pyvmomi_service.find_by_uuid = Mock(return_value=vm) ip_regex_param = Mock() ip_regex_param.name = 'ip_regex' ip_regex_param.value = '.*' wait_for_ip_param = Mock() wait_for_ip_param.name = 'wait_for_ip' wait_for_ip_param.value = 'True' request = Mock() request.deployedAppJson.name = 'App1' request.deployedAppJson.vmdetails.vmCustomParams = [ip_regex_param, wait_for_ip_param] request.appRequestJson.deploymentService.model = 'vCenter Clone VM From VM' request.appRequestJson.deploymentService.attributes = [Mock()] resource_context = Mock() resource_context.attributes = {'Reserved Networks': 'Net1;B'} cancellation_context = Mock(is_cancelled=False) ip_manager = VMIPManager() vm_details_provider = VmDetailsProvider(pyvmomi_service, ip_manager) # ACT command = VmDetailsCommand(pyvmomi_service, vm_details_provider) datas = command.get_vm_details( si=si, logger=Mock(), resource_context=resource_context, requests=[request], cancellation_context=cancellation_context) # ASSERT self.assertEqual(len(datas), 1) vm_details = datas[0] if isinstance(vm_details,VmDetailsData): pass self.assertEqual(vm_details.appName, 'App1') self.assertEqual(vm_details.errorMessage, '') self.assertEqual(len(vm_details.vmInstanceData), 6) self.assertEqual(len(vm_details.vmNetworkData), 1) nic = vm_details.vmNetworkData[0] if isinstance(nic,VmDetailsNetworkInterface): pass self.assertEqual(nic.interfaceId, 'Mac1') self.assertEqual(nic.isPredefined, True) self.assertEqual(nic.isPrimary, True) self.assertEqual(nic.networkId, '65') self.assertEqual(len(nic.networkData), 4) self.assertEqual(self._get_value(nic.networkData, 'IP') , '1.2.3.4') self.assertEqual(self._get_value(nic.networkData, 'MAC Address') , 'Mac1') self.assertEqual(self._get_value(nic.networkData, 'Network Adapter') , 'NetDeviceLabel') self.assertEqual(self._get_value(nic.networkData, 'Port Group Name') , 'Net1')
def test_restructure_layout_preferences_forwards(self): empty_workspace = Mock() empty_workspace_layout_pref = Mock() empty_workspace_layout_preferences = TestQueryResult([]) empty_workspace.workspacepreference_set.filter.side_effect = ( lambda **kwargs: empty_workspace_layout_pref if kwargs.get("name") == "layout" else empty_workspace_layout_preferences ) empty_workspace.tab_set.all.return_value = TestQueryResult([]) workspace = Mock() workspace_layout_pref = Mock() workspace_columns_pref = Mock() workspace_columns_pref.name = "columns" workspace_columns_pref.value = 15 workspace_layout_preferences = TestQueryResult([workspace_columns_pref]) workspace.workspacepreference_set.filter.side_effect = ( lambda **kwargs: workspace_layout_pref if kwargs.get("name", "") == "layout" else workspace_layout_preferences ) workspace_tab = Mock() workspace_tab_layout_pref = Mock() workspace_tab_columns_pref = Mock() workspace_tab_columns_pref.name = "columns" workspace_tab_columns_pref.value = 15 workspace_tab_layout_preferences = TestQueryResult([workspace_tab_columns_pref]) workspace_tab.tabpreference_set.filter.side_effect = ( lambda **kwargs: workspace_tab_layout_pref if kwargs.get("name", "") == "layout" else workspace_tab_layout_preferences ) workspace_empty_tab = Mock() workspace_empty_tab_layout_pref = Mock() workspace_empty_tab_layout_preferences = TestQueryResult([]) workspace_empty_tab.tabpreference_set.filter.side_effect = ( lambda **kwargs: workspace_empty_tab_layout_pref if kwargs.get("name", "") == "layout" else workspace_empty_tab_layout_preferences ) workspace.tab_set.all.return_value = TestQueryResult([workspace_empty_tab, workspace_tab]) migration = self._pick_migration("0016_restructure_layout_preferences") orm = Mock(autospec=migration.orm()) orm.Workspace.objects.all.return_value = TestQueryResult([empty_workspace, workspace]) migration.migration_instance().forwards(orm) self.assertTrue(empty_workspace_layout_pref.update.called) self.assertEqual(empty_workspace_layout_preferences.delete.call_count, 0) self.assertFalse(empty_workspace.workspacepreference_set.create.called) self.assertTrue(workspace_layout_pref.update.called) self.assertTrue(workspace_layout_preferences.delete.called) self.assertTrue(workspace_tab_layout_preferences.delete.called) self.assertFalse(workspace_empty_tab_layout_preferences.delete.called) self.assertTrue(workspace.workspacepreference_set.create.called)
def test_hash_function(self): mock_item_1 = Mock() mock_item_1.value = 1 mock_item_2 = Mock() mock_item_2.value = 2 input_list = [mock_item_1, mock_item_1, mock_item_2, mock_item_2] expected = [mock_item_1, mock_item_2] self.assertEqual(expected, unique_list_items(input_list, lambda x: x.value))
def test_hash_function(self): mock_item_1 = Mock() mock_item_1.value = 1 mock_item_2 = Mock() mock_item_2.value = 2 input_list = [mock_item_1, mock_item_1, mock_item_2, mock_item_2] expected = [mock_item_1, mock_item_2] self.assertEquals(expected, unique_list_items(input_list, lambda x: x.value))
def mock_read(path): result = Mock(spec=EtcdResult) if path == TEST_HOST_PATH + "/bird_ip": result.value = "192.168.24.1" return result if path == TEST_HOST_PATH + "/bird6_ip": result.value = "fd30:4500::1" return result assert False
def mock_read(path): result = Mock(spec=EtcdResult) if path == TEST_HOST_PATH + "/bird_ip": result.value = "" return result if path == TEST_HOST_PATH + "/bird6_ip": result.value = "" return result assert False
def test_got_csrf(self): cookie1 = Mock() cookie1.name = 'csrftoken' cookie1.value = 'csrf value 1' cookie1.domain = 'other domain' cookie2 = Mock() cookie2.name = 'csrftoken' cookie2.value = 'csrf value 2' cookie2.domain = 'test.trigger.io' self.remote.cookies = [cookie1, cookie2] eq_(self.remote._csrf_token(), 'csrf value 2')
def test_restructure_layout_preferences_forwards(self): empty_workspace = Mock() empty_workspace_layout_pref = Mock() empty_workspace_layout_preferences = TestQueryResult([]) empty_workspace.workspacepreference_set.filter.side_effect = lambda **kwargs: empty_workspace_layout_pref if kwargs.get( 'name') == 'layout' else empty_workspace_layout_preferences empty_workspace.tab_set.all.return_value = TestQueryResult([]) workspace = Mock() workspace_layout_pref = Mock() workspace_columns_pref = Mock() workspace_columns_pref.name = 'columns' workspace_columns_pref.value = 15 workspace_layout_preferences = TestQueryResult( [workspace_columns_pref]) workspace.workspacepreference_set.filter.side_effect = lambda **kwargs: workspace_layout_pref if kwargs.get( 'name', '') == 'layout' else workspace_layout_preferences workspace_tab = Mock() workspace_tab_layout_pref = Mock() workspace_tab_columns_pref = Mock() workspace_tab_columns_pref.name = 'columns' workspace_tab_columns_pref.value = 15 workspace_tab_layout_preferences = TestQueryResult( [workspace_tab_columns_pref]) workspace_tab.tabpreference_set.filter.side_effect = lambda **kwargs: workspace_tab_layout_pref if kwargs.get( 'name', '') == 'layout' else workspace_tab_layout_preferences workspace_empty_tab = Mock() workspace_empty_tab_layout_pref = Mock() workspace_empty_tab_layout_preferences = TestQueryResult([]) workspace_empty_tab.tabpreference_set.filter.side_effect = lambda **kwargs: workspace_empty_tab_layout_pref if kwargs.get( 'name', '') == 'layout' else workspace_empty_tab_layout_preferences workspace.tab_set.all.return_value = TestQueryResult( [workspace_empty_tab, workspace_tab]) migration = self._pick_migration('0016_restructure_layout_preferences') orm = Mock(autospec=migration.orm()) orm.Workspace.objects.all.return_value = TestQueryResult( [empty_workspace, workspace]) migration.migration_instance().forwards(orm) self.assertTrue(empty_workspace_layout_pref.update.called) self.assertEqual(empty_workspace_layout_preferences.delete.call_count, 0) self.assertFalse(empty_workspace.workspacepreference_set.create.called) self.assertTrue(workspace_layout_pref.update.called) self.assertTrue(workspace_layout_preferences.delete.called) self.assertTrue(workspace_tab_layout_preferences.delete.called) self.assertFalse(workspace_empty_tab_layout_preferences.delete.called) self.assertTrue(workspace.workspacepreference_set.create.called)
def test_wait_for_ready(self, m_sleep): m_resp_1 = Mock() m_resp_1.value = "false" m_resp_2 = Mock() m_resp_2.value = "true" responses = [ etcd.EtcdException(), etcd.EtcdKeyNotFound(), m_resp_1, m_resp_2, ] self.m_client.read.side_effect = iter(responses) self.watcher.wait_for_ready(1) self.assertEqual(m_sleep.mock_calls, [call(1)] * 3)
def test_exec_config_with_set_workspaces(self): """Test exec config with set workspaces subcommand.""" args = Mock() args.action = "set" args.key = "workspaces" args.value = False self.assertFalse(self.subcommand.execute(args))
def test_server_sends_marshaled_exception_when_callback_raises_exception(self, mock_command_response): request = '{"name": "foobar", "arg": {"arg1": "value"}}' expected = '{"error": "raise me!", "value": null}' command_response = Mock(CommandResponse) command_response.error = "raise me!" command_response.value = None mock_command_response.return_value = command_response callback = Mock(side_effect=BusCtlServerError()) marshaler = Mock(Marshaler) server = BusCtlServer() server._marshaler = marshaler command = Mock() command.name = "foobar" marshaler.unmarshal_command.return_value = command marshaler.marshal_response.return_value = expected command_class = Mock() command_class.name = "foobar" server.add_command(command_class, callback) response = server._process_next_command(request) self.assertEqual(response, expected) marshaler.marshal_response.assert_called_once_with(command_response)
def test_process_event_unknownservice(self): with patch.object(VOLTService.objects, "get_items") as fcservice_objects, \ patch.object(Service.objects, "get_items") as service_objects, \ patch.object(VOLTServiceInstance, "save") as fcsi_save: fcservice_objects.return_value = [self.fcservice] service_objects.return_value = [self.onos, self.fcservice] event_dict = { "status": "created", "labels": { "xos_service": "something_else" } } event = Mock() event.value = json.dumps(event_dict) step = self.event_step(model_accessor=self.model_accessor, log=self.log) step.process_event(event) self.assertEqual(self.fcsi1.backend_code, 1) self.assertEqual(self.fcsi1.backend_status, "succeeded") self.assertEqual(self.fcsi2.backend_code, 1) self.assertEqual(self.fcsi2.backend_status, "succeeded") fcsi_save.assert_not_called()
def test_nested_raw_field(self): foo = Mock() bar = Mock() bar.value = 3 foo.bar = bar field = fields.Raw() self.assertEquals(field.output("bar.value", foo), 3)
def test_print_report_with_filtered_cpus(self): timestamp = "2016-19-07 IST" total_interrupt_usage = Mock() total_interrupt_usage.total_interrupt_per_delta_time = Mock( return_value=1.23) options = Mock() options.cpu_list = 'ALL' options.cpu_filter = True printer = Mock() cpu_filter = Mock() cpu_interrupt = Mock() cpu_interrupt.cpu_number = Mock(return_value=0) cpu_interrupt.value = Mock(return_value=2.4) cpu_filter.filter_cpus = Mock(return_value=[cpu_interrupt]) report = TotalInterruptUsageReporter(cpu_filter, printer, options) report.print_report(total_interrupt_usage, timestamp) calls = [ call('\nTimestamp\tCPU \tintr/s'), call('2016-19-07 IST\tall \t1.23 '), call('2016-19-07 IST\t0 \t2.4 ') ] printer.assert_has_calls(calls)
def test_process_event_nolabels(self): with patch.object(FabricService.objects, "get_items") as fabric_service_objects, \ patch.object(Service.objects, "get_items") as service_objects, \ patch.object(Switch.objects, "get_items") as switch_objects, \ patch.object(Switch, "save") as switch_save, \ patch.object(SwitchPort, "save") as switchport_save: fabric_service_objects.return_value = [self.fabric_service] service_objects.return_value = [self.onos, self.fabric_service] switch_objects.return_value = [self.switch] event_dict = {"status": "created"} event = Mock() event.value = json.dumps(event_dict) step = self.event_step(model_accessor=self.model_accessor, log=self.log) step.process_event(event) self.assertEqual(self.switch.backend_code, 1) self.assertEqual(self.switch.backend_status, "succeeded") switch_save.assert_not_called() self.assertEqual(self.port1.backend_code, 1) self.assertEqual(self.port1.backend_status, "succeeded") self.assertEqual(self.port2.backend_code, 1) self.assertEqual(self.port2.backend_status, "succeeded") switchport_save.assert_not_called()
def test_process_event_unknownstatus(self): with patch.object(FabricService.objects, "get_items") as fabric_service_objects, \ patch.object(Service.objects, "get_items") as service_objects, \ patch.object(Switch.objects, "get_items") as switch_objects, \ patch.object(Switch, "save") as switch_save, \ patch.object(SwitchPort, "save") as switchport_save: fabric_service_objects.return_value = [self.fabric_service] service_objects.return_value = [self.onos, self.fabric_service] switch_objects.return_value = [self.switch] event_dict = {"status": "something_else", "labels": {"xos_service": "myonos"}} event = Mock() event.value = json.dumps(event_dict) step = self.event_step(log=self.log) step.process_event(event) self.assertEqual(self.switch.backend_code, 1) self.assertEqual(self.switch.backend_status, "succeeded") switch_save.assert_not_called() self.assertEqual(self.port1.backend_code, 1) self.assertEqual(self.port1.backend_status, "succeeded") self.assertEqual(self.port2.backend_code, 1) self.assertEqual(self.port2.backend_status, "succeeded") switchport_save.assert_not_called()
def test_process_event_unknownservice(self): with patch.object(ONOSService.objects, "get_items") as service_objects, \ patch.object(ONOSService, "save") as service_save, \ patch.object(ONOSApp, "save") as app_save: service_objects.return_value = [self.onos] event_dict = { "status": "created", "labels": { "xos_service": "some_other_service" } } event = Mock() event.value = json.dumps(event_dict) step = self.event_step(log=self.log, model_accessor=self.model_accessor) step.process_event(event) self.assertEqual(self.onos.backend_code, 1) self.assertEqual(self.onos.backend_status, "succeeded") service_save.assert_not_called() self.assertEqual(self.app1.backend_code, 1) self.assertEqual(self.app1.backend_status, "succeeded") app_save.assert_not_called() self.assertEqual(self.app2.backend_code, 1) self.assertEqual(self.app2.backend_status, "succeeded")
def test_to_json(self): host = "test_host" block = AllocationBlock(network, host) # Set up an allocation attr = { AllocationBlock.ATTR_HANDLE_ID: "test_key", AllocationBlock.ATTR_SECONDARY: { "key1": "value1", "key2": "value2" } } block.attributes.append(attr) block.allocations[5] = 0 assert_equal(block.count_free_addresses(), BLOCK_SIZE - 1) # Read out the JSON json_str = block.to_json() json_dict = json.loads(json_str) assert_equal(json_dict[AllocationBlock.CIDR], str(network)) assert_equal(json_dict[AllocationBlock.AFFINITY], "host:test_host") assert_dict_equal(json_dict[AllocationBlock.ATTRIBUTES][0], attr) expected_allocations = [None] * BLOCK_SIZE expected_allocations[5] = 0 assert_list_equal(json_dict[AllocationBlock.ALLOCATIONS], expected_allocations) # Verify we can read the JSON back in. result = Mock(spec=EtcdResult) result.value = json_str block2 = AllocationBlock.from_etcd_result(result) assert_equal(block2.to_json(), json_str)
def test_server_sends_marshaled_exception_when_callback_raises_exception( self, mock_command_response): request = '{"name": "foobar", "arg": {"arg1": "value"}}' expected = '{"error": "raise me!", "value": null}' command_response = Mock(CommandResponse) command_response.error = "raise me!" command_response.value = None mock_command_response.return_value = command_response callback = Mock(side_effect=BusCtlServerError()) marshaler = Mock(Marshaler) server = BusCtlServer() server._marshaler = marshaler command = Mock() command.name = "foobar" marshaler.unmarshal_command.return_value = command marshaler.marshal_response.return_value = expected command_class = Mock() command_class.name = "foobar" server.add_command(command_class, callback) response = server._process_next_command(request) self.assertEqual(response, expected) marshaler.marshal_response.assert_called_once_with(command_response)
def mock_read_4_endpoints(path, recursive): assert path == ALL_ENDPOINTS_PATH assert recursive leaves = [] specs = [ (CALICO_V_PATH + "/host/TEST_HOST/bird_ip", "192.168.1.1"), (CALICO_V_PATH + "/host/TEST_HOST/bird6_ip", "fd80::4"), (CALICO_V_PATH + "/host/TEST_HOST/config/marker", "created"), (CALICO_V_PATH + "/host/TEST_HOST/workload/docker/1234/endpoint/567890abcdef", EP_56.to_json()), (CALICO_V_PATH + "/host/TEST_HOST/workload/docker/5678/endpoint/90abcdef1234", EP_90.to_json()), (CALICO_V_PATH + "/host/TEST_HOST2/bird_ip", "192.168.1.2"), (CALICO_V_PATH + "/host/TEST_HOST2/bird6_ip", "fd80::3"), (CALICO_V_PATH + "/host/TEST_HOST2/config/marker", "created"), (CALICO_V_PATH + "/host/TEST_HOST2/workload/docker/1234/endpoint/7890abcdef12", EP_78.to_json()), (CALICO_V_PATH + "/host/TEST_HOST2/workload/docker/5678/endpoint/1234567890ab", EP_12.to_json())] for spec in specs: leaf = Mock(spec=EtcdResult) leaf.key = spec[0] leaf.value = spec[1] leaves.append(leaf) result = Mock(spec=EtcdResult) result.leaves = iter(leaves) return result
def test_process_event(self): with patch.object(FabricService.objects, "get_items") as fabric_service_objects, \ patch.object(Service.objects, "get_items") as service_objects, \ patch.object(Switch.objects, "get_items") as switch_objects, \ patch.object(Switch, "save", autospec=True) as switch_save, \ patch.object(SwitchPort, "save", autospec=True) as switchport_save: fabric_service_objects.return_value = [self.fabric_service] service_objects.return_value = [self.onos, self.fabric_service] switch_objects.return_value = [self.switch] event_dict = {"status": "created", "labels": {"xos_service": "myonos"}} event = Mock() event.value = json.dumps(event_dict) step = self.event_step(log=self.log) step.process_event(event) self.assertEqual(self.switch.backend_code, 0) self.assertEqual(self.switch.backend_status, "resynchronize due to kubernetes event") switch_save.assert_called_with(self.switch, update_fields=["updated", "backend_code", "backend_status"], always_update_timestamp=True) self.assertEqual(self.port1.backend_code, 0) self.assertEqual(self.port1.backend_status, "resynchronize due to kubernetes event") self.assertEqual(self.port2.backend_code, 0) self.assertEqual(self.port2.backend_status, "resynchronize due to kubernetes event") switchport_save.assert_has_calls([call(self.port1, update_fields=["updated", "backend_code", "backend_status"], always_update_timestamp=True), call(self.port2, update_fields=["updated", "backend_code", "backend_status"], always_update_timestamp=True)])
def dummy_balance_code(): m = Mock() m.pk = random.randint(1, 999) m.value = 100 m.code = generate_balance_code() m.refill_series.pk = random.randint(1, 99) m.refill_series.least_valid_until = date.today() return m
def setup(self): library = self.library = ContentFeedLibrary() # Create a subscriber subscriber = self.subscriber = Mock() # Create a subscription subscription = self.subscription = Mock() subscription.last_sent = datetime.datetime(2011, 1, 1, 0, 0) subscription.feed_record.last_updated = datetime.datetime(2011, 8, 4, 6, 50) subscription.feed_record.feed_name = 'MockFeed' param1 = Mock(); param1.name = 'p1'; param1.value = '1' param2 = Mock(); param2.name = 'p2'; param2.value = '2' subscription.feed.feed_params.all = lambda: [param1, param2] # The subscriber is subscribed to the subscription we created subscriber.subscriptions.all = lambda: [subscription]
def test_get_cookie(self): morsel = Mock() morsel.value = "value" self.rh.request.cookies = {"testcookie": morsel} val = self.rh.get_cookie("testcookie") self.assertEqual(val, "value") val = self.rh.get_cookie("non_existent") self.assertEqual(val, None)
def test_exec_config_with_set(self): """Test exec config with set subcommand.""" args = Mock() args.action = "set" args.key = "logfile" args.value = "/tmp/yoda.log" self.subcommand.execute(args) self.assertEqual("/tmp/yoda.log", self.config["logfile"])
def test_get_stack_parameters_dict_returns_proper_dict(self, _, get_stack_mock): cfn = CloudFormation() parameter_1 = Mock() parameter_1.key = "myKey1" parameter_1.value = "myValue1" parameter_2 = Mock() parameter_2.key = "myKey2" parameter_2.value = "myValue2" stack_mock = Mock() stack_mock.parameters = [parameter_1, parameter_2] get_stack_mock.return_value = stack_mock result = cfn.get_stack_parameters_dict('foo') self.assertDictEqual({'myKey1': 'myValue1', 'myKey2': 'myValue2'}, result)
def testEqualWithVariableSameValueNegative(self): variable1 = ConstantBuilder().value(2.0).build() variable2 = Mock() variable2.value = 2.0 variable2.dispatch = Mock( side_effect=lambda x: x.visit_variable(variable2)) self.assertFalse(variable1.equal(variable2)) self.assertNotEqual(variable1, variable2)
def testEqualWithConstantDifferentValueNegative(self): variable1 = VariableBuilder().value(3.0).build() variable2 = Mock() variable2.value = 2.0 variable2.dispatch = Mock( side_effect=lambda x: x.visit_constant(variable2)) self.assertFalse(variable1.equal(variable2)) self.assertNotEqual(variable1, variable2)
def dispatch(self, key, action, value=None): """ Send an EtcdResult to the watcher's dispatcher. """ m_response = Mock(spec=EtcdResult) m_response.key = key m_response.action = action m_response.value = value self.watcher.dispatcher.handle_event(m_response)
def test_should_get_phone_number_and_short_code_of_contact_when_name_does_not_exist( self): dbm = MagicMock(spec=DatabaseManager) uuid = "ds_short_code" mobile_number = "some_number" contact = Mock(spec=Contact) contact.value('name').return_value = None contact.value('mobile_number').return_value = 'some_number' contact.short_code = uuid with patch( 'datawinners.search.submission_index.Contact') as contact_mock: contact_mock.get.return_value = contact number, short_code = _lookup_contact_by_uid(dbm, uuid) self.assertEqual(mobile_number, "some_number") self.assertEqual(short_code, "ds_short_code")
def test_from_etcd_result(self): block_dict = {"10.23.24.0/24": 50, "10.23.35.0/24": 60} json_dict = { AllocationHandle.HANDLE_ID: "test_id2", AllocationHandle.BLOCK: block_dict } m_result = Mock(spec=EtcdResult) m_result.value = json.dumps(json_dict) handle = AllocationHandle.from_etcd_result(m_result) assert_dict_equal(block_dict, handle.block) assert_equal(m_result, handle.db_result) # Convert to JSON and back m_result.value = handle.to_json() handle2 = AllocationHandle.from_etcd_result(m_result) assert_equal(block_dict, handle2.block)
def test_get_vm_details(self): # Arrange image = self.mock_image() flavor = self.mock_flavor() vm = self.mock_vm() self.instance_service.get_instance_from_instance_id = Mock(return_value=vm) self.instance_service.get_image = Mock(return_value=image) self.instance_service.get_flavor = Mock(return_value=flavor) network = {'id': '300881', 'name': 'network_name_for_test', 'provider:segmentation_id': '777'} mock_client = Mock() test_neutron_network_service.neutron_client.Client = Mock(return_value=mock_client) mock_client.list_networks = Mock(return_value={'networks': [network]}) param = Mock() param.name = 'ip_regex' param.value = 'bla.*' request = Mock() request.deployedAppJson.name = 'OpenStack App for Tests' request.deployedAppJson.vmdetails.uid = '240975' request.deployedAppJson.vmdetails.vmCustomParams = [param] request.appRequestJson.deploymentService.model = 'OpenStack' request.appRequestJson.deploymentService.attributes = [Mock()] cancellation_context = Mock(is_cancelled=False) management_vlan_id = Mock() # Act result = self.vm_details_operation.get_vm_details(openstack_session=self.openstack_session, requests=[request], cancellation_context=cancellation_context, logger=Mock(), management_vlan_id=management_vlan_id) # Assert self.assertEqual(len(result), 1) vm_details = result[0] self.assertEqual(next(x.value for x in vm_details.vmInstanceData if x.key == 'Image'), 'Image Name') self.assertEqual(next(x.value for x in vm_details.vmInstanceData if x.key == 'Flavour'), 'Flavor Name') self.assertEqual(next(x.value for x in vm_details.vmInstanceData if x.key == 'Availability Zone'), 'Av Zone') self.assertEqual(next(x.value for x in vm_details.vmInstanceData if x.key == 'Disk Size'), '320 GB') self.assertEqual(next(x.value for x in vm_details.vmInstanceData if x.key == 'Memory'), '256 GB') self.assertEqual(next(x.value for x in vm_details.vmInstanceData if x.key == 'CPU'), '2 vCPU') self.assertEqual(len(vm_details.vmNetworkData), 1) nic = vm_details.vmNetworkData[0] self.assertEqual(nic.isPredefined, False) self.assertEqual(nic.networkId, '777') self.assertEqual(len(nic.networkData), 3) self.assertEqual(nic.privateIpAddress, '192.168.1.1') self.assertEqual(next(x.value for x in nic.networkData if x.key == 'IP'), '192.168.1.1') self.assertEqual(next(x.value for x in nic.networkData if x.key == 'VLAN Name'), 'network_name_for_test')
def test_get_addons_per_client(spark, df_equals): def make_addon_meta(addon_id): return Row(**dict( addon_id=addon_id, is_system=False, type="extension", user_disabled=False, app_disabled=False, foreign_install=False, )) MOCK_USERS_DF = [ Row( client_id="client-1", active_addons=[ make_addon_meta("test-guid-1"), make_addon_meta("test-guid-2"), make_addon_meta("test-guid-3"), ], ), Row( client_id="client_2", active_addons=[ make_addon_meta("test-guid-1"), make_addon_meta("test-guid-3"), ], ), Row( client_id="client_3", active_addons=[ make_addon_meta("test-guid-1"), make_addon_meta("test-guid-4"), ], ), Row( client_id="client_4", active_addons=[ make_addon_meta("test-guid-2"), make_addon_meta("test-guid-5"), make_addon_meta("test-guid-6"), ], ), Row(client_id="client_5", active_addons=[make_addon_meta("test-guid-1")]), ] test_users_df = spark.createDataFrame(MOCK_USERS_DF) mock_broadcast_amo_whitelist = Mock() mock_broadcast_amo_whitelist.value = Mock() mock_broadcast_amo_whitelist.value.__contains__ = lambda self, x: True result = taar_lite_guidguid.get_addons_per_client( mock_broadcast_amo_whitelist, test_users_df) assert len(result.collect()) > 0
def test_from_etcd_result_no_unallocated(self): """ Test the from_etcd_result processing when the allocation order is missing (this is allowed since it is a new field). """ result = Mock(spec=EtcdResult) # Build a JSON object for the Block attr0 = { AllocationBlock.ATTR_HANDLE_ID: "test_key1", AllocationBlock.ATTR_SECONDARY: { "key1": "value11", "key2": "value21" } } attr1 = { AllocationBlock.ATTR_HANDLE_ID: "test_key2", AllocationBlock.ATTR_SECONDARY: { "key1": "value12", "key2": "value22" } } allocations = [None] * BLOCK_SIZE allocations[0] = 0 allocations[1] = 0 allocations[4] = 1 json_dict = { AllocationBlock.CIDR: str(network), AllocationBlock.AFFINITY: "host:Sammy Davis, Jr.", AllocationBlock.STRICT_AFFINITY: True, AllocationBlock.ALLOCATIONS: allocations, AllocationBlock.ATTRIBUTES: [attr0, attr1] } result.value = json.dumps(json_dict) block = AllocationBlock.from_etcd_result(result) assert_equal(block.count_free_addresses(), BLOCK_SIZE - 3) assert_equal(block.db_result, result) assert_equal(block.cidr, network) assert_equal(block.host_affinity, "Sammy Davis, Jr.") assert_true(block.strict_affinity) assert_list_equal(block.allocations[:5], [0, 0, None, None, 1]) assert_dict_equal(block.attributes[0], attr0) assert_dict_equal(block.attributes[1], attr1) # Verify the allocation order is correctly calculated from the # unassigned entries. unallocated = [o for o in range(BLOCK_SIZE) if o not in (0, 1, 4)] assert_list_equal(block.unallocated, unallocated) # Verify we can get JSON back out. json_dict[AllocationBlock.UNALLOCATED] = unallocated assert_equal(json.dumps(json_dict), block.to_json())
def test_get_network(self): """ Test get_network() returns correct data. :return: """ etcd_entry = Mock() etcd_entry.value = TEST_JSON self.etcd_client.read.return_value = etcd_entry self.assertDictEqual(self.datastore.get_network(TEST_NETWORK_ID), TEST_DATA) self.etcd_client.read.assert_called_once_with(TEST_NETWORK_DIR)
def _get_registered_scheduler_driver_master(self): driver = Mock() framework_id = Mock() framework_id.value = 'framework_id' master_info = Mock() master_info.hostname = 'localhost' master_info.port = 1234 my_scheduler = scheduler.scale_scheduler.ScaleScheduler(None) my_scheduler.registered(driver,framework_id,master_info) return my_scheduler, driver, master_info
def dynamodb_resource(): """A mocked version of boto3 DynamoDB resource.""" mock_item = Mock() mock_item.value = "encrypted" mock_item.get = Mock(return_value=None) rv = {"Item": mock_item} mocked_table = Mock() mocked_table.get_item = Mock(return_value=rv) mocked = Mock() mocked.Table = Mock(return_value=mocked_table) return mocked
def test_get_keyvault_secret(self, _1): mock = Mock() mock.value = '{"client_id": "client", "client_secret": "secret"}' with patch('azure.common.credentials.ServicePrincipalCredentials.__init__', return_value=None), \ patch('azure.keyvault.v7_0.KeyVaultClient.get_secret', return_value=mock): reload(sys.modules['c7n_azure.utils']) result = get_keyvault_secret(None, 'https://testkv.vault.net/secrets/testsecret/123412') self.assertEqual(result, mock.value)
def _get_registered_scheduler_driver_master(self): driver = Mock() framework_id = Mock() framework_id.value = 'framework_id' master_info = Mock() master_info.hostname = 'localhost' master_info.port = 1234 my_scheduler = scheduler.scale_scheduler.ScaleScheduler() my_scheduler.registered(driver, framework_id, master_info) return my_scheduler, driver, master_info
def dynamodb_resource(): """Mocked boto3 DynamoDB resource.""" mock_item = Mock() mock_item.value = "encrypted" mock_item.get = Mock(return_value=None) return_value = {"Item": mock_item} mocked_table = Mock() mocked_table.get_item = Mock(return_value=return_value) mocked = Mock() mocked.Table = Mock(return_value=mocked_table) return mocked
def test_Query(self): self.db.provenance.find.return_value = ['record1'] self.setupRepo() q = Mock() field1 = Mock() field1.name = 'color' field1.value = 'red' field1.all = False q.getFields.return_value = [field1] out = self.repo.inquire(q) self.db.provenance.find.assert_called_with({'color':'red'}) self.fileFactory.fromProvenance.assert_called_with('record1')
def test_Query(self): self.db.provenance.find.return_value = ['record1'] self.setupRepo() q = Mock() field1 = Mock() field1.name = 'color' field1.value = 'red' field1.all = False q.getFields.return_value = [field1] out = self.repo.inquire(q) self.db.provenance.find.assert_called_with({'color': 'red'}) self.fileFactory.fromProvenance.assert_called_with('record1')
def test_should_return_number_of_cores_when_in_resources(self): resource_1 = Mock() resource_1.key = "weLoveCamelCase" resource_2 = Mock() resource_2.key = "numCpuCores" resource_2.value = 42 resource_3 = Mock() resource_3.key = "someOtherKey" resources = [resource_1, resource_2, resource_3] self.raw_esx.licensableResource.resource = resources self.assertEquals(self.wrapped_esx.get_number_of_cores(), 42)
def test_from_etcd_result(self): block_dict = { "10.23.24.0/24": 50, "10.23.35.0/24": 60 } json_dict = { AllocationHandle.HANDLE_ID: "test_id2", AllocationHandle.BLOCK: block_dict } m_result = Mock(spec=EtcdResult) m_result.value = json.dumps(json_dict) handle = AllocationHandle.from_etcd_result(m_result) assert_dict_equal(block_dict, handle.block) assert_equal(m_result, handle.db_result) # Convert to JSON and back m_result.value = handle.to_json() handle2 = AllocationHandle.from_etcd_result(m_result) assert_equal(block_dict, handle2.block)
def mock_read(path): result = Mock(spec=EtcdResult) if path == TEST_PROFILE_PATH: return result elif path == TEST_PROFILE_PATH + "tags": result.value = '["TAG1", "TAG2", "TAG3"]' return result elif path == TEST_PROFILE_PATH + "rules": result.value = """ { "id": "TEST", "inbound_rules": [ {"action": "allow", "src_net": "192.168.1.0/24", "src_ports": [200,2001]} ], "outbound_rules": [ {"action": "allow", "src_tag": "TEST", "src_ports": [200,2001]} ] } """ return result else: raise EtcdKeyNotFound()
def test_log_if_changed(): artifact = Mock() artifact.value = 'test' # change h.log_if_changed(artifact, 'value', 'changed', 'updated value') assert artifact.value == 'changed' assert len(AuditLogMock.logs) == 1 assert AuditLogMock.logs[0] == 'updated value' # don't change h.log_if_changed(artifact, 'value', 'changed', 'updated value') assert artifact.value == 'changed' assert len(AuditLogMock.logs) == 1 assert AuditLogMock.logs[0] == 'updated value'
def mock_read_2_pools(path): """ EtcdClient mock side effect for read with 2 IPv4 pools. """ result = Mock(spec=EtcdResult) assert path == IPV4_POOLS_PATH children = [] for i, net in enumerate(["192.168.3.0/24", "192.168.5.0/24"]): node = Mock(spec=EtcdResult) node.value = net node.key = IPV4_POOLS_PATH + str(i) children.append(node) result.children = iter(children) return result