coin/coin/vpn/tests.py

from django.test import TestCase

from coin.offers.models import Offer, OfferSubscription
from coin.vpn.models import VPNSubscription
from coin.resources.models import IPPool, IPSubnet
from coin.members.models import Member
from coin.members.tests import MemberTestsUtils


class VPNTestCase(TestCase):
    fixtures = ['example_pools.json', 'offers.json']

    def setUp(self):
        self.v6_pool = IPPool.objects.get(default_subnetsize=56)
        self.v4_pool = IPPool.objects.get(default_subnetsize=32)
        self.offer = Offer.objects.filter(backend="openvpn_ldap")[0]

        # Create a member.
        cn = MemberTestsUtils.get_random_ldap_cn()
        self.member = Member.objects.create(first_name=u"Toto",
                                            last_name=u"L'artichaut",
                                            ldap_cn=cn)

        # Create a new VPN with subnets.
        # We need Django to call clean() so that magic happens.
        abo = OfferSubscription(offer=self.offer, member=self.member)
        abo.full_clean()
        abo.save()
        v6 = IPSubnet(ip_pool=self.v6_pool, offer_subscription=abo)
        v6.full_clean()
        v6.save()
        v4 = IPSubnet(ip_pool=self.v4_pool, offer_subscription=abo)
        v4.full_clean()
        v4.save()
        vpn = VPNSubscription(administrative_subscription=abo,
                              login=cn + "_vpn",
                              password="tata")
        vpn.full_clean()
        vpn.save()

    def tearDown(self):
        """Properly clean up objects, so that they don't stay in LDAP"""
        VPNSubscription.objects.get().delete()
        Member.objects.get().delete()

    def test_has_ipv4_endpoint(self):
        vpn = VPNSubscription.objects.get()
        self.assertIsNotNone(vpn.ipv4_endpoint)

    def test_has_correct_ipv4_endpoint(self):
        """If there is not endpoint, we consider it to be correct."""
        vpn = VPNSubscription.objects.get()
        if vpn.ipv4_endpoint is not None:
            abo = OfferSubscription.objects.get()
            subnet = abo.ip_subnet.get(ip_pool=self.v4_pool)
            self.assertIn(vpn.ipv4_endpoint, subnet.inet)

    def test_has_ipv6_endpoint(self):
        vpn = VPNSubscription.objects.get()
        self.assertIsNotNone(vpn.ipv6_endpoint)

    def test_has_correct_ipv6_endpoint(self):
        """If there is not endpoint, we consider it to be correct."""
        vpn = VPNSubscription.objects.get()
        if vpn.ipv6_endpoint is not None:
            abo = OfferSubscription.objects.get()
            subnet = abo.ip_subnet.get(ip_pool=self.v6_pool)
            self.assertIn(vpn.ipv6_endpoint, subnet.inet)