peeringdb-peeringdb/tests/test_exporters.py

"""
Test peeringdb data export views
"""
import os
import pytest
import json
import difflib

from django.test import Client

from util import ClientCase

from peeringdb_server.models import (
    Organization,
    Network,
    InternetExchange,
    Facility,
    NetworkFacility,
    NetworkIXLan,
    IXLan,
)


class AdvancedSearchExportTest(ClientCase):
    """
    Tests advanced search result exports
    """

    @classmethod
    def setUpTestData(cls):

        ClientCase.setUpTestData()

        # create organization
        cls.org = Organization.objects.create(name="Test Org", status="ok")

        entity_count = range(1, 4)

        countries = ["US", "FI", ""]

        # create networks
        cls.net = [
            Network.objects.create(
                name="Network {}".format(i),
                status="ok",
                aka="AKA {}".format(i),
                policy_general="Open",
                info_traffic="0-20 Mbps",
                asn=i,
                org=cls.org,
            )
            for i in entity_count
        ]

        # create exchanges
        cls.ix = [
            InternetExchange.objects.create(
                name="Exchange {}".format(i),
                media="Ethernet",
                country=countries[i - 1],
                city="City {}".format(i),
                status="ok",
                org=cls.org,
            )
            for i in entity_count
        ]

        # create facilities
        cls.fac = [
            Facility.objects.create(
                name="Facility {}".format(i),
                status="ok",
                city="City {}".format(i),
                clli="CLLI{}".format(i),
                state="State {}".format(i),
                npanxx="{}-{}".format(i, i),
                country=countries[i - 1],
                zipcode=i,
                org=cls.org,
            )
            for i in entity_count
        ]

        # create network facility relationships
        cls.netfac = [
            NetworkFacility.objects.create(
                network=cls.net[i - 1], facility=cls.fac[i - 1], status="ok"
            )
            for i in entity_count
        ]

        # create ixlans
        cls.ixlan = [
            IXLan.objects.create(ix=cls.ix[i - 1], status="ok") for i in entity_count
        ]

        # create netixlans
        cls.netixlan = [
            NetworkIXLan.objects.create(
                ixlan=cls.ixlan[i - 1],
                network=cls.net[i - 1],
                asn=i,
                speed=0,
                status="ok",
            )
            for i in entity_count
        ]

    def expected_data(self, tag, fmt):
        path = os.path.join(
            os.path.dirname(__file__),
            "data",
            "export",
            "advancedsearch",
            "{}.{}".format(tag, fmt),
        )
        with open(path, "r") as fh:
            data = fh.read().rstrip()
        return data

    def test_export_net_json(self):
        """ test json export of network search """
        client = Client()
        response = client.get("/export/advanced-search/net/json?name_search=Network")
        self.assertEqual(
            json.loads(response.content), json.loads(self.expected_data("net", "json"))
        )

    def test_export_net_json_pretty(self):
        """ test pretty json export of network search """
        client = Client()
        response = client.get(
            "/export/advanced-search/net/json-pretty?name_search=Network"
        )
        self.assertEqual(response.content, self.expected_data("net", "jsonpretty"))

    def test_export_net_csv(self):
        """ test csv export of network search """
        client = Client()
        response = client.get("/export/advanced-search/net/csv?name_search=Network")
        self.assertEqual(
            response.content.replace("\r\n", "\n").rstrip(),
            self.expected_data("net", "csv"),
        )

    def test_export_fac_json(self):
        """ test json export of facility search """
        client = Client()
        response = client.get(
            "/export/advanced-search/fac/json?name__contains=Facility"
        )
        self.assertEqual(
            json.loads(response.content), json.loads(self.expected_data("fac", "json"))
        )

    def test_export_fac_json_pretty(self):
        """ test pretty json export of facility search """
        client = Client()
        response = client.get(
            "/export/advanced-search/fac/json-pretty?name__contains=Facility"
        )
        self.assertEqual(response.content, self.expected_data("fac", "jsonpretty"))

    def test_export_fac_csv(self):
        """ test csv export of facility search """
        client = Client()
        response = client.get("/export/advanced-search/fac/csv?name__contains=Facility")
        self.assertEqual(
            response.content.replace("\r\n", "\n").rstrip(),
            self.expected_data("fac", "csv"),
        )

    def test_export_ix_json(self):
        """ test json export of exchange search """
        client = Client()
        response = client.get("/export/advanced-search/ix/json?name__contains=Exchange")
        self.assertEqual(
            json.loads(response.content), json.loads(self.expected_data("ix", "json"))
        )

    def test_export_ix_json_pretty(self):
        """ test pretty json export of exchange search """
        client = Client()
        response = client.get(
            "/export/advanced-search/ix/json-pretty?name__contains=Exchange"
        )

        self.assertEqual(response.content, self.expected_data("ix", "jsonpretty"))

    def test_export_ix_csv(self):
        """ test csv export of exchange search """
        client = Client()
        response = client.get("/export/advanced-search/ix/csv?name__contains=Exchange")
        self.assertEqual(
            response.content.replace("\r\n", "\n").rstrip(),
            self.expected_data("ix", "csv"),
        )