def test_startview_mixin_with_create_view(self):
        class StartView(views.StartFlowMixin, generic.CreateView):
            model = StartViewFlowEntity
            fields = []

        view = StartView.as_view()
        user = User.objects.create(username='******', is_superuser=True)

        # get
        request = RequestFactory().get('/start/')
        request.user = user
        request.resolver_match = resolve('/test/start/')
        response = view(request, flow_class=StartViewTestFlow, flow_task=StartViewTestFlow.start)

        self.assertEqual(response.template_name,
                         ('tests/test_views_start/startviewtest/start.html',
                          'tests/test_views_start/startviewtest/start.html',
                          'viewflow/flow/start.html'))

        # post
        request = RequestFactory().post('/start/')
        request.user = user
        request.resolver_match = resolve('/test/start/')
        response = view(request, flow_class=StartViewTestFlow, flow_task=StartViewTestFlow.start)
        self.assertEqual(response.status_code, 302)

        process = StartViewTestFlow.process_class.objects.all()[0]
        process.get_task(StartViewTestFlow.start, status=[STATUS.DONE])
Esempio n. 2
0
def post_fork(server, worker):
    import mimetypes
    mimetypes.init()
    # hacky way to address gunicorn gevent requests hitting django too early before urls are loaded
    # see: https://github.com/benoitc/gunicorn/issues/527#issuecomment-19601046
    from django.urls import resolve
    resolve('/')
Esempio n. 3
0
    def test_flowview(self):
        view = views.UpdateProcessView.as_view()
        user = User.objects.create(username='******', is_superuser=True)

        act = TaskViewTestFlow.start.run()
        task = act.process.get_task(TaskViewTestFlow.task)

        # assigned get
        act = task.activate()
        act.assign(user=user)

        request = RequestFactory().get('/start/')
        request.user = user
        request.resolver_match = resolve('/test/1/task/1/')
        response = view(request, flow_class=TaskViewTestFlow, flow_task=TaskViewTestFlow.task,
                        process_pk=act.process.pk, task_pk=task.pk)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.template_name,
                         ('tests/test_views_task/taskviewtest/task.html',
                          'tests/test_views_task/taskviewtest/task.html',
                          'viewflow/flow/task.html'))
        # assigned post
        request = RequestFactory().post('/task/')
        request.user = user
        request.resolver_match = resolve('/test/1/task/1/')
        response = view(request, flow_class=TaskViewTestFlow, flow_task=TaskViewTestFlow.task,
                        process_pk=act.process.pk, task_pk=task.pk)
        self.assertEqual(response.status_code, 302)

        task.refresh_from_db()
        self.assertEqual(task.status, STATUS.DONE)
Esempio n. 4
0
def create_new_url(url):
    match_kamerstuk = re.match("kst-(\d+)-(\d+)", url)
    match_dossier = re.match("/dossier/(\d+)", url)
    new_url = ''
    if match_kamerstuk:
        dossier_id = match_kamerstuk.group(1)
        sub_id = match_kamerstuk.group(2)
        kamerstukken = Kamerstuk.objects.filter(id_main=dossier_id, id_sub=sub_id)
        if kamerstukken.exists():
            new_url = reverse('kamerstuk', args=(dossier_id, sub_id,))
    elif match_dossier:
        dossier_id = match_dossier.group(1)
        if Dossier.objects.filter(dossier_id=dossier_id).exists():
            new_url = reverse('dossier-timeline', args=(dossier_id,))
    if not new_url:
        try:
            resolve(url)
            openkamer_url = True
        except Resolver404:
            openkamer_url = False
        if openkamer_url or url[0] == '#' or 'http' in url:  # openkamer, anchor or external url
            new_url = url
        else:
            if url[0] != '/':
                url = '/' + url
            new_url = 'https://zoek.officielebekendmakingen.nl' + url
    return new_url
Esempio n. 5
0
def get_resolver_matches_chain(request, data=None):
    """Walk the current request URL path up to the top, attempting to resolve along the way
    """
    from django.urls import Resolver404
    from django.urls import resolve
    resolver_matches_chain = []
    path = request.path
    resolver_matches_chain.append((path, request.resolver_match,))
    while path:
        try:
            path = path[:path.rindex('/')]
            resolver_match = resolve(path)
            resolver_matches_chain.append((path, resolver_match))
        except Resolver404:
            # could not resolve without '/'
            path_with_slash = path + '/'
            if request.path != path_with_slash:
                try:
                    resolver_match = resolve(path_with_slash)
                    resolver_matches_chain.append((path_with_slash, resolver_match))
                except Resolver404:
                    pass
        except ValueError:
            # '/' substring not found
            break
    return resolver_matches_chain
