authentik.enterprise.tests.test_license

Enterprise license tests

  1"""Enterprise license tests"""
  2
  3from datetime import timedelta
  4from time import mktime
  5from unittest.mock import MagicMock, patch
  6
  7from django.test import TestCase
  8from django.utils.timezone import now
  9from rest_framework.exceptions import ValidationError
 10
 11from authentik.core.models import User
 12from authentik.enterprise.license import LicenseKey
 13from authentik.enterprise.models import (
 14    THRESHOLD_READ_ONLY_WEEKS,
 15    THRESHOLD_WARNING_ADMIN_WEEKS,
 16    THRESHOLD_WARNING_USER_WEEKS,
 17    License,
 18    LicenseUsage,
 19    LicenseUsageStatus,
 20)
 21from authentik.lib.generators import generate_id
 22
 23# Valid license expiry
 24expiry_valid = int(mktime((now() + timedelta(days=3000)).timetuple()))
 25# Valid license expiry, expires soon
 26expiry_soon = int(mktime((now() + timedelta(hours=10)).timetuple()))
 27# Invalid license expiry, recently expired
 28expiry_expired = int(mktime((now() - timedelta(hours=10)).timetuple()))
 29# Invalid license expiry, expired longer ago
 30expiry_expired_read_only = int(
 31    mktime((now() - timedelta(weeks=THRESHOLD_READ_ONLY_WEEKS + 1)).timetuple())
 32)
 33
 34
 35class TestEnterpriseLicense(TestCase):
 36    """Enterprise license tests"""
 37
 38    @patch(
 39        "authentik.enterprise.license.LicenseKey.validate",
 40        MagicMock(
 41            return_value=LicenseKey(
 42                aud="",
 43                exp=expiry_valid,
 44                name=generate_id(),
 45                internal_users=100,
 46                external_users=100,
 47            )
 48        ),
 49    )
 50    def test_valid(self):
 51        """Check license verification"""
 52        lic = License.objects.create(key=generate_id())
 53        self.assertTrue(lic.status.status().is_valid)
 54        self.assertEqual(lic.internal_users, 100)
 55
 56    def test_invalid(self):
 57        """Test invalid license"""
 58        with self.assertRaises(ValidationError):
 59            License.objects.create(key=generate_id())
 60
 61    @patch(
 62        "authentik.enterprise.license.LicenseKey.validate",
 63        MagicMock(
 64            return_value=LicenseKey(
 65                aud="",
 66                exp=expiry_valid,
 67                name=generate_id(),
 68                internal_users=100,
 69                external_users=100,
 70            )
 71        ),
 72    )
 73    def test_valid_multiple(self):
 74        """Check license verification"""
 75        lic = License.objects.create(key=generate_id(), expiry=expiry_valid)
 76        self.assertTrue(lic.status.status().is_valid)
 77        lic2 = License.objects.create(key=generate_id(), expiry=expiry_valid)
 78        self.assertTrue(lic2.status.status().is_valid)
 79        total = LicenseKey.get_total()
 80        self.assertEqual(total.internal_users, 200)
 81        self.assertEqual(total.external_users, 200)
 82        self.assertEqual(total.exp, expiry_valid)
 83        self.assertTrue(total.status().is_valid)
 84
 85    @patch(
 86        "authentik.enterprise.license.LicenseKey.validate",
 87        MagicMock(
 88            return_value=LicenseKey(
 89                aud="",
 90                exp=expiry_valid,
 91                name=generate_id(),
 92                internal_users=100,
 93                external_users=100,
 94            )
 95        ),
 96    )
 97    @patch(
 98        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
 99        MagicMock(return_value=1000),
100    )
101    @patch(
102        "authentik.enterprise.license.LicenseKey.get_external_user_count",
103        MagicMock(return_value=1000),
104    )
105    @patch(
106        "authentik.enterprise.license.LicenseKey.record_usage",
107        MagicMock(),
108    )
109    def test_limit_exceeded_read_only(self):
110        """Check license verification"""
111        License.objects.create(key=generate_id())
112        usage = LicenseUsage.objects.create(
113            internal_user_count=100,
114            external_user_count=100,
115            status=LicenseUsageStatus.VALID,
116        )
117        usage.record_date = now() - timedelta(weeks=THRESHOLD_READ_ONLY_WEEKS + 1)
118        usage.save(update_fields=["record_date"])
119        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.READ_ONLY)
120
121    @patch(
122        "authentik.enterprise.license.LicenseKey.validate",
123        MagicMock(
124            return_value=LicenseKey(
125                aud="",
126                exp=expiry_valid,
127                name=generate_id(),
128                internal_users=100,
129                external_users=100,
130            )
131        ),
132    )
133    @patch(
134        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
135        MagicMock(return_value=1000),
136    )
137    @patch(
138        "authentik.enterprise.license.LicenseKey.get_external_user_count",
139        MagicMock(return_value=1000),
140    )
141    @patch(
142        "authentik.enterprise.license.LicenseKey.record_usage",
143        MagicMock(),
144    )
145    def test_limit_exceeded_user_warning(self):
146        """Check license verification"""
147        License.objects.create(key=generate_id())
148        usage = LicenseUsage.objects.create(
149            internal_user_count=100,
150            external_user_count=100,
151            status=LicenseUsageStatus.VALID,
152        )
153        usage.record_date = now() - timedelta(weeks=THRESHOLD_WARNING_USER_WEEKS + 1)
154        usage.save(update_fields=["record_date"])
155        self.assertEqual(
156            LicenseKey.get_total().summary().status, LicenseUsageStatus.LIMIT_EXCEEDED_USER
157        )
158
159    @patch(
160        "authentik.enterprise.license.LicenseKey.validate",
161        MagicMock(
162            return_value=LicenseKey(
163                aud="",
164                exp=expiry_valid,
165                name=generate_id(),
166                internal_users=100,
167                external_users=100,
168            )
169        ),
170    )
171    @patch(
172        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
173        MagicMock(return_value=1000),
174    )
175    @patch(
176        "authentik.enterprise.license.LicenseKey.get_external_user_count",
177        MagicMock(return_value=1000),
178    )
179    @patch(
180        "authentik.enterprise.license.LicenseKey.record_usage",
181        MagicMock(),
182    )
183    def test_limit_exceeded_admin_warning(self):
184        """Check license verification"""
185        License.objects.create(key=generate_id())
186        usage = LicenseUsage.objects.create(
187            internal_user_count=100,
188            external_user_count=100,
189            status=LicenseUsageStatus.VALID,
190        )
191        usage.record_date = now() - timedelta(weeks=THRESHOLD_WARNING_ADMIN_WEEKS + 1)
192        usage.save(update_fields=["record_date"])
193        self.assertEqual(
194            LicenseKey.get_total().summary().status, LicenseUsageStatus.LIMIT_EXCEEDED_ADMIN
195        )
196
197    @patch(
198        "authentik.enterprise.license.LicenseKey.validate",
199        MagicMock(
200            return_value=LicenseKey(
201                aud="",
202                exp=expiry_expired_read_only,
203                name=generate_id(),
204                internal_users=100,
205                external_users=100,
206            )
207        ),
208    )
209    @patch(
210        "authentik.enterprise.license.LicenseKey.record_usage",
211        MagicMock(),
212    )
213    def test_expiry_read_only(self):
214        """Check license verification"""
215        License.objects.create(key=generate_id())
216        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.READ_ONLY)
217
218    @patch(
219        "authentik.enterprise.license.LicenseKey.validate",
220        MagicMock(
221            return_value=LicenseKey(
222                aud="",
223                exp=expiry_expired,
224                name=generate_id(),
225                internal_users=100,
226                external_users=100,
227            )
228        ),
229    )
230    @patch(
231        "authentik.enterprise.license.LicenseKey.record_usage",
232        MagicMock(),
233    )
234    def test_expiry_expired(self):
235        """Check license verification"""
236        User.objects.all().delete()
237        License.objects.all().delete()
238        License.objects.create(key=generate_id(), expiry=expiry_expired)
239        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.EXPIRED)
240
241    @patch(
242        "authentik.enterprise.license.LicenseKey.validate",
243        MagicMock(
244            return_value=LicenseKey(
245                aud="",
246                exp=expiry_soon,
247                name=generate_id(),
248                internal_users=100,
249                external_users=100,
250            )
251        ),
252    )
253    @patch(
254        "authentik.enterprise.license.LicenseKey.record_usage",
255        MagicMock(),
256    )
257    def test_expiry_soon(self):
258        """Check license verification"""
259        License.objects.create(key=generate_id())
260        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.EXPIRY_SOON)
expiry_valid = 2034453329
expiry_soon = 1775289329
expiry_expired = 1775217329
expiry_expired_read_only = 1771019729
class TestEnterpriseLicense(django.test.testcases.TestCase): 
 36class TestEnterpriseLicense(TestCase):
 37    """Enterprise license tests"""
 38
 39    @patch(
 40        "authentik.enterprise.license.LicenseKey.validate",
 41        MagicMock(
 42            return_value=LicenseKey(
 43                aud="",
 44                exp=expiry_valid,
 45                name=generate_id(),
 46                internal_users=100,
 47                external_users=100,
 48            )
 49        ),
 50    )
 51    def test_valid(self):
 52        """Check license verification"""
 53        lic = License.objects.create(key=generate_id())
 54        self.assertTrue(lic.status.status().is_valid)
 55        self.assertEqual(lic.internal_users, 100)
 56
 57    def test_invalid(self):
 58        """Test invalid license"""
 59        with self.assertRaises(ValidationError):
 60            License.objects.create(key=generate_id())
 61
 62    @patch(
 63        "authentik.enterprise.license.LicenseKey.validate",
 64        MagicMock(
 65            return_value=LicenseKey(
 66                aud="",
 67                exp=expiry_valid,
 68                name=generate_id(),
 69                internal_users=100,
 70                external_users=100,
 71            )
 72        ),
 73    )
 74    def test_valid_multiple(self):
 75        """Check license verification"""
 76        lic = License.objects.create(key=generate_id(), expiry=expiry_valid)
 77        self.assertTrue(lic.status.status().is_valid)
 78        lic2 = License.objects.create(key=generate_id(), expiry=expiry_valid)
 79        self.assertTrue(lic2.status.status().is_valid)
 80        total = LicenseKey.get_total()
 81        self.assertEqual(total.internal_users, 200)
 82        self.assertEqual(total.external_users, 200)
 83        self.assertEqual(total.exp, expiry_valid)
 84        self.assertTrue(total.status().is_valid)
 85
 86    @patch(
 87        "authentik.enterprise.license.LicenseKey.validate",
 88        MagicMock(
 89            return_value=LicenseKey(
 90                aud="",
 91                exp=expiry_valid,
 92                name=generate_id(),
 93                internal_users=100,
 94                external_users=100,
 95            )
 96        ),
 97    )
 98    @patch(
 99        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
100        MagicMock(return_value=1000),
101    )
102    @patch(
103        "authentik.enterprise.license.LicenseKey.get_external_user_count",
104        MagicMock(return_value=1000),
105    )
106    @patch(
107        "authentik.enterprise.license.LicenseKey.record_usage",
108        MagicMock(),
109    )
110    def test_limit_exceeded_read_only(self):
111        """Check license verification"""
112        License.objects.create(key=generate_id())
113        usage = LicenseUsage.objects.create(
114            internal_user_count=100,
115            external_user_count=100,
116            status=LicenseUsageStatus.VALID,
117        )
118        usage.record_date = now() - timedelta(weeks=THRESHOLD_READ_ONLY_WEEKS + 1)
119        usage.save(update_fields=["record_date"])
120        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.READ_ONLY)
121
122    @patch(
123        "authentik.enterprise.license.LicenseKey.validate",
124        MagicMock(
125            return_value=LicenseKey(
126                aud="",
127                exp=expiry_valid,
128                name=generate_id(),
129                internal_users=100,
130                external_users=100,
131            )
132        ),
133    )
134    @patch(
135        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
136        MagicMock(return_value=1000),
137    )
138    @patch(
139        "authentik.enterprise.license.LicenseKey.get_external_user_count",
140        MagicMock(return_value=1000),
141    )
142    @patch(
143        "authentik.enterprise.license.LicenseKey.record_usage",
144        MagicMock(),
145    )
146    def test_limit_exceeded_user_warning(self):
147        """Check license verification"""
148        License.objects.create(key=generate_id())
149        usage = LicenseUsage.objects.create(
150            internal_user_count=100,
151            external_user_count=100,
152            status=LicenseUsageStatus.VALID,
153        )
154        usage.record_date = now() - timedelta(weeks=THRESHOLD_WARNING_USER_WEEKS + 1)
155        usage.save(update_fields=["record_date"])
156        self.assertEqual(
157            LicenseKey.get_total().summary().status, LicenseUsageStatus.LIMIT_EXCEEDED_USER
158        )
159
160    @patch(
161        "authentik.enterprise.license.LicenseKey.validate",
162        MagicMock(
163            return_value=LicenseKey(
164                aud="",
165                exp=expiry_valid,
166                name=generate_id(),
167                internal_users=100,
168                external_users=100,
169            )
170        ),
171    )
172    @patch(
173        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
174        MagicMock(return_value=1000),
175    )
176    @patch(
177        "authentik.enterprise.license.LicenseKey.get_external_user_count",
178        MagicMock(return_value=1000),
179    )
180    @patch(
181        "authentik.enterprise.license.LicenseKey.record_usage",
182        MagicMock(),
183    )
184    def test_limit_exceeded_admin_warning(self):
185        """Check license verification"""
186        License.objects.create(key=generate_id())
187        usage = LicenseUsage.objects.create(
188            internal_user_count=100,
189            external_user_count=100,
190            status=LicenseUsageStatus.VALID,
191        )
192        usage.record_date = now() - timedelta(weeks=THRESHOLD_WARNING_ADMIN_WEEKS + 1)
193        usage.save(update_fields=["record_date"])
194        self.assertEqual(
195            LicenseKey.get_total().summary().status, LicenseUsageStatus.LIMIT_EXCEEDED_ADMIN
196        )
197
198    @patch(
199        "authentik.enterprise.license.LicenseKey.validate",
200        MagicMock(
201            return_value=LicenseKey(
202                aud="",
203                exp=expiry_expired_read_only,
204                name=generate_id(),
205                internal_users=100,
206                external_users=100,
207            )
208        ),
209    )
210    @patch(
211        "authentik.enterprise.license.LicenseKey.record_usage",
212        MagicMock(),
213    )
214    def test_expiry_read_only(self):
215        """Check license verification"""
216        License.objects.create(key=generate_id())
217        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.READ_ONLY)
218
219    @patch(
220        "authentik.enterprise.license.LicenseKey.validate",
221        MagicMock(
222            return_value=LicenseKey(
223                aud="",
224                exp=expiry_expired,
225                name=generate_id(),
226                internal_users=100,
227                external_users=100,
228            )
229        ),
230    )
231    @patch(
232        "authentik.enterprise.license.LicenseKey.record_usage",
233        MagicMock(),
234    )
235    def test_expiry_expired(self):
236        """Check license verification"""
237        User.objects.all().delete()
238        License.objects.all().delete()
239        License.objects.create(key=generate_id(), expiry=expiry_expired)
240        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.EXPIRED)
241
242    @patch(
243        "authentik.enterprise.license.LicenseKey.validate",
244        MagicMock(
245            return_value=LicenseKey(
246                aud="",
247                exp=expiry_soon,
248                name=generate_id(),
249                internal_users=100,
250                external_users=100,
251            )
252        ),
253    )
254    @patch(
255        "authentik.enterprise.license.LicenseKey.record_usage",
256        MagicMock(),
257    )
258    def test_expiry_soon(self):
259        """Check license verification"""
260        License.objects.create(key=generate_id())
261        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.EXPIRY_SOON)

