gva/gnuviechadmin/osusers/tests/test_views.py

"""
This module provides tests for :py:mod:`osusers.views`.

"""
from __future__ import absolute_import, unicode_literals

try:
    from unittest.mock import patch, MagicMock
except ImportError:
    from mock import patch, MagicMock

from django.core.urlresolvers import reverse
from django.test import TestCase, TransactionTestCase
from django.contrib.auth import get_user_model

from hostingpackages.models import (
    CustomerHostingPackage,
    HostingPackageTemplate,
)

from osusers.models import SshPublicKey
from osusers.views import (
    AddSshPublicKey,
    DeleteSshPublicKey,
    EditSshPublicKeyComment,
)


User = get_user_model()

TEST_USER = 'test'
TEST_PASSWORD = 'secret'
TEST_EMAIL = 'test@example.org'
EXAMPLE_KEY = "".join((
    "ssh-rsa ",
    "AAAAB3NzaC1yc2EAAAABIwAAAIEA1on8gxCGJJWSRT4uOrR13mUaUk0hRf4RzxSZ1zRb",
    "YYFw8pfGesIFoEuVth4HKyF8k1y4mRUnYHP1XNMNMJl1JcEArC2asV8sHf6zSPVffozZ",
    "5TT4SfsUu/iKy9lUcCfXzwre4WWZSXXcPff+EHtWshahu3WzBdnGxm5Xoi89zcE="
))


class HostingPackageAwareTestMixin(object):

    def _setup_hosting_package(self, customer):
        template = HostingPackageTemplate.objects.create(
            name='testpackagetemplate', mailboxcount=10, diskspace=1,
            diskspace_unit=0)
        package = CustomerHostingPackage.objects.create_from_template(
            customer, template, 'testpackage')
        with patch('hostingpackages.models.settings') as hmsettings:
            hmsettings.OSUSER_DEFAULT_GROUPS = []
            package.save()
        return package


