authentik.sources.saml.tests.test_metadata

SAML Source tests

View Source

 1"""SAML Source tests"""
 2
 3from defusedxml import ElementTree
 4from django.test import RequestFactory, TestCase
 5from lxml import etree  # nosec
 6
 7from authentik.core.tests.utils import create_test_cert, create_test_flow
 8from authentik.lib.generators import generate_id
 9from authentik.lib.xml import lxml_from_string
10from authentik.sources.saml.models import SAMLSource
11from authentik.sources.saml.processors.metadata import MetadataProcessor
12
13
14class TestMetadataProcessor(TestCase):
15    """Test MetadataProcessor"""
16
17    def setUp(self):
18        self.factory = RequestFactory()
19        self.source = SAMLSource.objects.create(
20            name=generate_id(),
21            slug=generate_id(),
22            issuer="authentik",
23            signing_kp=create_test_cert(),
24            encryption_kp=create_test_cert(),
25            pre_authentication_flow=create_test_flow(),
26        )
27
28    def test_metadata_schema(self):
29        """Test Metadata generation being valid"""
30        request = self.factory.get("/")
31        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
32        metadata = lxml_from_string(xml)
33
34        schema = etree.XMLSchema(
35            etree.parse("schemas/saml-schema-metadata-2.0.xsd", parser=etree.XMLParser())  # nosec
36        )
37        self.assertTrue(schema.validate(metadata))
38
39    def test_metadata_consistent(self):
40        """Test Metadata generation being consistent (xml stays the same)"""
41        request = self.factory.get("/")
42        xml_a = MetadataProcessor(self.source, request).build_entity_descriptor()
43        xml_b = MetadataProcessor(self.source, request).build_entity_descriptor()
44        self.assertEqual(xml_a, xml_b)
45
46    def test_metadata(self):
47        """Test Metadata generation being valid"""
48        request = self.factory.get("/")
49        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
50        metadata = ElementTree.fromstring(xml)
51        self.assertEqual(metadata.attrib["entityID"], "authentik")
52
53    def test_metadata_without_signature(self):
54        """Test Metadata generation being valid"""
55        self.source.signing_kp = None
56        self.source.save()
57        request = self.factory.get("/")
58        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
59        metadata = ElementTree.fromstring(xml)
60        self.assertEqual(metadata.attrib["entityID"], "authentik")

class TestMetadataProcessor(django.test.testcases.TestCase): View Source

15class TestMetadataProcessor(TestCase):
16    """Test MetadataProcessor"""
17
18    def setUp(self):
19        self.factory = RequestFactory()
20        self.source = SAMLSource.objects.create(
21            name=generate_id(),
22            slug=generate_id(),
23            issuer="authentik",
24            signing_kp=create_test_cert(),
25            encryption_kp=create_test_cert(),
26            pre_authentication_flow=create_test_flow(),
27        )
28
29    def test_metadata_schema(self):
30        """Test Metadata generation being valid"""
31        request = self.factory.get("/")
32        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
33        metadata = lxml_from_string(xml)
34
35        schema = etree.XMLSchema(
36            etree.parse("schemas/saml-schema-metadata-2.0.xsd", parser=etree.XMLParser())  # nosec
37        )
38        self.assertTrue(schema.validate(metadata))
39
40    def test_metadata_consistent(self):
41        """Test Metadata generation being consistent (xml stays the same)"""
42        request = self.factory.get("/")
43        xml_a = MetadataProcessor(self.source, request).build_entity_descriptor()
44        xml_b = MetadataProcessor(self.source, request).build_entity_descriptor()
45        self.assertEqual(xml_a, xml_b)
46
47    def test_metadata(self):
48        """Test Metadata generation being valid"""
49        request = self.factory.get("/")
50        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
51        metadata = ElementTree.fromstring(xml)
52        self.assertEqual(metadata.attrib["entityID"], "authentik")
53
54    def test_metadata_without_signature(self):
55        """Test Metadata generation being valid"""
56        self.source.signing_kp = None
57        self.source.save()
58        request = self.factory.get("/")
59        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
60        metadata = ElementTree.fromstring(xml)
61        self.assertEqual(metadata.attrib["entityID"], "authentik")

Test MetadataProcessor

def setUp(self): View Source

18    def setUp(self):
19        self.factory = RequestFactory()
20        self.source = SAMLSource.objects.create(
21            name=generate_id(),
22            slug=generate_id(),
23            issuer="authentik",
24            signing_kp=create_test_cert(),
25            encryption_kp=create_test_cert(),
26            pre_authentication_flow=create_test_flow(),
27        )

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

def test_metadata_schema(self): View Source

29    def test_metadata_schema(self):
30        """Test Metadata generation being valid"""
31        request = self.factory.get("/")
32        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
33        metadata = lxml_from_string(xml)
34
35        schema = etree.XMLSchema(
36            etree.parse("schemas/saml-schema-metadata-2.0.xsd", parser=etree.XMLParser())  # nosec
37        )
38        self.assertTrue(schema.validate(metadata))

Test Metadata generation being valid

def test_metadata_consistent(self): View Source

40    def test_metadata_consistent(self):
41        """Test Metadata generation being consistent (xml stays the same)"""
42        request = self.factory.get("/")
43        xml_a = MetadataProcessor(self.source, request).build_entity_descriptor()
44        xml_b = MetadataProcessor(self.source, request).build_entity_descriptor()
45        self.assertEqual(xml_a, xml_b)

Test Metadata generation being consistent (xml stays the same)

def test_metadata(self): View Source

47    def test_metadata(self):
48        """Test Metadata generation being valid"""
49        request = self.factory.get("/")
50        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
51        metadata = ElementTree.fromstring(xml)
52        self.assertEqual(metadata.attrib["entityID"], "authentik")

Test Metadata generation being valid

def test_metadata_without_signature(self): View Source

54    def test_metadata_without_signature(self):
55        """Test Metadata generation being valid"""
56        self.source.signing_kp = None
57        self.source.save()
58        request = self.factory.get("/")
59        xml = MetadataProcessor(self.source, request).build_entity_descriptor()
60        metadata = ElementTree.fromstring(xml)
61        self.assertEqual(metadata.attrib["entityID"], "authentik")

Test Metadata generation being valid