def test_normal(
            self, device_option, rate, direction, delay, delay_distro, loss, corrupt,
            network, port):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            direction=direction,
            bandwidth_rate=rate,
            latency_ms=delay,
            latency_distro_ms=delay_distro,
            packet_loss_rate=loss,
            corruption_rate=corrupt,
            network=network,
            port=port,
            src_network=None,
            is_enable_iptables=True,
        )

        params = [
            rate,
            delay,
            loss,
            corrupt,
        ]
        is_invalid = all([
            not FloatType(param).is_type() or param == 0 for param in params
        ])

        if is_invalid:
            with pytest.raises(ValueError):
                tc_obj.validate()
        else:
            tc_obj.validate()
示例#2
0
    def test_exception(self, device_option, value, expected):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            netem_param=NetemParameter(
                device=device_option,
                bandwidth_rate=value.get("bandwidth_rate"),
                latency_time=value.get("latency_time",
                                       Tc.ValueRange.LatencyTime.MIN),
                latency_distro_time=value.get("latency_distro_time",
                                              Tc.ValueRange.LatencyTime.MIN),
                packet_loss_rate=value.get("packet_loss_rate"),
                packet_duplicate_rate=value.get("packet_duplicate_rate"),
                corruption_rate=value.get("corruption_rate"),
            ),
            dst_network=value.get(Tc.Param.DST_NETWORK),
            src_port=value.get("src_port"),
            dst_port=value.get("dst_port"),
            shaping_algorithm=ShapingAlgorithm.HTB,
        )

        with pytest.raises(expected):
            tc_obj.validate()
示例#3
0
def test_TrafficControl_validate_bandwidth_rate_normal(value):
    tc_obj = TrafficControl(
        "dummy",
        bandwidth_rate=value,
        direction=TrafficDirection.OUTGOING,
        shaping_algorithm=ShapingAlgorithm.HTB,
    )
    tc_obj.validate_bandwidth_rate()
示例#4
0
def test_TrafficControl_validate_bandwidth_rate_exception_2(value, expected):
    with pytest.raises(expected):
        tc_obj = TrafficControl(
            "dummy",
            bandwidth_rate=value,
            latency_time=Tc.ValueRange.LatencyTime.MIN,
            latency_distro_time=Tc.ValueRange.LatencyTime.MIN,
            shaping_algorithm=ShapingAlgorithm.HTB)
        tc_obj.validate_bandwidth_rate()
示例#5
0
    def test_normal_reordering(
            self, device_option, direction, delay, reordering):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            direction=direction,
            latency_ms=delay,
            reordering_rate=reordering,
        )

        tc_obj.validate()
示例#6
0
    def test_normal_reordering(self, device_option, direction, delay, reordering):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            direction=direction,
            latency_time=delay,
            latency_distro_time=Tc.ValueRange.LatencyTime.MIN,
            reordering_rate=reordering,
            shaping_algorithm=ShapingAlgorithm.HTB,
        )

        tc_obj.validate()
示例#7
0
    def test_normal(
        self,
        device_option,
        network,
        is_ipv6,
        expected_ip_ver,
        expected_protocol,
        expected_protocol_match,
    ):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            netem_param=NetemParameter(
                device=device_option,
                latency_time=Tc.ValueRange.LatencyTime.MIN,
                latency_distro_time=Tc.ValueRange.LatencyTime.MIN,
            ),
            dst_network=network,
            is_ipv6=is_ipv6,
            shaping_algorithm=ShapingAlgorithm.HTB,
        )

        assert tc_obj.ip_version == expected_ip_ver
        assert tc_obj.protocol == expected_protocol
        assert tc_obj.protocol_match == expected_protocol_match
    def test_exception(self, device_option, value, expected):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            bandwidth_rate=value.get("bandwidth_rate"),
            latency_ms=value.get("latency_ms"),
            latency_distro_ms=value.get("latency_distro_ms"),
            packet_loss_rate=value.get("packet_loss_rate"),
            corruption_rate=value.get("curruption_rate"),
            network=value.get("network"),
            port=value.get("port"),
        )

        with pytest.raises(expected):
            tc_obj.validate()
示例#9
0
    def test_exception(self, device_option, value, expected):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            bandwidth_rate=value.get("bandwidth_rate"),
            latency_ms=value.get("latency_ms"),
            latency_distro_ms=value.get("latency_distro_ms"),
            packet_loss_rate=value.get("packet_loss_rate"),
            corruption_rate=value.get("corruption_rate"),
            network=value.get("network"),
            port=value.get("port"),
        )

        with pytest.raises(expected):
            tc_obj.validate()
示例#10
0
    def test_normal(
            self, device_option, network, is_ipv6,
            expected_ip_ver, expected_protocol, expected_protocol_match):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option, dst_network=network, is_ipv6=is_ipv6)

        assert tc_obj.ip_version == expected_ip_ver
        assert tc_obj.protocol == expected_protocol
        assert tc_obj.protocol_match == expected_protocol_match
示例#11
0
    def test_normal(
            self, device_option, rate, direction, delay, delay_distro,
            loss, duplicate, corrupt, network, src_port, dst_port):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            direction=direction,
            bandwidth_rate=rate,
            latency_ms=delay,
            latency_distro_ms=delay_distro,
            packet_loss_rate=loss,
            packet_duplicate_rate=duplicate,
            corruption_rate=corrupt,
            dst_network=network,
            src_port=src_port,
            dst_port=dst_port,
            src_network=None,
            is_enable_iptables=True,
        )

        if is_invalid_param(
                rate, delay, loss, duplicate, corrupt, reordering=None):
            with pytest.raises(ValueError):
                tc_obj.validate()
        else:
            tc_obj.validate()