Esempio n. 6
0
    def test_urls(self):
        # This executes the code at the module level
        url = reverse('app_library')
        resolver = resolve(url)
        self.assertEqual('/apps/', url)
        self.assertEqual('library', resolver.func.__name__)
        self.assertEqual('tethys_apps.views', resolver.func.__module__)

        url = reverse('send_beta_feedback')
        resolver = resolve(url)
        self.assertEqual('/apps/send-beta-feedback/', url)
        self.assertEquals('send_beta_feedback_email', resolver.func.__name__)
        self.assertEqual('tethys_apps.views', resolver.func.__module__)

        url = reverse('test_app:home')
        resolver = resolve(url)
        self.assertEqual('/apps/test-app/', url)
        self.assertEquals('home', resolver.func.__name__)
        self.assertEqual('tethys_apps.tethysapp.test_app.controllers', resolver.func.__module__)

        url = reverse('test_extension:home', kwargs={'var1': 'foo', 'var2': 'bar'})
        resolver = resolve(url)
        self.assertEqual('/extensions/test-extension/foo/bar/', url)
        self.assertEquals('home', resolver.func.__name__)
        self.assertEqual('tethysext.test_extension.controllers', resolver.func.__module__)

        url = reverse('test_extension:home', args=['foo', 'bar'])
        resolver = resolve(url)
        self.assertEqual('/extensions/test-extension/foo/bar/', url)
        self.assertEquals('home', resolver.func.__name__)
        self.assertEqual('tethysext.test_extension.controllers', resolver.func.__module__)
    def test_task_cancel_view(self):
        act = ActionsTestFlow.start.run()
        view = views.CancelTaskView.as_view()
        task = act.process.get_task(ActionsTestFlow.task, status=[STATUS.NEW])

        # get
        request = RequestFactory().get('/cancel/')
        request.user = User(username='******', is_superuser=True)
        request.resolver_match = resolve('/test/')

        response = view(
            request, flow_class=ActionsTestFlow, flow_task=ActionsTestFlow.task,
            process_pk=act.process.pk, task_pk=task.pk)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.template_name,
                         ('tests/test_views_actions/actionstest/task_cancel.html',
                          'tests/test_views_actions/actionstest/task_cancel.html',
                          'viewflow/flow/task_cancel.html',
                          'viewflow/flow/task_action.html'))
        self.assertEqual(response.context_data['activation'].process, act.process)

        # post
        request = RequestFactory().post('/cancel/', {'run_action': 1})
        request.user = User(username='******', is_superuser=True)
        request.resolver_match = resolve('/test/')

        response = view(
            request, flow_class=ActionsTestFlow, flow_task=ActionsTestFlow.start,
            process_pk=act.process.pk, task_pk=task.pk)
        task.refresh_from_db()

        self.assertEqual(response.status_code, 302)
        self.assertEqual(task.status, STATUS.CANCELED)
        self.assertIsNotNone(task.finished)
    def test_process_cancel_view(self):
        act = ActionsTestFlow.start.run()
        view = views.CancelProcessView.as_view()

        # get
        request = RequestFactory().get('/cancel/')
        request.user = User(username='******', is_superuser=True)
        request.resolver_match = resolve('/test/')

        response = view(request, flow_class=ActionsTestFlow, process_pk=act.process.pk)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.template_name,
                         ('tests/test_views_actions/actionstest/process_cancel.html',
                          'viewflow/flow/process_cancel.html'))
        self.assertEqual(response.context_data['process'], act.process)

        self.assertEqual(len(response.context_data['active_tasks']), 1)
        self.assertEqual(response.context_data['uncancelable_tasks'], [])

        # post
        request = RequestFactory().post('/cancel/', {'_cancel_process': 1})
        request.user = User(username='******', is_superuser=True)
        request.resolver_match = resolve('/test/')

        response = view(request, flow_class=ActionsTestFlow, process_pk=act.process.pk)
        act.process.refresh_from_db()

        self.assertEqual(response.status_code, 302)
        self.assertEqual(act.process.status, STATUS.CANCELED)
        canceled_task = act.process.get_task(ActionsTestFlow.task, status=[STATUS.CANCELED])
        self.assertIsNotNone(canceled_task.finished)
