ramon
/
skillbox
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects 1 Releases 1 Wiki Activity

Remove or comment unused code

This commit is contained in:
Christian Cueni 2021-05-11 13:12:08 +02:00
parent 5648351ef5
commit 3c89a8b256
9 changed files with 390 additions and 374 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
client/src/pages/hello.vue
View File

@ -9,7 +9,7 @@
<script>
import HELLO_EMAIL_MUTATION from '@/graphql/gql/local/mutations/helloEmail.gql';
// import HELLO_EMAIL_MUTATION from '@/graphql/gql/local/mutations/helloEmail.gql';
import LoadingButton from '@/components/LoadingButton';
import pageTitleMixin from '@/mixins/page-title';

44
client/src/pages/registration.vue
View File

@ -319,28 +319,28 @@
this.submitted = true;
if (result) {
this.loading = true;
const registrationData = {
customer: {
prefix: this.prefix,
email: this.helloEmail,
firstname: this.firstname,
lastname: this.lastname,
gender: this.prefix === 'Herr' ? 1 : 2,
addresses: [{
street: [this.street],
postcode: this.postcode,
city: this.city,
country_id: 'CH',
firstname: this.firstname,
lastname: this.lastname,
prefix: this.prefix,
default_shipping: true,
default_billing: true
}]
},
password: this.password,
accepted_terms: this.acceptedTerms
};
// const registrationData = {
// customer: {
// prefix: this.prefix,
// email: this.helloEmail,
// firstname: this.firstname,
// lastname: this.lastname,
// gender: this.prefix === 'Herr' ? 1 : 2,
// addresses: [{
// street: [this.street],
// postcode: this.postcode,
// city: this.city,
// country_id: 'CH',
// firstname: this.firstname,
// lastname: this.lastname,
// prefix: this.prefix,
// default_shipping: true,
// default_billing: true
// }]
// },
// password: this.password,
// accepted_terms: this.acceptedTerms
// };
// register(registrationData).then((response) => {
// this.loading = false;

8
client/src/router/index.js
View File

@ -98,10 +98,14 @@ const routes = [
{
path: '/login-success',
redirect: to => {
console.log(to)
console.log(to);
switch (to.query.state) {
case 'email_not_verified':
return '/verify-email'
return '/verify-email';
case 'no_valid_license':
return '/verify-email';
default:
return '/unknown';
}
}
},

3
server/core/tests/test_coupon.py
View File

@ -54,8 +54,7 @@ class CouponTests(TestCase):
@patch.object(requests, 'put', return_value=MockResponse(200, data=['200', 'Coupon successfully redeemed']))
@patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
def test_user_has_valid_coupon(self, admin_mock, orders_mock, response_mock):
def test_user_has_valid_coupon(self, orders_mock, response_mock):
result = self.make_coupon_mutation('COUPON--1234', self.client)
user_role_key = self.user.user_roles.get(user=self.user).role.key

20
server/oauth/hep_client.py
View File

@ -5,6 +5,7 @@ import logging
import requests
from oauth.oauth_client import oauth
from users.licenses import MYSKILLBOX_LICENSES
from users.models import License
logger = logging.getLogger(__name__)
@ -29,7 +30,7 @@ class HepClient:
'content-type': 'application/json'
}
def _call(self, url, method='get', data=None, request=None, token=None):
def _call(self, url, request, token, method='get', data=None):
request_url = f'{self.URL}{url}'
@ -41,7 +42,7 @@ class HepClient:
if method == 'post':
response = requests.post(request_url, json=data)
elif method == 'get':
response = oauth.hep.get(url, **token_parameters)
response = oauth.hep.get(url, params=data, **token_parameters)
elif method == 'put':
response = requests.put(request_url, data=data)
@ -57,10 +58,21 @@ class HepClient:
return user_data['email_verified_at'] is not None
def user_details(self, request=None, token=None):
self._has_credentials(request, token)
response = self._call('api/auth/user', request, token)
return response.json()['data']
def fetch_eorders(self, request=None, token=None):
self._has_credentials(request, token)
data = {
'filters[product_type]': 'eLehrmittel',
}
response = self._call('api/partners/users/orders/search', request, token, data=data)
return response.json()['data']
def _has_credentials(self, request, token):
if request is None and token is None:
raise HepClientNoTokenException
response = self._call('/api/auth/user', request=request, token=token)
return response.json()['data']
def customers_search(self, admin_token, email):
response = self._call('/rest/V1/customers/search?searchCriteria[filterGroups][0][filters][0][field]='

2
server/oauth/views.py
View File

@ -25,8 +25,10 @@ def authorize(request):
if user and status_msg != EMAIL_NOT_VERIFIED:
dj_login(request, user)
OAuth2Token.objects.update_or_create_token(token, user)
hep_client.fetch_eorders(token=token)
if status_msg:
return redirect(f'/login-success?state={status_msg}')
# return status_msg

160
server/registration/tests/test_registration.py
View File

@ -14,88 +14,88 @@ from django.test import TestCase, RequestFactory
from graphene.test import Client
from api.schema_public import schema
from core.hep_client import HepClient
from core.tests.mock_hep_data_factory import ME_DATA, VALID_TEACHERS_ORDERS
# from core.hep_client import HepClient
# from core.tests.mock_hep_data_factory import ME_DATA, VALID_TEACHERS_ORDERS
from users.models import License
from users.models import User, Role, SchoolClass
INVALID_KEY_ME = dict(ME_DATA)
INVALID_KEY_ME['confirmation'] = 'abddddddd'
# INVALID_KEY_ME = dict(ME_DATA)
#
# INVALID_KEY_ME['confirmation'] = 'abddddddd'
class RegistrationTests(TestCase):
def setUp(self):
request = RequestFactory().post('/')
Role.objects.create_default_roles()
self.email = 'sepp@skillbox.iterativ.ch'
self.first_name = 'Sepp'
self.last_name = 'Feuz'
# adding session
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
self.client = Client(schema=schema, context_value=request)
def make_register_mutation(self, confirmation_key, user_id):
mutation = '''
mutation Registration($input: RegistrationInput!){
registration(input: $input) {
success
message
}
}
'''
return self.client.execute(mutation, variables={
'input': {
'confirmationKey': confirmation_key,
'userId': user_id
}
})
@patch.object(HepClient, 'customer_activate', return_value="Response")
@patch.object(HepClient, 'customers_by_id', return_value=ME_DATA)
@patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
@patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"')
def test_user_can_register_with_valid_confirmation_key_and_no_license(self, admin_mock, customer_by_id_mock,
product_mock, customer_mock):
result = self.make_register_mutation('CONFIRMATION_KEY', 1)
self.assertTrue(result.get('data').get('registration').get('success'))
self.assertEqual(result.get('data').get('registration').get('message'), 'no_valid_license')
@patch.object(HepClient, 'customer_activate', return_value="Response")
@patch.object(HepClient, 'customers_by_id', return_value=INVALID_KEY_ME)
@patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"')
def test_user_cannot_register_with_invalid_key(self, admin_mock, confirmation_mock, id_mock):
result = self.make_register_mutation('CONFIRMATION_KEY', 1)
self.assertFalse(result.get('data').get('registration').get('success'))
self.assertEqual(result.get('data').get('registration').get('message'), 'invalid_key')
@patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS)
@patch.object(HepClient, 'customer_activate', return_value="Response")
@patch.object(HepClient, 'customers_by_id', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"')
def test_teacher_can_register_with_remote_license(self, admin_mock, id_mock, activate_mock, orders_mock):
result = self.make_register_mutation('CONFIRMATION_KEY', 1)
user = User.objects.get(email=ME_DATA['email'])
user_role_key = user.user_roles.get(user=user).role.key
self.assertEqual(user_role_key, Role.objects.TEACHER_KEY)
license = License.objects.get(licensee=user)
self.assertEqual(license.for_role.key, Role.objects.TEACHER_KEY)
school_class = SchoolClass.objects.get(users__in=[user])
self.assertIsNotNone(school_class)
self.assertTrue(result.get('data').get('registration').get('success'))
self.assertTrue(user.is_authenticated)
# class RegistrationTests(TestCase):
# def setUp(self):
# request = RequestFactory().post('/')
#
# Role.objects.create_default_roles()
#
# self.email = 'sepp@skillbox.iterativ.ch'
# self.first_name = 'Sepp'
# self.last_name = 'Feuz'
#
# # adding session
# middleware = SessionMiddleware()
# middleware.process_request(request)
# request.session.save()
# self.client = Client(schema=schema, context_value=request)
#
# def make_register_mutation(self, confirmation_key, user_id):
# mutation = '''
# mutation Registration($input: RegistrationInput!){
# registration(input: $input) {
# success
# message
# }
# }
# '''
#
# return self.client.execute(mutation, variables={
# 'input': {
# 'confirmationKey': confirmation_key,
# 'userId': user_id
# }
# })
#
# @patch.object(HepClient, 'customer_activate', return_value="Response")
# @patch.object(HepClient, 'customers_by_id', return_value=ME_DATA)
# @patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
# @patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"')
# def test_user_can_register_with_valid_confirmation_key_and_no_license(self, admin_mock, customer_by_id_mock,
# product_mock, customer_mock):
#
# result = self.make_register_mutation('CONFIRMATION_KEY', 1)
#
# self.assertTrue(result.get('data').get('registration').get('success'))
# self.assertEqual(result.get('data').get('registration').get('message'), 'no_valid_license')
#
# @patch.object(HepClient, 'customer_activate', return_value="Response")
# @patch.object(HepClient, 'customers_by_id', return_value=INVALID_KEY_ME)
# @patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"')
# def test_user_cannot_register_with_invalid_key(self, admin_mock, confirmation_mock, id_mock):
#
# result = self.make_register_mutation('CONFIRMATION_KEY', 1)
#
# self.assertFalse(result.get('data').get('registration').get('success'))
# self.assertEqual(result.get('data').get('registration').get('message'), 'invalid_key')
#
# @patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS)
# @patch.object(HepClient, 'customer_activate', return_value="Response")
# @patch.object(HepClient, 'customers_by_id', return_value=ME_DATA)
# @patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"')
# def test_teacher_can_register_with_remote_license(self, admin_mock, id_mock, activate_mock, orders_mock):
# result = self.make_register_mutation('CONFIRMATION_KEY', 1)
#
# user = User.objects.get(email=ME_DATA['email'])
#
# user_role_key = user.user_roles.get(user=user).role.key
# self.assertEqual(user_role_key, Role.objects.TEACHER_KEY)
#
# license = License.objects.get(licensee=user)
# self.assertEqual(license.for_role.key, Role.objects.TEACHER_KEY)
#
# school_class = SchoolClass.objects.get(users__in=[user])
# self.assertIsNotNone(school_class)
#
# self.assertTrue(result.get('data').get('registration').get('success'))
# self.assertTrue(user.is_authenticated)

55
server/registration/tests/test_registration_proxy.py
View File

@ -15,8 +15,7 @@ import requests
from django.test import TestCase, Client
from django.urls import reverse
from core.hep_client import HepClient
from core.tests.mock_hep_data_factory import MockResponse
RESPONSE = {
'id': 1234,
@ -67,29 +66,29 @@ DATA = {
}
class ProxyTest(TestCase):
def setUp(self):
self.client = Client()
@patch.object(HepClient, 'customer_create', return_value=RESPONSE)
def test_proxy_filters_confirmation_key(self, create_mock):
response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json")
found = 'confirmation' in response.json().keys()
self.assertFalse(found)
@patch.object(requests, 'post', return_value=MockResponse(400,
data={'message': 'Ein Kunde mit der gleichen E-Mail-Adresse existiert bereits in einer zugeordneten Website.'}))
def test_handles_400(self, create_mock):
response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json")
self.assertEquals(response.json()['message'], 'Ein Kunde mit der gleichen E-Mail-Adresse existiert bereits in einer zugeordneten Website.')
def test_requires_accepted_terms(self):
del DATA['accepted_terms']
response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json")
self.assertEquals(response.status_code, 400)
self.assertEquals(response.json()['message'], 'Sie müssen hier zustimmen, damit Sie sich registrieren können.')
# class ProxyTest(TestCase):
#
# def setUp(self):
# self.client = Client()
#
# @patch.object(HepClient, 'customer_create', return_value=RESPONSE)
# def test_proxy_filters_confirmation_key(self, create_mock):
#
# response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json")
# found = 'confirmation' in response.json().keys()
# self.assertFalse(found)
#
# @patch.object(requests, 'post', return_value=MockResponse(400,
# data={'message': 'Ein Kunde mit der gleichen E-Mail-Adresse existiert bereits in einer zugeordneten Website.'}))
# def test_handles_400(self, create_mock):
#
# response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json")
# self.assertEquals(response.json()['message'], 'Ein Kunde mit der gleichen E-Mail-Adresse existiert bereits in einer zugeordneten Website.')
#
# def test_requires_accepted_terms(self):
#
# del DATA['accepted_terms']
#
# response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json")
# self.assertEquals(response.status_code, 400)
# self.assertEquals(response.json()['message'], 'Sie müssen hier zustimmen, damit Sie sich registrieren können.')

470
server/users/tests/test_login.py
View File

@ -1,237 +1,237 @@
from datetime import timedelta
from unittest.mock import patch
import requests
from django.conf import settings
from django.contrib.sessions.middleware import SessionMiddleware
from django.test import TestCase, RequestFactory
from django.utils import timezone
from graphene.test import Client
from api.schema_public import schema
from core.factories import UserFactory
from core.hep_client import HepClient
from core.tests.mock_hep_data_factory import MockResponse, ME_DATA, VALID_STUDENT_ORDERS, VALID_TEACHERS_ORDERS, \
NOT_CONFIRMED_ME
from users.factories import LicenseFactory
from users.models import Role, User, SchoolClass, License, UserData
TOKEN = 'abcd12345!'
MYSKILLBOX_GROUP_ID_ME_DATA = ME_DATA.copy()
MYSKILLBOX_GROUP_ID_ME_DATA['group_id'] = settings.HEP_MYSKILLBOX_GROUP_ID
# from datetime import timedelta
# from unittest.mock import patch
#
# import requests
# from django.conf import settings
# from django.contrib.sessions.middleware import SessionMiddleware
# from django.test import TestCase, RequestFactory
# from django.utils import timezone
# from graphene.test import Client
#
# from api.schema_public import schema
# from core.factories import UserFactory
# from core.hep_client import HepClient
# from core.tests.mock_hep_data_factory import MockResponse, ME_DATA, VALID_STUDENT_ORDERS, VALID_TEACHERS_ORDERS, \
# NOT_CONFIRMED_ME
# from users.factories import LicenseFactory
# from users.models import Role, User, SchoolClass, License, UserData
#
# TOKEN = 'abcd12345!'
#
# MYSKILLBOX_GROUP_ID_ME_DATA = ME_DATA.copy()
# MYSKILLBOX_GROUP_ID_ME_DATA['group_id'] = settings.HEP_MYSKILLBOX_GROUP_ID
class LoginTests(TestCase):
def setUp(self):
self.user = UserFactory(username=ME_DATA['id'], email=ME_DATA['id'])
Role.objects.create_default_roles()
self.teacher_role = Role.objects.get_default_teacher_role()
request = RequestFactory().post('/')
# adding session
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
self.client = Client(schema=schema, context_value=request)
def make_login_mutation(self, token):
mutation = '''
mutation Login($input: LoginInput!){
login(input: $input) {
success
message
}
}
'''
return self.client.execute(mutation, variables={
'input': {
'tokenInput': token
}
})
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_can_login_with_local_user_and_valid_local_license(self, me_mock):
self.user.hep_id = ME_DATA['id']
self.user.save()
now = timezone.now()
expiry_date = now + timedelta(100)
LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
result = self.make_login_mutation(TOKEN)
self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated)
reloaded_user = User.objects.get(pk=self.user.id)
self.assertEqual(reloaded_user.license_expiry_date, expiry_date.date())
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_can_login_with_local_user_and_valid_local_licenses(self, me_mock):
self.user.hep_id = ME_DATA['id']
self.user.save()
now = timezone.now()
expiry_date1 = now + timedelta(100)
expiry_date2 = now + timedelta(110)
LicenseFactory(expire_date=expiry_date1, licensee=self.user, for_role=self.teacher_role).save()
LicenseFactory(expire_date=expiry_date2, licensee=self.user, for_role=self.teacher_role).save()
result = self.make_login_mutation(TOKEN)
self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated)
reloaded_user = User.objects.get(pk=self.user.id)
self.assertEqual(reloaded_user.license_expiry_date, expiry_date2.date())
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_data_is_synced_on_login(self, me_mock):
old_mail = 'aschi@iterativ.ch'
self.user.hep_id = ME_DATA['id']
self.user.email = old_mail
self.user.username = old_mail
self.user.save()
now = timezone.now()
expiry_date = now + timedelta(365)
LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
result = self.make_login_mutation(TOKEN)
user = User.objects.get(hep_id=self.user.hep_id)
self.assertEqual(user.username, ME_DATA['email'])
self.assertEqual(user.email, ME_DATA['email'])
self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_can_login_with_local_user_and_valid_local_licenses(self, me_mock):
self.user.hep_id = ME_DATA['id']
self.user.save()
now = timezone.now()
expiry_date1 = now + timedelta(365)
expiry_date2 = now + timedelta(366)
LicenseFactory(expire_date=expiry_date1, licensee=self.user, for_role=self.teacher_role).save()
LicenseFactory(expire_date=expiry_date2, licensee=self.user, for_role=self.teacher_role).save()
result = self.make_login_mutation(TOKEN)
self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated)
@patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
def test_teacher_can_login_with_remote_user_and_remote_license(self, order_mock, me_mock, admin_token_mock):
result = self.make_login_mutation(TOKEN)
user = User.objects.get(email=ME_DATA['email'])
user_role_key = user.user_roles.get(user=user).role.key
self.assertEqual(user_role_key, Role.objects.TEACHER_KEY)
license = License.objects.get(licensee=user)
self.assertEqual(license.for_role.key, Role.objects.TEACHER_KEY)
school_class = SchoolClass.objects.get(users__in=[user])
self.assertIsNotNone(school_class)
self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated)
try:
UserData.objects.get(user=user)
self.fail('LoginTests.test_teacher_can_login_with_remote_user_and_remote_license: Userdata should not exist')
except:
pass
@patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS)
@patch.object(HepClient, 'customer_me', return_value=MYSKILLBOX_GROUP_ID_ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
def test_teacher_can_login_with_remote_user_and_remote_license_with_myskillbox_group_id(self, order_mock, me_mock, admin_token_mock):
self.make_login_mutation(TOKEN)
user = User.objects.get(email=MYSKILLBOX_GROUP_ID_ME_DATA['email'])
try:
UserData.objects.get(user=user)
except:
self.fail('LoginTests.test_teacher_can_login_with_remote_user_and_remote_license: Userdata should exist')
@patch.object(HepClient, '_customer_orders', return_value=VALID_STUDENT_ORDERS)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
def test_student_can_login_with_remote_user_and_remote_license(self, order_mock, me_mock, admin_token_mock):
result = self.make_login_mutation(TOKEN)
user = User.objects.get(email=ME_DATA['email'])
user_role_key = user.user_roles.get(user=user).role.key
self.assertEqual(user_role_key, Role.objects.STUDENT_KEY)
license = License.objects.get(licensee=user)
self.assertEqual(license.for_role.key, Role.objects.STUDENT_KEY)
self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated)
@patch.object(requests, 'post', return_value=MockResponse(401))
def test_user_with_no_login_cannot_login(self, post_mock):
result = self.make_login_mutation('some')
self.assertEqual(result.get('errors')[0].get('message'), 'invalid_credentials')
@patch.object(HepClient, 'is_email_verified', return_value=False)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_with_unconfirmed_email_cannot_login(self, me_mock, post_mock):
result = self.make_login_mutation(TOKEN)
User.objects.get(email=ME_DATA['email'])
self.assertEqual(result.get('errors')[0].get('message'), 'email_not_verified')
@patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
def test_user_can_login_without_license(self, me_mock, product_mock, admin_token_mock):
result = self.make_login_mutation(TOKEN)
self.assertTrue(result.get('data').get('login').get('success'))
self.assertEqual(result.get('data').get('login').get('message'), 'no_valid_license')
self.assertTrue(self.user.is_authenticated)
@patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
def test_user_can_login_local_license_invalid(self, product_mock, me_mock, admin_token_mock):
now = timezone.now()
expiry_date = now - timedelta(1)
LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
result = self.make_login_mutation(TOKEN)
self.assertTrue(result.get('data').get('login').get('success'))
self.assertEqual(result.get('data').get('login').get('message'), 'no_valid_license')
self.assertTrue(self.user.is_authenticated)
@patch.object(HepClient, 'customer_me', return_value=NOT_CONFIRMED_ME)
def test_user_can_login_with_unconfirmed_email(self, me_mock):
result = self.make_login_mutation(TOKEN)
self.assertEqual(result.get('errors')[0].get('message'), 'email_not_verified')
@patch.object(requests, 'get', return_value=MockResponse(500))
def test_user_gets_notified_if_server_error(self, post_mock):
result = self.make_login_mutation(TOKEN)
self.assertEqual(result.get('errors')[0].get('message'), 'unknown_error')
# class LoginTests(TestCase):
# def setUp(self):
# self.user = UserFactory(username=ME_DATA['id'], email=ME_DATA['id'])
# Role.objects.create_default_roles()
# self.teacher_role = Role.objects.get_default_teacher_role()
#
# request = RequestFactory().post('/')
#
# # adding session
# middleware = SessionMiddleware()
# middleware.process_request(request)
# request.session.save()
# self.client = Client(schema=schema, context_value=request)
#
# def make_login_mutation(self, token):
# mutation = '''
# mutation Login($input: LoginInput!){
# login(input: $input) {
# success
# message
# }
# }
# '''
#
# return self.client.execute(mutation, variables={
# 'input': {
# 'tokenInput': token
# }
# })
#
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# def test_user_can_login_with_local_user_and_valid_local_license(self, me_mock):
#
# self.user.hep_id = ME_DATA['id']
# self.user.save()
#
# now = timezone.now()
# expiry_date = now + timedelta(100)
# LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
#
# result = self.make_login_mutation(TOKEN)
#
# self.assertTrue(result.get('data').get('login').get('success'))
# self.assertTrue(self.user.is_authenticated)
#
# reloaded_user = User.objects.get(pk=self.user.id)
# self.assertEqual(reloaded_user.license_expiry_date, expiry_date.date())
#
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# def test_user_can_login_with_local_user_and_valid_local_licenses(self, me_mock):
#
# self.user.hep_id = ME_DATA['id']
# self.user.save()
#
# now = timezone.now()
# expiry_date1 = now + timedelta(100)
# expiry_date2 = now + timedelta(110)
#
# LicenseFactory(expire_date=expiry_date1, licensee=self.user, for_role=self.teacher_role).save()
# LicenseFactory(expire_date=expiry_date2, licensee=self.user, for_role=self.teacher_role).save()
#
# result = self.make_login_mutation(TOKEN)
#
# self.assertTrue(result.get('data').get('login').get('success'))
# self.assertTrue(self.user.is_authenticated)
#
# reloaded_user = User.objects.get(pk=self.user.id)
# self.assertEqual(reloaded_user.license_expiry_date, expiry_date2.date())
#
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# def test_user_data_is_synced_on_login(self, me_mock):
#
# old_mail = 'aschi@iterativ.ch'
#
# self.user.hep_id = ME_DATA['id']
# self.user.email = old_mail
# self.user.username = old_mail
# self.user.save()
#
# now = timezone.now()
# expiry_date = now + timedelta(365)
# LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
#
# result = self.make_login_mutation(TOKEN)
#
# user = User.objects.get(hep_id=self.user.hep_id)
#
# self.assertEqual(user.username, ME_DATA['email'])
# self.assertEqual(user.email, ME_DATA['email'])
# self.assertTrue(result.get('data').get('login').get('success'))
# self.assertTrue(self.user.is_authenticated)
#
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# def test_user_can_login_with_local_user_and_valid_local_licenses(self, me_mock):
#
# self.user.hep_id = ME_DATA['id']
# self.user.save()
#
# now = timezone.now()
# expiry_date1 = now + timedelta(365)
# expiry_date2 = now + timedelta(366)
#
# LicenseFactory(expire_date=expiry_date1, licensee=self.user, for_role=self.teacher_role).save()
# LicenseFactory(expire_date=expiry_date2, licensee=self.user, for_role=self.teacher_role).save()
#
# result = self.make_login_mutation(TOKEN)
#
# self.assertTrue(result.get('data').get('login').get('success'))
# self.assertTrue(self.user.is_authenticated)
#
# @patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS)
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# @patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
# def test_teacher_can_login_with_remote_user_and_remote_license(self, order_mock, me_mock, admin_token_mock):
# result = self.make_login_mutation(TOKEN)
#
# user = User.objects.get(email=ME_DATA['email'])
#
# user_role_key = user.user_roles.get(user=user).role.key
# self.assertEqual(user_role_key, Role.objects.TEACHER_KEY)
#
# license = License.objects.get(licensee=user)
# self.assertEqual(license.for_role.key, Role.objects.TEACHER_KEY)
#
# school_class = SchoolClass.objects.get(users__in=[user])
# self.assertIsNotNone(school_class)
#
# self.assertTrue(result.get('data').get('login').get('success'))
# self.assertTrue(self.user.is_authenticated)
#
# try:
# UserData.objects.get(user=user)
# self.fail('LoginTests.test_teacher_can_login_with_remote_user_and_remote_license: Userdata should not exist')
# except:
# pass
#
# @patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS)
# @patch.object(HepClient, 'customer_me', return_value=MYSKILLBOX_GROUP_ID_ME_DATA)
# @patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
# def test_teacher_can_login_with_remote_user_and_remote_license_with_myskillbox_group_id(self, order_mock, me_mock, admin_token_mock):
# self.make_login_mutation(TOKEN)
# user = User.objects.get(email=MYSKILLBOX_GROUP_ID_ME_DATA['email'])
# try:
# UserData.objects.get(user=user)
# except:
# self.fail('LoginTests.test_teacher_can_login_with_remote_user_and_remote_license: Userdata should exist')
#
# @patch.object(HepClient, '_customer_orders', return_value=VALID_STUDENT_ORDERS)
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# @patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
# def test_student_can_login_with_remote_user_and_remote_license(self, order_mock, me_mock, admin_token_mock):
#
# result = self.make_login_mutation(TOKEN)
# user = User.objects.get(email=ME_DATA['email'])
#
# user_role_key = user.user_roles.get(user=user).role.key
# self.assertEqual(user_role_key, Role.objects.STUDENT_KEY)
#
# license = License.objects.get(licensee=user)
# self.assertEqual(license.for_role.key, Role.objects.STUDENT_KEY)
#
# self.assertTrue(result.get('data').get('login').get('success'))
# self.assertTrue(self.user.is_authenticated)
#
# @patch.object(requests, 'post', return_value=MockResponse(401))
# def test_user_with_no_login_cannot_login(self, post_mock):
# result = self.make_login_mutation('some')
#
# self.assertEqual(result.get('errors')[0].get('message'), 'invalid_credentials')
#
# @patch.object(HepClient, 'is_email_verified', return_value=False)
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# def test_user_with_unconfirmed_email_cannot_login(self, me_mock, post_mock):
# result = self.make_login_mutation(TOKEN)
#
# User.objects.get(email=ME_DATA['email'])
# self.assertEqual(result.get('errors')[0].get('message'), 'email_not_verified')
#
# @patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# @patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
# def test_user_can_login_without_license(self, me_mock, product_mock, admin_token_mock):
# result = self.make_login_mutation(TOKEN)
#
# self.assertTrue(result.get('data').get('login').get('success'))
# self.assertEqual(result.get('data').get('login').get('message'), 'no_valid_license')
# self.assertTrue(self.user.is_authenticated)
#
# @patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
# @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
# @patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'})
# def test_user_can_login_local_license_invalid(self, product_mock, me_mock, admin_token_mock):
# now = timezone.now()
# expiry_date = now - timedelta(1)
# LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
#
# result = self.make_login_mutation(TOKEN)
#
# self.assertTrue(result.get('data').get('login').get('success'))
# self.assertEqual(result.get('data').get('login').get('message'), 'no_valid_license')
# self.assertTrue(self.user.is_authenticated)
#
# @patch.object(HepClient, 'customer_me', return_value=NOT_CONFIRMED_ME)
# def test_user_can_login_with_unconfirmed_email(self, me_mock):
# result = self.make_login_mutation(TOKEN)
#
# self.assertEqual(result.get('errors')[0].get('message'), 'email_not_verified')
#
# @patch.object(requests, 'get', return_value=MockResponse(500))
# def test_user_gets_notified_if_server_error(self, post_mock):
# result = self.make_login_mutation(TOKEN)
#
# self.assertEqual(result.get('errors')[0].get('message'), 'unknown_error')