def test_add_mod_delete(self):
client = Client()
response = client.post(reverse('api:db-list'), {
'name': 'test',
'description': 'fakedb'
})
assert response.status_code == status.HTTP_403_FORBIDDEN
assert client.login(username='******', password='******')
response = client.post(reverse('api:db-list'), {
'name': 'test',
'description': 'fakedb'
})
assert response.status_code == status.HTTP_201_CREATED
response = client.patch(reverse('api:db-detail', kwargs={'pk': 1}),
{'description': 'fakedb2'})
assert response.status_code == status.HTTP_200_OK
client.logout()
response = client.patch(reverse('api:db-detail', kwargs={'pk': 1}),
{'description': 'fakedb2'})
assert response.status_code == status.HTTP_403_FORBIDDEN
response = client.delete(reverse('api:db-detail', kwargs={'pk': 1}))
assert response.status_code == status.HTTP_403_FORBIDDEN
assert client.login(username='******', password='******')
response = client.get(reverse('api:db-detail', kwargs={'pk': 1}),
{'description': 'fakedb2'})
assert response.data['description'] == 'fakedb2'
response = client.delete(reverse('api:db-detail', kwargs={'pk': 1}))
assert response.status_code == status.HTTP_204_NO_CONTENT
def setUp(self):
self.client = Client()
self.headers = {
'HTTP_X_ANONYMOUS_CONSUMER': False,
'HTTP_X_AUTHENTICATED-USERID': 3
}
self.user_data = {
'username':
'******',
'id':
3,
'organizations': [{
'name':
'Organization',
'id':
3,
'groups': [{
'name': 'organization.admin',
'permissions': [{
'name': 'all',
'code': 'all'
}]
}]
}]
}
redis.StrictRedis(settings.PERMISSIONS_HOST).set(
'authorization.3', json.dumps(self.user_data))
def setUp(self):
f = faker.Faker()
kong_id = str(uuid.uuid4())
self.password = str(uuid.uuid4())
responses.add(responses.POST,
'{}/consumers/?apikey={}'.format(
settings.KONG_ADMIN_URL,
settings.KONG_MANAGER_TOKEN),
json={
'created_at': 1519279548000,
'username': '******',
'id': kong_id
},
status=201)
self.org = Organization.objects.create(name='Organization')
self.perm = Permission.objects.create(name='all', code='code')
self.user = User.objects.create_user(username=f.first_name(),
password=self.password)
self.user.organization_set.add(self.org)
self.team = Team.objects.create(
name="{}.admin".format(self.org.name.lower()),
organization=self.org,
)
self.user.team_set.add(self.team)
self.team_perm = TeamPermissions.objects.create(permission=self.perm,
team=self.team)
self.client = Client()
self.response = self.client.post("/login/", {
'username': self.user.username,
'password': self.password
})
def test_add_change_delete(self):
client = Client()
# add
response = client.post(reverse('api:location-list'),
{'region': 'reg1'})
assert response.status_code == status.HTTP_403_FORBIDDEN
assert client.login(username='******', password='******')
response = client.post(reverse('api:location-list'),
{'region': 'reg1'})
assert response.status_code == status.HTTP_201_CREATED
loc_id = Location.objects.last().location_id
# change
url = reverse('api:location-detail', kwargs={'pk': loc_id})
response = client.patch(url, {'region': 'reg2'})
assert response.status_code == status.HTTP_200_OK
url = reverse('api:location-detail', kwargs={'pk': loc_id})
response = client.put(url, {'region': 'reg2'})
assert response.status_code == status.HTTP_200_OK
# delete
response = client.delete(url)
try:
Location.objects.get(location_id=loc_id)
self.fail('does not exist expected')
except Location.DoesNotExist:
pass
def test_succesful_get(self):
c = Client()
user = User.objects.get(username="******")
project = Project.objects.get(name="unique 3")
c.force_authenticate(user=user)
response_1 = c.get(self.urlReverse(project.id))
self.assertEqual(response_1.status_code, 200)
def test_succesful_put(self):
c = Client()
user = User.objects.get(username="******")
project = Project.objects.get(name="unique 3")
c.force_authenticate(user=user)
data_1 = {
"left": 1,
"top": 3,
"width": 30,
"height": 30,
"id": "some-id-1",
"parent": None,
"page": "best ever 3"
}
data_2 = {
"left": 1,
"top": 3,
"width": 30,
"height": 30,
"id": "another-id-2",
"parent": "some-id-1",
"page": "best ever 3"
}
response_1 = c.put(self.urlReverse(project.id),
data=[data_1, data_2],
format="json")
self.assertEqual(response_1.status_code, 200)
def test_successfully_created(self):
c = Client()
user = User.objects.get(username="******")
c.force_authenticate(user=user)
response = c.post(reverse("projects-new"), {"name": "2nd Project"},
format='json')
self.assertEqual(response.status_code, 200)
def setUp(self):
self.user = User.objects.create_user(email='*****@*****.**',
password='******')
self.user.is_staff = True
self.user.save()
self.client = Client()
self.client.login(email=self.user.email, password='******')
def test_no_project(self):
c = Client()
user = User.objects.get(username="******")
c.force_authenticate(user=user)
data = {}
response = c.post(self.urlReverse(101, 102), data, format="json")
self.assertEqual(response.status_code, 400)
def test_project_already_exists(self):
c = Client()
user = User.objects.get(username="******")
c.force_authenticate(user=user)
response = c.post(reverse("projects-new"), {"name": "First Project"},
format='json')
self.assertEqual(response.status_code, 406)
def test_unauthenticated(self):
c = Client()
proj = Project.objects.get(name="Discipline")
response = c.delete(self.reverseWrapper(proj.id, 90),
{"title": "Love"},
format="json")
self.assertEqual(response.status_code, 401)
def test_add_change_delete(self):
client = Client()
# add
response = client.post(reverse('api:passport-list'), {
'accession': 1,
'local_name': 'tomate'
})
assert response.status_code == status.HTTP_403_FORBIDDEN
assert client.login(username='******', password='******')
response = client.post(reverse('api:passport-list'), {
'accession': 1,
'local_name': 'tomate',
})
assert response.status_code == status.HTTP_201_CREATED
pass_id = Passport.objects.last().passport_id
# change
url = reverse('api:passport-detail', kwargs={'pk': pass_id})
response = client.patch(url, {'local_name': 'tomate2'})
assert response.status_code == status.HTTP_200_OK
response = client.put(url, {'accession': 1, 'local_name': 'tomate'})
assert response.status_code == status.HTTP_200_OK
# delete
response = client.delete(url)
try:
Passport.objects.get(passport_id=pass_id)
self.fail('does not exist expected')
except Passport.DoesNotExist:
pass
def setUp(self):
self.client = Client()
# values must be hardcoded
self.user_id = 'must be hardcoded'
self.spotify_token = 'must be hardcoded'
self.location = 'PHX'
self.explicit = 'False'
self.genre = 'pop'
self.params = {
'user_id': self.user_id,
'spotify_token': self.spotify_token,
'playlist_name': 'Test',
'location': self.location,
'explicit': self.explicit,
'genre': self.genre
}
self.response = self.client.get('/pinplay_api/', self.params)
self.headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer {}'.format(self.spotify_token)
}
def get_token(username, password):
client = Client()
response = client.post(reverse('token_obtain_pair'), {
'username': username,
'password': password
})
return response.data['access']
def test_create_mod_delete(self):
client = Client()
cvterm = Cvterm.objects.filter(cv__name='assay_props').last()
response = client.post(reverse('api:assayprop-list'), {
'assay': 1,
'type': cvterm.cvterm_id,
'value': '11'
})
assert response.status_code == status.HTTP_403_FORBIDDEN
assert client.login(username='******', password='******')
response = client.post(reverse('api:assayprop-list'), {
'assay': 1,
'type': cvterm.cvterm_id,
'value': '11'
})
assert response.status_code == status.HTTP_201_CREATED
url = reverse('api:assayprop-detail',
kwargs={'pk': response.data['assay_prop_id']})
response = client.patch(url, {'value': '12'})
assert response.status_code == status.HTTP_200_OK
assert response.data['value'] == '12'
def test_add_change_delete(self):
client = Client()
# add
test_plantname = 'prueba'
response = client.post(reverse('api:plant-list'),
{'plant_name': test_plantname})
assert response.status_code == status.HTTP_403_FORBIDDEN
assert client.login(username='******', password='******')
response = client.post(reverse('api:plant-list'), {
'plant_name': test_plantname,
'accession': 1
})
assert response.status_code == status.HTTP_201_CREATED
# change
url = reverse('api:plant-detail',
kwargs={'plant_name': test_plantname})
response = client.patch(url, {
'plant_name': test_plantname,
'row': '1'
})
assert response.status_code == status.HTTP_200_OK
plant = Plant.objects.get(plant_name=test_plantname)
assert plant.row == '1'
# delete
response = client.delete(url)
try:
Plant.objects.get(plant_name=test_plantname)
self.fail('does not exist expected')
except Plant.DoesNotExist:
pass
def test_invalid_project_type_yields_error(self):
c = Client()
user = User.objects.get(username="******")
c.force_authenticate(user=user)
response = c.post(reverse("projects-new"), {"name": True},
format='json')
self.assertEqual(response.status_code, 406)
def test_failed_login(self):
c = Client()
response = c.post(reverse("auth-view"), {
"username": "******",
"password": "******"
},
format="json")
self.assertEquals(response.status_code, 400)
def setUp(self):
self.client = Client()
redis = get_redis()
self.user_id = 1
self.example = Example.objects.create(name="example")
user_permission_data = get_user_data(self.user_id)
redis.set("authorization.1", user_permission_data)
self.headers = {"HTTP_X_AUTHENTICATED_USERID": self.user_id}
def test_list(self):
client = Client()
response = client.get(reverse('api:fieldbook_observation-list'))
assert response.status_code == status.HTTP_403_FORBIDDEN
assert client.login(username='******', password='******')
response = client.get(reverse('api:fieldbook_observation-list'))
assert len(response.data) == 8
def test_list(self):
client = Client()
response = client.get(reverse('api:assayplant-list'))
assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
response = client.get(
reverse('api:assayplant-detail', kwargs={'pk': 1}))
assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
def test_list(self):
client = Client()
response = client.get(reverse('api:group-list'))
assert response.status_code == status.HTTP_403_FORBIDDEN
client.login(username='******', password='******')
response = client.get(reverse('api:group-list'))
assert response.status_code == status.HTTP_200_OK
def test_search(self):
client = Client()
response = client.get(reverse('api:cvterm-list'))
assert len(response.data) > 64
response = client.get(reverse('api:cvterm-list'),
{'cv': 'biological_status'})
assert len(response.data) == 21
def setUp(self):
self.client = Client()
self.dog = Dog.objects.create(name='Fluffy', labels=['terrier'])
self.file = File.objects.create(file=SimpleUploadedFile(
name='test_image.jpg',
content=open('api/tests/test_doug_two.jpg', 'rb').read(),
content_type='image/jpeg'),
remark='test')
def test_no_projects_found(self):
user = User.objects.get(username="******")
c = Client()
c.force_authenticate(user=user)
response = c.get(reverse("projects-list"))
self.assertEqual(response.status_code, 200)
# response should return empty list
self.assertListEqual(response.data, [])
def test_successful_page_created(self):
c = Client()
user = User.objects.get(username="******")
c.force_authenticate(user=user)
proj = Project.objects.get(name="Keep Going")
response = c.post(self.reverseWrapper(proj.id), {"title": "Love"},
format="json")
self.assertEqual(response.status_code, 200)
def test_list(self):
client = Client()
url = reverse('api:cvterm-list')
response = client.get(url)
assert response.status_code == status.HTTP_200_OK
client.login(username='******', password='******')
response = client.get(url)
assert response.status_code == status.HTTP_200_OK
def test_validation_errors(self):
c = Client()
data = {
"email": "*****@*****.**",
"firstPassword": "******",
"secondPassword": "******"
}
response = c.post(reverse("sign-up"), data, format="json")
self.assertEqual(response.status_code, 400)
def test_no_project(self):
c = Client()
user = User.objects.get(username="******")
c.force_authenticate(user=user)
response_1 = c.get(self.urlReverse(105))
data_1 = {}
response_2 = c.put(self.urlReverse(105), [data_1], format="json")
self.assertEqual(response_1.status_code, 404)
self.assertEqual(response_2.status_code, 400)
def test_succesful_user(self):
c = Client()
data = {
"email": "*****@*****.**",
"firstPassword": "******",
"secondPassword": "******"
}
response = c.post(reverse("sign-up"), data, format="json")
self.assertEqual(response.status_code, 200)