def test_cloudfront_validate_distribution_id(self):
with self.assertRaises(ImproperlyConfigured):
get_backends(backend_settings={
'cloudfront': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.CloudfrontBackend',
},
})
def test_cloudfront_validate_distribution_id(self):
with self.assertRaises(ImproperlyConfigured):
get_backends(backend_settings={
'cloudfront': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.CloudfrontBackend',
},
})
def test_azure_cdn_purge(self, make_purge_call_mock):
backends = get_backends(backend_settings={
'azure_cdn': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.AzureCdnBackend',
'RESOURCE_GROUP_NAME': 'test-resource-group',
'CDN_PROFILE_NAME': 'wagtail-io-profile',
'CDN_ENDPOINT_NAME': 'wagtail-io-endpoint',
'CREDENTIALS': 'Fake credentials',
},
})
self.assertEqual(set(backends.keys()), set(['azure_cdn']))
self.assertIsInstance(backends['azure_cdn'], AzureCdnBackend)
# purge()
backends['azure_cdn'].purge('http://www.wagtail.io/home/events/christmas/?test=1')
make_purge_call_mock.assert_called_once()
call_args = tuple(make_purge_call_mock.call_args)[0]
self.assertEqual(len(call_args), 2)
self.assertIsInstance(call_args[0], CdnManagementClient)
self.assertEqual(call_args[1], ["/home/events/christmas/?test=1"])
make_purge_call_mock.reset_mock()
# purge_batch()
backends['azure_cdn'].purge_batch([
'http://www.wagtail.io/home/events/christmas/?test=1', 'http://torchbox.com/blog/'
])
make_purge_call_mock.assert_called_once()
call_args = tuple(make_purge_call_mock.call_args)[0]
self.assertIsInstance(call_args[0], CdnManagementClient)
self.assertEqual(call_args[1], ["/home/events/christmas/?test=1", "/blog/"])
def test_azure_front_door_purge(self, make_purge_call_mock):
backends = get_backends(backend_settings={
'azure_front_door': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.AzureFrontDoorBackend',
'RESOURCE_GROUP_NAME': 'test-resource-group',
'FRONT_DOOR_NAME': 'wagtail-io-front-door',
'CREDENTIALS': 'Fake credentials',
},
})
self.assertEqual(set(backends.keys()), set(['azure_front_door']))
self.assertIsInstance(backends['azure_front_door'], AzureFrontDoorBackend)
# purge()
backends['azure_front_door'].purge('http://www.wagtail.io/home/events/christmas/?test=1')
make_purge_call_mock.assert_called_once()
call_args = tuple(make_purge_call_mock.call_args)[0]
self.assertIsInstance(call_args[0], FrontDoorManagementClient)
self.assertEqual(call_args[1], ["/home/events/christmas/?test=1"])
make_purge_call_mock.reset_mock()
# purge_batch()
backends['azure_front_door'].purge_batch([
'http://www.wagtail.io/home/events/christmas/?test=1', 'http://torchbox.com/blog/'
])
make_purge_call_mock.assert_called_once()
call_args = tuple(make_purge_call_mock.call_args)[0]
self.assertIsInstance(call_args[0], FrontDoorManagementClient)
self.assertEqual(call_args[1], ["/home/events/christmas/?test=1", "/blog/"])
def test_backwards_compatibility(self):
backends = get_backends()
self.assertEqual(set(backends.keys()), set(['default']))
self.assertIsInstance(backends['default'], HTTPBackend)
self.assertEqual(backends['default'].cache_scheme, 'http')
self.assertEqual(backends['default'].cache_netloc, 'localhost:8000')
def test_backwards_compatibility(self):
backends = get_backends()
self.assertEqual(set(backends.keys()), set(['default']))
self.assertIsInstance(backends['default'], HTTPBackend)
self.assertEqual(backends['default'].cache_scheme, 'http')
self.assertEqual(backends['default'].cache_netloc, 'localhost:8000')
def test_backwards_compatibility(self):
backends = get_backends()
self.assertEqual(set(backends.keys()), {"default"})
self.assertIsInstance(backends["default"], HTTPBackend)
self.assertEqual(backends["default"].cache_scheme, "http")
self.assertEqual(backends["default"].cache_netloc, "localhost:8000")
def _test_http_with_side_effect(self, urlopen_mock, urlopen_side_effect):
# given a backends configuration with one HTTP backend
backends = get_backends(
backend_settings={
"varnish": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.HTTPBackend",
"LOCATION": "http://localhost:8000",
},
})
self.assertEqual(set(backends.keys()), {"varnish"})
self.assertIsInstance(backends["varnish"], HTTPBackend)
# and mocked urlopen that may or may not raise network-related exception
urlopen_mock.side_effect = urlopen_side_effect
# when making a purge request
backends.get("varnish").purge(
"http://www.wagtail.org/home/events/christmas/")
# then no exception is raised
# and mocked urlopen is called with a proper purge request
self.assertEqual(urlopen_mock.call_count, 1)
(purge_request, ), _call_kwargs = urlopen_mock.call_args
self.assertEqual(purge_request.full_url,
"http://localhost:8000/home/events/christmas/")
def test_cloudfront(self):
backends = get_backends(backend_settings={
'cloudfront': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.CloudfrontBackend',
'DISTRIBUTION_ID': 'frontend',
},
})
self.assertEqual(set(backends.keys()), set(['cloudfront']))
self.assertIsInstance(backends['cloudfront'], CloudfrontBackend)
self.assertEqual(backends['cloudfront'].cloudfront_distribution_id, 'frontend')
def test_cloudfront(self):
backends = get_backends(backend_settings={
'cloudfront': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.CloudfrontBackend',
'DISTRIBUTION_ID': 'frontend',
},
})
self.assertEqual(set(backends.keys()), set(['cloudfront']))
self.assertIsInstance(backends['cloudfront'], CloudfrontBackend)
self.assertEqual(backends['cloudfront'].cloudfront_distribution_id, 'frontend')
def test_cloudfront_distribution_id_mapping(self, _create_invalidation):
backends = get_backends(backend_settings={
'cloudfront': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.CloudfrontBackend',
'DISTRIBUTION_ID': {
'www.wagtail.org': 'frontend',
}
},
})
backends.get('cloudfront').purge('http://www.wagtail.org/home/events/christmas/')
backends.get('cloudfront').purge('http://torchbox.com/blog/')
_create_invalidation.assert_called_once_with('frontend', ['/home/events/christmas/'])
def test_varnish(self):
backends = get_backends(backend_settings={
'varnish': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.HTTPBackend',
'LOCATION': 'http://localhost:8000',
},
})
self.assertEqual(set(backends.keys()), set(['varnish']))
self.assertIsInstance(backends['varnish'], HTTPBackend)
self.assertEqual(backends['varnish'].cache_scheme, 'http')
self.assertEqual(backends['varnish'].cache_netloc, 'localhost:8000')
def test_azure_front_door(self):
backends = get_backends(backend_settings={
'azure_front_door': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.AzureFrontDoorBackend',
'RESOURCE_GROUP_NAME': 'test-resource-group',
'FRONT_DOOR_NAME': 'wagtail-io-front-door',
},
})
self.assertEqual(set(backends.keys()), set(['azure_front_door']))
self.assertIsInstance(backends['azure_front_door'], AzureFrontDoorBackend)
self.assertEqual(backends['azure_front_door']._resource_group_name, 'test-resource-group')
self.assertEqual(backends['azure_front_door']._front_door_name, 'wagtail-io-front-door')
def test_cloudfront_distribution_id_mapping(self, _create_invalidation):
backends = get_backends(backend_settings={
'cloudfront': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.CloudfrontBackend',
'DISTRIBUTION_ID': {
'www.wagtail.io': 'frontend',
}
},
})
backends.get('cloudfront').purge('http://www.wagtail.io/home/events/christmas/')
backends.get('cloudfront').purge('http://torchbox.com/blog/')
_create_invalidation.assert_called_once_with('frontend', ['/home/events/christmas/'])
def test_varnish(self):
backends = get_backends(backend_settings={
'varnish': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.HTTPBackend',
'LOCATION': 'http://localhost:8000',
},
})
self.assertEqual(set(backends.keys()), set(['varnish']))
self.assertIsInstance(backends['varnish'], HTTPBackend)
self.assertEqual(backends['varnish'].cache_scheme, 'http')
self.assertEqual(backends['varnish'].cache_netloc, 'localhost:8000')
def test_filter(self):
backends = get_backends(backend_settings={
'varnish': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.HTTPBackend',
'LOCATION': 'http://*****:*****@test.com',
'TOKEN': 'this is the token',
'ZONEID': 'this is a zone id',
}
}, backends=['cloudflare'])
self.assertEqual(set(backends.keys()), set(['cloudflare']))
def test_varnish(self):
backends = get_backends(
backend_settings={
"varnish": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.HTTPBackend",
"LOCATION": "http://localhost:8000",
},
})
self.assertEqual(set(backends.keys()), {"varnish"})
self.assertIsInstance(backends["varnish"], HTTPBackend)
self.assertEqual(backends["varnish"].cache_scheme, "http")
self.assertEqual(backends["varnish"].cache_netloc, "localhost:8000")
def test_azure_cdn(self):
backends = get_backends(backend_settings={
'azure_cdn': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.AzureCdnBackend',
'RESOURCE_GROUP_NAME': 'test-resource-group',
'CDN_PROFILE_NAME': 'wagtail-io-profile',
'CDN_ENDPOINT_NAME': 'wagtail-io-endpoint',
},
})
self.assertEqual(set(backends.keys()), set(['azure_cdn']))
self.assertIsInstance(backends['azure_cdn'], AzureCdnBackend)
self.assertEqual(backends['azure_cdn']._resource_group_name, 'test-resource-group')
self.assertEqual(backends['azure_cdn']._cdn_profile_name, 'wagtail-io-profile')
self.assertEqual(backends['azure_cdn']._cdn_endpoint_name, 'wagtail-io-endpoint')
def test_filter(self):
backends = get_backends(backend_settings={
'varnish': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.HTTPBackend',
'LOCATION': 'http://*****:*****@test.com',
'API_KEY': 'this is the api key',
'ZONEID': 'this is a zone id',
}
}, backends=['cloudflare'])
self.assertEqual(set(backends.keys()), set(['cloudflare']))
def test_cloudflare(self):
backends = get_backends(backend_settings={
'cloudflare': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.CloudflareBackend',
'EMAIL': '*****@*****.**',
'TOKEN': 'this is the token',
'ZONEID': 'this is a zone id',
},
})
self.assertEqual(set(backends.keys()), set(['cloudflare']))
self.assertIsInstance(backends['cloudflare'], CloudflareBackend)
self.assertEqual(backends['cloudflare'].cloudflare_email, '*****@*****.**')
self.assertEqual(backends['cloudflare'].cloudflare_token, 'this is the token')
def test_cloudfront(self):
backends = get_backends(
backend_settings={
"cloudfront": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.CloudfrontBackend",
"DISTRIBUTION_ID": "frontend",
},
})
self.assertEqual(set(backends.keys()), {"cloudfront"})
self.assertIsInstance(backends["cloudfront"], CloudfrontBackend)
self.assertEqual(backends["cloudfront"].cloudfront_distribution_id,
"frontend")
def test_azure_front_door_get_client(self):
mock_credentials = mock.MagicMock()
backends = get_backends(backend_settings={
'azure_front_door': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.AzureFrontDoorBackend',
'RESOURCE_GROUP_NAME': 'test-resource-group',
'FRONT_DOOR_NAME': 'wagtail-io-fake-front-door-name',
'SUBSCRIPTION_ID': 'fake-subscription-id',
'CREDENTIALS': mock_credentials,
},
})
client = backends['azure_front_door']._get_client()
self.assertEqual(set(backends.keys()), set(['azure_front_door']))
self.assertIsInstance(client, FrontDoorManagementClient)
self.assertEqual(client.config.subscription_id, 'fake-subscription-id')
self.assertIs(client.config.credentials, mock_credentials)
def test_cloudflare(self):
backends = get_backends(backend_settings={
'cloudflare': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.CloudflareBackend',
'EMAIL': '*****@*****.**',
'API_KEY': 'this is the api key',
'ZONEID': 'this is a zone id',
'BEARER_TOKEN': 'this is a bearer token'
},
})
self.assertEqual(set(backends.keys()), set(['cloudflare']))
self.assertIsInstance(backends['cloudflare'], CloudflareBackend)
self.assertEqual(backends['cloudflare'].cloudflare_email, '*****@*****.**')
self.assertEqual(backends['cloudflare'].cloudflare_api_key, 'this is the api key')
self.assertEqual(backends['cloudflare'].cloudflare_token, 'this is a bearer token')
def test_azure_cdn_get_client(self):
mock_credentials = mock.MagicMock()
backends = get_backends(backend_settings={
'azure_cdn': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.AzureCdnBackend',
'RESOURCE_GROUP_NAME': 'test-resource-group',
'CDN_PROFILE_NAME': 'wagtail-io-profile',
'CDN_ENDPOINT_NAME': 'wagtail-io-endpoint',
'SUBSCRIPTION_ID': 'fake-subscription-id',
'CREDENTIALS': mock_credentials,
},
})
self.assertEqual(set(backends.keys()), set(['azure_cdn']))
client = backends['azure_cdn']._get_client()
self.assertIsInstance(client, CdnManagementClient)
self.assertEqual(client.config.subscription_id, 'fake-subscription-id')
self.assertIs(client.config.credentials, mock_credentials)
def test_cloudfront_distribution_id_mapping(self, _create_invalidation):
backends = get_backends(
backend_settings={
"cloudfront": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.CloudfrontBackend",
"DISTRIBUTION_ID": {
"www.wagtail.org": "frontend",
},
},
})
backends.get("cloudfront").purge(
"http://www.wagtail.org/home/events/christmas/")
backends.get("cloudfront").purge("http://torchbox.com/blog/")
_create_invalidation.assert_called_once_with(
"frontend", ["/home/events/christmas/"])
def test_azure_front_door_get_client(self):
mock_credentials = mock.MagicMock()
backends = get_backends(
backend_settings={
"azure_front_door": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.AzureFrontDoorBackend",
"RESOURCE_GROUP_NAME": "test-resource-group",
"FRONT_DOOR_NAME": "wagtail-io-fake-front-door-name",
"SUBSCRIPTION_ID": "fake-subscription-id",
"CREDENTIALS": mock_credentials,
},
})
client = backends["azure_front_door"]._get_client()
self.assertEqual(set(backends.keys()), {"azure_front_door"})
self.assertIsInstance(client, FrontDoorManagementClient)
self.assertEqual(client.config.subscription_id, "fake-subscription-id")
self.assertIs(client.config.credentials, mock_credentials)
def test_azure_front_door(self):
backends = get_backends(
backend_settings={
"azure_front_door": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.AzureFrontDoorBackend",
"RESOURCE_GROUP_NAME": "test-resource-group",
"FRONT_DOOR_NAME": "wagtail-io-front-door",
},
})
self.assertEqual(set(backends.keys()), {"azure_front_door"})
self.assertIsInstance(backends["azure_front_door"],
AzureFrontDoorBackend)
self.assertEqual(backends["azure_front_door"]._resource_group_name,
"test-resource-group")
self.assertEqual(backends["azure_front_door"]._front_door_name,
"wagtail-io-front-door")
def test_multiple(self):
backends = get_backends(
backend_settings={
"varnish": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.HTTPBackend",
"LOCATION": "http://*****:*****@test.com",
"API_KEY": "this is the api key",
"ZONEID": "this is a zone id",
},
})
self.assertEqual(set(backends.keys()), {"varnish", "cloudflare"})
def test_azure_cdn_get_client(self):
mock_credentials = mock.MagicMock()
backends = get_backends(
backend_settings={
"azure_cdn": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.AzureCdnBackend",
"RESOURCE_GROUP_NAME": "test-resource-group",
"CDN_PROFILE_NAME": "wagtail-io-profile",
"CDN_ENDPOINT_NAME": "wagtail-io-endpoint",
"SUBSCRIPTION_ID": "fake-subscription-id",
"CREDENTIALS": mock_credentials,
},
})
self.assertEqual(set(backends.keys()), {"azure_cdn"})
client = backends["azure_cdn"]._get_client()
self.assertIsInstance(client, CdnManagementClient)
self.assertEqual(client.config.subscription_id, "fake-subscription-id")
self.assertIs(client.config.credentials, mock_credentials)
def test_azure_cdn(self):
backends = get_backends(
backend_settings={
"azure_cdn": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.AzureCdnBackend",
"RESOURCE_GROUP_NAME": "test-resource-group",
"CDN_PROFILE_NAME": "wagtail-io-profile",
"CDN_ENDPOINT_NAME": "wagtail-io-endpoint",
},
})
self.assertEqual(set(backends.keys()), {"azure_cdn"})
self.assertIsInstance(backends["azure_cdn"], AzureCdnBackend)
self.assertEqual(backends["azure_cdn"]._resource_group_name,
"test-resource-group")
self.assertEqual(backends["azure_cdn"]._cdn_profile_name,
"wagtail-io-profile")
self.assertEqual(backends["azure_cdn"]._cdn_endpoint_name,
"wagtail-io-endpoint")
def _test_http_with_side_effect(self, urlopen_mock, urlopen_side_effect):
# given a backends configuration with one HTTP backend
backends = get_backends(backend_settings={
'varnish': {
'BACKEND': 'wagtail.contrib.frontend_cache.backends.HTTPBackend',
'LOCATION': 'http://localhost:8000',
},
})
self.assertEqual(set(backends.keys()), set(['varnish']))
self.assertIsInstance(backends['varnish'], HTTPBackend)
# and mocked urlopen that may or may not raise network-related exception
urlopen_mock.side_effect = urlopen_side_effect
# when making a purge request
backends.get('varnish').purge('http://www.wagtail.io/home/events/christmas/')
# then no exception is raised
# and mocked urlopen is called with a proper purge request
self.assertEqual(urlopen_mock.call_count, 1)
(purge_request,), _call_kwargs = urlopen_mock.call_args
self.assertEqual(purge_request.full_url, 'http://localhost:8000/home/events/christmas/')
def test_cloudflare(self):
backends = get_backends(
backend_settings={
"cloudflare": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.CloudflareBackend",
"EMAIL": "*****@*****.**",
"API_KEY": "this is the api key",
"ZONEID": "this is a zone id",
"BEARER_TOKEN": "this is a bearer token",
},
})
self.assertEqual(set(backends.keys()), {"cloudflare"})
self.assertIsInstance(backends["cloudflare"], CloudflareBackend)
self.assertEqual(backends["cloudflare"].cloudflare_email,
"*****@*****.**")
self.assertEqual(backends["cloudflare"].cloudflare_api_key,
"this is the api key")
self.assertEqual(backends["cloudflare"].cloudflare_token,
"this is a bearer token")
def test_azure_cdn_purge(self, make_purge_call_mock):
backends = get_backends(
backend_settings={
"azure_cdn": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.AzureCdnBackend",
"RESOURCE_GROUP_NAME": "test-resource-group",
"CDN_PROFILE_NAME": "wagtail-io-profile",
"CDN_ENDPOINT_NAME": "wagtail-io-endpoint",
"CREDENTIALS": "Fake credentials",
},
})
self.assertEqual(set(backends.keys()), {"azure_cdn"})
self.assertIsInstance(backends["azure_cdn"], AzureCdnBackend)
# purge()
backends["azure_cdn"].purge(
"http://www.wagtail.org/home/events/christmas/?test=1")
make_purge_call_mock.assert_called_once()
call_args = tuple(make_purge_call_mock.call_args)[0]
self.assertEqual(len(call_args), 2)
self.assertIsInstance(call_args[0], CdnManagementClient)
self.assertEqual(call_args[1], ["/home/events/christmas/?test=1"])
make_purge_call_mock.reset_mock()
# purge_batch()
backends["azure_cdn"].purge_batch([
"http://www.wagtail.org/home/events/christmas/?test=1",
"http://torchbox.com/blog/",
])
make_purge_call_mock.assert_called_once()
call_args = tuple(make_purge_call_mock.call_args)[0]
self.assertIsInstance(call_args[0], CdnManagementClient)
self.assertEqual(call_args[1],
["/home/events/christmas/?test=1", "/blog/"])
def test_azure_front_door_purge(self, make_purge_call_mock):
backends = get_backends(
backend_settings={
"azure_front_door": {
"BACKEND":
"wagtail.contrib.frontend_cache.backends.AzureFrontDoorBackend",
"RESOURCE_GROUP_NAME": "test-resource-group",
"FRONT_DOOR_NAME": "wagtail-io-front-door",
"CREDENTIALS": "Fake credentials",
},
})
self.assertEqual(set(backends.keys()), {"azure_front_door"})
self.assertIsInstance(backends["azure_front_door"],
AzureFrontDoorBackend)
# purge()
backends["azure_front_door"].purge(
"http://www.wagtail.org/home/events/christmas/?test=1")
make_purge_call_mock.assert_called_once()
call_args = tuple(make_purge_call_mock.call_args)[0]
self.assertIsInstance(call_args[0], FrontDoorManagementClient)
self.assertEqual(call_args[1], ["/home/events/christmas/?test=1"])
make_purge_call_mock.reset_mock()
# purge_batch()
backends["azure_front_door"].purge_batch([
"http://www.wagtail.org/home/events/christmas/?test=1",
"http://torchbox.com/blog/",
])
make_purge_call_mock.assert_called_once()
call_args = tuple(make_purge_call_mock.call_args)[0]
self.assertIsInstance(call_args[0], FrontDoorManagementClient)
self.assertEqual(call_args[1],
["/home/events/christmas/?test=1", "/blog/"])
def inner(*args, backend_settings=None, backends=None, **kwargs):
for backend_name, backend in get_backends(backend_settings=backend_settings, backends=backends).items():
if not isinstance(backend, CloudflareBackend):
continue
func(*args, backend=backend, **kwargs)
def test_default(self):
backends = get_backends()
self.assertEqual(len(backends), 0)
def get_context_data(self, **kwargs):
uwsgi_backend = get_backends().get('uwsgi', None)
kwargs['cache_keys'] = uwsgi_backend.get_cache_keys() if uwsgi_backend else []
return super().get_context_data(**kwargs)
def test_default(self):
backends = get_backends()
self.assertEqual(len(backends), 0)
