authentik.stages.prompt.tests API documentation

def setUp(self): View Source

 29    def setUp(self):
 30        super().setUp()
 31        self.user = create_test_admin_user()
 32        self.factory = RequestFactory()
 33        self.flow = create_test_flow()
 34        username_prompt = Prompt.objects.create(
 35            name=generate_id(),
 36            field_key="username_prompt",
 37            label="USERNAME_LABEL",
 38            type=FieldTypes.USERNAME,
 39            required=True,
 40            placeholder="USERNAME_PLACEHOLDER",
 41            initial_value="akuser",
 42        )
 43        text_prompt = Prompt.objects.create(
 44            name=generate_id(),
 45            field_key="text_prompt",
 46            label="TEXT_LABEL",
 47            type=FieldTypes.TEXT,
 48            required=True,
 49            placeholder="TEXT_PLACEHOLDER",
 50            initial_value="some text",
 51        )
 52        text_area_prompt = Prompt.objects.create(
 53            name=generate_id(),
 54            field_key="text_area_prompt",
 55            label="TEXT_AREA_LABEL",
 56            type=FieldTypes.TEXT_AREA,
 57            required=True,
 58            placeholder="TEXT_AREA_PLACEHOLDER",
 59            initial_value="some text",
 60        )
 61        email_prompt = Prompt.objects.create(
 62            name=generate_id(),
 63            field_key="email_prompt",
 64            label="EMAIL_LABEL",
 65            type=FieldTypes.EMAIL,
 66            required=True,
 67            placeholder="EMAIL_PLACEHOLDER",
 68            initial_value="email@example.com",
 69        )
 70        password_prompt = Prompt.objects.create(
 71            name=generate_id(),
 72            field_key="password_prompt",
 73            label="PASSWORD_LABEL",
 74            type=FieldTypes.PASSWORD,
 75            required=True,
 76            placeholder="PASSWORD_PLACEHOLDER",
 77            initial_value="supersecurepassword",
 78        )
 79        password2_prompt = Prompt.objects.create(
 80            name=generate_id(),
 81            field_key="password2_prompt",
 82            label="PASSWORD_LABEL",
 83            type=FieldTypes.PASSWORD,
 84            required=True,
 85            placeholder="PASSWORD_PLACEHOLDER",
 86            initial_value="supersecurepassword",
 87        )
 88        number_prompt = Prompt.objects.create(
 89            name=generate_id(),
 90            field_key="number_prompt",
 91            label="NUMBER_LABEL",
 92            type=FieldTypes.NUMBER,
 93            required=True,
 94            placeholder="NUMBER_PLACEHOLDER",
 95            initial_value="42",
 96        )
 97        hidden_prompt = Prompt.objects.create(
 98            name=generate_id(),
 99            field_key="hidden_prompt",
100            type=FieldTypes.HIDDEN,
101            required=True,
102            placeholder="HIDDEN_PLACEHOLDER",
103            initial_value="something idk",
104        )
105        static_prompt = Prompt.objects.create(
106            name=generate_id(),
107            field_key="static_prompt",
108            type=FieldTypes.STATIC,
109            required=True,
110            placeholder="static",
111            initial_value="something idk",
112        )
113        radio_button_group = Prompt.objects.create(
114            name=generate_id(),
115            field_key="radio_button_group",
116            type=FieldTypes.RADIO_BUTTON_GROUP,
117            required=True,
118            placeholder="test",
119            initial_value="test",
120        )
121        dropdown = Prompt.objects.create(
122            name=generate_id(),
123            field_key="dropdown",
124            type=FieldTypes.DROPDOWN,
125            required=True,
126        )
127        self.stage = PromptStage.objects.create(name="prompt-stage")
128        self.stage.fields.set(
129            [
130                username_prompt,
131                text_prompt,
132                email_prompt,
133                password_prompt,
134                password2_prompt,
135                number_prompt,
136                hidden_prompt,
137                static_prompt,
138                radio_button_group,
139                dropdown,
140            ]
141        )
142
143        self.prompt_data = {
144            username_prompt.field_key: "test-username",
145            text_prompt.field_key: "test-input",
146            text_area_prompt.field_key: "test-area-input",
147            email_prompt.field_key: "test@test.test",
148            password_prompt.field_key: "test",
149            password2_prompt.field_key: "test",
150            number_prompt.field_key: 3,
151            hidden_prompt.field_key: hidden_prompt.initial_value,
152            static_prompt.field_key: static_prompt.initial_value,
153            radio_button_group.field_key: radio_button_group.initial_value,
154            dropdown.field_key: "",
155        }
156
157        self.binding = FlowStageBinding.objects.create(target=self.flow, stage=self.stage, order=2)
158
159        self.request = RequestFactory().get("/")
160        self.request.user = create_test_admin_user()
161        self.flow_executor = FlowExecutorView(request=self.request)
162        self.stage_view = PromptStageView(self.flow_executor, request=self.request)