class AddSshPublicKeyTest(HostingPackageAwareTestMixin, TestCase):

    def setUp(self):
        self.customer = User.objects.create_user(
            username=TEST_USER, password=TEST_PASSWORD)
        self.package = self._setup_hosting_package(self.customer)

    def _get_url(self):
        return reverse('add_ssh_key', kwargs={'package': self.package.id})

    def test_get_anonymous(self):
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_regular_user(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_other_regular_user(self):
        User.objects.create_user(
            'test2', password=TEST_PASSWORD)
        self.client.login(username='test2', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_staff_user(self):
        User.objects.create_superuser(
            'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
        self.client.login(username='admin', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_template(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertTemplateUsed(response, 'osusers/sshpublickey_create.html')

    def test_get_form_kwargs(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        view = AddSshPublicKey(
            request=MagicMock(), kwargs={'package': str(self.package.pk)})
        the_kwargs = view.get_form_kwargs()
        self.assertIn('hostingpackage', the_kwargs)
        self.assertEqual(the_kwargs['hostingpackage'], self.package)

    def test_get_context_data(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertIn('customer', response.context)
        self.assertEqual(response.context['customer'], self.customer)
        self.assertIn('osuser', response.context)
        self.assertEqual(
            response.context['osuser'], self.package.osuser.username)

    def test_form_valid_redirect(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.post(
            self._get_url(),
            data={'publickeytext': EXAMPLE_KEY})
        self.assertRedirects(response, self.package.get_absolute_url())

    def test_form_valid_message(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.post(
            self._get_url(), follow=True,
            data={'publickeytext': EXAMPLE_KEY})
        messages = list(response.context['messages'])
        self.assertEqual(len(messages), 1)
        self.assertEqual(
            'Successfully added new ssh-rsa SSH public key.'.format(
                username=self.package.osuser.username
            ), str(messages[0]))


class DeleteSshPublicKeyTest(HostingPackageAwareTestMixin, TestCase):

    def setUp(self):
        self.customer = User.objects.create_user(
            username=TEST_USER, password=TEST_PASSWORD)
        self.package = self._setup_hosting_package(self.customer)
        self.sshkey = SshPublicKey.objects.create(
            user=self.package.osuser, algorithm='good', data='key',
            comment='comment')

    def _get_url(self):
        return reverse(
            'delete_ssh_key', kwargs={
                'package': self.package.id,
                'pk': self.sshkey.id
            })

    def test_get_anonymous(self):
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_regular_user(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_other_regular_user(self):
        User.objects.create_user(
            'test2', password=TEST_PASSWORD)
        self.client.login(username='test2', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_staff_user(self):
        User.objects.create_superuser(
            'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
        self.client.login(username='admin', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_template(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertTemplateUsed(
            response, 'osusers/sshpublickey_confirm_delete.html')

    def test_get_queryset(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        view = DeleteSshPublicKey(
            request=MagicMock(), kwargs={
                'package': str(self.package.pk),
                'pk': str(self.sshkey.pk)
            })
        queryset = view.get_queryset()
        self.assertQuerysetEqual(queryset, [repr(self.sshkey)])

    def test_get_context_data(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        for key in ('hostingpackage', 'customer', 'osuser'):
            self.assertIn(key, response.context)
        self.assertEqual(response.context['hostingpackage'], self.package)
        self.assertEqual(response.context['customer'], self.customer)
        self.assertEqual(
            response.context['osuser'], self.package.osuser.username)

    def test_get_success_url(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.post(
            self._get_url(),
            data={'comment': 'new comment'})
        self.assertRedirects(response, reverse('list_ssh_keys', kwargs={
            'package': self.package.id}))


class EditSshPublicKeyCommentTest(
        HostingPackageAwareTestMixin, TransactionTestCase):

    def setUp(self):
        self.customer = User.objects.create_user(
            username=TEST_USER, password=TEST_PASSWORD)
        self.package = self._setup_hosting_package(self.customer)
        self.sshkey = SshPublicKey.objects.create(
            user=self.package.osuser, algorithm='good', data='key',
            comment='comment')

    def _get_url(self):
        return reverse(
            'edit_ssh_key_comment', kwargs={
                'package': self.package.id,
                'pk': self.sshkey.id
            })

    def test_get_anonymous(self):
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_regular_user(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_other_regular_user(self):
        User.objects.create_user(
            'test2', password=TEST_PASSWORD)
        self.client.login(username='test2', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_staff_user(self):
        User.objects.create_superuser(
            'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
        self.client.login(username='admin', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_template(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertTemplateUsed(
            response, 'osusers/sshpublickey_edit_comment.html')

    def test_get_queryset(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        view = EditSshPublicKeyComment(
            request=MagicMock(), kwargs={
                'package': str(self.package.pk),
                'pk': str(self.sshkey.pk)
            })
        queryset = view.get_queryset()
        self.assertQuerysetEqual(queryset, [repr(self.sshkey)])

    def test_get_form_kwargs(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        view = EditSshPublicKeyComment(
            request=MagicMock(), kwargs={
                'package': str(self.package.pk),
                'pk': str(self.sshkey.pk)
            })
        the_kwargs = view.get_form_kwargs()
        self.assertIn('hostingpackage', the_kwargs)
        self.assertEqual(the_kwargs['hostingpackage'], self.package)

    def test_get_context_data(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        for key in ('hostingpackage', 'customer', 'osuser'):
            self.assertIn(key, response.context)
        self.assertEqual(response.context['hostingpackage'], self.package)
        self.assertEqual(response.context['customer'], self.customer)
        self.assertEqual(
            response.context['osuser'], self.package.osuser.username)

    def test_get_success_url(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.post(
            self._get_url(),
            data={'comment': 'new comment'})
        self.assertRedirects(response, reverse('list_ssh_keys', kwargs={
            'package': self.package.id}))


class ListSshPublicKeysTest(HostingPackageAwareTestMixin, TestCase):

    def setUp(self):
        self.customer = User.objects.create_user(
            username=TEST_USER, password=TEST_PASSWORD)
        self.package = self._setup_hosting_package(self.customer)

    def _get_url(self):
        return reverse('list_ssh_keys', kwargs={'package': self.package.id})

    def test_get_anonymous(self):
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_regular_user(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_other_regular_user(self):
        User.objects.create_user(
            'test2', password=TEST_PASSWORD)
        self.client.login(username='test2', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_staff_user(self):
        User.objects.create_superuser(
            'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
        self.client.login(username='admin', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_template(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertTemplateUsed(response, 'osusers/sshpublickey_list.html')

    def test_get_context_data(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        for key in ('hostingpackage', 'customer', 'osuser'):
            self.assertIn(key, response.context)
        self.assertEqual(response.context['hostingpackage'], self.package)
        self.assertEqual(response.context['customer'], self.customer)
        self.assertEqual(
            response.context['osuser'], self.package.osuser.username)


class SetOsUserPasswordTest(HostingPackageAwareTestMixin, TestCase):

    def setUp(self):
        self.customer = User.objects.create_user(
            username=TEST_USER, password=TEST_PASSWORD)
        self.package = self._setup_hosting_package(self.customer)

    def _get_url(self):
        return reverse('set_osuser_password', kwargs={
            'slug': self.package.osuser.username})

    def test_get_anonymous(self):
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_regular_user(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_other_regular_user(self):
        User.objects.create_user(
            'test2', password=TEST_PASSWORD)
        self.client.login(username='test2', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 403)

    def test_get_staff_user(self):
        User.objects.create_superuser(
            'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
        self.client.login(username='admin', password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertEqual(response.status_code, 200)

    def test_get_template(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertTemplateUsed(response, 'osusers/user_setpassword.html')

    def test_get_context_data(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.get(self._get_url())
        self.assertIn('customer', response.context)
        self.assertEqual(response.context['customer'], self.customer)

    def test_form_valid_redirect(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.post(
            self._get_url(),
            data={'password1': TEST_PASSWORD, 'password2': TEST_PASSWORD})
        self.assertRedirects(response, self.package.get_absolute_url())

    def test_form_valid_message(self):
        self.client.login(username=TEST_USER, password=TEST_PASSWORD)
        response = self.client.post(
            self._get_url(), follow=True,
            data={'password1': TEST_PASSWORD, 'password2': TEST_PASSWORD})
        messages = list(response.context['messages'])
        self.assertEqual(len(messages), 1)
        self.assertEqual(
            'New password for {username} has been set successfully.'.format(
                username=self.package.osuser.username
            ), str(messages[0]))