示例#1
0
    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'
        })
示例#2
0
    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")]))
示例#3
0
    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')
示例#4
0
    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')
示例#5
0
    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
示例#10
0
	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')
示例#11
0
    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)
示例#12
0
 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)
示例#13
0
 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)
示例#14
0
 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))
示例#15
0
    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()
示例#17
0
 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)
示例#18
0
    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)
示例#19
0
    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()
示例#20
0
    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()
示例#21
0
 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)
示例#22
0
    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_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")
示例#24
0
    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)
示例#25
0
    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)
示例#26
0
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
示例#27
0
    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)])
示例#28
0
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
示例#29
0
    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]
示例#30
0
 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)
示例#31
0
 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)
示例#32
0
    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]
示例#33
0
 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"])
示例#34
0
    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)
示例#35
0
 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)
示例#37
0
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
示例#38
0
 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)
示例#39
0
 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)
示例#40
0
    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")
示例#41
0
    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
示例#44
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)
示例#46
0
    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
示例#47
0
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
示例#48
0
    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)
示例#49
0
    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
示例#50
0
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
示例#51
0
 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')
示例#52
0
 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')
示例#53
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_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)
示例#55
0
    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)
示例#56
0
        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()
示例#57
0
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'
示例#58
0
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