"""
This module provides tests for :py:mod:`userdbs.admin`.

"""
from __future__ import absolute_import

from django.contrib.admin import AdminSite
from django.test import TestCase

from userdbs.admin import (DatabaseUserAdmin, DatabaseUserCreationForm,
                           UserDatabaseAdmin, UserDatabaseCreationForm)
from userdbs.models import DB_TYPES, DatabaseUser, UserDatabase

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


class DatabaseUserCreationFormTest(TestCase):

    @patch('userdbs.admin.DatabaseUser.objects.create_database_user')
    def test_save(self, create_database_user):
        create_database_user.return_value = Mock()
        form = DatabaseUserCreationForm()
        mockuser = Mock(name='osuser')
        form.cleaned_data = {
            'osuser': mockuser,
            'db_type': DB_TYPES.pgsql
        }
        retval = form.save()
        self.assertTrue(create_database_user.called_with(
            osuser=mockuser, db_type=DB_TYPES.pgsql, commit=True))
        self.assertEqual(retval, create_database_user.return_value)

    def test_save_m2m_returns_none(self):
        form = DatabaseUserCreationForm()
        self.assertIsNone(form.save_m2m())


class UserDatabaseCreationFormTest(TestCase):

    @patch('userdbs.admin.UserDatabase.objects.create_userdatabase')
    def test_save(self, create_userdatabase):
        create_userdatabase.return_value = Mock()
        form = UserDatabaseCreationForm()
        mockuser = Mock(name='mockuser')
        form.cleaned_data = {'db_user': mockuser}
        retval = form.save()
        self.assertTrue(create_userdatabase.called_with(
            db_user=mockuser, commit=True))
        self.assertEqual(retval, create_userdatabase.return_value)

    def test_save_m2m_returns_none(self):
        form = UserDatabaseCreationForm()
        self.assertIsNone(form.save_m2m())


class DatabaseUserAdminTest(TestCase):

    def setUp(self):
        site = AdminSite()
        self.dbuadmin = DatabaseUserAdmin(DatabaseUser, site)
        super(DatabaseUserAdminTest, self).setUp()

    def test_get_form_with_instance(self):
        form = self.dbuadmin.get_form(
            Mock(name='request'), obj=Mock(name='dbuser'))
        self.assertEqual(
            form.Meta.fields,
            ['osuser', 'name', 'db_type']
        )

    def test_get_form_without_instance(self):
        form = self.dbuadmin.get_form(Mock(name='request'))
        self.assertEqual(
            form.Meta.fields,
            ['osuser', 'db_type']
        )

    def test_get_readonly_fields_with_instance(self):
        fields = self.dbuadmin.get_readonly_fields(
            Mock(name='request'), obj=Mock(name='dbuser'))
        self.assertEqual(
            fields, ['osuser', 'name', 'db_type'])

    def test_get_readonly_fields_without_instance(self):
        fields = self.dbuadmin.get_readonly_fields(
            Mock(name='request'))
        self.assertEqual(fields, [])

    def test_save_model_change(self):
        objmock = Mock()
        self.dbuadmin.save_model(Mock(name='request'), objmock, Mock(), True)
        self.assertTrue(objmock.create_in_database.not_called())

    def test_save_model_no_change(self):
        objmock = Mock()
        self.dbuadmin.save_model(Mock(name='request'), objmock, Mock(), False)
        self.assertTrue(objmock.create_in_database.called_with())

    def test_perform_delete_selected(self):
        usermock = Mock()
        selected = Mock()
        selected.all.return_value = [usermock]
        self.dbuadmin.perform_delete_selected(Mock(name='request'), selected)
        self.assertTrue(selected.all.called_with())
        self.assertTrue(usermock.delete.called_with())

    def test_get_actions(self):
        requestmock = MagicMock(name='request')
        self.assertNotIn(
            'delete_selected',
            self.dbuadmin.get_actions(requestmock))
        self.assertIn(
            'perform_delete_selected',
            self.dbuadmin.get_actions(requestmock))


class UserDatabaseAdminTest(TestCase):

    def setUp(self):
        site = AdminSite()
        self.udbadmin = UserDatabaseAdmin(UserDatabase, site)
        super(UserDatabaseAdminTest, self).setUp()

    def test_get_form_with_instance(self):
        form = self.udbadmin.get_form(
            Mock(name='request'), obj=Mock(name='userdb'))
        self.assertEqual(form.Meta.fields, ['db_name', 'db_user'])

    def test_get_form_without_instance(self):
        form = self.udbadmin.get_form(Mock(name='request'))
        self.assertEqual(form.Meta.fields, ['db_user'])

    def test_get_readonly_fields_with_instance(self):
        fields = self.udbadmin.get_readonly_fields(
            Mock(name='request'), obj=Mock(name='userdb'))
        self.assertEqual(
            fields, ['db_name', 'db_user'])

    def test_get_readonly_fields_without_instance(self):
        fields = self.udbadmin.get_readonly_fields(
            Mock(name='request'))
        self.assertEqual(fields, [])

    def test_save_model_change(self):
        objmock = Mock()
        self.udbadmin.save_model(Mock(name='request'), objmock, Mock(), True)
        self.assertTrue(objmock.create_in_database.not_called())

    def test_save_model_no_change(self):
        objmock = Mock()
        self.udbadmin.save_model(Mock(name='request'), objmock, Mock(), False)
        self.assertTrue(objmock.create_in_database.called_with())

    def test_perform_delete_selected(self):
        userdbmock = Mock()
        selected = Mock()
        selected.all.return_value = [userdbmock]
        self.udbadmin.perform_delete_selected(Mock(name='request'), selected)
        self.assertTrue(selected.all.called_with())
        self.assertTrue(userdbmock.delete.called_with())

    def test_get_actions(self):
        requestmock = MagicMock(name='request')
        self.assertNotIn(
            'delete_selected',
            self.udbadmin.get_actions(requestmock))
        self.assertIn(
            'perform_delete_selected',
            self.udbadmin.get_actions(requestmock))