Hook method for setting up the test fixture before exercising it.

def test_inline_file_field(self): View Source

164    def test_inline_file_field(self):
165        """test InlineFileField"""
166        with self.assertRaises(ValidationError):
167            InlineFileField().to_internal_value("foo")
168        with self.assertRaises(ValidationError):
169            InlineFileField().to_internal_value("data:foo/bar;foo,qwer")
170        self.assertEqual(
171            InlineFileField().to_internal_value("data:mine/type;base64,Zm9v"),
172            "data:mine/type;base64,Zm9v",
173        )
174        self.assertEqual(
175            InlineFileField().to_internal_value("data:mine/type;base64,Zm9vqwer"),
176            "data:mine/type;base64,Zm9vqwer",
177        )

test InlineFileField

def test_render(self): View Source

179    def test_render(self):
180        """Test render of form, check if all prompts are rendered correctly"""
181        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
182        session = self.client.session
183        session[SESSION_KEY_PLAN] = plan
184        session.save()
185
186        response = self.client.get(
187            reverse("authentik_api:flow-executor", kwargs={"flow_slug": self.flow.slug})
188        )
189        self.assertEqual(response.status_code, 200)
190        for prompt in self.stage.fields.all():
191            self.assertIn(prompt.field_key, response.content.decode())
192            self.assertIn(prompt.label, response.content.decode())
193            self.assertIn(prompt.placeholder, response.content.decode())

Test render of form, check if all prompts are rendered correctly

def test_valid_challenge_with_policy(self): View Source

195    def test_valid_challenge_with_policy(self):
196        """Test challenge_response validation"""
197        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
198        expr = (
199            "return request.context['prompt_data']['password_prompt'] "
200            "== request.context['prompt_data']['password2_prompt']"
201        )
202        expr_policy = ExpressionPolicy.objects.create(name="validate-form", expression=expr)
203        self.stage.validation_policies.set([expr_policy])
204        self.stage.save()
205        challenge_response = PromptChallengeResponse(
206            None,
207            stage_instance=self.stage,
208            plan=plan,
209            data=self.prompt_data,
210            stage=self.stage_view,
211        )
212        self.assertEqual(challenge_response.is_valid(), True)

Test challenge_response validation

def test_invalid_challenge(self): View Source

214    def test_invalid_challenge(self):
215        """Test challenge_response validation"""
216        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
217        expr = "False"
218        expr_policy = ExpressionPolicy.objects.create(name=generate_id(), expression=expr)
219        self.stage.validation_policies.set([expr_policy])
220        self.stage.save()
221        challenge_response = PromptChallengeResponse(
222            None, stage_instance=self.stage, plan=plan, data=self.prompt_data, stage=self.stage_view
223        )
224        self.assertEqual(challenge_response.is_valid(), False)

Test challenge_response validation

def test_invalid_challenge_multiple(self): View Source

226    def test_invalid_challenge_multiple(self):
227        """Test challenge_response validation (multiple policies)"""
228        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
229        expr_policy1 = ExpressionPolicy.objects.create(name=generate_id(), expression="False")
230        expr_policy2 = ExpressionPolicy.objects.create(name=generate_id(), expression="False")
231        self.stage.validation_policies.set([expr_policy1, expr_policy2])
232        self.stage.save()
233        challenge_response = PromptChallengeResponse(
234            None, stage_instance=self.stage, plan=plan, data=self.prompt_data, stage=self.stage_view
235        )
236        self.assertEqual(challenge_response.is_valid(), False)