Enterprise license tests

@patch('authentik.enterprise.license.LicenseKey.validate', MagicMock(return_value=LicenseKey(aud='', exp=expiry_valid, name=generate_id(), internal_users=100, external_users=100)))
def test_valid(self): 
39    @patch(
40        "authentik.enterprise.license.LicenseKey.validate",
41        MagicMock(
42            return_value=LicenseKey(
43                aud="",
44                exp=expiry_valid,
45                name=generate_id(),
46                internal_users=100,
47                external_users=100,
48            )
49        ),
50    )
51    def test_valid(self):
52        """Check license verification"""
53        lic = License.objects.create(key=generate_id())
54        self.assertTrue(lic.status.status().is_valid)
55        self.assertEqual(lic.internal_users, 100)

Check license verification

def test_invalid(self): 
57    def test_invalid(self):
58        """Test invalid license"""
59        with self.assertRaises(ValidationError):
60            License.objects.create(key=generate_id())

Test invalid license

@patch('authentik.enterprise.license.LicenseKey.validate', MagicMock(return_value=LicenseKey(aud='', exp=expiry_valid, name=generate_id(), internal_users=100, external_users=100)))
def test_valid_multiple(self): 
62    @patch(
63        "authentik.enterprise.license.LicenseKey.validate",
64        MagicMock(
65            return_value=LicenseKey(
66                aud="",
67                exp=expiry_valid,
68                name=generate_id(),
69                internal_users=100,
70                external_users=100,
71            )
72        ),
73    )
74    def test_valid_multiple(self):
75        """Check license verification"""
76        lic = License.objects.create(key=generate_id(), expiry=expiry_valid)
77        self.assertTrue(lic.status.status().is_valid)
78        lic2 = License.objects.create(key=generate_id(), expiry=expiry_valid)
79        self.assertTrue(lic2.status.status().is_valid)
80        total = LicenseKey.get_total()
81        self.assertEqual(total.internal_users, 200)
82        self.assertEqual(total.external_users, 200)
83        self.assertEqual(total.exp, expiry_valid)
84        self.assertTrue(total.status().is_valid)

