208 lines
7.2 KiB
Python
208 lines
7.2 KiB
Python
# 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 mock import create_autospec
|
|
from mock import MagicMock
|
|
from sqlalchemy.engine.base import Engine
|
|
from synergy_scheduler_manager.common.project import Project
|
|
from synergy_scheduler_manager.common.queue import QueueDB
|
|
from synergy_scheduler_manager.common.queue import QueueItem
|
|
from synergy_scheduler_manager.project_manager import ProjectManager
|
|
from synergy_scheduler_manager.scheduler_manager import Worker
|
|
from synergy_scheduler_manager.tests.unit import base
|
|
|
|
"""
|
|
class TestNotifications(base.TestCase):
|
|
|
|
def test_info_quota(self):
|
|
SharedQuota.setSize("vcpus", 20)
|
|
SharedQuota.setSize("memory", 4096)
|
|
SharedQuota.enable()
|
|
|
|
self.assertEqual(20, SharedQuota.getSize('vcpus'))
|
|
self.assertEqual(4096, SharedQuota.getSize('memory'))
|
|
|
|
prj_a = Project()
|
|
prj_a.setId(1)
|
|
prj_a.setName("prj_a")
|
|
|
|
prj_b = Project()
|
|
prj_b.setId(2)
|
|
prj_b.setName("prj_b")
|
|
|
|
prjDict = {1: prj_a, 2: prj_b}
|
|
|
|
quota = prjDict[1].getQuota()
|
|
|
|
quota.setSize("vcpus", 10, private=True)
|
|
quota.setSize("memory", 2048, private=True)
|
|
|
|
self.assertEqual(10, quota.getSize('vcpus', private=True))
|
|
self.assertEqual(2048, quota.getSize('memory', private=True))
|
|
|
|
quota.setSize("vcpus",
|
|
SharedQuota.getSize('vcpus'),
|
|
private=False)
|
|
quota.setSize("memory",
|
|
SharedQuota.getSize('memory'),
|
|
private=False)
|
|
|
|
self.assertEqual(20, quota.getSize('vcpus', private=False))
|
|
self.assertEqual(4096, quota.getSize('memory', private=False))
|
|
|
|
flavor = Flavor()
|
|
flavor.setVCPUs(2)
|
|
flavor.setMemory(512)
|
|
|
|
server = Server()
|
|
server.setType("ephemeral")
|
|
server.setId("server_id")
|
|
server.setFlavor(flavor)
|
|
|
|
self.assertEqual(True, server.isEphemeral())
|
|
try:
|
|
allocated = quota.allocate(server, blocking=False)
|
|
except Exception as ex:
|
|
print(ex)
|
|
|
|
self.assertEqual(True, allocated)
|
|
|
|
self.assertEqual(0, quota.getUsage('vcpus', private=True))
|
|
self.assertEqual(0, quota.getUsage('memory', private=True))
|
|
|
|
self.assertEqual(2, quota.getUsage('vcpus', private=False))
|
|
self.assertEqual(512, quota.getUsage('memory', private=False))
|
|
|
|
self.assertEqual(2, SharedQuota.getUsage('vcpus'))
|
|
self.assertEqual(512, SharedQuota.getUsage('memory'))
|
|
|
|
ns = Notifications(prjDict, None)
|
|
|
|
payload = {
|
|
"state": "deleted",
|
|
"deleted_at": "2016-12-09T10:06:10.000000",
|
|
"terminated_at": "2016-12-09T10:06:10.025305",
|
|
"instance_type": "m1.tiny",
|
|
"user_id": "user",
|
|
"root_gb": "1",
|
|
"metadata": {},
|
|
"instance_id": "server_id",
|
|
"tenant_id": 1,
|
|
"memory_mb": 512,
|
|
"vcpus": 2}
|
|
|
|
ns.info(ctxt=None,
|
|
publisher_id=None,
|
|
event_type="compute.instance.delete.end",
|
|
payload=payload,
|
|
metadata=None)
|
|
|
|
quota = prjDict[1].getQuota()
|
|
|
|
self.assertEqual(0, quota.getUsage("vcpus", private=True))
|
|
self.assertEqual(0, quota.getUsage("memory", private=True))
|
|
|
|
self.assertEqual(0, quota.getUsage('vcpus', private=False))
|
|
self.assertEqual(0, quota.getUsage('memory', private=False))
|
|
|
|
self.assertEqual(0, SharedQuota.getUsage('vcpus'))
|
|
self.assertEqual(0, SharedQuota.getUsage('memory'))
|
|
"""
|
|
|
|
|
|
class TestWorker(base.TestCase):
|
|
|
|
# TO COMPLETE
|
|
def setUp(self):
|
|
super(TestWorker, self).setUp()
|
|
self.nova_manager_mock = MagicMock()
|
|
self.keystone_manager_mock = MagicMock()
|
|
db_engine_mock = create_autospec(Engine)
|
|
|
|
def my_side_effect(*args, **kwargs):
|
|
project1 = Project()
|
|
project1.setId(1)
|
|
project1.setName("test_project1")
|
|
project1.getShare().setValue(5)
|
|
|
|
project2 = Project()
|
|
project2.setId(2)
|
|
project2.setName("test_project2")
|
|
project2.getShare().setValue(55)
|
|
|
|
if args[0] == 1:
|
|
return project1
|
|
elif args[0] == 2:
|
|
return project2
|
|
|
|
keystone_manager = MagicMock()
|
|
keystone_manager.getProject.side_effect = my_side_effect
|
|
|
|
self.project_manager = ProjectManager()
|
|
self.project_manager.db_engine = MagicMock()
|
|
self.project_manager.keystone_manager = keystone_manager
|
|
self.project_manager.default_TTL = 10
|
|
self.project_manager.default_share = 30
|
|
self.project_manager._addProject(1, "test_project1", 10, 50)
|
|
|
|
self.worker = Worker(
|
|
name="test",
|
|
queue=QueueDB("testq", db_engine_mock),
|
|
project_manager=self.project_manager,
|
|
nova_manager=self.nova_manager_mock,
|
|
keystone_manager=self.keystone_manager_mock)
|
|
|
|
def test_destroy(self):
|
|
"""An empty worker can be destroyed without raising an exception."""
|
|
self.worker.destroy()
|
|
|
|
def test_name(self):
|
|
self.assertEqual('test', self.worker.getName())
|
|
|
|
def test_run_build_server(self):
|
|
|
|
def nova_exec_side_effect(command, *args, **kwargs):
|
|
"""Mock nova.execute to do a successful build."""
|
|
if command == "GET_SERVER":
|
|
res = {"OS-EXT-STS:vm_state": "building",
|
|
"OS-EXT-STS:task_state": "scheduling"}
|
|
elif command == "BUILD_SERVER":
|
|
res = None
|
|
else:
|
|
raise TypeError("Wrong arguments to nova exec mock")
|
|
return res
|
|
|
|
# Mock queue.isClosed to do a 1-pass run of the worker
|
|
is_closed_mock = create_autospec(self.worker.queue.isClosed)
|
|
self.worker.queue.isClosed = is_closed_mock
|
|
self.worker.queue.isClosed.side_effect = (False, True)
|
|
|
|
# Mock QueueItem in the queue
|
|
qitem_mock = create_autospec(QueueItem)
|
|
get_item_mock = create_autospec(self.worker.queue.getItem)
|
|
get_item_mock.return_value = qitem_mock
|
|
self.worker.queue.getItem = get_item_mock
|
|
|
|
# Mock nova "GET_SERVER" and "BUILD_SERVER" calls
|
|
nova_exec = self.nova_manager_mock.execute
|
|
nova_exec.side_effect = nova_exec_side_effect
|
|
|
|
project = self.project_manager.getProject(id=1)
|
|
# Mock quota allocation
|
|
quota_allocate_mock = create_autospec(project.getQuota().allocate)
|
|
quota_allocate_mock.return_value = True
|
|
project.getQuota().allocate = quota_allocate_mock
|
|
|
|
# Delete item from the queue
|
|
delete_item_mock = create_autospec(self.worker.queue.deleteItem)
|
|
self.worker.queue.deleteItem = delete_item_mock
|