Test challenge_response validation (multiple policies)

def test_valid_challenge_request(self): View Source

238    def test_valid_challenge_request(self):
239        """Test a request with valid challenge_response data"""
240        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
241        session = self.client.session
242        session[SESSION_KEY_PLAN] = plan
243        session.save()
244
245        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
246        expr = (
247            "return request.context['prompt_data']['password_prompt'] "
248            "== request.context['prompt_data']['password2_prompt']"
249        )
250        expr_policy = ExpressionPolicy.objects.create(name=generate_id(), expression=expr)
251        self.stage.validation_policies.set([expr_policy])
252        self.stage.save()
253        challenge_response = PromptChallengeResponse(
254            None, stage_instance=self.stage, plan=plan, data=self.prompt_data, stage=self.stage_view
255        )
256        self.assertEqual(challenge_response.is_valid(), True)
257
258        with patch("authentik.flows.views.executor.FlowExecutorView.cancel", MagicMock()):
259            response = self.client.post(
260                reverse(
261                    "authentik_api:flow-executor",
262                    kwargs={"flow_slug": self.flow.slug},
263                ),
264                challenge_response.validated_data,
265            )
266        self.assertEqual(response.status_code, 200)
267        self.assertStageRedirects(response, reverse("authentik_core:root-redirect"))
268
269        # Check that valid data has been saved
270        session = self.client.session
271        plan: FlowPlan = session[SESSION_KEY_PLAN]
272        data = plan.context[PLAN_CONTEXT_PROMPT]
273        for prompt in self.stage.fields.all():
274            prompt: Prompt
275            self.assertEqual(data[prompt.field_key], self.prompt_data[prompt.field_key])

Test a request with valid challenge_response data

def test_invalid_password(self): View Source

277    def test_invalid_password(self):
278        """Test challenge_response validation"""
279        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
280        self.prompt_data["password2_prompt"] = "qwerqwerqr"
281        challenge_response = PromptChallengeResponse(
282            None, stage_instance=self.stage, plan=plan, data=self.prompt_data, stage=self.stage_view
283        )
284        self.assertEqual(challenge_response.is_valid(), False)
285        self.assertEqual(
286            challenge_response.errors,
287            {"non_field_errors": [ErrorDetail(string="Passwords don't match.", code="invalid")]},
288        )

Test challenge_response validation

def test_invalid_username(self): View Source

290    def test_invalid_username(self):
291        """Test challenge_response validation"""
292        user = create_test_admin_user()
293        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
294        self.prompt_data["username_prompt"] = user.username
295        challenge_response = PromptChallengeResponse(
296            None, stage_instance=self.stage, plan=plan, data=self.prompt_data, stage=self.stage_view
297        )
298        self.assertEqual(challenge_response.is_valid(), False)
299        self.assertEqual(
300            challenge_response.errors,
301            {"username_prompt": [ErrorDetail(string="Username is already taken.", code="invalid")]},
302        )

Test challenge_response validation

def test_invalid_choice_field(self): View Source

304    def test_invalid_choice_field(self):
305        """Test invalid choice field value"""
306        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
307        self.prompt_data["radio_button_group"] = "some invalid choice"
308        self.prompt_data["dropdown"] = "another invalid choice"
309        challenge_response = PromptChallengeResponse(
310            None, stage_instance=self.stage, plan=plan, data=self.prompt_data, stage=self.stage_view
311        )
312        self.assertEqual(challenge_response.is_valid(), False)
313        self.assertEqual(
314            challenge_response.errors,
315            {
316                "radio_button_group": [
317                    ErrorDetail(
318                        string=f"\"{self.prompt_data['radio_button_group']}\" "
319                        "is not a valid choice.",
320                        code="invalid_choice",
321                    )
322                ],
323                "dropdown": [
324                    ErrorDetail(
325                        string=f"\"{self.prompt_data['dropdown']}\" is not a valid choice.",
326                        code="invalid_choice",
327                    )
328                ],
329            },
330        )

Test invalid choice field value

def test_static_hidden_overwrite(self): View Source

