Python urlparser.UrlParser类代码示例

    def test_assemble_data_with_non_api_callback(self):
        bad_pattern = patterns('', url(r'^some_view/', NonApiView.as_view()))

        urlparser = UrlParser()
        data = urlparser.__assemble_endpoint_data__(bad_pattern)

        self.assertIsNone(data)

 def get_apis_for_resource(self, filter_path):
     urlparser = UrlParser()
     urlconf = getattr(self.request, "urlconf", None)
     apis = urlparser.get_apis(urlconf=urlconf, filter_path=filter_path)
     authorized_apis = filter(lambda a: self.handle_resource_access(self.request, a['pattern']), apis)
     authorized_apis_list = list(authorized_apis)
     return authorized_apis_list

    def test_flatten_url_tree_url_import_with_routers(self):
        from django.contrib.auth.models import User

        class MockApiViewSet(ModelViewSet):
            serializer_class = CommentSerializer
            model = User

        class AnotherMockApiViewSet(ModelViewSet):
            serializer_class = CommentSerializer
            model = User

        router = DefaultRouter()
        router.register(r'other_views', MockApiViewSet)
        router.register(r'more_views', MockApiViewSet)

        urls_app = patterns('',
            url(r'^', include(router.urls))
        )
        urls = patterns('',
            url(r'api/', include(urls_app)),
            url(r'test/', include(urls_app))
        )
        urlparser = UrlParser()
        apis = urlparser.get_apis(urls)

        self.assertEqual(sum(api['path'].find('api') != -1 for api in apis), 4)
        self.assertEqual(sum(api['path'].find('test') != -1 for api in apis), 4)

    def test_get_api_callback_not_rest_view(self):
        urlparser = UrlParser()
        non_api = patterns('',
            url(r'something', NonApiView.as_view())
        )
        callback = urlparser.__get_pattern_api_callback__(non_api)

        self.assertIsNone(callback)

    def test_flatten_url_tree_url_import(self):
        urls = patterns('',
            url(r'api/base/path/', include(self.url_patterns))
        )
        urlparser = UrlParser()
        apis = urlparser.get_apis(urls)

        self.assertEqual(len(self.url_patterns), len(apis))

    def test_flatten_url_tree_excluded_namesapce(self):
        urls = patterns('',
            url(r'api/base/path/', include(self.url_patterns, namespace='exclude'))
        )
        urlparser = UrlParser()
        apis = urlparser.__flatten_patterns_tree__(patterns=urls, exclude_namespaces='exclude')

        self.assertEqual([], apis)

 def get_resources(self):
     urlparser = UrlParser()
     urlconf = getattr(self.request, "urlconf", None)
     apis = urlparser.get_apis(
         urlconf=urlconf,
         exclude_namespaces=rfs.SWAGGER_SETTINGS.get('exclude_namespaces'))
     resources = urlparser.get_top_level_apis(apis)
     return resources

    def get_resources(self):
        api_prefixes = SWAGGER_SETTINGS.get('api_prefixes')
        if api_prefixes:
            return [endpoint.strip("/") for endpoint in api_prefixes]

        urlparser = UrlParser()
        apis = urlparser.get_apis(exclude_namespaces=SWAGGER_SETTINGS.get('exclude_namespaces'))
        return urlparser.get_top_level_apis(apis)

    def test_get_apis(self):
        urlparser = UrlParser()
        urls = import_module(settings.ROOT_URLCONF)
        # Overwrite settings with test patterns
        urls.urlpatterns = self.url_patterns
        apis = urlparser.get_apis()

        for api in apis:
            self.assertIn(api['pattern'], self.url_patterns)

 def get_resources(self):
     urlparser = UrlParser()
     urlconf = getattr(self.request, "urlconf", None)
     exclude_namespaces = rfs.SWAGGER_SETTINGS.get('exclude_namespaces')
     apis = urlparser.get_apis(urlconf=urlconf, exclude_namespaces=exclude_namespaces)
     authorized_apis = filter(lambda a: self.handle_resource_access(self.request, a['pattern']), apis)
     authorized_apis_list = list(authorized_apis)
     resources = urlparser.get_top_level_apis(authorized_apis_list)
     return resources

    def test_get_serializer_set(self):
        class SerializedAPI(ListCreateAPIView):
            serializer_class = CommentSerializer

        urlparser = UrlParser()
        url_patterns = patterns('', url(r'my-api/', SerializedAPI.as_view()))
        apis = urlparser.get_apis(url_patterns)

        docgen = DocumentationGenerator()
        serializers = docgen.__get_serializer_set__(apis)

        self.assertIn(CommentSerializer, serializers)

    def test_assemble_endpoint_data(self):
        """
        Tests that the endpoint data is correctly packaged
        """
        urlparser = UrlParser()
        pattern = self.url_patterns[0]

        data = urlparser.__assemble_endpoint_data__(pattern)

        self.assertEqual(data['path'], '/a-view/')
        self.assertEqual(data['callback'], MockApiView)
        self.assertEqual(data['pattern'], pattern)

    def get_api_for_resource(self, filter_path, version=None):
        root_router = get_router(version)
        url_parser = UrlParser()
        fp = filter_path.split("/")
        route_name = fp[-1]
        nests = fp[:-1]
        router = root_router
        try:
            for nest in nests:
                router = next(cr for cr in router.children_routers if cr.parent_prefix == nest)
            route = next(r for r in router.registry if r[0] == route_name)
        except StopIteration:
            raise Http404

        return url_parser.get_apis(patterns=patterns("", *router.get_partial_urls([route])))

    def test_exclude_router_api_root(self):
        from django.contrib.auth.models import User

        class MyViewSet(ModelViewSet):
            serializer_class = CommentSerializer
            model = User

        router = DefaultRouter()
        router.register('test', MyViewSet)

        urls_created = len(router.urls)

        parser = UrlParser()
        apis = parser.get_apis(router.urls)

        self.assertEqual(4, urls_created - len(apis))

    def get_resources(self):
        urlparser = UrlParser()
        apis = urlparser.get_apis(exclude_namespaces=SWAGGER_SETTINGS.get('exclude_namespaces'))
        # Swagger urlparser has bug that causes exclude_namespaces to not work in some cases
        # In our case we dont want to include all urls from all modules to same documentation
        # so instead we check that the apis url (current url) can be found from the endpoints url.
        # If not then it belogn to another module and we dont include it to documentation.
        filtered_apis = []
        p = self.request_path.replace('api-docs/', '')
        for endpoint in apis:
            try:
                str(endpoint['path']).index(p)
                filtered_apis.append(endpoint)
            except ValueError:
                pass

        return urlparser.get_top_level_apis(filtered_apis)