Esempio n. 9
0
def internal_path_exists(path):
    """
    Validates that url path is registered and can properly be resolved
    in a django configuration.
    """
    try:
        resolve(path)
    except Http404:
        raise ValidationError("'{0}' is not a valid url.".format(path))
Esempio n. 10
0
    def test_apis_url_exist(self):
        try:
            # PostList
            resolve('/api/post/')

            # PostDetail
            resolve('/api/post/1/')
        except NoReverseMatch as e:
            self.fail(e)
Esempio n. 11
0
 def test_invalid_resolve(self):
     test_urls = [
         '/lookahead-/not-a-city/',
         '/lookbehind-/not-a-city/',
         '/lookahead+/other-city/',
         '/lookbehind+/other-city/',
     ]
     for test_url in test_urls:
         with self.assertRaises(Resolver404):
             resolve(test_url)
Esempio n. 12
0
def _get_return_path_from_post(request):
    return_path = request.POST.get('return_path')
    try:
        if not return_path:
            raise ValueError()
        if not return_path.startswith('/'):
            raise ValueError()
        resolve(return_path)
        return return_path
    except (Http404, ValueError):
        return None
Esempio n. 13
0
def is_valid_path(path, urlconf=None):
    """
    Return True if the given path resolves against the default URL resolver,
    False otherwise. This is a convenience method to make working with "is
    this a match?" cases easier, avoiding try...except blocks.
    """
    try:
        resolve(path, urlconf)
        return True
    except Resolver404:
        return False
Esempio n. 14
0
    def test_get_next_task_url_back(self):
        request = RequestFactory().get('/test/', {'back': '/test_back_url/'})
        request.user = User(username='******')
        request.resolver_match = resolve('/test/')

        next_url = views.get_next_task_url(request, None)
        self.assertEqual(next_url, '/test_back_url/')

        request = RequestFactory().get('/test/', {'back': 'http://unsafe.com/test_back_url/'})
        request.user = User(username='******')
        request.resolver_match = resolve('/test/')

        next_url = views.get_next_task_url(request, None)
        self.assertEqual(next_url, '/')
Esempio n. 15
0
    def reset_urls(self, urlconf_modules=None):
        """Reset `urls.py` for a set of Django apps."""

        if urlconf_modules is None:
            urlconf_modules = [settings.ROOT_URLCONF]
            if self.URLCONF_MODULES is not None:
                urlconf_modules.extend(self.URLCONF_MODULES)

        for urlconf in urlconf_modules:
            if urlconf in sys.modules:
                reload(sys.modules[urlconf])
        clear_url_caches()

        # Resolve a URL so that the new urlconf gets loaded
        resolve('/')
Esempio n. 16
0
    def test_admin_timeline_prunes_user_output(self):
        """multiple users in timeline is confusing."""
        admin = self.User.objects.create(username="******", email="*****@*****.**")
        admin.is_staff = True
        admin.is_superuser = True
        admin.save()

        # create a drip campaign that will surely give us duplicates.
        model_drip = Drip.objects.create(
            name="A Custom Week Ago", subject_template="HELLO {{ user.username }}", body_html_template="KETTEHS ROCK!"
        )
        QuerySetRule.objects.create(
            drip=model_drip,
            field_name="date_joined",
            lookup_type="gte",
            field_value=(timezone.now() - timedelta(days=1)).isoformat(),
        )

        # then get it's admin view.
        rf = RequestFactory()
        timeline_url = reverse(
            "admin:drip_timeline", kwargs={"drip_id": model_drip.id, "into_past": 3, "into_future": 3}
        )

        request = rf.get(timeline_url)
        request.user = admin

        match = resolve(timeline_url)

        response = match.func(request, *match.args, **match.kwargs)

        # check that our admin (not excluded from test) is shown once.
        self.assertEqual(unicode(response.content).count(admin.email), 1)
