def test_when_during_proxy_starting_already_started_from_other_thread(
self):
from core.db.models import Session, Endpoint, Provider
provider = Provider(name='noname', url='nourl')
endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = '127.0.0.1'
endpoint.name = 'test_endpoint'
endpoint.ports = {'4455': 4455, '9000': 9000, '5900': 5900}
session = Session("some_platform")
session.id = 1
session.name = "session1"
session.status = "running"
type(session).vnc_proxy_port = PropertyMock(
side_effect=[None, 55555, 55555])
session.vnc_proxy_pid = 55555
session.created = session.modified = datetime.now()
session.endpoint = endpoint
session.stop_vnc_proxy = Mock()
with patch('flask.current_app.sessions.get_session',
Mock(return_value=session)):
response = self.vmmaster_client.get(
'/api/session/{}/vnc_info'.format(session.id))
session._close()
body = json.loads(response.data)
self.assertEqual(200, response.status_code)
self.assertDictEqual({'vnc_proxy_port': 55555}, body['result'])
self.assertEqual(200, body['metacode'])
self.assertTrue(session.stop_vnc_proxy.called)
def setUp(self):
self.ctx = self.app.test_request_context()
self.ctx.push()
with patch('flask.current_app.database',
DatabaseMock()), patch('flask.current_app.sessions',
Mock()):
from core.db.models import Session, Provider, Endpoint
self.session = Session('origin_1')
self.session.name = "session1"
provider = Provider(name='noname', url='nourl')
vm = Endpoint(Mock(), '', provider)
vm.name = 'vm1'
vm.ip = self.host
vm.ports = {
'selenium': self.webdriver_server.port,
'agent': self.vmmaster_agent.port,
'vnc': self.vnc_server.port
}
self.session.endpoint = vm
self.session.run()
from vmmaster.webdriver import commands
self.commands = commands
def test_get_vnc_port_if_running_proxy(self):
from core.db.models import Session, Endpoint, Provider
provider = Provider(name='noname', url='nourl')
endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = '127.0.0.1'
endpoint.name = 'test_endpoint'
endpoint.ports = {'4455': 4455, '9000': 9000, '5900': 5900}
session = Session("some_platform")
session.id = 1
session.name = "session1"
session.status = "running"
session.vnc_proxy_port = 55555
session.vnc_proxy_pid = 55555
session.created = session.modified = datetime.now()
session.endpoint = endpoint
session.stop_vnc_proxy = Mock()
with patch('flask.current_app.sessions.get_session',
Mock(return_value=session)), patch(
'core.utils.kill_process', Mock(return_value=True)):
response = self.vmmaster_client.get('/api/session/%s/vnc_info' %
session.id)
session._close()
body = json.loads(response.data)
self.assertEqual(200, response.status_code)
self.assertDictEqual({'vnc_proxy_port': 55555}, body['result'])
self.assertEqual(200, body['metacode'])
self.assertTrue(session.stop_vnc_proxy.called)
def test_get_vnc_proxy_port_if_session_is_waiting(self):
from core.db.models import Session, Endpoint, Provider
provider = Provider(name='noname', url='nourl')
endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = '127.0.0.1'
endpoint.name = 'test_endpoint'
endpoint.ports = {'4455': 4455, '9000': 9000, '5900': 5900}
session = Session("some_platform")
session.name = "session1"
session.id = 1
session.status = "waiting"
session.vnc_proxy_port = None
session.vnc_proxy_pid = None
session.created = session.modified = datetime.now()
session.endpoint = endpoint
with patch('flask.current_app.sessions.get_session',
Mock(return_value=session)):
response = self.vmmaster_client.get(
'/api/session/{}/vnc_info'.format(session.id))
body = json.loads(response.data)
self.assertEqual(200, response.status_code)
self.assertDictEqual({}, body['result'])
self.assertEqual(500, body['metacode'])
def test_unavailable_run_script_during_add_tasks(self):
"""
- add tasks
Expected: selenium log was saved and endpoint was deleted
"""
from vmpool.artifact_collector import ArtifactCollector
with patch(
'core.db.Database', DatabaseMock()
):
from core.db.models import Session, Endpoint, Provider
session = Session("origin_1")
session.id = self.session_id
log_path = os.sep.join([self.artifact_dir, 'selenium_server.log'])
provider = Provider(name='noname', url='nourl')
endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = '127.0.0.1'
endpoint.name = 'test_endpoint'
endpoint.ports = {'selenium': '4455', 'agent': '9000', 'vnc': '5900'}
session.endpoint = endpoint
self.app.sessions.get_session = Mock(return_value=session)
art_collector = ArtifactCollector(database=Mock())
in_queue = art_collector.save_artifact(session, 'selenium_server.log', '/var/log/selenium_server.log')
self.assertTrue(in_queue)
self.assertTrue(wait_for(
lambda: len(art_collector.get_queue()) == 0))
with open(log_path, 'r') as f:
text = f.read()
self.assertIn('Connection refused', text)
art_collector.stop()
def test_500_code_run_script_during_add_tasks(self):
"""
- add tasks
Expected: selenium log was saved and endpoint was deleted
"""
from vmpool.artifact_collector import ArtifactCollector
with patch(
'core.db.Database', DatabaseMock()
):
from core.db.models import Session, Endpoint, Provider
session = Session("origin_1")
session.id = self.session_id
provider = Provider(name='noname', url='nourl')
endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = '127.0.0.1'
endpoint.name = 'test_endpoint'
endpoint.ports = {'selenium': '4455', 'agent': '9000', 'vnc': '5900'}
session.endpoint = endpoint
art_collector = ArtifactCollector(database=Mock())
in_queue = art_collector.save_artifact(session, 'selenium_server.log', '/var/log/selenium_server.log')
self.assertTrue(in_queue)
self.assertTrue(wait_for(
lambda: len(art_collector.get_queue()) == 0))
art_collector.stop()
def test_endpoints_cleanup(self):
"""
- endpoint1 linked with session
- endpoint2 not linked with session
- both endpoints mark as 'deleted'
expected: endpoint1 deleted, endpoint2 not deleted
"""
class FakeOrigin(str):
short_name = 'fake_short_name'
from core.db.models import Session, Endpoint, Provider
provider = Provider('name', 'url')
endpoint1 = Endpoint(origin=FakeOrigin('fake'),
prefix='prefix',
provider=provider)
endpoint2 = Endpoint(origin=FakeOrigin('fake'),
prefix='prefix',
provider=provider)
endpoint1.deleted, endpoint2.deleted = True, True
endpoint1.save(), endpoint2.save()
session = Session(platform='some_platform',
name='__test_keep_forever_sessions_1')
session.refresh()
session.endpoint = endpoint1
session.save()
endpoints_to_delete = [
e.id for e in self.cleanup.endpoints_to_delete()
]
self.assertNotIn(endpoint1.id, endpoints_to_delete)
self.assertIn(endpoint2.id, endpoints_to_delete)
def __init__(self):
self.session = Session()
self.ruz_api = RuzApi()
self.nvr_api = Nvr_Api()
self.calendar_api = GCalendar()
self.ruz = self.session.query(OnlineRoom).filter_by(name="РУЗ").first()
self.jitsi = self.session.query(OnlineRoom).filter_by(
name="Jitsi").first()
def test_api_stop_session(self):
from core.db.models import Session
session = Session("some_platform")
session.failed = Mock()
with patch('flask.current_app.sessions.get_session',
Mock(return_value=session)):
response = self.vmmaster_client.get("/api/session/{}/stop".format(
session.id))
body = json.loads(response.data)
self.assertEqual(200, body['metacode'])
session.failed.assert_any_call(
reason=constants.SESSION_CLOSE_REASON_API_CALL)
def test_session_keep_forever(self):
user = Mock(id=1, max_stored_sessions=0)
from core.db.models import Session
session1 = Session(platform='some_platform',
name='__test_keep_forever_sessions_1')
session1.closed = True
session1.keep_forever = True
session1.save()
session2 = Session(platform='some_platform',
name='__test_keep_forever_sessions_2')
session2.closed = True
session2.keep_forever = False
session2.save()
session_ids_to_delete = [
p.id for p in self.cleanup.sessions_overflow(user)
]
self.assertNotIn(session1.id, session_ids_to_delete)
self.assertIn(session2.id, session_ids_to_delete)
self.cleanup.delete_session_data([session1, session2])
def test_sessions_overflow(self):
user = Mock(id=1, max_stored_sessions=0)
from core.db.models import Session
session = Session('some_platform')
session.status = 'unknown'
session.closed = True
session.name = '__test_outdated_sessions'
session.save()
session_ids_to_delete = [
p.id for p in self.cleanup.sessions_overflow(user)
]
self.assertIn(session.id, session_ids_to_delete)
self.cleanup.delete_session_data([session])
def test_api_sessions(self):
from core.db.models import Session
session = Session(self.platform, "session1",
self.desired_caps["desiredCapabilities"])
session.created = session.modified = datetime.now()
with patch('flask.current_app.sessions.active',
Mock(return_value=[session])):
response = self.vmmaster_client.get('/api/sessions')
body = json.loads(response.data)
self.assertEqual(200, response.status_code)
sessions = body['result']['sessions']
self.assertEqual(1, len(sessions))
self.assertEqual(self.platform, session.platform)
self.assertEqual(200, body['metacode'])
session.failed()
def test_file_deletion(self):
from core.db.models import Session
session = Session('some_platform')
session.status = 'unknown'
session.name = '__test_file_deletion'
session.save()
session_dir = os.path.join(config.SCREENSHOTS_DIR, str(session.id))
system_utils.run_command(["mkdir", config.SCREENSHOTS_DIR],
silent=True)
system_utils.run_command(["mkdir", session_dir], silent=True)
system_utils.run_command(
["touch", os.path.join(session_dir, "file_for_deletion")],
silent=True)
self.cleanup.delete_session_data([session])
self.assertEqual(os.path.isdir(session_dir), 0)
system_utils.run_command(["rm", "-rf", config.SCREENSHOTS_DIR],
silent=True)
def setUp(self):
setup_config('data/config_openstack.py')
self.host = "localhost"
self.port = config.PORT
self.address = (self.host, self.port)
self.vmmaster = vmmaster_server_mock(self.port)
self.assertTrue(server_is_up(self.address))
self.free_port = get_free_port()
self.ctx = self.vmmaster.app.app_context()
self.ctx.push()
from core.db.models import Session, Provider, Endpoint
self.session = Session('some_platform')
provider = Provider(name='noname', url='nourl')
endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = 'localhost'
self.session.endpoint = endpoint
def get_session():
profiler.register_get_session_call()
dc = commands.get_desired_capabilities(request)
matched_platform, provider_id = current_app.get_matched_platforms(dc)
if not matched_platform:
raise SessionException("Cannot match platform for DesiredCapabilities: {}".format(dc))
session = Session(platform=matched_platform, dc=dc, provider_id=provider_id)
request.session = session
log.info("New session {}({}) on provider {} with dc: {}".format(session.id, session.name, provider_id, dc))
yield session
start_time = time.time()
while not session.endpoint_id:
time.sleep(constants.GET_SESSION_SLEEP_TIME)
if time.time() - start_time >= config.GET_VM_TIMEOUT:
raise CreationException("Timeout getting endpoint for {}".format(session))
session.refresh()
yield session
session.run()
yield session