def handle(self, *args, **options):
# engine was created by initial_data.yml
my_engine = Engine.objects.get(version='2.4.10',
engine_type__name='mongodb')
my_host = factory.HostFactory(hostname='localhost')
my_env = factory.EnvironmentFactory(name='laboratory')
my_plan = factory.PlanFactory(name='small',
engine_type=my_engine.engine_type,
environments=[my_env])
my_infradb = factory.DatabaseInfraFactory(name='local_infra',
plan=my_plan,
environment=my_env,
engine=my_engine,
capacity=10)
factory.InstanceFactory(databaseinfra=my_infradb, hostname=my_host)
my_role = Role.objects.get_or_create(name="role_dba")[0]
organization = Organization.objects.get_or_create(
name='fake_organization')[0]
my_team = Team.objects.get_or_create(name="my team",
role=my_role,
organization=organization)[0]
my_admin = User.objects.create_superuser('admin',
email='*****@*****.**',
password='******')
my_team.users.add(my_admin)
def _create_database_structure(cls):
mysql_host = settings.DB_HOST
mysql_port = settings.DB_PORT or 3306
cls.mysql_endpoint = '{}:{}'.format(mysql_host, mysql_port)
cls.engine_type = factory_physical.EngineTypeFactory(name='mysql')
cls.engine = factory_physical.EngineFactory(
engine_type=cls.engine_type)
cls.disk_offering = factory_physical.DiskOfferingFactory(
size_kb=524288)
cls.plan = factory_physical.PlanFactory(
disk_offering=cls.disk_offering, engine=cls.engine)
cls.databaseinfra = factory_physical.DatabaseInfraFactory(
name="__test__ mysqlinfra2",
user="******",
password=settings.DB_PASSWORD,
endpoint=cls.mysql_endpoint,
engine=cls.engine,
disk_offering=cls.disk_offering,
plan=cls.plan)
cls.hostname = factory_physical.HostFactory()
cls.instance = factory_physical.InstanceFactory(
address="new_instance.localinstance",
port=123,
is_active=True,
instance_type=Instance.MYSQL,
databaseinfra=cls.databaseinfra,
hostname=cls.hostname)
cls.database = factory_logical.DatabaseFactory(
name='test_db_1',
databaseinfra=cls.databaseinfra,
)
cls.nfsaas_host_attr = factory_physical.NFSaaSHostAttr(
host=cls.hostname,
# nfsaas_size_kb=cls.database.total_size_in_kb,
nfsaas_used_size_kb=cls.database.used_size_in_kb)
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory(
password="******", endpoint="127.0.0.1:6379")
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, port=6379, instance_type=4)
self.driver = Redis(databaseinfra=self.databaseinfra)
self._redis_client = None
def test_connection_string_when_in_replica_set(self, get_replica_name):
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, address='127.0.0.2', port=27018)
get_replica_name.return_value = 'my_repl'
self.assertEqual(
"mongodb://<user>:<password>@127.0.0.1:27017,127.0.0.2:27018?replicaSet=my_repl",
self.driver.get_connection())
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory(
user="******", password="", endpoint="127.0.0.1:3306")
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, port=3306)
self.driver = MySQL(databaseinfra=self.databaseinfra)
self._mysql_client = None
def test_check_instances_status_is_alert(self):
plan = factory.PlanFactory()
environment = plan.environments.all()[0]
datainfra1 = factory.DatabaseInfraFactory(plan=plan,
environment=environment,
capacity=10)
factory.InstanceFactory(address="127.0.0.1",
port=27017,
databaseinfra=datainfra1,
status=1)
factory.InstanceFactory(address="127.0.0.2",
port=27017,
databaseinfra=datainfra1,
status=0)
self.assertEquals(datainfra1.check_instances_status(),
DatabaseInfra.ALERT)
def setUp(self):
self.task = TaskHistoryFactory()
self.instance = physical_factory.InstanceFactory()
self.databaseinfra = self.instance.databaseinfra
self.database = logical_factory.DatabaseFactory()
self.database.databaseinfra = self.databaseinfra
self.database.save()
def setUp(self):
super(DatabaseAPITestCase, self).setUp()
self.datainfra = physical_factory.DatabaseInfraFactory()
self.instance = physical_factory.InstanceFactory(
address="127.0.0.1", port=27017, databaseinfra=self.datainfra)
self.team = TeamFactory()
self.project = ProjectFactory()
self.environment = self.datainfra.environment
def setUp(self):
mongo_host = os.getenv('TESTS_MONGODB_HOST', '127.0.0.1')
mongo_port = os.getenv('TESTS_MONGODB_PORT', '27017')
self.mongo_endpoint = '{}:{}'.format(mongo_host, mongo_port)
self.databaseinfra = factory_physical.DatabaseInfraFactory()
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, address=mongo_host)
self.driver = MongoDB(databaseinfra=self.databaseinfra)
self._mongo_client = None
def test_connection_with_database_and_replica(self, get_replica_name):
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, address='127.0.0.2', port=27018)
get_replica_name.return_value = 'my_repl'
self.database = factory_logical.DatabaseFactory(
name="my_db_url_name", databaseinfra=self.databaseinfra)
self.assertEqual(
"mongodb://<user>:<password>@127.0.0.1:27017,127.0.0.2:27018/my_db_url_name?replicaSet=my_repl",
self.driver.get_connection(database=self.database))
def test_connection_string_when_in_replica_set(self, get_replica_name):
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, address='127.0.0.2', port=27018)
get_replica_name.return_value = 'my_repl'
expected_conn = ("mongodb://<user>:<password>"
"@{},127.0.0.2:27018"
"?replicaSet=my_repl").format(self.instance_endpoint)
self.assertEqual(expected_conn, self.driver.get_connection())
def test_hosts(self):
plan = factory.PlanFactory()
environment = plan.environments.all()[0]
datainfra = factory.DatabaseInfraFactory(plan=plan,
environment=environment,
capacity=1)
instance = factory.InstanceFactory(address="127.0.0.1",
port=27017,
databaseinfra=datainfra)
host_1 = instance.hostname
instance = factory.InstanceFactory(address="127.0.0.2",
port=27017,
databaseinfra=datainfra)
host_2 = instance.hostname
factory.InstanceFactory(address="127.0.0.3",
port=27017,
databaseinfra=datainfra,
hostname=host_2)
self.assertIn(host_1, datainfra.hosts)
self.assertIn(host_2, datainfra.hosts)
self.assertEqual(len(datainfra.hosts), 2)
def test_best_for_with_only_one_datainfra_per_plan_and_environment(self):
plan = factory.PlanFactory()
environment = plan.environments.all()[0]
datainfra = factory.DatabaseInfraFactory(plan=plan,
environment=environment)
factory.InstanceFactory(address="127.0.0.1",
port=27017,
databaseinfra=datainfra)
self.assertEqual(
datainfra,
DatabaseInfra.best_for(plan=plan,
environment=environment,
name="test"))
def setUp(self):
redis_host = settings.REDIS_HOST
redis_port = settings.REDIS_PORT
self.endpoint = "{}:{}".format(redis_host, redis_port)
self.databaseinfra = factory_physical.DatabaseInfraFactory(
password="******", endpoint=self.endpoint)
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra,
port=redis_port,
instance_type=4,
address=redis_host)
self.driver = Redis(databaseinfra=self.databaseinfra)
self._redis_client = None
def setUp(self):
mysql_host = settings.DB_HOST
mysql_port = settings.DB_PORT or 3306
self.mysql_endpoint = '{}:{}'.format(mysql_host, mysql_port)
self.databaseinfra = factory_physical.DatabaseInfraFactory(
user="******",
password=settings.DB_PASSWORD,
endpoint=self.mysql_endpoint)
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra,
address=mysql_host,
port=mysql_port)
self.driver = MySQL(databaseinfra=self.databaseinfra)
self._mysql_client = None
def setUpClass(cls):
cls.databaseinfra = factory.DatabaseInfraFactory(
name="__test__ mysqlinfra", user="******", password='******')
cls.hostname = factory.HostFactory()
cls.instance = factory.InstanceFactory(
address="new_instance.localinstance",
port=123,
is_active=True,
databaseinfra=cls.databaseinfra,
hostname=cls.hostname)
cls.nfaas_host_attr = factory.NFSaaSHostAttr(host=cls.hostname)
cs_offering = factory.CloudStackOfferingFactory(memory_size_mb=9)
cls.infra_offering = factory.DatabaseInfraOfferingFactory(
databaseinfra=cls.databaseinfra, offering=cs_offering)
def test_best_for_with_only_two_datainfra_per_plan_and_environment_returns_rounding_robin_them(
self):
plan = factory.PlanFactory()
environment = plan.environments.all()[0]
datainfra1 = factory.DatabaseInfraFactory(plan=plan,
environment=environment,
capacity=10)
factory.InstanceFactory(address="127.0.0.1",
port=27017,
databaseinfra=datainfra1)
datainfra2 = factory.DatabaseInfraFactory(plan=plan,
environment=environment,
capacity=10)
factory.InstanceFactory(address="127.0.0.2",
port=27017,
databaseinfra=datainfra2)
for i in range(10):
should_choose = (datainfra1, datainfra2)[i % 2]
choosed = DatabaseInfra.best_for(plan=plan,
environment=environment,
name="test")
self.assertEqual(should_choose, choosed)
database = factory_logical.DatabaseFactory(databaseinfra=choosed)
self.assertEqual(choosed, database.databaseinfra)
def test_connection_with_database_and_replica(self, get_replica_name):
self.databaseinfra.plan.is_ha = True
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, address='127.0.0.2', port=27018)
get_replica_name.return_value = 'my_repl'
self.database = factory_logical.DatabaseFactory(
name="my_db_url_name", databaseinfra=self.databaseinfra)
expected_conn = ("mongodb://<user>:<password>"
"@{},127.0.0.2:27018/my_db_url_name"
"?replicaSet=my_repl").format(self.instance_endpoint)
self.assertEqual(
expected_conn,
self.driver.get_connection(database=self.database)
)
def setUp(self):
self.plan = physical_factory.PlanFactory()
self.environment = self.plan.environments.all()[0]
self.databaseinfra = physical_factory.DatabaseInfraFactory(
plan=self.plan, environment=self.environment, capacity=10)
self.instance = physical_factory.InstanceFactory(
address="127.0.0.1", port=27017, databaseinfra=self.databaseinfra)
self.project = factory.ProjectFactory()
self.role = Role.objects.get_or_create(name="fake_role")[0]
self.team = Team.objects.get_or_create(
name="fake_team", role=self.role, database_alocation_limit=0)[0]
self.user = User.objects.create_superuser(
self.USERNAME, email="*****@*****.**" % self.USERNAME, password=self.PASSWORD)
self.team.users.add(self.user)
self.client.login(username=self.USERNAME, password=self.PASSWORD)
self.description = "My database"
def setUpClass(cls, instances_mock):
cls.databaseinfra = factory.DatabaseInfraFactory(
name="__test__ mysqlinfra", user="******", password='******')
cls.hostname = factory.HostFactory()
cls.instance = factory.InstanceFactory(
address="new_instance.localinstance",
port=123,
is_active=True,
databaseinfra=cls.databaseinfra,
hostname=cls.hostname)
cls.volume = factory.VolumeFactory(host=cls.hostname)
offering = factory.OfferingFactory(memory_size_mb=9)
offering.environments.add(cls.databaseinfra.environment)
plan = cls.databaseinfra.plan
plan.provider = 1
plan.stronger_offering = offering
plan.weaker_offering = offering
plan.save()
instances_mock.return_value = [cls.instance]
cls.instance.hostname.offering = offering
cls.instance.hostname.save()
def test_best_for_with_only_over_capacity_datainfra_returns_None(self):
"""tests database infra capacity"""
NUMBER_OF_DATABASES_TO_TEST = 4
plan = factory.PlanFactory()
environment = plan.environments.all()[0]
datainfra = factory.DatabaseInfraFactory(
plan=plan,
environment=environment,
capacity=NUMBER_OF_DATABASES_TO_TEST)
factory.InstanceFactory(address="127.0.0.1",
port=27017,
databaseinfra=datainfra)
for i in range(NUMBER_OF_DATABASES_TO_TEST):
self.assertEqual(
datainfra,
DatabaseInfra.best_for(plan=plan,
environment=environment,
name="test"))
factory_logical.DatabaseFactory(databaseinfra=datainfra)
self.assertIsNone(
DatabaseInfra.best_for(plan=plan,
environment=environment,
name="test"))
def setUpClass(cls, instances_mock):
cls.databaseinfra = factory.DatabaseInfraFactory(
name="__test__ mysqlinfra", user="******", password='******')
cls.hostname = factory.HostFactory()
cls.instance = factory.InstanceFactory(
address="new_instance.localinstance",
port=123,
is_active=True,
databaseinfra=cls.databaseinfra,
hostname=cls.hostname)
cls.nfaas_host_attr = factory.NFSaaSHostAttr(host=cls.hostname)
cs_offering = factory.CloudStackOfferingFactory(memory_size_mb=9)
cls.infra_offering = factory.DatabaseInfraOfferingFactory(
databaseinfra=cls.databaseinfra, offering=cs_offering)
instances_mock.return_value = [cls.instance]
factory.PlanAttrFactory.create(plan=cls.databaseinfra.plan)
cls.instance.hostname.offering = cs_offering
cls.instance.hostname.save()
offering = cls.databaseinfra.offering
offering.memory_size_mb = 9
offering.save()
cls.databaseinfra.plan.provider = 1
cls.databaseinfra.plan.save()
def setUp(self):
self.instance = physical_factory.InstanceFactory()
self.databaseinfra = self.instance.databaseinfra
self.engine = FakeDriver(databaseinfra=self.databaseinfra)
self.environment = physical_factory.EnvironmentFactory()
self.plan_upgrade = physical_factory.PlanFactory()
def setUp(self):
self.instance = physical_factory.InstanceFactory()
self.databaseinfra = self.instance.databaseinfra
self.engine = FakeDriver(databaseinfra=self.databaseinfra)
def setUp(self):
self.instance = factory_physical.InstanceFactory()
self.databaseinfra = self.instance.databaseinfra
self.engine = FakeDriver(databaseinfra=self.databaseinfra)
self.database = factory_logical.DatabaseFactory(
databaseinfra=self.databaseinfra)
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory()
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra)
self.driver = MongoDB(databaseinfra=self.databaseinfra)
self._mongo_client = None