Esempio n. 17
0
 def test_developer_urls_services(self):
     url = reverse('services:wps_home')
     resolver = resolve(url)
     self.assertEqual('/developer/services/wps/', url)
     self.assertEqual('wps_home', resolver.func.__name__)
     self.assertEqual('tethys_services.views', resolver.func.__module__)
     self.assertEqual('services', resolver.namespaces[0])
Esempio n. 18
0
    def add_section(self, name, url, icon, action="formax", button="Save", nobutton=False, dependents=None):
        resolver = resolve(url)
        self.request.META["HTTP_X_FORMAX"] = 1
        self.request.META["HTTP_X_PJAX"] = 1

        start = time.time()

        open = self.request.GET.get("open", None)
        if open == name:  # pragma: needs cover
            action = "open"

        response = resolver.func(self.request, *resolver.args, **resolver.kwargs)

        # redirects don't do us any good
        if not isinstance(response, HttpResponseRedirect):
            self.sections.append(
                dict(
                    name=name,
                    url=url,
                    response=response.rendered_content,
                    icon=icon,
                    action=action,
                    button=button,
                    nobutton=nobutton,
                    dependents=dependents,
                )
            )

        if settings.DEBUG:
            print("%s took: %f" % (url, time.time() - start))
Esempio n. 19
0
    def test_user_urls_profile(self):
        url = reverse('user:profile', kwargs={'username': '******'})
        resolver = resolve(url)

        self.assertEqual('/user/foo/', url)
        self.assertEqual('profile', resolver.func.__name__)
        self.assertEqual('tethys_portal.views.user', resolver.func.__module__)
Esempio n. 20
0
 def test_developer_urls_gizmos(self):
     url = reverse('gizmos:showcase')
     resolver = resolve(url)
     self.assertEqual('/developer/gizmos/', url)
     self.assertEqual('index', resolver.func.__name__)
     self.assertEqual('tethys_gizmos.views.gizmo_showcase', resolver.func.__module__)
     self.assertEqual('gizmos', resolver.namespaces[0])
Esempio n. 21
0
 def test_converter_resolve(self):
     for url, (url_name, app_name, kwargs) in converter_test_data:
         with self.subTest(url=url):
             match = resolve(url)
             self.assertEqual(match.url_name, url_name)
             self.assertEqual(match.app_name, app_name)
             self.assertEqual(match.kwargs, kwargs)
Esempio n. 22
0
    def generate_stats(self, request, response):
        self.record_stats({
            'get': [(k, request.GET.getlist(k)) for k in sorted(request.GET)],
            'post': [(k, request.POST.getlist(k)) for k in sorted(request.POST)],
            'cookies': [(k, request.COOKIES.get(k)) for k in sorted(request.COOKIES)],
        })
        view_info = {
            'view_func': _("<no view>"),
            'view_args': 'None',
            'view_kwargs': 'None',
            'view_urlname': 'None',
        }
        try:
            match = resolve(request.path)
            func, args, kwargs = match
            view_info['view_func'] = get_name_from_obj(func)
            view_info['view_args'] = args
            view_info['view_kwargs'] = kwargs
            view_info['view_urlname'] = getattr(match, 'url_name',
                                                _("<unavailable>"))
        except Http404:
            pass
        self.record_stats(view_info)

        if hasattr(request, 'session'):
            self.record_stats({
                'session': [(k, request.session.get(k))
                            for k in sorted(request.session.keys(), key=force_text)]
            })
Esempio n. 23
0
def add_preserved_filters(context, url, popup=False, to_field=None):
    opts = context.get('opts')
    preserved_filters = context.get('preserved_filters')

    parsed_url = list(urlparse(url))
    parsed_qs = dict(parse_qsl(parsed_url[4]))
    merged_qs = {}

    if opts and preserved_filters:
        preserved_filters = dict(parse_qsl(preserved_filters))

        match_url = '/%s' % url.partition(get_script_prefix())[2]
        try:
            match = resolve(match_url)
        except Resolver404:
            pass
        else:
            current_url = '%s:%s' % (match.app_name, match.url_name)
            changelist_url = 'admin:%s_%s_changelist' % (opts.app_label, opts.model_name)
            if changelist_url == current_url and '_changelist_filters' in preserved_filters:
                preserved_filters = dict(parse_qsl(preserved_filters['_changelist_filters']))

        merged_qs.update(preserved_filters)

    if popup:
        from django.contrib.admin.options import IS_POPUP_VAR
        merged_qs[IS_POPUP_VAR] = 1
    if to_field:
        from django.contrib.admin.options import TO_FIELD_VAR
        merged_qs[TO_FIELD_VAR] = to_field

    merged_qs.update(parsed_qs)

    parsed_url[4] = urlencode(merged_qs)
    return urlunparse(parsed_url)
