1064 lines
46 KiB
Python
1064 lines
46 KiB
Python
# Copyright (c) 2015 Rackspace, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
import json
|
|
import uuid
|
|
|
|
import mock
|
|
from oslo_context import context as context_utils
|
|
from taskflow import engines
|
|
|
|
from poppy.distributed_task.taskflow.flow import create_service
|
|
from poppy.distributed_task.taskflow.flow import create_ssl_certificate
|
|
from poppy.distributed_task.taskflow.flow import delete_service
|
|
from poppy.distributed_task.taskflow.flow import delete_ssl_certificate
|
|
from poppy.distributed_task.taskflow.flow import purge_service
|
|
from poppy.distributed_task.taskflow.flow import recreate_ssl_certificate
|
|
from poppy.distributed_task.taskflow.flow import update_service
|
|
from poppy.distributed_task.taskflow.flow import update_service_state
|
|
from poppy.distributed_task.taskflow.task import common
|
|
from poppy.distributed_task.utils import memoized_controllers
|
|
from poppy.model.helpers import domain
|
|
from poppy.model.helpers import origin
|
|
from poppy.model import service
|
|
from poppy.model import ssl_certificate
|
|
from tests.unit import base
|
|
from tests.unit.manager.default.test_services import MonkeyPatchControllers
|
|
|
|
|
|
class DNSException(Exception):
|
|
pass
|
|
|
|
|
|
class TestFlowRuns(base.TestCase):
|
|
|
|
def setUp(self):
|
|
super(TestFlowRuns, self).setUp()
|
|
|
|
pyrax_cloud_dns_patcher = mock.patch('pyrax.cloud_dns')
|
|
pyrax_cloud_dns_patcher.start()
|
|
self.addCleanup(pyrax_cloud_dns_patcher.stop)
|
|
|
|
pyrax_set_credentials_patcher = mock.patch('pyrax.set_credentials')
|
|
pyrax_set_credentials_patcher.start()
|
|
self.addCleanup(pyrax_set_credentials_patcher.stop)
|
|
|
|
cassandra_cluster_patcher = mock.patch('cassandra.cluster.Cluster')
|
|
cassandra_cluster_patcher.start()
|
|
self.addCleanup(cassandra_cluster_patcher.stop)
|
|
|
|
self.time_factor = 0.001
|
|
self.total_retries = 5
|
|
self.dns_exception_responder = [
|
|
{
|
|
'cdn_provider':
|
|
{
|
|
'error': 'DNSException',
|
|
'error_class': 'tests.unit.distributed_task'
|
|
'.taskflow.test_flows.DNSException'
|
|
}
|
|
}
|
|
]
|
|
|
|
self.dns_responder = [
|
|
{
|
|
'cdn_provider':
|
|
{
|
|
'success': 'True',
|
|
}
|
|
}
|
|
]
|
|
|
|
@staticmethod
|
|
def all_controllers():
|
|
service_controller, storage_controller = \
|
|
memoized_controllers.task_controllers('poppy', 'storage')
|
|
service_controller, dns_controller = \
|
|
memoized_controllers.task_controllers('poppy', 'dns')
|
|
service_controller, ssl_cert_controller = \
|
|
memoized_controllers.task_controllers('poppy', 'ssl_certificate')
|
|
return service_controller, storage_controller, dns_controller, \
|
|
ssl_cert_controller
|
|
|
|
def dns_exceptions_and_succeed(self):
|
|
# NOTE(TheSriram): create a chain of mocked return values,
|
|
# to allow for retries, and finally succeed. The last value
|
|
# indicating success, is just shown to indicate
|
|
# that exceptions were not thrown.
|
|
dns_responder_returns = [self.dns_exception_responder * 3]
|
|
dns_responder_returns.append(self.dns_responder)
|
|
return dns_responder_returns
|
|
|
|
def dns_exceptions_only(self):
|
|
# NOTE(TheSriram): create a chain of mocked return values,
|
|
# to allow for retries, and finally fail.
|
|
dns_responder_returns = [self.dns_exception_responder * 5]
|
|
return dns_responder_returns
|
|
|
|
@staticmethod
|
|
def patch_create_flow(service_controller,
|
|
storage_controller, dns_controller):
|
|
storage_controller.get_service = mock.Mock()
|
|
storage_controller.get_service.return_value = mock.Mock(domains=[])
|
|
storage_controller.update_service = mock.Mock()
|
|
storage_controller._driver.close_connection = mock.Mock()
|
|
service_controller.provider_wrapper.create = mock.Mock()
|
|
service_controller.provider_wrapper.create._mock_return_value = []
|
|
service_controller._driver = mock.Mock()
|
|
service_controller._driver.providers.__getitem__ = mock.Mock()
|
|
dns_controller.create = mock.Mock()
|
|
dns_controller.create._mock_return_value = []
|
|
common.create_log_delivery_container = mock.Mock()
|
|
|
|
@staticmethod
|
|
def patch_update_flow(service_controller,
|
|
storage_controller, dns_controller):
|
|
storage_controller.get_service = mock.Mock()
|
|
storage_controller.update_service = mock.Mock()
|
|
storage_controller._driver.close_connection = mock.Mock()
|
|
service_controller.provider_wrapper.update = mock.Mock()
|
|
service_controller.provider_wrapper.update._mock_return_value = []
|
|
service_controller._driver = mock.Mock()
|
|
service_controller._driver.providers.__getitem__ = mock.Mock()
|
|
dns_controller.update = mock.Mock()
|
|
dns_controller.update._mock_return_value = []
|
|
common.create_log_delivery_container = mock.Mock()
|
|
|
|
@staticmethod
|
|
def patch_delete_flow(service_controller,
|
|
storage_controller, dns_controller):
|
|
storage_controller.get_service = mock.Mock()
|
|
storage_controller.update_service = mock.Mock()
|
|
storage_controller.delete_service = mock.Mock()
|
|
storage_controller._driver.close_connection = mock.Mock()
|
|
service_controller.provider_wrapper.delete = mock.Mock()
|
|
service_controller.provider_wrapper.delete._mock_return_value = []
|
|
service_controller._driver = mock.Mock()
|
|
service_controller._driver.providers.__getitem__ = mock.Mock()
|
|
dns_controller.update = mock.Mock()
|
|
dns_controller.update._mock_return_value = []
|
|
|
|
@staticmethod
|
|
def patch_purge_flow(service_controller,
|
|
storage_controller, dns_controller):
|
|
storage_controller.get_service = mock.Mock()
|
|
storage_controller.update_service = mock.Mock()
|
|
storage_controller.delete_service = mock.Mock()
|
|
storage_controller._driver.close_connection = mock.Mock()
|
|
service_controller.provider_wrapper.purge = mock.Mock()
|
|
service_controller.provider_wrapper.purge._mock_return_value = []
|
|
service_controller._driver = mock.Mock()
|
|
service_controller._driver.providers.__getitem__ = mock.Mock()
|
|
|
|
@staticmethod
|
|
def patch_service_state_flow(service_controller,
|
|
storage_controller, dns_controller):
|
|
storage_controller.update_state = mock.Mock()
|
|
dns_controller.enable = mock.Mock()
|
|
dns_controller.enable._mock_return_value = []
|
|
dns_controller.disable = mock.Mock()
|
|
dns_controller.disable._mock_return_value = []
|
|
|
|
@staticmethod
|
|
def patch_create_ssl_certificate_flow(service_controller,
|
|
storage_controller, dns_controller):
|
|
storage_controller.get = mock.Mock()
|
|
storage_controller.update = mock.Mock()
|
|
storage_controller._driver.close_connection = mock.Mock()
|
|
service_controller.provider_wrapper.create_certificate = mock.Mock()
|
|
service_controller.provider_wrapper.create_certificate.\
|
|
_mock_return_value = []
|
|
service_controller._driver = mock.Mock()
|
|
service_controller._driver.providers.__getitem__ = mock.Mock()
|
|
service_controller._driver.notification = [mock.Mock()]
|
|
dns_controller.create = mock.Mock()
|
|
dns_controller.create._mock_return_value = []
|
|
common.create_log_delivery_container = mock.Mock()
|
|
|
|
@staticmethod
|
|
def patch_recreate_ssl_certificate_flow(
|
|
service_controller, storage_controller, dns_controller):
|
|
storage_controller.get = mock.Mock()
|
|
storage_controller.update = mock.Mock()
|
|
storage_controller._driver.close_connection = mock.Mock()
|
|
service_controller.provider_wrapper.create_certificate = mock.Mock()
|
|
service_controller.provider_wrapper.create_certificate.\
|
|
_mock_return_value = []
|
|
service_controller._driver = mock.Mock()
|
|
service_controller._driver.providers.__getitem__ = mock.Mock()
|
|
service_controller._driver.notification = [mock.Mock()]
|
|
dns_controller.create = mock.Mock()
|
|
dns_controller.create._mock_return_value = []
|
|
common.create_log_delivery_container = mock.Mock()
|
|
|
|
def test_create_flow_normal(self):
|
|
providers = ['cdn_provider']
|
|
kwargs = {
|
|
'providers_list_json': json.dumps(providers),
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'auth_token': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(str(uuid.uuid4())),
|
|
'time_seconds': [i * self.time_factor
|
|
for i in range(self.total_retries)],
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_create_flow(service_controller,
|
|
storage_controller,
|
|
dns_controller)
|
|
engines.run(create_service.create_service(), store=kwargs)
|
|
|
|
def test_update_flow_normal(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
domains_new = domain.Domain(domain='mycdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_old = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
service_new = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_new],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'auth_token': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'time_seconds': [i * self.time_factor
|
|
for i in range(self.total_retries)],
|
|
'service_old': json.dumps(service_old.to_dict()),
|
|
'service_obj': json.dumps(service_new.to_dict()),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_update_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
engines.run(update_service.update_service(), store=kwargs)
|
|
|
|
def test_delete_flow_normal(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'provider_details': json.dumps(
|
|
dict([(k, v.to_dict())
|
|
for k, v in service_obj.provider_details.items()])),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_delete_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
storage_controller.get_service = mock.Mock(
|
|
return_value=service_obj)
|
|
engines.run(delete_service.delete_service(), store=kwargs)
|
|
|
|
def test_purge_flow_normal(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'provider_details': json.dumps(
|
|
dict([(k, v.to_dict())
|
|
for k, v in service_obj.provider_details.items()])),
|
|
'purge_url': 'cdn.poppy.org',
|
|
'hard': json.dumps(True),
|
|
'service_obj': json.dumps(service_obj.to_dict()),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_purge_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
engines.run(purge_service.purge_service(), store=kwargs)
|
|
|
|
def test_service_state_flow_normal(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
enable_kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'state': 'enable',
|
|
'service_obj': json.dumps(service_obj.to_dict()),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
disable_kwargs = enable_kwargs.copy()
|
|
disable_kwargs['state'] = 'disable'
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_service_state_flow(service_controller,
|
|
storage_controller,
|
|
dns_controller)
|
|
engines.run(update_service_state.enable_service(),
|
|
store=enable_kwargs)
|
|
engines.run(update_service_state.disable_service(),
|
|
store=disable_kwargs)
|
|
|
|
def test_create_flow_dns_exception(self):
|
|
providers = ['cdn_provider']
|
|
kwargs = {
|
|
'providers_list_json': json.dumps(providers),
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'auth_token': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(str(uuid.uuid4())),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_create_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
dns_controller.create = mock.Mock()
|
|
dns_controller.create._mock_return_value = {
|
|
'cdn_provider': {
|
|
'error': 'Whoops!',
|
|
'error_class': 'tests.unit.distributed_task'
|
|
'.taskflow.test_flows.DNSException'
|
|
}
|
|
}
|
|
engines.run(create_service.create_service(), store=kwargs)
|
|
|
|
def test_update_flow_dns_exception(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
domains_new = domain.Domain(domain='mycdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_old = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
service_new = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_new],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'auth_token': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'service_old': json.dumps(service_old.to_dict()),
|
|
'service_obj': json.dumps(service_new.to_dict()),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_update_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
dns_controller.update = mock.Mock()
|
|
dns_controller.update._mock_return_value = {
|
|
'cdn_provider': {
|
|
'error': 'Whoops!',
|
|
'error_class': 'tests.unit.distributed_task'
|
|
'.taskflow.test_flows.DNSException'
|
|
}
|
|
}
|
|
|
|
engines.run(update_service.update_service(), store=kwargs)
|
|
|
|
def test_delete_flow_dns_exception(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'provider_details': json.dumps(
|
|
dict([(k, v.to_dict())
|
|
for k, v in service_obj.provider_details.items()])),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_delete_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
|
|
service_mock = mock.Mock()
|
|
type(service_mock).domains = []
|
|
storage_controller.get_service.return_value = service_mock
|
|
dns_controller.delete = mock.Mock()
|
|
dns_controller.delete._mock_return_value = {
|
|
'cdn_provider': {
|
|
'error': 'Whoops!',
|
|
'error_class': 'tests.unit.distributed_task'
|
|
'.taskflow.test_flows.DNSException'
|
|
}
|
|
}
|
|
|
|
engines.run(delete_service.delete_service(), store=kwargs)
|
|
|
|
def test_service_state_flow_dns_exception(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
enable_kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'state': 'enable',
|
|
'service_obj': json.dumps(service_obj.to_dict()),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
disable_kwargs = enable_kwargs.copy()
|
|
disable_kwargs['state'] = 'disable'
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_service_state_flow(service_controller,
|
|
storage_controller,
|
|
dns_controller)
|
|
dns_controller.enable = mock.Mock()
|
|
dns_controller.enable._mock_return_value = {
|
|
'cdn_provider': {
|
|
'error': 'Whoops!',
|
|
'error_class': 'tests.unit.distributed_task'
|
|
'.taskflow.test_flows.DNSException'
|
|
}
|
|
}
|
|
dns_controller.disable = mock.Mock()
|
|
dns_controller.disable._mock_return_value = {
|
|
'cdn_provider': {
|
|
'error': 'Whoops!',
|
|
'error_class': 'tests.unit.distributed_task'
|
|
'.taskflow.test_flows.DNSException'
|
|
}
|
|
}
|
|
engines.run(update_service_state.enable_service(),
|
|
store=enable_kwargs)
|
|
engines.run(update_service_state.disable_service(),
|
|
store=disable_kwargs)
|
|
|
|
def test_update_flow_dns_exception_with_retry_and_succeed(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
domains_new = domain.Domain(domain='mycdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_old = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
service_new = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_new],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'auth_token': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'service_old': json.dumps(service_old.to_dict()),
|
|
'service_obj': json.dumps(service_new.to_dict()),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_update_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
dns_controller.update = mock.Mock()
|
|
dns_responder_returns = self.dns_exceptions_and_succeed()
|
|
|
|
dns_controller.update._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
|
|
engines.run(update_service.update_service(), store=kwargs)
|
|
|
|
def test_update_flow_dns_exception_with_retry_and_fail(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
domains_new = domain.Domain(domain='mycdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_old = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
service_new = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_new],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'auth_token': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'service_old': json.dumps(service_old.to_dict()),
|
|
'service_obj': json.dumps(service_new.to_dict()),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_update_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
dns_controller.update = mock.Mock()
|
|
dns_responder_returns = self.dns_exceptions_only()
|
|
|
|
dns_controller.update._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
|
|
engines.run(update_service.update_service(), store=kwargs)
|
|
|
|
def test_create_flow_dns_exception_with_retry_and_succeed(self):
|
|
providers = ['cdn_provider']
|
|
kwargs = {
|
|
'providers_list_json': json.dumps(providers),
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'auth_token': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(str(uuid.uuid4())),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_create_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
dns_controller.create = mock.Mock()
|
|
|
|
dns_responder_returns = self.dns_exceptions_and_succeed()
|
|
|
|
dns_controller.create._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
|
|
engines.run(create_service.create_service(), store=kwargs)
|
|
|
|
def test_create_flow_dns_exception_with_retry_and_fail(self):
|
|
providers = ['cdn_provider']
|
|
kwargs = {
|
|
'providers_list_json': json.dumps(providers),
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'auth_token': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(str(uuid.uuid4())),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_create_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
dns_controller.create = mock.Mock()
|
|
|
|
dns_responder_returns = self.dns_exceptions_only()
|
|
|
|
dns_controller.create._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
|
|
engines.run(create_service.create_service(), store=kwargs)
|
|
|
|
def test_delete_flow_dns_exception_with_retry_and_succeed(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'provider_details': json.dumps(
|
|
dict([(k, v.to_dict())
|
|
for k, v in service_obj.provider_details.items()])),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_delete_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
dns_controller.delete = mock.Mock()
|
|
dns_responder_returns = self.dns_exceptions_and_succeed()
|
|
|
|
dns_controller.delete._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
engines.run(delete_service.delete_service(), store=kwargs)
|
|
|
|
def test_delete_flow_dns_exception_with_retry_and_fail(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'service_id': json.dumps(service_id),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'provider_details': json.dumps(
|
|
dict([(k, v.to_dict())
|
|
for k, v in service_obj.provider_details.items()])),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_delete_flow(service_controller, storage_controller,
|
|
dns_controller)
|
|
dns_controller.delete = mock.Mock()
|
|
dns_responder_returns = self.dns_exceptions_only()
|
|
|
|
dns_controller.delete._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
engines.run(delete_service.delete_service(), store=kwargs)
|
|
|
|
def test_service_state_flow_dns_exception_retry_and_succeed(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
enable_kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'state': 'enable',
|
|
'service_obj': json.dumps(service_obj.to_dict()),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
disable_kwargs = enable_kwargs.copy()
|
|
disable_kwargs['state'] = 'disable'
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_service_state_flow(service_controller,
|
|
storage_controller,
|
|
dns_controller)
|
|
dns_responder_returns = self.dns_exceptions_and_succeed()
|
|
|
|
dns_controller.enable._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
dns_controller.disable._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
|
|
engines.run(update_service_state.enable_service(),
|
|
store=enable_kwargs)
|
|
engines.run(update_service_state.disable_service(),
|
|
store=disable_kwargs)
|
|
|
|
def test_service_state_flow_dns_exception_retry_and_fail(self):
|
|
service_id = str(uuid.uuid4())
|
|
domains_old = domain.Domain(domain='cdn.poppy.org')
|
|
current_origin = origin.Origin(origin='poppy.org')
|
|
service_obj = service.Service(service_id=service_id,
|
|
name='poppy cdn service',
|
|
domains=[domains_old],
|
|
origins=[current_origin],
|
|
flavor_id='cdn')
|
|
|
|
enable_kwargs = {
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'state': 'enable',
|
|
'service_obj': json.dumps(service_obj.to_dict()),
|
|
'time_seconds': [i * self.time_factor for
|
|
i in range(self.total_retries)],
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
disable_kwargs = enable_kwargs.copy()
|
|
disable_kwargs['state'] = 'disable'
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
self.patch_service_state_flow(service_controller,
|
|
storage_controller,
|
|
dns_controller)
|
|
dns_responder_returns = self.dns_exceptions_only()
|
|
|
|
dns_controller.enable._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
dns_controller.disable._mock_side_effect = (dns_responder for
|
|
dns_responder in
|
|
dns_responder_returns)
|
|
|
|
engines.run(update_service_state.enable_service(),
|
|
store=enable_kwargs)
|
|
engines.run(update_service_state.disable_service(),
|
|
store=disable_kwargs)
|
|
|
|
def test_create_ssl_certificate_normal(self):
|
|
|
|
providers = ['cdn_provider']
|
|
cert_obj_json = ssl_certificate.SSLCertificate('cdn',
|
|
'mytestsite.com',
|
|
'san')
|
|
kwargs = {
|
|
'providers_list_json': json.dumps(providers),
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'cert_obj_json': json.dumps(cert_obj_json.to_dict()),
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_create_ssl_certificate_flow(service_controller,
|
|
storage_controller,
|
|
dns_controller)
|
|
engines.run(create_ssl_certificate.create_ssl_certificate(),
|
|
store=kwargs)
|
|
|
|
def test_recreate_ssl_certificate(self):
|
|
|
|
providers = ['cdn_provider']
|
|
cert_obj_json = ssl_certificate.SSLCertificate('cdn',
|
|
'mytestsite.com',
|
|
'san')
|
|
kwargs = {
|
|
'providers_list_json': json.dumps(providers),
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'domain_name': 'mytestsite.com',
|
|
'cert_type': 'san',
|
|
'cert_obj_json': json.dumps(cert_obj_json.to_dict()),
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_recreate_ssl_certificate_flow(service_controller,
|
|
storage_controller,
|
|
dns_controller)
|
|
engines.run(recreate_ssl_certificate.recreate_ssl_certificate(),
|
|
store=kwargs)
|
|
|
|
def test_delete_ssl_certificate_normal(self):
|
|
|
|
kwargs = {
|
|
'cert_type': "san",
|
|
'project_id': json.dumps(str(uuid.uuid4())),
|
|
'domain_name': "san.san.com",
|
|
'context_dict': context_utils.RequestContext().to_dict()
|
|
}
|
|
|
|
(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller,
|
|
ssl_cert_controller
|
|
) = self.all_controllers()
|
|
|
|
with MonkeyPatchControllers(service_controller,
|
|
dns_controller,
|
|
storage_controller,
|
|
ssl_cert_controller,
|
|
memoized_controllers.task_controllers):
|
|
|
|
self.patch_create_ssl_certificate_flow(
|
|
service_controller,
|
|
storage_controller,
|
|
dns_controller
|
|
)
|
|
engines.run(
|
|
delete_ssl_certificate.delete_ssl_certificate(),
|
|
store=kwargs
|
|
)
|