Check license verification

@patch('authentik.enterprise.license.LicenseKey.validate', MagicMock(return_value=LicenseKey(aud='', exp=expiry_valid, name=generate_id(), internal_users=100, external_users=100)))
@patch('authentik.enterprise.license.LicenseKey.get_internal_user_count', MagicMock(return_value=1000))
@patch('authentik.enterprise.license.LicenseKey.get_external_user_count', MagicMock(return_value=1000))
@patch('authentik.enterprise.license.LicenseKey.record_usage', MagicMock())
def test_limit_exceeded_read_only(self): 
 86    @patch(
 87        "authentik.enterprise.license.LicenseKey.validate",
 88        MagicMock(
 89            return_value=LicenseKey(
 90                aud="",
 91                exp=expiry_valid,
 92                name=generate_id(),
 93                internal_users=100,
 94                external_users=100,
 95            )
 96        ),
 97    )
 98    @patch(
 99        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
100        MagicMock(return_value=1000),
101    )
102    @patch(
103        "authentik.enterprise.license.LicenseKey.get_external_user_count",
104        MagicMock(return_value=1000),
105    )
106    @patch(
107        "authentik.enterprise.license.LicenseKey.record_usage",
108        MagicMock(),
109    )
110    def test_limit_exceeded_read_only(self):
111        """Check license verification"""
112        License.objects.create(key=generate_id())
113        usage = LicenseUsage.objects.create(
114            internal_user_count=100,
115            external_user_count=100,
116            status=LicenseUsageStatus.VALID,
117        )
118        usage.record_date = now() - timedelta(weeks=THRESHOLD_READ_ONLY_WEEKS + 1)
119        usage.save(update_fields=["record_date"])
120        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.READ_ONLY)

