def test_list_router_routes(self):
        t = uuidutils.generate_uuid()
        r = uuidutils.generate_uuid()

        router_path = "/tenants/%s/routers/%s" % (_ofc(t), _ofc(r))
        routes_path = router_path + "/routes"

        routes = [("10.1.1.0/24", "192.168.100.10"), ("10.2.2.0/20", "192.168.100.20")]
        data = {
            "routes": [
                {"id": self._get_route_id(route[0], route[1]), "destination": route[0], "nexthop": route[1]}
                for route in routes
            ]
        }
        self.do_request.return_value = data

        ret = self.driver.list_router_routes(router_path)
        self.do_request.assert_called_once_with("GET", routes_path)

        expected = [
            {
                "id": (routes_path + "/" + self._get_route_id(route[0], route[1])),
                "destination": route[0],
                "nexthop": route[1],
            }
            for route in routes
        ]
        self.assertEqual(len(routes), len(ret))
        self.assertEqual(data["routes"], expected)

    def test_update_router_interface(self):
        t = uuidutils.generate_uuid()
        r = uuidutils.generate_uuid()
        p = uuidutils.generate_uuid()

        router_path = "/tenants/%s/routers/%s" % (_ofc(t), _ofc(r))
        inf_path = "%s/interfaces/%s" % (router_path, _ofc(p))
        ip_address = '10.1.1.1/24'
        mac_address = '11:22:33:44:55:66'

        body = {'ip_address': ip_address,
                'mac_address': mac_address}
        ofc.OFCClient.do_request("PUT", inf_path, body=body)

        body = {'ip_address': ip_address}
        ofc.OFCClient.do_request("PUT", inf_path, body=body)

        body = {'mac_address': mac_address}
        ofc.OFCClient.do_request("PUT", inf_path, body=body)

        self.mox.ReplayAll()

        self.driver.update_router_interface(inf_path, ip_address, mac_address)
        self.driver.update_router_interface(inf_path, ip_address=ip_address)
        self.driver.update_router_interface(inf_path, mac_address=mac_address)
        self.mox.VerifyAll()

    def test_create_and_show_servicechain_instance(self):
        scs_id = self.create_servicechain_spec()['servicechain_spec']['id']
        policy_target_group_id = uuidutils.generate_uuid()
        classifier_id = uuidutils.generate_uuid()
        config_param_values = "{}"
        attrs = self._get_test_servicechain_instance_attrs(
            servicechain_spec=scs_id,
            provider_ptg_id=policy_target_group_id,
            consumer_ptg_id=policy_target_group_id,
            classifier_id=classifier_id,
            config_param_values=config_param_values)

        sci = self.create_servicechain_instance(
            servicechain_spec=scs_id,
            provider_ptg_id=policy_target_group_id,
            consumer_ptg_id=policy_target_group_id,
            classifier_id=classifier_id,
            config_param_values=config_param_values)
        for k, v in attrs.iteritems():
            self.assertEqual(sci['servicechain_instance'][k], v)

        self._test_show_resource('servicechain_instance',
                                 sci['servicechain_instance']['id'],
                                 attrs)
        req = self.new_delete_request('servicechain_instances',
                                      sci['servicechain_instance']['id'])
        req.get_response(self.ext_api)

    def create_security_group(self, context, security_group, default_sg=False):
        """Create security group.

        If default_sg is true that means we are a default security group for
        a given tenant if it does not exist.
        """
        s = security_group["security_group"]
        kwargs = {"context": context, "security_group": s, "is_default": default_sg}
        # NOTE(armax): a callback exception here will prevent the request
        # from being processed. This is a hook point for backend's validation;
        # we raise to propagate the reason for the failure.
        try:
            registry.notify(resources.SECURITY_GROUP, events.BEFORE_CREATE, self, **kwargs)
        except exceptions.CallbackFailure as e:
            raise ext_sg.SecurityGroupConflict(reason=e)

        tenant_id = self._get_tenant_id_for_create(context, s)

        if not default_sg:
            self._ensure_default_security_group(context, tenant_id)

        with context.session.begin(subtransactions=True):
            security_group_db = SecurityGroup(
                id=s.get("id") or (uuidutils.generate_uuid()),
                description=s["description"],
                tenant_id=tenant_id,
                name=s["name"],
            )
            context.session.add(security_group_db)
            if default_sg:
                context.session.add(
                    DefaultSecurityGroup(security_group=security_group_db, tenant_id=security_group_db["tenant_id"])
                )
            for ethertype in ext_sg.sg_supported_ethertypes:
                if default_sg:
                    # Allow intercommunication
                    ingress_rule = SecurityGroupRule(
                        id=uuidutils.generate_uuid(),
                        tenant_id=tenant_id,
                        security_group=security_group_db,
                        direction="ingress",
                        ethertype=ethertype,
                        source_group=security_group_db,
                    )
                    context.session.add(ingress_rule)

                egress_rule = SecurityGroupRule(
                    id=uuidutils.generate_uuid(),
                    tenant_id=tenant_id,
                    security_group=security_group_db,
                    direction="egress",
                    ethertype=ethertype,
                )
                context.session.add(egress_rule)

        secgroup_dict = self._make_security_group_dict(security_group_db)

        kwargs["security_group"] = secgroup_dict
        registry.notify(resources.SECURITY_GROUP, events.AFTER_CREATE, self, **kwargs)
        return secgroup_dict

    def test_update_servicechain_instance(self):
        name = "new_servicechain_instance"
        description = 'new desc'
        config_param_values = "{}"
        scs_id = self.create_servicechain_spec()['servicechain_spec']['id']
        provider_ptg_id = uuidutils.generate_uuid()
        consumer_ptg_id = uuidutils.generate_uuid()
        classifier_id = uuidutils.generate_uuid()
        attrs = self._get_test_servicechain_instance_attrs(
            name=name, description=description, servicechain_spec=scs_id,
            provider_ptg_id=provider_ptg_id, consumer_ptg_id=consumer_ptg_id,
            classifier_id=classifier_id,
            config_param_values=config_param_values)

        sci = self.create_servicechain_instance(
            servicechain_spec=scs_id, provider_ptg_id=provider_ptg_id,
            consumer_ptg_id=consumer_ptg_id, classifier_id=classifier_id,
            config_param_values=config_param_values)
        data = {'servicechain_instance': {'name': name,
                                          'description': description,
                                          'servicechain_spec': scs_id}}
        req = self.new_update_request('servicechain_instances', data,
                                      sci['servicechain_instance']['id'])
        res = self.deserialize(self.fmt, req.get_response(self.ext_api))
        for k, v in attrs.iteritems():
            self.assertEqual(res['servicechain_instance'][k], v)

        self._test_show_resource('servicechain_instance',
                                 sci['servicechain_instance']['id'], attrs)
        req = self.new_delete_request('servicechain_instances',
                                      sci['servicechain_instance']['id'])
        req.get_response(self.ext_api)

    def create_qos(self, context, qos):
        """ Create a qos and its default queue. """
        qos = qos['qos']
        default_queue = self._extract_default_queue_from_qos_param(qos)

        if qos['rate'] < default_queue['rate']:
            raise ext_qos.QosRateTooSmall(id=None, rate=qos['rate'])
        qos_target = self._check_qos_target(
            context, qos['target_type'], qos['target_id'], qos['direction'])

        tenant_id = self._get_tenant_id_for_create(context, qos)
        qos_id = qos.get('id', uuidutils.generate_uuid())
        default_queue_id = uuidutils.generate_uuid()

        with context.session.begin(subtransactions=True):
            qos_db = Qos(
                id=qos_id, tenant_id=tenant_id,
                name=qos['name'], description=qos['description'],
                direction=qos['direction'],
                port_id=qos_target['port_id'],
                router_id=qos_target['router_id'],
                rate=qos['rate'], burst=qos['burst'], cburst=qos['cburst'],
                default_queue_id=default_queue_id)
            qos_queue_db = QosQueue(
                id=default_queue_id, tenant_id=tenant_id,
                qos_id=qos_id, parent_id=None, prio=7,
                rate=default_queue['rate'], ceil=default_queue['ceil'],
                burst=default_queue['burst'], cburst=default_queue['cburst'])
            context.session.add(qos_db)
            context.session.add(qos_queue_db)

        return self._make_qos_dict(qos_db)

 def create_net_partition(self, params):
     fake_net_partition = {
         'nuage_entid': uuidutils.generate_uuid(),
         'l3dom_id': uuidutils.generate_uuid(),
         'l2dom_id': uuidutils.generate_uuid(),
     }
     return fake_net_partition

    def test_create_for_sg_rule(self):
        sg_id = uuidutils.generate_uuid()
        sg_name = 'test-sg'
        in_chain_id = uuidutils.generate_uuid()
        out_chain_id = uuidutils.generate_uuid()
        self.mock_api_cfg.chains_in = [
            _create_test_sg_in_chain(sg_id, sg_name, in_chain_id,
                                     self._tenant_id),
            _create_test_sg_out_chain(sg_id, sg_name, out_chain_id,
                                      self._tenant_id)]

        sg_rule_id = uuidutils.generate_uuid()
        sg_rule = _create_test_sg_rule(self._tenant_id, sg_id, sg_rule_id)

        props = {"os_sg_rule_id": sg_rule_id}
        calls = [mock.call.add_rule().port_group(None).type(
            'accept').nw_proto(6).nw_src_address(
                '192.168.1.0').nw_src_length(24).tp_src_start(
                    None).tp_src_end(None).tp_dst_start(1).tp_dst_end(
                        65535).properties(props).create()]

        self.client.create_for_sg_rule(sg_rule)

        # Egress chain rule added
        self.mock_api_cfg.chains_out[0].assert_has_calls(calls)

    def test_create_and_show_servicechain_instance(self):
        scs_id = self.create_servicechain_spec()["servicechain_spec"]["id"]
        policy_target_group_id = uuidutils.generate_uuid()
        classifier_id = uuidutils.generate_uuid()
        config_param_values = "{}"
        attrs = cm.get_create_servicechain_instance_default_attrs(
            servicechain_specs=[scs_id],
            provider_ptg_id=policy_target_group_id,
            consumer_ptg_id=policy_target_group_id,
            management_ptg_id=policy_target_group_id,
            classifier_id=classifier_id,
            config_param_values=config_param_values,
        )

        sci = self.create_servicechain_instance(
            servicechain_specs=[scs_id],
            provider_ptg_id=policy_target_group_id,
            consumer_ptg_id=policy_target_group_id,
            management_ptg_id=policy_target_group_id,
            classifier_id=classifier_id,
            config_param_values=config_param_values,
        )
        for k, v in attrs.iteritems():
            self.assertEqual(v, sci["servicechain_instance"][k])

        self._test_show_resource("servicechain_instance", sci["servicechain_instance"]["id"], attrs)
        req = self.new_delete_request("servicechain_instances", sci["servicechain_instance"]["id"])
        req.get_response(self.ext_api)

    def test_delete_router(self):
        t = uuidutils.generate_uuid()
        r = uuidutils.generate_uuid()

        router_path = "/tenants/%s/routers/%s" % (_ofc(t), _ofc(r))

        self.driver.delete_router(router_path)
        self.do_request.assert_called_once_with("DELETE", router_path)

 def test_delete_neutron_ports(self):
     port1 = ovs_lib.VifPort("tap1234", 1, uuidutils.generate_uuid(), "ca:fe:de:ad:be:ef", "br")
     port2 = ovs_lib.VifPort("tap5678", 2, uuidutils.generate_uuid(), "ca:ee:de:ad:be:ef", "br")
     with mock.patch.object(self.br, "get_vif_ports", return_value=[port1, port2]) as get_ports:
         with mock.patch.object(self.br, "delete_port") as delete_port:
             self.br.delete_ports(all_ports=False)
     get_ports.assert_called_once_with()
     delete_port.assert_has_calls([mock.call("tap1234"), mock.call("tap5678")])

 def test_get_nsx_switch_and_port_id_from_db_mappings(self):
     # This test is representative of the 'standard' case in which both the
     # switch and the port mappings were stored in the neutron db
     exp_ls_uuid = uuidutils.generate_uuid()
     exp_lp_uuid = uuidutils.generate_uuid()
     ret_value = exp_ls_uuid, exp_lp_uuid
     self._mock_port_mapping_db_calls(ret_value)
     self._verify_get_nsx_switch_and_port_id(exp_ls_uuid, exp_lp_uuid)

 def create_router(self, neutron_router, router, params):
     nuage_router = {
         'nuage_userid': uuidutils.generate_uuid(),
         'nuage_groupid': uuidutils.generate_uuid(),
         'nuage_domain_id': uuidutils.generate_uuid(),
         'nuage_def_zone_id': uuidutils.generate_uuid(),
     }
     return nuage_router

 def get_ofc_item_random_params(self):
     """create random parameters for ofc_item test."""
     tenant_id = uuidutils.generate_uuid()
     network_id = uuidutils.generate_uuid()
     port_id = uuidutils.generate_uuid()
     mac = ":".join(["%x" % random.randint(0, 255) for i in moves.xrange(6)])
     portinfo = nmodels.PortInfo(id=port_id, datapath_id="0x123456789", port_no=1234, vlan_id=321, mac=mac)
     return tenant_id, network_id, portinfo

 def create_subnet(self, neutron_subnet, params):
     nuage_subnet = {
         'nuage_l2template_id': uuidutils.generate_uuid(),
         'nuage_userid': uuidutils.generate_uuid(),
         'nuage_groupid': uuidutils.generate_uuid(),
         'nuage_l2domain_id': uuidutils.generate_uuid()
     }
     return nuage_subnet

 def get_random_params(self):
     """create random parameters for portinfo test."""
     tenant = uuidutils.generate_uuid()
     network = uuidutils.generate_uuid()
     port = uuidutils.generate_uuid()
     _filter = uuidutils.generate_uuid()
     none = uuidutils.generate_uuid()
     return tenant, network, port, _filter, none

 def get_def_netpartition_data(self, default_net_part):
     if default_net_part == 'default_test_np':
         fake_defnetpart_data = {
             'np_id': uuidutils.generate_uuid(),
             'l3dom_tid': uuidutils.generate_uuid(),
             'l2dom_tid': uuidutils.generate_uuid(),
         }
         return fake_defnetpart_data

 def test_redirect_to_chain(self):
     classifier = self.create_policy_classifier(
         name="class1", protocol="tcp", direction="in", port_range="20:90")
     classifier_id = classifier['policy_classifier']['id']
     action = self.create_policy_action(
         name="action1", action_type=gconst.GP_ACTION_REDIRECT,
         action_value=uuidutils.generate_uuid())
     action_id = action['policy_action']['id']
     action_id_list = [action_id]
     policy_rule = self.create_policy_rule(
         name='pr1', policy_classifier_id=classifier_id,
         policy_actions=action_id_list)
     policy_rule_id = policy_rule['policy_rule']['id']
     policy_rule_list = [policy_rule_id]
     policy_rule_set = self.create_policy_rule_set(
         name="c1", policy_rules=policy_rule_list)
     policy_rule_set_id = policy_rule_set['policy_rule_set']['id']
     self.create_policy_target_group(
         name="ptg1", provided_policy_rule_sets={policy_rule_set_id: None})
     create_chain_instance = mock.patch.object(
         servicechain_plugin.ServiceChainPlugin,
         'create_servicechain_instance')
     create_chain_instance = create_chain_instance.start()
     chain_instance_id = uuidutils.generate_uuid()
     create_chain_instance.return_value = {'id': chain_instance_id}
     # TODO(Magesh):Add tests which verifies that provide/consumer PTGs
     # are set correctly for the SCI
     with mock.patch.object(
             resource_mapping.ResourceMappingDriver,
             '_set_rule_servicechain_instance_mapping') as set_rule:
         with mock.patch.object(servicechain_db.ServiceChainDbPlugin,
                                'get_servicechain_spec') as sc_spec_get:
             sc_spec_get.return_value = {'servicechain_spec': {}}
             consumer_ptg = self.create_policy_target_group(
                 name="ptg2",
                 consumed_policy_rule_sets={policy_rule_set_id: None})
             consumer_ptg_id = consumer_ptg['policy_target_group']['id']
             set_rule.assert_called_once_with(mock.ANY, policy_rule_id,
                                              chain_instance_id)
     with mock.patch.object(servicechain_plugin.ServiceChainPlugin,
                            'delete_servicechain_instance'):
         with mock.patch.object(
             resource_mapping.ResourceMappingDriver,
             '_get_rule_servicechain_mapping') as get_rule:
             r_sc_map = resource_mapping.RuleServiceChainInstanceMapping()
             r_sc_map.rule_id = policy_rule_id
             r_sc_map.servicechain_instance_id = chain_instance_id
             get_rule.return_value = r_sc_map
             get_chain_inst = mock.patch.object(
                 servicechain_db.ServiceChainDbPlugin,
                 'get_servicechain_instance')
             get_chain_inst.start()
             get_chain_inst.return_value = {
                 "servicechain_instance": {'id': chain_instance_id}}
             req = self.new_delete_request(
                 'policy_target_groups', consumer_ptg_id)
             res = req.get_response(self.ext_api)
             self.assertEqual(res.status_int, webob.exc.HTTPNoContent.code)

 def get_ofc_item_random_params(self):
     """create random parameters for ofc_item test."""
     tenant_id = uuidutils.generate_uuid()
     network_id = uuidutils.generate_uuid()
     port_id = uuidutils.generate_uuid()
     portinfo = nmodels.PortInfo(id=port_id, datapath_id="0x123456789",
                                 port_no=1234, vlan_id=321,
                                 mac="11:22:33:44:55:66")
     return tenant_id, network_id, portinfo

 def test_router_create_with_nuage_rtr_template(self):
     nuage_rtr_template = uuidutils.generate_uuid()
     data = {"router": {"tenant_id": uuidutils.generate_uuid()}}
     data["router"]["name"] = "router1"
     data["router"]["admin_state_up"] = True
     data["router"]["nuage_router_template"] = nuage_rtr_template
     router_req = self.new_create_request("routers", data, "json")
     router_res = router_req.get_response(self.ext_api)
     self.assertEqual(exc.HTTPCreated.code, router_res.status_int)