authentik.sources.saml.tests.test_response API documentation

def setUp(self): View Source

21    def setUp(self):
22        self.factory = RequestFactory()
23        self.source = SAMLSource.objects.create(
24            name=generate_id(),
25            slug=generate_id(),
26            issuer="authentik",
27            allow_idp_initiated=True,
28            pre_authentication_flow=create_test_flow(),
29        )

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

def test_status_error(self): View Source

31    def test_status_error(self):
32        """Test error status"""
33        request = self.factory.post(
34            "/",
35            data={
36                "SAMLResponse": b64encode(
37                    load_fixture("fixtures/response_error.xml").encode()
38                ).decode()
39            },
40        )
41
42        with self.assertRaisesMessage(
43            ValueError,
44            (
45                "Invalid request, ACS Url in request http://localhost:9000/source/saml/google/acs/ "
46                "doesn't match configured ACS Url https://127.0.0.1:9443/source/saml/google/acs/."
47            ),
48        ):
49            ResponseProcessor(self.source, request).parse()

Test error status

@freeze_time('2022-10-14T14:15:00')

def test_success(self): View Source

51    @freeze_time("2022-10-14T14:15:00")
52    def test_success(self):
53        """Test success"""
54        request = self.factory.post(
55            "/",
56            data={
57                "SAMLResponse": b64encode(
58                    load_fixture("fixtures/response_success.xml").encode()
59                ).decode()
60            },
61        )
62
63        parser = ResponseProcessor(self.source, request)
64        parser.parse()
65        sfm = parser.prepare_flow_manager()
66        self.assertEqual(
67            sfm.user_properties,
68            {
69                "email": "foo@bar.baz",
70                "name": "foo",
71                "sn": "bar",
72                "username": "jens@goauthentik.io",
73                "attributes": {},
74                "path": self.source.get_user_path(),
75            },
76        )

Test success

@freeze_time('2022-10-14T14:16:40Z')

def test_success_with_status_message_and_detail(self): View Source

78    @freeze_time("2022-10-14T14:16:40Z")
79    def test_success_with_status_message_and_detail(self):
80        """Test success with StatusMessage and StatusDetail present (should not raise error)"""
81        request = self.factory.post(
82            "/",
83            data={
84                "SAMLResponse": b64encode(
85                    load_fixture("fixtures/response_success_with_message.xml").encode()
86                ).decode()
87            },
88        )
89
90        parser = ResponseProcessor(self.source, request)
91        parser.parse()
92        sfm = parser.prepare_flow_manager()
93        self.assertEqual(sfm.user_properties["username"], "jens@goauthentik.io")

Test success with StatusMessage and StatusDetail present (should not raise error)

@freeze_time('2022-10-14T14:16:40Z')

def test_error_with_message_and_detail(self): View Source

 95    @freeze_time("2022-10-14T14:16:40Z")
 96    def test_error_with_message_and_detail(self):
 97        """Test error status with StatusMessage and StatusDetail includes both in error"""
 98        request = self.factory.post(
 99            "/",
100            data={
101                "SAMLResponse": b64encode(
102                    load_fixture("fixtures/response_error_with_detail.xml").encode()
103                ).decode()
104            },
105        )
106
107        with self.assertRaises(ValueError) as ctx:
108            ResponseProcessor(self.source, request).parse()
109        # Should contain both detail and message
110        self.assertIn("User account is disabled", str(ctx.exception))
111        self.assertIn("Authentication failed", str(ctx.exception))

Test error status with StatusMessage and StatusDetail includes both in error

@freeze_time('2024-08-07T15:48:09.325Z')

def test_encrypted_correct(self): View Source

113    @freeze_time("2024-08-07T15:48:09.325Z")
114    def test_encrypted_correct(self):
115        """Test encrypted"""
116        key = load_fixture("fixtures/encrypted-key.pem")
117        kp = CertificateKeyPair.objects.create(
118            name=generate_id(),
119            key_data=key,
120        )
121        self.source.encryption_kp = kp
122        request = self.factory.post(
123            "/",
124            data={
125                "SAMLResponse": b64encode(
126                    load_fixture("fixtures/response_encrypted.xml").encode()
127                ).decode()
128            },
129        )
130
131        parser = ResponseProcessor(self.source, request)
132        parser.parse()

Test encrypted

def test_encrypted_incorrect_key(self): View Source

134    def test_encrypted_incorrect_key(self):
135        """Test encrypted"""
136        kp = create_test_cert()
137        self.source.encryption_kp = kp
138        request = self.factory.post(
139            "/",
140            data={
141                "SAMLResponse": b64encode(
142                    load_fixture("fixtures/response_encrypted.xml").encode()
143                ).decode()
144            },
145        )
146
147        parser = ResponseProcessor(self.source, request)
148        with self.assertRaises(InvalidEncryption):
149            parser.parse()

Test encrypted

@freeze_time('2022-10-14T14:16:40Z')

def test_verification_assertion(self): View Source

151    @freeze_time("2022-10-14T14:16:40Z")
152    def test_verification_assertion(self):
153        """Test verifying signature inside assertion"""
154        key = load_fixture("fixtures/signature_cert.pem")
155        kp = CertificateKeyPair.objects.create(
156            name=generate_id(),
157            certificate_data=key,
158        )
159        self.source.verification_kp = kp
160        self.source.signed_assertion = True
161        self.source.signed_response = False
162        request = self.factory.post(
163            "/",
164            data={
165                "SAMLResponse": b64encode(
166                    load_fixture("fixtures/response_signed_assertion.xml").encode()
167                ).decode()
168            },
169        )
170
171        parser = ResponseProcessor(self.source, request)
172        parser.parse()

Test verifying signature inside assertion