Esempio n. 24
0
    def dispatch(self, request, *args, **kwargs):
        # Set up since we need to super() later instead of earlier.
        self.request = request
        self.args = args
        self.kwargs = kwargs

        # Get the current object, url slug, and
        # urlpattern name (namespace aware).
        obj = self.get_object()
        slug = self.kwargs.get(self.slug_url_kwarg, None)
        match = resolve(request.path_info)
        url_parts = match.namespaces
        url_parts.append(match.url_name)
        current_urlpattern = ":".join(url_parts)

        # Figure out what the slug is supposed to be.
        if hasattr(obj, "get_canonical_slug"):
            canonical_slug = obj.get_canonical_slug()
        else:
            canonical_slug = self.get_canonical_slug()

        # If there's a discrepancy between the slug in the url and the
        # canonical slug, redirect to the canonical slug.
        if canonical_slug != slug:
            params = {self.pk_url_kwarg: obj.pk,
                      self.slug_url_kwarg: canonical_slug,
                      'permanent': True}
            return redirect(current_urlpattern, **params)

        return super(CanonicalSlugDetailMixin, self).dispatch(
            request, *args, **kwargs)
Esempio n. 25
0
 def test_url_namespace02(self):
     request = self.request_factory.get('/')
     request.resolver_match = resolve('/ns2/')
     template = self.engine.get_template('url-namespace02')
     context = RequestContext(request)
     output = template.render(context)
     self.assertEqual(output, '/ns2/named-client/42/')
Esempio n. 26
0
def server_error(request, template_name='500.html'):
    """
    500 error handler.
    """
    urlname = resolve(request.path).url_name
    submission_urls = [
        'receiver_secure_post',
        'receiver_secure_post_with_app_id',
        'receiver_post_with_app_id'
    ]
    if urlname in submission_urls + ['app_aware_restore']:
        return HttpResponse(status=500)

    domain = get_domain_from_url(request.path) or ''

    # hat tip: http://www.arthurkoziel.com/2009/01/15/passing-mediaurl-djangos-500-error-view/
    t = loader.get_template(template_name)
    type, exc, tb = sys.exc_info()

    traceback_text = format_traceback_the_way_python_does(type, exc, tb)
    traceback_key = uuid.uuid4().hex
    cache.cache.set(traceback_key, traceback_text, 60*60)

    return HttpResponseServerError(t.render(
        context={
            'MEDIA_URL': settings.MEDIA_URL,
            'STATIC_URL': settings.STATIC_URL,
            'domain': domain,
            '500traceback': traceback_key,
        },
        request=request,
    ))
Esempio n. 27
0
def reset_cached_api(request, apiurl):
    """
    This admin call gets the url of the original api that we wish to reset, backwards resolves that original function and gets its data back into cache
    :param request:
    :param apiurl:
    :return:
    """
    from undecorated import undecorated
    # from importlib import import_module
    try:
        match = resolve("/api/{}".format(apiurl))
        #mod = import_module(".".join(match.view_name.split(".")[:-1])) Dont actually need this, resolve gets us the func itself
        #func = mod.__getattribute__(match.func.func_name)

        if "django_cache" in match.func.func_dict:
            api_view = undecorated(match.func)
            redecorated_api_view = scache.django_cache(action="reset")(api_view)
            redecorated_api_view(request, *match.args, **match.kwargs)

            return HttpResponseRedirect("/api/{}".format(apiurl))
        else:
            raise Http404("API not in cache")

    except Resolver404 as re:
        logger.warn("Attempted to reset invalid url")
        raise Http404()
    except Exception as e:
        logger.warn("Unable to reset cache for {}".format(apiurl))
        raise Http404()
