def test_post_with_admin(self):
user = UserF.create()
project_1 = ProjectF.create(**{'creator': user})
project_2 = ProjectF.create(**{'creator': user})
data = {
str(project_1.id): 'on'
}
view = UserNotifications.as_view()
url = reverse('admin:notifications')
request = APIRequestFactory().post(url, data)
request.user = user
from django.contrib.messages.storage.fallback import FallbackStorage
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = view(request).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(
Admins.objects.get(project=project_1, user=user).contact
)
self.assertFalse(
Admins.objects.get(project=project_2, user=user).contact
)
def test_get_update_projects(self):
# Setup everything
updated_project_1 = ProjectF.create()
updated_project_2 = ProjectF.create()
not_updated_project = ProjectF.create()
for x in range(0, 2):
for project in [
updated_project_1, updated_project_2, not_updated_project
]:
ObservationFactory.create(project=project)
updated = ObservationFactory.create(project=updated_project_2)
yesterday = datetime.utcnow().replace(tzinfo=utc)
ObservationFactory.create(project=updated_project_1)
updated.update(attributes={'key': 'value'}, updator=UserF.create())
# the tests
command = Command()
updated_projects = command.get_updated_projects(yesterday)
self.assertIn(updated_project_1, updated_projects)
self.assertIn(updated_project_2, updated_projects)
self.assertNotIn(not_updated_project, updated_projects)
def setUp(self):
self.creator = UserF.create()
self.admin = UserF.create()
self.view_member = UserF.create()
self.contributor = UserF.create()
ProjectF.create(add_admins=[self.admin],
add_contributors=[self.contributor])
ProjectF.create(add_admins=[self.admin, self.contributor])
def setUp(self):
self.admin = UserF.create()
self.project1 = ProjectF(add_admins=[self.admin])
self.project2 = ProjectF(add_admins=[self.admin])
self.public_location = LocationFactory(**{'private': False})
self.private_location = LocationFactory(**{'private': True})
self.private_for_project_location = LocationFactory(
**{
'private': True,
'private_for_project': self.project1
})
def setUp(self):
self.creator = UserF.create()
self.admin = UserF.create()
self.view_member = UserF.create()
self.contributor = UserF.create()
ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
ProjectF.create(
add_admins=[self.admin, self.contributor]
)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.view_member = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.contributor],
add_viewers=[self.view_member]
)
self.other_project = ProjectF.create()
# Create 20 locations, 10 should be accessible for the project
for x in range(0, 5):
LocationFactory()
LocationFactory(**{
'private': True,
'private_for_project': self.other_project
})
LocationFactory(**{
'private': True,
'private_for_project': self.project
})
LocationFactory(**{
'private': True
})
def test_single_lookup(self):
project = ProjectF.create()
category = CategoryFactory.create(**{'project': project})
lookup = LookupFieldFactory.create(
**{'category': category, 'key': 'lookup'}
)
kermit = LookupValueFactory.create(**{
'field': lookup,
'name': 'Kermit'
})
gonzo = LookupValueFactory.create(**{
'field': lookup,
'name': 'Gonzo'
})
ObservationFactory.create_batch(3, **{
'project': project,
'category': category,
'attributes': {'lookup': kermit.id}
})
ObservationFactory.create_batch(3, **{
'project': project,
'category': category,
'attributes': {'lookup': gonzo.id}
})
result = project.observations.all().search('kermit')
self.assertEqual(len(result), 3)
for o in result:
self.assertEqual(o.attributes.get('lookup'), str(kermit.id))
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.view_member = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin],
add_contributors=[self.contributor],
add_viewers=[self.view_member])
self.category = CategoryFactory(**{
'status': 'active',
'project': self.project
})
TextFieldFactory.create(**{'key': 'key_1', 'category': self.category})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category
})
self.inactive_field = TextFieldFactory.create(**{
'key': 'key_3',
'category': self.category,
'status': 'inactive'
})
lookup_field = LookupFieldFactory(**{
'key': 'key_4',
'category': self.category
})
LookupValueFactory(**{'name': 'Ms. Piggy', 'field': lookup_field})
LookupValueFactory(**{'name': 'Kermit', 'field': lookup_field})
LookupValueFactory(**{
'name': 'Gonzo',
'field': lookup_field,
'status': 'inactive'
})
def test_create_with_wrong_location(self):
project = ProjectF()
location = LocationFactory(**{
'private': True,
'private_for_project': project
})
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"properties": {
"location": {
"id": location.id
},
"category": self.category.id,
"attributes": {
"key_1": "value 1",
"key_2": 12
}
}
}
ContributionSerializer(data=data,
context={
'user': self.contributor,
'project': self.project
})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.viewer = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
add_contributors=[self.creator])
self.contribution = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator
})
self.viewer = UserF.create()
self.grouping = GroupingFactory.create(add_viewers=[self.viewer],
**{'project': self.project})
RuleFactory.create(**{
'grouping': self.grouping,
'category': self.contribution.category
})
self.image_file = ImageFileFactory.create(**{
'contribution': self.contribution,
'creator': self.creator
})
def test_access_fields_with_non_member(self):
user = UserF.create()
project = ProjectF.create(**{'isprivate': True})
category = CategoryFactory(**{'project': project, 'status': 'active'})
TextFieldFactory.create(**{'status': 'active', 'category': category})
TextFieldFactory.create(**{'status': 'inactive', 'category': category})
Field.objects.get_list(user, project.id, category.id)
def setUp(self):
self.admin = UserF.create()
self.project = ProjectF(add_admins=[self.admin])
self.category = CategoryFactory(**{
'status': 'active',
'project': self.project
})
TextFieldFactory.create(**{'key': 'key_1', 'category': self.category})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category
})
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [-0.134046077728271, 51.52439200896907]
},
"properties": {
"attributes": {
"key_1": "value 1",
"key_2": 12
},
"category": self.category.id,
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
},
}
}
def setUp(self):
self.factory = RequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin],
add_contributors=[self.contributor])
def test_access_with_projct_non_member(self):
contributor = UserF.create()
project = ProjectF.create()
CategoryFactory(**{'project': project, 'status': 'active'})
CategoryFactory(**{'project': project, 'status': 'inactive'})
Category.objects.get_list(contributor, project.id)
def test_admin_access_with_non_member(self):
user = UserF.create()
project = ProjectF.create(**{'isprivate': True})
active_type = CategoryFactory(**{'project': project})
Category.objects.as_admin(user, project.id, active_type.id)
def test_access_fields_with_admin(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin], **{'isprivate': True})
category = CategoryFactory(**{'project': project, 'status': 'active'})
TextFieldFactory.create(**{'status': 'active', 'category': category})
TextFieldFactory.create(**{'status': 'inactive', 'category': category})
self.assertEqual(
len(Field.objects.get_list(admin, project.id, category.id)), 2)
def test_admin_access_active_field_with_non_member(self):
user = UserF.create()
project = ProjectF.create(**{'isprivate': True})
category = CategoryFactory(**{'project': project, 'status': 'active'})
field = TextFieldFactory.create(**{
'status': 'active',
'category': category
})
Field.objects.as_admin(user, project.id, category.id, field.id)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
add_contributors=[self.creator])
self.contribution = ObservationFactory.create(
**{'project': self.project})
def test_access_with_projct_admin(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin], **{'isprivate': True})
CategoryFactory(**{'project': project, 'status': 'active'})
CategoryFactory(**{'project': project, 'status': 'inactive'})
self.assertEqual(len(Category.objects.get_list(admin, project.id)), 2)
def test_admin_access_with_contributor(self):
user = UserF.create()
project = ProjectF.create(add_contributors=[user],
**{'isprivate': True})
active_type = CategoryFactory(**{'project': project})
Category.objects.as_admin(user, project.id, active_type.id)
def test_create(self):
project = ProjectF.create()
Category.objects.create(name='Test',
project=project,
creator=project.creator,
create_grouping=False)
views = project.groupings.all()
self.assertEqual(len(views), 0)
def test_create_with_view(self):
project = ProjectF.create()
category = Category.objects.create(name='Test',
project=project,
creator=project.creator,
create_grouping=True)
views = project.groupings.all()
self.assertEqual(len(views), 1)
self.assertEqual(views[0].name, category.name)
def test_admin_access_with_admin(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin], **{'isprivate': True})
active_type = CategoryFactory(**{'project': project})
self.assertEqual(
active_type,
Category.objects.as_admin(admin, project.id, active_type.id))
def test_access_inactive_field_with_contributor(self):
user = UserF.create()
project = ProjectF.create(add_contributors=[user],
**{'isprivate': True})
category = CategoryFactory(**{'project': project, 'status': 'active'})
field = TextFieldFactory.create(**{
'status': 'inactive',
'category': category
})
Field.objects.get_single(user, project.id, category.id, field.id)
def test_access_inactive_with_admin(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin], **{'isprivate': True})
inactive_type = CategoryFactory(**{
'project': project,
'status': 'inactive'
})
self.assertEqual(
inactive_type,
Category.objects.get_single(admin, project.id, inactive_type.id))
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin])
self.active_type = CategoryFactory(**{
'project': self.project,
'status': 'active'
})
def test_access_inactive_with_contributor(self):
contributor = UserF.create()
project = ProjectF.create(add_contributors=[contributor],
**{'isprivate': True})
inactive_type = CategoryFactory(**{
'project': project,
'status': 'inactive'
})
Category.objects.get_single(contributor, project.id, inactive_type.id)
def setUp(self):
self.factory = RequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin],
add_contributors=[self.contributor])
self.category = CategoryFactory.create(**{'project': self.project})
self.field = TextFieldFactory.create(**{'category': self.category})
def setUp(self):
self.factory = RequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
def setUp(self):
self.factory = APIRequestFactory()
self.project = ProjectF()
LocationFactory.create(**{'name': 'Hyde Park'})
LocationFactory.create(**{'description': 'hyde'})
LocationFactory.create(**{'name': 'hyde park'})
LocationFactory.create(**{'name': 'Regents Park'})
self.url = reverse('api:project_locations',
kwargs={'project_id': self.project.id})
def test_admin(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
view = GroupingFactory.create(**{
'project': project,
'isprivate': False
})
self.assertTrue(view.can_view(user))
self.assertTrue(view.can_read(user))
self.assertTrue(view.can_moderate(user))
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.user_to_add = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin])
self.contributors = UserGroupF(add_users=[self.contributor],
**{'project': self.project})
def test_admin(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
view = GroupingFactory.create(**{
'project': project,
'isprivate': False
})
self.assertTrue(view.can_view(user))
self.assertTrue(view.can_read(user))
self.assertTrue(view.can_moderate(user))
def test_admin_access_active_field_with_admin(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user], **{'isprivate': True})
category = CategoryFactory(**{'project': project, 'status': 'active'})
field = TextFieldFactory.create(**{
'status': 'active',
'category': category
})
self.assertEqual(
field,
Field.objects.as_admin(user, project.id, category.id, field.id))
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
add_contributors=[self.contributor])
self.view = GroupingFactory(**{
'project': self.project,
'description': 'description'
})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin]
)
self.active_type = CategoryFactory(**{
'project': self.project,
'status': 'active'
})
def setUp(self):
self.factory = RequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
self.category = CategoryFactory.create(
**{'project': self.project})
self.field = TextFieldFactory.create(
**{'category': self.category})
def test_get_update_projects(self):
# Setup everything
updated_project_1 = ProjectF.create()
updated_project_2 = ProjectF.create()
not_updated_project = ProjectF.create()
for x in range(0, 2):
for project in [
updated_project_1, updated_project_2, not_updated_project]:
ObservationFactory.create(project=project)
updated = ObservationFactory.create(project=updated_project_2)
yesterday = datetime.utcnow().replace(tzinfo=utc)
ObservationFactory.create(project=updated_project_1)
updated.update(attributes={'key': 'value'}, updator=UserF.create())
# the tests
command = Command()
updated_projects = command.get_updated_projects(yesterday)
self.assertIn(updated_project_1, updated_projects)
self.assertIn(updated_project_2, updated_projects)
self.assertNotIn(not_updated_project, updated_projects)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
self.active_type = CategoryFactory(**{
'project': self.project,
'status': 'active'
})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.viewer = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.creator]
)
self.contribution = ObservationFactory.create(
**{'project': self.project, 'creator': self.creator}
)
ImageFileFactory.create_batch(5, **{'contribution': self.contribution})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.user_to_add = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin]
)
self.contributors = UserGroupF(
add_users=[self.contributor],
**{'project': self.project}
)
def test_daily_digest(self):
moderator = UserF.create()
contributor = UserF.create()
UserF.create()
project = ProjectF.create(
add_admins=[moderator],
add_contributors=[contributor]
)
suspended = ObservationFactory.create(
created_at=(datetime.utcnow() - timedelta(2)).replace(tzinfo=utc),
project=project,
creator=contributor,
status='active'
)
updated = ObservationFactory.create(
project=project,
creator=contributor
)
approved = ObservationFactory.create(
project=project,
creator=contributor,
status='pending'
)
yesterday = datetime.utcnow().replace(tzinfo=utc)
suspended.update(
attributes=None,
status='pending',
updator=UserF.create()
)
updated.update(attributes={'key': 'value'}, updator=UserF.create())
approved.update(attributes=None, status='active', updator=moderator)
for user in [moderator, contributor]:
ObservationFactory.create(
project=project,
creator=user,
status='pending'
)
command = Command()
command.send_daily_digest(yesterday)
self.assertEquals(len(mail.outbox), 3)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.view_member = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
add_viewers=[self.view_member]
)
self.category = CategoryFactory(**{
'status': 'active',
'project': self.project
})
TextFieldFactory.create(**{
'key': 'key_1',
'category': self.category
})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category
})
self.inactive_field = TextFieldFactory.create(**{
'key': 'key_3',
'category': self.category,
'status': 'inactive'
})
lookup_field = LookupFieldFactory(**{
'key': 'key_4',
'category': self.category
})
LookupValueFactory(**{
'name': 'Ms. Piggy',
'field': lookup_field
})
LookupValueFactory(**{
'name': 'Kermit',
'field': lookup_field
})
LookupValueFactory(**{
'name': 'Gonzo',
'field': lookup_field,
'status': 'inactive'
})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.contrib_to_remove = UserF.create()
self.project = ProjectF.create(add_admins=[
self.admin
])
self.contributors = UserGroupF(add_users=[
self.contributor, self.contrib_to_remove
], **{
'project': self.project,
'can_contribute': True
})
def test_multiple_lookup(self):
project = ProjectF.create()
category = CategoryFactory.create(**{'project': project})
lookup = MultipleLookupFieldFactory.create(
**{'category': category, 'key': 'lookup'}
)
kermit = MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Kermit'
})
gonzo = MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Gonzo'
})
piggy = MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Ms Piggy'
})
ObservationFactory.create_batch(3, **{
'project': project,
'category': category,
'attributes': {'lookup': [piggy.id, kermit.id]}
})
ObservationFactory.create_batch(3, **{
'project': project,
'category': category,
'attributes': {'lookup': [gonzo.id]}
})
result = project.observations.all().search('kermit')
self.assertEqual(len(result), 3)
for o in result:
self.assertIn(kermit.id, json.loads(o.attributes.get('lookup')))
result = project.observations.all().search('piggy')
self.assertEqual(len(result), 3)
for o in result:
self.assertIn(kermit.id, json.loads(o.attributes.get('lookup')))
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin]
)
self.contributors = UserGroupF(
add_users=[self.contributor],
**{'project': self.project}
)
self.view = GroupingFactory(**{
'project': self.project
})
GroupingUserGroupFactory(**{
'usergroup': self.contributors,
'grouping': self.view
})
def test_get_update_stats(self):
moderator = UserF.create()
contributor = UserF.create()
some_dude = UserF.create()
project = ProjectF.create(
add_admins=[moderator],
add_contributors=[contributor]
)
suspended = ObservationFactory.create(
created_at=(datetime.utcnow() - timedelta(2)).replace(tzinfo=utc),
project=project,
creator=contributor,
status='active'
)
updated = ObservationFactory.create(
project=project,
creator=contributor
)
approved = ObservationFactory.create(
project=project,
creator=contributor,
status='pending'
)
yesterday = datetime.utcnow().replace(tzinfo=utc)
suspended.update(
attributes=None,
status='pending',
updator=UserF.create()
)
updated.update(attributes={'key': 'value'}, updator=UserF.create())
approved.update(attributes=None, status='active', updator=moderator)
for user in [moderator, contributor]:
ObservationFactory.create(
project=project,
creator=user,
status='pending'
)
command = Command()
report = command.get_updated_items(project, moderator, yesterday)
to_moderate = report.get('to_moderate')
self.assertEqual(len(to_moderate.get('new')), 2)
self.assertEqual(len(to_moderate.get('suspended')), 1)
self.assertIsNone(report.get('yours'))
report = command.get_updated_items(project, contributor, yesterday)
yours = report.get('yours')
self.assertEqual(len(yours.get('changed')), 3)
self.assertEqual(len(yours.get('approved')), 1)
self.assertEqual(len(yours.get('suspended')), 1)
report = command.get_updated_items(project, some_dude, yesterday)
self.assertEqual(report, None)
class AllContributionsMediaAPIViewTest(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.viewer = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.creator]
)
self.contribution = ObservationFactory.create(
**{'project': self.project, 'creator': self.creator}
)
ImageFileFactory.create_batch(5, **{'contribution': self.contribution})
def tearDown(self):
files = glob.glob(os.path.join(
settings.MEDIA_ROOT,
'user-uploads/images/*'
))
for f in files:
os.remove(f)
def get(self, user):
url = reverse(
'api:project_media',
kwargs={
'project_id': self.project.id,
'contribution_id': self.contribution.id
}
)
request = self.factory.get(url)
force_authenticate(request, user)
view = AllContributionsMediaAPIView.as_view()
return view(
request,
project_id=self.project.id,
contribution_id=self.contribution.id
).render()
def post(self, user, data=None):
if data is None:
data = {
'name': 'A test image',
'description': 'Test image description',
'file': get_image()
}
url = reverse(
'api:project_media',
kwargs={
'project_id': self.project.id,
'contribution_id': self.contribution.id
}
)
request = self.factory.post(url, data)
force_authenticate(request, user)
view = AllContributionsMediaAPIView.as_view()
return view(
request,
project_id=self.project.id,
contribution_id=self.contribution.id
).render()
def test_get_images_with_admin(self):
response = self.get(self.admin)
self.assertEqual(response.status_code, 200)
def test_get_images_with_contributor(self):
response = self.get(self.creator)
self.assertEqual(response.status_code, 200)
def test_get_images_with_some_dude(self):
response = self.get(UserF.create())
self.assertEqual(response.status_code, 404)
def test_get_images_with_anonymous(self):
response = self.get(AnonymousUser())
self.assertEqual(response.status_code, 404)
def test_upload_image_with_admin(self):
response = self.post(self.admin)
self.assertEqual(response.status_code, 201)
def test_upload_image_with_contributor(self):
response = self.post(self.creator)
self.assertEqual(response.status_code, 201)
def test_upload_image_with_some_dude(self):
response = self.post(UserF.create())
self.assertEqual(response.status_code, 404)
def test_upload_image_with_anonymous(self):
response = self.post(AnonymousUser())
self.assertEqual(response.status_code, 404)
def test_post_images_with_anonymous_to_public(self):
self.project.isprivate = False
self.project.everyone_contributes = True
self.project.save()
grouping = GroupingFactory.create(
**{'project': self.project, 'isprivate': False}
)
RuleFactory.create(**{
'grouping': grouping,
'category': self.contribution.category
})
response = self.post(AnonymousUser())
self.assertEqual(response.status_code, 201)
def test_upload_unsupported_file_format(self):
xyz_file = StringIO()
xyz = Image.new('RGBA', size=(50, 50), color=(256, 0, 0))
xyz.save(xyz_file, 'png')
xyz_file.seek(0)
data = {
'name': 'A test image',
'description': 'Test image description',
'file': ContentFile(xyz_file.read(), 'test.xyz')
}
response = self.post(self.admin, data=data)
self.assertEqual(response.status_code, 400)
def test_upload_with_loooooong_filename(self):
data = {
'name': 'A test image ',
'description': 'Test image description',
'file': get_image(file_name='One two three four six seven eight '
'nine ten eleven twelve thirteen '
'fourteen fifteen.png')
}
response = self.post(self.admin, data=data)
self.assertEqual(response.status_code, 201)
