def test_get_resource_name():
view = APIView()
context = {'view': view}
with override_settings(JSON_API_FORMAT_TYPES=None):
assert 'APIViews' == utils.get_resource_name(context), 'not formatted'
context = {'view': view}
with override_settings(JSON_API_FORMAT_TYPES='dasherize'):
assert 'api-views' == utils.get_resource_name(
context), 'derived from view'
view.model = get_user_model()
assert 'users' == utils.get_resource_name(
context), 'derived from view model'
view.resource_name = 'custom'
assert 'custom' == utils.get_resource_name(context), 'manually set on view'
view.response = Response(status=403)
assert 'errors' == utils.get_resource_name(context), 'handles 4xx error'
view.response = Response(status=500)
assert 'errors' == utils.get_resource_name(context), 'handles 500 error'
view = GenericAPIView()
view.serializer_class = ResourceSerializer
context = {'view': view}
assert 'users' == utils.get_resource_name(
context), 'derived from serializer'
view.serializer_class.Meta.resource_name = 'rcustom'
assert 'rcustom' == utils.get_resource_name(context), 'set on serializer'
view = GenericAPIView()
view.serializer_class = NonModelResourceSerializer
context = {'view': view}
assert 'users' == utils.get_resource_name(
context), 'derived from non-model serializer'
def test_render_no_pagination3(self):
obj = {'results': [{'foo': 'bar'}, {'spam': 'eggs'}]}
renderer = DatatablesRenderer()
view = APIView()
view._datatables_total_count = 4
view._datatables_filtered_count = 2
request = view.initialize_request(
self.factory.get('/api/foo/?format=datatables&draw=1'))
content = renderer.render(obj, 'application/json', {
'request': request,
'view': view
})
expected = {
'recordsTotal': 4,
'recordsFiltered': 2,
'data': [{
'foo': 'bar'
}, {
'spam': 'eggs'
}],
'draw': 1
}
self.assertEquals(json.loads(content.decode('utf-8')), expected)
def test_auth_data_no_org_or_resource(api_client, data_source, hsa_params_factory):
hsa_params = {
"username": "******",
"data_source": data_source,
}
params = hsa_params_factory(**hsa_params)
# Create a fake DRF request
request_factory = APIRequestFactory()
http_request = request_factory.get("/", params)
request = APIView().initialize_request(http_request)
auth = HaukiSignedAuthentication()
(authenticated_user, auth) = auth.authenticate(request)
assert authenticated_user.id is not None
assert authenticated_user.username == "test_user"
assert auth.user == authenticated_user
assert auth.user_origin.data_source == data_source
assert auth.has_organization_rights is False
assert auth.organization is None
assert auth.resource is None
def test_auth_data_resource_data_source_id(
api_client,
data_source,
resource_factory,
resource_origin_factory,
hsa_params_factory,
):
resource = resource_factory()
resource_origin = resource_origin_factory(
resource=resource, data_source=data_source, origin_id="12345"
)
hsa_params = {
"username": "******",
"data_source": data_source,
"resource": "{}:{}".format(
resource_origin.data_source.id, resource_origin.origin_id
),
}
params = hsa_params_factory(**hsa_params)
# Create a fake DRF request
request_factory = APIRequestFactory()
http_request = request_factory.get("/", params)
request = APIView().initialize_request(http_request)
auth = HaukiSignedAuthentication()
(authenticated_user, auth) = auth.authenticate(request)
assert authenticated_user.id is not None
assert authenticated_user.username == "test_user"
assert auth.user == authenticated_user
assert auth.user_origin.data_source == data_source
assert auth.has_organization_rights is False
assert auth.organization is None
assert auth.resource == resource
def test_is_owner(self):
# Get should return true even for unauthenticated requests
request = self.factory.get(reverse('user-detail', args=[self.user.pk]))
view_method = UserViewset.as_view({'get': 'list'})
perm = IsOwnerOrReadOnly()
self.assertTrue(
perm.has_object_permission(request, view_method,
self.user.profile))
# Put should return false if the wrong guest is authenticated
other_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
view = BingoCardViewset.as_view({'put': 'update'})
request = APIRequestFactory().put(
reverse('user-detail', args=[self.user.pk]),
instance=self.user,
data={'username': '******'},
)
force_authenticate(request, user=other_user)
request = APIView().initialize_request(request)
self.assertFalse(
perm.has_object_permission(request, view_method, self.card))
def request(method, *args, **kwargs):
request = getattr(APIRequestFactory(), method)(*args, **kwargs)
return APIView().initialize_request(request)
from django.core.paginator import EmptyPage, InvalidPage, Page, Paginator
from django.db.models import Q
from django.shortcuts import render
from django.views import View
from django.http import QueryDict
from rest_framework import permissions, status
from rest_framework.response import Response
from rest_framework.views import APIView
class {{cookiecutter.project_name}}APIView(APIView):
def prepare_parameters(self, params: QueryDict) -> dict:
new_params = {}
# This converts a query dict into a normal dictionary
# However, it preserves lists if a list of query parameters is given
params = {k: v[0] if len(v) == 1 else v for k, v in params.lists()}
for key, value in params.items():
if value in ["true", "True"]:
new_params[key] = True
elif value in ["false", "False"]:
new_params[key] = False
else:
new_params[key] = value
return new_params
class {{cookiecutter.project_name}}BaseListView({{cookiecutter.project_name}}APIView):
def get_query_filter(self, request) -> Q:
raise NotImplementedError("This is an abstract method!")
def get_pagination_info(self, request) -> (int, int):
def test_can_create_serializer(self):
ds = Dataset.objects.get(pk=1)
names = DatasetNameField(field1_en='en1', field2_en='en2')
names.save()
setattr(ds, "names", names)
p1 = Polygon(((0, 0), (0, 1), (1, 1), (0, 0)))
p2 = Polygon(((1, 1), (1, 2), (2, 2), (1, 1)))
mpoly = MultiPolygon(p1, p2)
polygon = MapPolygon(lat='42.7302',
lon='73.6788',
field1=1.0,
field2=2.0,
mpoly=mpoly,
dataset=ds)
polygon.save()
df1 = DataField(dataset=ds,
field_type='I',
field_name='int_data',
field_en='test1')
df1.save()
df2 = DataField(dataset=ds,
field_type='F',
field_name='float_data',
field_en='test2')
df2.save()
df3 = DataField(dataset=ds,
field_type='C',
field_name='char_data',
field_en='test3')
df3.save()
tag1 = Tag(dataset=ds, tag="tag1")
tag1.save()
tag2 = Tag(dataset=ds, tag="tag2")
tag2.save()
tag3 = Tag(dataset=ds, tag="tag3")
tag3.save()
element1 = DataElement(mapelement=polygon, datafield=df1, int_data=23)
element1.save()
element2 = DataElement(mapelement=polygon,
datafield=df2,
float_data=2.34)
element2.save()
element3 = DataElement(mapelement=polygon,
datafield=df3,
char_data='abc')
element3.save()
request = HttpRequest()
qdict = QueryDict('', mutable=True)
qdict.update({'tags': 'tag1,tag2,tag3'})
qdict.update({'street': '8th St', 'city': 'Troy', 'state': 'NY'})
qdict.update({
'max_lat': '52.5',
'min_lat': '18.9',
'max_lon': '108.1',
'min_lon': '22.1'
})
qdict.update({'radius': 5, 'center': '42.7302,73.6788'})
request.GET = qdict
# convert the HTTP Request object to a REST framework Request object
self.request = APIView().initialize_request(request)
serializer = CountPointsSerializer(context={'request': self.request})
count = serializer.get_count(polygon)
self.assertEqual(count['test1'], 23)
self.assertEqual(count['test2'], 2.34)
self.assertEqual(count['en2'], 2.0)
def test_returns_none_if_pk_is_missing(self):
serializer = Serializer()
view = APIView()
view.kwargs = {}
serializer.context['view'] = view
self.assertIsNone(get_entity_pk(serializer))
def test_get_request_filters(self):
""" Verify the method removes query parameters with empty values """
request = APIRequestFactory().get('/?q=')
request = APIView().initialize_request(request)
filters = HaystackRequestFilterMixin.get_request_filters(request)
assert filters == {}
def oauth2_user(value):
return APIView().initialize_request(value).user
class BlogViewSet(viewsets.ModelViewSet):
permission_classes = (IsAuthenticated,)
apiView = APIView()
queryset = Blog.objects.all().order_by('title')
serializer_class = BlogSerializer
def test_get_object_permission(self):
# TODO: add real tests after logic is determined in permission
req = self.factory.get('/')
req.session = self.session
view = APIView()
self.assertTrue(self.permission.has_object_permission(req, view))
def test_set_custom_inspector_class_via_settings(self):
with override_settings(REST_FRAMEWORK={'DEFAULT_SCHEMA_CLASS': 'tests.test_schemas.CustomViewInspector'}):
view = APIView()
assert isinstance(view.schema, CustomViewInspector)
def _get_request(self, *args, **kwargs):
req = self.factory.get(*args, **kwargs)
return APIView().initialize_request(req)
def test_get_resource_name_with_errors(status_code):
view = APIView()
context = {"view": view}
view.response = Response(status=status_code)
assert "errors" == get_resource_name(context)
def perform_authentication(self, request):
myview = APIView()
init_request = myview.initialize_request(request)
myview.perform_authentication(init_request)
return init_request.user.username
def test_apiview_schema_descriptor(self):
view = APIView()
assert hasattr(view, 'schema')
assert isinstance(view.schema, AutoSchema)
def get_request(self, endpoint):
# create an instance of a GET request.
raw_request = self.request_factory.get(endpoint)
drf_request = APIView().initialize_request(raw_request)
return drf_request
def test_returns_pk_value_if_present(self):
serializer = Serializer()
view = APIView()
view.kwargs = {'pk': 'foo'}
serializer.context['view'] = view
self.assertEqual('foo', get_entity_pk(serializer))
def view():
return APIView()