332    def test_static_hidden_overwrite(self):
333        """Test that static and hidden fields ignore any value sent to them"""
334        plan = FlowPlan(flow_pk=self.flow.pk.hex, bindings=[self.binding], markers=[StageMarker()])
335        plan.context[PLAN_CONTEXT_PROMPT] = {"hidden_prompt": "hidden"}
336        self.prompt_data["hidden_prompt"] = "foo"
337        self.prompt_data["static_prompt"] = "foo"
338        challenge_response = PromptChallengeResponse(
339            None, stage_instance=self.stage, plan=plan, data=self.prompt_data, stage=self.stage_view
340        )
341        self.assertEqual(challenge_response.is_valid(), True)
342        self.assertNotEqual(challenge_response.validated_data["hidden_prompt"], "foo")
343        self.assertEqual(challenge_response.validated_data["hidden_prompt"], "hidden")
344        self.assertNotEqual(challenge_response.validated_data["static_prompt"], "foo")

Test that static and hidden fields ignore any value sent to them

def test_prompt_placeholder(self): View Source

346    def test_prompt_placeholder(self):
347        """Test placeholder and expression"""
348        context = {
349            "foo": generate_id(),
350        }
351        prompt: Prompt = Prompt(
352            field_key="text_prompt_expression",
353            label="TEXT_LABEL",
354            type=FieldTypes.TEXT,
355            placeholder="return prompt_context['foo']",
356            placeholder_expression=True,
357        )
358        self.assertEqual(
359            prompt.get_placeholder(context, self.user, self.factory.get("/")), context["foo"]
360        )

Test placeholder and expression

def test_prompt_placeholder_does_not_take_value_from_context(self): View Source

362    def test_prompt_placeholder_does_not_take_value_from_context(self):
363        """Test placeholder does not automatically take value from context"""
364        context = {
365            "foo": generate_id(),
366        }
367        prompt: Prompt = Prompt(
368            field_key="text_prompt_expression",
369            label="TEXT_LABEL",
370            type=FieldTypes.TEXT,
371            placeholder="return prompt_context['foo']",
372            placeholder_expression=True,
373        )
374        context["text_prompt_expression"] = generate_id()
375
376        self.assertEqual(
377            prompt.get_placeholder(context, self.user, self.factory.get("/")), context["foo"]
378        )

Test placeholder does not automatically take value from context

def test_prompt_initial_value(self): View Source

380    def test_prompt_initial_value(self):
381        """Test initial_value and expression"""
382        context = {
383            "foo": generate_id(),
384        }
385        prompt: Prompt = Prompt(
386            field_key="text_prompt_expression",
387            label="TEXT_LABEL",
388            type=FieldTypes.TEXT,
389            initial_value="return prompt_context['foo']",
390            initial_value_expression=True,
391        )
392        self.assertEqual(
393            prompt.get_initial_value(context, self.user, self.factory.get("/")), context["foo"]
394        )
395        context["text_prompt_expression"] = generate_id()
396        self.assertEqual(
397            prompt.get_initial_value(context, self.user, self.factory.get("/")),
398            context["text_prompt_expression"],
399        )
400        self.assertNotEqual(
401            prompt.get_initial_value(context, self.user, self.factory.get("/")), context["foo"]
402        )

Test initial_value and expression

def test_choice_prompts_placeholder_and_initial_value_no_choices(self): View Source

404    def test_choice_prompts_placeholder_and_initial_value_no_choices(self):
405        """Test placeholder and initial value of choice fields with 0 choices"""
406        context = {}
407
408        prompt: Prompt = Prompt(
409            field_key="fixed_choice_prompt_expression",
410            label="LABEL",
411            type=FieldTypes.RADIO_BUTTON_GROUP,
412            placeholder="return []",
413            placeholder_expression=True,
414            initial_value="Invalid choice",
415            initial_value_expression=False,
416        )
417        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
418        self.assertEqual(prompt.get_initial_value(context, self.user, self.factory.get("/")), "")
419        self.assertEqual(prompt.get_choices(context, self.user, self.factory.get("/")), tuple())

Test placeholder and initial value of choice fields with 0 choices

def test_choice_prompts_placeholder_and_initial_value_single_choice(self): View Source