Check license verification

@patch('authentik.enterprise.license.LicenseKey.validate', MagicMock(return_value=LicenseKey(aud='', exp=expiry_valid, name=generate_id(), internal_users=100, external_users=100)))
@patch('authentik.enterprise.license.LicenseKey.get_internal_user_count', MagicMock(return_value=1000))
@patch('authentik.enterprise.license.LicenseKey.get_external_user_count', MagicMock(return_value=1000))
@patch('authentik.enterprise.license.LicenseKey.record_usage', MagicMock())
def test_limit_exceeded_user_warning(self): 
122    @patch(
123        "authentik.enterprise.license.LicenseKey.validate",
124        MagicMock(
125            return_value=LicenseKey(
126                aud="",
127                exp=expiry_valid,
128                name=generate_id(),
129                internal_users=100,
130                external_users=100,
131            )
132        ),
133    )
134    @patch(
135        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
136        MagicMock(return_value=1000),
137    )
138    @patch(
139        "authentik.enterprise.license.LicenseKey.get_external_user_count",
140        MagicMock(return_value=1000),
141    )
142    @patch(
143        "authentik.enterprise.license.LicenseKey.record_usage",
144        MagicMock(),
145    )
146    def test_limit_exceeded_user_warning(self):
147        """Check license verification"""
148        License.objects.create(key=generate_id())
149        usage = LicenseUsage.objects.create(
150            internal_user_count=100,
151            external_user_count=100,
152            status=LicenseUsageStatus.VALID,
153        )
154        usage.record_date = now() - timedelta(weeks=THRESHOLD_WARNING_USER_WEEKS + 1)
155        usage.save(update_fields=["record_date"])
156        self.assertEqual(
157            LicenseKey.get_total().summary().status, LicenseUsageStatus.LIMIT_EXCEEDED_USER
158        )

