Ejemplo n.º 1
0
                    expect(lambda: self.api.get_interface(self.intf.id)).to(raise_api_exception(404))
                    self.cleanup = None

            with description('non-existent interface,'):
                with it('succeeds'):
                    self.api.delete_interface('foo')

            with description('invalid interface ID,'):
                with it('returns 400'):
                    expect(lambda: self.api.delete_interface("Invalid_d")).to(raise_api_exception(404))

        with description('bulk-create,'):
            with description('IPv4 protocol,'):
                with description('static,'):
                    with before.each:
                        self.intfs = [ ipv4_interface(self.api.api_client, ipv4_address='192.0.2.{}'.format(i+1)) for i in range(BULK_OP_SIZE) ]

                    with description('valid interfaces,'):
                        with it('succeeds'):
                            resp = self.api.bulk_create_interfaces(client.models.BulkCreateInterfacesRequest(self.intfs))
                            expect(resp.items).to(have_len(len(self.intfs)))
                            for intf in resp.items:
                                expect(intf).to(be_valid_interface)
                            self.cleanup = resp.items

                    with description('single invalid interface,'):
                        with before.each:
                            self.intfs[-1].config.protocols[1].ipv4.static.gateway='10.0.0.1'

                        with it('returns 400 with no new interfaces'):
                            expect(lambda: self.api.bulk_create_interfaces(client.models.BulkCreateInterfacesRequest(self.intfs))).to(raise_api_exception(400))
Ejemplo n.º 2
0
                                    gen = packet_generator_model(
                                        self.api.api_client)
                                    gen.config.traffic[0].packet = template
                                    gen.config.traffic[
                                        0].signature = client.models.SpirentSignature(
                                            stream_id=1,
                                            latency='start_of_frame')
                                    expect(lambda: self.api.
                                           create_packet_generator(gen)).to(
                                               raise_api_exception(400))

            with description('attached to interface, '):
                with before.each:
                    self.intf1 = ipv4_interface(
                        self.intf_api.api_client,
                        method="static",
                        ipv4_address="192.168.22.10",
                        gateway="192.168.22.1",
                        mac_address="aa:bb:cc:dd:ee:01")
                    self.intf1.target_id = get_first_port_id(
                        self.api.api_client)
                    self.intf1.id = "interface-one"
                    intf1_impl = self.intf_api.create_interface(self.intf1)

                    self.target_ip = "192.168.22.1"
                    self.target_mac = "aa:bb:cc:dd:ee:20"
                    self.intf2 = ipv4_interface(self.intf_api.api_client,
                                                method="static",
                                                ipv4_address=self.target_ip,
                                                mac_address=self.target_mac)
                    self.intf2.port_id = get_second_port_id(
                        self.api.api_client)
Ejemplo n.º 3
0
            with description('non-existent interface,'):
                with it('succeeds'):
                    self.api.delete_interface('foo')

            with description('invalid interface ID,'):
                with it('returns 400'):
                    expect(lambda: self.api.delete_interface("Invalid_d")).to(
                        raise_api_exception(404))

        with description('bulk-create,'):
            with description('IPv4 protocol,'):
                with description('static,'):
                    with before.each:
                        self.intfs = [
                            ipv4_interface(self.api.api_client,
                                           ipv4_address='192.0.2.{}'.format(i +
                                                                            1))
                            for i in range(BULK_OP_SIZE)
                        ]

                    with description('valid interfaces,'):
                        with it('succeeds'):
                            resp = self.api.bulk_create_interfaces(
                                client.models.BulkCreateInterfacesRequest(
                                    self.intfs))
                            expect(resp.items).to(have_len(len(self.intfs)))
                            for intf in resp.items:
                                expect(intf).to(be_valid_interface)
                            self.cleanup = resp.items

                    with description('single invalid interface,'):
Ejemplo n.º 4
0
            self.ana_api = client.api.PacketAnalyzersApi(service.client())
            self.gen_api = client.api.PacketGeneratorsApi(service.client())
            self.intf_api = client.api.InterfacesApi(service.client())
            if not check_modules_exists(service.client(), 'packet-generator',
                                        'packet-analyzer'):
                self.skip()

        with description('packet-generator, '):
            with description('IPv4, '):
                with before.each:
                    self.source_ip = "192.168.22.10"
                    self.source_mac = "aa:bb:cc:dd:ee:01"
                    self.target_ip = "192.168.22.1"
                    self.intf1 = ipv4_interface(self.intf_api.api_client,
                                                method="static",
                                                ipv4_address=self.source_ip,
                                                gateway=self.target_ip,
                                                mac_address=self.source_mac)
                    self.intf1.target_id = get_first_port_id(
                        self.intf_api.api_client)
                    self.intf1.id = "interface-one"
                    self.intf_api.create_interface(self.intf1)

                    self.target_mac = "aa:bb:cc:dd:ee:20"
                    self.intf2 = ipv4_interface(self.intf_api.api_client,
                                                method="static",
                                                ipv4_address=self.target_ip,
                                                mac_address=self.target_mac)
                    self.intf2.port_id = get_second_port_id(
                        self.intf_api.api_client)
                    self.intf2.id = "interface-two"