build.tests.helpers

Complexity

Total Complexity

8

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Importance

Changes

0

7 Functions

Rating	Name	Duplication	Size	Complexity
A	get_link_mock()	0	7	1
A	get_controller_mock()	0	6	1
A	get_interface_mock()	0	10	1
A	get_topology_mock()	0	32	1
A	get_connection_mock()	0	10	1
A	get_switch_mock()	0	8	2
A	get_test_client()	0	4	1

"""Module to help to create tests."""
from unittest.mock import MagicMock, Mock, create_autospec

from kytos.core import Controller
from kytos.core.config import KytosConfig
from kytos.core.connection import (Connection, ConnectionProtocol,
                                   ConnectionState)
from kytos.core.interface import Interface
from kytos.core.link import Link
from kytos.core.switch import Switch


def get_controller_mock():
    """Return a controller mock."""
    options = KytosConfig().options['daemon']
    controller = Controller(options)
    controller.log = Mock()
    return controller


def get_interface_mock(name, port_number, switch):
    """Return a interface mock."""
    interface = create_autospec(Interface)
    interface.id = "{}:{}".format(switch.dpid, port_number)
    interface.name = name
    interface.port_number = port_number
    interface.switch = switch
    interface.address = "00:00:00:00:00:00"
    interface.lldp = True
    return interface


def get_link_mock(endpoint_a, endpoint_b):
    """Return a link mock."""
    link = create_autospec(Link)
    link.endpoint_a = endpoint_a
    link.endpoint_b = endpoint_b
    link.metadata = {"A": 0}
    return link


def get_switch_mock(dpid, of_version=None):
    """Return a switch mock."""
    switch = create_autospec(Switch)
    switch.dpid = dpid
    if of_version:
        switch.connection = get_connection_mock(of_version, switch)
        switch.ofp_version = '0x0' + str(of_version)
    return switch


def get_connection_mock(of_version, switch, state=ConnectionState.NEW):
    """Return a connection mock."""
    protocol = create_autospec(ConnectionProtocol)
    protocol.version = of_version
    connection = create_autospec(Connection)
    connection.protocol = protocol
    connection.switch = switch
    connection.address = "00:00:00:00:00:00"
    connection.state = state
    return connection


def get_topology_mock():
    """Create a default topology."""
    switch_a = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
    switch_b = get_switch_mock("00:00:00:00:00:00:00:02", 0x04)
    switch_c = get_switch_mock("00:00:00:00:00:00:00:03", 0x01)

    interface_a1 = get_interface_mock("s1-eth1", 1, switch_a)
    interface_a2 = get_interface_mock("s1-eth2", 2, switch_a)

    interface_b1 = get_interface_mock("s2-eth1", 1, switch_b)
    interface_b2 = get_interface_mock("s2-eth2", 2, switch_b)

    interface_c1 = get_interface_mock("s3-eth1", 1, switch_c)
    interface_c2 = get_interface_mock("s3-eth2", 2, switch_c)

    switch_a.interfaces = {interface_a1.id: interface_a1,
                           interface_a2.id: interface_a2}
    switch_b.interfaces = {interface_b1.id: interface_b1,
                           interface_b2.id: interface_b2}
    switch_c.interfaces = {interface_c1.id: interface_c1,
                           interface_c2.id: interface_c2}

    link_1 = get_link_mock(interface_a1, interface_b1)
    link_2 = get_link_mock(interface_a2, interface_c1)
    link_3 = get_link_mock(interface_b1, interface_c2)

    topology = MagicMock()
    topology.links = {"1": link_1, "2": link_2, "3": link_3}
    topology.switches = {switch_a.dpid: switch_a,
                         switch_b.dpid: switch_b,
                         switch_c.dpid: switch_c}
    return topology


def get_test_client(controller, napp):
    """Return a flask api test client."""
    controller.api_server.register_napp_endpoints(napp)
    return controller.api_server.app.test_client()