421    def test_choice_prompts_placeholder_and_initial_value_single_choice(self):
422        """Test placeholder and initial value of choice fields with 1 choice"""
423        context = {"foo": generate_id()}
424
425        prompt: Prompt = Prompt(
426            field_key="fixed_choice_prompt_expression",
427            label="LABEL",
428            type=FieldTypes.DROPDOWN,
429            placeholder=context["foo"],
430            placeholder_expression=False,
431            initial_value=context["foo"],
432            initial_value_expression=False,
433        )
434        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
435        self.assertEqual(
436            prompt.get_initial_value(context, self.user, self.factory.get("/")), context["foo"]
437        )
438        self.assertEqual(
439            prompt.get_choices(context, self.user, self.factory.get("/")), (context["foo"],)
440        )
441
442        prompt: Prompt = Prompt(
443            field_key="fixed_choice_prompt_expression",
444            label="LABEL",
445            type=FieldTypes.DROPDOWN,
446            placeholder="return [prompt_context['foo']]",
447            placeholder_expression=True,
448            initial_value="return prompt_context['foo']",
449            initial_value_expression=True,
450        )
451        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
452        self.assertEqual(
453            prompt.get_initial_value(context, self.user, self.factory.get("/")), context["foo"]
454        )
455        self.assertEqual(
456            prompt.get_choices(context, self.user, self.factory.get("/")), (context["foo"],)
457        )

Test placeholder and initial value of choice fields with 1 choice

def test_choice_prompts_placeholder_and_initial_value_single_choice_dict(self): View Source

459    def test_choice_prompts_placeholder_and_initial_value_single_choice_dict(self):
460        """Test placeholder and initial value of dict choice fields with 1 choice"""
461        context = {"foo": {"label": "foo", "value": generate_id()}}
462
463        prompt: Prompt = Prompt(
464            field_key="fixed_choice_prompt_expression",
465            label="LABEL",
466            type=FieldTypes.DROPDOWN,
467            placeholder=context["foo"],
468            placeholder_expression=False,
469            initial_value=context["foo"]["value"],
470            initial_value_expression=False,
471        )
472        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
473        self.assertEqual(
474            prompt.get_initial_value(context, self.user, self.factory.get("/")),
475            context["foo"]["value"],
476        )
477        self.assertEqual(
478            prompt.get_choices(context, self.user, self.factory.get("/")), (context["foo"],)
479        )
480
481        prompt: Prompt = Prompt(
482            field_key="fixed_choice_prompt_expression",
483            label="LABEL",
484            type=FieldTypes.DROPDOWN,
485            placeholder="return [prompt_context['foo']]",
486            placeholder_expression=True,
487            initial_value="return prompt_context['foo']['value']",
488            initial_value_expression=True,
489        )
490        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
491        self.assertEqual(
492            prompt.get_initial_value(context, self.user, self.factory.get("/")),
493            context["foo"]["value"],
494        )
495        self.assertEqual(
496            prompt.get_choices(context, self.user, self.factory.get("/")), (context["foo"],)
497        )

Test placeholder and initial value of dict choice fields with 1 choice

def test_choice_prompts_placeholder_and_initial_value_multiple_choices(self): View Source

499    def test_choice_prompts_placeholder_and_initial_value_multiple_choices(self):
500        """Test placeholder and initial value of choice fields with multiple choices"""
501        context = {}
502
503        prompt: Prompt = Prompt(
504            field_key="fixed_choice_prompt_expression",
505            label="LABEL",
506            type=FieldTypes.RADIO_BUTTON_GROUP,
507            placeholder="return ['test', True, 42]",
508            placeholder_expression=True,
509        )
510        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
511        self.assertEqual(
512            prompt.get_initial_value(context, self.user, self.factory.get("/")), "test"
513        )
514        self.assertEqual(
515            prompt.get_choices(context, self.user, self.factory.get("/")), ("test", True, 42)
516        )
517
518        prompt: Prompt = Prompt(
519            field_key="fixed_choice_prompt_expression",
520            label="LABEL",
521            type=FieldTypes.RADIO_BUTTON_GROUP,
522            placeholder="return ['test', True, 42]",
523            placeholder_expression=True,
524            initial_value="return True",
525            initial_value_expression=True,
526        )
527        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
528        self.assertEqual(prompt.get_initial_value(context, self.user, self.factory.get("/")), True)
529        self.assertEqual(
530            prompt.get_choices(context, self.user, self.factory.get("/")), ("test", True, 42)
531        )

