class BackOfficeBackend(TestCase):
def setUp(self):
user, created = User.objects.get_or_create(username='******',
password='******',
first_name='Admin',
last_name='User',
email='*****@*****.**',
is_active=True,
is_staff=True,
is_superuser=True)
user.set_password('admin')
user.save()
self.user2, created2 = User.objects.get_or_create(username='******',
password='******',
first_name='Admin2',
last_name='User',
email='*****@*****.**',
is_active=True,
is_staff=True,
is_superuser=True)
self.user2.set_password('admin')
self.user2.save()
self.home_url = reverse(test_backoffice.name + ':home', current_app=test_backoffice.app_name)
self.client = Client()
self.client.post(self.home_url, {'username': '******', 'password': '******'})
def _reverse(self, name, args=None, kwargs=None):
pass
def test_default_context(self):
"""The default context contains usable values"""
context = test_backoffice.default_context()
self.assertEqual(context['backoffice'], test_backoffice)
self.assertTrue('api_url' in context)
self.assertTrue('root_url' in context)
def test_home_view(self):
response = self.client.get(self.home_url)
self.assertEqual(response.status_code, 200)
self.assertIn('Hi, <strong>Admin</strong>', response.content)
def test_default_define_urls(self):
self.assertEqual(BackOfficeBase().define_urls(), ())
def test_login_as(self):
self.client.get(self.home_url + 'login/as/' + six.text_type(self.user2.pk) + '/')
response = self.client.get(self.home_url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertIn('Hi, <strong>Admin2</strong>', response.content)
response = self.client.get(self.home_url + 'end/login/as/', follow=True)
self.assertEqual(response.status_code, 200)
self.assertIn('Hi, <strong>Admin</strong>', response.content)
self.client.get(self.home_url + 'end/login/as/')
def test_logout(self):
response = self.client.get(self.home_url + 'logout/')
self.assertEqual(response.status_code, 200)
self.assertNotIn('Hi,', response.content)
def test_password_reset(self):
"""
Tests the forgotten/reset password workflow.
"""
c = Client()
resp = c.get(reverse('password_reset'))
self.assertTrue(resp.status_code, 200)
resp = c.post(reverse('password_reset'), data={'email': '*****@*****.**'})
self.assertEqual(resp.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
token = resp.context[0]['token']
uid = resp.context[0]['uid']
# Grab the token and uidb64 so that we can hit the reset url
resp = c.get(reverse('password_reset_confirm', kwargs={'token': token, 'uidb64': uid}))
self.assertEqual(resp.status_code, 200)
self.assertTrue(resp.template_name.endswith('password_reset_confirm.html'))
resp = c.post(reverse('password_reset_confirm', kwargs={'token': token, 'uidb64': uid}),
{'new_password1': 'mynewpassword', 'new_password2': 'mynewpassword'})
self.assertEqual(resp.status_code, 302)
self.assertEqual(resolve(urlsplit(resp.url).path).url_name, 'password_reset_complete')
resp = c.post(reverse('login'), {'username': '******', 'password': '******'})
# User is returned to the login page on error vs redirected by default
self.assertEqual(resp.status_code, 302)
self.assertNotEqual(resolve(urlsplit(resp.url).path).url_name, 'login')
class WebhooksPOST_TestCase(TestCase):
def setUp(self):
self.client = Client()
factories.models.User.update_friends = Mock()
def tearDown(self):
factories.models.User.update_friends = origin_update_friends
def _get_body(self, obj='user', entry={'id': -1}):
return dumps({
'object': obj,
'entry': [entry]
})
def _get_signature(self, body):
key = settings.SOCIAL_AUTH_FACEBOOK_SECRET
return "sha1={}".format(hmac.new(key, body, sha1).hexdigest())
def test_update_ok(self):
user = factories.UsersFactory.create()
body = self._get_body(entry={'id': user.uid})
signature = self._get_signature(body)
url = reverse('webhooks', )
response = self.client.post(url, body,
content_type="application/json",
**{'HTTP_X_HUB_SIGNATURE': signature})
self.assertEqual(response.content, 'Ok')
self.assertEqual(response.status_code, 200)
self.assertTrue(user.update_friends.called)
def test_update_fails_with_wrong_body(self):
body = self._get_body(obj='wrong object')
url = reverse('webhooks', )
response = self.client.post(url, body, content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, 'Invalid webhook')
def test_update_fails_with_wrong_uid(self):
body = self._get_body()
url = reverse('webhooks', )
signature = self._get_signature(body)
response = self.client.post(url, body,
content_type="application/json",
**{'HTTP_X_HUB_SIGNATURE': signature})
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, 'Invalid user id')
def test_update_fails_with_wrong_signature(self):
user = factories.UsersFactory.create()
body = self._get_body(entry={'id': user.uid})
url = reverse('webhooks', )
response = self.client.post(url, body,
content_type="application/json",
**{'HTTP_X_HUB_SIGNATURE': 'sha1=invalid'})
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, 'Invalid signature')
self.assertFalse(user.update_friends.called)
class TestAssignmentUploadForm(TestCase):
def upload_test(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
self.test_user = User.objects.create_user(self.username, self.email, self.password)
login = self.client.login(username=self.username, password=self.password)
self.assertEqual(login, True)
course = Course.objects.create(number='1234', name='Test course')
student = Student.objects.create(
user=User.objects.create_user('test_user', first_name='Student'),
course=course,
)
staff = Staff.objects.create(
user=User.objects.create_user('test_staff', first_name='Staff')
)
subject = Subject.objects.create(course=course, name='Subject1', staff=staff)
assignment = Assignment.objects.create(subject=subject, topic='This is Enemy', deadline=timezone.now(),
description="I need holiday..")
with open('requirements.txt') as fp:
self.client.post('/assignments/' + assignment.pk + '/upload/',
{'assignment': assignment, 'user': student.user, 'created': timezone.now(), 'file': fp})
response = self.client.get(reverse('assignment_detail', args=(assignment.pk,)))
print(response.status_code)
self.assertContains(response, assignment.topic)
self.assertContains(response, 'requirements.txt')
self.assertEqual(response.status_code, 200)
def test_post_user_check_result_false(self):
client = Client()
client.post(
'/users_check/', {'id_user_1': 123, 'id_user_2': 3}
)
self.assertEqual('res' in client._session().keys(), True)
self.assertEqual(False in client._session().values(), True)
class TestURNSubmissionFailureMessage(TestCase):
def setUp(self):
self.court = Court.objects.create(
court_code="0000",
region_code="06",
court_name="test court",
court_address="test address",
court_telephone="0800 MAKEAPLEA",
court_email="*****@*****.**",
submission_email="*****@*****.**",
plp_email="*****@*****.**",
enabled=True,
display_case_data=True,
validate_urn=True,
test_mode=False)
self.case = Case.objects.create(
urn="06YY0000000",
imported=True
)
self.client = Client()
def test_single_failure_no_message(self):
response = self.client.post('/plea/enter_urn/', data=dict(urn="06xx0000000"))
self.assertContains(response, "You need to fix the errors on this page before continuing.")
self.assertNotContains(response, "Your reference number has not been recognised")
def test_message_appears_after_multiple_failures(self):
for i in range(3):
response = self.client.post('/plea/enter_urn/', data=dict(urn="06xx0000000"))
self.assertContains(response, "Your reference number has not been recognised")
def test_activate(self):
c = Client()
response = c.get('/signup/activate/')
self.assertEqual(response.status_code, 200)
response = c.post('/signup/activate/', {'ps1_email': '*****@*****.**'}, follow=True)
self.assertEqual(response.status_code, 200)
# "read" email
token = self.get_token()
activation_url = '/signup/activate/confirm/{}'.format(token.token)
response = c.get(activation_url)
self.assertEqual(response.status_code, 200)
post_data = {
'preferred_username': '******',
'first_name': 'Jay',
'last_name': 'Hacker',
'preferred_email': '*****@*****.**',
'token': token.token,
}
response = c.post(activation_url, post_data, follow=True)
self.assertEqual(response.status_code, 200)
jay = Person.objects.get(pk=self.person.pk)
self.assertIsNotNone(jay.user)
PS1User.objects.delete_user(jay.user)
class LoginTest(SimpleTestCase):
user = '******'
pwd = '123456'
def setUp(self):
self.client = Client()
if not User.objects.filter(username=self.user).first():
User.objects.create_user(username=self.user, password=self.pwd)
def test_200ok(self):
self.assertEqual(self.client.get('/login/').status_code, 200)
self.assertEqual(self.client.post('/login/').status_code, 200)
def test_login_normal(self):
self.assertTrue(self.client.login(username=self.user, password=self.pwd))
self.client.logout()
res = self.client.post(path='/login/', data={'username': self.user, 'password': self.pwd})
self.assertEqual(res.url, 'http://testserver/index.html')
def test_login_nextpage(self):
res = self.client.post(path='/login/', data={'username': self.user, 'password': self.pwd, 'next': '/404/'})
self.assertEqual(res.status_code, 302)
def test_logout(self):
self.assertIsNone(self.client.logout())
self.client.login(username=self.user, password=self.pwd)
self.assertIsNone(self.client.logout())
class BasicAuthTests(TestCase):
"""Basic authentication"""
urls = 'rest_framework.tests.authentication'
def setUp(self):
self.csrf_client = Client(enforce_csrf_checks=True)
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
self.user = User.objects.create_user(self.username, self.email, self.password)
def test_post_form_passing_basic_auth(self):
"""Ensure POSTing json over basic auth with correct credentials passes and does not require CSRF"""
auth = 'Basic %s' % base64.encodestring('%s:%s' % (self.username, self.password)).strip()
response = self.csrf_client.post('/basic/', {'example': 'example'}, HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 200)
def test_post_json_passing_basic_auth(self):
"""Ensure POSTing form over basic auth with correct credentials passes and does not require CSRF"""
auth = 'Basic %s' % base64.encodestring('%s:%s' % (self.username, self.password)).strip()
response = self.csrf_client.post('/basic/', json.dumps({'example': 'example'}), 'application/json', HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 200)
def test_post_form_failing_basic_auth(self):
"""Ensure POSTing form over basic auth without correct credentials fails"""
response = self.csrf_client.post('/basic/', {'example': 'example'})
self.assertEqual(response.status_code, 401)
def test_post_json_failing_basic_auth(self):
"""Ensure POSTing json over basic auth without correct credentials fails"""
response = self.csrf_client.post('/basic/', json.dumps({'example': 'example'}), 'application/json')
self.assertEqual(response.status_code, 401)
self.assertEqual(response['WWW-Authenticate'], 'Basic realm="api"')
class TestUpdateUserPerms(TransactionTestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(username='******', password='******',
first_name='Hodor', last_name='HodorHodor',
email='*****@*****.**')
Perms.objects.create(user=self.user, access_level=1).save()
def test_update_user_perms(self):
"""Updating user permissions"""
self.client.login(username='******', password='******')
new_user = User.objects.create_user(username='******', password='******',
first_name='Phillip', last_name='J Fry',
email='*****@*****.**')
#Test if perms are created for new user
response = self.client.post('/users/perms/update/', data={'user_id': new_user.id, 'access_level': '5'}, follow=True)
self.assertRedirects(response, '/users/view/%d/' % new_user.id)
user = User.objects.get(pk=new_user.id)
self.assertEquals(user.perms.access_level, 5)
# Test updating once you have perms
response = self.client.post('/users/perms/update/', data={'user_id': new_user.id, 'access_level': '2'}, follow=True)
self.assertRedirects(response, '/users/view/%d/' % new_user.id)
user = User.objects.get(pk=new_user.id)
self.assertEquals(user.perms.access_level, 2)
def test_upload(self):
"""Can we create an image on the filestore?"""
username, user = _make_user()
c = Client()
with open(UPLOAD_FILE) as photo_fd:
response = c.post("/umedia/", {
"title": "a picture of me I just took",
"photo": photo_fd
})
self.assertEquals(302, response.status_code)
parsed = urlparse.urlparse(response["Location"])
self.assertEquals(parsed.path, settings.LOGIN_URL)
# Now login
loggedin = c.login(username=username, password="******")
self.assertTrue(loggedin)
with open(UPLOAD_FILE) as photo_fd:
response = c.post("/umedia/", {
"title": "a picture of me I just took",
"photo": photo_fd
})
self.assertEquals(201, response.status_code)
# What's the url
parsed = urlparse.urlparse(response["Location"])
# Check we've got the correct file type
self.assertEquals(os.path.splitext(parsed.path)[1][1:], "jpg")
# Check that is starts with something under the MEDIA_DOMAIN
self.assertEquals(
settings.MEDIA_DOMAIN,
".".join(parsed.netloc.split(".")[2:])
)
class AlarmViewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = PyDayUser.objects._create_user("*****@*****.**", "secret",
"MynameisWhat",
"MynameisWho")
self.client.login(email='*****@*****.**', password='******')
def test_get(self):
with self.assertTemplateUsed("create_alarm.html"):
self.client.get(reverse("pyday_alarms:alarms"))
def test_post(self):
with self.assertTemplateUsed("error.html"):
response = self.client.post(reverse("pyday_alarms:alarms"),
{'date': '07/01/2016', 'hour': '1',
'mins': '0', 'message': 'haha'},
follow=True)
self.assertContains(response, "Raspberry!")
def test_post_invalid_form(self):
with self.assertTemplateUsed("error.html"):
response = self.client.post(reverse("pyday_alarms:alarms"), {})
self.assertContains(response, "Invalid form")
class TestContentParsingWithAuthentication(TestCase):
urls = "djangorestframework.tests.content"
def setUp(self):
self.csrf_client = Client(enforce_csrf_checks=True)
self.username = "******"
self.email = "*****@*****.**"
self.password = "******"
self.user = User.objects.create_user(self.username, self.email, self.password)
self.req = RequestFactory()
def test_user_logged_in_authentication_has_post_when_not_logged_in(self):
"""Ensures request.POST exists after UserLoggedInAuthentication when user doesn't log in"""
content = {"example": "example"}
response = self.client.post("/", content)
self.assertEqual(status.OK, response.status_code, "POST data is malformed")
response = self.csrf_client.post("/", content)
self.assertEqual(status.OK, response.status_code, "POST data is malformed")
def test_user_logged_in_authentication_has_post_when_logged_in(self):
"""Ensures request.POST exists after UserLoggedInAuthentication when user does log in"""
self.client.login(username="******", password="******")
self.csrf_client.login(username="******", password="******")
content = {"example": "example"}
response = self.client.post("/", content)
self.assertEqual(status.OK, response.status_code, "POST data is malformed")
response = self.csrf_client.post("/", content)
self.assertEqual(status.OK, response.status_code, "POST data is malformed")
class ChangePasswordTestCase(TestCase):
def setUp(self):
self.my_user = User.objects.get(id=3)
self.client = Client()
def tearDown(self):
self.my_user = None
self.client = None
def sign_in_first(self):
return self.client.login(username=self.my_user.username, password="******")
def test_user_should_login_first(self):
# 'old_password', 'new_password1', 'new_password2'
resp = self.client.post('/changepassword/', {'old_password': '******',
'new_password1': 'test',
'new_password2': 'test'})
self.assertEqual(resp.status_code, 302, "The user is redirected because he is not logged in")
self.assertRedirects(resp, "/signin/?next=/changepassword/")
def test_if_password_changed_user_redirected_to_profile(self):
self.sign_in_first()
resp = self.client.post('/changepassword/', {'old_password': '******',
'new_password1': 'test',
'new_password2': 'test'})
login_successful = self.client.login(username=self.my_user.username, password="******")
self.assertTrue(login_successful)
self.assertEqual(resp.status_code, 302)
self.assertRedirects(resp, '/profile/')
def test_password_form_sent_through_get_method(self):
self.sign_in_first()
resp = self.client.get('/changepassword/')
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed("changepassword.html")
class EditProfileTestCase(TestCase):
def setUp(self):
self.my_user = User.objects.get(id=3)
self.client = Client()
def tearDown(self):
self.my_user = None
self.client = None
def sign_in_first(self):
return self.client.login(username=self.my_user.username, password="******")
def test_user_redirected_to_profile_if_email_valid(self):
self.sign_in_first()
resp = self.client.post("/editprofile/", {'email': '*****@*****.**'})
self.assertEqual(User.objects.get(id=3).email, '*****@*****.**')
self.assertRedirects(resp, '/profile/')
def test_error_redirected_to_edit_if_email_invalid(self):
self.sign_in_first()
resp = self.client.post("/editprofile/", {'email': 'skitest.fi'})
self.assertNotEqual(User.objects.get(id=3).email, 'skitest.fi')
self.assertFormError(resp, 'form', 'email', "Enter a valid email address.")
self.assertTemplateUsed(resp, 'editprofile.html')
def test_form_sent_in_response_to_get_request(self):
self.sign_in_first()
resp = self.client.post("/editprofile/")
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed("editprofile.html")
def test_user_agent(self):
"""Test the user agent."""
client = Client()
client.post('/with_user_agent', HTTP_USER_AGENT='Some User Agent')
all_visitors = Visitor.objects.all()
self.assertEqual(len(all_visitors), 1)
self.assertEqual(all_visitors[0].user_agent, 'Some User Agent')
class MontlyEventViewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = PyDayUser.objects._create_user("*****@*****.**", "secret",
"MynameisWhat",
"MynameisWho")
def test_get_not_logged(self):
response = self.client.get(reverse("pyday_calendar:monthly_events"),
follow=True)
self.assertEqual(response.redirect_chain,
[('/social/register/?next=/calendar/monthly_events/', 302)])
def test_get_logged(self):
self.client.login(email='*****@*****.**', password='******')
with self.assertTemplateUsed("monthly_event.html"):
resp = self.client.get(reverse("pyday_calendar:monthly_events"))
self.assertEqual(resp.status_code, 200)
def test_post_wrong_date(self):
self.client.login(email='*****@*****.**', password='******')
with self.assertTemplateUsed("error.html"):
self.client.post(reverse("pyday_calendar:monthly_events"), {
"date": "60/2016"})
def test_post_right_date(self):
self.client.login(email='*****@*****.**', password='******')
with self.assertTemplateUsed("monthly_event.html"):
self.client.post(reverse("pyday_calendar:monthly_events"), {
"date": "6/2016"})
def test_vote_api(self):
test_thread_1 = Discussion.objects.create(
title='This1',
username='******',
description='the other thing',
)
comment = Comment.objects.create(
discussion=test_thread_1,
text='parent',
username='******',
score=0,
)
upvote = {
"direction": "up",
"comment_id": str(comment.id)
}
client = Client()
client.post(reverse('vote_comment', kwargs=upvote))
# Refresh comment from the database
comment = Comment.objects.get(id=comment.id)
self.assertEqual(comment.score, 1)
downvote = {
"direction": "down",
"comment_id": str(comment.id)
}
client.post(reverse('vote_comment', kwargs=downvote))
comment = Comment.objects.get(id=comment.id)
self.assertEqual(comment.score, 0)
def test_ip_address(self):
"""Test the ip address."""
client = Client()
client.post('/with_ip', REMOTE_ADDR='10.10.10.10')
all_visitors = Visitor.objects.all()
self.assertEqual(len(all_visitors), 1)
self.assertEqual(all_visitors[0].ip_address, '10.10.10.10')
class ArticleTest(TestCase):
def setUp(self):
self.client = Client()
self.factory = RequestFactory()
def test_validate_article_edition(self):
user2 = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
article = Article()
article.title = "nicetitle"
article.content = "nicecontent"
article.create_user = user2
article.create_user.id = user2.id
article.save()
self.client.login(username="******", password="******")
response = self.client.get(reverse('edit_article', kwargs={'id': '1'}))
self.assertEqual(response.status_code, 302)
response = self.client.post(reverse('edit_article',
kwargs={'id': '1'}))
self.assertEqual(response.status_code, 302)
self.client.login(username="******", password="******")
response = self.client.get(reverse('edit_article', kwargs={'id': '1'}),
user=user2)
self.assertEqual(response.status_code, 200)
response = self.client.post(reverse('edit_article',
kwargs={'id': '1'}))
self.assertEqual(response.status_code, 200)
def test_edit_item(self):
timestamp = datetime.now()
description = 'Coke'
caffeine = 50
c = Client()
c.login(username='******', password='******')
response = c.post('/record/item', {
'time': self.timestamp,
'description': self.description,
'caffeine': self.caffeine,
})
response = c.post('/edit/item?id=1', {
'time': timestamp,
'description': description,
'caffeine': caffeine,
})
self.assertEqual(response.status_code, 303)
record = Record.objects.get(pk=1)
self.assertEqual(record.time, timestamp)
self.assertEqual(record.caffeine, caffeine)
self.assertEqual(record.description, description)
response = c.post('/edit/item?id=2', {
'time': timestamp,
'description': description,
'caffeine': caffeine,
})
self.assertEqual(response.status_code, 404)
class RegisterUser(TestCase):
"""Test for 200 OK at '/'"""
def setUp(self):
self.client = Client()
self.username = fake.user_name()
self.password = fake.password()
self.email = fake.email()
def test_register_user(self):
response = self.client.post(
"/register/",
{"username": self.username, "password1": self.password, "password2": self.password, "email": self.email},
follow=True,
)
self.assertEqual(response.status_code, 200)
self.assertIn("activate", response.content)
def test_activate(self):
register = self.client.post(
"/register/",
{"username": self.username, "password1": self.password, "password2": self.password, "email": self.email},
follow=True,
)
# Regex lifted from:
# http://stackoverflow.com/questions/9760588/how-do-you-extract-a-url-from-a-string-using-python
link = re.search("(?P<url>https?://[^\s]+)", mail.outbox[0].body).group("url")
link_bits = link.split("/")
rel_uri = "/" + "/".join(link_bits[3:])
activate = self.client.get(rel_uri, follow=True)
self.assertIn("activate/complete", activate.wsgi_request.path)
# Newly registered user now attempts to login
logginin = self.client.post("/login/", {"username": self.username, "password": self.password}, follow=True)
self.assertIn(self.username, logginin.content)
class TestGeneTable(TestCase):
def setUp(self):
args = []
opts = {'dumpfile': 'test_db_dump.xml', 'verbosity': 0}
cmd = 'migrate_db'
call_command(cmd, *args, **opts)
self.client = Client()
def test_view_index(self):
response = self.client.get('/create_gene_table/')
self.assertEqual(200, response.status_code)
def test_results(self):
expected = 'COI,mitochondrial,1047,58.357,42.0,0.0,58.0,17.299999999999997,22.5,9.5,9.1'
response = self.client.post('/create_gene_table/results/',
{
'taxonset': 1,
'geneset': 1,
'translations': False,
})
self.assertTrue(expected in str(response.content))
def test_results_invalid_form(self):
response = self.client.post('/create_gene_table/results/', {
'taxonset': 1000,
'geneset': 1000,
'translations': False,
})
expected = 'Erebia'
self.assertTrue(expected in str(response.content))
class QuestionMethodTests(TestCase):
def setUp(self):
first_name = "Joe"
second_name = "Man"
email = "*****@*****.**"
password = "******"
self.user = User(first_name=first_name, second_name=second_name, email=email, password=password)
self.user.save()
Picture(user=self.user, photo="First_photo.png").save()
Picture(user=self.user, photo="Second_photo.png").save()
Settings(user=self.user, profile_pic="Profile_photo.png").save()
self.client = Client()
self.client.post("/login", data={"email": self.user.email, "password": self.user.password})
def test_logout_leads_to_login_page(self):
# setup
response = self.client.get("/logout")
# Test
self.assertEqual(response.status_code, 302)
self.assertRegexpMatches(response.url, "login")
def test_logout_link_is_available_at_home(self):
# setup
response = self.client.get("/home")
# Test
self.assertEqual(response.status_code, 200)
self.assertContains(response, '<a href="/logout" class="">Logout</a>')
def test_edit_site(self):
c = Client()
val = c.login(username = "******",password = "******")
print 'the login value is: %s' % val
data= {'site_name':u'kibuye',
'comission_date':datetime(2015,12,11,22,0),
'location_city':u'kigali',
'location_country':u'rwanda',
'time_zone':'Africa/Kigali',
'position_0':36,
'position_1':42,
'installed_kw':2,
'system_voltage':4,
'number_of_panels':100,
'site_Id':2,
'battery_bank_capacity':1200,
'api_key': 'testing',
'api_key_numeric': '123456'}
response = c.post('/edit_site/' + str(self.site.id) , data)
# Testing if the site has been edited succesfully
self.assertEqual(response.status_code, 200)
self.assertEqual(Sesh_Site.objects.first().site_name, 'kibuye')
# Checking for another unauthorized user
val = c.login(username="******",password="******")
response = c.post('/edit_site/' + str(self.site.id), data)
self.assertEqual(response.status_code, 403)
class ViewTest(TestCase):
def setUp(self):
self.client_stub = Client()
self.person = Person(first_name = 'TestFirst',last_name = 'TestLast')
self.person.save()
self.phone = Phone(person = self.person,number = '7778889999')
self.phone.save()
def test_view_home_route(self):
response = self.client_stub.get('/')
self.assertEquals(response.status_code, 200)
def test_view_contacts_route(self):
response = self.client_stub.get('/all/')
self.assertEquals(response.status_code, 200)
def test_add_contact_route(self):
response = self.client_stub.get('/add/')
self.assertEqual(response.status_code, 200)
def test_create_contact_successful_route(self):
response = self.client_stub.post('/create',data = {'first_name' : 'testFirst', 'last_name':'tester', 'email':'*****@*****.**', 'address':'1234 nowhere', 'city':'far away', 'state':'CO', 'country':'USA', 'number':'987654321'})
self.assertEqual(response.status_code, 302)
def test_create_contact_unsuccessful_route(self):
response = self.client_stub.post('/create',data = {'first_name' : 'tester_first_n@me', 'last_name':'test', 'email':'*****@*****.**', 'address':'5678 everywhere', 'city':'far from here', 'state':'CA', 'country':'USA', 'number':'987654321'})
self.assertEqual(response.status_code, 200)
def tearDown(self):
self.phone.delete()
self.person.delete()
class TestClient(unittest.TestCase):
def setUp(self):
# Every test needs a client.
self.client = Client()
g = Gmina.objects.create(nazwa="Jakas")
self.o = Obwod.objects.create(adres="Blabla", gmina=g)
def test_getting_obwod(self):
response = self.client.post('/obwod/', {'obw_id': self.o.id})
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
data = json.loads(response.content)
self.assertEqual(self.o.toDict(), data)
def test_saving_obwod(self):
response = self.client.post('/save/', {'obw_id': self.o.id, 'ileKart': '3', 'upr': '4', 'wer': '0'})
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
data = json.loads(response.content)
self.assertEqual(1, data['dict']['wer'])
self.assertEqual('3', data['dict']['ile'])
self.assertEqual('4', data['dict']['upr'])
self.assertEqual(self.o.id, data['dict']['id'])
self.assertEqual('Blabla', data['dict']['adres'])
self.assertEqual(False, data['err'])
def test_registration_api_fails_if_user_exists(self):
c = Client()
response = c.post('/register/', {'username': '******',
'password': '******',
'email': '*****@*****.**',
'first_name':'John',
'last_name':'smith',
'security_question':'mother maiden name',
'security_answer':'andrews',
'gender':'male',
'phone_number':'1231231233'})
second_response = c.post('/register/', {'username': '******',
'password': '******',
'email': '*****@*****.**',
'first_name':'John',
'last_name':'smith',
'security_question':'mother maiden name',
'security_answer':'andrews',
'gender':'male',
'phone_number':'1231231233'})
self.assertEqual(second_response.status_code, 400)
saved_user = ITUUser.objects.filter(username='******')
# still should only have one
self.assertEqual(len(saved_user), 1)
def test_session_auth_post_requires_csrf_token(self):
""" Verify non-GET requests require a CSRF token be attached to the request. """
user = UserFactory(password=self.password, is_staff=True)
client = Client(enforce_csrf_checks=True)
self.assertTrue(client.login(username=user.username, password=self.password))
data = {
'course_key': 'a/b/c',
'enabled': True
}
# POSTs without a CSRF token should fail.
response = client.post(self.path, data=json.dumps(data), content_type=JSON)
# NOTE (CCB): Ordinarily we would expect a 403; however, since the CSRF validation and session authentication
# fail, DRF considers the request to be unauthenticated.
self.assertEqual(response.status_code, 401)
self.assertIn('CSRF', response.content)
# Retrieve a CSRF token
response = client.get('/dashboard')
csrf_token = response.cookies[settings.CSRF_COOKIE_NAME].value # pylint: disable=no-member
self.assertGreater(len(csrf_token), 0)
# Ensure POSTs made with the token succeed.
response = client.post(self.path, data=json.dumps(data), content_type=JSON, HTTP_X_CSRFTOKEN=csrf_token)
self.assertEqual(response.status_code, 201)
class PasswordResetChangeTest(ShadowConTestCase):
def setUp(self):
self.client = Client()
def run_test(self, key):
response = self.client.get(reverse(key))
self.assertSectionContains(response, "ShadowCon 2016", "title")
return response
def test_login(self):
response = self.run_test('login')
self.assertSectionContains(response, '<p><a href="%s">%s</a></p>' % (reverse('password_reset'),
'Lost password\\?'),
'section id="main" role="main"', '/section')
self.assertSectionContains(response, '<p><a href="%s">%s</a></p>' % (reverse('convention:new_user'),
'Create New Account'),
'section id="main" role="main"', '/section')
def test_logout(self):
response = self.run_test('logout')
self.assertSectionContains(response, 'You have successfully logged out',
'section id="main" role="main"', '/section')
def test_password_change(self):
self.client.login(username="******", password="******")
response = self.run_test('password_change')
self.assertSectionContains(response, 'Enter new password', 'section id="main" role="main"', '/section')
def test_password_change_done(self):
self.client.login(username="******", password="******")
response = self.run_test('password_change_done')
self.assertSectionContains(response, '<h2>Password Changed</h2>', 'section id="main" role="main"', '/section')
def test_password_reset(self):
response = self.run_test('password_reset')
self.assertSectionContains(response, 'Forgotten your password\\? Enter your',
'section id="main" role="main"', '/section')
def test_password_reset_done(self):
response = self.run_test('password_reset_done')
self.assertSectionContains(response, 'Password reset sent', 'section id="main" role="main"', '/section')
def test_password_reset_confirm_invalid_link(self):
response = self.client.get(reverse('password_reset_confirm', args=["invalid", "4a8-cd1bf13135ee4cae7176"]))
self.assertSectionContains(response, "ShadowCon 2016", "title")
self.assertSectionContains(response, 'The password reset link was invalid',
'section id="main" role="main"', '/section')
def test_password_reset_confirm_valid_link(self):
self.client.post(reverse('password_reset'), {"email": "*****@*****.**"})
email = self.get_email()
start = str(email.body).index('/reset')
stop = str(email.body).index('Your username, in case you\'ve forgotten: user')
link = str(email.body)[start:stop].strip()
response = self.client.get(link)
self.assertSectionContains(response, "ShadowCon 2016", "title")
self.assertSectionContains(response, 'Please enter your new password twice',
'section id="main" role="main"', '/section')
class TestBuildbot2HTTPStatusPush(TransactionTestCase):
reset_sequences = True
build_data = """
{
"buildid": 7646,
"builderid": 3420,
"workerid": 21,
"started_at": 1596624615,
"complete_at": 1596624754,
"complete": true,
"state_string": "build successful",
"properties": {
"portname": [
"portA",
"Trigger"
],
"workername": [
"ports-darwin20-x86_64",
"Worker"
],
"portrevision": [
"0",
"SetPropertyFromCommand Step"
],
"portversion": [
"1.2",
"SetPropertyFromCommand Step"
]
}
}
"""
invalid_build_data = """
{
"buildid": 7646,
"builderid": 3420,
"workerid": 21,
"started_at": 1596624615,
"complete_at": 1596624754,
}
"""
def setUp(self):
self.client = Client()
def test_new_builder_added(self):
Builder.objects.create(name="builder-1")
self.assertEquals(Builder.objects.all().count(), 1)
# Now make a push, new builder should be added automatically
response = self.client.post(reverse('buildbot2_submit'),
data=self.build_data,
content_type='text/plain')
self.assertEquals(Builder.objects.all().count(), 2)
# Make same call again
response = self.client.post(reverse('buildbot2_submit'),
data=self.build_data,
content_type='text/plain')
self.assertEquals(Builder.objects.all().count(), 2)
self.assertEquals(BuildHistory.objects.all().count(), 1)
def test_invalid_build_data(self):
response = self.client.post(reverse('buildbot2_submit'),
data=self.invalid_build_data,
content_type='text/plain')
self.assertEquals(BuildHistory.objects.all().count(), 0)
self.assertEquals(Builder.objects.all().count(), 0)
def test_build_properties(self):
response = self.client.post(reverse('buildbot2_submit'),
data=self.build_data,
content_type='text/plain')
self.assertEquals(BuildHistory.objects.all().count(), 1)
build_object = BuildHistory.objects.get(build_id=7646)
self.assertEquals(build_object.status, "build successful")
self.assertEquals(build_object.port_name, "portA")
self.assertEquals(build_object.port_version, "1.2")
self.assertEquals(build_object.port_revision, "0")
def testAddImpactMissingRequired(self):
c = Client()
response = c.post('/add_impact/', { 'impact_type': 1, 'location_name': 'Missing', 'comment': 'My Comment'})
self.assertEquals(response.content, 'error')
class CaseUpdateViewTest(TestCase):
def setUp(self):
super().setUp()
self.client = Client()
self.user = User.objects.create_user(username='******', password='******')
self.user.save()
self.test_case = Cases.objects.create(date='2020-05-06', author=self.user, case_code='qwerty', images='ct',
case='s', product='knee', software='mimics', procedure='rec', time=60)
self.test_case.save()
def test_redirect_if_not_logged_in(self):
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 302)
self.assertTrue(resp.url.startswith('/accounts/login/'))
def test_view_uses_correct_template(self):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, 'report/case_update.html')
def test_redirect_to_all_cases(self):
self.client.login(username='******', password='******')
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2020-05-06', 'case_code': '12345', 'images': 'ct', 'case': 's', 'product': 'knee',
'software': 'mimics', 'procedure': 'check', 'time': '55'},
)
self.assertRedirects(resp, reverse('report:all-cases'))
def test_update_date(self):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2019-05-06', 'case_code': 'qwerty', 'images': 'ct', 'case': 's', 'product': 'knee',
'software': 'mimics', 'procedure': 'rec', 'time': '60'},)
case = Cases.objects.get()
self.assertEqual(str(case.date), '2019-05-06')
@ddt.data('new_case_code')
def test_update_case_code(self, case_code):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2020-05-06', 'case_code': case_code, 'images': 'ct', 'case': 's', 'product': 'knee',
'software': 'mimics', 'procedure': 'rec', 'time': '60'},)
case = Cases.objects.get()
self.assertEqual(case.case_code, case_code)
@ddt.data('ct', 'mri')
def test_update_images(self, images):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2020-05-06', 'case_code': 'qwerty', 'images': images, 'case': 's', 'product': 'knee',
'software': 'mimics', 'procedure': 'rec', 'time': '60'},)
case = Cases.objects.get()
self.assertEqual(case.images, images)
@ddt.data('s', 'o')
def test_update_case(self, test_case):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2020-05-06', 'case_code': 'qwerty123', 'images': 'ct', 'case': test_case, 'product': 'knee',
'software': 'mimics', 'procedure': 'rec', 'time': '60'}, )
case = Cases.objects.get()
self.assertEqual(case.case, test_case)
@ddt.data('spine', 'knee', 'hip', 'shoulder', 'forearm', 'wrist', 'ankle', )
def test_update_product(self, product):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2020-05-06', 'case_code': 'qwerty123', 'images': 'ct', 'case': 's', 'product': product,
'software': 'mimics', 'procedure': 'rec', 'time': '60'}, )
case = Cases.objects.get()
self.assertEqual(case.product, product)
@ddt.data('mimics', 'avizo')
def test_update_software(self, software):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2020-05-06', 'case_code': 'qwerty123', 'images': 'ct', 'case': 's', 'product': 'knee',
'software': software, 'procedure': 'rec', 'time': '60'}, )
case = Cases.objects.get()
self.assertEqual(case.software, software)
@ddt.data('rec', 'check')
def test_update_procedure(self, procedure):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2020-05-06', 'case_code': 'qwerty123', 'images': 'ct', 'case': 's', 'product': 'knee',
'software': 'mimics', 'procedure': procedure, 'time': '60'}, )
case = Cases.objects.get()
self.assertEqual(case.procedure, procedure)
@ddt.data(25, 35)
def test_update_time(self, time):
self.client.login(username='******', password='******')
resp = self.client.get(reverse('report:case-update', kwargs={'slug': self.test_case.id, }))
self.assertEqual(resp.status_code, 200)
resp = self.client.post(
reverse('report:case-update', kwargs={'slug': self.test_case.id, }),
{'date': '2020-05-06', 'case_code': 'qwerty123', 'images': 'ct', 'case': 's', 'product': 'knee',
'software': 'mimics', 'procedure': 'rec', 'time': time}, )
case = Cases.objects.get()
self.assertEqual(case.time, time)
class TestNodesView(TestCase):
def setUp(self):
self.testcase_user = create_root_user()
self.client = Client()
self.client.login(testcase_user=self.testcase_user)
def test_alltags_view(self):
"""
GET /alltags/
returns all tags of current user
"""
Tag.objects.create(user=self.testcase_user, name="tag1")
Tag.objects.create(user=self.testcase_user, name="tag2")
alltags_url = reverse('core:alltags')
ret = self.client.get(
alltags_url,
content_type='application/json',
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
)
self.assertEqual(ret.status_code, 200)
tags = json.loads(ret.content)
self.assertEqual(set([tag['name'] for tag in tags['tags']]),
set(["tag2", "tag1"]))
def test_validate_tags_against_xss(self):
p = Folder.objects.create(title="P", user=self.testcase_user)
ret = self.client.post(
reverse('core:tags', args=(p.id, )),
{'tags': [{
"name": "xss<script>alert('hi!')</script>"
}]},
content_type='application/json',
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
)
self.assertEquals(ret.status_code, 400)
def test_associate_tags_to_folder(self):
p = Folder.objects.create(title="P", user=self.testcase_user)
ret = self.client.post(
reverse('core:tags', args=(p.id, )),
{'tags': [{
"name": "red"
}, {
"name": "green"
}]},
content_type='application/json',
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
)
self.assertEquals(ret.status_code, 200)
found_folders = Folder.objects.filter(
tags__name__in=["red", "green"]).distinct()
self.assertEqual(found_folders.count(), 1)
def test_create_one_tag_in_tags_view(self):
"""
User create tags in tags list view (left menu - tags).
Tags are created per user.
"""
tag_count = Tag.objects.filter(user=self.testcase_user,
name="tag_x").count()
self.assertEquals(tag_count, 0)
ret = self.client.post(
reverse('admin:tag-add'),
{
"name": "tag_x",
"fg_color": "#ffffff",
"bg_color": "#c41fff"
},
)
self.assertEquals(ret.status_code, HttpResponseRedirect.status_code)
tag_count = Tag.objects.filter(user=self.testcase_user,
name="tag_x").count()
self.assertEquals(tag_count, 1)
def run():
client = Client()
client.login(username=SUPERUSER_USERNAME, password=SUPERUSER_PASSWORD)
# setup the Flowvisor
response = test_get_and_post_form(
client,
reverse("set_flowvisor"),
params=dict(
name="flowvisor",
username=FV_USERNAME,
password=FV_PASSWORD,
password2=FV_PASSWORD,
url=FV_URL,
),
)
assert response.status_code == 301
# setup the Clearinghouse user
response = test_get_and_post_form(
client,
reverse("set_clearinghouse"),
params=dict(
username=CH_USERNAME,
password1=CH_PASSWORD,
password2=CH_PASSWORD,
),
)
assert response.status_code == 301
client.logout()
for username, info in USER_INFO.items():
# create user
User.objects.create_user(username=username,
email=info["email"],
password=info["password"])
client.login(username=username, password=info["password"])
# request flowspace
for fs in info["flowspace"]:
response = test_get_and_post_form(
client,
reverse("user_reg_fs"),
params=dict(
mac_addr=fs["mac_addr"],
ip_addr=fs["ip_addr"],
),
)
assert response.status_code == 301
client.logout()
# Login to approve user requests
client.login(username=SUPERUSER_USERNAME, password=SUPERUSER_PASSWORD)
# Parse the approval form
resp = client.get(reverse("approve_user_reg_table"))
# Get all the forms
d = pq(resp.content, parser="html")
forms = d("form")
for f in forms:
# only post to approve urls
if "approve" in f.action:
client.post(f.action, {})
client.logout()
class LoginTestCase(TestCase):
"""
test cases for logging in and signing up (users)
can use c = Client() for creating a client and
response = c.post(url, context_params) to post data to the url page
response = c.get(url) to get the page (doing c.get(url, follow=True) allows you to get the redirect chain via response.redirect_chain )
also
c.login(username='******', password='******') to login users (returns True if successful)
response.context[key] to get the context value for the key
"""
def setUp(self):
self.credentials = {'username': '******', 'password': '******'}
User.objects.create_user(self.credentials)
self.client = Client()
""" using incorrect credentials; should not make valid form """
def signup_with_incorrect_input(self):
data = {
'username': "******",
'password1': "testuserpassword",
'password2': "testuserpasswordwrong"
}
form = UserCreationForm(data=data)
self.assertFalse(form.is_valid())
""" using correct credentials; should make valid form """
def signup_with_correct_input(self):
data = {
'username': "******",
'password1': "testuserpassword",
'password2': "testuserpassword"
}
form = UserCreationForm(data=data)
self.assertFalse(form.is_valid())
""" using incorrect credentials; should not make user logged in (active) """
def login_with_incorrect_input(self):
data = {
'username': "******",
'password1': "secretwrong",
}
response = self.client.post(reverse('login'), data)
self.assertFalse(response.context['user'].is_active)
""" using correct credentials; should make user logged in (active) """
def login_with_correct_input(self):
data = {
'username': "******",
'password1': "secret",
}
response = self.client.post(reverse('login'), data)
self.assertTrue(response.context['user'].is_active)
""" log out the user, should be inactive """
def logout(self):
self.client.get(reverse('logout'))
self.assertFalse(response.context['user'].is_active)
class GalleryTestCase(TestCase):
def setUp(self):
self.user1 = user_model.User.objects.create_user(username='******',
password='******')
level = Level(flavor="Plain",
plane_life_span=1,
max_today_write=3,
max_today_reply=3,
next_level_likes=10)
level.save()
author1 = User(user=self.user1,
today_write_count=3,
today_reply_count=3,
total_likes=2,
level=level)
author1.save()
self.photo1 = Photo(image='0.jpg',
is_reported=False,
color=4,
author=author1)
self.photo1.save()
self.photo2 = Photo(image='1.jpg',
is_reported=False,
color=1,
author=author1)
self.photo2.save()
self.photo3 = Photo(image='2.jpg',
is_reported=False,
color=2,
author=author1)
self.photo3.save()
self.photo4 = Photo(image='3.jpg',
is_reported=False,
color=3,
author=author1)
self.photo4.save()
self.photo5 = Photo(image='4.jpeg',
is_reported=False,
color=4,
author=author1)
self.photo5.save()
self.client = Client()
def generate_photo_file(self):
file = io.BytesIO()
image = Image.new('RGBA', size=(100, 100), color=(155, 0, 0))
image.save(file, 'png')
file.name = 'test.png'
file.seek(0)
return file
def test_photo_list_get(self):
# Sign-in
response = self.client.get('/api/photo/random/')
self.assertEqual(response.status_code, 200)
data = json.loads(response.content.decode())
self.assertEqual(len(data), 5)
def test_photo_list_post(self):
image_file = self.generate_photo_file()
response = self.client.post('/api/photo/', {
'image': image_file,
'is_reported': 'False',
'color': '5'
},
format='multipart')
self.assertEqual(response.status_code, 400)
def test_photo_list_get_by_color(self):
response = self.client.get('/api/photo/color/4/')
self.assertEqual(response.status_code, 200)
data = json.loads(response.content.decode())
self.assertEqual(len(data), 2)
def test_photo_detail_report(self):
id = self.photo3.id
response = self.client.put('/api/photo/{}/report/'.format(id), {},
format='multipart')
self.assertEqual(response.status_code, 204)
response = self.client.get('/api/photo/{}/'.format(id))
data = json.loads(response.content.decode())
self.assertEqual(data['id'], id)
def test_photo_detail_delete(self):
id = self.photo1.id
response = self.client.delete('/api/photo/{}/'.format(id))
self.assertEqual(response.status_code, 204)
response = self.client.get('/api/photo/{}/'.format(id))
self.assertEqual(response.status_code, 404)
class SearchChklstTest(TransactionTestCase):
def setUp(self):
self.my_company = Company.objects.create(company_name='toto')
self.my_company2 = Company.objects.create(company_name='toto2')
self.my_manager = Manager.objects.create(mgr_name='mymanager',
mgr_company=self.my_company)
self.my_manager2 = Manager.objects.create(mgr_name='mymanager2',
mgr_company=self.my_company)
self.my_checklist = CheckList.objects.create(
chk_key="toto2",
chk_title='Libellé',
chk_company=self.my_company,
chk_enable=True,
)
self.my_material = Material.objects.create(
mat_designation="mymaterial",
mat_registration='Libellé',
mat_type="zzz",
mat_model="aaa",
mat_enable=True,
mat_company=self.my_company,
mat_manager=self.my_manager,
)
self.my_material2 = Material.objects.create(
mat_designation="mamaterial2",
mat_registration='Libellé',
mat_type="zzz",
mat_model="aaa",
mat_enable=True,
mat_company=self.my_company,
mat_manager=self.my_manager,
)
self.c = Client()
self.user = self.c.force_login(
User.objects.get_or_create(username='******',
user_company=self.my_company)[0])
self.new_chklst_done = CheckListDone.objects.create(
cld_status=1,
cld_key='unique_key',
cld_pdf_file="fic.pdf",
cld_valid=True,
cld_user=self.user,
cld_checklist=self.my_checklist,
cld_material=self.my_material,
cld_manager=self.my_manager,
cld_company=self.my_company)
self.new_chklst_done2 = CheckListDone.objects.create(
cld_status=1,
cld_key='unique_key2',
cld_pdf_file="fic.pdf",
cld_valid=True,
cld_user=self.user,
cld_checklist=self.my_checklist,
cld_material=self.my_material2,
cld_manager=self.my_manager,
cld_company=self.my_company)
def test_VIEW_autocomplete_search_chklst_1param_is_OK(self):
""""
verify Ajax search_chklst material parameter is OK --> returns 1 chklst
"""
print(inspect.currentframe().f_code.co_name)
data = {
'material': self.my_material.id,
}
data = json.dumps(data)
response = self.c.post("/app_home/search_chklst/",
data,
content_type="application/json")
assert response.status_code == 200
assert '"unique_key"' in response.content.decode("utf-8")
assert '"unique_key2"' not in response.content.decode("utf-8")
def test_VIEW_autocomplete_search_chklst_2returns_is_OK(self):
""""
verify Ajax search_chklst parameter manager is OK (parameter manager --> returns 2 checklists)
"""
print(inspect.currentframe().f_code.co_name)
data = {
'manager': self.my_manager.id,
}
data = json.dumps(data)
response = self.c.post("/app_home/search_chklst/",
data,
content_type="application/json")
assert response.status_code == 200
assert '"unique_key"' in response.content.decode("utf-8")
assert '"unique_key2"' in response.content.decode("utf-8")
class pages_views_test(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_superuser('*****@*****.**',
'microtest', 'mp')
self.page = Page.objects.create(title='Page', content='page_content')
# self.menu = Menu.objects.create(title='main', url='micro.in', status='on', lvl=1)
def test_views(self):
user_login = self.client.login(username='******', password='******')
self.assertTrue(user_login)
response = self.client.get('/blog/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/portal/content/page/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/portal/content/page/new/')
self.assertEqual(response.status_code, 200)
response = self.client.post('/portal/content/page/new/', {
'title': 'Page2',
'content': 'page_content'
})
self.assertEqual(response.status_code, 200)
self.assertTrue('Page created successfully' in response.content)
response = self.client.post('/portal/content/page/new/',
{'content': 'page_content'})
self.assertEqual(response.status_code, 200)
self.assertFalse('Page created successfully' in response.content)
response = self.client.get('/portal/content/menu')
self.assertEqual(response.status_code, 301)
response = self.client.get('/portal/content/menu/new/')
self.assertEqual(response.status_code, 200)
## With right input
response = self.client.post('/portal/content/menu/new/', {
'title': 'main',
'url': 'micro.in/m',
'status': 'on'
})
self.assertEqual(response.status_code, 200)
self.assertTrue('Menu created successfully' in response.content)
# Test cases for changing menu order
response = self.client.post('/portal/content/menu/1/order/',
{'mode': 'down'})
self.assertTrue(response.status_code, 200)
self.assertTrue('You cant move down' in response.content)
response = self.client.post('/portal/content/menu/1/order/',
{'mode': 'up'})
self.assertTrue(response.status_code, 200)
self.assertTrue('You cant move up' in response.content)
##with wrong input
response = self.client.post('/portal/content/menu/new/', {
'url': 'micro.in/m',
'status': 'on'
})
self.assertEqual(response.status_code, 200)
self.assertFalse('successfully' in response.content)
response = self.client.get('/portal/content/page/edit/' +
str(self.page.id) + '/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/portal/content/menu/')
self.assertEqual(response.status_code, 200)
response = self.client.post(
'/portal/content/page/edit/' + str(self.page.id) + '/', {
'title': 'Page',
'content': 'page_content'
})
self.assertEqual(response.status_code, 200)
self.assertTrue('successfully' in response.content)
response = self.client.post(
'/portal/content/page/edit/' + str(self.page.id) + '/',
{'content': 'page_content'})
self.assertEqual(response.status_code, 200)
self.assertFalse('successfully' in response.content)
##chnage menu status to off
response = self.client.get('/portal/content/menu/status/1/')
self.assertEqual(response.status_code, 302)
##change menu status to on
response = self.client.get('/portal/content/menu/status/1/')
self.assertEqual(response.status_code, 302)
response = self.client.get('/portal/content/menu/edit/1/')
self.assertTrue(response.status_code, 200)
response = self.client.post('/portal/content/menu/edit/1/', {
'title': 'main2',
'url': 'micro.in/menu',
'status': 'on'
})
self.assertTrue(response.status_code, 200)
self.assertTrue('updated successfully' in response.content)
response = self.client.post('/portal/content/menu/edit/1/', {
'title': 'main2',
'url': 'micro.in/menu',
'status': 'on',
'parent': 1
})
self.assertTrue(response.status_code, 200)
self.assertTrue(
'can not choose the same as parent' in response.content)
response = self.client.post('/portal/content/menu/edit/1/', {
'title': 'main2',
'url': 'micro.in/menu',
'status': 'on',
'parent': 2
})
self.assertTrue(response.status_code, 200)
#self.assertTrue('can not choose the same as parent' in response.content)
response = self.client.post('/portal/content/menu/edit/1/', {
'url': 'micro.in',
'status': 'on'
})
self.assertTrue(response.status_code, 200)
self.assertFalse('successfully' in response.content)
response = self.client.post('/portal/content/menu/new/', {
'title': 'menu2',
'url': 'http://micro.com/menu2',
'status': 'on'
})
self.assertEqual(response.status_code, 200)
self.assertTrue('Menu created successfully' in response.content)
# Test cases for changing menu order
response = self.client.post('/portal/content/menu/1/order/',
{'mode': 'down'})
self.assertTrue(response.status_code, 200)
response = self.client.post('/portal/content/menu/1/order/',
{'mode': 'up'})
self.assertTrue(response.status_code, 200)
response = self.client.post('/portal/content/menu/edit/1/', {
'title': 'main2',
'url': 'micro.in/menu',
'status': 'on',
'parent': 2
})
self.assertTrue(response.status_code, 200)
self.assertTrue('updated successfully' in response.content)
response = self.client.get('/portal/content/menu/delete_menu/1/')
self.assertTrue(response.status_code, 200)
response = self.client.get('/page2/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/portal/content/page/delete/' +
str(self.page.id) + '/')
self.assertEqual(response.status_code, 302)
class SearchTest(TransactionTestCase):
def setUp(self):
self.my_company = Company.objects.create(company_name='toto')
self.my_company2 = Company.objects.create(company_name='toto2')
self.my_manager = Manager.objects.create(mgr_name='mymanager',
mgr_company=self.my_company)
self.my_manager2 = Manager.objects.create(mgr_name='mymanager2',
mgr_company=self.my_company)
self.my_checklist = CheckList.objects.create(
chk_key="toto2",
chk_title='Libellé',
chk_company=self.my_company,
chk_enable=True,
)
self.my_material = Material.objects.create(
mat_designation="mymaterial",
mat_registration='Libellé',
mat_type="zzz",
mat_model="aaa",
mat_enable=True,
mat_company=self.my_company,
mat_manager=self.my_manager,
)
self.my_material2 = Material.objects.create(
mat_designation="mamaterial2",
mat_registration='Libellé',
mat_type="zzz",
mat_model="aaa",
mat_enable=True,
mat_company=self.my_company,
mat_manager=self.my_manager,
)
self.c = Client()
def test_VIEW_autocomplete_search_mat_is_OK(self):
""""
verify Ajax autocomplete_search_mat is OK
"""
print(inspect.currentframe().f_code.co_name)
self.c.force_login(
User.objects.get_or_create(username='******',
user_company=self.my_company)[0])
data = {
'manager': self.my_manager.id,
}
data = json.dumps(data)
response = self.c.post("/app_home/autocomplete_search_mat/",
data,
content_type="application/json")
assert response.status_code == 200
assert '"mymaterial"' in response.content.decode("utf-8")
def test_VIEW_autocomplete_search_man_is_OK(self):
""""
verify Ajax autocomplete_search_man is OK
"""
print(inspect.currentframe().f_code.co_name)
self.c.force_login(
User.objects.get_or_create(username='******',
user_company=self.my_company)[0])
data = {
'material': self.my_material.id,
}
data = json.dumps(data)
response = self.c.post("/app_home/autocomplete_search_man/",
data,
content_type="application/json")
assert response.status_code == 200
assert '"mymanager"' in response.content.decode("utf-8")
class TestViews(TestCase):
"""
Includes tests for all the functionality
associated with Views
"""
def setUp(self):
self.client = Client()
self.other_client = Client()
self.user = get_user_model().objects.create_user(
username='******',
email='*****@*****.**',
password='******'
)
self.other_user = get_user_model().objects.create_user(
username='******',
email='*****@*****.**',
password='******'
)
self.client.login(username='******', password='******')
self.other_client.login(
username='******', password='******')
self.question_one = Question.objects.create(
user=self.user, title='This is a sample question',
description='This is a sample question description',
tags='test1,test2')
self.question_two = Question.objects.create(
user=self.user,
title='A Short Title',
description='''This is a really good content, just if somebody
published it, that would be awesome, but no, nobody wants to
publish it, because they know this is just a test, and you
know than nobody wants to publish a test, just a test;
everybody always wants the real deal.''',
favorites=0,
has_accepted_answer=True
)
self.answer = Answer.objects.create(
user=self.user,
question=self.question_two,
description='A reaaaaally loooong content',
votes=0,
is_accepted=True
)
def test_index_questions(self):
response = self.client.get(reverse('questions'))
self.assertEqual(response.status_code, 200)
self.assertTrue(
'This is a sample question' in str(response.context['question']))
def test_create_question_view(self):
"""
"""
current_question_count = Question.objects.count()
response = self.client.post(reverse('ask'),
{'title': 'Not much of a title',
'description': 'babla',
'tags': 'test, tag'})
self.assertEqual(response.status_code, 302)
new_question = Question.objects.first()
self.assertEqual(new_question.title, 'Not much of a title')
self.assertEqual(Question.objects.count(),
current_question_count + 1)
def test_answered_questions(self):
response = self.client.get(reverse('answered'))
self.assertEqual(response.status_code, 200)
self.assertTrue('A Short Title' in str(response.context['question']))
def test_all_questions_view(self):
response = self.client.get(reverse('all'))
self.assertEqual(response.status_code, 200)
self.assertTrue('A Short Title' in str(response.context['question']))
def test_individual_question(self):
response = self.client.get(
'/questions/{}/'.format(self.question_one.id))
self.assertEqual(response.status_code, 200)
self.assertTrue(
'This is a sample question' in str(response.context['question']))
def test_answer_question(self):
current_answer_count = Answer.objects.count()
response = self.client.post(
reverse('answer'),
{'question': self.question_one.id,
'description': 'A reaaaaally loooong content'})
self.assertEqual(response.status_code, 302)
self.assertEqual(Answer.objects.count(), current_answer_count + 1)
def test_empty_answer(self):
current_answer_count = Answer.objects.count()
response = self.client.post(reverse('answer'),
{'question': self.question_one.id})
self.assertEqual(response.status_code, 200)
self.assertEqual(Answer.objects.count(), current_answer_count)
def test_answer_redirects(self):
response = self.other_client.get(reverse('answer'))
self.assertRedirects(response, reverse('questions'), status_code=302)
class TestAPI(TestCase):
fixtures = [
'organization_types.json', 'organization_government.json',
'organization_balance_gov.json', 'credit_trade_statuses.json',
'credit_trade_statuses_refused.json',
'organization_actions_types.json', 'organization_statuses.json',
'test_users.json', 'credit_trade_types.json',
'test_credit_trades.json', 'test_organization_fuel_suppliers.json',
'test_organization_balances.json', 'roles.json', 'permissions.json',
'roles_permissions.json'
]
def setUp(self):
# Initialize Foreign keys
# self.ct_status_id = fake_api_calls?.create_credit_trade_status()
self.ct_type_id = fake_api_calls.create_credit_trade_type()
self.fs1_id, self.fs1_status_id, self.fs1_action_type_id = (
fake_api_calls.create_organization())
self.user_id = fake_api_calls.create_user(self.fs1_id)
resp_user = User.objects.get(id=self.user_id)
resp_user.authorization_guid = 'e46435c1-7d69-489f-9dde-83005cd77744'
resp_user.save()
'''
Apply a fuel supplier role to the default user
'''
fs_user = User.objects.get(username='******')
fs_role = Role.objects.get(name='FSManager')
UserRole.objects.create(user_id=fs_user.id, role_id=fs_role.id)
'''
Apply a fuel supplier role to the respondent user
'''
fs_role = Role.objects.get(name='FSManager')
UserRole.objects.create(user_id=resp_user.id, role_id=fs_role.id)
self.credit_trade = fake_api_calls.create_credit_trade(
initiator=2,
respondent=self.fs1_id,
type=self.ct_type_id,
status=STATUS_DRAFT,
user_id=self.user_id,
)
self.client = Client(
HTTP_SMGOV_USERGUID='c9804c52-05f1-4a6a-9d24-332d9d8be2a9',
HTTP_SMGOV_USERDISPLAYNAME='Brad Smith',
HTTP_SMGOV_USEREMAIL='*****@*****.**',
HTTP_SM_UNIVERSALID='BSmith')
self.gov_client = Client(
HTTP_SMGOV_USERGUID='c2971372-3a96-4704-9b9c-18e4e9298ee3',
HTTP_SMGOV_USERDISPLAYNAME='Test Person',
HTTP_SMGOV_USEREMAIL='*****@*****.**',
HTTP_SM_UNIVERSALID='Teperson',
HTTP_SMGOV_USERTYPE='Internal',
HTTP_SM_AUTHDIRNAME='IDIR')
self.respondent_client = Client(
HTTP_SMGOV_USERGUID='e46435c1-7d69-489f-9dde-83005cd77744',
HTTP_SMGOV_USERDISPLAYNAME=resp_user.display_name,
HTTP_SMGOV_USEREMAIL=resp_user.email)
'''
Apply a government role to Teperson
'''
gov_user = User.objects.get(username='******')
gov_role = Role.objects.get(name='GovDirector')
UserRole.objects.create(user_id=gov_user.id, role_id=gov_role.id)
self.test_url = "/api/credit_trades"
self.test_data_fail = [{
'data': {
'number_of_credits': 1
},
'response': {
"status": ["This field is required."],
"respondent": ["This field is required."],
"type": ["This field is required."]
}
}, {
'data': {
'number_of_credits': 1,
'status': STATUS_DRAFT
},
'response': {
"respondent": ["This field is required."],
"type": ["This field is required."],
}
}, {
'data': {
'number_of_credits': 1,
'status': STATUS_DRAFT,
'respondent': self.fs1_id
},
'response': {
"type": ["This field is required."]
}
}]
self.test_data_success = [{
'data': {
'number_of_credits': 1,
'status': STATUS_DRAFT,
'initiator': 2,
'respondent': self.fs1_id,
'type': self.ct_type_id
},
}]
def test_current_user(self):
response = self.client.get('/api/users/current')
response_data = json.loads(response.content.decode("utf-8"))
HTTP_SMGOV_USERGUID = 'c9804c52-05f1-4a6a-9d24-332d9d8be2a9'
HTTP_SMGOV_USERDISPLAYNAME = 'Brad Smith'
HTTP_SMGOV_USEREMAIL = '*****@*****.**'
HTTP_SM_UNIVERSALID = 'BSmith'
assert response_data['authorizationGuid'] == HTTP_SMGOV_USERGUID
assert response_data['authorizationId'] == HTTP_SM_UNIVERSALID.lower()
assert response_data['email'] == HTTP_SMGOV_USEREMAIL
assert response_data['displayName'] == HTTP_SMGOV_USERDISPLAYNAME
def test_create_fail(self):
credit_trades = self.test_data_fail
for tests in credit_trades:
response = self.client.post(self.test_url,
content_type='application/json',
data=json.dumps(tests['data']))
self.assertJSONEqual(response.content.decode("utf-8"),
tests['response'])
assert response.status_code == status.HTTP_400_BAD_REQUEST
def test_create_success(self):
credit_trades = self.test_data_success
for tests in credit_trades:
response = self.client.post(self.test_url,
content_type='application/json',
data=json.dumps(tests['data']))
assert status.HTTP_201_CREATED == response.status_code
def test_create_and_create_trade_history(self):
credit_trades = self.test_data_success
for tests in credit_trades:
response = self.client.post(self.test_url,
content_type='application/json',
data=json.dumps(tests['data']))
ct_id = response.data['id']
response = self.client.get("{}/{}/history".format(
self.test_url, ct_id),
content_type='application/json')
assert status.HTTP_200_OK == response.status_code
def test_update(self, **kwargs):
credit_trade_id = kwargs.get("credit_trade_id",
self.credit_trade['id'])
num_of_credits = kwargs.get("num_of_credits", 4)
credit_trade_status = kwargs.get("credit_trade_status", STATUS_DRAFT)
fair_market_value = kwargs.get("fair_market_value", 1)
#
# if not credit_trade_id:
# credit_trade_id = self.credit_trade_id
data = {
'number_of_credits': num_of_credits,
'status': credit_trade_status,
'initiator': 2,
'respondent': self.fs1_id,
'type': self.ct_type_id,
'fair_market_value_per_credit': fair_market_value
}
response = self.client.put("{}/{}".format(self.test_url,
credit_trade_id),
content_type='application/json',
data=json.dumps(data))
assert status.HTTP_200_OK == response.status_code
def test_update_create_trade_history(self):
self.test_update(num_of_credits=1)
self.test_update(num_of_credits=2)
response = self.client.get("{}/{}/history".format(
self.test_url, self.credit_trade['id']),
content_type='application/json')
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(3, len(response_data))
assert status.HTTP_200_OK == response.status_code
# TODO: possibly move the next set of tests to another file;
# They test the business logic & not the API itself.
def test_is_internal_history_false(self):
self.test_update(credit_trade_status=STATUS_SUBMITTED)
data = {
'number_of_credits': 4,
'status': STATUS_ACCEPTED,
'initiator': 2,
'respondent': self.fs1_id,
'type': self.ct_type_id,
'fair_market_value_per_credit': 1
}
response = self.respondent_client.put("{}/{}".format(
self.test_url, self.credit_trade['id']),
content_type='application/json',
data=json.dumps(data))
# self.test_update(credit_trade_status=STATUS_ACCEPTED)
# TODO: Change this to /id/propose and /id/accept
response = self.client.get("{}/{}/history".format(
self.test_url, self.credit_trade['id']),
content_type='application/json')
response_data = json.loads(response.content.decode("utf-8"))
self.assertFalse(response_data[0]['isInternalHistoryRecord'])
def test_is_internal_history_draft(self):
# Initially created credit trade is "Draft"
response = self.client.get("{}/{}/history".format(
self.test_url, self.credit_trade['id']),
content_type='application/json')
response_data = json.loads(response.content.decode("utf-8"))
self.assertTrue(response_data[0]['isInternalHistoryRecord'])
def test_is_internal_history_draft_then_cancelled(self):
# Initially created credit trade is "Draft"
# Update the status to "Cancelled"
self.test_update(credit_trade_status=STATUS_CANCELLED)
credit_trade = CreditTrade.objects.get(id=self.credit_trade['id'])
self.assertEqual(credit_trade.status_id, STATUS_CANCELLED)
def test_nested_credit_trade(self):
response = self.client.get("{}/{}".format(self.test_url,
self.credit_trade['id']),
content_type='application/json')
response_data = json.loads(response.content.decode("utf-8"))
credit_trade_status = {"id": STATUS_DRAFT, "status": "Draft"}
self.assertTrue(
set(credit_trade_status).issubset(response_data['status']))
def test_nested_credit_trade_history(self):
response = self.client.get("{}/{}/history".format(
self.test_url, self.credit_trade['id']),
content_type='application/json')
response_data = json.loads(response.content.decode("utf-8"))[0]
credit_trade_status = {"id": STATUS_DRAFT, "status": "Draft"}
self.assertTrue(
set(credit_trade_status).issubset(response_data['status']))
def test_get_fuel_suppliers_only(self):
response_data = fake_api_calls.get_fuel_suppliers()
for r in response_data:
assert r['type'] == 2
def test_approved_buy(self, **kwargs):
# get fuel supplier balance for fs 1
initiator_bal = fake_api_calls.get_organization_balance(id=2)
respondent_bal, created = OrganizationBalance.objects.get_or_create(
organization_id=self.fs1_id,
expiration_date=None,
defaults={'validated_credits': 10000})
num_of_credits = 50
credit_trade = fake_api_calls.create_credit_trade(
user_id=self.user_id,
status=STATUS_SUBMITTED,
fair_market_value_per_credit=1000,
initiator=2,
respondent=self.fs1_id,
number_of_credits=num_of_credits,
type=2)
data = {
'number_of_credits': num_of_credits,
'status': STATUS_ACCEPTED,
'initiator': 2,
'respondent': self.fs1_id,
'type': 2,
'fair_market_value_per_credit': 1000
}
resp_user = User.objects.get(id=self.user_id)
resp_user.organization_id = self.fs1_id
resp_user.save()
response = self.respondent_client.put("{}/{}".format(
self.test_url, credit_trade['id']),
content_type='application/json',
data=json.dumps(data))
response = self.gov_client.put("{}/{}/approve".format(
self.test_url, credit_trade['id']),
content_type='application/json')
assert status.HTTP_200_OK == response.status_code
# TODO: Make sure two credit histories are created
initiator_bal_after = fake_api_calls.get_organization_balance(id=2)
respondent_bal_after = fake_api_calls.get_organization_balance(
id=self.fs1_id)
init_final_bal = initiator_bal['validatedCredits'] + num_of_credits
resp_final_bal = respondent_bal.validated_credits - num_of_credits
ct_completed = self.client.get("{}/{}".format(self.test_url,
credit_trade['id']),
content_type='application/json')
completed_response = json.loads(ct_completed.content.decode("utf-8"))
# response_data should have status == completed
today = datetime.datetime.today().strftime('%Y-%m-%d')
# Status of Credit Trade should be 'completed'
self.assertEqual(completed_response['status']['id'], STATUS_COMPLETED)
# Effective date should be today
self.assertEqual(initiator_bal_after['effectiveDate'], today)
self.assertEqual(respondent_bal_after['effectiveDate'], today)
# Credits should be subtracted/added
self.assertEqual(init_final_bal,
initiator_bal_after['validatedCredits'])
self.assertEqual(resp_final_bal,
respondent_bal_after['validatedCredits'])
def test_approved_sell(self, **kwargs):
pass
def test_approved_credit_validation(self, **kwargs):
pass
def test_approved_retirement(self, **kwargs):
pass
def test_approved_part_3_award(self, **kwargs):
pass
#
# def test_director_approved(self):
# """Execute and complete a trade when an "On Director's Approval" Trade
# is approved"""
# tests = [{
# 'data': {
# 'credit_trade_status': STATUS_APPROVED,
# 'number_of_credits': 2
# },
# 'response': {
# ''
# }
# }, {
# 'data': {
# 'credit_trade_status': STATUS_DRAFT,
# 'number_of_credits': 10,
# 'fair_market_value': "Value"
# },
# 'response': {
# ''
# }
# }]
# for test in tests:
# self.test_update(**test['data'])
# self.test_update(credit_trade_status=STATUS_APPROVED)
"""Test that no other fields are changed, except for notes,
effective date & status"""
# don't care where it comes from (ignore previous status)
# status is "Approved"
# no other fields can change, unless from getting a new note
# effective date is None or past
# Set effective date on director's approval
# fuel supplier receives credits
# fuel supplier loses credits
# OrganizationBalance record created, effective data = transaction create time
# end data is None
# pass
# Test transitions of statuses
def test_create_draft_or_proposed(self, **kwargs):
credit_trades = [{
'numberOfCredits': 1,
'status': STATUS_DRAFT,
'initiator': 2,
'respondent': self.fs1_id,
'type': self.ct_type_id
}, {
'numberOfCredits': 1,
'status': STATUS_SUBMITTED,
'initiator': 2,
'respondent': self.fs1_id,
'type': self.ct_type_id
}]
for ct in credit_trades:
response = fake_api_calls.create_credit_trade_dict(ct)
assert status.HTTP_201_CREATED == response.status_code
# Make sure action statuses are "Draft" and "Submitted"
# And Button actions are "Save as Draft" and "Propose"
new_ct = fake_api_calls.get_credit_trade(response.json()['id'])
if ct['status'] == STATUS_DRAFT:
statuses = [a['status'] for a in new_ct.json()['actions']]
actions = [a['action'] for a in new_ct.json()['actions']]
assert sorted(["Draft", "Submitted"]) == sorted(statuses)
assert sorted(["Save Draft", "Propose"]) == sorted(actions)
def test_create_other_statuses_fail(self, **kwargs):
credit_trades = [{
'data': {
'numberOfCredits': 1,
'status': STATUS_ACCEPTED,
'respondent': self.fs1_id,
'type': self.ct_type_id
},
'error': {
"invalidStatus": [
"You do not have permission to set"
" statuses to `Accepted`."
]
}
}, {
'data': {
'numberOfCredits': 1,
'status': STATUS_RECOMMENDED,
'respondent': self.fs1_id,
'type': self.ct_type_id
},
'error': {
"invalidStatus": [
"You do not have permission to set"
" statuses to `Recommended`."
]
}
}, {
'data': {
'numberOfCredits': 1,
'status': STATUS_APPROVED,
'respondent': self.fs1_id,
'type': self.ct_type_id
},
'error': {
"invalidStatus": [
"You do not have permission to set"
" statuses to `Approved`."
]
}
}, {
'data': {
'numberOfCredits': 1,
'status': STATUS_COMPLETED,
'respondent': self.fs1_id,
'type': self.ct_type_id
},
'error': {
"invalidStatus": [
"You do not have permission to set"
" statuses to `Completed`."
]
}
}, {
'data': {
'numberOfCredits': 1,
'status': STATUS_CANCELLED,
'respondent': self.fs1_id,
'type': self.ct_type_id
},
'error': {
"invalidStatus": [
"You do not have permission to set"
" statuses to `Cancelled`."
]
}
}, {
'data': {
'numberOfCredits': 1,
'status': STATUS_DECLINED,
'respondent': self.fs1_id,
'type': self.ct_type_id
},
'error': {
"invalidStatus": [
"You do not have permission to set"
" statuses to `Declined`."
]
}
}]
for tests in credit_trades:
response = fake_api_calls.create_credit_trade_dict(tests['data'])
self.assertJSONEqual(response.content.decode("utf-8"),
tests['error'])
assert response.status_code == status.HTTP_400_BAD_REQUEST
def test_update_draft_to_proposed_success(self, **kwargs):
credit_trades = [{
'numberOfCredits': 1,
'status': STATUS_DRAFT,
'initiator': 2,
'respondent': self.fs1_id,
'type': self.ct_type_id
}, {
'numberOfCredits': 5,
'status': STATUS_DRAFT,
'initiator': 2,
'respondent': self.fs1_id,
'type': self.ct_type_id
}]
self.test_create_success()
for ct in credit_trades:
# Create
response = fake_api_calls.create_credit_trade_dict(ct)
assert status.HTTP_201_CREATED == response.status_code
# Update
ct['status'] = STATUS_SUBMITTED
updated_response = fake_api_calls.update_credit_trade_dict(
ct,
response.json()['id'])
assert status.HTTP_200_OK == updated_response.status_code
def test_update_proposed_to_accepted(self, **kwargs):
pass
def test_update_proposed_to_rescinded(self, **kwargs):
pass
def test_update_proposed_to_refused(self, **kwargs):
pass
def test_update_accepted_to_rescinded(self, **kwargs):
pass
def test_update_accepted_to_recommended(self, **kwargs):
pass
def test_update_accepted_to_approved(self, **kwargs):
pass
def test_update_accepted_to_declined(self, **kwargs):
pass
class TestEmployeeViews(TestCase):
def setUp(self):
self.client = Client()
self.register_url = reverse('register')
self.details_url = reverse('details')
self.edit_url = reverse('edit')
self.employeeEdit_url = reverse('employeeEdit')
self.update_url = reverse('update')
self.employeeUpdate_url = reverse('employeeUpdate')
def create_emp(self):
return empTable.objects.create(name="test name",
address="test,, address",
phone=123,
email="test@email",
designation="null",
password=123)
def test_register_GET(self):
response = self.client.get(self.register_url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'EmployeeRegistration.html')
def test_register_POST(self):
response = self.client.post(
self.register_url, {
'name': 'test name',
'address': 'test,, address',
'phone': 123,
'email': 'test@email',
'designation': 'null'
})
self.assertEqual(response.status_code, 302)
def test_register_address_validation_POST(self):
response = self.client.post(
self.register_url, {
'name': 'test name',
'address': 'test, address',
'phone': 123,
'email': 'test@email',
'designation': 'null'
})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'EmployeeRegistration.html')
def test_register_name_validation_POST(self):
response = self.client.post(
self.register_url, {
'name': 'test',
'address': 'test,, address',
'phone': 123,
'email': 'test@email',
'designation': 'null'
})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'EmployeeRegistration.html')
def test_details(self):
response = self.client.get(self.details_url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'Details.html')
def test_edit(self):
emp = self.create_emp()
response = self.client.post(self.edit_url, {'id': emp.id})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'Update.html')
def test_employeeEdit(self):
emp = self.create_emp()
response = self.client.post(self.employeeEdit_url, {'id': emp.id})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'EmployeeUpdate.html')
def test_update(self):
emp = self.create_emp()
response = self.client.post(
self.update_url, {
'id': emp.id,
'name': 'test name',
'address': 'test,, address',
'phone': 123,
'email': 'test@email',
'designation': 'null'
})
self.assertEqual(response.status_code, 302)
def test_update_address_validation(self):
emp = self.create_emp()
response = self.client.post(
self.update_url, {
'id': emp.id,
'name': 'test name',
'address': 'test, address',
'phone': 123,
'email': 'test@email',
'designation': 'null'
})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'Update.html')
def test_update_name_validation(self):
emp = self.create_emp()
response = self.client.post(
self.update_url, {
'id': emp.id,
'name': 'test',
'address': 'test,, address',
'phone': 123,
'email': 'test@email',
'designation': 'null'
})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'Update.html')
def test_employeeUpdate(self):
emp = self.create_emp()
response = self.client.post(
self.employeeUpdate_url, {
'id': emp.id,
'name': 'test name',
'address': 'test,, address',
'phone': 123,
'email': 'test@email',
})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'EmployeeProfile.html')
def test_employeeUpdate_address_validation(self):
emp = self.create_emp()
response = self.client.post(
self.employeeUpdate_url, {
'id': emp.id,
'name': 'test name',
'address': 'test, address',
'phone': 123,
'email': 'test@email',
})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'EmployeeUpdate.html')
def test_employeeUpdate_name_validation(self):
emp = self.create_emp()
response = self.client.post(
self.employeeUpdate_url, {
'id': emp.id,
'name': 'test',
'address': 'test,, address',
'phone': 123,
'email': 'test@email',
})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'EmployeeUpdate.html')
class FilterDataUser(TestCase):
"""
This class tests on filter_data API requests made by authenticated users
:return:
"""
def setUp(self):
self.client = Client()
User.objects.create_user(
username="******",
password="******"
)
user = User.objects.get(username="******")
response = self.client.post(
"/api/token/",
{
"username": "******",
"password": "******"
},
content_type="application/json"
)
self.access_token = response.data["access"]
Config.objects.create(
name=f"CoronaCases",
heading="heading",
description="desc",
user=user,
filters=json.dumps(SF[0])
)
config = Config.objects.get(user=user, name="CoronaCases")
file_path = "source.json"
file = open(file_path, 'r')
convert_schema(config, file, DB_FORMAT_TYPES['TYPE_ZERO'])
def test_response(self):
"""
This method tests the output of the API against a dummy response file after populating
the DB with tuples obtained from randomly splitting the "filter" object (function used: utils.dummyDataDefault)
:return:
"""
response = self.client.get(
"/api/visualization/filter_data/",
{
"isDefault": "false",
"model": "CoronaCases",
"filters": PF[0]
},
**{"HTTP_AUTHORIZATION": f"JWT " + self.access_token},
content_type="application/json"
)
self.assertEqual(response.status_code, 200)
to_comp = json.load(open("response.json"))
self.assertCountEqual(response.data[Data], to_comp)
def test_format(self):
"""
This method tests the output of format of the API response.
:return:
"""
response = self.client.get(
"/api/visualization/filter_data/",
{
"isDefault": "false",
"model": "CoronaCases",
"filters": PF[0][:2]
},
**{"HTTP_AUTHORIZATION": f"JWT " + self.access_token},
content_type="application/json"
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data[primaryFilters], PF[0][:2])
self.assertTrue(response.data[Data])
def test_anonymousUserAccess(self):
"""
This method tests whether an anonymous user can access a user's resources
:return:
"""
self.client = Client()
response = self.client.get(
"/api/visualization/filter_data/",
{
"isDefault": "false",
"model": "CoronaCases",
"filters": PF[0][:2]
}
)
self.assertEqual(response.status_code, 400)
class TestTournament(TestCase):
def setUp(self):
self.client = Client()
def test_create_tournament(self):
res = self.client.post(
'/api/tournament/',
{
'name': 'Tournament',
'players': [
{'name': f'Player {n}'}
for n in range(1, 9)
],
'game_size': 4,
'game_cups': 2,
'game_races': 4,
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
assert_valid(res.content, is_decodable_json_where({
'name': 'Tournament',
'token': is_str,
'admin_token': is_str,
'players': is_list_of({
'id': is_int,
'name': is_str,
}),
'games': is_list_of({
'name': is_str,
'round': is_int,
'state': is_in({'waiting', 'active', 'done'}),
'players': is_list_of(is_dict_union(
player={
'player': is_int,
},
slot={
'game': is_str,
'position': is_in({1, 2, 3, 4}),
'player': None,
},
)),
'cups': is_list_of(
is_list_of({
'player': is_int,
'races': is_list_of(is_nullable(is_int)),
'points': is_int,
'rank': is_in({1, 2, 3, 4}),
'fag_points': is_int,
'f*g': is_bool,
}),
),
'total': is_list_of({
'player': is_int,
'points': is_int,
'rank': is_in({1, 2, 3, 4}),
}),
}),
'next_race': is_nullable({
'game': is_str,
'cup': is_int,
'race': is_int,
}),
'ranks': is_list_of({
'rank': is_in({1, 2, 3, 4, 5, 6, 7, 8}),
'game': is_str,
'position': is_in({1, 2, 3, 4}),
'player': None,
}),
}))
def test_perform_tournament(self):
tournament = Tournament.objects.create(
name='Tournament',
game_size=4,
game_cups=2,
game_races=4,
)
for n in range(1, 5):
Player.objects.create(
tournament=tournament,
number=n,
name=f'Player {n}',
)
schedule(tournament, shuffle=False)
url = f'/api/tournament/{tournament.admin_token}/'
def assert_tournament_state(
content, cups, total, next_race, ranks, state='active',
):
assert_valid(content, is_decodable_json_where({
'name': 'Tournament',
'token': is_str,
'admin_token': is_str,
'players': [
{'id': 1, 'name': 'Player 1'},
{'id': 2, 'name': 'Player 2'},
{'id': 3, 'name': 'Player 3'},
{'id': 4, 'name': 'Player 4'},
],
'games': [{
'name': 'A',
'round': 1,
'state': state,
'players': [
{'type': 'player', 'player': 1},
{'type': 'player', 'player': 2},
{'type': 'player', 'player': 3},
{'type': 'player', 'player': 4},
],
'cups': cups,
'total': total,
}],
'next_race': next_race,
'ranks': ranks,
}))
res = self.client.get(url)
self.assertEqual(res.status_code, 200)
assert_tournament_state(
res.content,
cups=[
[
{
'player': 0,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 1,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 2,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
],
[
{
'player': 0,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 1,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 2,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
],
],
total=[
{'player': 0, 'points': 0, 'rank': 1},
{'player': 1, 'points': 0, 'rank': 2},
{'player': 2, 'points': 0, 'rank': 3},
{'player': 3, 'points': 0, 'rank': 4},
],
next_race={'game': 'A', 'cup': 1, 'race': 1},
ranks=[
{'rank': 1, 'game': 'A', 'position': 1, 'player': None},
{'rank': 2, 'game': 'A', 'position': 2, 'player': None},
{'rank': 3, 'game': 'A', 'position': 3, 'player': None},
{'rank': 4, 'game': 'A', 'position': 4, 'player': None},
],
)
res = self.client.post(
url,
data={
'game': 'A',
'cup': 1,
'race': 1,
'positions': [1, 2, 3, 4],
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
assert_tournament_state(
res.content,
cups=[
[
{
'player': 0,
'races': [1, None, None, None],
'points': 15,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 1,
'races': [2, None, None, None],
'points': 12,
'rank': 2,
'fag_points': 0,
'f*g': False,
},
{
'player': 2,
'races': [3, None, None, None],
'points': 10,
'rank': 3,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [4, None, None, None],
'points': 8,
'rank': 4,
'fag_points': 1,
'f*g': True,
},
],
[
{
'player': 0,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 1,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 2,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
],
],
total=[
{'player': 0, 'points': 15, 'rank': 1},
{'player': 1, 'points': 12, 'rank': 2},
{'player': 2, 'points': 10, 'rank': 3},
{'player': 3, 'points': 8, 'rank': 4},
],
next_race={'game': 'A', 'cup': 1, 'race': 2},
ranks=[
{'rank': 1, 'game': 'A', 'position': 1, 'player': None},
{'rank': 2, 'game': 'A', 'position': 2, 'player': None},
{'rank': 3, 'game': 'A', 'position': 3, 'player': None},
{'rank': 4, 'game': 'A', 'position': 4, 'player': None},
],
)
res = self.client.post(
url,
data={
'game': 'A',
'cup': 1,
'race': 2,
'positions': [12, 11, 10, 9],
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
assert_tournament_state(
res.content,
cups=[
[
{
'player': 0,
'races': [1, 12, None, None],
'points': 15,
'rank': 1,
'fag_points': 1,
'f*g': True,
},
{
'player': 1,
'races': [2, 11, None, None],
'points': 13,
'rank': 2,
'fag_points': 0,
'f*g': False,
},
{
'player': 2,
'races': [3, 10, None, None],
'points': 12,
'rank': 3,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [4, 9, None, None],
'points': 11,
'rank': 4,
'fag_points': 1,
'f*g': True,
},
],
[
{
'player': 0,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 1,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 2,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
],
],
total=[
{'player': 0, 'points': 15, 'rank': 1},
{'player': 1, 'points': 13, 'rank': 2},
{'player': 2, 'points': 12, 'rank': 3},
{'player': 3, 'points': 11, 'rank': 4},
],
next_race={'game': 'A', 'cup': 1, 'race': 3},
ranks=[
{'rank': 1, 'game': 'A', 'position': 1, 'player': None},
{'rank': 2, 'game': 'A', 'position': 2, 'player': None},
{'rank': 3, 'game': 'A', 'position': 3, 'player': None},
{'rank': 4, 'game': 'A', 'position': 4, 'player': None},
],
)
res = self.client.post(
url,
data={
'game': 'A',
'cup': 1,
'race': 3,
'positions': [8, 1, 11, 4],
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
assert_tournament_state(
res.content,
cups=[
[
{
'player': 1,
'races': [2, 11, 1, None],
'points': 28,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 0,
'races': [1, 12, 8, None],
'points': 19,
'rank': 2,
'fag_points': 1,
'f*g': True,
},
{
'player': 3,
'races': [4, 9, 4, None],
'points': 19,
'rank': 2,
'fag_points': 1,
'f*g': True,
},
{
'player': 2,
'races': [3, 10, 11, None],
'points': 13,
'rank': 4,
'fag_points': 1,
'f*g': True,
},
],
[
{
'player': 0,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 1,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 2,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
],
],
total=[
{'player': 1, 'points': 28, 'rank': 1},
{'player': 0, 'points': 19, 'rank': 2},
{'player': 3, 'points': 19, 'rank': 3},
{'player': 2, 'points': 13, 'rank': 4},
],
next_race={'game': 'A', 'cup': 1, 'race': 4},
ranks=[
{'rank': 1, 'game': 'A', 'position': 1, 'player': None},
{'rank': 2, 'game': 'A', 'position': 2, 'player': None},
{'rank': 3, 'game': 'A', 'position': 3, 'player': None},
{'rank': 4, 'game': 'A', 'position': 4, 'player': None},
],
)
res = self.client.post(
url,
data={
'game': 'A',
'cup': 1,
'race': 4,
'positions': [2, 5, 10, 3],
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
assert_tournament_state(
res.content,
cups=[
[
{
'player': 1,
'races': [2, 11, 1, 5],
'points': 35,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 0,
'races': [1, 12, 8, 2],
'points': 31,
'rank': 2,
'fag_points': 1,
'f*g': False,
},
{
'player': 3,
'races': [4, 9, 4, 3],
'points': 29,
'rank': 3,
'fag_points': 1,
'f*g': False,
},
{
'player': 2,
'races': [3, 10, 11, 10],
'points': 15,
'rank': 4,
'fag_points': 3,
'f*g': True,
},
],
[
{
'player': 0,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 1,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 2,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [None, None, None, None],
'points': 0,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
],
],
total=[
{'player': 1, 'points': 180 + 35, 'rank': 1},
{'player': 0, 'points': 120 + 31, 'rank': 2},
{'player': 3, 'points': 60 + 29, 'rank': 3},
{'player': 2, 'points': 0 + 15, 'rank': 4},
],
next_race={'game': 'A', 'cup': 2, 'race': 1},
ranks=[
{'rank': 1, 'game': 'A', 'position': 1, 'player': None},
{'rank': 2, 'game': 'A', 'position': 2, 'player': None},
{'rank': 3, 'game': 'A', 'position': 3, 'player': None},
{'rank': 4, 'game': 'A', 'position': 4, 'player': None},
],
)
res = self.client.post(
url,
data={
'game': 'A',
'cup': 2,
'race': 1,
'positions': [1, 5, 2, 3],
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
res = self.client.post(
url,
data={
'game': 'A',
'cup': 2,
'race': 2,
'positions': [5, 4, 1, 2],
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
res = self.client.post(
url,
data={
'game': 'A',
'cup': 2,
'race': 3,
'positions': [2, 1, 4, 5],
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
res = self.client.post(
url,
data={
'game': 'A',
'cup': 2,
'race': 4,
'positions': [2, 6, 3, 4],
},
content_type='application/json',
)
self.assertEqual(res.status_code, 200)
assert_tournament_state(
res.content,
cups=[
[
{
'player': 1,
'races': [2, 11, 1, 5],
'points': 35,
'rank': 1,
'fag_points': 0,
'f*g': False,
},
{
'player': 0,
'races': [1, 12, 8, 2],
'points': 31,
'rank': 2,
'fag_points': 1,
'f*g': False,
},
{
'player': 3,
'races': [4, 9, 4, 3],
'points': 29,
'rank': 3,
'fag_points': 1,
'f*g': False,
},
{
'player': 2,
'races': [3, 10, 11, 10],
'points': 15,
'rank': 4,
'fag_points': 3,
'f*g': True,
},
],
[
{
'player': 0,
'races': [1, 5, 2, 2],
'points': 46,
'rank': 1,
'fag_points': 1,
'f*g': False,
},
{
'player': 2,
'races': [2, 1, 4, 3],
'points': 45,
'rank': 2,
'fag_points': 0,
'f*g': False,
},
{
'player': 3,
'races': [3, 2, 5, 4],
'points': 37,
'rank': 3,
'fag_points': 1,
'f*g': False,
},
{
'player': 1,
'races': [5, 4, 1, 6],
'points': 36,
'rank': 4,
'fag_points': 3,
'f*g': True,
},
],
],
total=[
{'player': 0, 'points': 120 + 31 + 180 + 46, 'rank': 1},
{'player': 1, 'points': 180 + 35 + 0 + 36, 'rank': 2},
{'player': 3, 'points': 60 + 29 + 60 + 37, 'rank': 3},
{'player': 2, 'points': 0 + 15 + 120 + 45, 'rank': 4},
],
next_race=None,
ranks=[
{'rank': 1, 'game': 'A', 'position': 1, 'player': 1},
{'rank': 2, 'game': 'A', 'position': 2, 'player': 2},
{'rank': 3, 'game': 'A', 'position': 3, 'player': 4},
{'rank': 4, 'game': 'A', 'position': 4, 'player': 3},
],
state='done',
)
class TestNotifyUsersAboutChallenge(TestCase):
def setUp(self):
self.client = Client()
self.superuser = User.objects.create_superuser('superuser',
"*****@*****.**",
'secret_password')
self.user = User.objects.create(username='******',
email="*****@*****.**",
password='******')
self.url = reverse_lazy('web:notify_users_about_challenge')
self.email_data = {
'subject': 'Subject of the Email',
'body': 'Body of the Email'
}
def test_if_user_isnt_authenticated(self):
response = self.client.get(self.url)
html = response.content.decode('utf8')
self.assertTrue(html.startswith('<!DOCTYPE html>'))
self.assertTrue(html.endswith(''))
self.assertEqual(response.status_code, 200)
def test_if_user_is_authenticated_but_not_superuser(self):
self.data = {
'username': self.user.username,
'password': self.user.password
}
response = self.client.post(self.url, self.data)
html = response.content.decode('utf8')
self.assertTrue(html.startswith('<!DOCTYPE html>'))
self.assertTrue(html.endswith(''))
self.assertEqual(response.status_code, 200)
def test_if_user_is_authenticated_and_superuser(self):
request = self.client.get('/admin/', follow=True)
response = self.client.login(username='******',
password='******')
self.assertEqual(request.status_code, 200)
self.assertTrue(response)
def test_notification_email_data_page(self):
request = self.client.get('/admin/', follow=True)
response = self.client.login(username='******',
password='******',
follow=True)
request = self.client.get(self.url)
html = request.content.decode('utf8')
self.assertTrue(html.startswith(''))
self.assertTrue(html.endswith(''))
self.assertEqual(request.status_code, 200)
self.assertTrue(response)
def test_notification_email_without_challenge_image(self):
request = self.client.get('/admin/', follow=True)
response = self.client.login(username='******',
password='******',
follow=True)
request = self.client.post(self.url, self.email_data)
html = request.content.decode('utf8')
self.assertTrue(html.startswith(''))
self.assertTrue(html.endswith(''))
self.assertEqual(request.status_code, 200)
self.assertTrue(response)
def test_notification_email_with_challenge_image(self):
request = self.client.get('/admin/', follow=True)
response = self.client.login(username='******',
password='******',
follow=True)
self.email_data['challenge_image'] = SimpleUploadedFile(
name='test_background_image.jpg',
content=open('frontend/src/images/rocket.png', 'rb').read(),
content_type='image/jpg')
request = self.client.post(self.url, self.email_data)
html = request.content.decode('utf8')
self.assertTrue(html.startswith(''))
self.assertTrue(html.endswith(''))
self.assertTrue(response)
self.assertEqual(request.status_code, 200)
def test_notification_with_put_request(self):
request = self.client.get('/admin/', follow=True)
response = self.client.login(username='******',
password='******',
follow=True)
request = self.client.put(self.url, self.email_data)
html = request.content.decode('utf8')
self.assertTrue(html.startswith('<!DOCTYPE html>'))
self.assertTrue(html.endswith(''))
self.assertTrue(response)
self.assertEqual(request.status_code, 200)
class TestProfile(TestCase):
def setUp(self):
self.client = Client()
self.user1 = User.objects.create(username='******',
password='******',
email='*****@*****.**')
self.user2 = User.objects.create(username='******',
email='*****@*****.**')
self.user2.set_password('pass@123')
self.user2.save()
self.user2_profile = Profile.objects.create(
user=self.user2,
department='Computer Engineering',
institute='ace',
title='Doctor',
position='instructor',
phone_number='1122993388',
location='mumbai',
how_did_you_hear_about_us='Google',
state='IN-MH',
is_email_verified=1)
def test_has_profile_for_user_without_profile(self):
"""
If no profile exists for user passed as argument return False
"""
has_profile_status = has_profile(self.user1)
self.assertFalse(has_profile_status)
def test_has_profile_for_user_with_profile(self):
"""
If profile exists for user passed as argument return True
"""
has_profile_status = has_profile(self.user2)
self.assertTrue(has_profile_status)
def test_view_profile_denies_anonymous(self):
"""
If not logged in redirect to login page
"""
response = self.client.get(reverse(view_profile), follow=True)
redirect_destination = '/login/?next=/view_profile/'
self.assertTrue(response.status_code, 200)
self.assertRedirects(response, redirect_destination)
def test_edit_profile_get(self):
"""
GET request to edit profile should display profile form
"""
self.client.login(username=self.user2, password='******')
response = self.client.get(reverse(edit_profile))
user_profile = User.objects.get(id=self.user2.id)
profile = Profile.objects.get(user=user_profile)
self.assertEqual(response.status_code, 200)
self.assertEqual(profile.institute, 'ace')
self.client.logout()
def test_edit_profile_post(self):
self.client.login(username=self.user2, password='******')
response = self.client.post(
'/edit_profile/', {
'first_name': 'demo_test',
'last_name': 'user2',
'institute': 'IIT',
'department': 'aerospace engineering'
})
updated_profile_user = User.objects.get(id=self.user2.id)
updated_profile = Profile.objects.get(user=updated_profile_user)
self.assertEqual(updated_profile.institute, 'IIT')
self.assertEqual(updated_profile.department, 'aerospace engineering')
self.assertEqual(updated_profile.position, 'instructor')
self.assertEqual(response.status_code, 200)
# self.assertTemplateUsed(response, 'workshop_app/profile_updated.html')
def test_register_page(self):
self.client.get('/register/')
self.register_response = self.client.post('/register/',
data={
'username': '******',
'email': '*****@*****.**',
'password': '******',
'confirm password':
'******',
'first name': 'testor',
'last name': 'user',
'phone number':
1234567890,
'institute': 'IIT',
'location': 'mumbai',
'state': (2),
'department': (2)
})
self.assertEqual(self.register_response.status_code, 200)
class TestStringMethods(TestCase):
def setUp(self):
cache.clear()
self.client = Client()
self.client_auth = Client()
self.client_auth_fol = Client()
self.client_not_auth = Client()
self.user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.user_auth = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.user_auth_fol = User.objects.create_user(
username="******",
email="*****@*****.**",
password="******")
self.group = Group.objects.create(
title="terminator",
slug="film",
description="1984, science fiction, action")
self.client.force_login(self.user)
def test_profile(self):
response = self.client.get(
reverse('profile', kwargs={"username": self.user.username}))
self.assertEqual(response.status_code, 200)
def test_create_post(self):
response = self.client.get(
reverse('profile', kwargs={"username": self.user.username}))
self.assertEqual(len(response.context["page"]), 0)
response_create = self.client.post(reverse('new_post'), {
"text": "new post",
"group": self.group.id
},
follow=True)
self.assertRedirects(response_create, reverse('index'))
response_prof = self.client.get(
reverse('profile', kwargs={"username": self.user.username}))
self.assertEqual(len(response_prof.context["page"]), 1)
self.post = Post.objects.get(id=1)
self.assertEqual(self.post.text, "new post")
self.assertEqual(self.post.author, self.user)
self.assertEqual(self.post.group, self.group)
def test_guest(self):
response_new = self.client_not_auth.get(reverse('new_post'),
follow=True)
self.assertRedirects(response_new,
f"{reverse('login')}?next={reverse('new_post')}")
self.assertEqual(Post.objects.count(), 0)
def test_new_post(self):
newpost = Post.objects.create(text="New test post", author=self.user)
self.url_list = (reverse('index'),
reverse('profile',
kwargs={"username": self.user.username}),
reverse('post',
kwargs={
"username": self.user.username,
"post_id": newpost.id,
}))
for url in self.url_list:
with self.subTest(url=url):
response = self.client.get(url)
self.assertContains(response, newpost.text)
def test_change_post(self):
self.post = Post.objects.create(text="Its driving me crazy!",
author=self.user,
group=self.group)
post = Post.objects.get(author=self.user.id)
response = self.client.post(reverse('post_edit',
kwargs={
'username': self.user.username,
'post_id': self.post.id
}), {
'text': 'New post text',
'author': self.user.id
},
follow=False)
post_new = Post.objects.get(author=self.user.id)
self.url_list = (reverse('index'),
reverse('profile',
kwargs={"username": self.user.username}),
reverse('post',
kwargs={
"username": self.user.username,
"post_id": post.id,
}))
for url in self.url_list:
with self.subTest(url=url):
response = self.client.get(url)
self.assertContains(response, post_new.text)
def test_404(self):
response = self.client.get('/auth/test404')
self.assertEqual(response.status_code, 404)
def test_with_picture(self):
small_gif = (
b'\x47\x49\x46\x38\x39\x61\x01\x00\x01\x00\x00\x00\x00\x21\xf9\x04'
b'\x01\x0a\x00\x01\x00\x2c\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02'
b'\x02\x4c\x01\x00\x3b')
img = SimpleUploadedFile(
name='some.gif',
content=small_gif,
content_type='image/gif',
)
post = Post.objects.create(
author=self.user,
text='text',
group=self.group,
image=img,
)
urls = [
reverse('index'),
reverse('profile', kwargs={"username": self.user.username}),
reverse('post',
kwargs={
"username": self.user.username,
"post_id": post.id,
}),
reverse('group_posts', kwargs={'slug': post.group.slug}),
]
for url in urls:
with self.subTest(url=url):
response = self.client.get(url)
self.assertContains(response, '<img')
post.image.delete()
def test_without_picture(self):
not_image = SimpleUploadedFile(
name='some.txt',
content=b'abc',
content_type='text/plain',
)
url = reverse('new_post')
response = self.client.post(url, {
'text': 'some_text',
'image': not_image
})
self.assertFormError(
response,
'form',
'image',
errors=('Загрузите правильное изображение. '
'Файл, который вы загрузили, поврежден '
'или не является изображением.'),
)
def test_cache(self):
self.assertEqual(Post.objects.count(), 0)
response = self.client.get(reverse('index'))
self.post = Post.objects.create(text="Its driving me crazy!",
author=self.user,
group=self.group)
self.assertEqual(Post.objects.count(), 1)
response_new = self.client.get(reverse('index'))
self.assertEqual(response.content, response_new.content)
def test_folowing_auth_user(self):
self.client_auth.force_login(self.user_auth)
self.assertEqual(self.user.following.count(), 0)
response = self.client_auth.post(
reverse('profile_follow', kwargs={'username': self.user.username}))
self.assertEqual(self.user.following.count(), 1)
def test_unfollowing_auth_user(self):
self.client_auth.force_login(self.user_auth)
folowing = Follow.objects.create(user=self.user_auth, author=self.user)
self.assertEqual(self.user.following.count(), 1)
response = self.client_auth.post(
reverse('profile_unfollow',
kwargs={'username': self.user.username}))
self.assertEqual(self.user.following.count(), 0)
def test_new_post_followers(self):
self.client_auth_fol.force_login(self.user_auth_fol)
folowing = Follow.objects.create(user=self.user_auth_fol,
author=self.user)
newpost = Post.objects.create(text="New test post", author=self.user)
response_auth_fol = self.client_auth_fol.get(reverse('follow_index'))
self.assertContains(response_auth_fol, newpost.text)
def test_new_post_notfollowers(self):
self.client_auth.force_login(self.user_auth)
newpost = Post.objects.create(text="New test post", author=self.user)
response_auth = self.client_auth.get(reverse('follow_index'))
self.assertNotContains(response_auth, newpost.text)
def test_auth_user_comment(self):
self.post = Post.objects.create(
text="Test post for comments",
author=self.user,
)
post = Post.objects.get(author=self.user.id)
self.client_auth.force_login(self.user_auth)
self.assertEqual(Comment.objects.count(), 0)
self.client_auth.post(reverse('add_comment',
args=[post.author, post.id]),
{'text': 'new_comment'},
follow=True)
self.assertEqual(Comment.objects.count(), 1)
def test_notauth_user_comment(self):
self.post = Post.objects.create(
text="Test post for comments",
author=self.user,
)
post = Post.objects.get(author=self.user.id)
self.assertEqual(Comment.objects.count(), 0)
self.client_not_auth.post(reverse('add_comment',
args=[post.author, post.id]),
{'text': 'new_comment_not_auth'},
follow=True)
self.assertEqual(Comment.objects.count(), 0)
class UserTests(TestCase):
def set_up(self):
self.client = Client()
def test_user_registration(self):
"""
Tests the registration procedure.
First we test invalid cases (when the passwords don't match), then we check that the User is created and the
username correctly tokenized if the registration is successful.
"""
alphabet = string.ascii_letters + string.digits + '@.+-_'
username = ''.join(choice(alphabet) for _ in range(4))
password1 = 'notagain'
correct_password2 = password1
data = {'username': username,
'password1': password1,
'password2': ''}
endpoint = '/registration/'
for _ in range(10):
data['password2'] = token_bytes(16).decode('iso-8859-1')
invalid_req = self.client.post(endpoint, data, follow=True)
self.assertEqual(len(invalid_req.redirect_chain), 0)
data['password2'] = correct_password2
valid_req = self.client.post(endpoint, data, follow=True)
self.assertEqual(len(valid_req.redirect_chain), 1) # aka the redirect to /login/
self.assertIsNotNone(User.objects.last())
registered_user = User.objects.last()
self.assertIn('-', registered_user.username)
initials = get_user_token_initials(registered_user.username)
self.assertEqual(initials, username)
def test_user_login(self):
"""
Tests user login and correct fernet token usage.
"""
username = '******'
user_token = create_user_token(username)
password = '******'
test_user = User.objects.create_user(username=user_token, password=password)
self.assertEqual(test_user.username, user_token)
self.assertTrue(argon2.verify(password, test_user.password[6:]))
initials = get_user_token_initials(user_token)
self.assertEqual(initials, username)
self.assertIsNone(test_user.last_login)
for _ in range(20):
self.assertFalse(self.client.login(username=user_token, password=token_bytes(16).decode('iso-8859-1')))
self.assertIsNone(test_user.last_login)
self.assertTrue(self.client.login(username=user_token, password=password))
test_user.last_login = datetime.now()
self.assertIsNotNone(test_user.last_login)
user_token_list = []
for _ in range(20):
# we enter the loop already logged-in
if self.client.get('/vault/').status_code != 200:
# we're logged out -> log in with the most recent pass token
self.client.login(username=user_token, password=user_token_list[-1])
test_user.last_login = datetime.now()
pass_token = self.client.get('/token').context['password_token']
self.assertTrue(pass_token)
self.assertIsInstance(pass_token, str)
user_token_list.append(pass_token)
self.client.logout()
self.assertEqual(self.client.get('/vault/').status_code, 302)
self.assertEqual(len(user_token_list), 20)
for pass_tk in user_token_list:
if pass_tk == user_token_list[-1]:
# we should only be able to login with the most recent token
self.assertTrue(self.client.login(username=user_token, password=pass_tk))
else:
self.assertFalse(self.client.login(username=user_token, password=pass_tk))
def test_user_deletion(self):
"""
Tests user deletion (and the deletion of all associated data).
"""
user = User.objects.create_user(username='******', password='******')
self.assertNotEqual(User.objects.last(), None)
for _ in range(4):
Vault.objects.create(owner=user, app='testapp')
self.assertEqual(Vault.objects.filter(owner=user).count(), 4)
self.assertEqual(Nonce.objects.filter(user=user).count(), 1)
user.delete()
self.assertEqual(User.objects.last(), None)
self.assertEqual(Vault.objects.filter(owner=user).exists(), False)
self.assertEqual(Nonce.objects.filter(user=user).first(), None)
class UpdateDisciplineTestCase(TestCase):
"""
Test to update discipline by teacher.
"""
def setUp(self):
"""
This method will run before any test case.
"""
self.client = Client()
self.teacher1 = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.teacher2 = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.student = User.objects.create_user(username='******',
email='*****@*****.**',
password='******',
is_teacher=False)
self.discipline = Discipline.objects.create(
title='Discipline01',
description='Discipline description.',
classroom='Class A',
students_limit=59,
monitors_limit=5,
is_closed=True,
teacher=self.teacher1,
slug='discipline01')
self.url = reverse_lazy('disciplines:update',
kwargs={'slug': self.discipline.slug})
def tearDown(self):
"""
This method will run after any test.
"""
self.teacher1.delete()
self.teacher2.delete()
self.student.delete()
self.discipline.delete()
def test_update_discipline_ok(self):
"""
Update the discipline by teacher successfully.
"""
self.client.login(username=self.teacher1.username, password='******')
data = {
'title': 'Discipline modified',
'description': 'Discipline description.',
'classroom': 'Class A',
'students_limit': 60,
'monitors_limit': 5,
}
response = self.client.post(self.url, data, follow=True)
profile_url = reverse_lazy('accounts:profile')
self.assertRedirects(response, profile_url)
self.discipline.refresh_from_db()
self.assertEqual(self.discipline.title, 'Discipline modified')
check_messages(self,
response,
tag='alert-success',
content='Discipline updated successfully.')
def test_update_discipline_input_error(self):
"""
Test to edit discipline without fields.
"""
self.client.login(username=self.teacher1.username, password='******')
data = {
'title': '',
'description': '',
'classroom': '',
'students_limit': 60,
'monitors_limit': 5,
}
response = self.client.post(self.url, data, follow=True)
self.assertFormError(response, 'form', 'title',
_("This field is required."))
self.assertFormError(response, 'form', 'description',
_("This field is required."))
self.assertFormError(response, 'form', 'classroom',
_("This field is required."))
self.discipline.refresh_from_db()
self.assertEqual(self.discipline.title, 'Discipline01')
self.assertEqual(self.discipline.description,
'Discipline description.')
self.assertEqual(self.discipline.classroom, 'Class A')
def test_student_update_discipline(self):
"""
Test to update discipline by student without success.
"""
self.client.login(username=self.student.username, password='******')
data = {
'title': 'Discipline modified',
'description': 'Discipline description.',
'classroom': 'Class A',
'students_limit': 60,
'monitors_limit': 5,
}
response = self.client.post(self.url, data, follow=True)
profile_url = reverse_lazy('accounts:profile')
self.assertRedirects(response, profile_url)
self.discipline.refresh_from_db()
self.assertEqual(self.discipline.title, 'Discipline01')
check_messages(self,
response,
tag='alert-danger',
content="You are not authorized to do this action.")
def test_another_teacher_update_discipline(self):
"""
Test specific teacher can't update disciplines created by another
teacher.
"""
self.client.login(username=self.teacher2.username, password='******')
data = {
'title': 'Discipline modified',
'description': 'Discipline description.',
'classroom': 'Class A',
'students_limit': 60,
'monitors_limit': 5,
}
response = self.client.post(self.url, data, follow=True)
profile_url = reverse_lazy('accounts:profile')
self.assertRedirects(response, profile_url)
self.discipline.refresh_from_db()
self.assertEqual(self.discipline.title, 'Discipline01')
check_messages(self,
response,
tag='alert-danger',
content="You are not authorized to do this action.")
def test_open_discipline_if_modify_students_limit(self):
"""
If discipline is closed, open it if modify students limit.
"""
self.client.login(username=self.teacher1.username, password='******')
self.assertEqual(self.discipline.is_closed, True)
data = {
'title': 'Discipline modified',
'description': 'Discipline description.',
'classroom': 'Class A',
'students_limit': 60,
'monitors_limit': 5,
}
response = self.client.post(self.url, data, follow=True)
profile_url = reverse_lazy('accounts:profile')
self.assertRedirects(response, profile_url)
self.discipline.refresh_from_db()
self.assertEqual(self.discipline.title, 'Discipline modified')
self.assertEqual(self.discipline.is_closed, False)
check_messages(self,
response,
tag='alert-success',
content='Discipline updated successfully.')
class PropertyTest(TestCase):
def setUp(self):
self.test_user = User.objects.get_or_create(user_name="test",
kakao_id=12345,
is_host=False)[0]
def getToken(test_user):
return jwt.encode({
'id': test_user.id
},
MINIBNB_SECRET_KEY,
algorithm='HS256').decode('UTF-8')
self.encoded = getToken(self.test_user)
self.client = Client()
def test_property_create(self):
multipart_data = {
'property_name': '선릉 근처 근사한 숙소',
'description': '머물기 정말 편한 숙소입니다.',
'address1': '서울시 성북구',
'address2': '',
'postal': '12345',
'max_people': '4',
'price': '50000',
'picture1': open('./property/tests/1234.png', 'rb'),
}
data = MultipartEncoder(multipart_data)
response = self.client.post('/property/create',
data=data.to_string(),
**{
'HTTP_AUTHORIZATION': self.encoded,
'content_type': data.content_type
})
new_property = Property.objects.get(user__id=self.test_user.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(Property.objects.count(), 1)
self.test_user.is_host = True
response = self.client.post('/property/create',
data=data.to_string(),
**{
'HTTP_AUTHORIZATION': self.encoded,
'content_type': data.content_type
})
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {'message': '숙소가 이미 존재합니다.'})
def test_property_delete(self):
multipart_data = {
'property_name': '선릉 근처 근사한 숙소',
'description': '머물기 정말 편한 숙소입니다.',
'address1': '서울시 성북구',
'address2': '',
'postal': '12345',
'max_people': '4',
'price': '50000',
'picture1': open('./property/tests/1234.png', 'rb'),
}
data = MultipartEncoder(multipart_data)
response = self.client.post('/property/create',
data=data.to_string(),
**{
'HTTP_AUTHORIZATION': self.encoded,
'content_type': data.content_type
})
new_property = Property.objects.get(user__id=self.test_user.id)
test_body = {'property_id': new_property.id}
response = self.client.post(
'/property/delete', json.dumps(test_body), **{
'HTTP_AUTHORIZATION': self.encoded,
'content_type': 'application/json'
})
self.assertEqual(response.status_code, 200)
self.assertEqual(Property.objects.count(), 0)
def tearDown(self):
User.objects.get(user_name="test").delete()
class TestCollection(MockIRODSTestCaseMixin, TransactionTestCase):
def setUp(self):
super(TestCollection, self).setUp()
self.api_client = Client()
self.group, _ = Group.objects.get_or_create(name='Hydroshare Author')
self.user1 = create_account(
'*****@*****.**',
username='******',
password='******',
first_name='myfirstname1',
last_name='mylastname1',
superuser=False,
groups=[self.group]
)
self.resCollection = create_resource(
resource_type='CollectionResource',
owner=self.user1,
title='My Collection',
keywords=['kw1', 'kw2'],
metadata=[{"rights": {"statement": "mystatement", "url": "http://www.google.com"}},
{"description": {"abstract": "myabstract"}}
]
)
self.resCollection_with_missing_metadata = create_resource(
resource_type='CollectionResource',
owner=self.user1,
title='My Collection with missing required metadata'
)
self.resGen1 = create_resource(
resource_type='GenericResource',
owner=self.user1,
title='Gen 1'
)
self.resGen2 = create_resource(
resource_type='GenericResource',
owner=self.user1,
title='Gen 2'
)
self.resGen3 = create_resource(
resource_type='GenericResource',
owner=self.user1,
title='Gen 3'
)
self.resGen4 = create_resource(
resource_type='GenericResource',
owner=self.user1,
title='Gen 4'
)
self.resTimeSeries = create_resource(
resource_type='TimeSeriesResource',
owner=self.user1,
title='Test Time Series Resource'
)
self.resNetCDF = create_resource(
resource_type='NetcdfResource',
owner=self.user1,
title='Test NetCDF Resource'
)
self.resGeoFeature = create_resource(
resource_type='GeographicFeatureResource',
owner=self.user1,
title='Test Geographic Feature (shapefiles)'
)
self.resModelInstance = create_resource(
resource_type='ModelInstanceResource',
owner=self.user1,
title='Test Model Instance Resource')
self.user2 = create_account(
'*****@*****.**',
username='******',
password='******',
first_name='myfirstname2',
last_name='mylastname2',
superuser=False,
groups=[self.group]
)
self.resGen5 = create_resource(
resource_type='GenericResource',
owner=self.user2,
title='Gen 4'
)
base_url = "/hsapi/_internal/{0}"
self.url_to_update_collection = base_url + "/update-collection/"
self.url_to_collection_member_permission = base_url + "/collection-member-permission/{1}/"
self.url_to_set_resource_flag = base_url + "/set-resource-flag/"
self.url_to_delete_resource = base_url + "/delete-resource/"
self.url_to_update_collection_for_deleted_resources = \
base_url + "/update-collection-for-deleted-resources/"
self.url_to_calculate_collection_coverages = \
"/hsapi/_internal/calculate-collection-coverages/{0}/"
def test_collection_basic_functions(self):
# test basic collection class with different res types
self.assertEqual(self.resCollection.resources.count(), 0)
# add res to collection.resources
self.resCollection.resources.add(self.resGen1)
self.resCollection.resources.add(self.resGeoFeature)
self.resModelInstance.collections.add(self.resCollection)
self.resTimeSeries.collections.add(self.resCollection)
# test count
self.assertEqual(self.resCollection.resources.count(), 4)
# test res in collection.resources
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGeoFeature, self.resCollection.resources.all())
self.assertIn(self.resModelInstance, self.resCollection.resources.all())
self.assertIn(self.resTimeSeries, self.resCollection.resources.all())
# test collection in res.collections
self.assertIn(self.resCollection, self.resGen1.collections.all())
self.assertIn(self.resCollection, self.resGeoFeature.collections.all())
self.assertIn(self.resCollection, self.resModelInstance.collections.all())
self.assertIn(self.resCollection, self.resTimeSeries.collections.all())
# test remove all res from collection.resources
self.resCollection.resources.clear()
self.assertEqual(self.resCollection.resources.count(), 0)
# test collection NOT in res.collections
self.assertNotIn(self.resCollection, self.resGen1.collections.all())
self.assertNotIn(self.resCollection, self.resGeoFeature.collections.all())
self.assertNotIn(self.resCollection, self.resModelInstance.collections.all())
self.assertNotIn(self.resCollection, self.resTimeSeries.collections.all())
# test adding same resources to multiple collection resources
self.resCollection.resources.add(self.resGen1)
self.resCollection.resources.add(self.resGeoFeature)
self.resCollection_with_missing_metadata.resources.add(self.resGen1)
self.resCollection_with_missing_metadata.resources.add(self.resGeoFeature)
# test resources are in both collection resource
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGeoFeature, self.resCollection.resources.all())
self.assertIn(self.resGen1, self.resCollection_with_missing_metadata.resources.all())
self.assertIn(self.resGeoFeature, self.resCollection_with_missing_metadata.resources.all())
def test_collection_deleted_resource(self):
# test CollectionDeletedResource
self.assertEqual(self.resCollection.deleted_resources.count(), 0)
self.assertEqual(CollectionDeletedResource.objects.count(), 0)
# create 2 CollectionDeletedResource obj and associate with collection
CollectionDeletedResource.objects.create(resource_title=self.resGen1.
metadata.title,
deleted_by=self.user1,
collection=self.resCollection)
CollectionDeletedResource.objects.create(resource_title=self.
resModelInstance.metadata.title,
deleted_by=self.user1,
collection=self.resCollection)
self.assertEqual(CollectionDeletedResource.objects.count(), 2)
self.assertEqual(self.resCollection.deleted_resources.count(), 2)
self.assertEqual(self.resCollection.
deleted_resources.
filter(resource_title=self.
resGen1.metadata.title).count(), 1)
self.assertEqual(self.resCollection.
deleted_resources.
filter(resource_title=self.
resModelInstance.metadata.title).count(), 1)
# remove CollectionDeletedResource objs
self.resCollection.deleted_resources.all().delete()
self.assertEqual(CollectionDeletedResource.objects.count(), 0)
self.assertEqual(self.resCollection.deleted_resources.count(), 0)
def test_update_collection_set_add_remove_logic(self):
# test update_type: set, add, remove
self.assertEqual(self.resCollection.resources.count(), 0)
url_to_update_collection = self.url_to_update_collection.format(self.resCollection.short_id)
# user 1 login
self.api_client.login(username='******', password='******')
# test "update_type=set"
# add 3 private member resources :[resGen1 resGen2 resGen3]
response = self.api_client.post(url_to_update_collection,
{'update_type': 'set',
'resource_id_list':
[self.resGen1.short_id, self.resGen2.short_id,
self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 3)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
# set new list: [resGen1 resGen3 resGen4]
response = self.api_client.post(url_to_update_collection,
{'update_type': 'set',
'resource_id_list':
[self.resGen1.short_id, self.resGen3.short_id,
self.resGen4.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 3)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
self.assertIn(self.resGen4, self.resCollection.resources.all())
# resGen2 should be gone
self.assertNotIn(self.resGen2, self.resCollection.resources.all())
# set empty list []
response = self.api_client.post(url_to_update_collection,
{'update_type': 'set',
'resource_id_list':
[]}, )
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 0)
# test "update_type=add"
# add to list: [resGen1 resGen2 resGen3]
response = self.api_client.post(url_to_update_collection,
{'update_type': 'add',
'resource_id_list':
[self.resGen1.short_id, self.resGen2.short_id,
self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 3)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
# add to list [resGen4]
response = self.api_client.post(url_to_update_collection,
{'update_type': 'add',
'resource_id_list':
[self.resGen4.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 4)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
self.assertIn(self.resGen4, self.resCollection.resources.all())
# add to list: empty []
response = self.api_client.post(url_to_update_collection,
{'update_type': 'add',
'resource_id_list':
[]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 4)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
self.assertIn(self.resGen4, self.resCollection.resources.all())
# add a resource that is already in collection -- error expected
response = self.api_client.post(url_to_update_collection,
{'update_type': 'add',
'resource_id_list':
[self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertEqual(self.resCollection.resources.count(), 4)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
self.assertIn(self.resGen4, self.resCollection.resources.all())
# test "update_type=remove"
# remove from collection: [resGen1 resGen3]
response = self.api_client.post(url_to_update_collection,
{'update_type': 'remove',
'resource_id_list':
[self.resGen1.short_id,
self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 2)
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen4, self.resCollection.resources.all())
# remove from collection: empty []
response = self.api_client.post(url_to_update_collection,
{'update_type': 'remove',
'resource_id_list':
[]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 2)
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen4, self.resCollection.resources.all())
# remove a resource that is not in collection: [resGen1] -- error expected
response = self.api_client.post(url_to_update_collection,
{'update_type': 'remove',
'resource_id_list':
[self.resGen1.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertEqual(self.resCollection.resources.count(), 2)
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen4, self.resCollection.resources.all())
# remove all remain resources: [resGen2, resGen4]
response = self.api_client.post(url_to_update_collection,
{'update_type': 'remove',
'resource_id_list':
[self.resGen2.short_id,
self.resGen4.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 0)
def test_update_collection_own_permission(self):
# test update_collection()
self.assertEqual(self.resCollection.resources.count(), 0)
self.assertFalse(self.resCollection.can_be_public_or_discoverable)
url_to_update_collection = self.url_to_update_collection.format(self.resCollection.short_id)
# anonymous user
# should inform frontend error
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen1.short_id, self.resGen2.short_id,
self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertEqual(resp_json["metadata_status"], "Insufficient to make public")
self.assertFalse(self.resCollection.can_be_public_or_discoverable)
# user 1 login
self.api_client.login(username='******', password='******')
# add 3 private member resources
# should inform frontend "sufficient to make public"
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen1.short_id, self.resGen2.short_id,
self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(resp_json["metadata_status"], "Sufficient to make public")
self.assertTrue(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 3)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
# remove renGen2 (just add 1 and 3)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen1.short_id, self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(resp_json["metadata_status"], "Sufficient to make public")
self.assertTrue(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 2)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertNotIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
# remove all existing contained resources
response = self.api_client.post(url_to_update_collection,
{'resource_id_list': []},
)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(resp_json["metadata_status"], "Insufficient to make public")
self.assertFalse(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 0)
# add resGen1, resGen2, and resGen5 (no permission)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen1.short_id, self.resGen2.short_id,
self.resGen5.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertEqual(self.resCollection.resources.count(), 0)
# add resGen1 and resGen3
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen1.short_id, self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(resp_json["metadata_status"], "Sufficient to make public")
self.assertTrue(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 2)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
# remove resGen1 and resGen3, add resGen2 and resGen5 (no permission)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen2.short_id, self.resGen5.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertEqual(self.resCollection.resources.count(), 2)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen3, self.resCollection.resources.all())
# grants View permission to User 1 over resGen5
self.user2.uaccess.share_resource_with_user(self.resGen5, self.user1, PrivilegeCodes.VIEW)
# remove resGen1 and resGen3, add resGen2 and resGen5 (having permission)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen2.short_id, self.resGen5.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertTrue(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 2)
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertIn(self.resGen5, self.resCollection.resources.all())
# test adding resources to a collection that does not have all the required metadata
self.assertEqual(self.resCollection_with_missing_metadata.resources.count(), 0)
url_to_update_collection = self.url_to_update_collection.format(
self.resCollection_with_missing_metadata.short_id)
self.assertFalse(self.resCollection_with_missing_metadata.can_be_public_or_discoverable)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen1.short_id, self.resGen2.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertFalse(self.resCollection_with_missing_metadata.can_be_public_or_discoverable)
def test_update_collection_edit_permission(self):
self.assertEqual(self.resCollection.resources.count(), 0)
url_to_update_collection = self.url_to_update_collection.format(self.resCollection.short_id)
# User 2 login
self.api_client.login(username='******', password='******')
# User 2: add resGen5 in to collection (User 2 has no permission over this collection)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list': [self.resGen5.short_id]},
)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertFalse(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 0)
# grants View permission to User 2 over collection
self.user1.uaccess.share_resource_with_user(self.resCollection,
self.user2, PrivilegeCodes.VIEW)
# User 2: add resGen5 in to collection
# (User 2 has View permission over this collection that is not enough)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list': [self.resGen5.short_id]},
)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertFalse(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 0)
# grants Change permission to User 2 over collection
self.user1.uaccess.share_resource_with_user(self.resCollection,
self.user2, PrivilegeCodes.CHANGE)
# User 2: add resGen5 in to collection (User 2 has Change permission over this collection)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list': [self.resGen5.short_id]},
)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertTrue(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 1)
self.assertIn(self.resGen5, self.resCollection.resources.all())
# User 2: remove resGen5 and add resGen3 (no permission)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list': [self.resGen3.short_id]},
)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertTrue(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 1)
self.assertIn(self.resGen5, self.resCollection.resources.all())
# grants View permission to User 2 over renGen3
self.user1.uaccess.share_resource_with_user(self.resGen3, self.user2, PrivilegeCodes.VIEW)
# User 2: remove resGen5 and add resGen3 (View permission)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list': [self.resGen3.short_id]},
)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertTrue(self.resCollection.can_be_public_or_discoverable)
self.assertEqual(self.resCollection.resources.count(), 1)
self.assertIn(self.resGen3, self.resCollection.resources.all())
def test_collection_holds_collection(self):
# a collection resource can be added to another collection resource
url_to_update_collection = self.url_to_update_collection.format(self.resCollection.short_id)
# this collection should contain no resources at this point
self.assertEqual(self.resCollection.resources.count(), 0)
# user 1 login
self.api_client.login(username='******', password='******')
# add collection to itself
# json response status should be error
response = self.api_client.post(url_to_update_collection,
{'resource_id_list': [self.resCollection.short_id]},
)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
# collection still should have no resource
self.assertEqual(self.resCollection.resources.count(), 0)
# add one collection resource to another collection resource
# json response status should be success
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resCollection_with_missing_metadata.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
# collection should have 1 resource
self.assertEqual(self.resCollection.resources.count(), 1)
self.assertEqual(self.resCollection.resources.all()[0].resource_type.lower(),
"collectionresource")
def test_update_collection_for_deleted_resources(self):
self.assertEqual(self.resCollection.resources.count(), 0)
self.assertEqual(self.resCollection.deleted_resources.count(), 0)
self.assertFalse(self.resCollection.can_be_public_or_discoverable)
# user 1 login
self.api_client.login(username='******', password='******')
# add 2 resources into collection
url_to_update_collection = self.url_to_update_collection.format(self.resCollection.short_id)
self.api_client.post(url_to_update_collection,
{'resource_id_list': [self.resGen1.short_id, self.resGen2.short_id,
]})
self.assertEqual(self.resCollection.resources.count(), 2)
self.assertIn(self.resGen1, self.resCollection.resources.all())
self.assertIn(self.resGen2, self.resCollection.resources.all())
self.assertTrue(self.resCollection.can_be_public_or_discoverable)
# at this point there should be no tracked deleted resource for the collection
self.assertEqual(self.resCollection.deleted_resources.count(), 0)
# delete resGen1
res_id_resGen1 = self.resGen1.short_id
url_to_delete_resource_for_resGen1 = \
self.url_to_delete_resource.format(self.resGen1.short_id)
self.api_client.post(url_to_delete_resource_for_resGen1, HTTP_REFERER='http://foo/bar')
# delete resGen2
res_id_resGen2 = self.resGen2.short_id
url_to_delete_resource_for_resGen2 = \
self.url_to_delete_resource.format(self.resGen2.short_id)
self.api_client.post(url_to_delete_resource_for_resGen2, HTTP_REFERER='http://foo/bar')
# resGen1 and resGen2 should not be in collection.resources
self.assertEqual(self.resCollection.resources.count(), 0)
self.assertNotIn(self.resGen1, self.resCollection.resources.all())
self.assertNotIn(self.resGen2, self.resCollection.resources.all())
self.assertFalse(self.resCollection.can_be_public_or_discoverable)
# deleted_resources has info about resGen1 and resGen2
self.assertEqual(CollectionDeletedResource.objects.count(), 2)
# there should be now 2 tracked deleted resources for the collection
self.assertEqual(self.resCollection.deleted_resources.count(), 2)
self.assertIn(CollectionDeletedResource.objects.get(resource_id=res_id_resGen1),
self.resCollection.deleted_resources.all())
self.assertIn(CollectionDeletedResource.objects.get(resource_id=res_id_resGen2),
self.resCollection.deleted_resources.all())
# test clear deleted_resources through view
url_to_update_collection_for_deleted_resources = \
self.url_to_update_collection_for_deleted_resources.format(
self.resCollection.short_id)
# log out User 1
self.api_client.logout()
# log in as User 2
self.api_client.login(username='******', password='******')
# User 2 update_collection_for_deleted_resources --> error
response = self.api_client.post(url_to_update_collection_for_deleted_resources)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "error")
self.assertEqual(self.resCollection.deleted_resources.count(), 2)
# logout and login as User 1
self.api_client.logout()
self.api_client.login(username='******', password='******')
# User 1update_collection_for_deleted_resources --> success
response = self.api_client.post(url_to_update_collection_for_deleted_resources)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
# there should be now no tracked deleted resources for the collection
self.assertEqual(self.resCollection.deleted_resources.count(), 0)
self.assertEqual(CollectionDeletedResource.objects.count(), 0)
def test_are_all_contained_resources_published(self):
# no contained resource
self.assertEqual(self.resCollection.resources.count(), 0)
# should return False
self.assertEqual(self.resCollection.are_all_contained_resources_published, False)
self.assertEqual(self.resGen1.raccess.published, False)
self.assertEqual(self.resGeoFeature.raccess.published, False)
# add 2 unpublished resources to collection
self.resCollection.resources.add(self.resGen1)
self.resCollection.resources.add(self.resGeoFeature)
self.assertEqual(self.resCollection.resources.count(), 2)
# not all contained res are published
self.assertEqual(self.resCollection.are_all_contained_resources_published, False)
# manually set the first contained res (self.resGen1) to published
self.resGen1.raccess.published = True
self.resGen1.raccess.save()
self.assertEqual(self.resGen1.raccess.published, True)
self.assertEqual(self.resGeoFeature.raccess.published, False)
# not all contained res are published
self.assertEqual(self.resCollection.are_all_contained_resources_published, False)
# manually set the second contained res (self.resGeoFeature) to published as well
self.resGeoFeature.raccess.published = True
self.resGeoFeature.raccess.save()
self.assertEqual(self.resGen1.raccess.published, True)
self.assertEqual(self.resGeoFeature.raccess.published, True)
# all contained res are published now
self.assertEqual(self.resCollection.are_all_contained_resources_published, True)
def test_versioning(self):
# no contained resource
self.assertEqual(self.resCollection.resources.count(), 0)
# add 3 resources to collection
self.resCollection.resources.add(self.resGen1)
self.resCollection.resources.add(self.resGeoFeature)
self.resCollection.resources.add(self.resCollection_with_missing_metadata)
self.assertEqual(self.resCollection.resources.count(), 3)
# make a new version of collection
new_collection = create_empty_resource(self.resCollection.short_id, self.user1)
new_collection = create_new_version_resource(self.resCollection, new_collection, self.user1)
# test the new version is a collection
self.assertTrue(isinstance(new_collection, CollectionResource))
# new version collection should have same contained res as its original does
self.assertEqual(new_collection.resources.count(), self.resCollection.resources.count())
for contained_res in new_collection.resources.all():
self.assertIn(contained_res, self.resCollection.resources.all())
# changes to old version collection should not affect new version collection
self.resCollection.resources.clear()
self.assertEqual(self.resCollection.resources.count(), 0)
self.assertEqual(new_collection.resources.count(), 3)
def test_copy(self):
# no contained resource
self.assertEqual(self.resCollection.resources.count(), 0)
# add 3 resources to collection
self.resCollection.resources.add(self.resGen1)
self.resCollection.resources.add(self.resGeoFeature)
self.resCollection.resources.add(self.resCollection_with_missing_metadata)
self.assertEqual(self.resCollection.resources.count(), 3)
# make a new copy of collection
new_collection = create_empty_resource(self.resCollection.short_id, self.user1,
action='copy')
new_collection = copy_resource(self.resCollection, new_collection)
# test the new copy is a collection
self.assertTrue(isinstance(new_collection, CollectionResource))
# new copy collection should have same contained res as its original does
self.assertEqual(new_collection.resources.count(), self.resCollection.resources.count())
for contained_res in new_collection.resources.all():
self.assertIn(contained_res, self.resCollection.resources.all())
# changes to old collection should not affect new copied collection
self.resCollection.resources.clear()
self.assertEqual(self.resCollection.resources.count(), 0)
self.assertEqual(new_collection.resources.count(), 3)
def test_update_collection_coverages(self):
# collection has no coverages metadata by default
self.assertEqual(self.resCollection.metadata.coverages.count(), 0)
# add 2 resources without coverage metadata to collection
self.resCollection.resources.add(self.resGen1)
self.resCollection.resources.add(self.resGeoFeature)
self.assertEqual(self.resCollection.resources.count(), 2)
# calculate overall coverages
_update_collection_coverages(self.resCollection)
# no collection coverage
self.assertEqual(self.resCollection.metadata.coverages.count(), 0)
# update resGen1 coverage
metadata_dict = [{'coverage': {'type': 'period', 'value':
{'name': 'Name for period coverage',
'start': '1/1/2016', 'end': '12/31/2016'}}}, ]
update_science_metadata(pk=self.resGen1.short_id, metadata=metadata_dict, user=self.user1)
self.assertEqual(self.resGen1.metadata.coverages.count(), 1)
# calculate overall coverages
_update_collection_coverages(self.resCollection)
# collection should have 1 coverage metadata: period
self.assertEqual(self.resCollection.metadata.coverages.count(), 1)
period_coverage_obj = self.resCollection.metadata.coverages.all()[0]
self.assertEqual(period_coverage_obj.type.lower(), 'period')
self.assertEqual(parser.parse(period_coverage_obj.value['start'].lower()),
parser.parse('1/1/2016'))
self.assertEqual(parser.parse(period_coverage_obj.value['end'].lower()),
parser.parse('12/31/2016'))
# update resGeoFeature coverage
metadata_dict = [{'coverage': {'type': 'point', 'value':
{'name': 'Name for point coverage', 'east': '-20',
'north': '10', 'units': 'decimal deg'}}}, ]
update_science_metadata(pk=self.resGeoFeature.short_id, metadata=metadata_dict,
user=self.user1)
self.assertEqual(self.resGeoFeature.metadata.coverages.count(), 1)
# calculate overall coverages
_update_collection_coverages(self.resCollection)
# collection should have 2 coverage metadata: period and point
self.assertEqual(self.resCollection.metadata.coverages.count(), 2)
# test period
period_qs = self.resCollection.metadata.coverages.all().filter(type='period')
self.assertEqual(period_qs.count(), 1)
self.assertEqual(parser.parse(period_qs[0].value['start'].lower()),
parser.parse('1/1/2016'))
self.assertEqual(parser.parse(period_qs[0].value['end'].lower()),
parser.parse('12/31/2016'))
# test point
point_qs = self.resCollection.metadata.coverages.all().filter(type='point')
self.assertEqual(point_qs.count(), 1)
self.assertEqual(point_qs[0].value['east'], -20)
self.assertEqual(point_qs[0].value['north'], 10)
# add a 3rd res with period and box coverages into collection
metadata_dict = [{'coverage': {'type': 'period', 'value':
{'name': 'Name for period coverage',
'start': '1/1/2010', 'end': '6/1/2016'}}},
{'coverage': {'type': 'point', 'value':
{'name': 'Name for point coverage', 'east': '25',
'north': '-35', 'units': 'decimal deg'}}}]
update_science_metadata(pk=self.resGen2.short_id, metadata=metadata_dict, user=self.user1)
self.assertEqual(self.resGen2.metadata.coverages.count(), 2)
self.resCollection.resources.add(self.resGen2)
self.assertEqual(self.resCollection.resources.count(), 3)
# calculate overall coverages
_update_collection_coverages(self.resCollection)
self.assertEqual(self.resCollection.metadata.coverages.count(), 2)
# test period
period_qs = self.resCollection.metadata.coverages.all().filter(type='period')
self.assertEqual(period_qs.count(), 1)
self.assertEqual(parser.parse(period_qs[0].value['start'].lower()),
parser.parse('1/1/2010'))
self.assertEqual(parser.parse(period_qs[0].value['end'].lower()),
parser.parse('12/31/2016'))
# test point
point_qs = self.resCollection.metadata.coverages.all().filter(type='box')
self.assertEqual(point_qs.count(), 1)
self.assertEqual(point_qs[0].value['westlimit'], -20)
self.assertEqual(point_qs[0].value['northlimit'], 10)
self.assertEqual(point_qs[0].value['eastlimit'], 25)
self.assertEqual(point_qs[0].value['southlimit'], -35)
# test view func calculate_collection_coverages
# user 1 login
self.api_client.login(username='******', password='******')
# add 2 resources into collection
url_to_calculate_collection_coverages = \
self.url_to_calculate_collection_coverages.\
format(self.resCollection.short_id)
response = self.api_client.post(url_to_calculate_collection_coverages)
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(len(resp_json["new_coverage_list"]), 2)
found_period = False
found_box = False
for cv in resp_json["new_coverage_list"]:
if cv["type"] == 'period':
found_period = True
self.assertEqual(parser.parse(cv['value']['start'].lower()),
parser.parse('1/1/2010'))
self.assertEqual(parser.parse(cv['value']['end'].lower()),
parser.parse('12/31/2016'))
self.assertEqual(cv['element_id_str'], '-1')
elif cv["type"] == 'box':
found_box = True
self.assertEqual(cv['value']['westlimit'], -20)
self.assertEqual(cv['value']['northlimit'], 10)
self.assertEqual(cv['value']['eastlimit'], 25)
self.assertEqual(cv['value']['southlimit'], -35)
self.assertEqual(cv['element_id_str'], '-1')
self.assertTrue(found_period)
self.assertTrue(found_box)
# remove all contained res
self.resCollection.resources.clear()
_update_collection_coverages(self.resCollection)
self.assertEqual(self.resCollection.metadata.coverages.count(), 0)
def test_hasPart_metadata(self):
# no contained res
self.assertEqual(self.resCollection.resources.count(), 0)
# no hasPart metadata
self.assertEqual(self.resCollection.metadata.relations.count(), 0)
url_to_update_collection = self.url_to_update_collection.format(self.resCollection.short_id)
# user 1 login
self.api_client.login(username='******', password='******')
# add 3 private member resources
# should inform frontend "sufficient to make public"
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen1.short_id, self.resGen2.short_id,
self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 3)
# should be 3 hasPart metadata
self.assertEqual(self.resCollection.metadata.relations.count(), 3)
# check contained res
hasPart = "hasPart"
# check self.resGen1.short_id
value = RES_LANDING_PAGE_URL_TEMPLATE.format(self.resGen1.short_id)
self.assertEqual(
self.resCollection.metadata.relations.filter(type=hasPart, value=value).count(), 1)
# check self.resGen2.short_id
value = RES_LANDING_PAGE_URL_TEMPLATE.format(self.resGen2.short_id)
self.assertEqual(
self.resCollection.metadata.relations.filter(type=hasPart, value=value).count(), 1)
# check self.resGen3.short_id
value = RES_LANDING_PAGE_URL_TEMPLATE.format(self.resGen3.short_id)
self.assertEqual(
self.resCollection.metadata.relations.filter(type=hasPart, value=value).count(), 1)
# remove renGen2 (keep 1 and 3)
response = self.api_client.post(url_to_update_collection,
{'resource_id_list':
[self.resGen1.short_id, self.resGen3.short_id]}, )
resp_json = json.loads(response.content.decode())
self.assertEqual(resp_json["status"], "success")
self.assertEqual(self.resCollection.resources.count(), 2)
# should be 2 hasPart metadata
self.assertEqual(self.resCollection.metadata.relations.count(), 2)
# check self.resGen1.short_id
value = RES_LANDING_PAGE_URL_TEMPLATE.format(self.resGen1.short_id)
self.assertEqual(
self.resCollection.metadata.relations.filter(type=hasPart, value=value).count(), 1)
# check self.resGen2.short_id -- should be 0
value = RES_LANDING_PAGE_URL_TEMPLATE.format(self.resGen2.short_id)
self.assertEqual(
self.resCollection.metadata.relations.filter(type=hasPart, value=value).count(), 0)
# check self.resGen3.short_id
value = RES_LANDING_PAGE_URL_TEMPLATE.format(self.resGen3.short_id)
self.assertEqual(
self.resCollection.metadata.relations.filter(type=hasPart, value=value).count(), 1)
def test_save_resource_list_csv_to_bag(self):
# test "update_text_file" attribute
# by default it is 'True'
self.assertEqual(self.resCollection.update_text_file, "True")
# set it to 'False'
self.resCollection.extra_data = {'update_text_file': 'False'}
self.resCollection.save()
self.assertEqual(self.resCollection.update_text_file, "False")
# update_text_file is a read-only attribute
with self.assertRaises(AttributeError):
self.resCollection.update_text_file = "Invalid String"
with self.assertRaises(AttributeError):
self.resCollection.update_text_file = 1
# set it back to 'True'
self.resCollection.extra_data = {'update_text_file': 'True'}
self.resCollection.save()
self.assertEqual(self.resCollection.update_text_file, "True")
# test update_collection_list_csv()
self.assertEqual(self.resCollection.resources.count(), 0)
self.resCollection.resources.add(self.resGen1)
self.resCollection.resources.add(self.resGen2)
self.resCollection.resources.add(self.resGen3)
self.assertEqual(self.resCollection.resources.count(), 3)
self.assertEqual(ResourceFile.objects.filter(object_id=self.resCollection.id).count(), 0)
csv_list = update_collection_list_csv(self.resCollection)
self.assertEqual(ResourceFile.objects.filter(object_id=self.resCollection.id).count(), 1)
# csv_list should have 4 rows: header row + 3 data rows
self.assertEqual(len(csv_list), 4)
# add res_id to one list
res_id_list = []
res_id_list.append(csv_list[1][2])
res_id_list.append(csv_list[2][2])
res_id_list.append(csv_list[3][2])
self.assertEqual(len(res_id_list), 3)
self.assertIn(self.resGen1.short_id, res_id_list)
self.assertIn(self.resGen2.short_id, res_id_list)
self.assertIn(self.resGen3.short_id, res_id_list)
class DispatcherTestCase(TestCase):
""" Test the server-side function dispatcher.
In these tests, we base64-encode every message we send to the server
because this is what boto does.
"""
def setUp(self):
global CALL_COUNTER
CALL_COUNTER = 0
self.client = Client()
self.url = reverse('beanstalk_dispatcher')
@override_settings(**DISPATCH_SETTINGS)
def test_no_get(self):
response = self.client.get(self.url)
self.assertEquals(response.status_code, 405)
@override_settings(BEANSTALK_DISPATCH_TABLE=None)
def test_no_dispatch(self):
response = self.client.post(
self.url,
b64encode(create_request_body('some_func').encode('ascii')),
content_type='application/json')
self.assertEquals(response.status_code, 400)
self.assertEquals(json.loads(response.content.decode()), {
'message': 'No beanstalk dispatch table configured',
'error': 400
})
@override_settings(**DISPATCH_SETTINGS)
def test_missing_function(self):
response = self.client.post(
self.url,
b64encode(create_request_body('nonexistent_func').encode('ascii')),
content_type='application/json')
self.assertEquals(response.status_code, 400)
self.assertEquals(
json.loads(response.content.decode()), {
'message': 'Requested function not found: nonexistent_func',
'error': 400
})
@override_settings(**DISPATCH_SETTINGS)
def test_malformed_request(self):
keys = {FUNCTION, ARGS, KWARGS}
for missing_key in keys:
request_body = {key: 'test' for key in keys - {missing_key}}
response = self.client.post(
self.url,
b64encode(json.dumps(request_body).encode('ascii')),
content_type='application/json')
self.assertEquals(response.status_code, 400)
self.assertEquals(
json.loads(response.content.decode()), {
'message':
'Please provide a {} argument'.format(missing_key),
'error': 400
})
@override_settings(**DISPATCH_SETTINGS)
def test_both_args_kwargs(self):
body = b64encode(
create_request_body('the_counter', 1,
second_arg=5).encode('ascii'))
response = self.client.post(self.url,
body,
content_type='application/json')
self.assertEquals(response.status_code, 200)
self.assertEquals(json.loads(response.content.decode()), {})
self.assertEquals(CALL_COUNTER, 6)
@override_settings(**DISPATCH_SETTINGS)
def test_just_args(self):
body = b64encode(create_request_body('the_counter', 2).encode('ascii'))
response = self.client.post(self.url,
body,
content_type='application/json')
self.assertEquals(response.status_code, 200)
self.assertEquals(json.loads(response.content.decode()), {})
self.assertEquals(CALL_COUNTER, 2)
def testOptimization(self):
user = User.objects.filter(username='******')[0]
self.assertEqual(len(Project.objects.filter(user=user)), 1)
project = Project.objects.filter(user=user)[0]
if isdir(join(settings.MEDIA_ROOT, project.folder)):
rmtree(join(settings.MEDIA_ROOT, project.folder))
mkdir(join(settings.MEDIA_ROOT, project.folder))
self.assertEqual(len(SbmlModel.objects.filter(project=project)), 0)
c = Client()
self.assertTrue(c.login(username='******', password='******'))
response_choose_project = c.get('/project/%s/' % project.folder)
self.assertRedirects(response_choose_project, '/models/', status_code=302, target_status_code=200)
self.assertEqual(len(SbmlModel.objects.filter(project=project)), 0)
files_folder = join(dirname(__file__), "files")
model_filename = join(files_folder, "modelx8Ow70.xml")
response_load_model = c.post('/models/', {
'action': 'load_model',
'docfile': open(model_filename, 'rb')
})
self.assertEqual(response_load_model.status_code, 200)
self.assertEqual(len(SbmlModel.objects.filter(project=project)), 1)
response_create_experiment = c.post('/data/', {
'action': 'save',
'experiment_id': "",
'experiment_name': "Enzymatic reaction",
'experiment_notes': "Something"
})
self.assertEqual(response_create_experiment.status_code, 200)
self.assertEqual(
[experiment.name for experiment in response_create_experiment.context['experimental_data']],
[u'Enzymatic reaction']
)
experiment_id = response_create_experiment.context['experimental_data'][0].id
# Testing conditions
response_choose_experiment = c.get('/data/%d/' % experiment_id)
self.assertEqual(response_choose_experiment.status_code, 200)
self.assertEqual(response_choose_experiment.context['experiment_name'], u'Enzymatic reaction')
self.assertEqual(
[condition.name for condition in response_choose_experiment.context['conditions']],
[]
)
response_new_condition = c.post('/data/%d/' % experiment_id, {
'action': 'save',
'condition_id': "",
'condition_name': "Test condition",
'condition_notes': "Some notes"
})
self.assertEqual(response_new_condition.status_code, 200)
self.assertEqual(
[condition.name for condition in response_new_condition.context['conditions']],
[u'Test condition']
)
condition_id = response_new_condition.context['conditions'][0].id
response_choose_experiment = c.get('/data/%d/%d/' % (experiment_id, condition_id))
self.assertEqual(response_choose_experiment.status_code, 200)
self.assertEqual(len(response_choose_experiment.context['experiment_initial_data']), 0)
response_add_treatment = c.post('/data/%d/%d/' % (experiment_id, condition_id), {
'data_type': 'treatment',
'action': 'save',
'id': "",
'name': 'Substrate',
'time': 0,
'value': 15
})
self.assertEqual(response_add_treatment.status_code, 200)
self.assertEqual(len(response_add_treatment.context['experiment_initial_data']), 1)
self.assertEqual(len(response_add_treatment.context['experiment_data']), 0)
response_add_observation = c.post('/data/%d/%d/' % (experiment_id, condition_id), {
'data_type': 'observation',
'action': 'save',
'id': "",
'name': 'Product',
'time': 0,
'value': 0,
'stddev': 0,
'steady_state': 'off',
'min_steady_state': "0",
'max_steady_state': "0"
})
self.assertEqual(response_add_observation.status_code, 200)
self.assertEqual(len(response_add_observation.context['experiment_data']), 1)
response_add_observation = c.post('/data/%d/%d/' % (experiment_id, condition_id), {
'data_type': 'observation',
'action': 'save',
'id': "",
'name': 'Product',
'time': 10,
'value': 10,
'stddev': 0,
'steady_state': 'off',
'min_steady_state': "0",
'max_steady_state': "0"
})
self.assertEqual(response_add_observation.status_code, 200)
self.assertEqual(len(response_add_observation.context['experiment_data']), 2)
response_add_observation = c.post('/data/%d/%d/' % (experiment_id, condition_id), {
'data_type': 'observation',
'action': 'save',
'id': "",
'name': 'Product',
'time': 20,
'value': 15,
'stddev': 0,
'steady_state': 'off',
'min_steady_state': "0",
'max_steady_state': "0"
})
self.assertEqual(response_add_observation.status_code, 200)
self.assertEqual(len(response_add_observation.context['experiment_data']), 3)
response_add_observation = c.post('/data/%d/%d/' % (experiment_id, condition_id), {
'data_type': 'observation',
'action': 'save',
'id': "",
'name': 'Product',
'time': 50,
'value': 15,
'stddev': 0,
'steady_state': 'off',
'min_steady_state': "0",
'max_steady_state': "0"
})
self.assertEqual(response_add_observation.status_code, 200)
self.assertEqual(len(response_add_observation.context['experiment_data']), 4)
response_get_fit_data = c.get('/fit/data/')
self.assertEqual(response_get_fit_data.status_code, 200)
self.assertEqual(
[dataset for dataset in response_get_fit_data.context['experimental_data_sets']],
[u'Enzymatic reaction']
)
response_list_optimizations = c.get('/fit/list/')
self.assertEqual(response_list_optimizations.status_code, 200)
self.assertEqual(len(response_list_optimizations.context['optimizations']), 0)
response_add_dataset = c.post('/json/add_dataset/', {
'dataset_ind': 0
})
self.assertEqual(response_add_dataset.status_code, 200)
mapping = loads(response_add_dataset.content.decode('utf-8'))['model_xpaths']
sbml_filename = str(SbmlModel.objects.filter(project=project)[0].sbml_file)
doc = SbmlDocument()
doc.readSbmlFromFile(join(settings.MEDIA_ROOT, sbml_filename))
self.assertEqual(sorted(list(mapping.keys())), ['Product', 'Substrate'])
self.assertEqual(doc.model.listOfSpecies.index(doc.getByXPath(mapping['Substrate'])), 0)
self.assertEqual(doc.model.listOfSpecies.index(doc.getByXPath(mapping['Product'])), 3)
response_create_optimization = c.post('/fit/data/', {
'action': 'create',
'dataset_0': experiment_id,
'list_dataset_0_data_species_0_value': "Product",
'list_dataset_0_species_0_value': 3,
'list_dataset_0_data_species_1_value': "Substrate",
'list_dataset_0_species_1_value': 0,
'parameter_0_active': "on",
'parameter_0_id': 0,
'parameter_0_name': "Binding rate",
'parameter_0_value': 1.0,
'parameter_0_min': 1e-4,
'parameter_0_max': 1e+4,
'parameter_0_precision': 7,
'parameter_1_active': "on",
'parameter_1_id': 0,
'parameter_1_name': "Unbinding rate",
'parameter_1_value': 1.0,
'parameter_1_min': 1e-4,
'parameter_1_max': 1e+4,
'parameter_1_precision': 7,
'parameter_2_active': "on",
'parameter_2_id': 0,
'parameter_2_name': "Catalytic rate",
'parameter_2_value': 1.0,
'parameter_2_min': 1e-4,
'parameter_2_max': 1e+4,
'parameter_2_precision': 7,
'nb_cores': 2,
'lambda': 0.001,
'score_precision': 0.001,
'param_precision': 7,
'initial_temperature': 1,
'initial_moves': 2000,
'freeze_count': 100,
'negative_penalty': 0
})
self.assertEqual(response_create_optimization.status_code, 200)
self.assertEqual(response_create_optimization.context['form'].getErrors(), [])
sleep(5)
response_list_optimizations = c.get('/fit/list/')
self.assertEqual(response_list_optimizations.status_code, 200)
self.assertEqual(len(response_list_optimizations.context['optimizations']), 1)
self.assertEqual(response_list_optimizations.context['optimizations'][0][0].status, "Running")
sleep(10)
response_get_optimization = c.get('/fit/%s/' % response_list_optimizations.context['optimizations'][0][0].optimization_id)
self.assertEqual(response_get_optimization.status_code, 200)
sleep(240)
response_list_optimizations = c.get('/fit/list/')
self.assertEqual(response_list_optimizations.status_code, 200)
self.assertEqual(response_list_optimizations.context['optimizations'][0][0].status, "Finished")
response_get_optimization = c.get(
'/fit/%s/' % response_list_optimizations.context['optimizations'][0][0].optimization_id)
self.assertEqual(response_get_optimization.status_code, 200)
scores = response_get_optimization.context['score_values']
self.assertTrue(scores[len(scores)-1] < 0.24)
class Test_Api_Custom(TestCase):
def setUp(self):
# Every test needs a client.
self.client = Client()
# needed to setup django
django.setup()
def createContact(self, fuelSupplierId):
testContactUrl = "/api/fuelsuppliercontacts"
# Create:
payload = fakedata.FuelSupplierContactTestDataCreate()
payload['fuelSupplierFK'] = fuelSupplierId
jsonString = json.dumps(payload)
response = self.client.post(testContactUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
contactId = data['id']
return contactId
def createFuelSupplierStatus(self):
testUrl = "/api/fuelsupplierstatuses"
payload = fakedata.FuelSupplierStatusTestDataCreate()
payload['effectiveDate'] = '2017-01-01'
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId
def createFuelSupplierActionType(self):
testUrl = "/api/fuelsupplieractionstypes"
payload = fakedata.FuelSupplierActionsTypeTestDataCreate()
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId
def createFuelSupplier(self):
statusId = self.createFuelSupplierStatus()
actionsTypeId = self.createFuelSupplierActionType()
testUrl = "/api/fuelsuppliers"
# Create:
payload = {
'name': "Initial",
'status': "Initial",
'createdDate': '2000-01-01',
# 'primaryContact': contactId ,
# 'contacts': [contactId],
'notes': [],
'attachments': [],
'history': [],
'fuelSupplierStatusFK': statusId,
'fuelSupplierActionsTypeFK': actionsTypeId,
}
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId, statusId, actionsTypeId
def createRole(self):
testUrl = "/api/roles"
# Create:
fakeRole = fakedata.RoleTestDataCreate()
payload = {
'name': fakeRole['name'],
'description': fakeRole['description']
}
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId
def createPermission(self):
testUrl = "/api/permissions"
# Create:
fakePermission = fakedata.PermissionTestDataCreate()
payload = {
'code': fakePermission['code'],
'name': fakePermission['name'],
'description': fakePermission['description']
}
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId
def createUser(self, fuelsupplierId):
testUserUrl = "/api/users"
# Create:
fakeUser = fakedata.UserTestDataCreate()
payload = {
'givenName': fakeUser['givenName'],
'surname': fakeUser['surname'],
'email': fakeUser['email'],
'status': 'Active',
'userFK': fakeUser['userId'],
'guid': fakeUser['guid'],
'authorizationDirectory': fakeUser['authorizationDirectory'],
'fuelSupplier': fuelsupplierId
}
jsonString = json.dumps(payload)
response = self.client.post(testUserUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
userId = data['id']
return userId
def createCreditTradeType(self):
testUrl = "/api/credittradetypes"
payload = fakedata.CreditTradeTypeTestDataCreate()
payload['expirationDate'] = '2017-01-02'
payload['effectiveDate'] = '2017-01-01'
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId
def createCreditTradeStatus(self):
testUrl = "/api/credittradestatuses"
payload = fakedata.CreditTradeStatusTestDataCreate()
payload['effectiveDate'] = '2017-01-01'
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId
def createCreditTrade(self, fuelSupplierId, userId):
typeId = self.createCreditTradeType()
statusId = self.createCreditTradeStatus()
testUrl = "/api/credittrades"
payload = {
'status': 'Active',
'initiator': fuelSupplierId,
'respondent': fuelSupplierId,
'initiatorLastUpdateBy': userId,
'respondentLastUpdatedBy': None,
'reviewedRejectedBy': None,
'approvedRejectedBy': None,
'cancelledBy': None,
'tradeExecutionDate': '2017-01-01',
# TODO: replace transactionType
'transactionType': 'Type',
'fairMarketValuePrice': '100.00',
'fuelSupplierBalanceBeforeTransaction': '2017-01-01',
'notes': [],
'attachments': [],
'history': [],
'creditTradeTypeFK': typeId,
'creditTradeStatusFK': statusId,
'respondentFK': fuelSupplierId,
}
fakeCreditTrade = fakedata.CreditTradeTestDataCreate()
payload.update(fakeCreditTrade)
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId, typeId, statusId
def createNotificationEvent(self):
testUrl = "/api/notificationevents"
payload = {
'eventTime': '2017-01-01',
}
event = fakedata.NotificationEventTestDataCreate()
payload.update(event)
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_201_CREATED == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
return createdId
def createAndVerifyNotification(self):
testUrl = "/api/notifications"
fuelSupplierId, statusId, actionId = self.createFuelSupplier()
userId = self.createUser(fuelSupplierId)
notificationEventId = self.createNotificationEvent()
payload = fakedata.NotificationTestDataCreate()
payload['userFK'] = userId
payload['notificationEventFK'] = notificationEventId
request = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=request)
assert status.HTTP_201_CREATED == response.status_code
return json.loads(response.content.decode("utf-8"))
def createUserFavourite(self, userId):
url = "/api/users/" + str(userId) + "/favourites"
payload = fakedata.UserFavouriteTestDataCreate()
request = json.dumps(payload)
response = self.client.post(url,
content_type='application/json',
data=request)
assert status.HTTP_200_OK == response.status_code
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
return data['id']
def deleteContact(self, contactId):
# cleanup the contact
deleteUrl = "/api/fuelsuppliercontacts/" + str(contactId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK.
assert status.HTTP_204_NO_CONTENT == response.status_code
def deleteRole(self, roleId):
deleteUrl = "/api/roles/" + str(roleId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK.
assert status.HTTP_204_NO_CONTENT == response.status_code
def deleteNotificationEvent(self, notificationEventId):
deleteUrl = "/api/notificationevents/" + str(
notificationEventId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK.
assert status.HTTP_204_NO_CONTENT == response.status_code
def deleteUser(self, userId):
deleteUrl = "/api/users/" + str(userId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK
assert status.HTTP_204_NO_CONTENT == response.status_code
def deleteFuelSupplier(self, fuelsupplierId):
deleteUrl = "/api/fuelsuppliers/" + str(fuelsupplierId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK.
assert status.HTTP_204_NO_CONTENT == response.status_code
def deleteCreditTrade(self, creditTradeId):
deleteUrl = "/api/credittrades/" + str(creditTradeId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK.
assert status.HTTP_204_NO_CONTENT == response.status_code
def deletePermission(self, permissionId):
deleteUrl = "/api/permissions/" + str(permissionId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK.
assert status.HTTP_204_NO_CONTENT == response.status_code
def test_credittradesSearchGet(self):
fsId, _, _ = self.createFuelSupplier()
contactId = self.createContact(fsId)
userId = self.createUser(fsId)
credId, credTypeId, _ = self.createCreditTrade(fsId, userId)
testUrl = "/api/credittrades/search"
response = self.client.get(testUrl)
assert status.HTTP_200_OK == response.status_code
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
assert len(data) == 1
self.deleteCreditTrade(credId)
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fsId)
def test_usersCurrentFavouritesIdDeletePost(self):
fsId, _, _ = self.createFuelSupplier()
contactId = self.createContact(fsId)
userId = self.createUser(fsId)
userFavId = self.createUserFavourite(userId)
url = "/api/users/current/favourites/" + str(userFavId) + "/delete"
response = self.client.post(url)
assert status.HTTP_200_OK == response.status_code
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fsId)
def test_usersCurrentFavouritesPut(self):
fsId, _, _ = self.createFuelSupplier()
contactId = self.createContact(fsId)
userId = self.createUser(fsId)
url = "/api/users/current/favourites"
payload = fakedata.UserFavouriteTestDataCreate()
request = json.dumps(payload)
response = self.client.post(url,
content_type='application/json',
data=request)
assert status.HTTP_200_OK == response.status_code
payload = [fakedata.UserFavouriteTestDataUpdate()]
request = json.dumps(payload)
response = self.client.put(url,
content_type='application/json',
data=request)
assert status.HTTP_200_OK == response.status_code
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
assert data[0]["value"] == "Changed"
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fsId)
def test_usersCurrentFavouritesSearchGet(self):
fsId, _, _ = self.createFuelSupplier()
contactId = self.createContact(fsId)
userId = self.createUser(fsId)
userFavId = self.createUserFavourite(userId)
url = "/api/users/current/favourites/search"
response = self.client.get(url)
assert status.HTTP_200_OK == response.status_code
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
assert len(data) == 1
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fsId)
def test_usersCurrentGet(self):
fuelSupplierId, statusId, actionId = self.createFuelSupplier()
contactId = self.createContact(fuelSupplierId)
userId = self.createUser(fuelSupplierId)
testUrl = "/api/users/current"
# List:
response = self.client.get(testUrl)
assert status.HTTP_200_OK == response.status_code
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fuelSupplierId)
def test_fuelsuppliersIdAttachmentsGet(self):
fuelSupplierId, statusId, actionId = self.createFuelSupplier()
contactId = self.createContact(fuelSupplierId)
uploadUrl = "/api/fuelsuppliers/"
uploadUrl += str(fuelSupplierId) + "/attachments"
payload = fakedata.FuelSupplierAttachmentTestDataCreate()
payload['fuelSupplierFK'] = fuelSupplierId
rawData = "TEST"
jsonString = json.dumps(payload)
fileData = SimpleUploadedFile("file.txt", rawData.encode('utf-8'))
form = {
"file": fileData,
"item": jsonString,
}
response = self.client.post(uploadUrl, data=form)
# Check that the response is OK.
assert status.HTTP_200_OK == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
testUrl = "/api/fuelsupplierattachments"
# download the attachment.
downloadUrl = testUrl + "/" + str(createdId)
response = self.client.get(downloadUrl)
# Check that the response is 200 OK.
result = response.content.decode("utf-8")
assert status.HTTP_200_OK == response.status_code
parsed = response.content.decode("utf-8")
# response should match the contents sent.
# TODO: check that raw data matched returned parsed data
# assert rawData==parsed
# Cleanup:
deleteUrl = "/api/fuelsupplierattachments/" + str(
createdId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK.
assert status.HTTP_204_NO_CONTENT == response.status_code
# Cleanup
self.deleteContact(contactId)
self.deleteFuelSupplier(fuelSupplierId)
def test_fuelsuppliersIdHistoryGet(self):
fuelSupplierId, statusId, actionId = self.createFuelSupplier()
contactId = self.createContact(fuelSupplierId)
testUrl = "/api/fuelsuppliers/" + str(fuelSupplierId) + "/history"
payload = fakedata.FuelSupplierHistoryTestDataCreate()
payload['fuelSupplierFK'] = fuelSupplierId
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_200_OK == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
createdId = data['id']
# Cleanup the History
deleteUrl = "/api/fuelsupplierhistories/" + str(createdId) + "/delete"
response = self.client.post(deleteUrl)
# Check that the response is OK.
assert status.HTTP_204_NO_CONTENT == response.status_code
# Cleanup
self.deleteContact(contactId)
self.deleteFuelSupplier(fuelSupplierId)
def test_fuelsuppliersSearchGet(self):
fuelSupplierId, statusId, actionId = self.createFuelSupplier()
contactId = self.createContact(fuelSupplierId)
# do a search
testUrl = "/api/fuelsuppliers/search"
response = self.client.get(testUrl)
# Check that the response is OK.
assert status.HTTP_200_OK == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
# Cleanup
self.deleteContact(contactId)
self.deleteFuelSupplier(fuelSupplierId)
def test_rolesIdPermissionsGet(self):
# create a group.
roleId = self.createRole()
# create a permission.
permissionId = self.createPermission()
rolePermissionUrl = "/api/roles/" + str(roleId) + "/permissions"
# create a new group membership.
payload = {'roleFK': roleId, 'permissionFK': permissionId}
jsonString = json.dumps(payload)
response = self.client.post(rolePermissionUrl,
content_type='application/json',
data=jsonString)
assert status.HTTP_200_OK == response.status_code
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
rolePermissionId = data['id']
# test the get
response = self.client.get(rolePermissionUrl)
assert status.HTTP_200_OK == response.status_code
# test the put. This will also delete the RolePermission.
payload = []
jsonString = json.dumps(payload)
response = self.client.put(rolePermissionUrl,
content_type='application/json',
data=jsonString)
assert status.HTTP_200_OK == response.status_code
# cleanup
self.deleteRole(roleId)
self.deletePermission(permissionId)
def test_rolesIdUsersGet(self):
roleId = self.createRole()
fuelSupplierId, statusId, actionId = self.createFuelSupplier()
contactId = self.createContact(fuelSupplierId)
userId = self.createUser(fuelSupplierId)
userRoleUrl = "/api/users/" + str(userId) + "/roles"
# create a new UserRole.
payload = {
'effectiveDate': '2000-01-01',
'expiryDate': None,
'user': userId,
'role': roleId
}
jsonString = json.dumps(payload)
response = self.client.post(userRoleUrl,
content_type='application/json',
data=jsonString)
assert status.HTTP_200_OK == response.status_code
# test the get
response = self.client.get(userRoleUrl)
assert status.HTTP_200_OK == response.status_code
testUrl = "/api/roles/" + str(roleId)
# get the users in the group.
response = self.client.get(testUrl)
# Check that the response is OK.
assert status.HTTP_200_OK == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
# test the PUT - this will clear the user role map.
payload = []
jsonString = json.dumps(payload)
response = self.client.put(userRoleUrl,
content_type='application/json',
data=jsonString)
assert status.HTTP_200_OK == response.status_code
# cleanup
self.deleteRole(roleId)
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fuelSupplierId)
def test_usersIdFavouritesGet(self):
fsId, _, _ = self.createFuelSupplier()
contactId = self.createContact(fsId)
userId = self.createUser(fsId)
url = "/api/users/" + str(userId) + "/favourites"
payload = fakedata.UserFavouriteTestDataCreate()
jsonString = json.dumps(payload)
response = self.client.post(url,
content_type='application/json',
data=jsonString)
assert status.HTTP_200_OK == response.status_code
payload = [fakedata.UserFavouriteTestDataUpdate()]
jsonString = json.dumps(payload)
response = self.client.put(url,
content_type='application/json',
data=jsonString)
assert status.HTTP_200_OK == response.status_code
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
assert data[0]["value"] == "Changed"
response = self.client.get(url)
assert status.HTTP_200_OK == response.status_code
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
assert len(data) > 0
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fsId)
def test_usersIdNotificationsGet(self):
fsId, fsTypeId, _ = self.createFuelSupplier()
contactId = self.createContact(fsId)
userId = self.createUser(fsId)
credId, credTypeId, _ = self.createCreditTrade(fsId, userId)
notificationEventId = self.createNotificationEvent()
# add notification to user.
userNotificationUrl = "/api/users/" + str(userId) + "/notifications"
# create a new UserRole.
payload = {
'notificationEventFK': notificationEventId,
'hasBeenViewed': False,
'isWatchNotification': False,
'userFK': userId
}
jsonString = json.dumps(payload)
response = self.client.post(userNotificationUrl,
content_type='application/json',
data=jsonString)
assert status.HTTP_200_OK == response.status_code
# test the Get
response = self.client.get(userNotificationUrl)
assert status.HTTP_200_OK == response.status_code
# cleanup
self.deleteNotificationEvent(notificationEventId)
self.deleteCreditTrade(credId)
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fsId)
def test_usersIdPermissionsGet(self):
# create a user.
fuelSupplierId, statusId, actionId = self.createFuelSupplier()
contactId = self.createContact(fuelSupplierId)
userId = self.createUser(fuelSupplierId)
# create a credit trade
notificationEventId = self.createUser(fuelSupplierId)
# assign permissions to the user.
#TODO add that.
userPermissionUrl = "/api/users/" + str(userId) + "/permissions"
# test the Get
response = self.client.get(userPermissionUrl)
assert status.HTTP_200_OK == response.status_code
# cleanup
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fuelSupplierId)
def test_usersIdRolesGet(self):
fsId, _, _ = self.createFuelSupplier()
contactId = self.createContact(fsId)
userId = self.createUser(fsId)
roleId = self.createRole()
url = "/api/users/" + str(userId) + "/roles"
payload = fakedata.UserRoleTestDataCreate()
payload['user'] = userId
payload['role'] = roleId
jsonString = json.dumps(payload)
response = self.client.post(url,
content_type='application/json',
data=jsonString)
assert response.status_code == status.HTTP_200_OK
response = self.client.get(url)
assert response.status_code == status.HTTP_200_OK
payload = [fakedata.UserRoleTestDataUpdate()]
payload[0]['user'] = userId
payload[0]['role'] = roleId
jsonString = json.dumps(payload)
response = self.client.put(url,
content_type='application/json',
data=jsonString)
assert response.status_code == status.HTTP_200_OK
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
assert data[0]['userFK'] == userId
assert data[0]['roleFK'] == roleId
self.deleteRole(roleId)
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fsId)
def test_usersSearchGet(self):
fuelSupplierId, statusId, actionId = self.createFuelSupplier()
contactId = self.createContact(fuelSupplierId)
userId = self.createUser(fuelSupplierId)
# do a search
testUrl = "/api/users/search"
response = self.client.get(testUrl)
# Check that the response is OK.
assert status.HTTP_200_OK == response.status_code
# parse the response.
jsonString = response.content.decode("utf-8")
data = json.loads(jsonString)
# Cleanup
self.deleteUser(userId)
self.deleteContact(contactId)
self.deleteFuelSupplier(fuelSupplierId)
def test_createCreditTradeNegativeNumberOfCredits(self):
fsId, _, _ = self.createFuelSupplier()
userId = self.createUser(fsId)
typeId = self.createCreditTradeType()
statusId = self.createCreditTradeStatus()
testUrl = "/api/credittrades"
payload = {
'creditTradeStatusFK': statusId,
'creditTradeTypeFK': typeId,
'fairMarketValuePrice': '100.00',
'historySet': [],
'initiator': fsId,
'respondentFK': fsId,
'tradeEffectiveDate': '2017-01-01',
}
fakeCreditTrade = fakedata.CreditTradeTestDataCreate()
payload.update(fakeCreditTrade)
payload['numberOfCredits'] = -1
jsonString = json.dumps(payload)
response = self.client.post(testUrl,
content_type='application/json',
data=jsonString)
# Check that the response is OK.
assert status.HTTP_422_UNPROCESSABLE_ENTITY == response.status_code
self.deleteUser(userId)
self.deleteFuelSupplier(fsId)
class BasicViewTests(TestCase):
"""Test view routing."""
def setup(self):
"""Create client."""
self.client = Client()
# def test_home_route(self):
# """Route to home."""
# response = self.client.get('/')
# self.assertEqual(response.status_code, 200)
# def test_home_route2(self):
# """Display home."""
# response = self.client.get('/')
# self.assertIn('Exquisite', response.content.decode('utf-8'))
def test_login_route(self):
"""Route to login."""
response = self.client.get('/accounts/login/')
self.assertEqual(response.status_code, 200)
def test_login_route2(self):
"""Display login."""
response = self.client.get('/accounts/login/')
self.assertIn('Username', response.content.decode('utf-8'))
def test_register_route(self):
"""Route to register."""
response = self.client.get('/accounts/register/')
self.assertEqual(response.status_code, 200)
def test_register_route2(self):
"""Display register."""
response = self.client.get('/accounts/register/')
self.assertIn('Email', response.content.decode('utf-8'))
def test_logout_route(self):
"""Route to logout."""
response = self.client.get('/accounts/logout/')
self.assertEqual(response.status_code, 200)
def test_logout_route2(self):
"""Display logout."""
response = self.client.get('/accounts/logout/')
self.assertIn('logged out', response.content.decode('utf-8'))
def test_activate_route(self):
"""Route to activate."""
response = self.client.get('/accounts/activate/complete/')
self.assertEqual(response.status_code, 200)
def test_activate_route2(self):
"""Display activate."""
response = self.client.get('/accounts/activate/complete/')
self.assertIn('Activation complete', response.content.decode('utf-8'))
def test_registered_route(self):
"""Route to registered."""
response = self.client.get('/accounts/register/complete/')
self.assertEqual(response.status_code, 200)
def test_registered_route2(self):
"""Display registered."""
response = self.client.get('/accounts/register/complete/')
self.assertIn(
'Registration complete', response.content.decode('utf-8'))
# def test_get_home_page(self):
# """Test get homepage."""
# response = self.client.get(reverse_lazy('home'))
# self.assertEqual(response.status_code, 200)
# self.assertEqual(response.templates[0].name, 'generic/home.html')
# self.assertEqual(response.templates[1].name, 'generic/base.html')
def test_get_registration_page(self):
"""Test registration page."""
response = self.client.get(reverse_lazy('registration_register'))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.templates[0].name, 'registration/registration_form.html')
self.assertEqual(response.templates[1].name, 'generic/base.html')
def test_register_user(self):
"""Test for user registration."""
response = self.client.post(
reverse_lazy('registration_register'),
{
'username': '******',
'password1': 'pass1234',
'password2': 'pass1234',
'email': '*****@*****.**'
}, follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.templates[0].name, 'registration/registration_complete.html')
self.assertEqual(response.templates[1].name, 'generic/base.html')
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertEqual(email.to, ['*****@*****.**'])
register_url = email.body.splitlines()[-1]
register_url = urlparse(register_url)
response = self.client.get(register_url.path)
self.assertEqual(response.status_code, 302)
self.assertTrue(self.client.login(username='******', password='******'))
class ProductViewsTestCase(TestCase):
"""Views tests class."""
def setUp(self):
"""Set up function."""
self.client = Client()
self.product_url = "/products/research_product"
self.list_url = "/products/results_list"
self.info_url = "/products/informations"
self.substitute_url = "/products/save_substitute/"
User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
Product.objects.create(name="oreo")
Product.objects.create(name="oreo2")
def test_research_product_found(self):
"""Test research_product."""
self.client.login(email="*****@*****.**", password='******')
product = "oreo"
response = self.client.get(f"{self.product_url}/{product}/")
self.assertTemplateUsed(response, "results.html")
self.assertEqual(response.context["other_results"], 1)
self.assertTrue(response.context.get("product"))
def test_research_product_not_found(self):
"""Test research_product."""
self.client.login(email="*****@*****.**", password='******')
product = "potiron"
response = self.client.get(f"{self.product_url}/{product}/")
self.assertTemplateUsed(response, "no_products_found.html")
def test_results_list_results(self):
"""Test results_list."""
self.client.login(email="*****@*****.**", password='******')
product = "oreo"
response = self.client.get(f"{self.list_url}/{product}/")
self.assertTrue(len(response.context["products"].object_list) == 2)
def test_results_list_no_results(self):
"""Test results_list."""
self.client.login(email="*****@*****.**", password='******')
product = "xzxzxz"
response = self.client.get(f"{self.list_url}/{product}/")
self.assertTrue(len(response.context["products"].object_list) == 0)
def test_informations_not_found(self):
"""Test informations."""
self.client.login(email="*****@*****.**", password='******')
product = "xzxzxz"
response = self.client.get(f"{self.info_url}/{product}/")
self.assertTemplateUsed(response, "product_not_found.html")
def test_informations_found(self):
"""Test informations."""
self.client.login(email="*****@*****.**", password='******')
product = "oreo"
response = self.client.get(f"{self.info_url}/{product}/")
self.assertTemplateUsed(response, "informations.html")
self.assertTrue(response.context.get("product"))
self.assertTrue(response.context.get("nutriscore_img"))
def test_save_substitute_no_double(self):
"""Test informations."""
user = User.objects.get(email="*****@*****.**")
self.client.login(email="*****@*****.**", password='******')
base_product = Product.objects.get(name="oreo")
product = Product.objects.get(name="oreo2")
Substitute.objects.create(user=user,
base_product=base_product,
substituted=product)
response = self.client.post(
f"{self.substitute_url}", {
"base_product": base_product,
"product": product,
"next": self.substitute_url
})
self.assertEqual(len(Substitute.objects.all()), 1)
def test_save_substitute_OK(self):
"""Test informations."""
user = User.objects.get(email="*****@*****.**")
self.client.login(email="*****@*****.**", password='******')
base_product = Product.objects.get(name="oreo")
product = Product.objects.get(name="oreo2")
response = self.client.post(
f"{self.substitute_url}", {
"base_product": base_product,
"product": product,
"next": self.substitute_url
})
self.assertEqual(len(Substitute.objects.all()), 1)
class TestStringMethods(TestCase):
# fixtures = ['testdata.json', 'auth.user']
def setUp(self):
"""Создание пользователя, авторизация и добавление поста с проверкой на главной странице"""
self.client = Client()
response = self.client.post(reverse("signup"), USER_BY, follow=True)
self.assertRedirects(response,
reverse("login"),
status_code=302,
target_status_code=200)
print("Новый пользователь создан")
response = self.client.post("/auth/login/", {
'username': USER_BY['username'],
'password': USER_BY['password']
})
print("Пользователь авторизован")
self.client.post(reverse("new_post"), {'text': TEST_POST})
cache.clear()
response = self.client.get(reverse("index"))
self.assertContains(response,
TEST_POST,
count=1,
status_code=200,
msg_prefix='Поста на INDEX странице нет')
print("Создан пост на главной странице")
def test_add_img(self):
"""Создание поста с картинкой"""
with open("test_files/image.png", "rb") as fp:
response = self.client.post(reverse("new_post"), {
'text': TEST_POST_D,
'image': fp
})
self.assertRedirects(response,
reverse("index"),
status_code=302,
target_status_code=200,
msg_prefix='',
fetch_redirect_response=True)
print("Пользователь создал пост С КАРТИНКОЙ")
def test_add_new_user(self):
"""Создание второго пользователя, авторизация, подписка на первого и добавление коментария"""
response = self.client.post(reverse("signup"), USER_DY, follow=True)
self.assertRedirects(response,
"/auth/login/",
status_code=302,
target_status_code=200)
print("Второй пользователь создан")
self.client.post("/auth/login/", {
'username': '******',
'password': '******'
})
print("Второй пользователь авторизован")
response = self.client.post(reverse(
"profile_follow", kwargs={'username': USER_BY['username']}),
follow=True)
print("Подписка на АВТОРА")
self.assertRedirects(response,
reverse("follow_index"),
status_code=302,
target_status_code=200)
response = self.client.get(reverse("follow_index"))
self.assertContains(response,
TEST_POST,
count=1,
status_code=200,
msg_prefix='Поста на follow_index странице нет')
print("Пост на follow_index странице USERA")
self.client.post(
reverse("add_comment",
kwargs={
'username': USER_BY['username'],
'post_id': 1
}), {'text': COMMENT})
response = self.client.get("/testuser/1/", follow=True)
self.assertContains(response,
COMMENT,
count=1,
status_code=200,
msg_prefix='Комментария на post странице нет')
print("Коментарий на странице POST USERA")
def test_no_picture_ban(self):
"""Добавление не картинки, к посту"""
with open("test_files/test_file.txt", "rb") as fp:
response = self.client.post(reverse("new_post"), {
'text': TEST_POST,
'image': fp
})
response = self.client.get(reverse("index"))
self.assertContains(
response,
'<img',
count=0,
status_code=200,
msg_prefix='Файл не картинка, ИСКЛЮЧЕНИЯ НЕ ВЫЗВАЛ')
print("Файл не картинка, НЕ ДОБАВИЛСЯ")
def test_not_found(self):
"""Отсутствие страницы, код 404"""
response = self.client.get("/not_fount/")
self.assertEqual(response.status_code, 404)
def test_send_mail(self):
"""Отправка письма пользователю"""
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, 'Тема письма')
print("Письмо отправлено")
def test_view_new_post_page(self):
"""Доступ к странице добавления поста, для зарегистрированого пользователя"""
response = self.client.get(reverse("new_post"))
self.assertEqual(response.status_code, 200)
print("Доступ к странице добавления поста, есть!")
def test_view_index_page(self):
"""Проверка наличие поста на главной странице"""
response = self.client.get(reverse("index"))
self.assertContains(response,
TEST_POST,
count=1,
status_code=200,
msg_prefix='Поста на главной странице нет')
print("Пост на главной странице")
def test_view_profile_page(self):
"""Наличие поста на странице профиля пользователя"""
response = self.client.get(
reverse("profile", kwargs={'username': USER_BY['username']}))
self.assertContains(response,
TEST_POST,
count=1,
status_code=200,
msg_prefix='Поста profile на странице нет')
print("Пост на profile странице")
def test_view_edit_page(self):
"""Редактирование поста"""
self.client.post(
reverse("post_edit",
kwargs={
'username': USER_BY['username'],
'post_id': 1
}), {'text': 'My best Editen text!'})
print("Страница поста редактирования")
response = self.client.get(
reverse("post",
kwargs={
'username': USER_BY['username'],
'post_id': 1
}))
self.assertContains(response,
'My best Editen text!',
count=1,
status_code=200,
msg_prefix='Поста на главной странице нет',
html=False)
print("Отредактированый пост на главной странице")
def test_not_add_comment(self):
"""Не авторизованый пользователь не может добавить коментарий"""
self.client.get(reverse("logout"))
self.client.post(
reverse("add_comment",
kwargs={
'username': USER_BY['username'],
'post_id': 1
}), {'text': COMMENT})
response = self.client.get(
reverse("post",
kwargs={
'username': USER_BY['username'],
'post_id': 1
}))
self.assertContains(response,
COMMENT,
count=0,
status_code=200,
msg_prefix='Комментарий на post странице')
print("Коментарий нет POST USERA")
def test_cache_view(self):
"""Проверка срабатывания кеширования"""
self.client.post(
reverse("post_edit",
kwargs={
'username': USER_BY['username'],
'post_id': 1
}), {'text': 'My best Editen text!'})
response = self.client.get(reverse("index"))
self.assertContains(response, 'My best Editen text!', count=0)
print(
"Отредактированый пост на главной странице не отображается, кешируется старый"
)
cache.clear()
response = self.client.get(reverse("index"))
self.assertContains(response, 'My best Editen text!', count=1)
print("Отредактированый пост на post странице минуя кеш")
def test_cache_index_page(self):
"""Проверка срабатывания кеширования второй вариант"""
cache.set('index_page', COMMENT)
cache.set('index_page_2', 'Two comment')
response = cache.get('index_page_2')
self.assertNotEqual(response, COMMENT)
# cache.clear()
response = cache.get('index_page')
self.assertEqual(response, COMMENT)
class CommentsViewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(email='*****@*****.**',
password='******',
name='test')
self.user1 = User.objects.create_user(name='test1',
email='*****@*****.**',
password='******')
self.post = Post.objects.create(user=self.user, body='test_post')
self.comment = Comment.objects.create(post=self.post,
user=self.user,
body='test_comment')
self.client.force_login(self.user)
def test_reply_form_with_parent(self):
data = {
'body': 'test comment with parent',
'parent_id': self.comment.pk
}
response = self.client.post(reverse('reply_form',
kwargs={
'pk': self.post.pk,
'parent_id': self.comment.pk
}),
data=data,
follow=True)
self.assertTrue(
isinstance(
Comment.objects.filter(
body='test comment with parent').first(), Comment))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'post_detail.html')
def test_reply_form_with_no_parent(self):
data = {'body': 'test comment with parent'}
self.client.post(reverse('reply_form',
kwargs={
'pk': self.post.pk,
'parent_id': self.comment.pk
}),
data=data,
follow=True)
self.assertTrue(
isinstance(
Comment.objects.filter(
body='test comment with parent').first(), Comment))
def test_reply_form_with_parent_fail_no_post(self):
data = {
'body': 'test comment with parent',
'parent_id': self.comment.pk
}
response = self.client.post(reverse('reply_form',
kwargs={
'pk': '10',
'parent_id': self.comment.pk
}),
data=data,
follow=True)
self.assertIn(force_bytes('Action not allowed'), response.content)
def test_reply_form_not_user(self):
self.client.logout()
response = self.client.get(reverse('post_detail',
kwargs={'pk': self.post.pk}),
follow=True)
self.assertRedirects(response, '/login/')
def test_delete_comment(self):
self.client.get(reverse('delete_comment',
kwargs={'pk': self.comment.pk}),
follow=True)
self.assertEqual(len(Comment.objects.filter(body='test_comment')), 0)
def test_delete_comment_not_commenter(self):
comment = Comment.objects.create(user=self.user1, body='test_comment1')
response = self.client.get(reverse('delete_comment',
kwargs={'pk': comment.pk}),
follow=True)
self.assertIn(force_bytes('You can only delete your own comments'),
response.content)
def test_delete_comment_fail(self):
response = self.client.get(reverse('delete_comment',
kwargs={'pk': '10'}),
follow=True)
self.assertIn(force_bytes('Action not allowed'), response.content)
def test_edit_comment(self):
data = {'body': 'test comment changed'}
self.client.post(reverse('edit_comment',
kwargs={'pk': self.comment.pk}),
data=data,
follow=True)
g_response = self.client.get(reverse('edit_comment',
kwargs={'pk': self.comment.pk}),
follow=True)
self.assertIsNotNone(
Comment.objects.filter(body='test comment changed'))
self.assertTemplateUsed(g_response, 'edit_comment.html')
def test_edit_comment_fail(self):
data = {'body': 'test comment changed'}
response = self.client.post(reverse('edit_comment',
kwargs={'pk': '10'}),
data=data,
follow=True)
self.assertIn(force_bytes('Action not allowed'), response.content)
def test_like_comment(self):
self.client.get(reverse('like_comment', kwargs={'pk':
self.comment.pk}))
self.assertIn(self.user, self.comment.likers.all())
self.client.get(reverse('like_comment', kwargs={'pk':
self.comment.pk}))
self.assertNotIn(self.user, self.comment.likers.all())
self.assertNotIn(self.user, self.comment.dislikers.all())
self.client.get(reverse('like_comment', kwargs={'pk':
self.comment.pk}))
self.assertIn(self.user, self.comment.likers.all())
self.assertNotIn(self.user, self.comment.dislikers.all())
self.comment.dislikers.add(self.user)
self.comment.likers.remove(self.user)
self.client.get(reverse('like_comment', kwargs={'pk':
self.comment.pk}))
self.assertIn(self.user, self.comment.likers.all())
self.assertNotIn(self.user, self.comment.dislikers.all())
def test_like_comment_fail(self):
response = self.client.get(reverse('like_comment', kwargs={'pk':
'10'}))
self.assertIn(force_bytes('Action not allowed'), response.content)
def test_dislike_comment(self):
self.client.get(
reverse('dislike_comment', kwargs={'pk': self.comment.pk}))
self.assertIn(self.user, self.comment.dislikers.all())
self.client.get(
reverse('dislike_comment', kwargs={'pk': self.comment.pk}))
self.assertNotIn(self.user, self.comment.dislikers.all())
self.assertNotIn(self.user, self.comment.likers.all())
self.client.get(
reverse('dislike_comment', kwargs={'pk': self.comment.pk}))
self.assertIn(self.user, self.comment.dislikers.all())
self.assertNotIn(self.user, self.comment.likers.all())
self.comment.likers.add(self.user)
self.comment.dislikers.remove(self.user)
self.client.get(
reverse('dislike_comment', kwargs={'pk': self.comment.pk}))
self.assertIn(self.user, self.comment.dislikers.all())
self.assertNotIn(self.user, self.comment.likers.all())
def test_dislike_comment_fail(self):
response = self.client.get(
reverse('dislike_comment', kwargs={'pk': '10'}))
self.assertIn(force_bytes('Action not allowed'), response.content)
class LabViewsTestCase(TestCase):
def setUp(self):
self.client = Client()
self.lab = G(Lab, name="ECCL", institution="MIT", approved_to_test=False)
self.lab2 = G(Lab, name="Second lab")
self.researcher = G(
User, is_active=True, is_researcher=True, given_name="Alice"
)
self.researcher_outside_lab = G(
User, is_active=True, is_researcher=True, given_name="Bobbington"
)
self.researcher_in_lab = G(
User, is_active=True, is_researcher=True, given_name="Candice"
)
self.lab.researchers.add(self.researcher)
self.lab.researchers.add(self.researcher_in_lab)
self.lab.member_group.user_set.add(self.researcher_in_lab)
self.lab.save()
self.study_type = G(StudyType, name="default", id=1)
self.study = G(
Study, creator=self.researcher, study_type=self.study_type, lab=self.lab
)
self.study.researcher_group.user_set.add(self.researcher_in_lab)
self.superuser = G(User, is_active=True, is_researcher=True, is_superuser=True)
self.participant = G(User, is_active=True)
self.create_lab_url = reverse("exp:lab-create")
self.lab_detail_url = reverse("exp:lab-detail", kwargs={"pk": self.lab.pk})
self.lab_members_url = reverse("exp:lab-members", kwargs={"pk": self.lab.pk})
self.lab_list_url = reverse("exp:lab-list")
self.lab2_request_url = reverse("exp:lab-request", kwargs={"pk": self.lab2.pk})
self.lab_update_url = reverse("exp:lab-edit", kwargs={"pk": self.lab.pk})
# Create lab view: can get as researcher
def testCanGetCreateLabViewAsResearcher(self):
self.client.force_login(self.researcher)
page = self.client.get(self.create_lab_url)
self.assertEqual(
page.status_code, 200, "Unable to get create lab view as researcher"
)
self.assertTemplateUsed(
page,
"studies/lab_create.html",
"Incorrect template used for displaying create lab form",
)
# Create lab view: can create new lab as researcher
def testCanCreateNewLabAsResearcher(self):
self.client.force_login(self.researcher)
post_data = {
"name": "New lab",
"principal_investigator_name": "Jane Smith",
"institution": "MIT",
"contact_email": "*****@*****.**",
"contact_phone": "(123) 456-7890",
"lab_website": "https://mit.edu",
"description": "ABCDEFG",
"irb_contact_info": "how to reach the IRB",
}
page = self.client.post(self.create_lab_url, post_data)
self.assertEqual(page.status_code, 302, "Unable to create lab as researcher")
# Create lab view: cannot get as participant
def testCanGetCreateLabViewAsParticipant(self):
self.client.force_login(self.participant)
page = self.client.get(self.create_lab_url)
self.assertEqual(
page.status_code, 403, "Participant is able to create a new lab!"
)
# Lab detail view: can see as researcher
def testCanGetLabDetailViewAsResearcher(self):
self.client.force_login(self.researcher)
page = self.client.get(self.lab_detail_url)
self.assertEqual(
page.status_code, 200, "Unable to get lab detail view as researcher"
)
self.assertTemplateUsed(
page,
"studies/lab_detail.html",
"Incorrect template used for displaying lab detail page",
)
# Lab detail view: cannot see as participant
def testCanGetLabDetailViewAsParticipant(self):
self.client.force_login(self.participant)
page = self.client.get(self.lab_detail_url)
self.assertEqual(
page.status_code, 403, "Participant is able to view exp lab detail page!"
)
# Lab members view: cannot see as researcher not in lab
def testCannotGetLabMembersViewAsUnaffiliatedResearcher(self):
self.client.force_login(self.researcher_outside_lab)
page = self.client.get(self.lab_members_url)
self.assertEqual(
page.status_code, 403, "Unaffiliated researcher is able to view lab members"
)
# Lab members view: can see as researcher in lab.
def testCanGetLabMembersViewAsLabResearcher(self):
self.client.force_login(self.researcher)
page = self.client.get(self.lab_members_url)
self.assertEqual(
page.status_code, 200, "Unable to get lab members view as lab researcher"
)
self.assertTemplateUsed(
page,
"studies/lab_member_list.html",
"Incorrect template used for displaying lab member page",
)
# note - can use page.context_data too!
self.assertIn("Alice", page.rendered_content)
self.assertIn("Candice", page.rendered_content)
self.assertNotIn("Bobbington", page.rendered_content)
# Lab members view: cannot post as researcher in lab w/o manage perms
def testPostLabMembersViewIncorrectPerms(self):
self.client.force_login(self.researcher)
post_data = {
"user_action": "make_member",
"user_id": self.researcher_outside_lab.pk,
}
page = self.client.post(self.lab_members_url, post_data)
self.assertEqual(
page.status_code,
403,
"Researcher able to add new lab member without permissions",
)
# Lab members view: can add new researcher w/ appropriate perms
def testAddNewLabMemberWithCorrectPerms(self):
self.client.force_login(self.researcher)
assign_perm(
LabPermission.MANAGE_LAB_RESEARCHERS.codename, self.researcher, self.lab
)
post_data = {
"user_action": "make_guest",
"user_id": self.researcher_outside_lab.pk,
}
page = self.client.post(self.lab_members_url, post_data)
self.assertEqual(
page.status_code,
302,
"Researcher unable to add new lab member despite correct permissions",
)
self.assertRedirects(page, self.lab_members_url)
self.assertIn(
self.lab,
self.researcher_outside_lab.labs.all(),
"Researcher not successfully added to lab",
)
self.assertIn(self.researcher_outside_lab, self.lab.guest_group.user_set.all())
# Lab members view: can remove researcher w/ appropriate perms
def testRemoveLabMemberWithCorrectPerms(self):
self.client.force_login(self.researcher)
assign_perm(
LabPermission.MANAGE_LAB_RESEARCHERS.codename, self.researcher, self.lab
)
post_data = {
"user_action": "remove_researcher",
"user_id": self.researcher_in_lab.pk,
}
page = self.client.post(self.lab_members_url, post_data)
self.assertEqual(
page.status_code,
302,
"Researcher unable to remove lab member despite correct permissions",
)
self.assertRedirects(page, self.lab_members_url)
self.assertNotIn(self.lab, self.researcher_in_lab.labs.all())
self.assertNotIn(
self.researcher_in_lab,
self.lab.member_group.user_set.all(),
"Researcher removed from lab but not from associated member group",
)
self.assertNotIn(
self.researcher_in_lab,
self.study.researcher_group.user_set.all(),
"Researcher removed from lab but not from associated study group",
)
# Lab list view: can see as researcher
def testCanGetLabListViewAsResearcher(self):
self.client.force_login(self.researcher)
page = self.client.get(self.lab_list_url)
self.assertEqual(
page.status_code, 200, "Unable to get lab list view as researcher"
)
self.assertTemplateUsed(
page,
"studies/lab_list.html",
"Incorrect template used for displaying lab list page",
)
# Lab list view: cannot see as participant
def testCanGetLabListViewAsParticipant(self):
self.client.force_login(self.participant)
page = self.client.get(self.lab_list_url)
self.assertEqual(
page.status_code, 403, "Participant is able to view exp lab list page!"
)
# Lab update view: cannot get as researcher w/o edit perms
def testGetLabUpdateViewIncorrectPerms(self):
assign_perm(
LabPermission.MANAGE_LAB_RESEARCHERS.codename, self.researcher, self.lab
)
self.client.force_login(self.researcher)
page = self.client.get(self.lab_update_url)
self.assertEqual(
page.status_code,
403,
"Researcher able to access lab update view without permissions",
)
# Lab update view: can get as researcher w/ edit perms
def testGetLabUpdateViewCorrectPerms(self):
assign_perm(LabPermission.EDIT_LAB_METADATA.codename, self.researcher, self.lab)
self.client.force_login(self.researcher)
page = self.client.get(self.lab_update_url)
self.assertEqual(
page.status_code,
200,
"Researcher not able to access lab update view despite permissions",
)
# Lab update view: cannot post as researcher w/o edit perms
def testPostLabUpdateViewIncorrectPerms(self):
assign_perm(
LabPermission.MANAGE_LAB_RESEARCHERS.codename, self.researcher, self.lab
)
self.client.force_login(self.researcher)
post_data = {
"name": "New lab",
"principal_investigator_name": "Jane Smith",
"institution": "New institution",
"contact_email": "*****@*****.**",
"contact_phone": "(123) 456-7890",
"lab_website": "https://mit.edu",
"description": "ABCDEFG",
"irb_contact_info": "how to reach the IRB",
}
page = self.client.post(self.lab_update_url, post_data)
self.assertEqual(
page.status_code,
403,
"Researcher able to edit lab metadata without permissions",
)
updated_lab = Lab.objects.get(pk=self.lab.pk)
self.assertEqual(updated_lab.institution, "MIT")
# Lab update view: can post as researcher w/ edit perms
def testPostLabUpdateViewCorrectPerms(self):
assign_perm(LabPermission.EDIT_LAB_METADATA.codename, self.researcher, self.lab)
self.client.force_login(self.researcher)
post_data = {
"name": "New lab",
"principal_investigator_name": "Jane Smith",
"institution": "New institution",
"contact_email": "*****@*****.**",
"contact_phone": "(123) 456-7890",
"lab_website": "https://mit.edu",
"description": "ABCDEFG",
"irb_contact_info": "how to reach the IRB",
}
page = self.client.post(self.lab_update_url, post_data)
self.assertEqual(
page.status_code,
302,
"Researcher unable to edit lab metadata despite permissions",
)
updated_lab = Lab.objects.get(pk=self.lab.pk)
self.assertEqual(updated_lab.institution, "New institution")
# Lab update view: cannot update approved_to_test
def testPostLabUpdateViewEditApproval(self):
assign_perm(LabPermission.EDIT_LAB_METADATA.codename, self.researcher, self.lab)
self.client.force_login(self.researcher)
post_data = {
"name": "New lab",
"principal_investigator_name": "Jane Smith",
"institution": "New institution",
"contact_email": "*****@*****.**",
"contact_phone": "(123) 456-7890",
"lab_website": "https://mit.edu",
"description": "ABCDEFG",
"irb_contact_info": "how to reach the IRB",
"approved_to_test": True,
}
page = self.client.post(self.lab_update_url, post_data)
updated_lab = Lab.objects.get(pk=self.lab.pk)
self.assertFalse(
updated_lab.approved_to_test,
"Researcher approved lab to test without permission",
)
# Lab update view: can update approved_to_test as admin
def testPostLabUpdateViewEditApprovalAsAdmin(self):
assign_perm(LabPermission.EDIT_LAB_APPROVAL.prefixed_codename, self.researcher)
assign_perm(LabPermission.EDIT_LAB_METADATA.prefixed_codename, self.researcher)
self.client.force_login(self.researcher)
post_data = {
"name": "New lab",
"principal_investigator_name": "Jane Smith",
"institution": "New institution",
"contact_email": "*****@*****.**",
"contact_phone": "(123) 456-7890",
"lab_website": "https://mit.edu",
"description": "ABCDEFG",
"irb_contact_info": "how to reach the IRB",
"approved_to_test": True,
}
page = self.client.post(self.lab_update_url, post_data)
updated_lab = Lab.objects.get(pk=self.lab.pk)
self.assertEqual(page.status_code, 302)
self.assertTrue(
updated_lab.approved_to_test,
"Researcher could not approve lab to test despite permission",
)
# Lab membership request: can make as researcher
def testRequestLabMembershipAsResearcher(self):
self.client.force_login(self.researcher)
page = self.client.post(self.lab2_request_url, {})
self.assertEqual(
page.status_code, 302, "Unable to request lab membership as researcher"
)
self.assertIn(self.researcher, self.lab2.requested_researchers.all())
self.assertNotIn(self.researcher, self.lab2.researchers.all())
# Lab membership request: cannot make as participant
def testRequestLabMembershipAsParticipant(self):
self.client.force_login(self.participant)
page = self.client.post(self.lab2_request_url, {})
self.assertEqual(
page.status_code, 403, "Participant is able to request lab membership!"
)
