authentik.enterprise.providers.ws_federation.tests.test_metadata 

 1from django.test import TestCase
 2from lxml import etree  # nosec
 3
 4from authentik.core.models import Application
 5from authentik.core.tests.utils import RequestFactory, create_test_flow
 6from authentik.enterprise.providers.ws_federation.models import WSFederationProvider
 7from authentik.enterprise.providers.ws_federation.processors.metadata import MetadataProcessor
 8from authentik.lib.generators import generate_id
 9from authentik.lib.xml import lxml_from_string
10
11
12class TestWSFedMetadata(TestCase):
13    def setUp(self):
14        self.flow = create_test_flow()
15        self.provider = WSFederationProvider.objects.create(
16            name=generate_id(),
17            authorization_flow=self.flow,
18        )
19        self.app = Application.objects.create(
20            name=generate_id(), slug=generate_id(), provider=self.provider
21        )
22        self.factory = RequestFactory()
23
24    def test_metadata_generation(self):
25        request = self.factory.get("/")
26        metadata_a = MetadataProcessor(self.provider, request).build_entity_descriptor()
27        metadata_b = MetadataProcessor(self.provider, request).build_entity_descriptor()
28        self.assertEqual(metadata_a, metadata_b)
29
30    def test_schema(self):
31        """Test that metadata generation is consistent"""
32        request = self.factory.get("/")
33        metadata = lxml_from_string(
34            MetadataProcessor(self.provider, request).build_entity_descriptor()
35        )
36
37        schema = etree.XMLSchema(
38            etree.parse(source="schemas/ws-federation.xsd", parser=etree.XMLParser())  # nosec
39        )
40        self.assertTrue(schema.validate(metadata))
class TestWSFedMetadata(django.test.testcases.TestCase): 
13class TestWSFedMetadata(TestCase):
14    def setUp(self):
15        self.flow = create_test_flow()
16        self.provider = WSFederationProvider.objects.create(
17            name=generate_id(),
18            authorization_flow=self.flow,
19        )
20        self.app = Application.objects.create(
21            name=generate_id(), slug=generate_id(), provider=self.provider
22        )
23        self.factory = RequestFactory()
24
25    def test_metadata_generation(self):
26        request = self.factory.get("/")
27        metadata_a = MetadataProcessor(self.provider, request).build_entity_descriptor()
28        metadata_b = MetadataProcessor(self.provider, request).build_entity_descriptor()
29        self.assertEqual(metadata_a, metadata_b)
30
31    def test_schema(self):
32        """Test that metadata generation is consistent"""
33        request = self.factory.get("/")
34        metadata = lxml_from_string(
35            MetadataProcessor(self.provider, request).build_entity_descriptor()
36        )
37
38        schema = etree.XMLSchema(
39            etree.parse(source="schemas/ws-federation.xsd", parser=etree.XMLParser())  # nosec
40        )
41        self.assertTrue(schema.validate(metadata))

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

def setUp(self): 
14    def setUp(self):
15        self.flow = create_test_flow()
16        self.provider = WSFederationProvider.objects.create(
17            name=generate_id(),
18            authorization_flow=self.flow,
19        )
20        self.app = Application.objects.create(
21            name=generate_id(), slug=generate_id(), provider=self.provider
22        )
23        self.factory = RequestFactory()

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

def test_metadata_generation(self): 
25    def test_metadata_generation(self):
26        request = self.factory.get("/")
27        metadata_a = MetadataProcessor(self.provider, request).build_entity_descriptor()
28        metadata_b = MetadataProcessor(self.provider, request).build_entity_descriptor()
29        self.assertEqual(metadata_a, metadata_b)
def test_schema(self): 
31    def test_schema(self):
32        """Test that metadata generation is consistent"""
33        request = self.factory.get("/")
34        metadata = lxml_from_string(
35            MetadataProcessor(self.provider, request).build_entity_descriptor()
36        )
37
38        schema = etree.XMLSchema(
39            etree.parse(source="schemas/ws-federation.xsd", parser=etree.XMLParser())  # nosec
40        )
41        self.assertTrue(schema.validate(metadata))

Test that metadata generation is consistent