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> <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 LoadingButton from '@/components/LoadingButton';
import pageTitleMixin from '@/mixins/page-title'; import pageTitleMixin from '@/mixins/page-title';

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

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

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

@ -98,10 +98,14 @@ const routes = [
{ {
path: '/login-success', path: '/login-success',
redirect: to => { redirect: to => {
console.log(to) console.log(to);
switch (to.query.state) { switch (to.query.state) {
case 'email_not_verified': 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(requests, 'put', return_value=MockResponse(200, data=['200', 'Coupon successfully redeemed']))
@patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS) @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, orders_mock, response_mock):
def test_user_has_valid_coupon(self, admin_mock, orders_mock, response_mock):
result = self.make_coupon_mutation('COUPON--1234', self.client) result = self.make_coupon_mutation('COUPON--1234', self.client)
user_role_key = self.user.user_roles.get(user=self.user).role.key 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 import requests
from oauth.oauth_client import oauth from oauth.oauth_client import oauth
from users.licenses import MYSKILLBOX_LICENSES
from users.models import License from users.models import License
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -29,7 +30,7 @@ class HepClient:
'content-type': 'application/json' '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}' request_url = f'{self.URL}{url}'
@ -41,7 +42,7 @@ class HepClient:
if method == 'post': if method == 'post':
response = requests.post(request_url, json=data) response = requests.post(request_url, json=data)
elif method == 'get': elif method == 'get':
response = oauth.hep.get(url, **token_parameters) response = oauth.hep.get(url, params=data, **token_parameters)
elif method == 'put': elif method == 'put':
response = requests.put(request_url, data=data) response = requests.put(request_url, data=data)
@ -57,10 +58,21 @@ class HepClient:
return user_data['email_verified_at'] is not None return user_data['email_verified_at'] is not None
def user_details(self, request=None, token=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: if request is None and token is None:
raise HepClientNoTokenException raise HepClientNoTokenException
response = self._call('/api/auth/user', request=request, token=token)
return response.json()['data']
def customers_search(self, admin_token, email): def customers_search(self, admin_token, email):
response = self._call('/rest/V1/customers/search?searchCriteria[filterGroups][0][filters][0][field]=' 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: if user and status_msg != EMAIL_NOT_VERIFIED:
dj_login(request, user) dj_login(request, user)
OAuth2Token.objects.update_or_create_token(token, user) OAuth2Token.objects.update_or_create_token(token, user)
hep_client.fetch_eorders(token=token)
if status_msg: if status_msg:
return redirect(f'/login-success?state={status_msg}') return redirect(f'/login-success?state={status_msg}')
# return 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 graphene.test import Client
from api.schema_public import schema from api.schema_public import schema
from core.hep_client import HepClient # from core.hep_client import HepClient
from core.tests.mock_hep_data_factory import ME_DATA, VALID_TEACHERS_ORDERS # from core.tests.mock_hep_data_factory import ME_DATA, VALID_TEACHERS_ORDERS
from users.models import License from users.models import License
from users.models import User, Role, SchoolClass from users.models import User, Role, SchoolClass
INVALID_KEY_ME = dict(ME_DATA) # INVALID_KEY_ME = dict(ME_DATA)
#
INVALID_KEY_ME['confirmation'] = 'abddddddd' # INVALID_KEY_ME['confirmation'] = 'abddddddd'
class RegistrationTests(TestCase): # class RegistrationTests(TestCase):
def setUp(self): # def setUp(self):
request = RequestFactory().post('/') # request = RequestFactory().post('/')
#
Role.objects.create_default_roles() # Role.objects.create_default_roles()
#
self.email = 'sepp@skillbox.iterativ.ch' # self.email = 'sepp@skillbox.iterativ.ch'
self.first_name = 'Sepp' # self.first_name = 'Sepp'
self.last_name = 'Feuz' # self.last_name = 'Feuz'
#
# adding session # # adding session
middleware = SessionMiddleware() # middleware = SessionMiddleware()
middleware.process_request(request) # middleware.process_request(request)
request.session.save() # request.session.save()
self.client = Client(schema=schema, context_value=request) # self.client = Client(schema=schema, context_value=request)
#
def make_register_mutation(self, confirmation_key, user_id): # def make_register_mutation(self, confirmation_key, user_id):
mutation = ''' # mutation = '''
mutation Registration($input: RegistrationInput!){ # mutation Registration($input: RegistrationInput!){
registration(input: $input) { # registration(input: $input) {
success # success
message # message
} # }
} # }
''' # '''
#
return self.client.execute(mutation, variables={ # return self.client.execute(mutation, variables={
'input': { # 'input': {
'confirmationKey': confirmation_key, # 'confirmationKey': confirmation_key,
'userId': user_id # 'userId': user_id
} # }
}) # })
#
@patch.object(HepClient, 'customer_activate', return_value="Response") # @patch.object(HepClient, 'customer_activate', return_value="Response")
@patch.object(HepClient, 'customers_by_id', return_value=ME_DATA) # @patch.object(HepClient, 'customers_by_id', return_value=ME_DATA)
@patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None) # @patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
@patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"') # @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, # def test_user_can_register_with_valid_confirmation_key_and_no_license(self, admin_mock, customer_by_id_mock,
product_mock, customer_mock): # product_mock, customer_mock):
#
result = self.make_register_mutation('CONFIRMATION_KEY', 1) # result = self.make_register_mutation('CONFIRMATION_KEY', 1)
#
self.assertTrue(result.get('data').get('registration').get('success')) # self.assertTrue(result.get('data').get('registration').get('success'))
self.assertEqual(result.get('data').get('registration').get('message'), 'no_valid_license') # self.assertEqual(result.get('data').get('registration').get('message'), 'no_valid_license')
#
@patch.object(HepClient, 'customer_activate', return_value="Response") # @patch.object(HepClient, 'customer_activate', return_value="Response")
@patch.object(HepClient, 'customers_by_id', return_value=INVALID_KEY_ME) # @patch.object(HepClient, 'customers_by_id', return_value=INVALID_KEY_ME)
@patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"') # @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): # def test_user_cannot_register_with_invalid_key(self, admin_mock, confirmation_mock, id_mock):
#
result = self.make_register_mutation('CONFIRMATION_KEY', 1) # result = self.make_register_mutation('CONFIRMATION_KEY', 1)
#
self.assertFalse(result.get('data').get('registration').get('success')) # self.assertFalse(result.get('data').get('registration').get('success'))
self.assertEqual(result.get('data').get('registration').get('message'), 'invalid_key') # 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_orders', return_value=VALID_TEACHERS_ORDERS)
@patch.object(HepClient, 'customer_activate', return_value="Response") # @patch.object(HepClient, 'customer_activate', return_value="Response")
@patch.object(HepClient, 'customers_by_id', return_value=ME_DATA) # @patch.object(HepClient, 'customers_by_id', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value=b'"AABBCCDDEE**44566"') # @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): # 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) # result = self.make_register_mutation('CONFIRMATION_KEY', 1)
#
user = User.objects.get(email=ME_DATA['email']) # user = User.objects.get(email=ME_DATA['email'])
#
user_role_key = user.user_roles.get(user=user).role.key # user_role_key = user.user_roles.get(user=user).role.key
self.assertEqual(user_role_key, Role.objects.TEACHER_KEY) # self.assertEqual(user_role_key, Role.objects.TEACHER_KEY)
#
license = License.objects.get(licensee=user) # license = License.objects.get(licensee=user)
self.assertEqual(license.for_role.key, Role.objects.TEACHER_KEY) # self.assertEqual(license.for_role.key, Role.objects.TEACHER_KEY)
#
school_class = SchoolClass.objects.get(users__in=[user]) # school_class = SchoolClass.objects.get(users__in=[user])
self.assertIsNotNone(school_class) # self.assertIsNotNone(school_class)
#
self.assertTrue(result.get('data').get('registration').get('success')) # self.assertTrue(result.get('data').get('registration').get('success'))
self.assertTrue(user.is_authenticated) # 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.test import TestCase, Client
from django.urls import reverse from django.urls import reverse
from core.hep_client import HepClient
from core.tests.mock_hep_data_factory import MockResponse
RESPONSE = { RESPONSE = {
'id': 1234, 'id': 1234,
@ -67,29 +66,29 @@ DATA = {
} }
class ProxyTest(TestCase): # class ProxyTest(TestCase):
#
def setUp(self): # def setUp(self):
self.client = Client() # self.client = Client()
#
@patch.object(HepClient, 'customer_create', return_value=RESPONSE) # @patch.object(HepClient, 'customer_create', return_value=RESPONSE)
def test_proxy_filters_confirmation_key(self, create_mock): # def test_proxy_filters_confirmation_key(self, create_mock):
#
response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json") # response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json")
found = 'confirmation' in response.json().keys() # found = 'confirmation' in response.json().keys()
self.assertFalse(found) # self.assertFalse(found)
#
@patch.object(requests, 'post', return_value=MockResponse(400, # @patch.object(requests, 'post', return_value=MockResponse(400,
data={'message': 'Ein Kunde mit der gleichen E-Mail-Adresse existiert bereits in einer zugeordneten Website.'})) # data={'message': 'Ein Kunde mit der gleichen E-Mail-Adresse existiert bereits in einer zugeordneten Website.'}))
def test_handles_400(self, create_mock): # def test_handles_400(self, create_mock):
#
response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json") # 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.') # 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): # def test_requires_accepted_terms(self):
#
del DATA['accepted_terms'] # del DATA['accepted_terms']
#
response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json") # response = self.client.post(reverse('api:registration:proxy'), json.dumps(DATA), content_type="application/json")
self.assertEquals(response.status_code, 400) # self.assertEquals(response.status_code, 400)
self.assertEquals(response.json()['message'], 'Sie müssen hier zustimmen, damit Sie sich registrieren können.') # 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 datetime import timedelta
from unittest.mock import patch # from unittest.mock import patch
#
import requests # import requests
from django.conf import settings # from django.conf import settings
from django.contrib.sessions.middleware import SessionMiddleware # from django.contrib.sessions.middleware import SessionMiddleware
from django.test import TestCase, RequestFactory # from django.test import TestCase, RequestFactory
from django.utils import timezone # from django.utils import timezone
from graphene.test import Client # from graphene.test import Client
#
from api.schema_public import schema # from api.schema_public import schema
from core.factories import UserFactory # from core.factories import UserFactory
from core.hep_client import HepClient # from core.hep_client import HepClient
from core.tests.mock_hep_data_factory import MockResponse, ME_DATA, VALID_STUDENT_ORDERS, VALID_TEACHERS_ORDERS, \ # from core.tests.mock_hep_data_factory import MockResponse, ME_DATA, VALID_STUDENT_ORDERS, VALID_TEACHERS_ORDERS, \
NOT_CONFIRMED_ME # NOT_CONFIRMED_ME
from users.factories import LicenseFactory # from users.factories import LicenseFactory
from users.models import Role, User, SchoolClass, License, UserData # from users.models import Role, User, SchoolClass, License, UserData
#
TOKEN = 'abcd12345!' # TOKEN = 'abcd12345!'
#
MYSKILLBOX_GROUP_ID_ME_DATA = ME_DATA.copy() # MYSKILLBOX_GROUP_ID_ME_DATA = ME_DATA.copy()
MYSKILLBOX_GROUP_ID_ME_DATA['group_id'] = settings.HEP_MYSKILLBOX_GROUP_ID # MYSKILLBOX_GROUP_ID_ME_DATA['group_id'] = settings.HEP_MYSKILLBOX_GROUP_ID
class LoginTests(TestCase): # class LoginTests(TestCase):
def setUp(self): # def setUp(self):
self.user = UserFactory(username=ME_DATA['id'], email=ME_DATA['id']) # self.user = UserFactory(username=ME_DATA['id'], email=ME_DATA['id'])
Role.objects.create_default_roles() # Role.objects.create_default_roles()
self.teacher_role = Role.objects.get_default_teacher_role() # self.teacher_role = Role.objects.get_default_teacher_role()
#
request = RequestFactory().post('/') # request = RequestFactory().post('/')
#
# adding session # # adding session
middleware = SessionMiddleware() # middleware = SessionMiddleware()
middleware.process_request(request) # middleware.process_request(request)
request.session.save() # request.session.save()
self.client = Client(schema=schema, context_value=request) # self.client = Client(schema=schema, context_value=request)
#
def make_login_mutation(self, token): # def make_login_mutation(self, token):
mutation = ''' # mutation = '''
mutation Login($input: LoginInput!){ # mutation Login($input: LoginInput!){
login(input: $input) { # login(input: $input) {
success # success
message # message
} # }
} # }
''' # '''
#
return self.client.execute(mutation, variables={ # return self.client.execute(mutation, variables={
'input': { # 'input': {
'tokenInput': token # 'tokenInput': token
} # }
}) # })
#
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_can_login_with_local_user_and_valid_local_license(self, me_mock): # def test_user_can_login_with_local_user_and_valid_local_license(self, me_mock):
#
self.user.hep_id = ME_DATA['id'] # self.user.hep_id = ME_DATA['id']
self.user.save() # self.user.save()
#
now = timezone.now() # now = timezone.now()
expiry_date = now + timedelta(100) # expiry_date = now + timedelta(100)
LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save() # LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
#
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
self.assertTrue(result.get('data').get('login').get('success')) # self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated) # self.assertTrue(self.user.is_authenticated)
#
reloaded_user = User.objects.get(pk=self.user.id) # reloaded_user = User.objects.get(pk=self.user.id)
self.assertEqual(reloaded_user.license_expiry_date, expiry_date.date()) # self.assertEqual(reloaded_user.license_expiry_date, expiry_date.date())
#
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_can_login_with_local_user_and_valid_local_licenses(self, me_mock): # def test_user_can_login_with_local_user_and_valid_local_licenses(self, me_mock):
#
self.user.hep_id = ME_DATA['id'] # self.user.hep_id = ME_DATA['id']
self.user.save() # self.user.save()
#
now = timezone.now() # now = timezone.now()
expiry_date1 = now + timedelta(100) # expiry_date1 = now + timedelta(100)
expiry_date2 = now + timedelta(110) # expiry_date2 = now + timedelta(110)
#
LicenseFactory(expire_date=expiry_date1, licensee=self.user, for_role=self.teacher_role).save() # 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() # LicenseFactory(expire_date=expiry_date2, licensee=self.user, for_role=self.teacher_role).save()
#
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
self.assertTrue(result.get('data').get('login').get('success')) # self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated) # self.assertTrue(self.user.is_authenticated)
#
reloaded_user = User.objects.get(pk=self.user.id) # reloaded_user = User.objects.get(pk=self.user.id)
self.assertEqual(reloaded_user.license_expiry_date, expiry_date2.date()) # self.assertEqual(reloaded_user.license_expiry_date, expiry_date2.date())
#
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_data_is_synced_on_login(self, me_mock): # def test_user_data_is_synced_on_login(self, me_mock):
#
old_mail = 'aschi@iterativ.ch' # old_mail = 'aschi@iterativ.ch'
#
self.user.hep_id = ME_DATA['id'] # self.user.hep_id = ME_DATA['id']
self.user.email = old_mail # self.user.email = old_mail
self.user.username = old_mail # self.user.username = old_mail
self.user.save() # self.user.save()
#
now = timezone.now() # now = timezone.now()
expiry_date = now + timedelta(365) # expiry_date = now + timedelta(365)
LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save() # LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
#
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
user = User.objects.get(hep_id=self.user.hep_id) # user = User.objects.get(hep_id=self.user.hep_id)
#
self.assertEqual(user.username, ME_DATA['email']) # self.assertEqual(user.username, ME_DATA['email'])
self.assertEqual(user.email, ME_DATA['email']) # self.assertEqual(user.email, ME_DATA['email'])
self.assertTrue(result.get('data').get('login').get('success')) # self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated) # self.assertTrue(self.user.is_authenticated)
#
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_can_login_with_local_user_and_valid_local_licenses(self, me_mock): # def test_user_can_login_with_local_user_and_valid_local_licenses(self, me_mock):
#
self.user.hep_id = ME_DATA['id'] # self.user.hep_id = ME_DATA['id']
self.user.save() # self.user.save()
#
now = timezone.now() # now = timezone.now()
expiry_date1 = now + timedelta(365) # expiry_date1 = now + timedelta(365)
expiry_date2 = now + timedelta(366) # expiry_date2 = now + timedelta(366)
#
LicenseFactory(expire_date=expiry_date1, licensee=self.user, for_role=self.teacher_role).save() # 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() # LicenseFactory(expire_date=expiry_date2, licensee=self.user, for_role=self.teacher_role).save()
#
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
self.assertTrue(result.get('data').get('login').get('success')) # self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated) # self.assertTrue(self.user.is_authenticated)
#
@patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS) # @patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'}) # @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): # 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) # result = self.make_login_mutation(TOKEN)
#
user = User.objects.get(email=ME_DATA['email']) # user = User.objects.get(email=ME_DATA['email'])
#
user_role_key = user.user_roles.get(user=user).role.key # user_role_key = user.user_roles.get(user=user).role.key
self.assertEqual(user_role_key, Role.objects.TEACHER_KEY) # self.assertEqual(user_role_key, Role.objects.TEACHER_KEY)
#
license = License.objects.get(licensee=user) # license = License.objects.get(licensee=user)
self.assertEqual(license.for_role.key, Role.objects.TEACHER_KEY) # self.assertEqual(license.for_role.key, Role.objects.TEACHER_KEY)
#
school_class = SchoolClass.objects.get(users__in=[user]) # school_class = SchoolClass.objects.get(users__in=[user])
self.assertIsNotNone(school_class) # self.assertIsNotNone(school_class)
#
self.assertTrue(result.get('data').get('login').get('success')) # self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated) # self.assertTrue(self.user.is_authenticated)
#
try: # try:
UserData.objects.get(user=user) # UserData.objects.get(user=user)
self.fail('LoginTests.test_teacher_can_login_with_remote_user_and_remote_license: Userdata should not exist') # self.fail('LoginTests.test_teacher_can_login_with_remote_user_and_remote_license: Userdata should not exist')
except: # except:
pass # pass
#
@patch.object(HepClient, '_customer_orders', return_value=VALID_TEACHERS_ORDERS) # @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, 'customer_me', return_value=MYSKILLBOX_GROUP_ID_ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'}) # @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): # 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) # self.make_login_mutation(TOKEN)
user = User.objects.get(email=MYSKILLBOX_GROUP_ID_ME_DATA['email']) # user = User.objects.get(email=MYSKILLBOX_GROUP_ID_ME_DATA['email'])
try: # try:
UserData.objects.get(user=user) # UserData.objects.get(user=user)
except: # except:
self.fail('LoginTests.test_teacher_can_login_with_remote_user_and_remote_license: Userdata should exist') # 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_orders', return_value=VALID_STUDENT_ORDERS)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'}) # @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): # 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) # result = self.make_login_mutation(TOKEN)
user = User.objects.get(email=ME_DATA['email']) # user = User.objects.get(email=ME_DATA['email'])
#
user_role_key = user.user_roles.get(user=user).role.key # user_role_key = user.user_roles.get(user=user).role.key
self.assertEqual(user_role_key, Role.objects.STUDENT_KEY) # self.assertEqual(user_role_key, Role.objects.STUDENT_KEY)
#
license = License.objects.get(licensee=user) # license = License.objects.get(licensee=user)
self.assertEqual(license.for_role.key, Role.objects.STUDENT_KEY) # self.assertEqual(license.for_role.key, Role.objects.STUDENT_KEY)
#
self.assertTrue(result.get('data').get('login').get('success')) # self.assertTrue(result.get('data').get('login').get('success'))
self.assertTrue(self.user.is_authenticated) # self.assertTrue(self.user.is_authenticated)
#
@patch.object(requests, 'post', return_value=MockResponse(401)) # @patch.object(requests, 'post', return_value=MockResponse(401))
def test_user_with_no_login_cannot_login(self, post_mock): # def test_user_with_no_login_cannot_login(self, post_mock):
result = self.make_login_mutation('some') # result = self.make_login_mutation('some')
#
self.assertEqual(result.get('errors')[0].get('message'), 'invalid_credentials') # self.assertEqual(result.get('errors')[0].get('message'), 'invalid_credentials')
#
@patch.object(HepClient, 'is_email_verified', return_value=False) # @patch.object(HepClient, 'is_email_verified', return_value=False)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
def test_user_with_unconfirmed_email_cannot_login(self, me_mock, post_mock): # def test_user_with_unconfirmed_email_cannot_login(self, me_mock, post_mock):
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
User.objects.get(email=ME_DATA['email']) # User.objects.get(email=ME_DATA['email'])
self.assertEqual(result.get('errors')[0].get('message'), 'email_not_verified') # self.assertEqual(result.get('errors')[0].get('message'), 'email_not_verified')
#
@patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None) # @patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'}) # @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): # def test_user_can_login_without_license(self, me_mock, product_mock, admin_token_mock):
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
self.assertTrue(result.get('data').get('login').get('success')) # self.assertTrue(result.get('data').get('login').get('success'))
self.assertEqual(result.get('data').get('login').get('message'), 'no_valid_license') # self.assertEqual(result.get('data').get('login').get('message'), 'no_valid_license')
self.assertTrue(self.user.is_authenticated) # self.assertTrue(self.user.is_authenticated)
#
@patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None) # @patch.object(HepClient, 'myskillbox_product_for_customer', return_value=None)
@patch.object(HepClient, 'customer_me', return_value=ME_DATA) # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
@patch.object(HepClient, 'fetch_admin_token', return_value={'token': 'AABBCCDDEE**44566'}) # @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): # def test_user_can_login_local_license_invalid(self, product_mock, me_mock, admin_token_mock):
now = timezone.now() # now = timezone.now()
expiry_date = now - timedelta(1) # expiry_date = now - timedelta(1)
LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save() # LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save()
#
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
self.assertTrue(result.get('data').get('login').get('success')) # self.assertTrue(result.get('data').get('login').get('success'))
self.assertEqual(result.get('data').get('login').get('message'), 'no_valid_license') # self.assertEqual(result.get('data').get('login').get('message'), 'no_valid_license')
self.assertTrue(self.user.is_authenticated) # self.assertTrue(self.user.is_authenticated)
#
@patch.object(HepClient, 'customer_me', return_value=NOT_CONFIRMED_ME) # @patch.object(HepClient, 'customer_me', return_value=NOT_CONFIRMED_ME)
def test_user_can_login_with_unconfirmed_email(self, me_mock): # def test_user_can_login_with_unconfirmed_email(self, me_mock):
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
self.assertEqual(result.get('errors')[0].get('message'), 'email_not_verified') # self.assertEqual(result.get('errors')[0].get('message'), 'email_not_verified')
#
@patch.object(requests, 'get', return_value=MockResponse(500)) # @patch.object(requests, 'get', return_value=MockResponse(500))
def test_user_gets_notified_if_server_error(self, post_mock): # def test_user_gets_notified_if_server_error(self, post_mock):
result = self.make_login_mutation(TOKEN) # result = self.make_login_mutation(TOKEN)
#
self.assertEqual(result.get('errors')[0].get('message'), 'unknown_error') # self.assertEqual(result.get('errors')[0].get('message'), 'unknown_error')