Test placeholder and initial value of choice fields with multiple choices

def test_choice_prompts_placeholder_and_initial_value_multiple_choices_dict(self): View Source

533    def test_choice_prompts_placeholder_and_initial_value_multiple_choices_dict(self):
534        """Test placeholder and initial value of dict choice fields with multiple dict choices"""
535        context = {}
536
537        prompt: Prompt = Prompt(
538            field_key="fixed_choice_prompt_expression",
539            label="LABEL",
540            type=FieldTypes.RADIO_BUTTON_GROUP,
541            placeholder="return ["
542            "{'label': 'Option 1', 'value': 'value1'},"
543            "{'label': 'Option 2', 'value': 'value2'}"
544            "]",
545            placeholder_expression=True,
546        )
547        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
548        self.assertEqual(
549            prompt.get_initial_value(context, self.user, self.factory.get("/")).get("value"),
550            "value1",
551        )
552        self.assertEqual(
553            tuple(
554                (choice["label"], choice["value"])
555                for choice in prompt.get_choices(context, self.user, self.factory.get("/"))
556            ),
557            (("Option 1", "value1"), ("Option 2", "value2")),
558        )
559
560        prompt: Prompt = Prompt(
561            field_key="fixed_choice_prompt_expression",
562            label="LABEL",
563            type=FieldTypes.RADIO_BUTTON_GROUP,
564            placeholder="return ["
565            "{'label': 'Option 1', 'value': 'value1'},"
566            "{'label': 'Option 2', 'value': 'value2'}"
567            "]",
568            placeholder_expression=True,
569            initial_value="return 'value2'",
570            initial_value_expression=True,
571        )
572        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
573        self.assertEqual(
574            prompt.get_initial_value(context, self.user, self.factory.get("/")), "value2"
575        )
576        self.assertEqual(
577            tuple(
578                (choice["label"], choice["value"])
579                for choice in prompt.get_choices(context, self.user, self.factory.get("/"))
580            ),
581            (("Option 1", "value1"), ("Option 2", "value2")),
582        )

Test placeholder and initial value of dict choice fields with multiple dict choices

def test_choice_prompts_placeholder_and_initial_value_from_context(self): View Source

584    def test_choice_prompts_placeholder_and_initial_value_from_context(self):
585        """Test placeholder and initial value of choice fields with values from context"""
586        rand_value = generate_id()
587        context = {
588            "fixed_choice_prompt_expression": rand_value,
589            "fixed_choice_prompt_expression__choices": ["test", 42, rand_value],
590        }
591
592        prompt: Prompt = Prompt(
593            field_key="fixed_choice_prompt_expression",
594            label="LABEL",
595            type=FieldTypes.RADIO_BUTTON_GROUP,
596        )
597        self.assertEqual(prompt.get_placeholder(context, self.user, self.factory.get("/")), "")
598        self.assertEqual(
599            prompt.get_initial_value(context, self.user, self.factory.get("/")), rand_value
600        )
601        self.assertEqual(
602            prompt.get_choices(context, self.user, self.factory.get("/")), ("test", 42, rand_value)
603        )

Test placeholder and initial value of choice fields with values from context

def test_initial_value_not_valid_choice(self): View Source

605    def test_initial_value_not_valid_choice(self):
606        """Test initial_value not a valid choice"""
607        context = {}
608        prompt: Prompt = Prompt(
609            field_key="choice_prompt",
610            label="TEXT_LABEL",
611            type=FieldTypes.DROPDOWN,
612            placeholder="choice",
613            initial_value="another_choice",
614        )
615        self.assertEqual(
616            prompt.get_choices(context, self.user, self.factory.get("/")),
617            ("choice",),
618        )
619        self.assertEqual(
620            prompt.get_initial_value(context, self.user, self.factory.get("/")),
621            "choice",
622        )

Test initial_value not a valid choice

def test_choices_are_none_for_non_choice_fields(self): View Source

