class TestMessagesFetch(TenantTestCase):
def setUp(self):
super().setUp()
self.client = TenantClient(self.tenant)
user = get_user_model().objects.create(username="******")
user.set_password('dummypassword')
user.save()
room = Room.objects.create()
room.members.add(user)
for i in range(25):
Message.objects.create(sender=user, room=room, text=f"Message {i}")
def test_pagination(self):
logged_in = self.client.login(username="******", password="******")
assert logged_in
room_uuid = str(Room.objects.all()[0].id)
messages = Message.objects.all()[:20]
messages_array = []
for message in messages:
dict = {}
dict['sender'] = message.sender.username
dict['message'] = message.text
dict['received_room_id'] = room_uuid
dict['date_created'] = message.date_created.strftime(
"%d %b %Y %H:%M:%S %Z")
messages_array.append(dict)
response = self.client.get(f'/ajax/get-messages/{room_uuid}/?page=1',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
content = json.loads(response.content)
self.assertEqual(content, messages_array)
# Check second page
messages = Message.objects.all()[20:]
messages_array = []
for message in messages:
dict = {}
dict['sender'] = message.sender.username
dict['message'] = message.text
dict['received_room_id'] = room_uuid
dict['date_created'] = message.date_created.strftime(
"%d %b %Y %H:%M:%S %Z")
messages_array.append(dict)
response = self.client.get(f'/ajax/get-messages/{room_uuid}/?page=2',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
content = json.loads(response.content)
self.assertEqual(content, messages_array)
response = self.client.get(f'/ajax/get-messages/{room_uuid}/?page=3',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
content = json.loads(response.content)
self.assertEqual(content, [])
class SharedFranchiseListAPIViewWithPublicSchemaTestCase(
APITestCase, TenantTestCase):
"""
Console:
python manage.py test shared_api.tests.test_franchise_list_views
"""
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(SharedFranchiseListAPIViewWithPublicSchemaTestCase, self).setUp()
self.anon_client = TenantClient(self.tenant)
call_command('init_app', verbosity=0)
# Update the tenant.
self.tenant.name = 'Over 55 (London) Inc.',
self.tenant.alternate_name = "Over55",
self.tenant.description = "Located at the Forks of the Thames in ...",
self.tenant.address_country = "CA",
self.tenant.address_locality = "London",
self.tenant.address_region = "Ontario",
self.tenant.post_office_box_number = "", # Post Offic #
self.tenant.postal_code = "N6H 1B4",
self.tenant.street_address = "78 Riverside Drive",
self.tenant.street_address_extra = "", # Extra line.
self.tenant.save()
@transaction.atomic
def tearDown(self):
del self.anon_client
super(SharedFranchiseListAPIViewWithPublicSchemaTestCase,
self).tearDown()
@transaction.atomic
def test_anonymous_get_with_200(self):
url = reverse('workery_franchise_list_create_api_endpoint')
response = self.anon_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("London", str(response.data))
self.assertIn("Ontario", str(response.data))
@transaction.atomic
def test_anonymous_search_get_with_200_(self):
url = reverse('workery_franchise_list_create_api_endpoint'
) + "?format=json&search=London"
response = self.anon_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("London", str(response.data))
self.assertIn("Ontario", str(response.data))
class BaseSetup(TenantTestCase):
def setUp(self):
super().setUp()
self.c = TenantClient(self.tenant)
def test_role_list_view(self):
response = self.c.get(reverse('roles:roles'))
self.assertEqual(response.status_code, 200)
def test_role_create_view(self):
response = self.c.get(reverse('roles:create'))
self.assertEqual(response.status_code, 200)
class BaseSetup(TenantTestCase):
def setUp(self):
super().setUp()
self.c = TenantClient(self.tenant)
# test para proba que existe una vista de listar usuarios
def test_user_list_view(self):
response = self.c.get(reverse('users:users'))
self.assertEqual(response.status_code, 200)
#comentario 2 modificado
def test_user_create_view(self):
response = self.c.get(reverse('users:create'))
self.assertEqual(response.status_code, 200)
class FoundationPublicDecoratorWithTenantSchemaTestCase(TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Tenant Schema"""
tenant.schema_name = 'galactic'
tenant.name = "Galactic Alliance of Humankind"
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@transaction.atomic
def setUp(self):
super(FoundationPublicDecoratorWithTenantSchemaTestCase, self).setUp()
self.c = TenantClient(self.tenant)
@transaction.atomic
def tearDown(self):
# users = User.objects.all()
# for user in users.all():
# user.delete()
super(FoundationPublicDecoratorWithTenantSchemaTestCase,
self).tearDown()
@transaction.atomic
def test_tenant_required_decorator_with_access_granted(self):
response = self.c.get(reverse('tenant_is_valid'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'access-granted', response.content)
class TestTenantDashboardViews(TenantTestCase):
"""
Console:
python manage.py test tenant_dashboard.tests.test_web_views
"""
@classmethod
def setUpClass(cls):
"""
Run at the beginning before all the unit tests run.
"""
super().setUpClass()
def setUp(self):
"""
Run at the beginning of every unit test.
"""
super(TestTenantDashboardViews, self).setUp()
# Setup our app and account.
call_command('init_app', verbosity=0)
call_command(
'create_shared_account',
TEST_USER_EMAIL,
TEST_USER_PASSWORD,
"Bart",
"Mika",
verbosity=0
)
# Get user and credentials.
user = SharedUser.objects.get()
token, orig_iat = get_jwt_token_and_orig_iat(user)
# Setup our clients.
self.anon_c = TenantClient(self.tenant)
self.auth_c = TenantClient(self.tenant, HTTP_AUTHORIZATION='JWT {0}'.format(token))
self.auth_c.login(
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD
)
def tearDown(self):
"""
Run at the end of every unit test.
"""
# Delete previous data.
SharedUser.objects.all().delete()
# Delete our clients.
del self.anon_c
del self.auth_c
# Finish teardown.
super(TestTenantDashboardViews, self).tearDown()
def test_master_page(self):
response = self.auth_c.get(self.tenant.reverse('workery_tenant_dashboard_master'))
self.assertEqual(response.status_code, 200)
self.assertIn('Dashboard', str(response.content))
class TestUsernames(TenantTestCase):
def setUp(self):
super().setUp()
self.client = TenantClient(self.tenant)
for i in range(5):
user = get_user_model().objects.create(
**{get_user_model().USERNAME_FIELD: f"user{i}"})
user.set_password("dummypassword")
user.save()
def test_users_list_view(self):
logged_in = self.client.login(**{
get_user_model().USERNAME_FIELD: "user0",
'password': "******"
})
found = resolve(reverse('django_chatter:users_list'))
self.assertEqual(found.func, users_list)
response = self.client.get(reverse('django_chatter:users_list'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
json_array = []
for user in get_user_model().objects.all():
dict = {}
dict["id"] = user.pk
dict["text"] = user.get_username()
json_array.append(dict)
self.assertEqual(response.status_code, 200)
self.assertEqual(str(response.content, encoding='utf-8'),
json.dumps(json_array))
class GetIsUniqueWithPublicSchemaTestCase(APITestCase, TenantTestCase):
"""
Console:
python manage.py test shared_api.tests.test_get_is_unique_views
"""
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(GetIsUniqueWithPublicSchemaTestCase, self).setUp()
self.c = TenantClient(self.tenant)
call_command('init_app', verbosity=0)
call_command('create_shared_account',
TEST_USER_EMAIL,
TEST_USER_PASSWORD,
"Bart",
"Mika",
verbosity=0)
@transaction.atomic
def tearDown(self):
users = SharedUser.objects.all()
for user in users.all():
user.delete()
del self.c
super(GetIsUniqueWithPublicSchemaTestCase, self).tearDown()
@transaction.atomic
def test_anonymous_get_with_200(self):
# CASE 1 OF 2:
url = reverse(
'at_get_is_unique_api_endpoint') + "?email=" + TEST_USER_EMAIL
response = self.c.get(url, {}, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(1, int(response.content))
# CASE 2 OF 2:
url = reverse('at_get_is_unique_api_endpoint'
) + "[email protected]"
response = self.c.get(url, {}, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(0, int(response.content))
def test_tenantmemiddleware_with_unauthenticated_user_in_public_schema(
self):
# Verify that no "Me" objects are created.
self.assertEqual(Me.objects.all().count(), 0)
# Run the test.
client = TenantClient(self.tenant)
response = client.get(reverse('public_home'))
self.assertEqual(response.status_code, 200)
# Verify that no "Me" objects are created.
self.assertEqual(Me.objects.all().count(), 0)
class TestHomeViews(TenantTestCase):
"""
Class used to test the "views".
Console:
python manage.py test shared_home.tests.test_views
"""
def setUp(self):
super(TestHomeViews, self).setUp()
self.c = TenantClient(self.tenant)
def tearDown(self):
del self.c
def test_get_index_page(self):
response = self.c.get(reverse('at_index_master'))
self.assertEqual(response.status_code, 200)
def test_http_404_page(self):
response = self.c.get('la-la-la-la-la-la-la-la-la-la-la')
self.assertEqual(response.status_code, 404)
class APICountryAndProvinceViewslWithSchemaTestCase(APITestCase,
TenantTestCase):
"""
Console:
python manage.py test shared_api.tests.views.test_country_and_province_views
"""
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(APICountryAndProvinceViewslWithSchemaTestCase, self).setUp()
self.c = TenantClient(self.tenant)
call_command('init_app', verbosity=0)
@transaction.atomic
def tearDown(self):
SharedUser.objects.delete_all()
del self.c
super(APICountryAndProvinceViewslWithSchemaTestCase, self).tearDown()
@transaction.atomic
def test_country_api_endpoint_with_success(self):
# Log out.
url = reverse('workery_get_countries_api_endpoint')
data = {}
response = self.c.get(url, data, content_type='application/json')
# Confirm.
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_province_api_endpoint_with_success(self):
# Log out.
url = reverse('workery_get_provinces_api_endpoint')
data = {}
response = self.c.get(url, data, content_type='application/json')
# Confirm.
self.assertEqual(response.status_code, status.HTTP_200_OK)
class TestIndexView(TenantTestCase):
def setUp(self):
super().setUp()
self.client = TenantClient(self.tenant)
user = get_user_model().objects.create(username="******")
user.set_password('dummypassword')
user.save()
room = Room.objects.create()
room.members.add(user)
message_1 = Message.objects.create(
sender=user,
text="first message",
room=room
)
message_2 = Message.objects.create(
sender=user,
text="last message",
room=room
)
def test_chat_render_view(self):
logged_in = self.client.login(username="******", password="******")
found = resolve(reverse('django_chatter:index'))
self.assertEqual(
type(found.func), type(IndexView.as_view())
)
response = self.client.get(reverse('django_chatter:index'), follow=True)
self.assertEqual(response.status_code, 200)
room = Room.objects.all()[0]
room_url = f"/chat/{room.id}/"
message = Message.objects.all()[0]
self.assertEqual(response.redirect_chain[0][0], room_url)
self.assertEqual(str(room.id), response.context['room_uuid_json'])
self.assertEqual(
str(response.context['latest_messages_curr_room']),
str(Message.objects.all())
)
self.assertEqual(response.context['room_name'], 'Notes to Yourself')
self.assertTemplateUsed(response, 'django_chatter/base.html')
self.assertTemplateUsed(response, 'django_chatter/chat-window.html')
self.assertTemplateUsed(response, 'django_chatter/chatroom-list.html')
self.assertQuerysetEqual(
response.context['rooms_with_unread'],
Room.objects.none()
)
def test_token_middleware_with_authentication_with_token(self):
# Setup
email = self.user.email.lower(
) # Emails should be case-insensitive unique
converted = email.encode(
'utf8', 'ignore') # Deal with internationalized email addresses
self.user.username = base64.urlsafe_b64encode(
hashlib.sha256(converted).digest())[:30]
self.user.save()
# Test
token = Token.objects.get(user__email=TEST_USER_EMAIL)
authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
authenticated_user = authorized_client.login(
username=TEST_USER_EMAIL, password=TEST_USER_PASSWORD)
self.assertTrue(authenticated_user)
response = authorized_client.get(reverse('public_home'))
self.assertEqual(response.status_code, 200)
class TodoGroupTestAPI(APITestCase, DjangoReduxTestCases):
def setUp(self):
self.data = {
'name': 'todo group',
}
self.client = TenantClient(self.tenant)
@patch.object(DjangoReduxJWTAuthentication, 'authenticate')
def test_create_todo_group_api(self, mock):
mock.return_value = self.account, {}
response = self.client.post(reverse('todo:todo-group-list'), self.data)
self.assertEquals(response.status_code, HTTP_201_CREATED)
@patch.object(DjangoReduxJWTAuthentication, 'authenticate')
def test_get_todo_group_by_id_api(self, mock):
mock.return_value = self.account, {}
response = self.client.post(reverse('todo:todo-group-list'), self.data)
self.assertEquals(response.status_code, HTTP_201_CREATED)
id = response.data['id']
response = self.client.get(
reverse('todo:todo-group-detail', kwargs={'pk': id}))
self.assertEquals(response.status_code, HTTP_200_OK)
self.assertEquals(response.data['name'], self.data['name'])
@patch.object(DjangoReduxJWTAuthentication, 'authenticate')
def test_update_todo_group_api(self, mock):
mock.return_value = self.account, {}
response = self.client.post(reverse('todo:todo-group-list'), self.data)
self.assertEquals(response.status_code, HTTP_201_CREATED)
id = response.data['id']
self.data['name'] = 'update todo group'
response = self.client.put(path=reverse('todo:todo-group-detail',
kwargs={'pk': id}),
data=json.dumps(self.data),
content_type='application/json')
self.assertEquals(response.status_code, HTTP_200_OK)
self.assertEquals(response.data['name'], 'update todo group')
def test_tenantmemiddleware_with_authenticated_user_in_tenant_schema(self):
# Verify that no "Me" objects are created.
self.assertEqual(Me.objects.all().count(), 0)
# Create our User and run our test.
user = User.objects.create_user( # Create our User.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD,
first_name=TEST_USER_FIRSTNAME,
last_name=TEST_USER_LASTNAME,
)
user.is_active = True
user.save()
token = Token.objects.get(user=user)
client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' + token.key)
client.login(username=TEST_USER_USERNAME, password=TEST_USER_PASSWORD)
response = client.get(reverse('public_home'))
self.assertEqual(response.status_code, 200)
# Verify
me = Me.objects.get_by_owner_or_none(owner=user)
self.assertIsNotNone(me)
class APICityOptionWithTenantSchemaTestCase(APITestCase, TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Tenant Schema"""
tenant.schema_name = 'galacticallianceofhumankind'
tenant.name = "Galactic Alliance of Humankind"
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
user = User.objects.create_user( # Create our user.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
user.is_superuser = True
user.is_active = True
user.save()
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English.
super(APICityOptionWithTenantSchemaTestCase, self).setUp()
# Initialize our test data.
self.user = User.objects.get()
token = Token.objects.get(user__username=TEST_USER_USERNAME)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
# Above taken from:
# http://www.django-rest-framework.org/api-guide/testing/#authenticating
@transaction.atomic
def tearDown(self):
ProvinceOption.objects.delete_all()
CityOption.objects.delete_all()
PostalAddress.objects.delete_all()
ContactPoint.objects.delete_all()
Me.objects.delete_all()
users = User.objects.all()
for user in users.all():
user.delete()
# super(APICityOptionWithTenantSchemaTestCase, self).tearDown()
@transaction.atomic
def test_list(self):
response = self.unauthorized_client.get('/api/tenantcityoption/')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_list_with_authentication(self):
response = self.authorized_client.get('/api/tenantcityoption/')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_post(self):
data = {
'name': 'Unit Test',
}
response = self.unauthorized_client.post(
'/api/tenantcityoption/',
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_post_with_authentication(self):
country = CountryOption.objects.create(
id=1,
name="Unit Test",
)
province = ProvinceOption.objects.create(
id=1,
name="Unit Test",
country=country,
)
data = {
'name': 'Unit Test',
'country': country.id,
'province': province.id
}
response = self.authorized_client.post('/api/tenantcityoption/',
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
@transaction.atomic
def test_put(self):
# Create a new object with our specific test data.
country = CountryOption.objects.create(
id=1,
name="Unit Test",
)
province = ProvinceOption.objects.create(
id=1,
name="Unit Test",
country=country,
)
city = CityOption.objects.create(
id=1,
name="Unit Test",
country=country,
province=province,
)
# Run the test.
data = {
'id': 1,
'name': 'Unit Test',
'country': country.id,
'province': province.id,
'city': city.id,
}
response = self.unauthorized_client.put(
'/api/tenantcityoption/1/',
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_put_with_authorization(self):
# Create a new object with our specific test data.
country = CountryOption.objects.create(
id=1,
name="Unit Test",
)
province = ProvinceOption.objects.create(
id=1,
name="Unit Test",
country=country,
)
city = CityOption.objects.create(
id=1,
name="Unit Test",
country=country,
province=province,
)
# Run the test.
data = {
'id': 1,
'name': 'Unit Test',
'country': country.id,
'province': province.id,
'city': city.id,
}
response = self.authorized_client.put('/api/tenantcityoption/1/',
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_delete(self):
response = self.unauthorized_client.delete('/api/tenantcityoption/1/')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_delete_with_authentication(self):
country = CountryOption.objects.create(
id=1,
name="Unit Test",
)
province = ProvinceOption.objects.create(
id=1,
name="Unit Test",
country=country,
)
city = CityOption.objects.create(
id=1,
name="Unit Test",
country=country,
province=province,
)
response = self.authorized_client.delete('/api/tenantcityoption/1/')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
class TestTenantOngoingOrderOperationViews(TenantTestCase):
"""
Console:
python manage.py test tenant_ongoing_order_operation.tests
"""
#------------------#
# Setup Unit Tests #
#------------------#
def setup_tenant(tenant):
"""Tenant Schema"""
tenant.schema_name = TEST_SCHEMA_NAME
tenant.name = 'Over 55 (London) Inc.',
tenant.alternate_name = "Over55",
tenant.description = "Located at the Forks of the Thames in ...",
tenant.address_country = "CA",
tenant.address_locality = "London",
tenant.address_region = "Ontario",
tenant.post_office_box_number = "", # Post Offic #
tenant.postal_code = "N6H 1B4",
tenant.street_address = "78 Riverside Drive",
tenant.street_address_extra = "", # Extra line.
@classmethod
def setUpClass(cls):
"""
Run at the beginning before all the unit tests run.
"""
super().setUpClass()
def setUp(self):
"""
Run at the beginning of every unit test.
"""
super(TestTenantOngoingOrderOperationViews, self).setUp()
# Setup our app and account.
call_command('init_app', verbosity=0)
call_command('populate_tenant_content', TEST_SCHEMA_NAME, verbosity=0)
call_command('populate_tenant_sample_db',
TEST_SCHEMA_NAME,
verbosity=0)
# Get user and credentials.
user = SharedUser.objects.get(email="*****@*****.**")
token, orig_iat = get_jwt_token_and_orig_iat(user)
# Setup our clients.
self.anon_c = TenantClient(self.tenant)
self.auth_c = TenantClient(self.tenant,
HTTP_AUTHORIZATION='JWT {0}'.format(token))
self.auth_c.login(username="******",
password="******")
def tearDown(self):
"""
Run at the end of every unit test.
"""
# Delete previous data.
SharedUser.objects.all().delete()
# Delete our clients.
del self.anon_c
del self.auth_c
# Finish teardown.
super(TestTenantOngoingOrderOperationViews, self).tearDown()
def test_ongoing_job_assign_operation_page(self):
ongoing_work = OngoingWorkOrder.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_ongoing_job_assign_operation',
reverse_args=[int(ongoing_work.id)])
a_url += "?return_id=lite-retrieve"
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_ongoing_job_assign_confirm_operation_page(self):
ongoing_work = OngoingWorkOrder.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_ongoing_job_assign_confirm_operation',
reverse_args=[int(ongoing_work.id)])
a_url += "?return_id=lite-retrieve"
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_ongoing_job_unassign_operation_page(self):
ongoing_work = OngoingWorkOrder.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_ongoing_job_unassign_operation',
reverse_args=[int(ongoing_work.id)])
a_url += "?return_id=lite-retrieve"
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_ongoing_job_close_operation_page(self):
ongoing_work = OngoingWorkOrder.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_ongoing_job_close_operation',
reverse_args=[int(ongoing_work.id)])
a_url += "?return_id=lite-retrieve"
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_ongoing_job_creation_wizard_operation_page(self):
ongoing_work = OngoingWorkOrder.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_ongoing_job_creation_wizard_operation',
reverse_args=[int(ongoing_work.id)])
a_url += "?return_id=lite-retrieve"
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_ongoing_job_follow_up_operation_page(self):
ongoing_work = OngoingWorkOrder.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_ongoing_job_follow_up_operation',
reverse_args=[int(ongoing_work.id)])
a_url += "?return_id=lite-retrieve"
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_ongoing_job_completion_survey_operation_page(self):
ongoing_work = OngoingWorkOrder.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_ongoing_job_completion_survey_operation',
reverse_args=[int(ongoing_work.id)])
a_url += "?return_id=lite-retrieve"
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_ongoing_job_postpone_operation_page(self):
ongoing_work = OngoingWorkOrder.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_ongoing_job_postpone_operation',
reverse_args=[int(ongoing_work.id)])
a_url += "?return_id=lite-retrieve"
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class APITagWithTenantSchemaTestCase(APITestCase, TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Tenant Schema"""
tenant.schema_name = 'galacticalliance'
tenant.name = "Galactic Alliance of Humankind"
tenant.has_perks=True
tenant.has_mentors=True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(id=constants.ENTREPRENEUR_GROUP_ID, name="Entreprenuer",),
Group(id=constants.MENTOR_GROUP_ID, name="Mentor",),
Group(id=constants.ADVISOR_GROUP_ID, name="Advisor",),
Group(id=constants.ORGANIZATION_MANAGER_GROUP_ID, name="Org Manager",),
Group(id=constants.ORGANIZATION_ADMIN_GROUP_ID, name="Org Admin",),
Group(id=constants.CLIENT_MANAGER_GROUP_ID, name="Client Manager",),
Group(id=constants.SYSTEM_ADMIN_GROUP_ID, name="System Admin",),
])
org_admin_group = Group.objects.get(id=constants.ORGANIZATION_ADMIN_GROUP_ID)
user = User.objects.create_user( # Create our user.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD
)
user.is_superuser = True
user.is_active = True
user.groups.add(org_admin_group)
user.save()
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English.
super(APITagWithTenantSchemaTestCase, self).setUp()
# Initialize our test data.
self.user = User.objects.get()
token = Token.objects.get(user__username=TEST_USER_USERNAME)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.authorized_client = TenantClient(self.tenant, HTTP_AUTHORIZATION='Token ' + token.key)
self.authorized_client.login(
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD
)
self.tenant.owner = self.user
self.tenant.save()
# Above taken from:
# http://www.django-rest-framework.org/api-guide/testing/#authenticating
# Initialize our test data.
Tag.objects.bulk_create([
Tag(name='1'),
Tag(name='2'),
Tag(name='3'),
])
@transaction.atomic
def tearDown(self):
Tag.objects.delete_all()
PostalAddress.objects.delete_all()
ContactPoint.objects.delete_all()
Me.objects.delete_all()
users = User.objects.all()
for user in users.all():
user.delete()
# super(APITagWithTenantSchemaTestCase, self).tearDown()
@transaction.atomic
def test_list_with_anonymous_user(self):
response = self.unauthorized_client.get('/api/tenanttag/')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_list_with_authenticated_management_group_user(self):
response = self.authorized_client.get('/api/tenanttag/')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_list_with_authenticated_advisor_group_user(self):
# Change Group that the User belongs in.
org_admin_group = Group.objects.get(id=constants.ORGANIZATION_ADMIN_GROUP_ID)
advisor_group = Group.objects.get(id=constants.ADVISOR_GROUP_ID)
self.user.groups.remove(org_admin_group)
self.user.groups.add(advisor_group)
self.user.save()
# Test and verify.
response = self.authorized_client.get('/api/tenanttag/')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_post_with_anonymous_user(self):
data = {
'name': 'Unit Test',
}
response = self.unauthorized_client.post('/api/tenanttag/', json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_post_with_authenticated_management_group_user(self):
# Run the test and verify.
data = {
'name': 'Unit Test',
}
response = self.authorized_client.post('/api/tenanttag/', json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
@transaction.atomic
def test_post_with_authenticated_advisor_group_user(self):
# Change Group that the User belongs in.
org_admin_group = Group.objects.get(id=constants.ORGANIZATION_ADMIN_GROUP_ID)
advisor_group = Group.objects.get(id=constants.ADVISOR_GROUP_ID)
self.user.groups.remove(org_admin_group)
self.user.groups.add(advisor_group)
self.user.save()
# Test and verify.
data = {
'name': 'Unit Test',
}
response = self.authorized_client.post('/api/tenanttag/', json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@transaction.atomic
def test_put_with_anonymous_user(self):
# Delete any previous data.
items = Tag.objects.all()
for item in items.all():
item.delete()
# Create a new object with our specific test data.
Tag.objects.create(
id=1,
name="Unit Test",
)
# Run the test.
data = {
'id': 1,
'name': 'Unit Test',
}
response = self.unauthorized_client.put('/api/tenanttag/1/', json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_put_with_authenticated_management_user(self):
# Delete any previous data.
items = Tag.objects.all()
for item in items.all():
item.delete()
# Create a new object with our specific test data.
Tag.objects.create(
id=1,
name="Unit Test",
)
# Run the test.
data = {
'id': 1,
'name': 'Unit Test',
}
response = self.authorized_client.put('/api/tenanttag/1/', json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_put_with_authenticated_advisor_user(self):
# Change Group that the User belongs in.
org_admin_group = Group.objects.get(id=constants.ORGANIZATION_ADMIN_GROUP_ID)
advisor_group = Group.objects.get(id=constants.ADVISOR_GROUP_ID)
self.user.groups.remove(org_admin_group)
self.user.groups.add(advisor_group)
self.user.save()
# Delete any previous data.
items = Tag.objects.all()
for item in items.all():
item.delete()
# Create a new object with our specific test data.
Tag.objects.create(
id=1,
name="Unit Test",
)
# Run the test.
data = {
'id': 1,
'name': 'Unit Test',
}
response = self.authorized_client.put('/api/tenanttag/1/', json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@transaction.atomic
def test_delete_with_anonymous_user(self):
response = self.unauthorized_client.delete('/api/tenanttag/1/')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_delete_with_authenticated_management_user(self):
response = self.authorized_client.delete('/api/tenanttag/1/')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
@transaction.atomic
def test_delete_with_authenticated_advisor_user(self):
# Change Group that the User belongs in.
org_admin_group = Group.objects.get(id=constants.ORGANIZATION_ADMIN_GROUP_ID)
advisor_group = Group.objects.get(id=constants.ADVISOR_GROUP_ID)
self.user.groups.remove(org_admin_group)
self.user.groups.add(advisor_group)
self.user.save()
# Run test and verify.
response = self.authorized_client.delete('/api/tenanttag/1/')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
class WorkspaceAPIWithTenantSchemaTestCase(APITestCase, FastTenantTestCase):
fixtures = []
@staticmethod
def get_test_schema_name():
return 'galacticalliance'
def setup_tenant(self, tenant):
"""Tenant Schema"""
tenant.schema_name = 'galacticalliance'
tenant.name = "Galactic Alliance of Humankind"
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
user = User.objects.create_user( # Create our user.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
user.is_active = True
user.save()
group = Group.objects.get(id=constants.ORGANIZATION_ADMIN_GROUP_ID)
user.groups.add(group)
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English.
# Initialize our test data.
self.user = User.objects.get()
token = Token.objects.get(user__username=TEST_USER_USERNAME)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
Workspace.objects.bulk_create([
Workspace(owner=self.user),
Workspace(owner=self.user),
Workspace(owner=self.user),
])
# Above taken from:
# http://www.django-rest-framework.org/api-guide/testing/#authenticating
@transaction.atomic
def tearDown(self):
Workspace.objects.delete_all()
PostalAddress.objects.delete_all()
ContactPoint.objects.delete_all()
Workspace.objects.delete_all()
FileUpload.objects.delete_all()
Me.objects.delete_all()
users = User.objects.all()
for user in users.all():
user.delete()
# super(WorkspaceAPIWithTenantSchemaTestCase, self).tearDown()
@transaction.atomic
def test_list(self):
response = self.unauthorized_client.get('/api/tenantworkspace/')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_list_with_authentication(self):
response = self.authorized_client.get('/api/tenantworkspace/')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_post_with_anonymous_user(self):
data = {
'name': 'Unit Test',
'description': 'Used for unit testing purposes.',
'owner': self.user.id
}
response = self.unauthorized_client.post('/api/tenantworkspace/',
data,
format="json")
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_post_with_non_management_user(self):
for group in self.user.groups.all():
group.delete()
data = {
'name': 'Unit Test',
'description': 'Used for unit testing purposes.',
'owner': self.user.id,
'type_of': constants.INFO_RESOURCE_INTERAL_URL_TYPE,
'url': 'http://smegurus.com'
}
response = self.authorized_client.post('/api/tenantworkspace/',
data,
format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@transaction.atomic
def test_post_with_authentication(self):
# CASE 1 OF 5: SUCCESS
data = {
'name': 'Unit Test',
'description': 'Used for unit testing purposes.',
'owner': self.user.id,
'type_of': constants.INFO_RESOURCE_INTERAL_URL_TYPE,
'url': 'http://smegurus.com'
}
response = self.authorized_client.post('/api/tenantworkspace/',
data,
format="json")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
@transaction.atomic
def test_put(self):
# Create a new object with our specific test data.
Workspace.objects.create(id=999,
name="Unit Test",
description="Used for unit testing purposes.")
# Run the test.
data = {
'id': 999,
'name': 'Unit Test',
'description': 'Used for unit testing purposes.',
'owner': self.user.id
}
response = self.unauthorized_client.put(
'/api/tenantworkspace/999/',
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_put_with_authorization(self):
# Create a new object with our specific test data.
Workspace.objects.create(id=666,
name="Unit Test",
description="Used for unit testing purposes.",
owner_id=self.user.id)
# Run the test.
data = {
'id': 666,
'name': 'Unit Test',
'description': 'Used for unit testing purposes.',
'owner': self.user.id
}
response = self.authorized_client.put('/api/tenantworkspace/666/',
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_delete(self):
Workspace.objects.create(id=999,
name="Unit Test",
description="Used for unit testing purposes.")
response = self.unauthorized_client.delete('/api/tenantworkspace/999/')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_delete_with_authentication(self):
Workspace.objects.create(id=999,
name="Unit Test",
description="Used for unit testing purposes.")
response = self.authorized_client.delete('/api/tenantworkspace/999/')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
class TestTenantReportViews(TenantTestCase):
"""
Console:
python manage.py test tenant_report.tests.test_views.TestTenantReportViews
"""
#------------------#
# Setup Unit Tests #
#------------------#
def setup_tenant(tenant):
"""Tenant Schema"""
tenant.schema_name = TEST_SCHEMA_NAME
tenant.name = 'Over 55 (London) Inc.',
tenant.alternate_name = "Over55",
tenant.description = "Located at the Forks of the Thames in ...",
tenant.address_country = "CA",
tenant.address_locality = "London",
tenant.address_region = "Ontario",
tenant.post_office_box_number = "", # Post Offic #
tenant.postal_code = "N6H 1B4",
tenant.street_address = "78 Riverside Drive",
tenant.street_address_extra = "", # Extra line.
@classmethod
def setUpClass(cls):
"""
Run at the beginning before all the unit tests run.
"""
super().setUpClass()
def setUp(self):
"""
Run at the beginning of every unit test.
"""
super(TestTenantReportViews, self).setUp()
# Setup our app and account.
call_command('init_app', verbosity=0)
call_command('populate_tenant_content', TEST_SCHEMA_NAME, verbosity=0)
call_command('populate_tenant_sample_db',
TEST_SCHEMA_NAME,
verbosity=0)
# Create the account.
call_command(
'create_tenant_account',
TEST_SCHEMA_NAME,
MANAGEMENT_GROUP_ID,
TEST_USER_EMAIL,
TEST_USER_PASSWORD,
"Bart",
"Mika",
TEST_USER_TEL_NUM,
TEST_USER_TEL_EX_NUM,
TEST_USER_CELL_NUM,
"CA",
"London",
"Ontario",
"", # Post Offic #
"N6H 1B4",
"78 Riverside Drive",
"", # Extra line.
verbosity=0)
# Get user and credentials.
user = SharedUser.objects.filter(email=TEST_USER_EMAIL).first()
token, orig_iat = get_jwt_token_and_orig_iat(user)
# Setup our clients.
self.anon_c = TenantClient(self.tenant)
self.auth_c = TenantClient(self.tenant,
HTTP_AUTHORIZATION='JWT {0}'.format(token))
self.auth_c.login(username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
TaskItem.objects.update_or_create(
id=1,
defaults={
'id':
1,
'type_of':
FOLLOW_UP_CUSTOMER_SURVEY_TASK_ITEM_TYPE_OF_ID,
'title':
_('Completion Survey'),
'description':
_('Please call up the client and perform the satisfaction survey.'
),
'due_date':
timezone.now(),
'is_closed':
False,
'job':
None,
'ongoing_job':
None,
# 'created_by': None,
# created_from
# created_from_is_public
# last_modified_by
})
def tearDown(self):
"""
Run at the end of every unit test.
"""
# Delete previous data.
SharedUser.objects.delete_all()
TaskItem.objects.delete_all()
# Delete our clients.
del self.anon_c
del self.auth_c
# Finish teardown.
super(TestTenantReportViews, self).tearDown()
def test_report_listing_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_reports_list_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
def test_report_1_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_01_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Service Fee', str(response.content))
def test_report_2_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_02_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Associate Jobs Report', str(response.content))
def test_report_3_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_03_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Service Fees by Skill Set Report',
str(response.content))
def test_report_4_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_04_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Cancelled Jobs Report', str(response.content))
def test_report_5_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_05_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Associate Insurance Report', str(response.content))
def test_report_6_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_06_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Associate Police Check Due Date Report',
str(response.content))
def test_report_7_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_07_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Associate Birthdays Report', str(response.content))
def test_report_8_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_08_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Associate Skill Sets Report', str(response.content))
def test_report_9_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_09_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Client Addresses Report', str(response.content))
def test_report_10_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_10_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Jobs Report', str(response.content))
def test_report_11_details_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_report_11_detail_master'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Reports', str(response.content))
self.assertIn('Commercial Jobs Report', str(response.content))
class SMEGurusTokenMiddlewareWithPublicSchemaTestCase(APITestCase,
TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Public Schema"""
tenant.schema_name = 'test' # Do not change this!
tenant.name = "Galactic Alliance of Humankind"
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
user = User.objects.create_user( # Create our User.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
user.is_active = True
user.save()
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(SMEGurusTokenMiddlewareWithPublicSchemaTestCase, self).setUp()
self.c = TenantClient(self.tenant)
self.user = User.objects.get()
@transaction.atomic
def tearDown(self):
users = User.objects.all()
for user in users.all():
user.delete()
groups = Group.objects.all()
for group in groups.all():
group.delete()
# super(SMEGurusTokenMiddlewareWithPublicSchemaTestCase, self).tearDown()
@transaction.atomic
def test_token_middleware_with_authentication_with_token(self):
# Setup
email = self.user.email.lower(
) # Emails should be case-insensitive unique
converted = email.encode(
'utf8', 'ignore') # Deal with internationalized email addresses
self.user.username = base64.urlsafe_b64encode(
hashlib.sha256(converted).digest())[:30]
self.user.save()
# Test
token = Token.objects.get(user__email=TEST_USER_EMAIL)
authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
authenticated_user = authorized_client.login(
username=TEST_USER_EMAIL, password=TEST_USER_PASSWORD)
self.assertTrue(authenticated_user)
response = authorized_client.get(reverse('public_home'))
self.assertEqual(response.status_code, 200)
@transaction.atomic
def test_token_middleware_with_anonymous_user(self):
response = self.c.get(reverse('public_home'))
self.assertEqual(response.status_code, 200)
@transaction.atomic
def test_token_middleware_with_authentication_without_token(self):
# Setup
email = self.user.email.lower(
) # Emails should be case-insensitive unique
converted = email.encode(
'utf8', 'ignore') # Deal with internationalized email addresses
self.user.username = base64.urlsafe_b64encode(
hashlib.sha256(converted).digest())[:30]
self.user.save()
# Test
token = Token.objects.get(user__email=TEST_USER_EMAIL)
authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
authenticated_user = authorized_client.login(
username=TEST_USER_EMAIL, password=TEST_USER_PASSWORD)
self.assertTrue(authenticated_user)
token = Token.objects.get(user__email=TEST_USER_EMAIL)
token.delete()
response = authorized_client.get(reverse('public_home'))
self.assertEqual(response.status_code, 200)
class TenantCalendarTestCases(APITestCase, TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Tenant Schema"""
tenant.schema_name = 'galacticalliance'
tenant.name = "Galactic Alliance of Humankind"
tenant.is_setup = True
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
User.objects.bulk_create([
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
])
user = User.objects.create_user( # Create our User.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
user.is_active = True
user.save()
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(TenantCalendarTestCases, self).setUp()
# Initialize our test data.
self.user = User.objects.get(username=TEST_USER_USERNAME)
token = Token.objects.get(user=self.user)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
self.authorized_client.login(username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
# Update Organization.
self.tenant.users.add(self.user)
self.tenant.save()
# Create our Profile.
country = CountryOption.objects.create(id=1, name='Avalan')
province = ProvinceOption.objects.create(id=1,
name='Colony 01',
country=country)
city = CityOption.objects.create(
id=1,
name='Megazone 23',
province=province,
country=country,
)
self.me = Me.objects.create(
owner=self.user,
is_in_intake=True,
address=PostalAddress.objects.create(
country=CountryOption.objects.get(id=1),
region=ProvinceOption.objects.get(id=1),
locality=CityOption.objects.get(id=1),
owner=self.user))
@transaction.atomic
def tearDown(self):
PostalAddress.objects.delete_all()
ContactPoint.objects.delete_all()
CityOption.objects.delete_all()
ProvinceOption.objects.delete_all()
CountryOption.objects.delete_all()
Me.objects.delete_all()
users = User.objects.all()
for user in users.all():
user.delete()
# super(TenantCalendarTestCases, self).tearDown()
@transaction.atomic
def test_calendar_master_page(self):
url = reverse('tenant_calendar_master')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Calendar', response.content)
@transaction.atomic
def test_calendar_details_page(self):
calendar_event = CalendarEvent.objects.create(
id=666,
owner=self.user,
name='Celebrate victorious battle of Hideauze',
description='Come and celebrate!',
start='1980-01-01',
finish='1980-01-01',
)
calendar_event.pending.add(self.me)
url = reverse('tenant_calendar_details_edit',
args=[
calendar_event.id,
])
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Calendar', response.content)
@transaction.atomic
def test_calendar_info_page(self):
calendar_event = CalendarEvent.objects.create(
id=666,
owner=self.user,
name='Celebrate victorious battle of Hideauze',
description='Come and celebrate!',
start='1980-01-01',
finish='1980-01-01',
)
calendar_event.pending.add(self.me)
url = reverse('tenant_calendar_details_info',
args=[
calendar_event.id,
])
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Calendar', response.content)
@transaction.atomic
def test_calendar_created_page(self):
url = reverse('tenant_calendar_create')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Calendar', response.content)
class TestPortalDashView(BaseTenantTestCase):
def test_get(self):
self.client = TenantClient(self.tenant)
response = self.client.get(reverse("management:dashboard"))
self.assertEqual(response.status_code, status.HTTP_200_OK)
class PublicIndexTestCase(TenantTestCase):
fixtures = [
# 'banned_domains.json',
# 'banned_ips.json',
# 'banned_words.json',
# 'groups',
# 'permissions',
]
def setup_tenant(self, tenant):
"""Public Schema"""
tenant.schema_name = 'test' # Do not change this!
tenant.name = "Galactic Alliance of Humankind"
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
@transaction.atomic
def setUp(self):
super(PublicIndexTestCase, self).setUp()
self.c = TenantClient(self.tenant)
@transaction.atomic
def tearDown(self):
users = User.objects.all()
for user in users.all():
user.delete()
# super(PublicIndexTestCase, self).tearDown()
@transaction.atomic
def test_index_page_view(self):
response = self.c.get(reverse('public_home'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'This is a land page.', response.content)
@transaction.atomic
def test_403_page_view(self):
response = self.c.get(reverse('public_403_error'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'403', response.content)
@transaction.atomic
def test_404_page_view(self):
response = self.c.get(reverse('public_404_error'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'404', response.content)
@transaction.atomic
def test_500_page_view(self):
response = self.c.get(reverse('public_500_error'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'500', response.content)
@transaction.atomic
def test_terms_page_view(self):
response = self.c.get(reverse('public_terms'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Terms', response.content)
class TenantDashboardTestCases(APITestCase, TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Tenant Schema"""
tenant.schema_name = 'galacticalliance'
tenant.name = "Galactic Alliance of Humankind"
tenant.is_setup = True
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
User.objects.bulk_create([
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
])
user = User.objects.create_user( # Create our User.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
user.is_active = True
user.save()
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(TenantDashboardTestCases, self).setUp()
# Initialize our test data.
self.user = User.objects.get(username=TEST_USER_USERNAME)
token = Token.objects.get(user=self.user)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
self.authorized_client.login(username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
# Update Organization.
self.tenant.users.add(self.user)
self.tenant.save()
@transaction.atomic
def tearDown(self):
PostalAddress.objects.delete_all()
ContactPoint.objects.delete_all()
Me.objects.delete_all()
users = User.objects.all()
for user in users.all():
user.delete()
items = Group.objects.all()
for item in items.all():
item.delete()
# super(TenantDashboardTestCases, self).tearDown()
@transaction.atomic
def test_dashboard_page_with_anonymous_user(self):
url = reverse('tenant_dashboard')
response = self.unauthorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_302_FOUND)
@transaction.atomic
def test_dashboard_page_with_organization_admin_user(self):
org_admin_group = Group.objects.get(
id=constants.ORGANIZATION_ADMIN_GROUP_ID)
self.user.groups.add(org_admin_group)
self.user.save()
url = reverse('tenant_dashboard')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Dashboard', response.content)
@transaction.atomic
def test_dashboard_page_with_entrepreneur_user_when_not_admitted(self):
entrepreneur_group = Group.objects.get(
id=constants.ENTREPRENEUR_GROUP_ID)
self.user.groups.add(entrepreneur_group)
self.user.save()
url = reverse('tenant_dashboard')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_302_FOUND)
@transaction.atomic
def test_dashboard_page_with_entrepreneur_user_when_admitted(self):
# Pre-configure the unit test.
entrepreneur_group = Group.objects.get(
id=constants.ENTREPRENEUR_GROUP_ID)
self.user.groups.add(entrepreneur_group)
self.user.save()
me, created = Me.objects.get_or_create(owner=self.user)
me.is_in_intake = True
me.is_setup = True
me.save()
# Run test and verify.
url = reverse('tenant_dashboard')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Dashboard', response.content)
class TenantReceptionResourceTestCases(APITestCase, TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Tenant Schema"""
tenant.schema_name = 'galacticalliance'
tenant.name = "Galactic Alliance of Humankind"
tenant.is_setup = True
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
User.objects.bulk_create([
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
])
user = User.objects.create_user( # Create our User.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
user.is_active = True
user.save()
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(TenantReceptionResourceTestCases, self).setUp()
# Initialize our test data.
self.user = User.objects.get(username=TEST_USER_USERNAME)
token = Token.objects.get(user=self.user)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
self.authorized_client.login(username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
# Update Organization.
self.tenant.users.add(self.user)
self.tenant.save()
# Setup User.
self.me = Me.objects.create(
id=666,
owner=self.user,
notify_when_task_had_an_interaction=True,
)
@transaction.atomic
def tearDown(self):
PostalAddress.objects.delete_all()
ContactPoint.objects.delete_all()
InfoResource.objects.delete_all()
SortedLogEventByCreated.objects.delete_all()
SortedCommentPostByCreated.objects.delete_all()
Me.objects.delete_all()
users = User.objects.all()
for user in users.all():
user.delete()
# super(TenantReceptionResourceTestCases, self).tearDown()
@transaction.atomic
def test_resource_master_page(self):
url = reverse('tenant_reception_resource_master')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Resource', response.content)
@transaction.atomic
def test_resource_details_page(self):
info = InfoResource.objects.create(
id=666,
owner=self.user,
name="Test",
description="Testing",
url="https://mikasoftware.com",
type_of=constants.INFO_RESOURCE_EXTERNAL_URL_TYPE)
url = reverse('tenant_reception_resource_details', args=[
info.id,
])
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
self.assertIn(b'Resource', response.content)
class APIPublicFileUploadWithPublicSchemaTestCase(APITestCase, TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Public Schema"""
tenant.schema_name = 'test'
tenant.name = "Galactic Alliance of Humankind"
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
user = User.objects.create_user( # Create our user.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
user.is_active = True
user.save()
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English.
super(APIPublicFileUploadWithPublicSchemaTestCase, self).setUp()
# Initialize our test data.
self.user = User.objects.get()
token = Token.objects.get(user__username=TEST_USER_USERNAME)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
PublicFileUpload.objects.bulk_create([
PublicFileUpload(owner=self.user),
PublicFileUpload(owner=self.user),
PublicFileUpload(owner=self.user),
])
# Above taken from:
# http://www.django-rest-framework.org/api-guide/testing/#authenticating
@transaction.atomic
def tearDown(self):
entries = PublicFileUpload.objects.all()
for entry in entries.all():
entry.delete()
users = User.objects.all()
for user in users.all():
user.delete()
super(APIPublicFileUploadWithPublicSchemaTestCase, self).tearDown()
def _create_test_file(self, path):
"""
Creates a simulated file.
Source: https://medium.com/@jxstanford/django-rest-framework-file-upload-e4bc8de669c0#.l8dbmtosq
"""
f = open(path, 'w')
f.write('test123\n')
f.close()
f = open(path, 'rb')
return {'datafile': f}
@transaction.atomic
def test_to_string(self):
# Create a new object with our specific test data.
entry = PublicFileUpload.objects.create(
id=2030,
owner=self.user,
)
entry.save()
self.assertEqual(str(entry), "")
@transaction.atomic
def test_post_with_authenticated_user(self):
# Step 1: Set the location variables.
url = reverse('publicfileupload-list')
data = self._create_test_file('/tmp/test_upload')
data['owner'] = self.user.id
# Step 2: Perform a "multiform" post using AJAX.
response = self.authorized_client.post(url, data, format='multipart')
# Step 3: Test & verify.
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertIn('created', response.data)
@transaction.atomic
def test_post(self):
# Step 1: Set the location variables.
url = reverse('publicfileupload-list')
data = self._create_test_file('/tmp/test_upload')
# Step 2: Perform a "multiform" post using AJAX.
response = self.unauthorized_client.post(url, data, format='multipart')
# Step 3: Test & verify.
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_list(self):
# Step 1: Set the location variables.
url = reverse('publicfileupload-list')
# Step 2: Test & verify.
response = self.unauthorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_list_with_authentication(self):
# Step 1: Set the location variables.
url = reverse('publicfileupload-list')
# Step 2: Test & verify.
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_list_with_banning(self):
# Step 1: Setup variables.
url = reverse('publicfileupload-list')
# Step 2: Ban self.
BannedIP.objects.create(address='127.0.0.1',
reason='For unit testing purposes.')
# Step 3: Test & verify.
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@transaction.atomic
def test_put(self):
# Delete any previous data.
uploads = PublicFileUpload.objects.all()
for upload in uploads.all():
upload.delete()
# Create a new object with our specific test data.
PublicFileUpload.objects.create(id=1, )
# Run the test.
url = reverse('publicfileupload-list') + '1/'
response = self.unauthorized_client.put(
url, json.dumps({
'id': 1,
}), content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_put_with_authorization(self):
# Delete any previous data.
uploads = PublicFileUpload.objects.all()
for upload in uploads.all():
upload.delete()
# Create a new object with our specific test data.
PublicFileUpload.objects.create(
id=1,
owner_id=self.user.id,
)
data = {'id': 1, 'owner': self.user.id}
# Run the test.
url = reverse('publicfileupload-list') + '1/'
response = self.authorized_client.put(url,
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_delete(self):
# Step 1: Set the location variables.
url = reverse('publicfileupload-list') + '1/'
# Step 2: Test & verify.
response = self.unauthorized_client.delete(url)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_delete_with_authentication(self):
# Step 1: Delete any previous data.
uploads = PublicFileUpload.objects.all()
for upload in uploads.all():
upload.delete()
# Step 2: Set the location variables.
PublicFileUpload.objects.create(
id=1,
owner_id=self.user.id,
)
url = reverse('publicfileupload-list') + '1/'
# Step 3: Test & verify.
response = self.authorized_client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
class TagListCreateAPIViewWithTenantTestCase(APITestCase, TenantTestCase):
"""
Console:
python manage.py test tenant_api.tests.test_tag_views
"""
#------------------#
# Setup Unit Tests #
#------------------#
def setup_tenant(tenant):
"""Tenant Schema"""
tenant.schema_name = TEST_SCHEMA_NAME
tenant.name = 'Over 55 (London) Inc.',
tenant.alternate_name = "Over55",
tenant.description = "Located at the Forks of the Thames in ...",
tenant.address_country = "CA",
tenant.address_locality = "London",
tenant.address_region = "Ontario",
tenant.post_office_box_number = "", # Post Offic #
tenant.postal_code = "N6H 1B4",
tenant.street_address = "78 Riverside Drive",
tenant.street_address_extra = "", # Extra line.
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(TagListCreateAPIViewWithTenantTestCase, self).setUp()
# Load up the dependat.
call_command('init_app', verbosity=0)
call_command('populate_tenant_content', TEST_SCHEMA_NAME, verbosity=0)
call_command('populate_tenant_sample_db',
TEST_SCHEMA_NAME,
verbosity=0)
# Get objects.
self.customer = Customer.objects.get(owner__email='*****@*****.**')
self.associate = Associate.objects.get(
owner__email='*****@*****.**')
# Get users.
exec_user = SharedUser.objects.get(email='*****@*****.**')
manager_user = SharedUser.objects.get(email='*****@*****.**')
frontline_user = SharedUser.objects.get(email='*****@*****.**')
associate_user = SharedUser.objects.get(email='*****@*****.**')
customer_user = SharedUser.objects.get(email='*****@*****.**')
# Get tokens.
exec_token, exec_orig_iat = get_jwt_token_and_orig_iat(exec_user)
manager_token, manager_orig_iat = get_jwt_token_and_orig_iat(
manager_user)
frontline_token, frontline_orig_iat = get_jwt_token_and_orig_iat(
frontline_user)
associate_token, associate_orig_iat = get_jwt_token_and_orig_iat(
associate_user)
customer_token, customer_orig_iat = get_jwt_token_and_orig_iat(
customer_user)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.exec_client = TenantClient(
self.tenant, HTTP_AUTHORIZATION='JWT {0}'.format(exec_token))
self.exec_client.login(username='******',
password=TEST_USER_PASSWORD)
self.manager_client = TenantClient(
self.tenant, HTTP_AUTHORIZATION='JWT {0}'.format(manager_token))
self.manager_client.login(username='******',
password=TEST_USER_PASSWORD)
self.staff_client = TenantClient(
self.tenant, HTTP_AUTHORIZATION='JWT {0}'.format(manager_token))
self.staff_client.login(username='******',
password=TEST_USER_PASSWORD)
self.customer_client = TenantClient(
self.tenant, HTTP_AUTHORIZATION='JWT {0}'.format(manager_token))
self.customer_client.login(username='******',
password=TEST_USER_PASSWORD)
self.tag = Tag.objects.create(text="Some generic text")
@transaction.atomic
def tearDown(self):
connection.set_schema(TEST_SCHEMA_NAME, True) # Switch to Tenant.
Tag.objects.delete_all()
del self.unauthorized_client
del self.exec_client
del self.manager_client
del self.staff_client
del self.customer_client
super(TagListCreateAPIViewWithTenantTestCase, self).tearDown()
#-------------------#
# List API-endpoint #
#-------------------#
@transaction.atomic
def test_list_with_401_by_permissions(self):
"""
Unit test will test anonymous make a GET request to the LIST API-endpoint.
"""
url = reverse('workery_tag_list_create_api_endpoint') + "?format=json"
response = self.unauthorized_client.get(
url, data=None, content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_list_with_200_by_permissions(self):
"""
Unit test will test authenticated user, who has permission, to make a
GET request to the list API-endpoint.
"""
url = reverse('workery_tag_list_create_api_endpoint')
url += "?format=json"
# Executive
response = self.exec_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Manager
response = self.manager_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Staff
response = self.staff_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_list_with_403_by_permissions(self):
"""
Unit test will test authenticated user, who does not have permission, to
make a GET request to the list API-endpoint.
"""
Permission.objects.all().delete()
url = reverse('workery_tag_list_create_api_endpoint')
url += "?format=json"
response = self.customer_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertIn(
"You do not have permission to access this API-endpoint.",
str(response.data))
#---------------------#
# Create API-endpoint #
#---------------------#
@transaction.atomic
def test_create_with_401_by_permissions(self):
"""
Unit test will test anonymous make a POST request to the create API-endpoint.
"""
url = reverse('workery_tag_list_create_api_endpoint') + "?format=json"
response = self.unauthorized_client.post(
url, data={}, content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_create_with_200_by_permissions(self):
"""
Unit test will test authenticated user, who has permission, to make a
POST request to the create API-endpoint.
"""
url = reverse('workery_tag_list_create_api_endpoint')
url += "?format=json"
# Executive
response = self.exec_client.post(url,
data=json.dumps({
'text':
'generic text',
}),
content_type='application/json')
self.assertIsNotNone(response)
# print(response.content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertIn("generic text", str(response.data))
# Manager
response = self.manager_client.post(url,
data=json.dumps({
'text':
'generic text #2',
}),
content_type='application/json')
self.assertIsNotNone(response)
# print(response.content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertIn("#2", str(response.data))
# Staff
response = self.staff_client.post(url,
data=json.dumps({
'text':
'generic text #3',
}),
content_type='application/json')
self.assertIsNotNone(response)
# print(response)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertIn("#3", str(response.data))
@transaction.atomic
def test_create_with_403_by_permissions(self):
"""
Unit test will test authenticated user, who does not have permission, to
make a POST request to the list API-endpoint.
"""
Permission.objects.all().delete()
url = reverse('workery_tag_list_create_api_endpoint')
url += "?format=json"
response = self.customer_client.post(url,
data=json.dumps({}),
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertIn(
"You do not have permission to access this API-endpoint.",
str(response.data))
#---------------------#
# Update API-endpoint #
#---------------------#
@transaction.atomic
def test_update_with_401_by_permissions(self):
"""
Unit test will test anonymous make a PUT request to the update API-endpoint.
"""
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
response = self.unauthorized_client.post(
url, data={}, content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_update_with_200_by_permissions(self):
"""
Unit test will test authenticated user, who has permission, to make a
PUT request to the update API-endpoint.
"""
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
data = json.dumps({
'text': 'generic text #1',
})
# Executive
response = self.exec_client.put(url,
data=data,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("generic text #1", str(response.data))
# Manager
response = self.manager_client.put(url,
data=data,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("generic text #1", str(response.data))
# Staff
response = self.staff_client.put(url,
data=data,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("generic text #1", str(response.data))
@transaction.atomic
def test_update_with_403_by_permissions(self):
"""
Unit test will test authenticated user, who does not have permission, to
make a PUT request to the update API-endpoint.
"""
Permission.objects.all().delete()
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
data = json.dumps({
'text': 'generic text',
})
response = self.customer_client.put(url,
data=data,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertIn(
"You do not have permission to access this API-endpoint.",
str(response.data))
#-----------------------#
# Retrieve API-endpoint #
#-----------------------#
@transaction.atomic
def test_retrieve_with_401_by_permissions(self):
"""
Unit test will test anonymous make a GET request to the retrieve API-endpoint.
"""
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
response = self.unauthorized_client.get(
url, data={}, content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_retrieve_with_200_by_permissions(self):
"""
Unit test will test authenticated user, who has permission, to make a
GET request to the retrieve API-endpoint.
"""
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
response = self.exec_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("generic text", str(response.data))
response = self.manager_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("generic text", str(response.data))
response = self.staff_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("generic text", str(response.data))
@transaction.atomic
def test_retrieve_with_403_by_permissions(self):
"""
Unit test will test authenticated user, who does not have permission, to
make a GET request to the retrieve API-endpoint.
"""
Permission.objects.all().delete()
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
response = self.exec_client.get(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertIn(
"You do not have permission to access this API-endpoint.",
str(response.data))
#-----------------------#
# Delete API-endpoint #
#-----------------------#
@transaction.atomic
def test_delete_with_401_by_permissions(self):
"""
Unit test will test anonymous make a DELETE request to the delete API-endpoint.
"""
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
response = self.unauthorized_client.delete(
url, data={}, content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@transaction.atomic
def test_delete_with_200_by_permissions(self):
"""
Unit test will test authenticated user, who has permission, to make a
DELETE request to the delete API-endpoint.
"""
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
response = self.exec_client.delete(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@transaction.atomic
def test_delete_with_403_by_permissions(self):
"""
Unit test will test authenticated user, who does not have permission, to
make a DELETE request to the delete API-endpoint.
"""
Permission.objects.all().delete()
url = reverse('workery_tag_retrieve_update_destroy_api_endpoint',
args=[self.tag.id]) + "?format=json"
response = self.exec_client.delete(url,
data=None,
content_type='application/json')
self.assertIsNotNone(response)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertIn(
"You do not have permission to access this API-endpoint.",
str(response.data))
class TestTenantTeamViews(TenantTestCase):
"""
Console:
python manage.py test tenant_task.tests.test_views
"""
#------------------#
# Setup Unit Tests #
#------------------#
def setup_tenant(tenant):
"""Tenant Schema"""
tenant.schema_name = TEST_SCHEMA_NAME
tenant.name = 'Over 55 (London) Inc.',
tenant.alternate_name = "Over55",
tenant.description = "Located at the Forks of the Thames in ...",
tenant.address_country = "CA",
tenant.address_locality = "London",
tenant.address_region = "Ontario",
tenant.post_office_box_number = "", # Post Offic #
tenant.postal_code = "N6H 1B4",
tenant.street_address = "78 Riverside Drive",
tenant.street_address_extra = "", # Extra line.
@classmethod
def setUpClass(cls):
"""
Run at the beginning before all the unit tests run.
"""
super().setUpClass()
def setUp(self):
"""
Run at the beginning of every unit test.
"""
super(TestTenantTeamViews, self).setUp()
# Setup our app and account.
call_command('init_app', verbosity=0)
call_command('populate_tenant_content', TEST_SCHEMA_NAME, verbosity=0)
call_command('populate_tenant_sample_db',
TEST_SCHEMA_NAME,
verbosity=0)
# Get user and credentials.
user = SharedUser.objects.get(email="*****@*****.**")
user2 = SharedUser.objects.get(email="*****@*****.**")
token, orig_iat = get_jwt_token_and_orig_iat(user)
token2, orig_iat2 = get_jwt_token_and_orig_iat(user2)
# Setup our clients.
self.anon_c = TenantClient(self.tenant)
self.exec_auth_c = TenantClient(
self.tenant, HTTP_AUTHORIZATION='JWT {0}'.format(token))
self.exec_auth_c.login(username="******",
password="******")
self.frontline_auth_c = TenantClient(
self.tenant, HTTP_AUTHORIZATION='JWT {0}'.format(token2))
self.frontline_auth_c.login(username="******",
password="******")
TaskItem.objects.update_or_create(
id=1,
defaults={
'id':
1,
'type_of':
FOLLOW_UP_CUSTOMER_SURVEY_TASK_ITEM_TYPE_OF_ID,
'title':
_('Completion Survey'),
'description':
_('Please call up the client and perform the satisfaction survey.'
),
'due_date':
timezone.now(),
'is_closed':
False,
'job':
None,
'ongoing_job':
None,
# 'created_by': None,
# created_from
# created_from_is_public
# last_modified_by
})
def tearDown(self):
"""
Run at the end of every unit test.
"""
# Delete previous data.
SharedUser.objects.delete_all()
TaskItem.objects.delete_all()
# Delete our clients.
del self.anon_c
del self.exec_auth_c
del self.frontline_auth_c
# Finish teardown.
super(TestTenantTeamViews, self).tearDown()
def test_unassigned_task_list_page_with_executive_staff(self):
response = self.exec_auth_c.get(
self.tenant.reverse('workery_tenant_unassigned_task_list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Unassigned Tasks', str(response.content))
def test_unassigned_task_list_page_with_frontline_staff(self):
response = self.frontline_auth_c.get(
self.tenant.reverse('workery_tenant_unassigned_task_list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_pending_task_list_page_with_executive_staff(self):
response = self.exec_auth_c.get(
self.tenant.reverse('workery_tenant_task_list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Pending Tasks', str(response.content))
def test_pending_task_list_page_with_frontline_staff(self):
response = self.frontline_auth_c.get(
self.tenant.reverse('workery_tenant_task_list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_closed_task_list_page_with_executive_staff(self):
response = self.exec_auth_c.get(
self.tenant.reverse('workery_tenant_closed_task_list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Closed Tasks', str(response.content))
def test_closed_task_list_page_with_frontline_staff(self):
response = self.frontline_auth_c.get(
self.tenant.reverse('workery_tenant_closed_task_list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_pending_task_retrieve_page_with_open_task(self):
obj = TaskItem.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_pending_task_retrieve',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Task', str(response.content))
def test_pending_task_retrieve_page_with_closed_task(self):
obj = TaskItem.objects.get()
obj.is_closed = True
obj.save()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_pending_task_retrieve',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_pending_task_retrieve_2_page(self):
obj = TaskItem.objects.get()
a_url = self.tenant.reverse(
reverse_id=
'workery_tenant_pending_task_retrieve_for_activity_sheet_retrieve',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Task', str(response.content))
def test_pending_task_retrieve_2_page_with_closed_task(self):
obj = TaskItem.objects.get()
obj.is_closed = True
obj.save()
a_url = self.tenant.reverse(
reverse_id=
'workery_tenant_pending_task_retrieve_for_activity_sheet_retrieve',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_pending_task_retrieve_3_page(self):
obj = TaskItem.objects.get()
a_url = self.tenant.reverse(
reverse_id=
'workery_tenant_pending_task_retrieve_for_activity_sheet_retrieve_and_create',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Task', str(response.content))
def test_pending_task_retrieve_3_page_with_closed_task(self):
obj = TaskItem.objects.get()
obj.is_closed = True
obj.save()
a_url = self.tenant.reverse(
reverse_id=
'workery_tenant_pending_task_retrieve_for_activity_sheet_retrieve_and_create',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_pending_task_retrieve_4_page(self):
obj = TaskItem.objects.get()
a_url = self.tenant.reverse(
reverse_id=
'workery_tenant_pending_task_retrieve_for_activity_sheet_follow_up_with_associate_retrieve',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Task', str(response.content))
def test_pending_task_retrieve_and_complete_page(self):
obj = TaskItem.objects.get()
a_url = self.tenant.reverse(
reverse_id=
'workery_tenant_pending_task_retrieve_and_complete_create',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Task', str(response.content))
def test_pending_task_retrieve_and_complete_page_with_closed_task(self):
obj = TaskItem.objects.get()
obj.is_closed = True
obj.save()
a_url = self.tenant.reverse(
reverse_id=
'workery_tenant_pending_task_retrieve_and_complete_create',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_pending_task_retrieve_and_ongoing_update_page(self):
obj = TaskItem.objects.get()
a_url = self.tenant.reverse(
reverse_id=
'workery_tenant_pending_task_retrieve_and_ongoing_update_create',
reverse_args=[int(obj.id)])
response = self.exec_auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Task', str(response.content))
def test_search_page(self):
response = self.exec_auth_c.get(
self.tenant.reverse('workery_tenant_task_search', ['pending']))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Search', str(response.content))
def test_search_confirmation_page(self):
response = self.exec_auth_c.get(
self.tenant.reverse('workery_tenant_task_search_results',
['pending']) + '?keyword=' + TEST_USER_EMAIL)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Search', str(response.content))
def test_search_confirmation_page_with_wrong_template(self):
response = self.exec_auth_c.get(
self.tenant.reverse('workery_tenant_task_search_results',
['la-la-la-la-la']) + '?keyword=' +
TEST_USER_EMAIL)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
class TestTenantPartnerViews(TenantTestCase):
"""
Console:
python manage.py test tenant_partner.tests
"""
#------------------#
# Setup Unit Tests #
#------------------#
def setup_tenant(tenant):
"""Tenant Schema"""
tenant.schema_name = TEST_SCHEMA_NAME
tenant.name = 'Over 55 (London) Inc.',
tenant.alternate_name = "Over55",
tenant.description = "Located at the Forks of the Thames in ...",
tenant.address_country = "CA",
tenant.address_locality = "London",
tenant.address_region = "Ontario",
tenant.post_office_box_number = "", # Post Offic #
tenant.postal_code = "N6H 1B4",
tenant.street_address = "78 Riverside Drive",
tenant.street_address_extra = "", # Extra line.
@classmethod
def setUpClass(cls):
"""
Run at the beginning before all the unit tests run.
"""
super().setUpClass()
def setUp(self):
"""
Run at the beginning of every unit test.
"""
super(TestTenantPartnerViews, self).setUp()
# Setup our app and account.
call_command('init_app', verbosity=0)
call_command('populate_tenant_content', TEST_SCHEMA_NAME, verbosity=0)
call_command('populate_tenant_sample_db',
TEST_SCHEMA_NAME,
verbosity=0)
# Get user and credentials.
user = SharedUser.objects.get(email='*****@*****.**')
token, orig_iat = get_jwt_token_and_orig_iat(user)
# Setup our clients.
self.anon_c = TenantClient(self.tenant)
self.auth_c = TenantClient(self.tenant,
HTTP_AUTHORIZATION='JWT {0}'.format(token))
self.auth_c.login(username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
def tearDown(self):
"""
Run at the end of every unit test.
"""
# Delete previous data.
SharedUser.objects.all().delete()
# Delete our clients.
del self.anon_c
del self.auth_c
# Finish teardown.
super(TestTenantPartnerViews, self).tearDown()
def test_summary_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_partner_summary'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Partner', str(response.content))
def test_create_confirmation_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_partner_confirm_create'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Add Partner', str(response.content))
def test_create_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_partner_create'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Add Partner', str(response.content))
def test_list_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_partner_list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Partner List', str(response.content))
def test_search_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_partner_search'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Partners Search', str(response.content))
def test_search_confirmation_page(self):
response = self.auth_c.get(
self.tenant.reverse('workery_tenant_partner_search_results') +
'?keyword=' + TEST_USER_EMAIL)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Search', str(response.content))
self.assertIn('Search Results', str(response.content))
# self.assertIn(TEST_USER_EMAIL, str(response.content))
def test_lite_retrieve_page(self):
partner = Partner.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_partner_lite_retrieve',
reverse_args=['summary', int(partner.id)])
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Partner', str(response.content))
# self.assertIn('Gendo', str(response.content))
def test_full_retrieve_page(self):
partner = Partner.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_partner_full_retrieve',
reverse_args=['summary', int(partner.id)])
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Partner', str(response.content))
# self.assertIn('Gendo', str(response.content))
def test_comments_retrieve_page(self):
partner = Partner.objects.get()
a_url = self.tenant.reverse(
reverse_id='workery_tenant_partner_retrieve_for_comment_list',
reverse_args=['summary', int(partner.id)])
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Partner', str(response.content))
self.assertIn('Add Comment/Note', str(response.content))
def test_update_page(self):
partner = Partner.objects.get()
a_url = self.tenant.reverse(reverse_id='workery_tenant_partner_update',
reverse_args=['summary',
int(partner.id)])
response = self.auth_c.get(a_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('Partner', str(response.content))
self.assertIn('Edit Partner', str(response.content))
class TenantIntakeEntrepreneurTestCases(APITestCase, TenantTestCase):
fixtures = []
def setup_tenant(self, tenant):
"""Tenant Schema"""
tenant.schema_name = 'galacticalliance'
tenant.name = "Galactic Alliance of Humankind"
tenant.is_setup = True
tenant.has_perks = True
tenant.has_mentors = True
tenant.how_discovered = "Command HQ"
tenant.how_many_served = 1
@classmethod
def setUpTestData(cls):
Group.objects.bulk_create([
Group(
id=constants.ENTREPRENEUR_GROUP_ID,
name="Entreprenuer",
),
Group(
id=constants.MENTOR_GROUP_ID,
name="Mentor",
),
Group(
id=constants.ADVISOR_GROUP_ID,
name="Advisor",
),
Group(
id=constants.ORGANIZATION_MANAGER_GROUP_ID,
name="Org Manager",
),
Group(
id=constants.ORGANIZATION_ADMIN_GROUP_ID,
name="Org Admin",
),
Group(
id=constants.CLIENT_MANAGER_GROUP_ID,
name="Client Manager",
),
Group(
id=constants.SYSTEM_ADMIN_GROUP_ID,
name="System Admin",
),
])
User.objects.bulk_create([
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
User(
email='*****@*****.**',
username='******',
password='******',
is_active=True,
),
])
user = User.objects.create_user( # Create our User.
email=TEST_USER_EMAIL,
username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
user.is_active = True
user.save()
@transaction.atomic
def setUp(self):
translation.activate('en') # Set English
super(TenantIntakeEntrepreneurTestCases, self).setUp()
# Initialize our test data.
self.user = User.objects.get(username=TEST_USER_USERNAME)
token = Token.objects.get(user=self.user)
# Setup.
self.unauthorized_client = TenantClient(self.tenant)
self.authorized_client = TenantClient(self.tenant,
HTTP_AUTHORIZATION='Token ' +
token.key)
self.authorized_client.login(username=TEST_USER_USERNAME,
password=TEST_USER_PASSWORD)
# Update Organization.
self.tenant.users.add(self.user)
self.tenant.save()
# Setup User.
country = CountryOption.objects.create(id=1, name='Avalan')
province = ProvinceOption.objects.create(id=1,
name='Colony 01',
country=country)
city = CityOption.objects.create(
id=1,
name='Megazone 23',
province=province,
country=country,
)
self.me = Me.objects.create(
owner=self.user,
address=PostalAddress.objects.create(
country=CountryOption.objects.get(id=1),
region=ProvinceOption.objects.get(id=1),
locality=CityOption.objects.get(id=1),
owner=self.user))
# Make the User belong to the Entrepreneur group.
entrepreneur_group = Group.objects.get(
id=constants.ENTREPRENEUR_GROUP_ID)
self.user.groups.add(entrepreneur_group)
self.user.save()
# Create the Intake object.
intake = Intake.objects.create(me=self.me,
status=constants.CREATED_STATUS)
@transaction.atomic
def tearDown(self):
PostalAddress.objects.delete_all()
ContactPoint.objects.delete_all()
Me.objects.delete_all()
users = User.objects.all()
for user in users.all():
user.delete()
items = Group.objects.all()
for item in items.all():
item.delete()
# super(TenantIntakeEntrepreneurTestCases, self).tearDown()
@transaction.atomic
def test_intake_page_with_employee_user(self):
entrepreneur_group = Group.objects.get(
id=constants.ENTREPRENEUR_GROUP_ID)
self.user.groups.remove(entrepreneur_group)
self.user.save()
url = reverse('tenant_intake_entr_round_one_step_one')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@transaction.atomic
def test_intake_round_one_page_one_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_one_step_one')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_one_page_two_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_one_step_two')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_one_page_three_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_one_step_three')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_one_page_four_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_one_step_four')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_one_page_five_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_one_step_five')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_one_page_six_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_one_step_six')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_two_page_one_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_two_step_one')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_two_page_two_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_two_step_two')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_two_page_three_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_two_step_three')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_two_page_four_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_two_step_four')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_round_two_page_five_with_entrepreneur_user(self):
url = reverse('tenant_intake_entr_round_two_step_five')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
#self.assertIn(b'Rewards',response.content)
@transaction.atomic
def test_intake_finished_page_with_entrepreneur_user(self):
url = reverse('tenant_intake_finished')
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(len(response.content) > 1)
