323 lines
12 KiB
Python
323 lines
12 KiB
Python
from model_mommy import mommy
|
|
from unittest import mock, skipIf
|
|
|
|
from django.test import TestCase
|
|
from django.conf import settings
|
|
from django.core.urlresolvers import reverse
|
|
from django.core.urlresolvers import resolve
|
|
from cms.test_utils.testcases import CMSTestCase
|
|
from django.contrib.auth.tokens import default_token_generator
|
|
from django.utils.http import urlsafe_base64_encode
|
|
from django.utils.encoding import force_bytes
|
|
from cms.api import create_page
|
|
|
|
from membership.models import CustomUser, StripeCustomer
|
|
from utils.tests import BaseTestCase
|
|
|
|
|
|
from .views import (
|
|
LoginView, SignupView, PasswordResetView, PasswordResetConfirmView,
|
|
MembershipPricingView, MembershipPaymentView
|
|
)
|
|
from .models import MembershipType
|
|
|
|
|
|
class ContactViewTest(TestCase):
|
|
def setUp(self):
|
|
self.url = reverse('digitalglarus:contact')
|
|
self.data = {
|
|
'name': 'test',
|
|
'email': 'test@gmail.com',
|
|
'phone_number': '32123123123123',
|
|
'message': 'This is a message',
|
|
}
|
|
|
|
def url_resolve_to_view_correctly(self):
|
|
found = resolve(self.url)
|
|
self.assertEqual(found.func.__name__, self.view.__name__)
|
|
|
|
def test_any_user_should_contact_us(self):
|
|
response = self.client.post(self.url, self.data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
|
|
class ViewsTest(CMSTestCase):
|
|
def setUp(self):
|
|
self.page1 = create_page(
|
|
'home', 'home_digitalglarus.html', published=True,
|
|
language='en-us'
|
|
)
|
|
self.page2 = create_page(
|
|
'about', 'about.html', published=True, language='en-us',
|
|
slug='about'
|
|
)
|
|
|
|
def test_digitalglarus_templates(self):
|
|
res1 = self.client.get('/en-us/')
|
|
self.assertContains(res1, 'Digital Glarus', status_code=200)
|
|
res2 = self.client.get('/en-us/cms/about/')
|
|
self.assertEqual(res2.status_code, 200)
|
|
|
|
|
|
class MembershipPricingViewTest(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(MembershipPricingViewTest, self).setUp()
|
|
|
|
self.membership_type = mommy.make(MembershipType)
|
|
self.url = reverse('digitalglarus:membership_pricing')
|
|
self.view = MembershipPricingView
|
|
self.expected_template = 'digitalglarus/membership_pricing.html'
|
|
|
|
def test_url_resolve_to_view_correctly(self):
|
|
found = resolve(self.url)
|
|
self.assertEqual(found.func.__name__, self.view.__name__)
|
|
|
|
def test_get(self):
|
|
# Anonymous user should get data
|
|
response = self.client.get(self.url)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(
|
|
response.context['membership_type'], self.membership_type
|
|
)
|
|
self.assertTemplateUsed(response, self.expected_template)
|
|
|
|
|
|
class MembershipPaymentViewTest(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(MembershipPaymentViewTest, self).setUp()
|
|
|
|
self.membership_type = mommy.make(MembershipType)
|
|
self.url = reverse('digitalglarus:membership_payment')
|
|
self.view = MembershipPaymentView
|
|
self.expected_template = 'digitalglarus/membership_payment.html'
|
|
|
|
# post data
|
|
self.billing_address = {
|
|
'street_address': 'street name',
|
|
'city': 'MyCity',
|
|
'postal_code': '32123123123123',
|
|
'country': 'VE',
|
|
'token': 'a23kfmslwxhkwis',
|
|
'membership_type': self.membership_type.id
|
|
}
|
|
|
|
def test_url_resolve_to_view_correctly(self):
|
|
found = resolve(self.url)
|
|
self.assertEqual(found.func.__name__, self.view.__name__)
|
|
|
|
def test_get(self):
|
|
|
|
# Anonymous user should get redirect to login
|
|
response = self.client.get(self.url)
|
|
expected_url = "%s?next=%s" % (
|
|
reverse('digitalglarus:signup'),
|
|
reverse('digitalglarus:membership_payment')
|
|
)
|
|
self.assertRedirects(response, expected_url=expected_url,
|
|
status_code=302, target_status_code=200)
|
|
|
|
# Logged user should get the page
|
|
response = self.customer_client.get(self.url, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.context['stripe_key'],
|
|
settings.STRIPE_API_PUBLIC_KEY)
|
|
self.assertEqual(response.context['membership_type'],
|
|
self.membership_type)
|
|
|
|
@skipIf(
|
|
settings.STRIPE_API_PRIVATE_KEY_TEST is None or
|
|
settings.STRIPE_API_PRIVATE_KEY_TEST is "",
|
|
"""Stripe details unavailable, so skipping CeleryTaskTestCase"""
|
|
)
|
|
@mock.patch('utils.stripe_utils.StripeUtils.create_customer')
|
|
def test_post(self, stripe_mocked_call):
|
|
|
|
# Anonymous user should get redirect to login
|
|
# response = self.client.post(self.url)
|
|
# expected_url = "%s?next=%s" % (reverse('digitalglarus:signup'),
|
|
# reverse('digitalglarus:membership_payment'))
|
|
# self.assertRedirects(response, expected_url=expected_url,
|
|
# status_code=302, target_status_code=200)
|
|
|
|
# Customer user should be able to pay
|
|
stripe_mocked_call.return_value = {
|
|
'paid': True,
|
|
'response_object': self.stripe_mocked_customer,
|
|
'error': None
|
|
}
|
|
response = self.customer_client.post(self.url, self.billing_address)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertTrue(
|
|
StripeCustomer.objects.filter(
|
|
user__email=self.customer.email
|
|
).exists()
|
|
)
|
|
stripe_customer = StripeCustomer.objects.get(
|
|
user__email=self.customer.email
|
|
)
|
|
self.assertEqual(stripe_customer.user, self.customer)
|
|
# self.assertTrue(MembershipOrder.objects.filter(customer=stripe_customer).exists())
|
|
# membership_order = MembershipOrder.objects.filter(
|
|
# customer=stripe_customer
|
|
# ).first()
|
|
# session_data = {
|
|
# 'membership_price':
|
|
# membership_order.membership.type.first_month_price,
|
|
# 'membership_dates':
|
|
# membership_order.membership.type.first_month_formated_range
|
|
# }
|
|
# self.assertEqual(session_data.get('membership_price'),
|
|
# self.session_data.get('membership_price'))
|
|
# self.assertEqual(session_data.get('membership_dates'),
|
|
# self.session_data.get('membership_dates'))
|
|
|
|
# self.assertTrue(HostingOrder.objects.filter(customer=stripe_customer).exists())
|
|
# hosting_order = HostingOrder.objects.filter(customer=stripe_customer)[0]
|
|
# vm_plan = {
|
|
# 'cores': hosting_order.vm_plan.cores,
|
|
# 'memory': hosting_order.vm_plan.memory,
|
|
# 'disk_size': hosting_order.vm_plan.disk_size,
|
|
# 'price': hosting_order.vm_plan.price,
|
|
# 'hosting_company': hosting_order.vm_plan.vm_type.hosting_company,
|
|
# 'configuration': hosting_order.vm_plan.configuration
|
|
# }
|
|
# self.assertEqual(vm_plan, self.session_data.get('vm_specs'))
|
|
|
|
|
|
class LoginViewTest(TestCase):
|
|
|
|
def setUp(self):
|
|
self.url = reverse('digitalglarus:login')
|
|
self.view = LoginView
|
|
self.expected_template = 'digitalglarus/login.html'
|
|
self.user = mommy.make('membership.CustomUser')
|
|
self.password = 'fake_password'
|
|
self.user.set_password(self.password)
|
|
self.user.save()
|
|
|
|
def test_url_resolve_to_view_correctly(self):
|
|
found = resolve(self.url)
|
|
self.assertEqual(found.func.__name__, self.view.__name__)
|
|
|
|
def test_get(self):
|
|
response = self.client.get(self.url)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertTemplateUsed(response, self.expected_template)
|
|
|
|
def test_anonymous_user_can_login(self):
|
|
data = {
|
|
'email': self.user.email,
|
|
'password': self.password
|
|
}
|
|
response = self.client.post(self.url, data=data, follow=True)
|
|
self.assertEqual(response.context['user'], self.user)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
|
|
class SignupViewTest(TestCase):
|
|
|
|
def setUp(self):
|
|
self.url = reverse('digitalglarus:signup')
|
|
self.expected_template = 'digitalglarus/signup.html'
|
|
self.view = SignupView
|
|
self.signup_data = {
|
|
'name': 'ungleich',
|
|
'email': 'test@ungleich.ch',
|
|
'password': 'fake_password',
|
|
'confirm_password': 'fake_password',
|
|
}
|
|
|
|
def test_url_resolve_to_view_correctly(self):
|
|
found = resolve(self.url)
|
|
self.assertEqual(found.func.__name__, self.view.__name__)
|
|
|
|
def test_get(self):
|
|
response = self.client.get(self.url)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertTemplateUsed(response, self.expected_template)
|
|
|
|
def test_anonymous_user_can_signup(self):
|
|
response = self.client.post(
|
|
self.url, data=self.signup_data, follow=True
|
|
)
|
|
self.user = CustomUser.objects.get(email=self.signup_data.get('email'))
|
|
self.assertEqual(response.context['user'], self.user)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
|
|
class PasswordResetViewTest(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(PasswordResetViewTest, self).setUp()
|
|
|
|
self.url = reverse('digitalglarus:reset_password')
|
|
self.view = PasswordResetView
|
|
self.expected_template = 'digitalglarus/reset_password.html'
|
|
self.user = mommy.make('membership.CustomUser')
|
|
self.password = 'fake_password'
|
|
self.user.set_password(self.password)
|
|
self.user.save()
|
|
|
|
self.post_data = {
|
|
'email': self.user.email
|
|
}
|
|
|
|
def test_url_resolve_to_view_correctly(self):
|
|
found = resolve(self.url)
|
|
self.assertEqual(found.func.__name__, self.view.__name__)
|
|
|
|
def test_get(self):
|
|
response = self.client.get(self.url)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertTemplateUsed(response, self.expected_template)
|
|
|
|
def test_post(self):
|
|
response = self.client.post(self.url, data=self.post_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
def test_test_generate_email_context(self):
|
|
context = self.setup_view(self.view()).\
|
|
test_generate_email_context(self.user)
|
|
self.assertEqual(context.get('user'), self.user)
|
|
self.assertEqual(context.get('site_name'), 'ungleich')
|
|
self.assertEqual(len(context.get('token')), 24)
|
|
|
|
|
|
class PasswordResetConfirmViewTest(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(PasswordResetConfirmViewTest, self).setUp()
|
|
|
|
self.view = PasswordResetConfirmView
|
|
self.expected_template = 'digitalglarus/confirm_reset_password.html'
|
|
self.user = mommy.make('membership.CustomUser')
|
|
self.password = 'fake_password'
|
|
self.user.set_password(self.password)
|
|
self.user.save()
|
|
|
|
self.token = default_token_generator.make_token(self.user)
|
|
self.uid = urlsafe_base64_encode(force_bytes(self.user.pk))
|
|
self.url = reverse('digitalglarus:reset_password_confirm',
|
|
kwargs={'token': self.token, 'uidb64': self.uid})
|
|
|
|
self.post_data = {
|
|
'new_password1': 'new_password',
|
|
'new_password2': 'new_password'
|
|
}
|
|
|
|
def test_url_resolve_to_view_correctly(self):
|
|
found = resolve(self.url)
|
|
self.assertEqual(found.func.__name__, self.view.__name__)
|
|
|
|
def test_get(self):
|
|
response = self.client.get(self.url)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertTemplateUsed(response, self.expected_template)
|
|
|
|
def test_post(self):
|
|
response = self.client.post(self.url, data=self.post_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertTrue(not response.context['form'].errors)
|