def test_sync_plugin_configuration(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(),
request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Check if remote upstream_url matches the locally known upstream_url
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(
api=api_ref)
# Publish plugin_configuration
logic.synchronize_plugin_configuration(self.client,
plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(
plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'],
Plugins.label(plugin_configuration_ref.plugin))
def test_sync_updated_api(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
self.assertEqual(result['request_host'], api_ref.request_host)
self.assertEqual(result['name'], api_ref.request_host)
# Update
new_name = fake.api_name()
self.assertNotEqual(new_name, api_ref.name)
api_ref.name = new_name
api_ref.save()
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
self.assertEqual(result['request_host'], api_ref.request_host)
self.assertEqual(result['name'], new_name)
def test_create_oauth2_plugin_with_scopes(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(),
request_host=fake.domain_name())
# Create plugin_configuration_ref
plugin_configuration_ref = PluginConfigurationReferenceFactory(
api=api_ref,
plugin=Plugins.OAUTH2_AUTHENTICATION,
config={'scopes': 'email,subscriptions,topups'})
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Reload plugin configuration
plugin_configuration_ref = PluginConfigurationReference.objects.get(
id=plugin_configuration_ref.id)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(
plugin_configuration_ref.kong_id)
self.assertEqual(result['name'],
Plugins.label(plugin_configuration_ref.plugin))
self.assertEqual(result['config']['scopes'],
['email', 'subscriptions', 'topups'])
def test_update_oauth2_plugin_with_scopes(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Create plugin_configuration_ref
plugin_configuration_ref = PluginConfigurationReferenceFactory(
api=api_ref, plugin=Plugins.OAUTH2_AUTHENTICATION, config={})
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Reload plugin configuration
plugin_configuration_ref = PluginConfigurationReference.objects.get(id=plugin_configuration_ref.id)
# Update plugin_configuration_ref
plugin_configuration_ref.config = dict({
'scopes': 'email,subscriptions,topups'
}, **plugin_configuration_ref.config)
plugin_configuration_ref.save()
# Publish api
logic.synchronize_api(self.client, api_ref)
# Reload plugin configuration
plugin_configuration_ref = PluginConfigurationReference.objects.get(id=plugin_configuration_ref.id)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_ref.kong_id)
self.assertEqual(result['config']['scopes'], ['email', 'subscriptions', 'topups'])
def test_sync_plugin_configuration(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Check if remote upstream_url matches the locally known upstream_url
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(api=api_ref)
# Publish plugin_configuration
logic.synchronize_plugin_configuration(self.client, plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'], Plugins.label(plugin_configuration_ref.plugin))
def test_sync_incomplete_api(self):
# Create incomplete api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Try to sync, expect an error
with self.assertRaises(ValueError):
logic.synchronize_api(self.client, api_ref)
self.assertFalse(api_ref.synchronized)
# Fix api_ref
api_ref.request_host = fake.domain_name()
api_ref.save()
# Sync again
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
self.assertEqual(result['request_host'], api_ref.request_host)
def test_sync_updated_api(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(),
request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
self.assertEqual(result['request_host'], api_ref.request_host)
self.assertEqual(result['name'], api_ref.request_host)
# Update
new_name = fake.api_name()
self.assertNotEqual(new_name, api_ref.name)
api_ref.name = new_name
api_ref.save()
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
self.assertEqual(result['request_host'], api_ref.request_host)
self.assertEqual(result['name'], new_name)
def test_delete_synchronized_plugin_configuration(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(),
request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(
api=api_ref)
# Publish plugin_configuration
logic.synchronize_plugin_configuration(self.client,
plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(
plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'],
Plugins.label(plugin_configuration_ref.plugin))
# Delete plugin_configuration
plugin_configuration_kong_id = plugin_configuration_ref.kong_id
plugin_configuration_ref.delete()
# Check
with self.assertRaises(ValueError):
_ = self.client.apis.plugins(
api_ref.kong_id).retrieve(plugin_configuration_kong_id)
def test_sync_update(self):
# Create api_ref
api_ref = APIReferenceFactory(target_url=fake.url(),
public_dns=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['target_url'], api_ref.target_url)
self.assertEqual(result['public_dns'], api_ref.public_dns)
self.assertEqual(result['name'], api_ref.public_dns)
# Update
new_name = fake.api_name()
api_ref.name = new_name
api_ref.save()
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['target_url'], api_ref.target_url)
self.assertEqual(result['public_dns'], api_ref.public_dns)
self.assertEqual(result['name'], new_name)
def test_withdraw_api(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(),
request_host=fake.domain_name())
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
self.assertEqual(result['request_host'], api_ref.request_host)
# Store kong_id
kong_id = api_ref.kong_id
# You can delete afterwards
logic.withdraw_api(self.client, api_ref)
self.assertFalse(api_ref.synchronized)
# Check kong
with self.assertRaises(ValueError):
_ = self.client.apis.retrieve(kong_id)
def test_sync_plugin_configuration_without_fields(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(),
request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Check if remote upstream_url matches the locally known upstream_url
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(
api=api_ref, config={})
# Attempt to publish
with self.assertRaises(ValueError):
logic.synchronize_plugin_configuration(self.client,
plugin_configuration_ref)
# Make sure we did not get a Kong ID (meaning it did not sync to Kong)
self.assertIsNone(plugin_configuration_ref.kong_id)
def test_withdraw(self):
# Create api_ref
api_ref = APIReferenceFactory(target_url=fake.url(),
public_dns=fake.domain_name())
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['target_url'], api_ref.target_url)
self.assertEqual(result['public_dns'], api_ref.public_dns)
# Store kong_id
kong_id = api_ref.kong_id
# You can delete afterwards
get_api_sync_engine().withdraw(self.client, api_ref)
self.assertFalse(api_ref.synchronized)
# Check kong
with self.assertRaises(ValueError):
result = self.client.apis.retrieve(kong_id)
def test_update_synchronized_plugin_configuration(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(api=api_ref)
# Publish plugin_configuration
logic.synchronize_plugin_configuration(self.client, plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'], Plugins.label(plugin_configuration_ref.plugin))
self.assertEqual(result['config']['second'], plugin_configuration_ref.config['second'])
# Update plugin_configuration
new_value = 5
self.assertNotEqual(new_value, plugin_configuration_ref.config['second'])
plugin_configuration_ref.config['second'] = new_value
plugin_configuration_ref.save()
logic.publish_plugin_configuration(self.client, plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'], Plugins.label(plugin_configuration_ref.plugin))
self.assertEqual(result['config']['second'], plugin_configuration_ref.config['second'])
def test_sync_incomplete_api(self):
# Create incomplete api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Try to sync, expect an error
with self.assertRaises(ValueError):
logic.synchronize_api(self.client, api_ref)
self.assertFalse(api_ref.synchronized)
# Fix api_ref
api_ref.request_host = fake.domain_name()
api_ref.save()
# Sync again
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
self.assertEqual(result['request_host'], api_ref.request_host)
def test_disable_synchronized_plugin_configuration(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(api=api_ref)
# Publish plugin_configuration
logic.synchronize_plugin_configuration(self.client, plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'], Plugins.label(plugin_configuration_ref.plugin))
self.assertTrue(result['enabled'])
# Update plugin_configuration
logic.enable_plugin_configuration(self.client, plugin_configuration_ref, enabled=False)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'], Plugins.label(plugin_configuration_ref.plugin))
self.assertFalse(result['enabled'])
def test_delete_synchronized_plugin_configuration(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(api=api_ref)
# Publish plugin_configuration
logic.synchronize_plugin_configuration(self.client, plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'], Plugins.label(plugin_configuration_ref.plugin))
# Delete plugin_configuration
plugin_configuration_kong_id = plugin_configuration_ref.kong_id
plugin_configuration_ref.delete()
# Check
with self.assertRaises(ValueError):
_ = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_kong_id)
def test_update_synchronized_plugin_configuration(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(),
request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(
api=api_ref)
# Publish plugin_configuration
logic.synchronize_plugin_configuration(self.client,
plugin_configuration_ref)
# Check if remote plugin name matches the locally known plugin, and that the configuration matches the locally
# known configuration
result = self.client.apis.plugins(api_ref.kong_id).retrieve(
plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'],
Plugins.label(plugin_configuration_ref.plugin))
self.assertEqual(result['config']['second'],
plugin_configuration_ref.config['second'])
# Update plugin_configuration
new_value = 5
self.assertNotEqual(new_value,
plugin_configuration_ref.config['second'])
plugin_configuration_ref.config['second'] = new_value
plugin_configuration_ref.save()
logic.publish_plugin_configuration(self.client,
plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(
plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'],
Plugins.label(plugin_configuration_ref.plugin))
self.assertEqual(result['config']['second'],
plugin_configuration_ref.config['second'])
def test_delete_api(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Publish
logic.synchronize_api(self.client, api_ref)
self.assertTrue(api_ref.synchronized)
# Check kong
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
self.assertEqual(result['request_host'], api_ref.request_host)
# You can delete afterwards
api_kong_id = api_ref.kong_id
api_ref.delete()
# Check kong
with self.assertRaises(ValueError):
_ = self.client.apis.retrieve(api_kong_id)
def test_create_oauth2_plugin(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Create plugin_configuration_ref
plugin_configuration_ref = PluginConfigurationReferenceFactory(
api=api_ref, plugin=Plugins.OAUTH2_AUTHENTICATION, config={})
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Reload plugin configuration
plugin_configuration_ref = PluginConfigurationReference.objects.get(id=plugin_configuration_ref.id)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'], Plugins.label(plugin_configuration_ref.plugin))
def test_sync_plugin_configuration_without_fields(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(), request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Check
result = self.client.apis.retrieve(api_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['upstream_url'], api_ref.upstream_url)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(api=api_ref, config={})
# Attempt to publish
with self.assertRaises(ValueError):
logic.synchronize_plugin_configuration(self.client, plugin_configuration_ref)
def test_disable_synchronized_plugin_configuration(self):
# Create api_ref
api_ref = APIReferenceFactory(upstream_url=fake.url(),
request_host=fake.domain_name())
# Mark for auto cleanup
self._cleanup_afterwards(api_ref)
# Publish api
logic.synchronize_api(self.client, api_ref)
# Create plugin_configuration
plugin_configuration_ref = PluginConfigurationReferenceFactory(
api=api_ref)
# Publish plugin_configuration
logic.synchronize_plugin_configuration(self.client,
plugin_configuration_ref)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(
plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'],
Plugins.label(plugin_configuration_ref.plugin))
self.assertTrue(result['enabled'])
# Update plugin_configuration
logic.enable_plugin_configuration(self.client,
plugin_configuration_ref,
enabled=False)
# Check
result = self.client.apis.plugins(api_ref.kong_id).retrieve(
plugin_configuration_ref.kong_id)
self.assertIsNotNone(result)
self.assertEqual(result['name'],
Plugins.label(plugin_configuration_ref.plugin))
self.assertFalse(result['enabled'])