Check license verification

@patch('authentik.enterprise.license.LicenseKey.validate', MagicMock(return_value=LicenseKey(aud='', exp=expiry_valid, name=generate_id(), internal_users=100, external_users=100)))
@patch('authentik.enterprise.license.LicenseKey.get_internal_user_count', MagicMock(return_value=1000))
@patch('authentik.enterprise.license.LicenseKey.get_external_user_count', MagicMock(return_value=1000))
@patch('authentik.enterprise.license.LicenseKey.record_usage', MagicMock())
def test_limit_exceeded_admin_warning(self): 
160    @patch(
161        "authentik.enterprise.license.LicenseKey.validate",
162        MagicMock(
163            return_value=LicenseKey(
164                aud="",
165                exp=expiry_valid,
166                name=generate_id(),
167                internal_users=100,
168                external_users=100,
169            )
170        ),
171    )
172    @patch(
173        "authentik.enterprise.license.LicenseKey.get_internal_user_count",
174        MagicMock(return_value=1000),
175    )
176    @patch(
177        "authentik.enterprise.license.LicenseKey.get_external_user_count",
178        MagicMock(return_value=1000),
179    )
180    @patch(
181        "authentik.enterprise.license.LicenseKey.record_usage",
182        MagicMock(),
183    )
184    def test_limit_exceeded_admin_warning(self):
185        """Check license verification"""
186        License.objects.create(key=generate_id())
187        usage = LicenseUsage.objects.create(
188            internal_user_count=100,
189            external_user_count=100,
190            status=LicenseUsageStatus.VALID,
191        )
192        usage.record_date = now() - timedelta(weeks=THRESHOLD_WARNING_ADMIN_WEEKS + 1)
193        usage.save(update_fields=["record_date"])
194        self.assertEqual(
195            LicenseKey.get_total().summary().status, LicenseUsageStatus.LIMIT_EXCEEDED_ADMIN
196        )

