def setUp(self):
load_states()
load_statutes()
settings.DEBUG = True
self.api_client = TestApiClient()
self.get_credentials()
#user creates all the groups and requests initially, user should always have edit perms unless another user takes that away
self.user = User.objects.create_user('john', '*****@*****.**',
'secret')
self.user.is_staff = True #someone has to be responsible
self.user.save()
self.usertwo = User.objects.create_user('yoko', '*****@*****.**',
'secret')
self.userthree = User.objects.create_user('ringo',
'*****@*****.**',
'secret')
self.post_data = {'name': 'A TEST GROUP'}
self.up, created = UserProfile.objects.get_or_create(user=self.user)
self.uptwo, created = UserProfile.objects.get_or_create(
user=self.usertwo)
self.upthree, created = UserProfile.objects.get_or_create(
user=self.userthree)
self.groupJSON = None
self.group = None
self.request = None
self.agency = None
self.agencyJSON = None
self.contact = None
self.contactJSON = None
self.government = None
self.governmentJSON = None
def testCreatingGenesetNotLoggedIn(self):
"""
Test that this fails and returns an Unauthorized response
"""
client = TestApiClient()
post_geneset_data = {
# Does not need user info because the API automatically gathers that from the request
'title': 'TestGeneset2',
'organism': '/api/v1/organism/h**o-sapiens',
'abstract': 'Second test geneset created by user.',
'public': False,
'annotations': {
55982: [20671152, 19583951],
18091: [8887666],
67087: [],
22410: []
},
'xrdb': 'Entrez',
'description': 'First version.',
}
# Try to create a geneset without being logged in, check for Unauthorized response
r1 = client.post('/api/v1/geneset',
format="json",
data=post_geneset_data)
self.assertHttpUnauthorized(r1)
class PersonResourceTestCase(ResourceTestCase):
def setUp(self):
super(PersonResourceTestCase, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.user = User.objects.get(id=1)
self.writeitinstance = WriteItInstance.objects.create(name=u"a test", slug=u"a-test", owner=self.user)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key': self.user.api_key.key}
def get_credentials(self):
credentials = self.create_apikey(username=self.user.username, api_key=self.user.api_key.key)
return credentials
def test_get_list_of_messages(self):
url = '/api/v1/person/'
response = self.api_client.get(url, authentication=self.get_credentials())
self.assertValidJSONResponse(response)
persons = self.deserialize(response)['objects']
self.assertEqual(len(persons), Person.objects.count()) # All the instances
def test_unauthorized_list_of_persons(self):
url = '/api/v1/person/'
response = self.api_client.get(url)
self.assertHttpUnauthorized(response)
def test_the_remote_url_of_the_person_points_to_its_popit_instance(self):
url = '/api/v1/person/'
response = self.api_client.get(url, authentication=self.get_credentials())
persons = self.deserialize(response)['objects']
self.assertEquals(persons[0]['popit_url'], persons[0]['resource_uri'])
def setUp(self):
super(PagePaginationTestCase, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.user = User.objects.get(id=1)
# self.writeitinstance = WriteItInstance.objects.create(name="a test", slug="a-test", owner=self.user)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key': self.user.api_key.key}
class PersonResourceTestCase(ResourceTestCase):
def setUp(self):
super(PersonResourceTestCase, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.user = User.objects.get(id=1)
self.writeitinstance = WriteItInstance.objects.create(name=u"a test", slug=u"a-test", owner=self.user)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key': self.user.api_key.key}
def get_credentials(self):
credentials = self.create_apikey(username=self.user.username, api_key=self.user.api_key.key)
return credentials
def test_get_list_of_messages(self):
url = '/api/v1/person/'
response = self.api_client.get(url, authentication=self.get_credentials())
self.assertValidJSONResponse(response)
persons = self.deserialize(response)['objects']
self.assertEqual(len(persons), Person.objects.count()) # All the instances
def test_unauthorized_list_of_persons(self):
url = '/api/v1/person/'
response = self.api_client.get(url)
self.assertHttpUnauthorized(response)
def test_the_remote_url_of_the_person_points_to_its_popit_instance(self):
url = '/api/v1/person/'
response = self.api_client.get(url, authentication=self.get_credentials())
persons = self.deserialize(response)['objects']
self.assertEquals(persons[0]['popit_url'], persons[0]['resource_uri'])
def setUp(self):
self.api_client = TestApiClient()
self.username = '******'
self.password = '******'
# create a user
self.user = hydroshare.create_account(
'*****@*****.**',
username=self.username,
first_name='Tian',
last_name='Gan',
superuser=False,
password=self.password,
groups=[]
)
# create a resource
self.res = hydroshare.create_resource(
'GenericResource',
self.user,
'My resource'
)
# create a group
self.group = hydroshare.create_group(
'Test group',
members=[],
owners=[self.user1]
)
def setUp(self):
super(HandleBounces, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.api_client = TestApiClient()
self.user = User.objects.get(id=1)
self.outbound_message = OutboundMessage.objects.get(id=1)
self.identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
class HandleBounces(ResourceTestCase):
def setUp(self):
super(HandleBounces, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.api_client = TestApiClient()
self.user = User.objects.get(id=1)
self.outbound_message = OutboundMessage.objects.get(id=1)
self.identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
def get_credentials(self):
credentials = self.create_apikey(username=self.user.username, api_key=self.user.api_key.key)
return credentials
def test_handle_bounces_endpoint(self):
url = '/api/v1/handle_bounce/'
bounce_data = {
'key': self.identifier.key,
}
resp = self.api_client.post(url, data=bounce_data, authentication=self.get_credentials())
self.assertHttpCreated(resp)
def test_handle_bounces_sets_the_contact_to_bounced(self):
url = '/api/v1/handle_bounce/'
bounce_data = {
'key': self.identifier.key,
}
self.api_client.post(url, data=bounce_data, authentication=self.get_credentials())
self.assertTrue(self.outbound_message.contact.is_bounced)
def setUp(self):
self.api_client = TestApiClient()
self.post_id = 1
self.post_data = {'post': {'pk': self.post_id, 'text': 'New comment'}}
self.detail_url = '/api/v1/comment/{0}/'.format(self.post_id)
self.list_url = '/api/v1/comment/'
self.serializer = Serializer()
class CreateOrListGroupsTest(ResourceTestCase):
serializer = Serializer()
def setUp(self):
self.api_client = TestApiClient()
self.user = hydroshare.create_account(
'*****@*****.**',
username='******',
first_name='User0_FirstName',
last_name='User0_LastName',
superuser=True,
password='******'
)
g0=hydroshare.create_group(name="group0")
g1=hydroshare.create_group(name="group1")
g2=hydroshare.create_group(name="group2")
self.user.groups.add(g0,g1,g2)
self.g_ids=[g0.id,g1.id,g2.id]
self.groups_url_base = '/hsapi/groups/'
self.api_client.client.login(username=self.user.username, password=self.user.password)
def tearDown(self):
Group.objects.all().delete()
User.objects.all().delete()
def test_create_group(self):
post_data = {'name': 'newgroup'}
resp = self.api_client.post(self.groups_url_base, data=post_data)
self.assertHttpCreated(resp)
grouplist = Group.objects.all()
num_of_groups=len(grouplist)
self.assertTrue(any(Group.objects.filter(name='newgroup')))
self.assertEqual(num_of_groups, 4)
def test_list_groups(self):
query = self.serialize({'user': self.user.id})
get_data = {'query': query}
resp = self.api_client.get(self.groups_url_base, data=get_data)
print resp
self.assertEqual(resp.status_code, 200)
groups = self.deserialize(resp)
new_ids = []
for num in range(len(groups)):
new_ids.append(groups[num]['id'])
self.assertTrue(Group.objects.filter(user='******'.format(num)).exists())
self.assertEqual(str(groups[num]['name']), 'group{0}'.format(num))c
self.assertEqual(sorted(self.g_ids), sorted(new_ids))
class CheckTokenTest(ResourceTestCase):
def setUp(self):
super(CheckTokenTest, self).setUp()
self.client = TestApiClient()
self.endpoint = '/api/v1/token/'
self.format = 'json'
# Create one user
self.user = User(username="******")
self.user.save()
# Create on token
self.token = UserToken(user=self.user)
self.token.save()
# check for the token ttl
def test_check_token(self):
url = "%s?token=%s" % (self.endpoint, self.token.token)
request = self.client.get(url, self.format)
self.assertValidJSONResponse(request)
# check for the WRONG token ttl
def test_check_wrong_token(self):
url = "%s?token=%s" % (self.endpoint, "not-a-valid-token")
self.assertHttpUnauthorized(self.client.get(url, self.format))
# check for the NO token ttl
def test_check_no_token(self):
self.assertHttpUnauthorized(self.client.get(self.endpoint, self.format))
class ApplicationTest(ResourceTestCase):
def setUp(self):
super(ApplicationTest, self).setUp()
self.client = TestApiClient()
self.endpoint = '/api/v1/apps/'
self.format = 'json'
# Create one user
self.user = User(username="******")
self.user.save()
# Create on token
self.token = UserToken(user=self.user)
self.token.save()
# list apps
def test_get_apps(self):
url = "%s?token=%s" % (self.endpoint, self.token.token)
request = self.client.get(url, self.format)
self.assertValidJSONResponse(request)
# list apps details
def test_get_apps_details(self):
app_id = Application.objects.all()[0].id
url = "%s%d/?token=%s" % (self.endpoint, app_id, self.token.token)
request = self.client.get(url, self.format)
self.assertValidJSONResponse(request)
def setUp(self):
super(AnswersResourceTestCase, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.writeitinstance = WriteItInstance.objects.get(id=1)
self.user = User.objects.get(id=1)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key': self.user.api_key.key}
class HandleBounces(ResourceTestCase):
def setUp(self):
super(HandleBounces, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.api_client = TestApiClient()
self.user = User.objects.all()[0]
self.outbound_message = OutboundMessage.objects.all()[0]
self.identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
def get_credentials(self):
credentials = self.create_apikey(username=self.user.username, api_key=self.user.api_key.key)
return credentials
def test_handle_bounces_endpoint(self):
url = '/api/v1/handle_bounce/'
bounce_data = {
'key':self.identifier.key
}
resp = self.api_client.post(url, data=bounce_data, authentication=self.get_credentials())
self.assertHttpCreated(resp)
def test_handle_bounces_sets_the_contact_to_bounced(self):
url = '/api/v1/handle_bounce/'
bounce_data = {
'key':self.identifier.key
}
resp = self.api_client.post(url, data=bounce_data, authentication=self.get_credentials())
self.assertTrue(self.outbound_message.contact.is_bounced)
def setUp(self):
# Generic
self.api_client = TestApiClient()
self.serializer = Serializer()
# API List data
self.list_url = '/api/v1/post/'
# API requests data
self.project_part_id = 1
self.post_id = 1
self.detail_url = '/api/v1/post/{0}/'.format(self.post_id)
self.project_part_query = '='.join(
['?project_part', str(self.project_part_id)])
self.post_data = {
'content': 'My post',
'project_part': {
'pk': self.project_part_id
}
}
# Open API request data
self.open_project_part_id = 2
self.open_post_id = 2
self.open_detail_url = '/api/v1/post/{0}/'.format(self.open_post_id)
self.open_project_part_query = '='.join(
['?project_part', str(self.open_project_part_id)])
self.open_post_data = {
'content': 'My post',
'project_part': {
'pk': self.open_project_part_id
}
}
def setUp(self):
super(Partner_v1__PhotoResourceTest, self).setUp()
# we need a custom serializer for multipart uploads
self.api_client = TestApiClient(serializer=MultipartSerializer())
self.api_key = 'key123_partner'
self.api_secret = 'sec123_partner'
self.api_account_1 = ApiAccount.objects.all()[0]
self.events = Event.objects.filter(
account__api_account=self.api_account_1)
self.photos = Photo.objects.filter(
event__account__api_account=self.api_account_1)
self.photo_1 = self.photos[0]
# The data we'll send on POST requests
filename = 'trashcat.jpg'
filepath = os.path.join(settings.PROJECT_PATH, 'api', 'assets',
filename)
f = open(filepath, 'rb')
self.post_data = {
'event': '/partner_v1/event/{0}/'.format(self.events[0].pk),
'caption': 'My super awesome caption!',
'image': {
'filename': filename,
'data': f.read(),
}
}
def setUp(self):
#Tastypie stuff
super(TestDeploymentResource, self).setUp()
self.bob_api_client = TestApiClient()
self.bill_api_client = TestApiClient()
self.anon_api_client = TestApiClient()
# Create a user bob.
self.user_bob_username = '******'
self.user_bob_password = '******'
self.user_bob = User.objects.create_user(self.user_bob_username,
'*****@*****.**',
self.user_bob_password)
# Create a user bob.
self.user_bill_username = '******'
self.user_bill_password = '******'
self.user_bill = User.objects.create_user(self.user_bill_username,
'*****@*****.**',
self.user_bill_password)
self.bob_api_client.client.login(username='******', password='******')
self.bill_api_client.client.login(username='******', password='******')
#assign users to the Public group
public_group, created = Group.objects.get_or_create(name='Public')
self.user_bob.groups.add(public_group)
self.user_bill.groups.add(public_group)
guardian.utils.get_anonymous_user().groups.add(public_group)
#make a couple of campaigns and save
self.campaign_bobs = mommy.make_one('catamidb.Campaign', id=1)
self.campaign_bills = mommy.make_one('catamidb.Campaign', id=2)
#make a deployments
self.deployment_bobs = mommy.make_recipe('catamidb.Deployment1',
id=1,
campaign=self.campaign_bobs)
self.deployment_bills = mommy.make_recipe('catamidb.Deployment2',
id=2,
campaign=self.campaign_bills)
#assign this one to bob
authorization.apply_campaign_permissions(
self.user_bob, self.campaign_bobs)
#assign this one to bill
authorization.apply_campaign_permissions(self.user_bill,
self.campaign_bills)
#the API url for deployments
self.deployment_url = '/api/dev/deployment/'
#some post data for testing deployment creation
self.post_data = {
'type': 'AUV',
'operator': 'XXX',
}
def test_put_queue(self):
""" Performs PUT request for queue id=2"""
client = TestApiClient()
response = client.put('/api/queue/2/', data={'place': 990})
# 204 == Action Performed -> No Data
self.assertEqual(response.status_code, 204)
def test_delete_queue_item(self):
""" Performs DELETE request to queue id 2"""
client = TestApiClient()
response = client.delete('/api/queue/2/', data={'format': 'json'})
# 204 == Action Performed -> No Data
self.assertEqual(response.status_code, 204)
def setUp(self):
super(ApiTestCase, self).setUp()
self.user = User.objects.create_user(username='******',
password='******',
email='*****@*****.**')
Election.objects.filter(owner=self.user).delete()
self.not_user = User.objects.create_user(username='******',
password='******',
email='*****@*****.**')
self.election, created = Election.objects.get_or_create(name='BarBaz',
owner=self.user,
slug='barbaz',
published=True)
self.election.category_set.all().delete()
self.election.personaldata_set.all().delete()
self.personal_data1 = PersonalData.objects.create(label=u"Age", election=self.election)
self.personal_data2 = PersonalData.objects.create(label=u"Profession", election=self.election)
self.category1 = Category.objects.create(name=u"Pets and phisicians", election=self.election, slug="pets")
self.category2 = Category.objects.create(name=u"language problemas ", election=self.election, slug="language")
self.question1 = Question.objects.create(category=self.category1, question=u"¿Cuál es el nombre de la ferocidad?")
self.answer1 = Answer.objects.create(caption=u"Fiera", question=self.question1)
self.answer2 = Answer.objects.create(caption=u"Ratón inteligente pero barza", question=self.question1)
self.question2 = Question.objects.create(category=self.category1, question=u"¿Which one is your favourite colour?")
self.answer3 = Answer.objects.create(caption=u"apple", question=self.question2)
self.answer4 = Answer.objects.create(caption=u"orange", question=self.question2)
self.question3 = Question.objects.create(category=self.category2, question=u"¿!¿Why don't you speak proper english?!?")
self.answer5 = Answer.objects.create(caption=u"Hablo inglés perfectamente", question=self.question3)
self.answer6 = Answer.objects.create(caption=u"I don't speak any english", question=self.question3)
self.election2, created = Election.objects.get_or_create(name='BarBaz2',
owner=self.not_user,
slug='barbaz2',
published=True)
self.candidate = Candidate.objects.create(
name='Bar Baz',
election=self.election)
self.candidate.associate_answer(self.answer2)
self.age1 = PersonalDataCandidate.objects.create(personal_data=self.personal_data1, candidate=self.candidate, value=u"2")
self.profession1 = PersonalDataCandidate.objects.create(personal_data=self.personal_data2, candidate=self.candidate, value=u"Perro")
self.candidate2 = Candidate.objects.create(
name='Fieri',
election=self.election)
self.candidate3 = Candidate.objects.create(
name='Ratón 1',
election=self.election2)
self.candidate3.personal_data.all().delete()
self.election3, created = Election.objects.get_or_create(name='BarBaz3',
owner=self.user,
slug='barbaz3',
published=True)
self.ferocious_link, created = Link.objects.get_or_create(
name='@fiera',
url='http://www.twitter.com/fiera',
candidate=self.candidate2)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key':self.user.api_key.key}
def setUp(self):
super(HelpResourceTest, self).setUp()
# TODO: If we end up supporting the PATCH method, use our
# FixedTestApiClient instead of the default
self.api_client = TestApiClient()
self.username = '******'
self.password = '******'
self.user = User.objects.create_user(self.username, '*****@*****.**',
self.password)
def setUp(self):
#Tastypie stuff
super(TestCampaignResource, self).setUp()
self.bob_api_client = TestApiClient()
self.bill_api_client = TestApiClient()
self.anon_api_client = TestApiClient()
# Create a user bob.
self.user_bob_username = '******'
self.user_bob_password = '******'
self.user_bob = User.objects.create_user(self.user_bob_username,
'*****@*****.**',
self.user_bob_password)
# Create a user bob.
self.user_bill_username = '******'
self.user_bill_password = '******'
self.user_bill = User.objects.create_user(self.user_bill_username,
'*****@*****.**',
self.user_bill_password)
self.bob_api_client.client.login(username='******', password='******')
self.bill_api_client.client.login(username='******', password='******')
#assign users to the Public group
public_group, created = Group.objects.get_or_create(name='Public')
self.user_bob.groups.add(public_group)
self.user_bill.groups.add(public_group)
guardian.utils.get_anonymous_user().groups.add(public_group)
#make a couple of campaigns and save
self.campaign_bobs = mommy.make_one('catamidb.Campaign', id=1)
self.campaign_bills = mommy.make_one('catamidb.Campaign', id=2)
#assign this one to bob
authorization.apply_campaign_permissions(
self.user_bob, self.campaign_bobs)
#assign this one to bill
authorization.apply_campaign_permissions(
self.user_bill, self.campaign_bills)
#the API url for campaigns
self.campaign_url = '/api/dev/campaign/'
#some post data for testing campaign creation
self.post_data = {
'short_name': 'Blah',
'description': 'Blah',
'associated_researchers': 'Blah',
'associated_publications': 'Blah',
'associated_research_grant': 'Blah',
'date_start': '2012-05-01',
'date_end': '2012-05-01',
'contact_person': 'Blah',
}
def setUp(self):
self.api_client = TestApiClient()
user = hydroshare.create_account(
'*****@*****.**',
username='******',
first_name='User0_FirstName',
last_name='User0_LastName',
)
self.res = hydroshare.create_resource('GenericResource', user, 'myres')
def test_put_vars(self):
""" Performs PUT request for vars id=1"""
client = TestApiClient()
response = client.put('/api/variables/1/', data={'values_used': 150})
# 204 == Action Performed -> No Data
self.assertEqual(response.status_code, 204)
def setUp(self):
# Tastypie stuff
super(TestCameraResource, self).setUp()
self.bob_api_client = TestApiClient()
self.bill_api_client = TestApiClient()
self.anon_api_client = TestApiClient()
# Create a user bob.
self.user_bob_username = "******"
self.user_bob_password = "******"
self.user_bob = User.objects.create_user(self.user_bob_username, "*****@*****.**", self.user_bob_password)
# Create a user bob.
self.user_bill_username = "******"
self.user_bill_password = "******"
self.user_bill = User.objects.create_user(
self.user_bill_username, "*****@*****.**", self.user_bill_password
)
self.bob_api_client.client.login(username="******", password="******")
self.bill_api_client.client.login(username="******", password="******")
# assign users to the Public group
public_group, created = Group.objects.get_or_create(name="Public")
self.user_bob.groups.add(public_group)
self.user_bill.groups.add(public_group)
guardian.utils.get_anonymous_user().groups.add(public_group)
# make a couple of campaigns and save
self.campaign_bobs = mommy.make_one("catamidb.Campaign", id=1)
self.campaign_bills = mommy.make_one("catamidb.Campaign", id=2)
# make a deployments
self.deployment_bobs = mommy.make_recipe("catamidb.Deployment1", id=1, campaign=self.campaign_bobs)
self.deployment_bills = mommy.make_recipe("catamidb.Deployment2", id=2, campaign=self.campaign_bills)
# make images
self.image_bobs = mommy.make_recipe("catamidb.Image1", id=1, deployment=self.deployment_bobs)
self.image_bills = mommy.make_recipe("catamidb.Image2", id=2, deployment=self.deployment_bills)
# make cameras
self.camera_bobs = mommy.make_one("catamidb.Camera", id=1, image=self.image_bobs)
self.camera_bills = mommy.make_one("catamidb.Camera", id=2, image=self.image_bills)
# assign this one to bob
authorization.apply_campaign_permissions(self.user_bob, self.campaign_bobs)
# assign this one to bill
authorization.apply_campaign_permissions(self.user_bill, self.campaign_bills)
# the API url for deployments
self.camera_url = "/api/dev/camera/"
# some post data for testing camera creation
self.post_data = []
def test_put_vars_for_current(self):
""" Performs PUT request for mag-current value """
client = TestApiClient()
response = client.put('/api/variables/2/', data={'values_used': 215})
# 204 == Action Performed -> No Data
self.assertEqual(response.status_code, 204)
def setUp(self):
self.api_client = TestApiClient()
self.user = hydroshare.create_account(
'*****@*****.**',
username='******',
first_name='User_FirstName',
last_name='User_LastName',
)
self.url_base = '/hsapi/capabilities/'
def setUp(self):
super(PublicMessagesInAPI, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.user = User.objects.get(id=1)
self.writeitinstance = WriteItInstance.objects.create(name="a test", slug="a-test", owner=self.user)
self.writeitinstance.config.moderation_needed_in_all_messages = True
self.writeitinstance.config.save()
self.person1 = Person.objects.get(id=1)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key': self.user.api_key.key}
def testGETInvite(self):
"""
Test GET invite with a logged in user.
Only POST is allowed, so this should return 405.
"""
client = TestApiClient()
client.client.login(username=self.u1, password=self.p1)
resp = client.get('/api/v1/user/invite', format="json", data={'email': self.e2})
self.assertHttpMethodNotAllowed(resp)
def test_api(username, password):
api_client = TestApiClient()
result = api_client.client.login(username=username, password=password)
#print(api_client.get('http://localhost:8000/sensorimotordb/api/v1/visuomotor_classification_analysis_results/?analysis__experiment=73', format='json'))
start = time.time()
#print(api_client.get('http://localhost:8000/sensorimotordb/api/v1/full_recording_trial/?condition__in=432,433,437,438,442,443,434,439,444,430,435,440,431,436,441&limit=0', format='json'))
#print(api_client.get('http://localhost:8000/sensorimotordb/api/v1/full_recording_trial/?unit_recordings__unit=518&limit=0', format='json'))
print(api_client.get('http://localhost:8000/sensorimotordb/api/v1/event/?trial__condition__experiment=108', format='json'))
end = time.time()
print(end - start)
def testCheckAuthorizationNotLoggedIn(self):
"""
Check that a user has access to NO user objects if they are not logged
in.
"""
client = TestApiClient()
resp = client.get('/api/v1/user', format="json")
self.assertValidJSONResponse(resp)
self.assertEqual(self.deserialize(resp)['objects'], [])
def testRejectCollaboration(self):
"""
Test that one user rejecting an existing collaboration destroys the collaboration.
The user objects returned should each have no relationship with each other after a
collaboration + reject.
"""
c1 = TestApiClient()
c1.client.login(username=self.u1, password=self.p1)
r1 = c1.post('/api/v1/user/invite', format="json", data={'email': self.e2})
self.assertValidJSONResponse(r1)
c2 = TestApiClient()
c2.client.login(username=self.u2, password=self.p2)
r2 = c2.post('/api/v1/user/invite', format="json", data={'email': self.e1})
self.assertValidJSONResponse(r2)
# Collaboration Exists
self.assertListEqual(list(get_collaborators(self.owner)), [self.other])
self.assertListEqual(list(get_collaborators(self.other)), [self.owner])
c2 = TestApiClient()
c2.client.login(username=self.u2, password=self.p2)
r2 = c2.post('/api/v1/user/reject', format="json", data={'email': self.e1})
self.assertValidJSONResponse(r2)
# Collaboration no longer exists.
self.assertListEqual(list(get_collaborators(self.owner)), [])
self.assertListEqual(list(get_collaborators(self.other)), [])
self.assertListEqual(list(get_invites(self.owner)), [])
self.assertListEqual(list(get_inviteds(self.other)), [])
def testInviteNoContent(self):
"""
Test invite with a logged in user but no content.
The user object should be returned without any invites.
"""
client = TestApiClient()
client.client.login(username=self.u1, password=self.p1)
resp = client.post('/api/v1/user/invite', format="json")
self.assertValidJSONResponse(resp)
self.assertEqual(self.deserialize(resp)['invites'], [])
def setUp(self):
super(ApiResourceTestCase, self).setUp()
self.api_client = TestApiClient(serializer=MultipartSerializer())
self._media_org = settings.MEDIA_ROOT
self._media_tmp = settings.MEDIA_ROOT = tempfile.mkdtemp()
try:
self.list_url = "{0}/{1}/".format(self.url_base, self.resource.Meta.resource_name)
except:
pass
def setUp(self):
super(FavoriteTest, self).setUp()
self.adm_un = "admin"
self.adm_pw = "admin"
create_models(type="document")
self.list_url = reverse('api_dispatch_list',
kwargs={
'api_name': 'api',
'resource_name': 'favorites'
})
self.api_client = TestApiClient()
class RefTSGetSites(ResourceTestCase):
def setUp(self):
self.serializer = Serializer()
self.logger = logging.getLogger(__name__)
self.api_client = TestApiClient()
self.client = Client()
self.username = '******'
self.password = '******'
self.group, _ = Group.objects.get_or_create(name='Hydroshare Author')
# create a user to be used for creating the resource
self.user_creator = hydroshare.create_account(
'*****@*****.**',
username=self.username,
first_name='Creator_FirstName',
last_name='Creator_LastName',
superuser=False,
password=self.password,
groups=[self.group]
)
self.wsdl_url_swe = "http://hydroportal.cuahsi.org/SwedishMonitoringData/webapp/cuahsi_1_1.asmx?WSDL"
self.wsdl_url_wwo = "http://worldwater.byu.edu/app/index.php/default/services/cuahsi_1_1.asmx?WSDL"
self.rest_url = "http://worldwater.byu.edu/interactive/sandbox/services/index.php/cuahsi_1_1.asmx/GetValues?location=WWO:S-PRHD&variable=WWO:JSWL&startDate=&endDate="
self.site_code_swe = "wq2371"
self.site_code_wwo = "S-PRHD"
self.post_data = {
'title': 'My REST API-created resource',
'resource_type': 'GenericResource'
}
def tearDown(self):
User.objects.all().delete()
GenericResource.objects.all().delete()
#TODO: This throws an encoding error...
# def test_get_sites_wwo(self):
# resp = self.api_client.get("/hsapi/_internal/search-sites/?wsdl_url="+self.wsdl_url_wwo)
# self.assertEqual(resp.status_code, 200)
def test_get_sites_swedish(self):
resp = self.api_client.get("/hsapi/_internal/search-sites/?url="+self.wsdl_url_swe)
self.assertEqual(resp.status_code, 200)
def test_get_variables_wwo(self):
resp = self.api_client.get("/hsapi/_internal/search-variables/?url="+self.wsdl_url_wwo+"&site="+self.site_code_wwo)
self.assertEqual(resp.status_code, 200)
self.assertTrue('Water level' in resp.content)
def setUp(self):
# Tastypie stuff
super(TestCampaignResource, self).setUp()
self.bob_api_client = TestApiClient()
self.bill_api_client = TestApiClient()
self.anon_api_client = TestApiClient()
# Create a user bob.
self.user_bob_username = "******"
self.user_bob_password = "******"
self.user_bob = User.objects.create_user(self.user_bob_username, "*****@*****.**", self.user_bob_password)
# Create a user bob.
self.user_bill_username = "******"
self.user_bill_password = "******"
self.user_bill = User.objects.create_user(
self.user_bill_username, "*****@*****.**", self.user_bill_password
)
self.bob_api_client.client.login(username="******", password="******")
self.bill_api_client.client.login(username="******", password="******")
# assign users to the Public group
public_group, created = Group.objects.get_or_create(name="Public")
self.user_bob.groups.add(public_group)
self.user_bill.groups.add(public_group)
guardian.utils.get_anonymous_user().groups.add(public_group)
# make a couple of campaigns and save
self.campaign_bobs = mommy.make_one("catamidb.Campaign")
self.campaign_bills = mommy.make_one("catamidb.Campaign")
# assign this one to bob
authorization.apply_campaign_permissions(self.user_bob, self.campaign_bobs)
# assign this one to bill
authorization.apply_campaign_permissions(self.user_bill, self.campaign_bills)
# the API url for campaigns
self.campaign_url = "/api/dev/campaign/"
# some post data for testing campaign creation
self.post_data = {
"short_name": "Blah",
"description": "Blah",
"associated_researchers": "Blah",
"associated_publications": "Blah",
"associated_research_grant": "Blah",
"date_start": "2012-05-01",
"date_end": "2012-05-01",
"contact_person": "Blah",
}
class RefTSSnotel(ResourceTestCase):
def setUp(self):
self.serializer = Serializer()
self.logger = logging.getLogger(__name__)
self.api_client = TestApiClient()
self.client = Client()
self.username = '******'
self.password = '******'
self.group, _ = Group.objects.get_or_create(name='Hydroshare Author')
# create a user to be used for creating the resource
self.user_creator = hydroshare.create_account(
'*****@*****.**',
username=self.username,
first_name='Creator_FirstName',
last_name='Creator_LastName',
superuser=False,
password=self.password,
groups=[self.group]
)
self.wsdl_url = "http://worldwater.byu.edu/interactive/snotel/services/index.php/cuahsi_1_1.asmx?WSDL"
self.rest_url = "http://worldwater.byu.edu/interactive/snotel/services/index.php/cuahsi_1_1.asmx/GetValuesObject?location=SNOTEL:1039&variable=SNOTEL:WTEQ&startDate=2014-10-01&endDate=2015-03-19"
self.time_series_base_rest = "/hsapi/_internal/time-series-from-service/?ref_type=rest&service_url="
self.time_series_base_soap = "/hsapi/_internal/time-series-from-service/?ref_type=soap&service_url="
self.site_code_swe = "wq2371"
self.site_code_wwo = "S-PRHD"
self.post_data = {
'title': 'My REST API-created resource',
'resource_type': 'GenericResource'
}
def tearDown(self):
User.objects.all().delete()
GenericResource.objects.all().delete()
def test_time_series_from_service_rest(self):
url = urllib.quote(self.rest_url)
resp = self.api_client.get(self.time_series_base_rest+url)
self.assertEqual(resp.status_code, 200)
self.assertTrue('visualization' in resp.content)
def test_time_series_from_service_soap(self):
url = urllib.quote(self.wsdl_url)
resp = self.api_client.get(self.time_series_base_soap+url+"&site=823&variable=WTEQ")
self.assertEqual(resp.status_code, 200)
self.assertTrue('visualization' in resp.content)
class JobTest(ResourceTestCase):
def setUp(self):
super(JobTest, self).setUp()
self.client = TestApiClient()
self.endpoint = '/api/v1/jobs/'
self.format = 'json'
# Create one user
self.user = User(username="******")
self.user.save()
# Create on token
self.token = UserToken(user=self.user)
self.token.save()
# create a job
self.job = Job(user=self.user, application=Application.objects.all()[0])
self.job.save()
def test_get_job_list(self):
url = "%s?token=%s" % (self.endpoint, self.token.token)
request = self.client.get(url, self.format)
self.assertValidJSONResponse(request)
def test_get_job_detail(self):
url = "%s%d/?token=%s" % (self.endpoint, self.job.id, self.token.token)
request = self.client.get(url, self.format)
self.assertValidJSONResponse(request)
def test_post_job(self):
data = {"application" : "/api/v1/apps/1/"}
url = "%s?token=%s" % (self.endpoint, self.token.token)
self.assertHttpCreated(self.client.post(url, self.format, data=data))
def test_patch_job(self):
job = Job(user=self.user, application=Application.objects.all()[0])
job.save()
data = {"progress":"50"}
url = "%s%d/?token=%s" % (self.endpoint, job.id, self.token.token)
resp = self.client.patch(url, self.format, data=data)
self.assertHttpAccepted(resp)
def test_delete_job(self):
job = Job(user=self.user, application=Application.objects.all()[0])
job.save()
url = "%s%d/?token=%s" % (self.endpoint, job.id, self.token.token)
self.assertHttpAccepted(self.client.delete(url, self.format))
class TestAnnotationCodesResource(ResourceTestCase):
def setUp(self):
#Tastypie stuff
super(TestAnnotationCodesResource, self).setUp()
#make some codes
self.codes = mommy.make_many(AnnotationCodes, 10)
self.bob_api_client = TestApiClient()
self.anon_api_client = TestApiClient()
# Create a user bob.
self.user_bob_username = '******'
self.user_bob_password = '******'
self.user_bob = User.objects.create_user(self.user_bob_username,
'*****@*****.**',
self.user_bob_password)
self.bob_api_client.client.login(username='******', password='******')
#end point for the API
self.annotation_code_url = '/api/dev/annotation_code/'
def test_get_codes_anon(self):
#check annon can get all the codes
response = self.anon_api_client.get(self.annotation_code_url, format='json')
self.assertValidJSONResponse(response)
self.assertEqual(len(self.deserialize(response)), len(self.codes))
#check annon can get the real code value
for code in self.codes:
response = self.anon_api_client.get(self.annotation_code_url + code.id.__str__() +"/", format='json')
self.assertValidJSONResponse(response)
code_from_request = self.deserialize(response)['caab_code'].__str__()
self.assertEqual(code.caab_code.__str__(), code_from_request)
#check bob can get all the codes
response = self.bob_api_client.get(self.annotation_code_url, format='json')
self.assertValidJSONResponse(response)
self.assertEqual(len(self.deserialize(response)), len(self.codes))
#check bob can get the real code value
for code in self.codes:
response = self.bob_api_client.get(self.annotation_code_url + code.id.__str__() +"/", format='json')
self.assertValidJSONResponse(response)
code_from_request = self.deserialize(response)['caab_code'].__str__()
self.assertEqual(code.caab_code.__str__(), code_from_request)
def setUp(self):
#Tastypie stuff
super(TestCollectionResource, self).setUp()
self.bob_api_client = TestApiClient()
self.bill_api_client = TestApiClient()
self.anon_api_client = TestApiClient()
# Create a user bob.
self.user_bob_username = '******'
self.user_bob_password = '******'
self.user_bob = User.objects.create_user(self.user_bob_username,
'*****@*****.**',
self.user_bob_password)
# Create a user bob.
self.user_bill_username = '******'
self.user_bill_password = '******'
self.user_bill = User.objects.create_user(self.user_bill_username,
'*****@*****.**',
self.user_bill_password)
self.bob_api_client.client.login(username='******', password='******')
self.bill_api_client.client.login(username='******', password='******')
#assign users to the Public group
public_group, created = Group.objects.get_or_create(name='Public')
self.user_bob.groups.add(public_group)
self.user_bill.groups.add(public_group)
guardian.utils.get_anonymous_user().groups.add(public_group)
#make a couple of collections and save
self.collection_bobs = mommy.make_recipe('collection.collection1', id=1, owner=self.user_bob)
self.collection_bills = mommy.make_recipe('collection.collection2', id=2, owner=self.user_bill)
#assign this one to bob
authorization.apply_collection_permissions(
self.user_bob, self.collection_bobs)
#assign this one to bill
authorization.apply_collection_permissions(
self.user_bill, self.collection_bills)
#the API url for campaigns
self.collection_url = '/api/dev/collection/'
#some post data for testing collection creation
self.post_data = {}
def setUp(self):
super(MessageResourceTestCase,self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.user = User.objects.all()[0]
self.writeitinstance = WriteItInstance.objects.create(name=u"a test", slug=u"a-test", owner=self.user)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key':self.user.api_key.key}
def setUp(self):
load_states()
load_statutes()
settings.DEBUG = True
self.api_client = TestApiClient()
self.get_credentials()
#user creates all the groups and requests initially, user should always have edit perms unless another user takes that away
self.user = User.objects.create_user('john', '*****@*****.**', 'secret')
self.user.is_staff = True#someone has to be responsible
self.user.save()
self.usertwo = User.objects.create_user('yoko', '*****@*****.**', 'secret')
self.userthree = User.objects.create_user('ringo', '*****@*****.**', 'secret')
self.post_data = {
'name': 'A TEST GROUP'
}
self.up, created = UserProfile.objects.get_or_create(user=self.user)
self.uptwo, created = UserProfile.objects.get_or_create(user=self.usertwo)
self.upthree, created = UserProfile.objects.get_or_create(user=self.userthree)
self.groupJSON = None
self.group = None
self.request = None
self.agency = None
self.agencyJSON = None
self.contact = None
self.contactJSON = None
self.government = None
self.governmentJSON = None
def setUp(self):
super(MessagesPerInstanceTestCase,self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.user = User.objects.all()[0]
self.writeitinstance = WriteItInstance.objects.create(name=u"a test", slug=u"a-test", owner=self.user)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key':self.user.api_key.key}
#creating messages
self.pedro = Person.objects.all()[0]
self.message1 = Message.objects.create(content = 'Content 1',
author_name='Felipe',
author_email="*****@*****.**",
subject='Fiera es una perra feroz',
writeitinstance= self.writeitinstance,
persons = [self.pedro])
#Confirmating
Confirmation.objects.create(message=self.message1)
self.message1.recently_confirmated()
#Confirmating
self.marcel = Person.objects.all()[1]
self.message2 = Message.objects.create(content = 'Content 1',
author_name='Felipe',
author_email="*****@*****.**",
subject='Fiera es una perra feroz',
writeitinstance= self.writeitinstance,
persons = [self.marcel])
#Confirmating message 2
Confirmation.objects.create(message=self.message2)
self.message2.recently_confirmated()
def setUp(self):
super(HandleBounces, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.api_client = TestApiClient()
self.user = User.objects.all()[0]
self.outbound_message = OutboundMessage.objects.all()[0]
self.identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
def setUp(self):
super(AnswersResourceTestCase, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.writeitinstance = WriteItInstance.objects.get(id=1)
self.user = User.objects.get(id=1)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key': self.user.api_key.key}
def setUp(self):
super(AnswersResourceTestCase, self).setUp()
call_command("loaddata", "example_data", verbosity=0)
self.writeitinstance = WriteItInstance.objects.get(id=1)
self.user = User.objects.get(id=1)
self.api_client = TestApiClient()
self.data = {"format": "json", "username": self.user.username, "api_key": self.user.api_key.key}
def setUp(self):
self.serializer = Serializer()
self.logger = logging.getLogger(__name__)
self.api_client = TestApiClient()
self.client = Client()
self.username = '******'
self.password = '******'
self.group, _ = Group.objects.get_or_create(name='Hydroshare Author')
# create a user to be used for creating the resource
self.user_creator = hydroshare.create_account(
'*****@*****.**',
username=self.username,
first_name='Creator_FirstName',
last_name='Creator_LastName',
superuser=False,
password=self.password,
groups=[self.group]
)
self.wsdl_url = "http://worldwater.byu.edu/interactive/snotel/services/index.php/cuahsi_1_1.asmx?WSDL"
self.rest_url = "http://worldwater.byu.edu/interactive/snotel/services/index.php/cuahsi_1_1.asmx/GetValuesObject?location=SNOTEL:1039&variable=SNOTEL:WTEQ&startDate=2014-10-01&endDate=2015-03-19"
self.time_series_base_rest = "/hsapi/_internal/time-series-from-service/?ref_type=rest&service_url="
self.time_series_base_soap = "/hsapi/_internal/time-series-from-service/?ref_type=soap&service_url="
self.site_code_swe = "wq2371"
self.site_code_wwo = "S-PRHD"
self.post_data = {
'title': 'My REST API-created resource',
'resource_type': 'GenericResource'
}
class GetCapabilities(ResourceTestCase):
serializer = Serializer()
def setUp(self):
self.api_client = TestApiClient()
self.user = hydroshare.create_account(
"*****@*****.**", username="******", first_name="User_FirstName", last_name="User_LastName"
)
self.url_base = "/hsapi/capabilities/"
def tearDown(self):
User.objects.all().delete()
def test_generic(self):
res = hydroshare.create_resource("GenericResource", self.user, "res1")
url = "{0}{1}/".format(self.url_base, res.short_id)
resp = self.api_client.get(url)
self.assertValidJSONResponse(resp)
capabilities = self.deserialize(resp)
self.assertEqual(capabilities, None)
def test_other_types(self):
pass
class PublicMessagesInAPI(ResourceTestCase):
def setUp(self):
super(PublicMessagesInAPI,self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.user = User.objects.all()[0]
self.writeitinstance = WriteItInstance.objects.create(name="a test", slug="a-test", owner=self.user)
self.writeitinstance.moderation_needed_in_all_messages = True
self.writeitinstance.save()
self.person1 = Person.objects.all()[0]
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key':self.user.api_key.key}
def test_non_confirmated_message_not_showing_in_api(self):
"""Non confirmated message is not in the API"""
message = Message.objects.create(content = 'Content 1',
author_name='Felipe',
author_email="*****@*****.**",
subject='public non confirmated message',
writeitinstance= self.writeitinstance,
persons = [self.person1])
#OK this is just to show that this message is not confirmed
self.assertFalse(message.confirmated)
self.assertNotIn(message, Message.public_objects.all())
#I've tested this in messages_test.py
url = '/api/v1/instance/{0}/messages/'.format(self.writeitinstance.id)
response = self.api_client.get(url,data = self.data)
self.assertValidJSONResponse(response)
messages = self.deserialize(response)['objects']
self.assertFalse(messages)
def setUp(self):
self.logger = logging.getLogger(__name__)
self.api_client = TestApiClient()
self.username = "******"
self.password = "******"
# create a user to be used for creating the resource
self.user_creator = hydroshare.create_account(
"*****@*****.**",
username=self.username,
first_name="Creator_FirstName",
last_name="Creator_LastName",
superuser=False,
password=self.password,
groups=[],
)
self.user_url = "/hsapi/accounts/{0}/".format(self.user_creator.username)
self.api_client.client.login(username=self.username, password=self.password)
# create a resource
self.resource = hydroshare.create_resource(
resource_type="GenericResource",
title="My resource",
owner=self.user_creator,
last_changed_by=self.user_creator,
)
self.resource_url_base = "/hsapi/resource/"
self.resource_url = "{0}{1}/".format(self.resource_url_base, self.resource.short_id)
self.post_data = {"title": "My REST API-created resource", "resource_type": "GenericResource"}
def setUp(self):
self.serializer = Serializer()
self.logger = logging.getLogger(__name__)
self.api_client = TestApiClient()
self.client = Client()
self.username = '******'
self.password = '******'
self.group, _ = Group.objects.get_or_create(name='Hydroshare Author')
# create a user to be used for creating the resource
self.user_creator = hydroshare.create_account(
'*****@*****.**',
username=self.username,
first_name='Creator_FirstName',
last_name='Creator_LastName',
superuser=False,
password=self.password,
groups=[self.group]
)
self.wsdl_url_swe = "http://hydroportal.cuahsi.org/SwedishMonitoringData/webapp/cuahsi_1_1.asmx?WSDL"
self.wsdl_url_wwo = "http://worldwater.byu.edu/app/index.php/default/services/cuahsi_1_1.asmx?WSDL"
self.rest_url = "http://worldwater.byu.edu/interactive/sandbox/services/index.php/cuahsi_1_1.asmx/GetValues?location=WWO:S-PRHD&variable=WWO:JSWL&startDate=&endDate="
self.site_code_swe = "wq2371"
self.site_code_wwo = "S-PRHD"
self.post_data = {
'title': 'My REST API-created resource',
'resource_type': 'GenericResource'
}
class SetAccessRulesTest(ResourceTestCase):
serializer = Serializer()
def setUp(self):
self.account_url_base = '/hsapi/resource/accessRules/'
self.api_client = TestApiClient()
def tearDown(self):
User.objects.all().delete()
Group.objects.all().delete()
def test_set_user_rules(self):
user = hydroshare.create_account(
'*****@*****.**',
username='******',
first_name='User0_FirstName',
last_name='User0_LastName',
)
url = '{0}{1}/'.format(self.account_url_base, user.id)
put_data = {
'pid':user.id,
'principaltype': 'user',
'principleID': user.id,
'access': 'view',
'allow': 'true'
}
resp = self.api_client.put(url, data=put_data)
self.assertEqual(resp.status_code, 200)
def test_set_group_rules(self):
group = hydroshare.create_group(name="group0")
url = '{0}{1}/'.format(self.account_url_base, group.id)
put_data = self.serialize({
'principaltype': 'group',
'principleID': group.id,
'access': 'view',
'allow': 'true'
})
resp = self.api_client.put(url, data=put_data)
self.assertEqual(resp.status_code, 200)
class PagePaginationTestCase(ResourceTestCase):
def setUp(self):
super(PagePaginationTestCase, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.user = User.objects.get(id=1)
# self.writeitinstance = WriteItInstance.objects.create(name="a test", slug="a-test", owner=self.user)
self.api_client = TestApiClient()
self.data = {'format': 'json', 'username': self.user.username, 'api_key': self.user.api_key.key}
def test_setting_all_variables(self):
request_data = {
'limit': None,
'offset': 0,
}
objects = Message.objects.all()
paginator = PagePaginator(request_data, objects)
self.assertIsInstance(paginator, Paginator)
def test_get_offset(self):
request_data = {
'limit': None,
'offset': 5,
}
objects = Message.objects.all()
paginator = PagePaginator(request_data, objects)
self.assertEquals(paginator.get_offset(), request_data['offset'])
def assertOffsetEquals(self, page, limit, offset, objects=Message.objects.all()):
request_data = {
'limit': limit,
'page': page,
}
objects = objects
paginator = PagePaginator(request_data, objects)
self.assertEquals(paginator.get_offset(), offset)
def test_get_page(self):
self.assertOffsetEquals(1, 1, 0)
self.assertOffsetEquals(1, 2, 0)
self.assertOffsetEquals(2, 1, 1)
self.assertOffsetEquals(2, 2, 2)
def test_get_paginated(self):
url = '/api/v1/message/'
data = self.data
data['page'] = 2
data['limit'] = 1
for message in Message.objects.all():
Confirmation.objects.create(message=message)
message.recently_confirmated()
response = self.api_client.get(url, data=data)
# All messages must be confirmed
# in order to be in the api
messages = self.deserialize(response)['objects']
self.assertEquals(
messages[0]['id'],
Message.public_objects.order_by('-created')[1].id)
def setUp(self):
super(AnswerCreationResource, self).setUp()
call_command('loaddata', 'example_data', verbosity=0)
self.outbound_message = OutboundMessage.objects.all()[0]
self.identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
self.api_client = TestApiClient()
self.user = User.objects.all()[0]
self.data = {'format': 'json', 'username': self.user.username, 'api_key':self.user.api_key.key}