Esempio n. 28
0
    def get_via_uri(self, uri, request=None):
        """
        This pulls apart the salient bits of the URI and populates the
        resource via a ``obj_get``.

        Optionally accepts a ``request``.

        If you need custom behavior based on other portions of the URI,
        simply override this method.
        """
        prefix = get_script_prefix()
        chomped_uri = uri

        if prefix and chomped_uri.startswith(prefix):
            chomped_uri = chomped_uri[len(prefix) - 1:]

        try:
            view, args, kwargs = resolve(chomped_uri)
            resource_name = kwargs['resource_name']
            resource_class = self.resource_mapping[resource_name]
        except (Resolver404, KeyError):
            raise NotFound("The URL provided '%s' was not a link to a valid resource." % uri)

        parent_resource = resource_class(api_name=self._meta.api_name)
        kwargs = parent_resource.remove_api_resource_names(kwargs)
        bundle = Bundle(request=request)
        return parent_resource.obj_get(bundle, **kwargs)
Esempio n. 29
0
    def forced_auth_req(self, method, url, user=None, data=None, request_format='json', **kwargs):
        """
        Function that allows api methods to be called with forced authentication

        If `user` parameter not provided, then `self.user` will be used

        If `view` parameter is provided, then the `view` function
        will be called directly, otherwise `url` will be resolved
        """
        factory = APIRequestFactory()

        data = data or {}
        req_to_call = getattr(factory, method)
        request = req_to_call(url, data, format=request_format, **kwargs)

        user = user or self.user
        force_authenticate(request, user=user)

        if "view" in kwargs:
            view = kwargs.pop("view")
            response = view(request)
        else:
            view_info = resolve(url)
            view = view_info.func
            response = view(request, *view_info.args, **view_info.kwargs)

        if hasattr(response, 'render'):
            response.render()

        return response
Esempio n. 30
0
    def test_matching_urls(self):
        def no_converter(x):
            return x

        test_data = (
            ('int', {'0', '1', '01', 1234567890}, int),
            ('str', {'abcxyz'}, no_converter),
            ('path', {'allows.ANY*characters'}, no_converter),
            ('slug', {'abcxyz-ABCXYZ_01234567890'}, no_converter),
            ('uuid', {'39da9369-838e-4750-91a5-f7805cd82839'}, uuid.UUID),
        )
        for url_name, url_suffixes, converter in test_data:
            for url_suffix in url_suffixes:
                url = '/%s/%s/' % (url_name, url_suffix)
                with self.subTest(url=url):
                    match = resolve(url)
                    self.assertEqual(match.url_name, url_name)
                    self.assertEqual(match.kwargs, {url_name: converter(url_suffix)})
                    # reverse() works with string parameters.
                    string_kwargs = {url_name: url_suffix}
                    self.assertEqual(reverse(url_name, kwargs=string_kwargs), url)
                    # reverse() also works with native types (int, UUID, etc.).
                    if converter is not no_converter:
                        # The converted value might be different for int (a
                        # leading zero is lost in the conversion).
                        converted_value = match.kwargs[url_name]
                        converted_url = '/%s/%s/' % (url_name, converted_value)
                        self.assertEqual(reverse(url_name, kwargs={url_name: converted_value}), converted_url)
Esempio n. 31
0
 def test_admin_home_procedures_is_resolved(self):
     url = reverse('systemadministrator_procedures')
     self.assertEquals(resolve(url).func.view_class, ProcedureView)
Esempio n. 32
0
 def test_login_urls_is_resolved(self):
     url = reverse('login')
     self.assertEquals(resolve(url).func, user_login)
 def test_view_function(self):
     view = resolve('/reset/{uidb64}/{token}/'.format(uidb64=self.uid,
                                                      token=self.token))
     self.assertEquals(view.func.view_class,
                       auth_views.PasswordResetConfirmView)
Esempio n. 34
0
 def test_aboutpage_url_resolves_aboutpageview(self):
     view = resolve('/about')
     self.assertEqual(view.func.__name__,
                      AboutPageView.as_view().__name__)
 def test_view_function(self):
     view = resolve('/reset/done/')
     self.assertEquals(view.func.view_class,
                       auth_views.PasswordResetDoneView)
Esempio n. 36
0
 def test_signup_url_resolves_signup_view(self):
     view = resolve('/signup/')
     self.assertEquals(view.func, signup)
