Merge "Initial creation of repository classes and tests"
This commit is contained in:
Jenkins
Gerrit Code Review
commit
29b492bff4
|
|
@ -21,10 +21,12 @@ class BaseDataModel(object):
|
|||
def to_dict(self):
|
||||
ret = {}
|
||||
for attr in self.__dict__:
|
||||
if (attr.startswith('_') or
|
||||
isinstance(getattr(self, attr), BaseDataModel)):
|
||||
if attr.startswith('_'):
|
||||
continue
|
||||
ret[attr] = self.__dict__[attr]
|
||||
if isinstance(getattr(self, attr), (BaseDataModel, list)):
|
||||
ret[attr] = None
|
||||
else:
|
||||
ret[attr] = self.__dict__[attr]
|
||||
return ret
|
||||
|
||||
def __eq__(self, other):
|
||||
|
|
|
|||
|
|
@ -52,8 +52,12 @@ class BadRequest(OctaviaException):
|
|||
|
||||
|
||||
class NotFound(OctaviaException):
|
||||
pass
|
||||
message = _('%(resource)s not found.')
|
||||
|
||||
|
||||
class NotAuthorized(OctaviaException):
|
||||
message = _("Not authorized.")
|
||||
|
||||
|
||||
class MissingArguments(OctaviaException):
|
||||
message = _("Missing arguments.")
|
||||
|
|
|
|||
|
|
@ -0,0 +1,165 @@
|
|||
# Copyright 2014 Rackspace
|
||||
#
|
||||
# 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.
|
||||
|
||||
"""
|
||||
Defines interface for DB access that Resource or Octavia Controllers may
|
||||
reference
|
||||
"""
|
||||
|
||||
from octavia.common import exceptions
|
||||
from octavia.db import models
|
||||
|
||||
|
||||
class BaseRepository(object):
|
||||
|
||||
model_class = None
|
||||
|
||||
def create(self, session, **model_kwargs):
|
||||
with session.begin():
|
||||
model = self.model_class(**model_kwargs)
|
||||
session.add(model)
|
||||
return model.to_data_model()
|
||||
|
||||
def delete(self, session, **filters):
|
||||
model = session.query(self.model_class).filter_by(**filters).first()
|
||||
with session.begin():
|
||||
session.delete(model)
|
||||
session.flush()
|
||||
|
||||
def delete_batch(self, session, ids=None):
|
||||
[self.delete(session, id) for id in ids]
|
||||
|
||||
def update(self, session, id, **model_kwargs):
|
||||
with session.begin():
|
||||
session.query(self.model_class).filter_by(
|
||||
id=id).update(model_kwargs)
|
||||
|
||||
def get(self, session, **filters):
|
||||
model = session.query(self.model_class).filter_by(**filters).first()
|
||||
if not model:
|
||||
raise exceptions.NotFound(resource=self.model_class.__name__)
|
||||
return model.to_data_model()
|
||||
|
||||
def get_all(self, session, **filters):
|
||||
model_list = session.query(self.model_class).filter_by(**filters).all()
|
||||
data_model_list = [model.to_data_model() for model in model_list]
|
||||
return data_model_list
|
||||
|
||||
|
||||
class Repositories(object):
|
||||
|
||||
def __init__(self):
|
||||
self.load_balancer = LoadBalancerRepository()
|
||||
self.vip = VipRepository()
|
||||
self.health_monitor = HealthMonitorRepository()
|
||||
self.session_persistence = SessionPersistenceRepository()
|
||||
self.pool = PoolRepository()
|
||||
self.member = MemberRepository()
|
||||
self.listener = ListenerRepository()
|
||||
self.listener_stats = ListenerStatisticsRepository()
|
||||
self.amphora = AmphoraRepository()
|
||||
self.sni = SNIRepository()
|
||||
|
||||
|
||||
class LoadBalancerRepository(BaseRepository):
|
||||
|
||||
model_class = models.LoadBalancer
|
||||
|
||||
|
||||
class VipRepository(BaseRepository):
|
||||
|
||||
model_class = models.Vip
|
||||
|
||||
def update(self, session, load_balancer_id, **model_kwargs):
|
||||
with session.begin():
|
||||
session.query(self.model_class).filter_by(
|
||||
load_balancer_id=load_balancer_id).update(model_kwargs)
|
||||
|
||||
|
||||
class HealthMonitorRepository(BaseRepository):
|
||||
|
||||
model_class = models.HealthMonitor
|
||||
|
||||
def update(self, session, pool_id, **model_kwargs):
|
||||
with session.begin():
|
||||
session.query(self.model_class).filter_by(
|
||||
pool_id=pool_id).update(model_kwargs)
|
||||
|
||||
|
||||
class SessionPersistenceRepository(BaseRepository):
|
||||
|
||||
model_class = models.SessionPersistence
|
||||
|
||||
def update(self, session, pool_id, **model_kwargs):
|
||||
with session.begin():
|
||||
session.query(self.model_class).filter_by(
|
||||
pool_id=pool_id).update(model_kwargs)
|
||||
|
||||
|
||||
class PoolRepository(BaseRepository):
|
||||
|
||||
model_class = models.Pool
|
||||
|
||||
|
||||
class MemberRepository(BaseRepository):
|
||||
|
||||
model_class = models.Member
|
||||
|
||||
def delete_members(self, session, member_ids):
|
||||
self.delete_batch(session, member_ids)
|
||||
|
||||
|
||||
class ListenerRepository(BaseRepository):
|
||||
|
||||
model_class = models.Listener
|
||||
|
||||
|
||||
class ListenerStatisticsRepository(BaseRepository):
|
||||
|
||||
model_class = models.ListenerStatistics
|
||||
|
||||
def update(self, session, listener_id, **model_kwargs):
|
||||
with session.begin():
|
||||
session.query(self.model_class).filter_by(
|
||||
listener_id=listener_id).update(model_kwargs)
|
||||
|
||||
|
||||
class AmphoraRepository(BaseRepository):
|
||||
|
||||
model_class = models.Amphora
|
||||
|
||||
def associate(self, session, load_balancer_id, amphora_id):
|
||||
with session.begin():
|
||||
load_balancer = session.query(models.LoadBalancer).filter_by(
|
||||
id=load_balancer_id).first()
|
||||
amphora = session.query(self.model_class).filter_by(
|
||||
id=amphora_id).first()
|
||||
load_balancer.amphorae.append(amphora)
|
||||
|
||||
|
||||
class SNIRepository(BaseRepository):
|
||||
|
||||
model_class = models.SNI
|
||||
|
||||
def update(self, session, listener_id=None, tls_container_id=None,
|
||||
**model_kwargs):
|
||||
if not listener_id and tls_container_id:
|
||||
raise exceptions.MissingArguments
|
||||
with session.begin():
|
||||
if listener_id:
|
||||
session.query(self.model_class).filter_by(
|
||||
listener_id=listener_id).update(model_kwargs)
|
||||
elif tls_container_id:
|
||||
session.query(self.model_class).filter_by(
|
||||
tls_container_id=tls_container_id).update(model_kwargs)
|
||||
|
|
@ -0,0 +1,916 @@
|
|||
# Copyright 2014 Rackspace
|
||||
#
|
||||
# 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.
|
||||
|
||||
from octavia.common import constants
|
||||
from octavia.common import data_models as models
|
||||
from octavia.common import exceptions
|
||||
from octavia.db import repositories as repo
|
||||
from octavia.openstack.common import uuidutils
|
||||
from octavia.tests.unit.db import base
|
||||
|
||||
|
||||
class BaseRepositoryTest(base.OctaviaDBTestBase):
|
||||
|
||||
FAKE_UUID_1 = uuidutils.generate_uuid()
|
||||
FAKE_UUID_2 = uuidutils.generate_uuid()
|
||||
FAKE_UUID_3 = uuidutils.generate_uuid()
|
||||
|
||||
def setUp(self):
|
||||
super(BaseRepositoryTest, self).setUp()
|
||||
self.pool_repo = repo.PoolRepository()
|
||||
self.member_repo = repo.MemberRepository()
|
||||
self.lb_repo = repo.LoadBalancerRepository()
|
||||
self.vip_repo = repo.VipRepository()
|
||||
self.listener_repo = repo.ListenerRepository()
|
||||
self.listener_stats_repo = repo.ListenerStatisticsRepository()
|
||||
self.sp_repo = repo.SessionPersistenceRepository()
|
||||
self.hm_repo = repo.HealthMonitorRepository()
|
||||
self.sni_repo = repo.SNIRepository()
|
||||
self.amphora_repo = repo.AmphoraRepository()
|
||||
|
||||
def test_get_all_return_value(self):
|
||||
pool_list = self.pool_repo.get_all(self.session,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertIsInstance(pool_list, list)
|
||||
lb_list = self.lb_repo.get_all(self.session,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertIsInstance(lb_list, list)
|
||||
listener_list = self.listener_repo.get_all(self.session,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertIsInstance(listener_list, list)
|
||||
member_list = self.member_repo.get_all(self.session,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertIsInstance(member_list, list)
|
||||
|
||||
|
||||
class PoolRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def create_pool(self, pool_id, tenant_id):
|
||||
pool = self.pool_repo.create(
|
||||
self.session, id=pool_id, tenant_id=tenant_id, name="pool_test",
|
||||
description="pool_description", protocol=constants.PROTOCOL_HTTP,
|
||||
lb_algorithm=constants.LB_ALGORITHM_ROUND_ROBIN,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
return pool
|
||||
|
||||
def test_get(self):
|
||||
pool = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
new_pool = self.pool_repo.get(self.session, id=pool.id)
|
||||
self.assertIsInstance(new_pool, models.Pool)
|
||||
self.assertEqual(pool, new_pool)
|
||||
|
||||
def test_get_all(self):
|
||||
pool_one = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
pool_two = self.create_pool(pool_id=self.FAKE_UUID_3,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
pool_list = self.pool_repo.get_all(self.session,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertIsInstance(pool_list, list)
|
||||
self.assertEqual(2, len(pool_list))
|
||||
self.assertEqual(pool_one, pool_list[0])
|
||||
self.assertEqual(pool_two, pool_list[1])
|
||||
|
||||
def test_create(self):
|
||||
pool = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertIsInstance(pool, models.Pool)
|
||||
self.assertEqual(self.FAKE_UUID_2, pool.tenant_id)
|
||||
self.assertEqual("pool_test", pool.name)
|
||||
self.assertEqual("pool_description", pool.description)
|
||||
self.assertEqual(constants.PROTOCOL_HTTP, pool.protocol)
|
||||
self.assertEqual(constants.LB_ALGORITHM_ROUND_ROBIN, pool.lb_algorithm)
|
||||
self.assertEqual(constants.ONLINE, pool.operating_status)
|
||||
|
||||
def test_update(self):
|
||||
pool = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.pool_repo.update(self.session, pool.id,
|
||||
description="other_pool_description")
|
||||
new_pool = self.pool_repo.get(self.session, id=self.FAKE_UUID_1)
|
||||
self.assertEqual("other_pool_description", new_pool.description)
|
||||
|
||||
def test_delete(self):
|
||||
pool = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.pool_repo.delete(self.session, id=pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.pool_repo.get,
|
||||
self.session, id=pool.id)
|
||||
|
||||
def test_delete_with_member(self):
|
||||
pool = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
member = self.member_repo.create(self.session, id=self.FAKE_UUID_3,
|
||||
tenant_id=self.FAKE_UUID_2,
|
||||
pool_id=pool.id,
|
||||
ip_address="10.0.0.1",
|
||||
protocol_port=80, enabled=True,
|
||||
operating_status=constants.ONLINE)
|
||||
new_pool = self.pool_repo.get(self.session, id=pool.id)
|
||||
self.assertEqual(1, len(new_pool.members))
|
||||
self.assertEqual(member, new_pool.members[0])
|
||||
self.pool_repo.delete(self.session, id=pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.pool_repo.get,
|
||||
self.session, id=pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.member_repo.get,
|
||||
self.session, id=member.id)
|
||||
|
||||
def test_delete_with_health_monitor(self):
|
||||
pool = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
hm = self.hm_repo.create(self.session, id=self.FAKE_UUID_3,
|
||||
tenant_id=self.FAKE_UUID_2, pool_id=pool.id,
|
||||
type=constants.HEALTH_MONITOR_HTTP,
|
||||
delay=1, timeout=1, fall_threshold=1,
|
||||
rise_threshold=1, enabled=True)
|
||||
new_pool = self.pool_repo.get(self.session, id=pool.id)
|
||||
self.assertEqual(pool, new_pool)
|
||||
self.assertEqual(hm, new_pool.health_monitor)
|
||||
self.pool_repo.delete(self.session, id=pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.pool_repo.get,
|
||||
self.session, id=pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.hm_repo.get, self.session,
|
||||
pool_id=hm.pool_id)
|
||||
|
||||
def test_delete_with_session_persistence(self):
|
||||
pool = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
sp = self.sp_repo.create(
|
||||
self.session, pool_id=pool.id,
|
||||
type=constants.SESSION_PERSISTENCE_HTTP_COOKIE,
|
||||
cookie_name="cookie_name")
|
||||
new_pool = self.pool_repo.get(self.session, id=pool.id)
|
||||
self.assertEqual(pool, new_pool)
|
||||
self.assertEqual(sp, new_pool.session_persistence)
|
||||
self.pool_repo.delete(self.session, id=new_pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.pool_repo.get,
|
||||
self.session, id=pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.sp_repo.get, self.session,
|
||||
pool_id=sp.pool_id)
|
||||
|
||||
def test_delete_with_all_children(self):
|
||||
pool = self.create_pool(pool_id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
hm = self.hm_repo.create(self.session, id=self.FAKE_UUID_1,
|
||||
tenant_id=self.FAKE_UUID_2, pool_id=pool.id,
|
||||
type=constants.HEALTH_MONITOR_HTTP,
|
||||
delay=1, timeout=1, fall_threshold=1,
|
||||
rise_threshold=1, enabled=True)
|
||||
member = self.member_repo.create(self.session, id=self.FAKE_UUID_3,
|
||||
tenant_id=self.FAKE_UUID_2,
|
||||
pool_id=pool.id,
|
||||
ip_address="10.0.0.1",
|
||||
protocol_port=80,
|
||||
operating_status=constants.ONLINE,
|
||||
enabled=True)
|
||||
sp = self.sp_repo.create(
|
||||
self.session, pool_id=pool.id,
|
||||
type=constants.SESSION_PERSISTENCE_HTTP_COOKIE,
|
||||
cookie_name="cookie_name")
|
||||
new_pool = self.pool_repo.get(self.session, id=pool.id)
|
||||
self.assertEqual(pool, new_pool)
|
||||
self.assertEqual(1, len(new_pool.members))
|
||||
new_member = self.member_repo.get(self.session, id=member.id)
|
||||
self.assertEqual(new_member, new_pool.members[0])
|
||||
self.assertEqual(hm, new_pool.health_monitor)
|
||||
self.assertEqual(sp, new_pool.session_persistence)
|
||||
self.pool_repo.delete(self.session, id=pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.pool_repo.get,
|
||||
self.session, id=pool.id)
|
||||
self.assertRaises(exceptions.NotFound, self.member_repo.get,
|
||||
self.session, id=member.id)
|
||||
self.assertRaises(exceptions.NotFound, self.hm_repo.get, self.session,
|
||||
pool_id=hm.pool_id)
|
||||
self.assertRaises(exceptions.NotFound, self.sp_repo.get, self.session,
|
||||
pool_id=sp.pool_id)
|
||||
|
||||
|
||||
class MemberRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def setUp(self):
|
||||
super(MemberRepositoryTest, self).setUp()
|
||||
self.pool = self.pool_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="pool_test", description="pool_description",
|
||||
protocol=constants.PROTOCOL_HTTP,
|
||||
lb_algorithm=constants.LB_ALGORITHM_ROUND_ROBIN,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
|
||||
def create_member(self, member_id, tenant_id, pool_id, ip_address):
|
||||
member = self.member_repo.create(self.session, id=member_id,
|
||||
tenant_id=tenant_id, pool_id=pool_id,
|
||||
ip_address=ip_address,
|
||||
protocol_port=80,
|
||||
operating_status=constants.ONLINE,
|
||||
enabled=True)
|
||||
return member
|
||||
|
||||
def test_get(self):
|
||||
member = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
|
||||
self.pool.id, "10.0.0.1")
|
||||
new_member = self.member_repo.get(self.session, id=member.id)
|
||||
self.assertIsInstance(new_member, models.Member)
|
||||
self.assertEqual(member, new_member)
|
||||
|
||||
def test_get_all(self):
|
||||
member_one = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
|
||||
self.pool.id, "10.0.0.1")
|
||||
member_two = self.create_member(self.FAKE_UUID_3, self.FAKE_UUID_2,
|
||||
self.pool.id, "10.0.0.2")
|
||||
member_list = self.member_repo.get_all(self.session,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertIsInstance(member_list, list)
|
||||
self.assertEqual(2, len(member_list))
|
||||
self.assertEqual(member_one, member_list[0])
|
||||
self.assertEqual(member_two, member_list[1])
|
||||
|
||||
def test_create(self):
|
||||
member = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
|
||||
self.pool.id, ip_address="10.0.0.1")
|
||||
new_member = self.member_repo.get(self.session, id=member.id)
|
||||
self.assertEqual(self.FAKE_UUID_1, new_member.id)
|
||||
self.assertEqual(self.FAKE_UUID_2, new_member.tenant_id)
|
||||
self.assertEqual(self.pool.id, new_member.pool_id)
|
||||
self.assertEqual("10.0.0.1", new_member.ip_address)
|
||||
self.assertEqual(80, new_member.protocol_port)
|
||||
self.assertEqual(constants.ONLINE, new_member.operating_status)
|
||||
self.assertEqual(True, new_member.enabled)
|
||||
|
||||
def test_update(self):
|
||||
ip_address_change = "10.0.0.2"
|
||||
member = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
|
||||
self.pool.id, "10.0.0.1")
|
||||
self.member_repo.update(self.session, id=member.id,
|
||||
ip_address=ip_address_change)
|
||||
new_member = self.member_repo.get(self.session, id=member.id)
|
||||
self.assertEqual(ip_address_change, new_member.ip_address)
|
||||
|
||||
def test_delete(self):
|
||||
member = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
|
||||
self.pool.id, "10.0.0.1")
|
||||
self.member_repo.delete(self.session, id=member.id)
|
||||
self.assertRaises(exceptions.NotFound, self.member_repo.get,
|
||||
self.session, id=member.id)
|
||||
new_pool = self.pool_repo.get(self.session, id=self.pool.id)
|
||||
self.assertIsNotNone(new_pool)
|
||||
self.assertEqual(0, len(new_pool.members))
|
||||
|
||||
|
||||
class SessionPersistenceRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def setUp(self):
|
||||
super(SessionPersistenceRepositoryTest, self).setUp()
|
||||
self.pool = self.pool_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="pool_test", description="pool_description",
|
||||
protocol=constants.PROTOCOL_HTTP,
|
||||
lb_algorithm=constants.LB_ALGORITHM_ROUND_ROBIN,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
|
||||
def create_session_persistence(self, pool_id):
|
||||
sp = self.sp_repo.create(
|
||||
self.session, pool_id=pool_id,
|
||||
type=constants.SESSION_PERSISTENCE_HTTP_COOKIE,
|
||||
cookie_name="cookie_name")
|
||||
return sp
|
||||
|
||||
def test_get(self):
|
||||
sp = self.create_session_persistence(self.pool.id)
|
||||
new_sp = self.sp_repo.get(self.session, pool_id=sp.pool_id)
|
||||
self.assertIsInstance(new_sp, models.SessionPersistence)
|
||||
self.assertEqual(sp, new_sp)
|
||||
|
||||
def test_create(self):
|
||||
sp = self.create_session_persistence(self.pool.id)
|
||||
new_sp = self.sp_repo.get(self.session, pool_id=sp.pool_id)
|
||||
self.assertEqual(self.pool.id, new_sp.pool_id)
|
||||
self.assertEqual(constants.SESSION_PERSISTENCE_HTTP_COOKIE,
|
||||
new_sp.type)
|
||||
self.assertEqual("cookie_name", new_sp.cookie_name)
|
||||
|
||||
def test_update(self):
|
||||
name_change = "new_cookie_name"
|
||||
sp = self.create_session_persistence(self.pool.id)
|
||||
self.sp_repo.update(self.session, pool_id=sp.pool_id,
|
||||
cookie_name=name_change)
|
||||
new_sp = self.sp_repo.get(self.session, pool_id=sp.pool_id)
|
||||
self.assertEqual(name_change, new_sp.cookie_name)
|
||||
|
||||
def test_delete(self):
|
||||
sp = self.create_session_persistence(self.pool.id)
|
||||
self.sp_repo.delete(self.session, pool_id=sp.pool_id)
|
||||
self.assertRaises(exceptions.NotFound, self.member_repo.get,
|
||||
self.session, pool_id=sp.pool_id)
|
||||
new_pool = self.pool_repo.get(self.session, id=self.pool.id)
|
||||
self.assertIsNotNone(new_pool)
|
||||
self.assertIsNone(new_pool.session_persistence)
|
||||
|
||||
|
||||
class ListenerRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def setUp(self):
|
||||
super(ListenerRepositoryTest, self).setUp()
|
||||
self.load_balancer = self.lb_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="lb_name", description="lb_description",
|
||||
provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
|
||||
def create_listener(self, listener_id, port, default_pool_id=None):
|
||||
listener = self.listener_repo.create(
|
||||
self.session, id=listener_id, tenant_id=self.FAKE_UUID_2,
|
||||
name="listener_name", description="listener_description",
|
||||
protocol=constants.PROTOCOL_HTTP, protocol_port=port,
|
||||
connection_limit=1, load_balancer_id=self.load_balancer.id,
|
||||
default_pool_id=default_pool_id, operating_status=constants.ONLINE,
|
||||
provisioning_status=constants.ACTIVE, enabled=True)
|
||||
return listener
|
||||
|
||||
def test_get(self):
|
||||
listener = self.create_listener(self.FAKE_UUID_1, 80)
|
||||
new_listener = self.listener_repo.get(self.session, id=listener.id)
|
||||
self.assertIsInstance(new_listener, models.Listener)
|
||||
self.assertEqual(listener, new_listener)
|
||||
|
||||
def test_get_all(self):
|
||||
listener_one = self.create_listener(self.FAKE_UUID_1, 80)
|
||||
listener_two = self.create_listener(self.FAKE_UUID_3, 88)
|
||||
listener_list = self.listener_repo.get_all(self.session,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertIsInstance(listener_list, list)
|
||||
self.assertEqual(2, len(listener_list))
|
||||
self.assertEqual(listener_one, listener_list[0])
|
||||
self.assertEqual(listener_two, listener_list[1])
|
||||
|
||||
def test_create(self):
|
||||
listener = self.create_listener(self.FAKE_UUID_1, 80)
|
||||
new_listener = self.listener_repo.get(self.session, id=listener.id)
|
||||
self.assertEqual(self.FAKE_UUID_1, new_listener.id)
|
||||
self.assertEqual(self.FAKE_UUID_2, new_listener.tenant_id)
|
||||
self.assertEqual("listener_name", new_listener.name)
|
||||
self.assertEqual("listener_description", new_listener.description)
|
||||
self.assertEqual(constants.PROTOCOL_HTTP, new_listener.protocol)
|
||||
self.assertEqual(80, new_listener.protocol_port)
|
||||
self.assertEqual(1, new_listener.connection_limit)
|
||||
self.assertEqual(self.load_balancer.id, new_listener.load_balancer_id)
|
||||
self.assertEqual(constants.ACTIVE, new_listener.provisioning_status)
|
||||
self.assertEqual(constants.ONLINE, new_listener.operating_status)
|
||||
self.assertEqual(True, new_listener.enabled)
|
||||
|
||||
def test_update(self):
|
||||
name_change = "new_listener_name"
|
||||
listener = self.create_listener(self.FAKE_UUID_1, 80)
|
||||
self.listener_repo.update(self.session, listener.id,
|
||||
name=name_change)
|
||||
new_listener = self.listener_repo.get(self.session, id=listener.id)
|
||||
self.assertEqual(name_change, new_listener.name)
|
||||
|
||||
def test_delete(self):
|
||||
listener = self.create_listener(self.FAKE_UUID_1, 80)
|
||||
self.listener_repo.delete(self.session, id=listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener.id)
|
||||
|
||||
def test_delete_with_sni(self):
|
||||
listener = self.create_listener(self.FAKE_UUID_1, 80)
|
||||
sni = self.sni_repo.create(self.session, listener_id=listener.id,
|
||||
tls_container_id=self.FAKE_UUID_3)
|
||||
new_listener = self.listener_repo.get(self.session, id=listener.id)
|
||||
self.assertIsNotNone(new_listener)
|
||||
self.assertEqual(sni, new_listener.sni_containers[0])
|
||||
self.listener_repo.delete(self.session, id=new_listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.sni_repo.get, self.session,
|
||||
listener_id=listener.id)
|
||||
|
||||
def test_delete_with_stats(self):
|
||||
listener = self.create_listener(self.FAKE_UUID_1, 80)
|
||||
stats = self.listener_stats_repo.create(
|
||||
self.session, listener_id=listener.id, bytes_in=1, bytes_out=1,
|
||||
active_connections=1, total_connections=1)
|
||||
new_listener = self.listener_repo.get(self.session, id=listener.id)
|
||||
self.assertIsNotNone(new_listener)
|
||||
self.assertEqual(stats, new_listener.stats)
|
||||
self.listener_repo.delete(self.session, id=listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_stats_repo.get,
|
||||
self.session, listener_id=listener.id)
|
||||
|
||||
def test_delete_with_pool(self):
|
||||
pool = self.pool_repo.create(
|
||||
self.session, id=self.FAKE_UUID_3, tenant_id=self.FAKE_UUID_2,
|
||||
name="pool_test", description="pool_description",
|
||||
protocol=constants.PROTOCOL_HTTP,
|
||||
lb_algorithm=constants.LB_ALGORITHM_ROUND_ROBIN,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
listener = self.create_listener(self.FAKE_UUID_1, 80,
|
||||
default_pool_id=pool.id)
|
||||
new_listener = self.listener_repo.get(self.session, id=listener.id)
|
||||
self.assertIsNotNone(new_listener)
|
||||
self.assertEqual(pool, new_listener.default_pool)
|
||||
self.listener_repo.delete(self.session, id=new_listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.pool_repo.get,
|
||||
self.session, id=pool.id)
|
||||
|
||||
def test_delete_with_all_children(self):
|
||||
pool = self.pool_repo.create(
|
||||
self.session, id=self.FAKE_UUID_3, tenant_id=self.FAKE_UUID_2,
|
||||
name="pool_test", description="pool_description",
|
||||
protocol=constants.PROTOCOL_HTTP,
|
||||
lb_algorithm=constants.LB_ALGORITHM_ROUND_ROBIN,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
listener = self.create_listener(self.FAKE_UUID_1, 80,
|
||||
default_pool_id=pool.id)
|
||||
sni = self.sni_repo.create(self.session, listener_id=listener.id,
|
||||
tls_container_id=self.FAKE_UUID_3)
|
||||
stats = self.listener_stats_repo.create(
|
||||
self.session, listener_id=listener.id, bytes_in=1, bytes_out=1,
|
||||
active_connections=1, total_connections=1)
|
||||
new_listener = self.listener_repo.get(self.session, id=listener.id)
|
||||
self.assertIsNotNone(new_listener)
|
||||
self.assertEqual(pool, new_listener.default_pool)
|
||||
self.assertEqual(sni, new_listener.sni_containers[0])
|
||||
self.assertEqual(stats, new_listener.stats)
|
||||
self.listener_repo.delete(self.session, id=listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.sni_repo.get, self.session,
|
||||
listener_id=listener.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_stats_repo.get,
|
||||
self.session, listener_id=sni.listener_id)
|
||||
self.assertRaises(exceptions.NotFound, self.pool_repo.get,
|
||||
self.session, id=pool.id)
|
||||
|
||||
|
||||
class ListenerStatisticsRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def setUp(self):
|
||||
super(ListenerStatisticsRepositoryTest, self).setUp()
|
||||
self.listener = self.listener_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="listener_name", description="listener_description",
|
||||
protocol=constants.PROTOCOL_HTTP, protocol_port=80,
|
||||
connection_limit=1, provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
|
||||
def create_listener_stats(self, listener_id):
|
||||
stats = self.listener_stats_repo.create(
|
||||
self.session, listener_id=listener_id, bytes_in=1, bytes_out=1,
|
||||
active_connections=1, total_connections=1)
|
||||
return stats
|
||||
|
||||
def test_get(self):
|
||||
stats = self.create_listener_stats(self.listener.id)
|
||||
new_stats = self.listener_stats_repo.get(self.session,
|
||||
listener_id=stats.listener_id)
|
||||
self.assertIsInstance(new_stats, models.ListenerStatistics)
|
||||
self.assertEqual(stats.listener_id, new_stats.listener_id)
|
||||
|
||||
def test_create(self):
|
||||
stats = self.create_listener_stats(self.listener.id)
|
||||
new_stats = self.listener_stats_repo.get(self.session,
|
||||
listener_id=stats.listener_id)
|
||||
self.assertEqual(self.listener.id, new_stats.listener_id)
|
||||
self.assertEqual(1, new_stats.bytes_in)
|
||||
self.assertEqual(1, new_stats.bytes_out)
|
||||
self.assertEqual(1, new_stats.active_connections)
|
||||
self.assertEqual(1, new_stats.total_connections)
|
||||
|
||||
def test_update(self):
|
||||
bytes_in_change = 2
|
||||
stats = self.create_listener_stats(self.listener.id)
|
||||
self.listener_stats_repo.update(self.session, stats.listener_id,
|
||||
bytes_in=bytes_in_change)
|
||||
new_stats = self.listener_stats_repo.get(self.session,
|
||||
listener_id=stats.listener_id)
|
||||
self.assertIsInstance(new_stats, models.ListenerStatistics)
|
||||
self.assertEqual(stats.listener_id, new_stats.listener_id)
|
||||
|
||||
def test_delete(self):
|
||||
stats = self.create_listener_stats(self.listener.id)
|
||||
self.listener_stats_repo.delete(self.session,
|
||||
listener_id=stats.listener_id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_stats_repo.get,
|
||||
self.session, listener_id=stats.listener_id)
|
||||
new_listener = self.listener_repo.get(self.session,
|
||||
id=self.listener.id)
|
||||
self.assertIsNotNone(new_listener)
|
||||
self.assertIsNone(new_listener.stats)
|
||||
|
||||
|
||||
class HealthMonitorRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def setUp(self):
|
||||
super(HealthMonitorRepositoryTest, self).setUp()
|
||||
self.pool = self.pool_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="pool_test", description="pool_description",
|
||||
protocol=constants.PROTOCOL_HTTP,
|
||||
lb_algorithm=constants.LB_ALGORITHM_ROUND_ROBIN,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
|
||||
def create_health_monitor(self, pool_id):
|
||||
health_monitor = self.hm_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
type=constants.HEALTH_MONITOR_HTTP, pool_id=pool_id,
|
||||
delay=1, timeout=1, fall_threshold=1, rise_threshold=1,
|
||||
http_method="POST", url_path="http://localhost:80/index.php",
|
||||
expected_codes="200", enabled=True)
|
||||
return health_monitor
|
||||
|
||||
def test_get(self):
|
||||
hm = self.create_health_monitor(self.pool.id)
|
||||
new_hm = self.hm_repo.get(self.session, pool_id=hm.pool_id)
|
||||
self.assertIsInstance(new_hm, models.HealthMonitor)
|
||||
self.assertEqual(hm, new_hm)
|
||||
|
||||
def test_create(self):
|
||||
hm = self.create_health_monitor(self.pool.id)
|
||||
new_hm = self.hm_repo.get(self.session, pool_id=hm.pool_id)
|
||||
self.assertEqual(constants.HEALTH_MONITOR_HTTP, new_hm.type)
|
||||
self.assertEqual(self.pool.id, new_hm.pool_id)
|
||||
self.assertEqual(1, new_hm.delay)
|
||||
self.assertEqual(1, new_hm.timeout)
|
||||
self.assertEqual(1, new_hm.fall_threshold)
|
||||
self.assertEqual(1, new_hm.rise_threshold)
|
||||
self.assertEqual("POST", new_hm.http_method)
|
||||
self.assertEqual("http://localhost:80/index.php", new_hm.url_path)
|
||||
self.assertEqual("200", new_hm.expected_codes)
|
||||
self.assertEqual(True, new_hm.enabled)
|
||||
|
||||
def test_update(self):
|
||||
delay_change = 2
|
||||
hm = self.create_health_monitor(self.pool.id)
|
||||
self.hm_repo.update(self.session, hm.pool.id, delay=delay_change)
|
||||
new_hm = self.hm_repo.get(self.session, pool_id=hm.pool_id)
|
||||
self.assertEqual(delay_change, new_hm.delay)
|
||||
|
||||
def test_delete(self):
|
||||
hm = self.create_health_monitor(self.pool.id)
|
||||
self.hm_repo.delete(self.session, pool_id=hm.pool_id)
|
||||
self.assertRaises(exceptions.NotFound, self.hm_repo.get, self.session,
|
||||
pool_id=hm.pool_id)
|
||||
new_pool = self.pool_repo.get(self.session, id=self.pool.id)
|
||||
self.assertIsNotNone(new_pool)
|
||||
self.assertIsNone(new_pool.health_monitor)
|
||||
|
||||
|
||||
class LoadBalancerRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def create_loadbalancer(self, lb_id):
|
||||
lb = self.lb_repo.create(self.session, id=lb_id,
|
||||
tenant_id=self.FAKE_UUID_2, name="lb_name",
|
||||
description="lb_description",
|
||||
provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE,
|
||||
enabled=True)
|
||||
return lb
|
||||
|
||||
def test_get(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
new_lb = self.lb_repo.get(self.session, id=lb.id)
|
||||
self.assertIsInstance(new_lb, models.LoadBalancer)
|
||||
self.assertEqual(lb, new_lb)
|
||||
|
||||
def test_get_all(self):
|
||||
lb_one = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
lb_two = self.create_loadbalancer(self.FAKE_UUID_3)
|
||||
lb_list = self.lb_repo.get_all(self.session,
|
||||
tenant_id=self.FAKE_UUID_2)
|
||||
self.assertEqual(2, len(lb_list))
|
||||
self.assertEqual(lb_one, lb_list[0])
|
||||
self.assertEqual(lb_two, lb_list[1])
|
||||
|
||||
def test_create(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
self.assertEqual(self.FAKE_UUID_1, lb.id)
|
||||
self.assertEqual(self.FAKE_UUID_2, lb.tenant_id)
|
||||
self.assertEqual("lb_name", lb.name)
|
||||
self.assertEqual("lb_description", lb.description)
|
||||
self.assertEqual(constants.ACTIVE, lb.provisioning_status)
|
||||
self.assertEqual(constants.ONLINE, lb.operating_status)
|
||||
self.assertEqual(True, lb.enabled)
|
||||
|
||||
def test_update(self):
|
||||
name_change = "load_balancer_name"
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
self.lb_repo.update(self.session, lb.id, name=name_change)
|
||||
new_lb = self.lb_repo.get(self.session, id=lb.id)
|
||||
self.assertEqual(name_change, new_lb.name)
|
||||
|
||||
def test_delete(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
self.lb_repo.delete(self.session, id=lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.lb_repo.get, self.session,
|
||||
id=lb.id)
|
||||
|
||||
def test_delete_with_amphora(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
amphora = self.amphora_repo.create(self.session, id=self.FAKE_UUID_1,
|
||||
load_balancer_id=lb.id,
|
||||
host_id=self.FAKE_UUID_3,
|
||||
status=constants.ACTIVE)
|
||||
new_lb = self.lb_repo.get(self.session, id=lb.id)
|
||||
self.assertIsNotNone(new_lb)
|
||||
self.assertEqual(1, len(new_lb.amphorae))
|
||||
self.assertEqual(amphora, new_lb.amphorae[0])
|
||||
self.lb_repo.delete(self.session, id=new_lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.lb_repo.get, self.session,
|
||||
id=lb.id)
|
||||
new_amphora = self.amphora_repo.get(self.session, id=amphora.id)
|
||||
self.assertIsNotNone(new_amphora)
|
||||
self.assertIsNone(new_amphora.load_balancer_id)
|
||||
|
||||
def test_delete_with_many_amphora(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
amphora_1 = self.amphora_repo.create(self.session, id=self.FAKE_UUID_1,
|
||||
load_balancer_id=lb.id,
|
||||
host_id=self.FAKE_UUID_3,
|
||||
status=constants.ACTIVE)
|
||||
amphora_2 = self.amphora_repo.create(self.session, id=self.FAKE_UUID_3,
|
||||
load_balancer_id=lb.id,
|
||||
host_id=self.FAKE_UUID_3,
|
||||
status=constants.ACTIVE)
|
||||
new_lb = self.lb_repo.get(self.session, id=lb.id)
|
||||
self.assertIsNotNone(new_lb)
|
||||
self.assertEqual(2, len(new_lb.amphorae))
|
||||
self.assertIn(amphora_1, new_lb.amphorae)
|
||||
self.assertIn(amphora_2, new_lb.amphorae)
|
||||
self.lb_repo.delete(self.session, id=new_lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.lb_repo.get, self.session,
|
||||
id=lb.id)
|
||||
new_amphora_1 = self.amphora_repo.get(self.session, id=amphora_1.id)
|
||||
new_amphora_2 = self.amphora_repo.get(self.session, id=amphora_2.id)
|
||||
self.assertIsNotNone(new_amphora_1)
|
||||
self.assertIsNotNone(new_amphora_2)
|
||||
self.assertIsNone(new_amphora_1.load_balancer_id)
|
||||
self.assertIsNone(new_amphora_2.load_balancer_id)
|
||||
|
||||
def test_delete_with_vip(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
vip = self.vip_repo.create(self.session, load_balancer_id=lb.id,
|
||||
ip_address="10.0.0.1")
|
||||
new_lb = self.lb_repo.get(self.session, id=lb.id)
|
||||
self.assertIsNotNone(new_lb)
|
||||
self.assertIsNotNone(new_lb.vip)
|
||||
self.assertEqual(vip, new_lb.vip)
|
||||
self.lb_repo.delete(self.session, id=new_lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.lb_repo.get, self.session,
|
||||
id=lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.vip_repo.get, self.session,
|
||||
load_balancer_id=lb.id)
|
||||
|
||||
def test_delete_with_listener(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
listener = self.listener_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="listener_name", description="listener_description",
|
||||
load_balancer_id=lb.id, protocol=constants.PROTOCOL_HTTP,
|
||||
protocol_port=80, connection_limit=1,
|
||||
provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
new_lb = self.lb_repo.get(self.session, id=lb.id)
|
||||
self.assertIsNotNone(new_lb)
|
||||
self.assertEqual(1, len(new_lb.listeners))
|
||||
self.assertEqual(listener, new_lb.listeners[0])
|
||||
self.lb_repo.delete(self.session, id=new_lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.lb_repo.get, self.session,
|
||||
id=lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener.id)
|
||||
|
||||
def test_delete_with_many_listeners(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
listener_1 = self.listener_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="listener_name", description="listener_description",
|
||||
load_balancer_id=lb.id, protocol=constants.PROTOCOL_HTTP,
|
||||
protocol_port=80, connection_limit=1,
|
||||
provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
listener_2 = self.listener_repo.create(
|
||||
self.session, id=self.FAKE_UUID_3, tenant_id=self.FAKE_UUID_2,
|
||||
name="listener_name", description="listener_description",
|
||||
load_balancer_id=lb.id, protocol=constants.PROTOCOL_HTTPS,
|
||||
protocol_port=443, connection_limit=1,
|
||||
provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
new_lb = self.lb_repo.get(self.session, id=lb.id)
|
||||
self.assertIsNotNone(new_lb)
|
||||
self.assertEqual(2, len(new_lb.listeners))
|
||||
self.assertIn(listener_1, new_lb.listeners)
|
||||
self.assertIn(listener_2, new_lb.listeners)
|
||||
self.lb_repo.delete(self.session, id=new_lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.lb_repo.get, self.session,
|
||||
id=lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener_1.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener_2.id)
|
||||
|
||||
def test_delete_with_all_children(self):
|
||||
lb = self.create_loadbalancer(self.FAKE_UUID_1)
|
||||
amphora = self.amphora_repo.create(self.session, id=self.FAKE_UUID_1,
|
||||
load_balancer_id=lb.id,
|
||||
host_id=self.FAKE_UUID_3,
|
||||
status=constants.ACTIVE)
|
||||
vip = self.vip_repo.create(self.session, load_balancer_id=lb.id,
|
||||
ip_address="10.0.0.1")
|
||||
listener = self.listener_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="listener_name", description="listener_description",
|
||||
load_balancer_id=lb.id, protocol=constants.PROTOCOL_HTTP,
|
||||
protocol_port=80, connection_limit=1,
|
||||
provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
new_lb = self.lb_repo.get(self.session, id=lb.id)
|
||||
self.assertIsNotNone(new_lb)
|
||||
self.assertIsNotNone(new_lb.vip)
|
||||
self.assertEqual(vip, new_lb.vip)
|
||||
self.assertEqual(1, len(new_lb.amphorae))
|
||||
self.assertEqual(1, len(new_lb.listeners))
|
||||
self.assertEqual(amphora, new_lb.amphorae[0])
|
||||
self.assertEqual(listener, new_lb.listeners[0])
|
||||
self.lb_repo.delete(self.session, id=new_lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.lb_repo.get, self.session,
|
||||
id=lb.id)
|
||||
new_amphora = self.amphora_repo.get(self.session, id=amphora.id)
|
||||
self.assertIsNotNone(new_amphora)
|
||||
self.assertIsNone(new_amphora.load_balancer_id)
|
||||
self.assertRaises(exceptions.NotFound, self.vip_repo.get, self.session,
|
||||
load_balancer_id=lb.id)
|
||||
self.assertRaises(exceptions.NotFound, self.listener_repo.get,
|
||||
self.session, id=listener.id)
|
||||
|
||||
|
||||
class VipRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def setUp(self):
|
||||
super(VipRepositoryTest, self).setUp()
|
||||
self.lb = self.lb_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="lb_name", description="lb_description",
|
||||
provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
|
||||
def create_vip(self, lb_id):
|
||||
vip = self.vip_repo.create(self.session, load_balancer_id=lb_id,
|
||||
ip_address="10.0.0.1")
|
||||
return vip
|
||||
|
||||
def test_get(self):
|
||||
vip = self.create_vip(self.lb.id)
|
||||
new_vip = self.vip_repo.get(self.session,
|
||||
load_balancer_id=vip.load_balancer_id)
|
||||
self.assertIsInstance(new_vip, models.Vip)
|
||||
self.assertEqual(vip, new_vip)
|
||||
|
||||
def test_create(self):
|
||||
vip = self.create_vip(self.lb.id)
|
||||
self.assertEqual(self.lb.id, vip.load_balancer_id)
|
||||
self.assertEqual("10.0.0.1", vip.ip_address)
|
||||
|
||||
def test_update(self):
|
||||
address_change = "10.0.0.2"
|
||||
vip = self.create_vip(self.lb.id)
|
||||
self.vip_repo.update(self.session, vip.load_balancer_id,
|
||||
ip_address=address_change)
|
||||
new_vip = self.vip_repo.get(self.session,
|
||||
load_balancer_id=vip.load_balancer_id)
|
||||
self.assertEqual(address_change, new_vip.ip_address)
|
||||
|
||||
def test_delete(self):
|
||||
vip = self.create_vip(self.lb.id)
|
||||
self.vip_repo.delete(self.session,
|
||||
load_balancer_id=vip.load_balancer_id)
|
||||
self.assertRaises(exceptions.NotFound, self.vip_repo.get, self.session,
|
||||
load_balancer_id=vip.load_balancer_id)
|
||||
new_lb = self.lb_repo.get(self.session, id=self.lb.id)
|
||||
self.assertIsNotNone(new_lb)
|
||||
self.assertIsNone(new_lb.vip)
|
||||
|
||||
|
||||
class SNIRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def setUp(self):
|
||||
super(SNIRepositoryTest, self).setUp()
|
||||
self.listener = self.listener_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="listener_name", description="listener_description",
|
||||
protocol=constants.PROTOCOL_HTTP, protocol_port=80,
|
||||
connection_limit=1, provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
|
||||
def create_sni(self, listener_id):
|
||||
sni = self.sni_repo.create(self.session,
|
||||
listener_id=listener_id,
|
||||
tls_container_id=self.FAKE_UUID_3,
|
||||
position=0)
|
||||
return sni
|
||||
|
||||
def test_get(self):
|
||||
sni = self.create_sni(self.listener.id)
|
||||
new_sni = self.sni_repo.get(self.session, listener_id=sni.listener_id)
|
||||
self.assertIsInstance(new_sni, models.SNI)
|
||||
self.assertEqual(sni, new_sni)
|
||||
|
||||
def test_create(self):
|
||||
sni = self.create_sni(self.listener.id)
|
||||
new_sni = self.sni_repo.get(self.session, listener_id=sni.listener_id)
|
||||
self.assertEqual(self.listener.id, new_sni.listener_id)
|
||||
self.assertEqual(self.FAKE_UUID_3, new_sni.tls_container_id)
|
||||
self.assertEqual(0, new_sni.position)
|
||||
|
||||
def test_update(self):
|
||||
position_change = 10
|
||||
sni = self.create_sni(self.listener.id)
|
||||
self.sni_repo.update(self.session, listener_id=sni.listener_id,
|
||||
position=position_change)
|
||||
new_sni = self.sni_repo.get(self.session, listener_id=sni.listener_id)
|
||||
self.assertEqual(position_change, new_sni.position)
|
||||
|
||||
def test_delete(self):
|
||||
sni = self.create_sni(self.listener.id)
|
||||
self.sni_repo.delete(self.session, listener_id=sni.listener_id)
|
||||
self.assertRaises(exceptions.NotFound, self.sni_repo.get, self.session,
|
||||
listener_id=sni.listener_id)
|
||||
new_listener = self.listener_repo.get(self.session,
|
||||
id=self.listener.id)
|
||||
self.assertIsNotNone(new_listener)
|
||||
self.assertEqual(0, len(new_listener.sni_containers))
|
||||
|
||||
|
||||
class AmphoraRepositoryTest(BaseRepositoryTest):
|
||||
|
||||
def setUp(self):
|
||||
super(AmphoraRepositoryTest, self).setUp()
|
||||
self.lb = self.lb_repo.create(
|
||||
self.session, id=self.FAKE_UUID_1, tenant_id=self.FAKE_UUID_2,
|
||||
name="lb_name", description="lb_description",
|
||||
provisioning_status=constants.ACTIVE,
|
||||
operating_status=constants.ONLINE, enabled=True)
|
||||
|
||||
def create_amphora(self, amphora_id):
|
||||
amphora = self.amphora_repo.create(self.session, id=amphora_id,
|
||||
host_id=self.FAKE_UUID_3,
|
||||
status=constants.ACTIVE)
|
||||
return amphora
|
||||
|
||||
def test_get(self):
|
||||
amphora = self.create_amphora(self.FAKE_UUID_1)
|
||||
new_amphora = self.amphora_repo.get(self.session, id=amphora.id)
|
||||
self.assertIsInstance(new_amphora, models.Amphora)
|
||||
self.assertEqual(amphora, new_amphora)
|
||||
|
||||
def test_create(self):
|
||||
amphora = self.create_amphora(self.FAKE_UUID_1)
|
||||
self.assertEqual(self.FAKE_UUID_1, amphora.id)
|
||||
self.assertEqual(self.FAKE_UUID_3, amphora.host_id)
|
||||
self.assertEqual(constants.ACTIVE, amphora.status)
|
||||
|
||||
def test_update(self):
|
||||
status_change = constants.PENDING_UPDATE
|
||||
amphora = self.create_amphora(self.FAKE_UUID_1)
|
||||
self.amphora_repo.update(self.session, amphora.id,
|
||||
status=status_change)
|
||||
new_amphora = self.amphora_repo.get(self.session, id=amphora.id)
|
||||
self.assertEqual(status_change, new_amphora.status)
|
||||
|
||||
def test_delete(self):
|
||||
amphora = self.create_amphora(self.FAKE_UUID_1)
|
||||
self.amphora_repo.delete(self.session, id=amphora.id)
|
||||
self.assertRaises(exceptions.NotFound, self.amphora_repo.get,
|
||||
self.session, id=amphora.id)
|
||||
|
||||
def test_associate_amphora_load_balancer(self):
|
||||
amphora = self.create_amphora(self.FAKE_UUID_1)
|
||||
self.amphora_repo.associate(self.session, self.lb.id, amphora.id)
|
||||
new_amphora = self.amphora_repo.get(self.session,
|
||||
id=amphora.id)
|
||||
self.assertIsNotNone(new_amphora.load_balancer)
|
||||
self.assertIsInstance(new_amphora.load_balancer, models.LoadBalancer)
|
||||
|
||||
def test_delete_amphora_with_load_balancer(self):
|
||||
amphora = self.create_amphora(self.FAKE_UUID_1)
|
||||
self.amphora_repo.associate(self.session, self.lb.id, amphora.id)
|
||||
self.amphora_repo.delete(self.session, id=amphora.id)
|
||||
self.assertRaises(exceptions.NotFound, self.amphora_repo.get,
|
||||
self.session, id=amphora.id)
|
||||
new_lb = self.lb_repo.get(self.session, id=self.lb.id)
|
||||
self.assertEqual(0, len(new_lb.amphorae))
|
||||
Loading…
Reference in New Issue