def test_access_shared_timetables(self):
Friendship.objects.create(initiating_student=self.student,
receiving_student=self.student3,
accepted=True)
# Self
client = RequestsClient()
client.headers.update(
{'Authorization': 'Token ' + str(self.token.key)})
response = client.get('http://testserver/api/timetables/2072452q/')
self.assertEqual(response.status_code, 200)
# Shared
client = RequestsClient()
client.headers.update(
{'Authorization': 'Token ' + str(self.token.key)})
response = client.get('http://testserver/api/timetables/2072452y/')
self.assertEqual(response.status_code, 200)
# Not shared
client = RequestsClient()
client.headers.update(
{'Authorization': 'Token ' + str(self.token.key)})
response = client.get('http://testserver/api/timetables/2072452n/')
self.assertEqual(response.status_code, 403)
# Non existent
client = RequestsClient()
client.headers.update(
{'Authorization': 'Token ' + str(self.token.key)})
response = client.get('http://testserver/api/timetables/2072452z/')
self.assertEqual(response.status_code, 404)
def test_create_attendance_record(self):
factory = APIRequestFactory()
# Check not marked as attended
client = RequestsClient()
client.headers.update(
{'Authorization': 'Token ' + str(self.token.key)})
response = client.get(
'http://testserver/api/timetables/2072452q/?day=2016-12-5')
self.assertFalse(response.json()[0]['attended'])
# Add attendance record
view = AttendanceRecordViewSet.as_view({'post': 'create'})
beacon_data = {
'uuid': '123e4567-e89b-12d3-a456-426655440000',
'major': 1,
'minor': 1,
'seen_at_time': dateutil.parser.parse("Dec 5th, 2016 09:00:00")
}
request = factory.post('/attendance-records/', beacon_data)
force_authenticate(request, user=self.user)
response = view(request)
self.assertEqual(response.status_code, 201) # 201 Created
# Check marked as attended
client = RequestsClient()
client.headers.update(
{'Authorization': 'Token ' + str(self.token.key)})
response = client.get(
'http://testserver/api/timetables/2072452q/?day=2016-12-5')
self.assertTrue(response.json()[0]['attended'])
def setUp(self) -> None:
ClientUser.objects.create(consumer_key='pass', consumer_secret='pass')
self.client = RequestsClient()
self.client.auth = HTTPBasicAuth('pass', 'pass')
self.client.headers.update({'x-test': 'true'})
url = reverse('get_token')
response = self.client.post('http://testserver{}'.format(url))
self.token = response.json().get('access_token')
self.client = RequestsClient()
self.client.headers.update(
{'Authorization': 'Bearer {}'.format(self.token)})
url = reverse('register')
self.client.post('http://testserver{}'.format(url),
json={
'msisdn': 254763488092,
'pin': 1212
})
category = ProductCategory.objects.create(name='Category')
url = reverse('login')
self.client.headers.update(
{'Authorization': 'Bearer {}'.format(self.token)})
response = self.client.post('http://testserver{}'.format(url),
json={
'msisdn': 254763488092,
'pin': 1212
})
self.client.headers.update(
{'X-SESSION-KEY': response.json().get('session_key')})
Product.objects.create(name='Jeans', price=100.00, category=category)
def test_admin_can_view_other_user_detail(settings, live_server):
settings.PATH_TO_JWT_PUBLIC_KEY = TEST_JWT_PUBLIC_KEY_FILE
sensor01_token_payload = get_token_payload(authorities=["ROLE_MANAGER"])
encoded = jwt.encode(sensor01_token_payload, str(PRIVATE_KEY), algorithm="RS256")
utf8_bytes = encoded.decode("utf-8")
client = RequestsClient()
# authenticating with "ROLE_MANAGER" creates user if does not already exist
response = client.get(
f"{live_server.url}", headers={"Authorization": f"Bearer {utf8_bytes}"}
)
assert response.status_code == 200
sensor02_token_payload = get_token_payload(authorities=["ROLE_MANAGER"])
sensor02_token_payload["user_name"] = "sensor02"
encoded = jwt.encode(sensor02_token_payload, str(PRIVATE_KEY), algorithm="RS256")
utf8_bytes = encoded.decode("utf-8")
client = RequestsClient()
sensor01_user = User.objects.get(username=sensor01_token_payload["user_name"])
kws = {"pk": sensor01_user.pk}
kws.update(V1)
user_detail = reverse("user-detail", kwargs=kws)
response = client.get(
f"{live_server.url}{user_detail}",
headers={"Authorization": f"Bearer {utf8_bytes}"},
)
assert response.status_code == 200
def test_token_hidden(settings, live_server):
settings.PATH_TO_JWT_PUBLIC_KEY = TEST_JWT_PUBLIC_KEY_FILE
token_payload = get_token_payload(authorities=["ROLE_MANAGER"])
encoded = jwt.encode(token_payload, str(PRIVATE_KEY), algorithm="RS256")
utf8_bytes = encoded.decode("utf-8")
client = RequestsClient()
# authenticating with "ROLE_MANAGER" creates user if does not already exist
response = client.get(
f"{live_server.url}", headers={"Authorization": f"Bearer {utf8_bytes}"}
)
assert response.status_code == 200
sensor01_user = User.objects.get(username=token_payload["user_name"])
kws = {"pk": sensor01_user.pk}
kws.update(V1)
user_detail = reverse("user-detail", kwargs=kws)
client = RequestsClient()
response = client.get(
f"{live_server.url}{user_detail}",
headers={"Authorization": f"Bearer {utf8_bytes}"},
)
assert response.status_code == 200
assert (
response.json()["auth_token"]
== "rest_framework.authentication.TokenAuthentication is not enabled"
)
def test_user_delete(self):
response = RequestsClient().delete(self.url + '{id}/'.format(
id=self.user_dakarai_id))
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
response = RequestsClient().get(self.url + '{id}/'.format(
id=self.user_dakarai_id))
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def setUp(self):
self.client = RequestsClient()
self.client.headers.update(
{"Authorization": "Bearer {}".format(self.token.key)})
self.client_no_token = RequestsClient()
self.client_invalid_token = RequestsClient()
self.client_invalid_token.headers.update(
{"Authorization": "Bearer 1111aaaa2222oooo"})
def test_token_access(self):
url = URL_ROOT + "/api/status/"
client_no_token = RequestsClient()
client_invalid_token = RequestsClient()
client_invalid_token.headers.update(
{"Authorization": "Bearer 1111aaaa2222oooo"})
response = client_no_token.get(url)
self.assertEqual(response.status_code, 401)
response = client_invalid_token.get(url)
self.assertEqual(response.status_code, 401)
def test_case_1():
"""
Returns 200 .
"""
client = RequestsClient()
status_response = client.get('http://testserver/service/')
assert status_response.status_code == 200
def setUp(self):
# Client to send test requests
self.client = RequestsClient()
# Dummy data to be tested
self.user = FakeUser.objects.create(name='name for test',
username='******',
email='email for test',
phone='555566222',
website='www.test.com')
self.address = FakeAddress.objects.create(user=self.user,
street='street for test',
suite='suite for test',
city='city for test',
zipcode='4445')
self.geo = FakeGeo.objects.get_or_create(address=self.address,
lat='66561.235',
lng='23.354')
self.company = FakeCompany.objects.get_or_create(
user=self.user,
name='company name',
catchPhrase='random phrase',
bs='random bs')
def test_boards_url(self):
client = RequestsClient()
response = client.get('http://127.0.0.1:8000/api/v1/boards/')
self.assertEqual(response.status_code, 200)
self.assertJSONEqual('{"id": 1, "board_size": 8}',
'{"id": 1, "board_size": 8}')
def test_create_private_chat(self):
path = 'http://testserver/chat/rooms/'
rooms_before_new_event = Room.objects.all().count()
client = RequestsClient()
user1 = self.volunteerDicts[0]
user2 = self.volunteerDicts[1]
user3 = self.volunteerDicts[2]
user1_token = self.volunteerTokens[0]['access']
self._test_create_private_chat_helper(user1, user2, user3, user1_token,
client, path,
rooms_before_new_event, 1)
user1 = self.volunteerDicts[1]
user2 = self.volunteerDicts[2]
user3 = self.volunteerDicts[0]
user1_token = self.volunteerTokens[1]['access']
self._test_create_private_chat_helper(user1, user2, user3, user1_token,
client, path,
rooms_before_new_event, 2)
room_count = Room.objects.all().count()
self._test_create_private_chat_helper(user1, user2, user3, user1_token,
client, path,
rooms_before_new_event, 2)
self.assertEqual(Room.objects.all().count(), room_count)
def test_set_3(self):
client = RequestsClient()
for ro in self.test_3:
row = json.loads(ro)
res = {}
if row['request']['method'] == "GET":
res = client.get('http://localhost:8000' +
row['request']['url'] + '/')
elif row['request']['method'] == "POST":
res = client.post(
'http://localhost:8000' + row['request']['url'] + '/', json=row['request']['body'])
elif row['request']['method'] == "DELETE":
res = client.delete(
'http://localhost:8000' + row['request']['url'] + '/')
elif row['request']['method'] == "PUT":
res = client.put('http://localhost:8000' + row['request']['url'] + '/', json=row['request']['body'])
self.assertEqual(res.status_code, row['response']['status_code'])
if row['response']['headers'] != {}:
self.assertEqual(
res.headers['Content-Type'], row['response']['headers']['Content-Type'])
if row['request']['url'] in ['/actors','/actors/streak'] and row['request']['method'] == 'GET':
self.assertEqual(sorted(json.loads(res.text)), sorted(row['response']['body']))
elif row['response']['body'] != {}:
response = json.loads(res.text)
for resp in response:
if resp['created_at']:
temp = parse(resp['created_at'])
temp = temp.replace(tzinfo=None)
temp = str(temp)
resp['created_at'] = temp
self.assertEqual(response, row['response']['body'])
def test_get_request(self):
client = RequestsClient()
response = client.get('http://testserver/')
assert response.status_code == 200
assert response.headers['Content-Type'] == 'application/json'
expected = {'method': 'GET', 'query_params': {}}
assert response.json() == expected
def list_todo(self, api_key, action, sort_by, filter_title_by,
filter_description_by, filter_state_by, filter_due_date_by,
reverse_order):
if api_key == "":
msg = _('API Key must not be empty.')
raise ValidationError({'error': msg})
else:
if action == 'get':
response = client.get(
'http://localhost:8000/todoapp/api/list/',
headers={'Authorization': 'Api-Key %s' % api_key})
return response
else:
client = RequestsClient()
try:
sort_choices = [
'task_title', 'task_description', 'task_state',
'task_due_date'
]
data = {
"sort_by": sort_by,
"filter_title_by": filter_title_by,
"filter_description_by": filter_description_by,
"filter_state_by": filter_state_by,
"filter_due_date_by": filter_due_date_by,
"reverse_order": reverse_order,
}
response = client.post(
'http://localhost:8000/todoapp/api/list/',
data,
headers={'Authorization': 'Api-Key %s' % api_key})
return response
except Exception as e:
raise ValidationError({'error': e.args})
def test_API_user(self):
# client = RequestsClient()
#
# # Obtain a CSRF token.
# response = client.get('http://127.0.0.1:9090/api-auth/login/')
# assert response.status_code == 200
# csrftoken = response.cookies['csrftoken']
#
# # Interact with the API.
# response = client.post('http://127.0.0.1:9090/api-auth/login/', json={
# 'username': '******',
# 'password': '******'
# }, headers={'X-CSRFToken': csrftoken})
# assert response.status_code == 200
from requests.auth import HTTPBasicAuth
# Include an appropriate `Authorization:` header on all requests.
# token = Token.objects.get(user__username='******')
# client = APIClient()
# client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
client = RequestsClient()
client.auth = HTTPBasicAuth('jody', 'rekless')
# client.headers.update({'x-test': 'true'})
test = client.login()
response = client.post('http://127.0.0.1:9090/api-auth/login/')
assert response.status_code == 200
def test_auth(self):
# Confirm session is not authenticated
client = RequestsClient()
response = client.get('http://testserver/auth/')
assert response.status_code == 200
assert response.headers['Content-Type'] == 'application/json'
expected = {'username': None}
assert response.json() == expected
assert 'csrftoken' in response.cookies
csrftoken = response.cookies['csrftoken']
user = User.objects.create(username='******')
user.set_password('password')
user.save()
# Perform a login
response = client.post('http://testserver/auth/',
json={
'username': '******',
'password': '******'
},
headers={'X-CSRFToken': csrftoken})
assert response.status_code == 200
assert response.headers['Content-Type'] == 'application/json'
expected = {'username': '******'}
assert response.json() == expected
# Confirm session is authenticated
response = client.get('http://testserver/auth/')
assert response.status_code == 200
assert response.headers['Content-Type'] == 'application/json'
expected = {'username': '******'}
assert response.json() == expected
def setUp(self):
self.c = RequestsClient()
self.pre_http = "http://127.0.0.1:8000"
self.rfid_tag = UserProfile.objects.all()[0].rfid_tag
self.user = UserProfile.objects.all()[0].user
self.gym = GymProfile.objects.first()
self.header = {'Authorization': 'Token ' + str(self.user.auth_token)}
def test_get_category_data(self):
client = RequestsClient()
response = client.get('http://127.0.0.1:8000/api/v1/category/')
print(response.status_code)
print(type(response.status_code))
assert response.status_code == 200
def setUp(self):
self.client = APIClient()
self.rc = RequestsClient()
self.upd_data = {
"vnfInstanceName": "vnf new name",
"vnfInstanceDescription": "new description"
}
def test_del_article(self):
url = 'http://127.0.0.1:8000/api/v1/articles/1/'
client = RequestsClient()
response = client.delete(
'http://127.0.0.1:8000/api/v1/articles/1/?format=json')
def test_wrong_post_request(self):
client = RequestsClient()
res = client.get(BASE_URL + 'weather/')
self.assertEqual(res.status_code, 200)
self.assertEqual(res.json(), [])
res = client.post(BASE_URL + 'weather/', json=self.weather4)
self.assertEqual(res.status_code, 400, 'Id should be a whole number')
self.assertEqual(res.json()['id'], ['Enter a whole number.'])
res = client.post(BASE_URL + 'weather/', json=self.weather5)
self.assertEqual(res.status_code, 400,
'Date should be in given format')
self.assertEqual(res.json()['date'], ['Enter a valid date/time.'])
res = client.post(BASE_URL + 'weather/', json=self.weather6)
self.assertEqual(res.status_code, 400,
'Latitude should be in given format')
self.assertEqual(res.json()['lat'], ['Enter a number.'])
res = client.post(BASE_URL + 'weather/', json=self.weather7)
self.assertEqual(res.status_code, 400,
'longitude should be in given format')
self.assertEqual(res.json()['lon'], ['Enter a number.'])
res = client.post(BASE_URL + 'weather/', json=self.weather8)
self.assertEqual(res.status_code, 400, 'Bad request data')
self.assertEqual(res.json()['lat'], ['Enter a number.'])
self.assertEqual(res.json()['lon'], ['Enter a number.'])
self.assertEqual(res.json()['id'], ['Enter a whole number.'])
self.assertEqual(res.json()['date'], ['Enter a valid date/time.'])
res = client.post(BASE_URL + 'weather/', json=self.weather1)
self.assertEqual(res.status_code, 201)
def test_question_post(self):
print("Test question post")
client = RequestsClient()
url = 'http://127.0.0.1:8000/api/question/'
data = {"name": "John", "question": "Where is my socks?"}
response = client.post(url=url, data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_login(self):
client = RequestsClient()
response = client.get("http://testserver/accounts/login")
csrftoken = response.cookies['csrftoken']
user = models.CaseUser.objects.get(email="*****@*****.**")
user_password = "******"
"""
Testing valid login
"""
response = client.post("http://testserver/accounts/view_details/",
json={'email': user.email, 'password': user_password},
headers={'X-CSRFToken': csrftoken})
assert response.status_code == 200
soup = BeautifulSoup(response.content, 'html.parser')
api_key = soup.findAll("span", {"class": "user_api_key"})[0].text
assert api_key == models.Token.objects.get(user=user).key
case_allowance = soup.findAll("span", {"class": "user_case_allowance"})[0].text
assert case_allowance == "500"
"""
Testing invalid login
"""
response = client.post("http://testserver/accounts/view_details/",
json={'email': user.email, 'password': user_password + "1"},
headers={'X-CSRFToken': csrftoken})
assert response.status_code == 400
def test_category_post(self):
print("Post category")
url = 'http://testserver/categories/'
client = RequestsClient()
data = {'name': 'Languages', 'imgpath': 'someimg'}
response = client.post(url, data)
self.assertEquals(response.status_code, status.HTTP_200_OK)
def test_get_with_headers(self):
client = RequestsClient()
response = client.get('http://testserver/headers/', headers={'User-Agent': 'example'})
assert response.status_code == 200
assert response.headers['Content-Type'] == 'application/json'
headers = response.json()['headers']
assert headers['USER-AGENT'] == 'example'
def test_weather_temperature_filter_request(self):
client = RequestsClient()
client.get(BASE_URL + 'weather/')
client.post(BASE_URL + 'weather/', json=self.weather2)
client.post(BASE_URL + 'weather/', json=self.weather1)
client.post(BASE_URL + 'weather/', json=self.weather3)
res = client.get(BASE_URL +
'weather/temperature?start=1985-02-01&end=1985-02-02')
self.assertEqual(res.status_code, 200)
self.assertEqual(res.json(), [])
self.assertEqual(len(res.json()), 0)
res = client.get(BASE_URL +
'weather/temperature?start=1985-01-01&end=1985-01-02')
self.assertEqual(res.status_code, 200)
self.assertEqual(len(res.json()), 2)
self.assertEqual(res.json()[0]['lowest'], 2.7)
self.assertEqual(res.json()[0]['highest'], 91.3)
self.assertEqual(res.json()[1]['lowest'], 39.8)
self.assertEqual(res.json()[1]['highest'], 53.5)
res = client.get(BASE_URL +
'weather/temperature?start=1985-01-01&end=1985-01-04')
self.assertEqual(res.status_code, 200)
self.assertEqual(len(res.json()), 3)
self.assertEqual(res.json()[0]['city'], 'Monroe')
self.assertEqual(res.json()[0]['state'], 'Louisiana')
self.assertEqual(res.json()[1]['city'], 'Monroe')
self.assertEqual(res.json()[1]['state'], 'Tennessee')
self.assertEqual(res.json()[2]['city'], 'Nashville')
self.assertEqual(res.json()[2]['state'], 'Tennessee')
def setUp(self):
settings.CACHE_KEY_PREFIX = 'opustest:' + settings.OPUS_SCHEMA_NAME
logging.disable(logging.ERROR)
if settings.TEST_GO_LIVE:
self.client = requests.Session()
else:
self.client = RequestsClient()
def test_get_all_trades_small(self):
client = RequestsClient()
for ro in self.test_small:
row = json.loads(ro)
res = {}
if row['request']['method'] == "GET":
res = client.get('http://localhost:8000' +
row['request']['url'] + '/')
elif row['request']['method'] == "POST":
res = client.post('http://localhost:8000' +
row['request']['url'] + '/',
json=row['request']['body'])
elif row['request']['method'] == "DELETE":
res = client.delete('http://localhost:8000' +
row['request']['url'] + '/')
self.assertEqual(res.status_code, row['response']['status_code'])
if row['response']['headers'] != {}:
self.assertEqual(res.headers['Content-Type'],
row['response']['headers']['Content-Type'])
if row['response']['body'] != {}:
response = json.loads(res.text)
for resp in response:
if resp['trade_timestamp']:
temp = parse(resp['trade_timestamp'])
temp = temp.replace(tzinfo=None)
temp = str(temp)
resp['trade_timestamp'] = temp
self.assertEqual(response, row['response']['body'])
def setUp(self):
with open("./resources/tests/cfg/test_metal_data.config",
"r") as metal_cfg:
test_data = metal_cfg.read()
self.investor_test = InvestorUser.objects.create_user(
username='******', password='******')
self.metal_test_data = json.loads(test_data)
self.silver_test_data_1 = self.metal_test_data.get('silver_record_1')
self.silver_test_data_2 = self.metal_test_data.get('silver_record_2')
self.gold_test_data_1 = self.metal_test_data.get('gold_record_1')
self.gold_test_data_2 = self.metal_test_data.get('gold_record_2')
self.silver_test_obj_1 = Metal.objects.create(
owner=self.investor_test, **self.silver_test_data_1)
self.silver_test_obj_2 = Metal.objects.create(
owner=self.investor_test, **self.silver_test_data_2)
self.gold_test_obj_1 = Metal.objects.create(owner=self.investor_test,
**self.gold_test_data_1)
self.gold_test_obj_2 = Metal.objects.create(owner=self.investor_test,
**self.gold_test_data_2)
self.client = RequestsClient()
response = self.client.post('http://127.0.0.1:8000/api/v1/auth/token',
json={
'username': '******',
'password': '******'
})
content = json.loads(response.content.decode('utf-8'))
self.token = content.get('token')