Check license verification

@patch('authentik.enterprise.license.LicenseKey.validate', MagicMock(return_value=LicenseKey(aud='', exp=expiry_expired_read_only, name=generate_id(), internal_users=100, external_users=100)))
@patch('authentik.enterprise.license.LicenseKey.record_usage', MagicMock())
def test_expiry_read_only(self): 
198    @patch(
199        "authentik.enterprise.license.LicenseKey.validate",
200        MagicMock(
201            return_value=LicenseKey(
202                aud="",
203                exp=expiry_expired_read_only,
204                name=generate_id(),
205                internal_users=100,
206                external_users=100,
207            )
208        ),
209    )
210    @patch(
211        "authentik.enterprise.license.LicenseKey.record_usage",
212        MagicMock(),
213    )
214    def test_expiry_read_only(self):
215        """Check license verification"""
216        License.objects.create(key=generate_id())
217        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.READ_ONLY)

Check license verification

@patch('authentik.enterprise.license.LicenseKey.validate', MagicMock(return_value=LicenseKey(aud='', exp=expiry_expired, name=generate_id(), internal_users=100, external_users=100)))
@patch('authentik.enterprise.license.LicenseKey.record_usage', MagicMock())
def test_expiry_expired(self): 
219    @patch(
220        "authentik.enterprise.license.LicenseKey.validate",
221        MagicMock(
222            return_value=LicenseKey(
223                aud="",
224                exp=expiry_expired,
225                name=generate_id(),
226                internal_users=100,
227                external_users=100,
228            )
229        ),
230    )
231    @patch(
232        "authentik.enterprise.license.LicenseKey.record_usage",
233        MagicMock(),
234    )
235    def test_expiry_expired(self):
236        """Check license verification"""
237        User.objects.all().delete()
238        License.objects.all().delete()
239        License.objects.create(key=generate_id(), expiry=expiry_expired)
240        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.EXPIRED)

Check license verification

@patch('authentik.enterprise.license.LicenseKey.validate', MagicMock(return_value=LicenseKey(aud='', exp=expiry_soon, name=generate_id(), internal_users=100, external_users=100)))
@patch('authentik.enterprise.license.LicenseKey.record_usage', MagicMock())
def test_expiry_soon(self): 
242    @patch(
243        "authentik.enterprise.license.LicenseKey.validate",
244        MagicMock(
245            return_value=LicenseKey(
246                aud="",
247                exp=expiry_soon,
248                name=generate_id(),
249                internal_users=100,
250                external_users=100,
251            )
252        ),
253    )
254    @patch(
255        "authentik.enterprise.license.LicenseKey.record_usage",
256        MagicMock(),
257    )
258    def test_expiry_soon(self):
259        """Check license verification"""
260        License.objects.create(key=generate_id())
261        self.assertEqual(LicenseKey.get_total().summary().status, LicenseUsageStatus.EXPIRY_SOON)

Check license verification