def test_views_with_other_user(self): user = UserF.create() group = UserGroupF.create() view = UserGroupData.as_view() request = HttpRequest() request.method = 'GET' request.user = user response = view( request, project_id=group.project.id, group_id=group.id ).render() rendered = render_to_string( 'users/usergroup_data.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(unicode(response.content), rendered) category = CategoryFactory.create(**{'project': group.project}) request = HttpRequest() request.method = 'POST' request.user = user request.POST = { 'permission': 'restricted', 'filters': '{ "%s": { } }' % category.id } response = view( request, project_id=group.project.id, group_id=group.id ).render() rendered = render_to_string( 'users/usergroup_data.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(unicode(response.content), rendered) self.assertIsNone(Group.objects.get(pk=group.id).filters)
def test_get_with_user(self): """ Accessing the view with normal user should render the page with an error message """ subset = SubsetFactory.create() user = UserFactory.create() self.request.user = user response = self.view(self.request, project_id=subset.project.id, subset_id=subset.id).render() rendered = render_to_string( 'base.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) self.assertEqual(Subset.objects.count(), 1)
def test_post_on_project_when_no_categories_with_admin(self): """ Updating with project admin when the project has no categories should render the page withh an error message """ subset = SubsetFactory.create() subset.project.islocked = True subset.project.save() user = subset.project.creator self.request.user = user self.request.method = 'POST' self.request.POST = {'filters': '{ "%s": { } }' % 154515} response = self.view(self.request, project_id=subset.project.id, subset_id=subset.id).render() reference = Subset.objects.get(pk=subset.id) self.assertNotEqual(reference.filters, json.loads('{ "%s": { } }' % 154515)) rendered = render_to_string( 'subsets/subset_data.html', { 'project': reference.project, 'subset': reference, 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'messages': get_messages(self.request), 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_non_existing_with_admin(self): """ Updating with project admin when subset does not exist should render the page withh an error message """ project = ProjectFactory.create() category = CategoryFactory.create(**{'project': project}) user = project.creator self.request.user = user self.request.method = 'POST' self.request.POST = {'filters': '{ "%s": { } }' % category.id} response = self.view(self.request, project_id=project.id, subset_id=634842156456).render() rendered = render_to_string( 'subsets/subset_data.html', { 'error_description': 'Subset matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_admin(self): """ Updating with project admin should render the page with a success message """ subset = SubsetFactory.create() category = CategoryFactory.create(**{'project': subset.project}) user = subset.project.creator self.request.user = user self.request.method = 'POST' self.request.POST = {'filters': '{ "%s": { } }' % category.id} response = self.view(self.request, project_id=subset.project.id, subset_id=subset.id).render() reference = Subset.objects.get(pk=subset.id) self.assertEqual(reference.filters, json.loads('{ "%s": { } }' % category.id)) rendered = render_to_string( 'subsets/subset_data.html', { 'project': reference.project, 'subset': reference, 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'messages': get_messages(self.request), 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(response.status_code, 200) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_post_with_user(self): """ Updating with normal user should render the page with an error message """ subset = SubsetFactory.create() category = CategoryFactory.create(**{'project': subset.project}) user = UserFactory.create() self.request.user = user self.request.method = 'POST' self.request.POST = {'filters': '{ "%s": { } }' % category.id} response = self.view(self.request, project_id=subset.project.id, subset_id=subset.id).render() reference_subset = Subset.objects.get(pk=subset.id) self.assertIsNone(reference_subset.filters) rendered = render_to_string( 'subsets/subset_data.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_user(self): """ Updating with normal user should render the page with an error message """ user = UserFactory.create() subset = SubsetFactory.create() self.request.user = user self.request.method = 'POST' self.request.POST = { 'name': 'Name', 'description': 'Description', } response = self.view(self.request, project_id=subset.project.id, subset_id=subset.id).render() rendered = render_to_string( 'subsets/subset_settings.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) reference = Subset.objects.get(pk=subset.id) self.assertNotEqual(reference.name, 'Name') self.assertNotEqual(reference.description, 'Description')
def test_get_non_existing_with_admin(self): """ Deleting with project admin when subset does not exist should render the page with an error message """ project = ProjectFactory.create() user = project.creator self.request.user = user response = self.view( self.request, project_id=project.id, subset_id=634842156456).render() rendered = render_to_string( 'base.html', { 'error_description': 'Subset matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_get_with_admin(self): """ Accessing the view with project admin should render the page """ subset = SubsetFactory.create() user = subset.project.creator self.request.user = user response = self.view( self.request, project_id=subset.project.id, subset_id=subset.id).render() rendered = render_to_string( 'subsets/subset_data.html', { 'project': subset.project, 'subset': subset, 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_non_existing_with_admin(self): """ Update the view with project admin should render an error message """ project = ProjectF.create() user = project.creator self.request.user = user self.request.method = 'POST' self.request.POST = { 'name': 'Name', 'description': 'Description', } response = self.view( self.request, project_id=project.id, subset_id=634842156456).render() rendered = render_to_string( 'subsets/subsets_settings.html', { 'error_description': 'Subset matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_admin(self): """ Accessing the view with project admin should render the page """ subset = SubsetFactory.create() user = subset.project.creator self.request.user = user self.request.method = 'POST' self.request.POST = { 'name': 'Name', 'description': 'Description', } response = self.view( self.request, project_id=subset.project.id, subset_id=subset.id).render() reference = Subset.objects.get(pk=subset.id) self.assertEqual(reference.name, 'Name') self.assertEqual(reference.description, 'Description') rendered = render_to_string( 'subsets/subsets_settings.html', { 'subset': reference, 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version(), 'messages': get_messages(self.request) } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def get(self, request): """ Handle GET request. Return GeoKey server information. Parameters ---------- request : rest_framework.request.Request Object representing the request. Returns ------- rest_framework.response.Response Contains the GeoKey server information. """ info = {'geokey': {}} info['geokey']['version'] = get_version() info['geokey']['installed_extensions'] = map( lambda (ext_id, ext): { 'name': ext_id, 'version': ext['version'] if 'version' in ext else None }, extensions.iteritems() ) return Response(info)
def get(self, request): """ Handle GET request. Return GeoKey server information. Parameters ---------- request : rest_framework.request.Request Object representing the request. Returns ------- rest_framework.response.Response Contains the GeoKey server information. """ info = {'geokey': {}} info['geokey']['version'] = get_version() info['geokey']['installed_extensions'] = [{ 'name': ext_id_ext[0], 'version': ext_id_ext[1]['version'] if 'version' in ext_id_ext[1] else None } for ext_id_ext in iter(list(extensions.items()))] return Response(info)
def test_post_with_superuser(self): """Test POST with superuser.""" self.create_inactive() user = UserFactory.create(**{"is_superuser": True}) self.request.method = "POST" self.request.POST = QueryDict("activate_users=%s&activate_users=%s" % (self.inactive_1.id, self.inactive_2.id)) self.request.user = user response = self.view(self.request).render() rendered = render_to_string( "superusertools/manage_inactive_users.html", { "GEOKEY_VERSION": version.get_version(), "PLATFORM_NAME": get_current_site(self.request).name, "user": user, "messages": get_messages(self.request), "inactive_users": [self.inactive_3], }, ) self.assertEqual(response.status_code, 200) response = render_helpers.remove_csrf(response.content.decode("utf-8")) self.assertEqual(response, rendered) self.assertEqual(User.objects.filter(is_active=False).count(), 1) self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 1)
def test_get_with_superuser(self): """Test GET with superuser.""" self.create_inactive() user = UserFactory.create(**{'is_superuser': True}) self.request.method = 'GET' self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactive_users.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': user, 'inactive_users': [ self.inactive_1, self.inactive_2, self.inactive_3 ] } ) self.assertEqual(response.status_code, 200) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_post_with_user(self): sapelli_project = create_horniman_sapelli_project(self.user) path = normpath(join(dirname(abspath(__file__)), 'files/Horniman.csv')) file = File(open(path, 'rb')) self.request.method = 'POST' self.request.FILES = {'csv_file': file} self.request.POST = {'form_category_id': sapelli_project.forms.first().category_id} self.request.user = self.user response = self.view( self.request, project_id=sapelli_project.geokey_project.id).render() self.assertEqual(response.status_code, 200) rendered = render_to_string( 'sapelli/upload_data_csv.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'messages': get_messages(self.request), 'user': self.user, 'sapelli_project': sapelli_project, } ) self.assertContains( response, '4 records have been added as project contributions' ) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered) self.assertEqual(sapelli_project.geokey_project.observations.count(), 5)
def test_get_with_user(self): """ Accessing the view with normal user should render the page with an error message """ subset = SubsetFactory.create() user = UserFactory.create() self.request.user = user response = self.view( self.request, project_id=subset.project.id, subset_id=subset.id).render() rendered = render_to_string( 'base.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) self.assertEqual(Subset.objects.count(), 1)
def test_post_non_existing_with_admin(self): """ Updating with project admin when subset does not exist should render the page withh an error message """ project = ProjectFactory.create() category = CategoryFactory.create(**{'project': project}) user = project.creator self.request.user = user self.request.method = 'POST' self.request.POST = { 'filters': '{ "%s": { } }' % category.id } response = self.view( self.request, project_id=project.id, subset_id=634842156456).render() rendered = render_to_string( 'subsets/subset_data.html', { 'error_description': 'Subset matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_user(self): """Test POST with user.""" self.create_inactive() user = UserFactory.create() self.request.method = 'POST' self.request.POST = QueryDict( 'activate_users=%s&activate_users=%s' % ( self.inactive_1.id, self.inactive_2.id ) ) self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactive_users.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': user, 'error': 'Permission denied.', 'error_description': 'No rights to access superuser tools.' } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) self.assertEqual(User.objects.filter(is_active=False).count(), 3) self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 3)
def get(self, request): """ Returns GeoKey server information Parameter --------- request : rest_framework.request.Request Represents the HTTP request Response -------- rest_framework.response.Response Containing the GeoKey server information """ info = {} gk_info = info['geokey'] = {} # GeoKey version: gk_info['version'] = get_version() # Installed extensions (with their version): gk_info['installed_extensions'] = map( lambda (ext_id, ext): { 'name': ext_id, 'version': (ext['version'] if 'version' in ext else None)}, filter( lambda (ext_id, ext): request.user.is_superuser or not ext['superuser'], extensions.iteritems())) # TODO Add more info later? # Return info: return Response(info)
def test_post_with_user(self): sapelli_project = create_horniman_sapelli_project(self.user) path = normpath(join(dirname(abspath(__file__)), 'files/Horniman.csv')) file = File(open(path, 'rb')) self.request.method = 'POST' self.request.FILES = {'csv_file': file} self.request.POST = { 'form_category_id': sapelli_project.forms.first().category_id } self.request.user = self.user response = self.view( self.request, project_id=sapelli_project.geokey_project.id).render() self.assertEqual(response.status_code, 200) rendered = render_to_string( 'sapelli/upload_data_csv.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'messages': get_messages(self.request), 'user': self.user, 'sapelli_project': sapelli_project, }) self.assertContains( response, '4 records have been added as project contributions') response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered) self.assertEqual(sapelli_project.geokey_project.observations.count(), 5)
def test_post_with_superuser(self): user = UserF.create(**{'is_superuser': True}) self.create_inactive() self.request.POST = QueryDict( 'activate_users=%s&activate_users=%s' % ( self.inactive_1.id, self.inactive_2.id)) self.request.method = 'POST' self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactiveusers.html', { 'inactive_users': [self.inactive_3], 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version(), 'messages': get_messages(self.request) } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) self.assertEqual( User.objects.filter(is_active=False).count(), 1 ) self.assertEqual( EmailAddress.objects.filter(verified=False).count(), 1 )
def test_post_with_regular_user_when_information_has_not_changed(self): """ Updating user profile with regular user should not change the information if it has not been changed. It should also show info message. """ self.request.method = 'POST' self.request.user = UserF.create() self.request.POST = { 'display_name': self.request.user.display_name, 'email': self.request.user.email } EmailAddress.objects.create( user=self.request.user, email=self.request.user.email, verified=True ) response = self.view(self.request).render() rendered = render_to_string( 'users/profile.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': self.request.user, 'messages': get_messages(self.request) } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) reference = EmailAddress.objects.get(user=self.request.user) self.assertEqual(reference.verified, True)
def test_post_with_user(self): """Test POST with user.""" self.create_inactive() user = UserFactory.create() self.request.method = "POST" self.request.POST = QueryDict("activate_users=%s&activate_users=%s" % (self.inactive_1.id, self.inactive_2.id)) self.request.user = user response = self.view(self.request).render() rendered = render_to_string( "superusertools/manage_inactive_users.html", { "GEOKEY_VERSION": version.get_version(), "PLATFORM_NAME": get_current_site(self.request).name, "user": user, "error": "Permission denied.", "error_description": "No rights to access superuser tools.", }, ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode("utf-8"), rendered) response = render_helpers.remove_csrf(response.content.decode("utf-8")) self.assertEqual(User.objects.filter(is_active=False).count(), 3) self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 3)
def test_get_with_admin(self): """ Accessing the view with project admin. It should render the page. """ project = ProjectFactory.create() user = project.creator logs = LoggerHistory.objects.filter( project__contains={'id': str(project.id)}) logger_list = LoggerList() self.request.user = user response = self.view(self.request, project_id=project.id).render() rendered = render_to_string( 'logger/logger_list.html', { 'project': project, 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version(), 'logs': logger_list.paginate_logs( logs[::-1], self.request.GET.get('page')) } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_get_with_user(self): """ Accessing the view with normal user. It should render the page with an error message. """ self.request.user = self.regular_user response = self.view( self.request, project_id=self.project.id, socialinteractionpull_id=self.si_pull.id ).render() rendered = render_to_string( 'socialinteractions/socialinteraction_pull.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': self.regular_user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_delete_with_admin_when_project_does_not_exit(self): """ Accessing the view with project admin when project does not exist. It should render the page with an error message. """ self.si_pull.project = self.project self.si_pull.creator = self.admin_user self.si_pull.save() self.request.user = self.admin_user response = self.view( self.request, project_id=634842156456, socialinteractionpull_id=self.si_pull.id ).render() rendered = render_to_string( 'base.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': self.admin_user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) self.assertEqual(SocialInteractionPull.objects.count(), 1)
def test_post_with_user(self): """ Updating with normal user. It should render the page with an error message. """ self.request.method = 'POST' self.request.POST = { 'name': 'My social interaction', 'description': '', 'socialaccount': self.socialaccount_2.id } self.request.user = self.regular_user response = self.view(self.request, project_id=self.project.id).render() rendered = render_to_string( 'socialinteractions/socialinteraction_post_create.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': self.regular_user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) self.assertEqual(0, SocialInteractionPost.objects.count())
def test_post_with_user(self): """ Updating with normal user should render the page with an error message """ self.request.method = 'POST' self.request.POST = { 'name': 'Name', 'description': 'Description', } project = ProjectFactory.create() CategoryFactory.create(project=project) user = UserFactory.create() self.request.user = user response = self.view(self.request, project_id=project.id).render() rendered = render_to_string( 'subsets/subset_create.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) self.assertEqual(0, Subset.objects.count())
def test_post_with_user(self): """ Updating with normal user should render the page with an error message """ subset = SubsetFactory.create() category = CategoryFactory.create(**{'project': subset.project}) user = UserFactory.create() self.request.user = user self.request.method = 'POST' self.request.POST = { 'filters': '{ "%s": { } }' % category.id } response = self.view( self.request, project_id=subset.project.id, subset_id=subset.id).render() reference_subset = Subset.objects.get(pk=subset.id) self.assertIsNone(reference_subset.filters) rendered = render_to_string( 'subsets/subset_data.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_views_with_other_user(self): user = UserF.create() group = UserGroupF.create() view = UserGroupData.as_view() request = HttpRequest() request.method = 'GET' request.user = user response = view(request, project_id=group.project.id, group_id=group.id).render() rendered = render_to_string( 'users/usergroup_data.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(unicode(response.content), rendered) category = CategoryFactory.create(**{'project': group.project}) request = HttpRequest() request.method = 'POST' request.user = user request.POST = { 'permission': 'restricted', 'filters': '{ "%s": { } }' % category.id } response = view(request, project_id=group.project.id, group_id=group.id).render() rendered = render_to_string( 'users/usergroup_data.html', { 'error_description': 'Project matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(unicode(response.content), rendered) self.assertIsNone(Group.objects.get(pk=group.id).filters)
def project_settings(request): GOOGLE_ANALYTICS = None if hasattr(settings, 'GOOGLE_ANALYTICS'): GOOGLE_ANALYTICS = settings.GOOGLE_ANALYTICS return { 'DEBUG': settings.DEBUG, 'PLATFORM_NAME': get_current_site(request).name, 'GEOKEY_VERSION': version.get_version(), 'GOOGLE_ANALYTICS': GOOGLE_ANALYTICS }
def test_get_with_user(self): user = UserFactory.create() self.request.user = user response = self.view(self.request).render() self.assertEqual(response.status_code, 200) rendered = render_to_string( 'sapelli/upload_sapelli_project.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': user, }) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_get_with_admin(self): """Test GET with admin.""" self.request.user = self.admin response = self.view( self.request, project_id=self.sapelli_project.geokey_project.id).render() self.assertEqual(response.status_code, 200) rendered = render_to_string( 'sapelli/logs.html', { 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version(), 'user': self.request.user, 'sapelli_project': self.sapelli_project, }) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_post_with_regular_user(self): """ Updating user profile with regular user should change the information and show success message. """ self.request.method = 'POST' self.request.user = UserF.create() self.request.POST = { 'display_name': 'Test User', 'email': '*****@*****.**' } EmailAddress.objects.create( user=self.request.user, email=self.request.user.email, verified=True ) response = self.view(self.request).render() rendered = render_to_string( 'users/profile.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': self.request.user, 'messages': get_messages(self.request) } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) reference = User.objects.get(pk=self.request.user.id) self.assertEqual( reference.display_name, self.request.POST.get('display_name') ) self.assertEqual( reference.email, self.request.POST.get('email') ) reference = EmailAddress.objects.get(user=self.request.user) self.assertEqual( reference.email, self.request.POST.get('email') ) self.assertEqual(reference.verified, False)
def test_get_with_user(self): sapelli_project = SapelliProjectFactory.create() self.request.user = sapelli_project.geokey_project.creator response = self.view(self.request).render() self.assertEqual(response.status_code, 200) rendered = render_to_string( 'sapelli/index.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'messages': get_messages(self.request), 'user': sapelli_project.geokey_project.creator, 'sapelli_projects': [sapelli_project], }) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_get_with_user(self): user = UserFactory.create() self.request.user = user response = self.view(self.request).render() self.assertEqual(response.status_code, 200) rendered = render_to_string( 'sapelli/upload_sapelli_project.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': user, } ) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_get_with_regular_user(self): """Test GET with regular user.""" self.request.user = self.regular_user response = self.view( self.request, project_id=self.sapelli_project.geokey_project.id).render() self.assertEqual(response.status_code, 200) rendered = render_to_string( 'sapelli/logs.html', { 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version(), 'user': self.request.user, 'error': 'Not found', 'error_description': 'Sapelli project not found.', }) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_get(self): """Test GET.""" self.request.user = AnonymousUser() response = self.view(self.request).render() self.assertEqual(response.status_code, 200) response = json.loads(response.content) self.assertIn('geokey', response) geokey = response.get('geokey') self.assertEqual(geokey.get('version'), get_version()) self.assertIn('installed_extensions', geokey) installed_extensions = geokey.get('installed_extensions') self.assertTrue(self.contains_extension('A', installed_extensions)) self.assertTrue(self.contains_extension('B', installed_extensions)) self.assertTrue(self.contains_extension('S', installed_extensions))
def test_get_with_user(self): user = UserF.create() self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactiveusers.html', { 'error_description': 'Superuser tools are for superusers only.' ' You are not a superuser.', 'error': 'Permission denied.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_get_with_regular_user(self): """ Accessing the view with regular user should render the page. """ self.request.method = 'GET' self.request.user = UserF.create() response = self.view(self.request).render() rendered = render_to_string( 'users/profile.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': self.request.user } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_get_with_superuser(self): user = UserF.create(**{'is_superuser': True}) inactive_users = UserF.create_batch(3, **{'is_active': False}) self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactiveusers.html', { 'inactive_users': inactive_users, 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_on_locked_project_with_admin(self): """ Updating with project admin when the project is locked should render the page withh an error message """ subset = SubsetFactory.create() subset.project.islocked = True subset.project.save() category = CategoryFactory.create(**{'project': subset.project}) user = subset.project.creator self.request.user = user self.request.method = 'POST' self.request.POST = { 'filters': '{ "%s": { } }' % category.id } response = self.view( self.request, project_id=subset.project.id, subset_id=subset.id).render() reference = Subset.objects.get(pk=subset.id) self.assertNotEqual( reference.filters, json.loads('{ "%s": { } }' % category.id) ) rendered = render_to_string( 'subsets/subset_data.html', { 'project': reference.project, 'subset': reference, 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'messages': get_messages(self.request), 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_get_with_user(self): sapelli_project = create_horniman_sapelli_project(self.user) self.request.user = self.user response = self.view( self.request, project_id=sapelli_project.geokey_project.id).render() self.assertEqual(response.status_code, 200) rendered = render_to_string( 'sapelli/upload_data_csv.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': self.user, 'sapelli_project': sapelli_project, }) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_get_with_user(self): """Test GET with user.""" user = UserFactory.create(**{'is_superuser': False}) self.request.method = 'GET' self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactive_users.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': user, 'error': 'Permission denied.', 'error_description': 'No rights to access superuser tools.', }) self.assertEqual(response.status_code, 200) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_get_with_superuser(self): """Test GET with superuser.""" self.create_inactive() user = UserFactory.create(**{'is_superuser': True}) self.request.method = 'GET' self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactive_users.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': user, 'inactive_users': [self.inactive_1, self.inactive_2, self.inactive_3] }) self.assertEqual(response.status_code, 200) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_post_with_user(self): """Test POST with user.""" self.create_inactive() user = UserFactory.create() self.request.method = 'POST' self.request.POST = QueryDict('activate_users=%s&activate_users=%s' % (self.inactive_1.id, self.inactive_2.id)) self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactive_users.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': user, 'error': 'Permission denied.', 'error_description': 'No rights to access superuser tools.' }) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered) self.assertEqual(User.objects.filter(is_active=False).count(), 3) self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 3)
def test_post_with_superuser(self): """Test POST with superuser.""" self.create_inactive() user = UserFactory.create(**{'is_superuser': True}) self.request.method = 'POST' self.request.POST = QueryDict('activate_users=%s&activate_users=%s' % (self.inactive_1.id, self.inactive_2.id)) self.request.user = user response = self.view(self.request).render() rendered = render_to_string( 'superusertools/manage_inactive_users.html', { 'GEOKEY_VERSION': version.get_version(), 'PLATFORM_NAME': get_current_site(self.request).name, 'user': user, 'messages': get_messages(self.request), 'inactive_users': [self.inactive_3] }) self.assertEqual(response.status_code, 200) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered) self.assertEqual(User.objects.filter(is_active=False).count(), 1) self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 1)
#!/usr/bin/env python """GeoKey setup.""" from os.path import join from setuptools import setup, find_packages from geokey.version import get_version name = 'geokey' version = get_version() repository = join('https://github.com/ExCiteS', name) def get_install_requires(): """ Get requirements (ignore links, exclude comments). Returns ------- list Requirements for GeoKey. """ requirements = list() for line in open('requirements.txt').readlines(): if line.startswith('#') or line.startswith('git+https') or line == '': continue requirements.append(line.rstrip()) return requirements
def test_views_with_admin(self): group = UserGroupF.create() view = UserGroupData.as_view() request = HttpRequest() request.method = 'GET' request.user = group.project.creator response = view(request, project_id=group.project.id, group_id=group.id).render() rendered = render_to_string( 'users/usergroup_data.html', { 'group': group, 'user': group.project.creator, 'PLATFORM_NAME': get_current_site(request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(unicode(response.content), rendered) request = HttpRequest() request.method = 'POST' request.user = group.project.creator request.POST = {'permission': 'all', 'filters': ''} response = view(request, project_id=group.project.id, group_id=group.id).render() ref = Group.objects.get(pk=group.id) rendered = render_to_string( 'users/usergroup_data.html', { 'group': ref, 'user': ref.project.creator, 'PLATFORM_NAME': get_current_site(request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(unicode(response.content), rendered) self.assertIsNone(ref.filters) category = CategoryFactory.create(**{'project': group.project}) request = HttpRequest() request.method = 'POST' request.user = group.project.creator request.POST = { 'permission': 'restricted', 'filters': '{ "%s": { } }' % category.id } response = view(request, project_id=group.project.id, group_id=group.id).render() ref = Group.objects.get(pk=group.id) rendered = render_to_string( 'users/usergroup_data.html', { 'group': ref, 'user': ref.project.creator, 'PLATFORM_NAME': get_current_site(request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(unicode(response.content), rendered) self.assertEqual(ref.filters, json.loads('{ "%s": { } }' % category.id))