def test_nested_route(self):
router = ExtendedSimpleRouter()
(router.register(r'users', UserViewSet,
'user').register(r'groups',
GroupViewSet,
'users-group',
parents_query_lookups=['user']))
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(get_regex_pattern(router.urls[0]), r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(get_regex_pattern(router.urls[1]),
r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
# test users group list
self.assertEqual(router.urls[2].name, 'users-group-list')
self.assertEqual(
get_regex_pattern(router.urls[2]), r'^users/{0}/groups/$'.format(
self.get_parent_lookup_regex('user')))
# test users group detail
self.assertEqual(router.urls[3].name, 'users-group-detail')
self.assertEqual(
get_regex_pattern(router.urls[3]),
r'^users/{0}/groups/{1}/$'.format(
self.get_parent_lookup_regex('user'),
self.get_lookup_regex('pk')),
)
def test_nested_route_depth_3(self):
router = ExtendedSimpleRouter()
(router.register(r'users', UserViewSet, 'user').register(
r'groups',
GroupViewSet,
'users-group',
parents_query_lookups=['user']).register(r'permissions',
PermissionViewSet,
'users-groups-permission',
parents_query_lookups=[
'group__user',
'group',
]))
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(get_regex_pattern(router.urls[0]), r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(get_regex_pattern(router.urls[1]),
r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
# test users group list
self.assertEqual(router.urls[2].name, 'users-group-list')
self.assertEqual(
get_regex_pattern(router.urls[2]), r'^users/{0}/groups/$'.format(
self.get_parent_lookup_regex('user')))
# test users group detail
self.assertEqual(router.urls[3].name, 'users-group-detail')
self.assertEqual(
get_regex_pattern(router.urls[3]),
r'^users/{0}/groups/{1}/$'.format(
self.get_parent_lookup_regex('user'),
self.get_lookup_regex('pk')),
)
# test users groups permission list
self.assertEqual(router.urls[4].name, 'users-groups-permission-list')
self.assertEqual(
get_regex_pattern(router.urls[4]),
r'^users/{0}/groups/{1}/permissions/$'.format(
self.get_parent_lookup_regex('group__user'),
self.get_parent_lookup_regex('group'),
))
# test users groups permission detail
self.assertEqual(router.urls[5].name, 'users-groups-permission-detail')
self.assertEqual(
get_regex_pattern(router.urls[5]),
r'^users/{0}/groups/{1}/permissions/{2}/$'.format(
self.get_parent_lookup_regex('group__user'),
self.get_parent_lookup_regex('group'),
self.get_lookup_regex('pk')),
)
def test_urls_have_trailing_slash_by_default(self):
router = ExtendedSimpleRouter()
router.register(r'router-viewset', RouterViewSet)
urls = router.urls
for exp in ['^router-viewset/$',
'^router-viewset/(?P<pk>[^/.]+)/$',
'^router-viewset/list_controller/$',
'^router-viewset/(?P<pk>[^/.]+)/detail_controller/$']:
msg = 'Should find url pattern with regexp %s' % exp
self.assertIsNotNone(get_url_pattern_by_regex_pattern(urls, exp), msg=msg)
def test_one_route(self):
router = ExtendedSimpleRouter()
router.register(r'users', UserViewSet, 'user')
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(get_regex_pattern(router.urls[0]), r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(get_regex_pattern(router.urls[1]), r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
def test_urls_have_trailing_slash_by_default(self):
router = ExtendedSimpleRouter()
router.register(r'router-viewset', RouterViewSet)
urls = router.urls
lookup_allowed_symbols = get_lookup_allowed_symbols()
for exp in ['^router-viewset/$',
'^router-viewset/{0}/$'.format(lookup_allowed_symbols),
'^router-viewset/list_controller/$',
'^router-viewset/{0}/detail_controller/$'.format(lookup_allowed_symbols)]:
msg = 'Should find url pattern with regexp %s' % exp
self.assertIsNotNone(get_url_pattern_by_regex_pattern(urls, exp), msg=msg)
def test_urls_can_have_trailing_slash_removed(self):
router = ExtendedSimpleRouter(trailing_slash=False)
router.register(r'router-viewset', RouterViewSet)
urls = router.urls
lookup_allowed_symbols = get_lookup_allowed_symbols(
force_dot=get_rest_framework_features()['allow_dot_in_lookup_regex_without_trailing_slash']
)
for exp in ['^router-viewset$',
'^router-viewset/{0}$'.format(lookup_allowed_symbols),
'^router-viewset/list_controller$',
'^router-viewset/{0}/detail_controller$'.format(lookup_allowed_symbols)]:
msg = 'Should find url pattern with regexp %s' % exp
self.assertIsNotNone(get_url_pattern_by_regex_pattern(urls, exp), msg=msg)
def test_urls_can_have_trailing_slash_removed(self):
router = ExtendedSimpleRouter(trailing_slash=False)
router.register(r'router-viewset', RouterViewSet)
urls = router.urls
if get_rest_framework_features()['allow_dot_in_lookup_regex_without_trailing_slash']:
lookup_allowed_symbols = '(?P<pk>[^/.]+)'
else:
lookup_allowed_symbols = '(?P<pk>[^/]+)'
for exp in ['^router-viewset$',
'^router-viewset/' + lookup_allowed_symbols + r'$',
'^router-viewset/list_controller$',
'^router-viewset/' + lookup_allowed_symbols + '/detail_controller$']:
msg = 'Should find url pattern with regexp %s' % exp
self.assertIsNotNone(get_url_pattern_by_regex_pattern(urls, exp), msg=msg)
from rest_framework_extensions.routers import ExtendedSimpleRouter, DefaultRouter router = ExtendedSimpleRouter() urlpatterns = router.urls
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import (ChartStyleViewSet, PartViewSet, NestedSheetViewSet,
SheetViewSet, NestedOperationViewSet,
OperationMethodViewSet, OperationTypeViewSet,
OperationViewSet)
router = ExtendedSimpleRouter(trailing_slash=False)
router.register(r'chart_styles',
ChartStyleViewSet,
base_name='chartstyle')
router.register(r'operation_methods',
OperationMethodViewSet,
base_name='operationmethod')
router.register(r'operation_types',
OperationTypeViewSet,
base_name='operationtype')
router.register(r'operations',
OperationViewSet,
base_name='operation')
(router.register(r'parts', PartViewSet, base_name='part')
.register(r'sheets',
NestedSheetViewSet,
'parts-sheet',
parents_query_lookups=['part']))
from rest_framework import routers
from rest_framework_extensions.routers import ExtendedSimpleRouter
from surveys.views import surveys_views, survey_responses_views
survey_responses_router = ExtendedSimpleRouter()
survey_responses_router.register(
r'surveys', surveys_views.SurveysViewSet,
basename='surveys').register(r'survey-responses',
survey_responses_views.SurveyResponsesViewSet,
basename='survey-responses',
parents_query_lookups=['survey_id'])
slashless_survey_responses_router = routers.DefaultRouter(trailing_slash=False)
slashless_survey_responses_router.registry = survey_responses_router.registry[:]
from .. import views
from ..authentication import EmployeeAuthentication, StaffAuthentication
from ..models import Employee, EmployeeToken, Staff, StaffToken
from ..serializers import EmployeePasswordSerializer, StaffPasswordSerializer
app_name = 'business'
router = SimpleRouter()
router.register(r'store', views.StoreViewSet, base_name='store')
router.register(r'food', views.FoodViewSet, base_name='food')
router.register(r'menu', views.MenuViewSet, base_name='menu')
router.register(r'ingredient', views.IngredientViewSet, base_name='ingredient')
router.register(r'orderedfood',
views.OrderedFoodViewSet,
base_name='orderedfood')
router_extended = ExtendedSimpleRouter()
router_extended.register(r'store', views.StoreViewSet,
base_name='store').register(
r'openingperiods',
views.StoreOpeningPeriodViewSet,
base_name='store-openingperiods',
parents_query_lookups=['pk'])
router_extended.register(r'store', views.StoreViewSet,
base_name='store').register(
r'holidayperiods',
views.StoreHolidayPeriodViewSet,
base_name='store-holidayperiods',
parents_query_lookups=['pk'])
router_extended.register(r'store', views.StoreViewSet,
base_name='store').register(
r'periods',
AssessmentsImagesView, AssessmentSyncView, RespondentTypeList,
ShareYourStoryAPIView, SurveyUserSummary,
SurveyBoundaryNeighbourInfoAPIView, AnswerViewSet,
SurveyBoundaryNeighbourDetailAPIView, SurveyDetailEBoundaryAPIView,
SurveyUsersCountAPIView, SurveyBoundaryAPIView, SurveyInstitutionAPIView,
BoundaryQuestionGroupMapping, SurveyAssociateBoundaryAPIView,
SurveyAssociateInstitutionAPIView, SurveyPartnersViewSet,
SurveySourceViewSet, SurveyTypeListView,
SurveyQuestionGroupQDetailsAPIView, SurveyInstitutionLocationAPIView,
SurveyGPAPIView, SurveyQuestionGroupQuestionKeyYearComparisonAPIView)
from schools.api_view import (InstitutionViewSet, StudentViewSet,
StudentGroupViewSet)
from rest_framework import routers
from rest_framework_extensions.routers import ExtendedSimpleRouter
nested_router = ExtendedSimpleRouter()
simple_router = routers.DefaultRouter()
simple_router.register(r'surveys/questions',
QuestionViewSet,
basename='survey-questions')
#survey/partner URL
simple_router.register(r'surveys/partners',
SurveyPartnersViewSet,
basename='survey-partners')
simple_router.register(r'surveys/sources',
SurveySourceViewSet,
basename='survey-sources')
# surveys -> questiongroup -> questions
from django.urls import path, include
from rest_framework import routers
import items.urls
import orders.urls
from items.views import ItemViewSet, CategoryViewSet, FavouriteViewSet, FavouriteItemViewSet
from orders.views import (Order_itemViewSet, OrderViewSet, Order_detailViewSet,
updateStock, PosSystems, BalanceCheckAPIView,
BalanceCheckDetail, PosCheckAPIView)
# TodoViewSet
from actors.views import UserViewSet, CustomerViewSet, login
import actors.urls
from rest_framework_extensions.routers import ExtendedSimpleRouter
from django.conf import settings
from django.conf.urls.static import static
category_item_router = ExtendedSimpleRouter()
(category_item_router.register(r'categories',
UserViewSet,
basename='categories').register(
r'items',
ItemViewSet,
'categories_item',
parents_query_lookups=['category']))
user_favourite_router = ExtendedSimpleRouter()
(user_favourite_router.register(r'users', UserViewSet,
basename='users').register(
r'favourite',
FavouriteViewSet,
'users_favourite',
parents_query_lookups=['user']))
favourite_item_router = ExtendedSimpleRouter()
from projects.views import (
ProjectViewSet,
ProjectPhaseViewSet,
ProjectTypeSchemaViewSet,
ProjectTypeViewSet,
ProjectSubtypeViewSet,
CommentViewSet,
DocumentViewSet,
ReportViewSet,
)
app_name = "projects"
router = routers.SimpleRouter()
projects_router = ExtendedSimpleRouter()
projects = projects_router.register(r"projects", ProjectViewSet, base_name="projects")
projects.register(
r"comments",
CommentViewSet,
base_name="project-comments",
parents_query_lookups=["project"],
)
router.registry.extend(projects_router.registry)
router.register(r"projecttypes", ProjectTypeViewSet)
router.register(r"projectsubtypes", ProjectSubtypeViewSet)
router.register(r"phases", ProjectPhaseViewSet)
router.register(r"schemas", ProjectTypeSchemaViewSet)
router.register(r"reports", ReportViewSet)
router.register(r"projects/(?P<project_pk>[^/.]+)/documents", DocumentViewSet)
def test_nested_route_depth_3_custom_regex(self):
"""
Nested routes with over two level of depth should respect all parents'
`lookup_value_regex` attribute.
"""
router = ExtendedSimpleRouter()
(router.register(r'users', CustomRegexUserViewSet, 'user').register(
r'groups',
CustomRegexGroupViewSet,
'users-group',
parents_query_lookups=['user'
]).register(r'permissions',
CustomRegexPermissionViewSet,
'users-groups-permission',
parents_query_lookups=[
'group__user',
'group',
]))
# custom regex configuration
user_viewset_regex = CustomRegexUserViewSet.lookup_value_regex
group_viewset_regex = CustomRegexGroupViewSet.lookup_value_regex
perm_viewset_regex = CustomRegexPermissionViewSet.lookup_value_regex
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(get_regex_pattern(router.urls[0]), r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(
get_regex_pattern(router.urls[1]), r'^users/{0}/$'.format(
self.get_custom_regex_lookup('pk', user_viewset_regex)))
# test users group list
self.assertEqual(router.urls[2].name, 'users-group-list')
self.assertEqual(
get_regex_pattern(router.urls[2]), r'^users/{0}/groups/$'.format(
self.get_custom_regex_parent_lookup('user',
user_viewset_regex)))
# test users group detail
self.assertEqual(router.urls[3].name, 'users-group-detail')
self.assertEqual(
get_regex_pattern(router.urls[3]),
r'^users/{0}/groups/{1}/$'.format(
self.get_custom_regex_parent_lookup('user',
user_viewset_regex),
self.get_custom_regex_lookup('pk', group_viewset_regex)),
)
# test users groups permission list
self.assertEqual(router.urls[4].name, 'users-groups-permission-list')
self.assertEqual(
get_regex_pattern(router.urls[4]),
r'^users/{0}/groups/{1}/permissions/$'.format(
self.get_custom_regex_parent_lookup('group__user',
user_viewset_regex),
self.get_custom_regex_parent_lookup('group',
group_viewset_regex),
))
# test users groups permission detail
self.assertEqual(router.urls[5].name, 'users-groups-permission-detail')
self.assertEqual(
get_regex_pattern(router.urls[5]),
r'^users/{0}/groups/{1}/permissions/{2}/$'.format(
self.get_custom_regex_parent_lookup('group__user',
user_viewset_regex),
self.get_custom_regex_parent_lookup('group',
group_viewset_regex),
self.get_custom_regex_lookup('pk', perm_viewset_regex)),
)
class NestedRouterMixinTestBehaviour__generic_relations(APITestCase):
router = ExtendedSimpleRouter()
# tasks route
(router.register(r'tasks',
TaskViewSet).register(r'comments',
TaskCommentViewSet,
'tasks-comment',
parents_query_lookups=['object_id'
]))
# books route
(router.register(r'books',
BookViewSet).register(r'comments',
BookCommentViewSet,
'books-comment',
parents_query_lookups=['object_id'
]))
urls = router.urls
def setUp(self):
self.tasks = {
'one': TaskModel.objects.create(id=1, title='Task one'),
'two': TaskModel.objects.create(id=2, title='Task two'),
}
self.books = {
'one': BookModel.objects.create(id=1, title='Book one'),
'two': BookModel.objects.create(id=2, title='Book two'),
}
self.comments = {
'for_task_one':
CommentModel.objects.create(id=1,
content_object=self.tasks['one'],
text=u'Comment for task one'),
'for_task_two':
CommentModel.objects.create(id=2,
content_object=self.tasks['two'],
text=u'Comment for task two'),
'for_book_one':
CommentModel.objects.create(id=3,
content_object=self.books['one'],
text=u'Comment for book one'),
'for_book_two':
CommentModel.objects.create(id=4,
content_object=self.books['two'],
text=u'Comment for book two'),
}
def assertResult(self, response, result):
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, result)
def test_comments_for_tasks(self):
url = '/tasks/{0}/comments/'.format(self.tasks['one'].id, )
response = self.client.get(url)
self.assertResult(
response,
[{
'id': self.comments['for_task_one'].id,
'content_type': self.comments['for_task_one'].content_type.id,
'object_id': self.comments['for_task_one'].object_id,
'text': self.comments['for_task_one'].text,
}])
url = '/tasks/{0}/comments/'.format(self.tasks['two'].id, )
response = self.client.get(url)
self.assertResult(
response,
[{
'id': self.comments['for_task_two'].id,
'content_type': self.comments['for_task_two'].content_type.id,
'object_id': self.comments['for_task_two'].object_id,
'text': self.comments['for_task_two'].text,
}])
def test_comments_for_books(self):
url = '/books/{0}/comments/'.format(self.books['one'].id, )
response = self.client.get(url)
self.assertResult(
response,
[{
'id': self.comments['for_book_one'].id,
'content_type': self.comments['for_book_one'].content_type.id,
'object_id': self.comments['for_book_one'].object_id,
'text': self.comments['for_book_one'].text,
}])
url = '/books/{0}/comments/'.format(self.books['two'].id, )
response = self.client.get(url)
self.assertResult(
response,
[{
'id': self.comments['for_book_two'].id,
'content_type': self.comments['for_book_two'].content_type.id,
'object_id': self.comments['for_book_two'].object_id,
'text': self.comments['for_book_two'].text,
}])
class NestedRouterMixinTestBehaviourBase(APITestCase):
router = ExtendedSimpleRouter()
# main routes
(router.register(r'users', UserViewSet).register(
r'groups',
GroupViewSet,
'users-group',
parents_query_lookups=['user_groups']).register(
r'permissions',
PermissionViewSet,
'users-groups-permission',
parents_query_lookups=['group__user', 'group']))
# register on one depth
permissions_routes = router.register(r'permissions', PermissionViewSet)
permissions_routes.register(r'groups',
GroupViewSet,
'permissions-group',
parents_query_lookups=['permissions'])
permissions_routes.register(r'users',
UserViewSet,
'permissions-user',
parents_query_lookups=['groups__permissions'])
# simple routes
router.register(r'groups', GroupViewSet, 'group')
router.register(r'permissions', PermissionViewSet, 'permission')
urls = router.urls
def setUp(self):
self.users = {
'vova': UserModel.objects.create(id=1, name='vova'),
'gena': UserModel.objects.create(id=2, name='gena'),
}
self.groups = {
'users': GroupModel.objects.create(id=3, name='users'),
'admins': GroupModel.objects.create(id=4, name='admins'),
'super_admins': GroupModel.objects.create(id=5,
name='super_admins'),
}
self.permissions = {
'read': PermissionModel.objects.create(id=6, name='read'),
'update': PermissionModel.objects.create(id=7, name='update'),
'delete': PermissionModel.objects.create(id=8, name='delete'),
}
# add permissions to groups
self.groups['users'].permissions = [self.permissions['read']]
self.groups['admins'].permissions = [
self.permissions['read'],
self.permissions['update'],
]
self.groups['super_admins'].permissions = [
self.permissions['read'],
self.permissions['update'],
self.permissions['delete'],
]
# add groups to users
self.users['vova'].groups = [self.groups['users']]
self.users['gena'].groups = [
self.groups['admins'],
self.groups['super_admins'],
]
PageViewSet,
SectionViewSet,
PageInSectionAPIView,
#ContentImageAPIView,
#HtmlContentImageList,
)
'''routerPage = routers.SimpleRouter()
routerPage.register(r'page', PageViewSet)
routerImg = routers.SimpleRouter()
routerImg.register(r'image', HtmlContentImageList)
routerSection = routers.SimpleRouter()
routerSection.register(r'section', SectionModelViewSet)'''
sectionRouter = ExtendedSimpleRouter()
(sectionRouter.register(r'sections', SectionViewSet,
base_name='section').register(
r'pages',
PageInSectionAPIView,
base_name='sections-page',
parents_query_lookups=['section_id']))
pageRouter = ExtendedSimpleRouter()
(pageRouter.register(r'pages', PageViewSet, base_name='page'))
categoryRouter = ExtendedSimpleRouter()
(sectionRouter.register(r'categories', CategoryViewSet, base_name='category'))
blogRouter = ExtendedSimpleRouter()
(blogRouter.register(r'blogs', BlogViewSet, base_name='blog'))
urlpatterns = [
class NestedRouterMixinTestBehaviour__parent_viewset_lookup(APITestCase):
router = ExtendedSimpleRouter()
# main routes
(router.register(r'users', UserViewSetWithEmailLookup).register(
r'groups',
GroupViewSet,
'users-group',
parents_query_lookups=['user_groups__email']))
urls = router.urls
def setUp(self):
self.users = {
'vova':
UserModel.objects.create(id=1,
name='vova',
email='*****@*****.**'),
'gena':
UserModel.objects.create(id=2,
name='gena',
email='*****@*****.**'),
}
self.groups = {
'users': GroupModel.objects.create(id=3, name='users'),
'admins': GroupModel.objects.create(id=4, name='admins'),
'super_admins': GroupModel.objects.create(id=5,
name='super_admins'),
}
# add groups to users
self.users['vova'].groups = [self.groups['users']]
self.users['gena'].groups = [
self.groups['admins'],
self.groups['super_admins'],
]
def test_users_detail(self):
url = '/users/{0}/'.format(self.users['gena'].email)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
expected = {
'id': self.users['gena'].id,
'name': self.users['gena'].name
}
self.assertEqual(response.data, expected)
def test_users_groups(self):
url = '/users/{0}/groups/'.format(self.users['gena'].email)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
expected = [{
'id': self.groups['admins'].id,
'name': self.groups['admins'].name
}, {
'id': self.groups['super_admins'].id,
'name': self.groups['super_admins'].name
}]
msg = 'Groups should be filtered by user'
self.assertEqual(response.data, expected, msg=msg)
def test_users_groups_detail(self):
url = '/users/{user_email}/groups/{group_pk}/'.format(
user_email=self.users['gena'].email,
group_pk=self.groups['admins'].id)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
expected = {
'id': self.groups['admins'].id,
'name': self.groups['admins'].name
}
self.assertEqual(response.data, expected)
def test_users_groups_detail__if_user_has_no_such_group(self):
url = '/users/{user_email}/groups/{group_pk}/'.format(
user_email=self.users['gena'].email,
group_pk=self.groups['users'].id)
response = self.client.get(url)
msg = 'If user has no requested group it should return 404'
self.assertEqual(response.status_code, 404, msg=msg)
# class NestedRouterMixinTestBehaviour__generic_relations1(APITestCase):
# router = ExtendedSimpleRouter()
# # tasks route
# (
# router.register(r'tasks', TaskViewSet)
# .register(r'', TaskCommentViewSet, 'tasks-comment', parents_query_lookups=['object_id'])
# )
# # books route
# (
# router.register(r'books', BookViewSet)
# .register(r'', BookCommentViewSet, 'books-comment', parents_query_lookups=['object_id'])
# )
#
# urls = router.urls
#
# def setUp(self):
# self.tasks = {
# 'one': TaskModel.objects.create(id=1, title='Task one'),
# 'two': TaskModel.objects.create(id=2, title='Task two'),
# }
# self.books = {
# 'one': BookModel.objects.create(id=1, title='Book one'),
# 'two': BookModel.objects.create(id=2, title='Book two'),
# }
# self.comments = {
# 'for_task_one': CommentModel.objects.create(
# id=1,
# content_object=self.tasks['one'],
# text=u'Comment for task one'
# ),
# 'for_task_two': CommentModel.objects.create(
# id=2,
# content_object=self.tasks['two'],
# text=u'Comment for task two'
# ),
# 'for_book_one': CommentModel.objects.create(
# id=3,
# content_object=self.books['one'],
# text=u'Comment for book one'
# ),
# 'for_book_two': CommentModel.objects.create(
# id=4,
# content_object=self.books['two'],
# text=u'Comment for book two'
# ),
# }
#
# def test_me(self):
# print 'hell'
