import unittest

from lib.shared_network import (
    garantir_shared_network,
    conectar_container_shared_network,
    desconectar_container_shared_network,
    obter_ip_container_shared_network,
)


class ResultadoFake:
    def __init__(self, codigo_retorno=0, saida=""):
        self.codigo_retorno = codigo_retorno
        self.saida = saida


class ClienteLinuxFake:
    def __init__(self, respostas=None):
        self.respostas = list(respostas or [])
        self.comandos = []

    def executar_comando(self, comando, disparar_excecao_se_retorno_nao_zero=True, echoar=True, descricao=""):
        self.comandos.append(comando)

        if self.respostas:
            return self.respostas.pop(0)

        return ResultadoFake()


class TestSharedNetwork(unittest.TestCase):
    def test_garantir_shared_network_executa_comando_da_rede(self):
        cliente_linux = ClienteLinuxFake()

        garantir_shared_network(cliente_linux)

        self.assertEqual(
            cliente_linux.comandos,
            ["docker network inspect shared_net >/dev/null 2>&1 || docker network create shared_net"]
        )

    def test_conectar_container_shared_network_reinicia_container(self):
        cliente_linux = ClienteLinuxFake(
            respostas=[
                ResultadoFake(codigo_retorno=0),
                ResultadoFake(codigo_retorno=0),
                ResultadoFake(codigo_retorno=0),
            ]
        )

        conectou = conectar_container_shared_network(
            cliente_linux,
            "proxy-apienterprise",
            reiniciar_apos_conexao=True
        )

        self.assertTrue(conectou)
        self.assertEqual(
            cliente_linux.comandos,
            [
                "docker inspect proxy-apienterprise >/dev/null 2>&1",
                "docker network connect shared_net proxy-apienterprise",
                "docker restart proxy-apienterprise",
            ]
        )

    def test_desconectar_container_shared_network_desconecta_container(self):
        cliente_linux = ClienteLinuxFake(
            respostas=[
                ResultadoFake(codigo_retorno=0),
                ResultadoFake(codigo_retorno=0),
            ]
        )

        desconectou = desconectar_container_shared_network(
            cliente_linux,
            "proxy-apienterprise"
        )

        self.assertTrue(desconectou)
        self.assertEqual(
            cliente_linux.comandos,
            [
                "docker inspect proxy-apienterprise >/dev/null 2>&1",
                "docker network disconnect shared_net proxy-apienterprise",
            ]
        )

    def test_obter_ip_container_shared_network_retorna_ip_correto(self):
        cliente_linux = ClienteLinuxFake(
            respostas=[
                ResultadoFake(codigo_retorno=0),
                ResultadoFake(
                    codigo_retorno=0,
                    saida='{"bridge":{"IPAddress":"172.17.0.2"},"shared_net":{"IPAddress":"172.19.0.10"}}'
                ),
            ]
        )

        ip = obter_ip_container_shared_network(cliente_linux, "MuWhatsapp")

        self.assertEqual(ip, "172.19.0.10")


if __name__ == "__main__":
    unittest.main()
