class BaseFuncTestCase(TestCase):
"""
Utitlity methods to pull stuff out of session etc.
"""
def setUp(self):
""" Turn of HOSTS check and setup reusable attributes """
self.settings = getattr(settings, "COOKIELESS", DEFAULT_SETTINGS)
self.settings["HOSTS"] = []
self.browser = Client()
self.browser.request()
self.engine = import_module(settings.SESSION_ENGINE)
self.crypt_sesh = CryptSession()
self.factory = RequestFactory()
self.skey = settings.SESSION_COOKIE_NAME
# This is a bit crap - because matching is fragile and also its
# reused to split up and grab the session id - TODO: replace with regex
self.hidden = '<input type="hidden" name="%s" value="' % self.skey
def get_session(self, response, url="/", agent="unknown browser"):
""" Extract id from response and retrieve session """
# post or get
parts = ""
if not response.content:
print("RESPONSE FAILED: {}".format(response.__class__))
else:
content = response.content.decode()
if self.hidden in content:
splitter = self.hidden
else:
splitter = "%s=" % self.skey
parts = content.split(splitter, 1)
session_key = ""
if len(parts) > 1:
parts = parts[1].split('"', 1)
session_id = parts[0]
request = self.factory.get(url,
REMOTE_ADDR="127.0.0.1",
HTTP_USER_AGENT=agent)
try:
session_key = self.crypt_sesh.decrypt(request, session_id)
except:
# Silently start new session in case fake session_id format causes error
pass
else:
session_id = ""
try:
session = self.engine.SessionStore(session_key)
except:
session = self.engine.SessionStore()
return session, session_id
class CryptTestCase(unittest.TestCase):
"""
Check the session id encryption is working OK
"""
# urls = 'django-cookieless.test_urls'
def setUp(self):
""" Get a session and a crypt_session """
self.settings = getattr(settings, "COOKIELESS", DEFAULT_SETTINGS)
self.engine = import_module(settings.SESSION_ENGINE)
self.crypt_sesh = CryptSession()
self.factory = RequestFactory()
def crypt_ok(self, request=None):
""" Check encryption works with various settings """
if not request:
request = self.factory.get("/")
session = self.engine.SessionStore()
session.create()
self.assertNotEqual(session.session_key, None)
sessionid = self.crypt_sesh.encrypt(request, session.session_key)
session_key = self.crypt_sesh.decrypt(request, sessionid)
return session.session_key, session_key
def test_default(self):
self.settings["CLIENT_ID"] = False
self.settings["HOSTS"] = []
keys = self.crypt_ok()
self.assertEqual(*keys)
def test_client_id(self):
self.settings["CLIENT_ID"] = False
self.settings["HOSTS"] = []
keys = self.crypt_ok()
self.assertEqual(*keys)
def test_hosts_check(self):
self.settings["CLIENT_ID"] = False
request = self.factory.get("/")
request.META["HTTP_REFERER"] = "http://localhost:12345/foobar"
settings.COOKIELESS_HOSTS = ["localhost"]
keys = self.crypt_ok(request)
self.assertEqual(*keys)
def test_test_client(self):
"""Cookieless can cause fail of test browser so check it"""
self.browser = Client()
self.browser.request()
self.assertTrue(self.browser)
class BaseFuncTestCase(TestCase):
"""
Utitlity methods to pull stuff out of session etc.
"""
def setUp(self):
""" Turn of HOSTS check and setup reusable attributes """
self.settings = getattr(settings, 'COOKIELESS', DEFAULT_SETTINGS)
self.settings['HOSTS'] = []
self.browser = Client()
self.browser.request()
self.engine = import_module(settings.SESSION_ENGINE)
self.crypt_sesh = CryptSession()
self.factory = RequestFactory()
self.skey = settings.SESSION_COOKIE_NAME
# This is a bit crap - because matching is fragile and also its
# reused to split up and grab the session id - TODO: replace with regex
self.hidden = '<input type="hidden" name="%s" value="' % self.skey
def get_session(self, response, url='/', agent='unknown browser'):
""" Extract id from response and retrieve session """
# post or get
parts = ''
if not response.content:
print 'RESPONSE FAILED: %s' % response.__class__
if response.content.find(self.hidden) > -1:
splitter = self.hidden
else:
splitter = '%s=' % self.skey
parts = response.content.split(splitter, 1)
session_key = ''
if len(parts) > 1:
parts = parts[1].split('"', 1)
session_id = parts[0]
request = self.factory.get(url, REMOTE_ADDR='127.0.0.1',
HTTP_USER_AGENT=agent)
try:
session_key = self.crypt_sesh.decrypt(request, session_id)
except:
# Silently start new session in case fake session_id format causes error
pass
else:
session_id = ''
try:
session = self.engine.SessionStore(session_key)
except:
session = self.engine.SessionStore()
return session, session_id
def request(self, **request):
if 'PATH_INFO' in request:
path=self.prefix+request['PATH_INFO']
else:
path=self.prefix
request['PATH_INFO']=path
print "\nclient PATH_INFO:", path
return DClient.request(self, **request)
def request(self, **request):
if 'PATH_INFO' in request:
path = self.prefix + request['PATH_INFO']
else:
path = self.prefix
request['PATH_INFO'] = path
print "\nclient PATH_INFO:", path
return DClient.request(self, **request)
def test_authentication_on_form(self):
client = Client()
response = client.post('/upload_email/', data)
assert not 'ok' in response.content, response.content
request = client.request()
client.login(username='******', password='******')
response = client.post('/upload_email/', data)
assert 'ok' in response.content, response.content
class BaseTest(TestCase):
def setUp(self):
create_paths()
self.client = Client()
connection._set_isolation_level(0)
def tearDown(self):
execute_sql('SELECT ak.drop_all_schemas()')
for dev_name in os.listdir(ROOT.devs):
if dev_name != ANONYM_NAME:
execute_sql('DROP TABLESPACE IF EXISTS "%s"' % dev_name)
Popen('sudo rm -r %s %s' % (ROOT.devs, ROOT.trash), shell=True)
shutil.rmtree(ROOT.locks)
shutil.rmtree(ROOT.domains)
def request(self, method, path, data='', content_type=None, status=OK):
if not path.startswith('/'):
path = '/' + path
if not isinstance(data, str):
data = json.dumps(data)
content_type = content_type or 'application/json'
parsed = urlparse(path)
request = {
'REQUEST_METHOD': method,
'PATH_INFO': urllib.unquote(parsed[2]),
'QUERY_STRING': parsed[4],
'wsgi.input': FakePayload(data),
'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest',
}
if data:
request['CONTENT_LENGTH'] = len(data)
if content_type:
request['CONTENT_TYPE'] = content_type
response = self.client.request(**request)
self.assertEqual(response.status_code, status, response.content)
return (json.loads(response.content)
if response['Content-Type'].startswith('application/json') else
response.content)
def get(self, path, status=OK):
return self.request('GET', path, status=status)
def post(self, path, data='', content_type=None, status=OK):
return self.request('POST', path, data, content_type, status)
def put(self, path, data='', content_type=None, status=OK):
if not content_type and isinstance(data, str):
content_type = 'text/plain'
return self.request('PUT', path, data, content_type, status)
def delete(self, path, status=OK):
return self.request('DELETE', path, status=status)
class BaseTest(TestCase):
def setUp(self):
create_paths()
self.client = Client()
connection._set_isolation_level(0)
def tearDown(self):
execute_sql('SELECT ak.drop_all_schemas()')
for dev_name in os.listdir(ROOT.devs):
if dev_name != ANONYM_NAME:
execute_sql('DROP TABLESPACE IF EXISTS "%s"' % dev_name)
Popen('sudo rm -r %s %s' % (ROOT.devs, ROOT.trash), shell=True)
shutil.rmtree(ROOT.locks)
shutil.rmtree(ROOT.domains)
def request(self, method, path, data='', content_type=None, status=OK):
if not path.startswith('/'):
path = '/' + path
if not isinstance(data, str):
data = json.dumps(data)
content_type = content_type or 'application/json'
parsed = urlparse(path)
request = {
'REQUEST_METHOD': method,
'PATH_INFO': urllib.unquote(parsed[2]),
'QUERY_STRING': parsed[4],
'wsgi.input': FakePayload(data),
'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest',
}
if data:
request['CONTENT_LENGTH'] = len(data)
if content_type:
request['CONTENT_TYPE'] = content_type
response = self.client.request(**request)
self.assertEqual(response.status_code, status, response.content)
return (json.loads(response.content)
if response['Content-Type'].startswith('application/json') else
response.content)
def get(self, path, status=OK):
return self.request('GET', path, status=status)
def post(self, path, data='', content_type=None, status=OK):
return self.request('POST', path, data, content_type, status)
def put(self, path, data='', content_type=None, status=OK):
if not content_type and isinstance(data, str):
content_type = 'text/plain'
return self.request('PUT', path, data, content_type, status)
def delete(self, path, status=OK):
return self.request('DELETE', path, status=status)
def execute(self, request=None, url=None):
if not url:
url = self.url
extra = {}
if self.ip_address:
extra['REMOTE_ADDR'] = self.ip_address
request = request or self.get_request()
client = Client()
if self.method != "get":
# Django 1.4 is not able to handle DELETE requests with payload.
# workaround here:
extra.update({
'wsgi.input': FakePayload(request),
'CONTENT_LENGTH': len(request),
'CONTENT_TYPE': "text/json",
'PATH_INFO': client._get_path(urlparse(url)),
'REQUEST_METHOD': self.method.upper()
})
return client.request(**extra)
else:
return client.get(url, **extra);
class TestApiClient(object):
def __init__(self, serializer=None):
"""
Sets up a fresh ``TestApiClient`` instance.
If you are employing a custom serializer, you can pass the class to the
``serializer=`` kwarg.
"""
self.client = Client()
self.serializer = serializer
if not self.serializer:
self.serializer = Serializer()
def get_content_type(self, short_format):
"""
Given a short name (such as ``json`` or ``xml``), returns the full content-type
for it (``application/json`` or ``application/xml`` in this case).
"""
return self.serializer.content_types.get(short_format, 'json')
def get(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``GET`` request to the provided URI.
Optionally accepts a ``data`` kwarg, which in the case of ``GET``, lets you
send along ``GET`` parameters. This is useful when testing filtering or other
things that read off the ``GET`` params. Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.get('/api/v1/entry/1/', data={'format': 'json', 'title__startswith': 'a', 'limit': 20, 'offset': 60})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['HTTP_ACCEPT'] = content_type
# GET & DELETE are the only times we don't serialize the data.
if data is not None:
kwargs['data'] = data
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.get(uri, **kwargs)
def post(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``POST`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``POST`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.post('/api/v1/entry/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data,
format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.post(uri, **kwargs)
def put(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``PUT`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``PUT`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.put('/api/v1/entry/1/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data,
format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.put(uri, **kwargs)
def patch(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``PATCH`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``PATCH`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.patch('/api/v1/entry/1/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data,
format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
# This hurts because Django doesn't support PATCH natively.
parsed = urlparse(uri)
r = {
'CONTENT_LENGTH': len(kwargs['data']),
'CONTENT_TYPE': content_type,
'PATH_INFO': self.client._get_path(parsed),
'QUERY_STRING': parsed[4],
'REQUEST_METHOD': 'PATCH',
'wsgi.input': FakePayload(kwargs['data']),
}
r.update(kwargs)
return self.client.request(**r)
def delete(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``DELETE`` request to the provided URI.
Optionally accepts a ``data`` kwarg, which in the case of ``DELETE``, lets you
send along ``DELETE`` parameters. This is useful when testing filtering or other
things that read off the ``DELETE`` params. Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.delete('/api/v1/entry/1/', data={'format': 'json'})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
# GET & DELETE are the only times we don't serialize the data.
if data is not None:
kwargs['data'] = data
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.delete(uri, **kwargs)
class TestApiClient(object):
def __init__(self, serializer=None):
"""
Sets up a fresh ``TestApiClient`` instance.
If you are employing a custom serializer, you can pass the class to the
``serializer=`` kwarg.
"""
self.client = Client()
self.serializer = serializer
if not self.serializer:
self.serializer = Serializer()
def get_content_type(self, short_format):
"""
Given a short name (such as ``json`` or ``xml``), returns the full content-type
for it (``application/json`` or ``application/xml`` in this case).
"""
return self.serializer.content_types.get(short_format or 'json')
def get(self, uri, format='json', data=None, authentication=None, **kwargs):
"""
Performs a simulated ``GET`` request to the provided URI.
Optionally accepts a ``data`` kwarg, which in the case of ``GET``, lets you
send along ``GET`` parameters. This is useful when testing filtering or other
things that read off the ``GET`` params. Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.get('/api/v1/entry/1/', data={'format': 'json', 'title__startswith': 'a', 'limit': 20, 'offset': 60})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['HTTP_ACCEPT'] = content_type
# GET & DELETE are the only times we don't serialize the data.
if data is not None:
kwargs['data'] = data
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.get(uri, **kwargs)
def post(self, uri, format='json', data=None, authentication=None, **kwargs):
"""
Performs a simulated ``POST`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``POST`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.post('/api/v1/entry/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data, format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.post(uri, **kwargs)
def put(self, uri, format='json', data=None, authentication=None, **kwargs):
"""
Performs a simulated ``PUT`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``PUT`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.put('/api/v1/entry/1/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data, format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.put(uri, **kwargs)
def patch(self, uri, format='json', data=None, authentication=None, **kwargs):
"""
Performs a simulated ``PATCH`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``PATCH`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.patch('/api/v1/entry/1/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data, format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
# This hurts because Django doesn't support PATCH natively.
parsed = urlparse(uri)
r = {
'CONTENT_LENGTH': len(kwargs['data']),
'CONTENT_TYPE': content_type,
'PATH_INFO': self.client._get_path(parsed),
'QUERY_STRING': parsed[4],
'REQUEST_METHOD': 'PATCH',
'wsgi.input': FakePayload(kwargs['data']),
}
r.update(kwargs)
return self.client.request(**r)
def delete(self, uri, format='json', data=None, authentication=None, **kwargs):
"""
Performs a simulated ``DELETE`` request to the provided URI.
Optionally accepts a ``data`` kwarg, which in the case of ``DELETE``, lets you
send along ``DELETE`` parameters. This is useful when testing filtering or other
things that read off the ``DELETE`` params. Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.delete('/api/v1/entry/1/', data={'format': 'json'})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
# GET & DELETE are the only times we don't serialize the data.
if data is not None:
kwargs['data'] = data
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.delete(uri, **kwargs)
class TestModelRequest(TestCase):
WEIGHT = 10
HEIGHT = 123
CEPHALIC_PERIMETER = 30
AGE = 1
def setUp(self):
"""
This method will run before any test case.
"""
self.client = Client()
self.user = self.make_user()
self.patient = Patient.objects.create(
ses="1234567",
user=self.user,
mother_name="Mãe",
father_name="Pai",
ethnicity=3,
sus_number="12345678911",
civil_registry_of_birth="12345678911",
)
self.user2 = self.make_user(username='******')
self.health_team = HealthTeam.objects.create(
cpf="057.641.271-65",
user=self.user2,
speciality=HealthTeam.NEUROLOGY,
council_acronym=HealthTeam.CRM,
register_number="1234567",
registration_state=HealthTeam.DF,
)
self.curve = Curves.objects.create(
patient=self.patient,
weight=self.WEIGHT,
height=self.HEIGHT,
cephalic_perimeter=self.CEPHALIC_PERIMETER,
age=self.AGE,
)
Curves.objects.create(
patient=self.patient,
weight=self.WEIGHT,
height=self.HEIGHT,
cephalic_perimeter=self.CEPHALIC_PERIMETER,
age=45,
)
def test_curves_form_valid_create_view(self):
"""
Test if create form is valid with all required fields
"""
self.client.force_login(user=self.health_team.user)
data = {
'height': self.HEIGHT,
'weight': self.WEIGHT,
'age': 12,
'cephalic_perimeter': self.CEPHALIC_PERIMETER,
}
response = self.client.post(path=reverse(
'medicalrecords:create_curve',
kwargs={'username': self.patient.user.username}),
data=data,
follow=True)
self.assertEquals(response.status_code, 200)
def test_data_parse_curves_height(self):
self.client.force_login(user=self.user2)
self.client.request()
response = self.client.get(path=reverse(
viewname='medicalrecords:curve_ajax', ),
follow=True,
data={
'username': self.patient.user.username,
'data_type': 'height',
'time_frame': 'months'
})
self.assertEquals(response.status_code, 200)
response = self.client.get(path=reverse(
viewname='medicalrecords:curve_ajax', ),
follow=True,
data={
'username': self.patient.user.username,
'data_type': 'height',
'time_frame': 'years'
})
self.assertEquals(response.status_code, 200)
def test_data_parse_curves_weight(self):
self.client.force_login(user=self.user2)
self.client.request()
response = self.client.get(path=reverse(
viewname='medicalrecords:curve_ajax', ),
follow=True,
data={
'username': self.patient.user.username,
'data_type': 'weight',
'time_frame': 'months'
})
self.assertEquals(response.status_code, 200)
response = self.client.get(path=reverse(
viewname='medicalrecords:curve_ajax', ),
follow=True,
data={
'username': self.patient.user.username,
'data_type': 'weight',
'time_frame': 'years'
})
self.assertEquals(response.status_code, 200)
def test_data_parse_curves_bmi(self):
self.client.force_login(user=self.user2)
self.client.request()
self.patient.user.gender = 'Female'
self.patient.user.save()
response = self.client.get(path=reverse(
viewname='medicalrecords:curve_ajax', ),
follow=True,
data={
'username': self.patient.user.username,
'data_type': 'bmi',
'time_frame': 'years'
})
self.assertEquals(response.status_code, 200)
def test_api_gender(self):
curve_api = CurveDataParser()
curve_api.patient = self.patient
self.patient.user.gender = 'Male'
self.patient.user.save()
self.assertEquals(curve_api.api_gender(), 'male')
self.patient.user.gender = 'Female'
self.patient.user.save()
self.assertEquals(self.patient.user.gender, 'Female')
self.assertEquals(curve_api.api_gender(), 'female')
def test_data_parse_curves_cephalic_perimeter(self):
self.client.force_login(user=self.user2)
self.client.request()
response = self.client.get(path=reverse(
viewname='medicalrecords:curve_ajax', ),
follow=True,
data={
'username': self.patient.user.username,
'data_type': 'cephalic_perimeter',
})
self.assertEquals(response.status_code, 200)
def test_curves_form_invalid_create_view(self):
"""
Test if create form is invalid with unique together
"""
self.client.force_login(user=self.health_team.user)
data = {
'height': self.HEIGHT,
'weight': self.WEIGHT,
'age': self.AGE,
'cephalic_perimeter': self.CEPHALIC_PERIMETER,
}
response = self.client.post(path=reverse(
'medicalrecords:create_curve',
kwargs={'username': self.user.username}),
data=data,
follow=True)
self.assertEquals(response.status_code, 200)
response2 = self.client.post(path=reverse(
'medicalrecords:create_curve',
kwargs={'username': self.user.username}),
data=data,
follow=True)
self.assertEquals(response2.status_code, 200)
def test_curves_validation(self):
"""
Test if curves age validation is ok
"""
self.curve_test = Curves.objects.create(
patient=self.patient,
weight=self.WEIGHT,
height=self.HEIGHT,
cephalic_perimeter=self.CEPHALIC_PERIMETER,
age=233,
)
self.curve_test.save()
self.curve_test.refresh_from_db()
self.assertEquals(self.curve_test.cephalic_perimeter, 0)