Esempio n. 37
0
 def test_homepage_url_resolves_homepageview(self):
     view = resolve('/')
     self.assertEqual(view.func.__name__,
                      HomePageView.as_view().__name__)
Esempio n. 38
0
 def test_resolve_root_url_to_home_page(self):
     found = resolve('/')
     self.assertEqual(found.func, home_page)
Esempio n. 39
0
 def test_new_topic_url_resolves_new_topic_view(self):
     view = resolve('/boards/1/new/')
     self.assertEquals(view.func, new_topic)
Esempio n. 40
0
 def test_url_for_homepageview_using_viewname(self):
     url = reverse('home')
     assert resolve(url).view_name == 'home'
Esempio n. 41
0
 def test_home_url_resolves_home_view(self):
     view = resolve('/')
     self.assertEquals(view.func, home)
Esempio n. 42
0
 def test_category_resolve(self):
     self.assertEqual(
         resolve('/board/test-board-slug/test-category-slug').view_name,
         'board:category')
Esempio n. 43
0
 def test_home_resolve(self):
     self.assertEqual(resolve('/board/').view_name, 'board:home')
Esempio n. 44
0
 def test_topic_resolve(self):
     self.assertEqual(
         resolve('/board/board-slug/category-slug/topic-slug').view_name,
         'board:topic')
Esempio n. 45
0
def test_redirect():
    assert reverse("users:redirect") == "/users/~redirect/"
    assert resolve("/users/~redirect/").view_name == "users:redirect"
Esempio n. 46
0
 def test_board_resolve(self):
     self.assertEqual(
         resolve('/board/test-board-slug').view_name, 'board:board')
Esempio n. 47
0
    def test_register_url_resolves_to_register_view(self):
        """ - Testing if register url points to registerpage view """

        url = resolve('/member/register')
        self.assertEqual(url.func, register)
Esempio n. 48
0
def test_detail(user: User):
    assert (reverse("users:detail",
                    kwargs={"username":
                            user.username}) == f"/users/{user.username}/")
    assert resolve(f"/users/{user.username}/").view_name == "users:detail"
Esempio n. 49
0
 def test_admin_home_is_resolved(self):
     url = reverse('systemadministrator_home')
     self.assertEquals(resolve(url).func.view_class, AdminView)
Esempio n. 50
0
def test_update():
    assert reverse("users:update") == "/users/~update/"
    assert resolve("/users/~update/").view_name == "users:update"
Esempio n. 51
0
    def test_modifypassword_url_resolves_to_modifypassword_view(self):
        """ - Testing if modifypassword url points to modifypassword view """

        url = resolve('/member/modifypassword')
        self.assertEqual(url.func, modifypassword)
Esempio n. 52
0
    def test_account_url_resolves_to_account_view(self):
        """ - Testing if account url points to accountpage view """

        url = resolve('/member/account')
        self.assertEqual(url.func, account)
Esempio n. 53
0
 def test_home_url_resolves(self):
     url = reverse('home')
     self.assertEquals(resolve(url).func, index)
Esempio n. 54
0
    def test_disconnect_url_resolves_to_disconnect_view(self):
        """ - Testing if disconnect url points to disconnectpage view """

        url = resolve('/member/disconnect')
        self.assertEqual(url.func, disconnect)
Esempio n. 55
0
 def test_url_for_postedit_using_viewname(self):
     url = reverse('post-edit', kwargs={'pk': 1})
     assert resolve(url).view_name == 'post-edit'
	def test_board_topics_url_resolves_board_topics_view(self):
		view = resolve(reverse('board_topics', kwargs={'pk': 1}))
		self.assertEquals(view.func.view_class, TopicListView)
Esempio n. 57
0
 def test_create_procedures_is_resolved(self):
     url = reverse('add_procedure')
     self.assertEquals(resolve(url).func, create_procedure)
Esempio n. 58
0
 def test_url_for_homepageview_using_view_classname(self):
     url = reverse('home')
     assert resolve(url).func.view_class == HomeView
Esempio n. 59
0
 def test_board_topics_url_resolves_board_topics_view(self):
     view = resolve('/boards/1/')
     self.assertEquals(view.func, board_topics)
Esempio n. 60
0
 def test_url_for_addpostview_using_viewname(self):
     url = reverse('add_post')
     assert resolve(url).view_name == 'add_post'