示例#12
0
def test_TrafficControl_validate_bandwidth_rate_exception_1(value, expected):
    with pytest.raises(expected):
        tc_obj = TrafficControl(
            "dummy",
            netem_param=NetemParameter(
                "dummy",
                bandwidth_rate=value,
                latency_time=Tc.ValueRange.LatencyTime.MIN,
                latency_distro_time=Tc.ValueRange.LatencyTime.MIN,
            ),
            direction=TrafficDirection.OUTGOING,
            shaping_algorithm=ShapingAlgorithm.HTB,
        )
        tc_obj.netem_param.validate_bandwidth_rate()
示例#13
0
    def test_normal(
        self,
        device_option,
        rate,
        direction,
        delay,
        delay_distro,
        loss,
        duplicate,
        corrupt,
        src_network,
        exclude_src_network,
        dst_network,
        exclude_dst_network,
        src_port,
        exclude_src_port,
        dst_port,
        exclude_dst_port,
        shaping_algorithm,
    ):
        if device_option is None:
            pytest.skip("device option is null")

        tc_obj = TrafficControl(
            device=device_option,
            direction=direction,
            netem_param=NetemParameter(
                device=device_option,
                bandwidth_rate=rate,
                latency_time=delay,
                latency_distro_time=delay_distro,
                packet_loss_rate=loss,
                packet_duplicate_rate=duplicate,
                corruption_rate=corrupt,
            ),
            src_network=src_network,
            exclude_src_network=exclude_src_network,
            dst_network=dst_network,
            exclude_dst_network=exclude_dst_network,
            src_port=src_port,
            exclude_src_port=exclude_src_port,
            dst_port=dst_port,
            exclude_dst_port=exclude_dst_port,
            is_enable_iptables=True,
            shaping_algorithm=shaping_algorithm,
        )

        if is_invalid_param(rate,
                            delay,
                            loss,
                            duplicate,
                            corrupt,
                            reordering=None):
            with pytest.raises(ParameterError):
                tc_obj.validate()
        else:
            tc_obj.validate()
示例#14
0
def test_TrafficControl_validate_bandwidth_rate_exception_1(value, expected):
    with pytest.raises(expected):
        tc_obj = TrafficControl(
            "dummy", bandwidth_rate=value, direction=TrafficDirection.OUTGOING)
        tc_obj.validate_bandwidth_rate()
示例#15
0
def test_TrafficControl_validate_bandwidth_rate_exception_2(value, expected):
    #tc_obj.bandwidth_rate = value
    tc_obj = TrafficControl("dummy", bandwidth_rate=value)
    with pytest.raises(expected):
        tc_obj._TrafficControl__validate_bandwidth_rate()
示例#16
0
def test_TrafficControl_validate_bandwidth_rate_normal(value):
    tc_obj = TrafficControl("dummy", bandwidth_rate=value)
    tc_obj._TrafficControl__validate_bandwidth_rate()
示例#17
0
    def test_normal(self, device_value):
        if device_value is None:
            pytest.skip("device option is null")

        delete_all_rules(device_value)

        tc = TrafficControl(
            device=device_value,
            shaping_algorithm="htb",
            direction=TrafficDirection.INCOMING,
            netem_param=NetemParameter(
                device=device_value,
                bandwidth_rate="200kbps",
                packet_loss_rate=0,
                packet_duplicate_rate=0,
                corruption_rate=0,
                reordering_rate=0,
            ),
            src_network="192.168.3.188",
            dst_port=5201,
        )
        assert tc.set_shaping_rule() == 0

        tc = TrafficControl(
            device=device_value,
            shaping_algorithm="htb",
            direction=TrafficDirection.OUTGOING,
            netem_param=NetemParameter(
                device=device_value,
                bandwidth_rate="1000000kbps",
                packet_loss_rate=0,
                packet_duplicate_rate=0,
                corruption_rate=0,
                reordering_rate=0,
            ),
            dst_network="192.168.3.188",
        )
        assert tc.set_shaping_rule() == 0

        result = tcconfig.parser.shaping_rule.TcShapingRuleParser(
            device=device_value,
            ip_version=4,
            logger=NullLogger(),
            tc_command_output=None,
            is_parse_filter_id=False,
        ).get_tc_parameter()
        expected = json.loads(
            """\
            {
                "enp0s3": {
                    "outgoing": {
                        "dst-network=192.168.3.188/32, protocol=ip": {
                            "rate": "1Gbps"
                        }
                    },
                    "incoming": {
                        "src-network=192.168.3.188/32, dst-port=5201, protocol=ip": {
                            "rate": "200Kbps"
                        }
                    }
                }
            }
            """
        )

        print_test_result(expected=expected, actual=result)
        assert result == expected
示例#18
0
def test_TrafficControl_validate_bandwidth_rate_normal(value):
    tc_obj = TrafficControl(
        "dummy", bandwidth_rate=value, direction=TrafficDirection.OUTGOING)
    tc_obj.validate_bandwidth_rate()
示例#19
0
def test_TrafficControl_validate_bandwidth_rate_exception_2(value, expected):
    tc_obj = TrafficControl("dummy", bandwidth_rate=value)
    with pytest.raises(expected):
        tc_obj.validate_bandwidth_rate()
示例#20
0
def test_TrafficControl_validate_bandwidth_rate_normal(value):
    tc_obj = TrafficControl("dummy", bandwidth_rate=value)
    tc_obj.validate_bandwidth_rate()