624    def test_choices_are_none_for_non_choice_fields(self):
625        """Test choices are None for non choice fields"""
626        context = {}
627        prompt: Prompt = Prompt(
628            field_key="text_prompt_expression",
629            label="TEXT_LABEL",
630            type=FieldTypes.TEXT,
631            placeholder="choice",
632        )
633        self.assertEqual(
634            prompt.get_choices(context, self.user, self.factory.get("/")),
635            None,
636        )

Test choices are None for non choice fields

def test_prompt_placeholder_error(self): View Source

638    def test_prompt_placeholder_error(self):
639        """Test placeholder and expression"""
640        context = {}
641        prompt: Prompt = Prompt(
642            field_key="text_prompt_expression",
643            label="TEXT_LABEL",
644            type=FieldTypes.TEXT,
645            placeholder="something invalid dunno",
646            placeholder_expression=True,
647        )
648        self.assertEqual(
649            prompt.get_placeholder(context, self.user, self.factory.get("/")),
650            "something invalid dunno",
651        )

Test placeholder and expression

def test_prompt_placeholder_disabled(self): View Source

653    def test_prompt_placeholder_disabled(self):
654        """Test placeholder and expression"""
655        context = {}
656        prompt: Prompt = Prompt(
657            field_key="text_prompt_expression",
658            label="TEXT_LABEL",
659            type=FieldTypes.TEXT,
660            placeholder="return prompt_context['foo']",
661            placeholder_expression=False,
662        )
663        self.assertEqual(
664            prompt.get_placeholder(context, self.user, self.factory.get("/")), prompt.placeholder
665        )

Test placeholder and expression

def test_invalid_save(self): View Source

667    def test_invalid_save(self):
668        """Ensure field can't be saved with invalid type"""
669        prompt: Prompt = Prompt(
670            field_key="text_prompt_expression",
671            label="TEXT_LABEL",
672            type="foo",
673            placeholder="foo",
674            placeholder_expression=False,
675            sub_text="test",
676            order=123,
677        )
678        with self.assertRaises(ValueError):
679            prompt.save()

Ensure field can't be saved with invalid type

def test_api_preview(self): View Source

681    def test_api_preview(self):
682        """Test API preview"""
683        self.client.force_login(self.user)
684        response = self.client.post(
685            reverse("authentik_api:prompt-preview"),
686            data={
687                "field_key": "text_prompt_expression",
688                "label": "TEXT_LABEL",
689                "type": FieldTypes.TEXT,
690                "placeholder": 'return "Hello world"',
691                "placeholder_expression": True,
692                "initial_value": 'return "Hello Hello world"',
693                "initial_value_expression": True,
694                "sub_text": "test",
695                "order": 123,
696            },
697        )
698        self.assertEqual(response.status_code, 200)
699        self.assertJSONEqual(
700            response.content.decode(),
701            {
702                "component": "ak-stage-prompt",
703                "fields": [
704                    {
705                        "field_key": "text_prompt_expression",
706                        "label": "TEXT_LABEL",
707                        "type": "text",
708                        "required": True,
709                        "placeholder": "Hello world",
710                        "initial_value": "Hello Hello world",
711                        "order": 123,
712                        "sub_text": "test",
713                        "choices": None,
714                    }
715                ],
716            },
717        )

Test API preview

def test_api_preview_invalid_expression(self): View Source

719    def test_api_preview_invalid_expression(self):
720        """Test API preview"""
721        self.client.force_login(self.user)
722        response = self.client.post(
723            reverse("authentik_api:prompt-preview"),
724            data={
725                "field_key": "text_prompt_expression",
726                "label": "TEXT_LABEL",
727                "type": FieldTypes.TEXT,
728                "placeholder": "return [",
729                "placeholder_expression": True,
730                "sub_text": "test",
731                "order": 123,
732            },
733        )
734        self.assertEqual(response.status_code, 400)
735        self.assertIn("non_field_errors", response.content.decode())

Test API preview

def test_field_type_text_required(self: TestPromptStage): View Source

741    def tester(self: TestPromptStage):
742        prompt: Prompt = Prompt(
743            field_key="text_prompt_expression",
744            label="TEXT_LABEL",
745            type=field_type,
746            placeholder="foo",
747            placeholder_expression=False,
748            sub_text="test",
749            order=123,
750            required=required,
751        )
752        self.assertIsNotNone(prompt.field("foo"))