def test_datetime(self):
now = datetime.now()
d = now + timedelta(seconds=0.1)
timer = Timer(d, test(), "timer")
timer.register(self.app)
wait_for(self.app, "flag")
self.app.reset()
def test_datetime(self):
now = datetime.now()
d = now + timedelta(seconds=0.1)
timer = Timer(d, test(), "timer")
timer.register(self.app)
wait_for(self.app, "flag")
self.app.reset()
def test_run_recorder(self):
"""
- call session.run()
- call session.succeed()
Expected: vnc_recorder was started and stopped
"""
with patch(
'core.video.VNCVideoHelper._flvrec', Mock()
), patch(
'core.video.VNCVideoHelper.start_recording', Mock()
) as start_rec_mock, patch(
'core.video.VNCVideoHelper.stop', Mock()
) as stop_rec_mock, patch(
'core.video.VNCVideoHelper.is_alive', Mock(return_value=True)
):
from vmpool.artifact_collector import ArtifactCollector
session = Mock(endpoint=Mock(prefix="ondemand", ip='127.0.0.1'), closed=False)
artifact_collector = ArtifactCollector(database=DatabaseMock())
artifact_collector.record_screencast(session)
wait_for(lambda: artifact_collector.in_queue, timeout=5)
session.closed = True
wait_for(lambda: not artifact_collector.in_queue, timeout=5)
self.assertTrue(start_rec_mock.called)
self.assertTrue(stop_rec_mock.called)
def test_connect_devices(self, device_spec):
"""
- set config with 1 device
- try to connect devices
Expected: 1 device connected and 1 device in connected_devices list
- stop stf-connect
Expected: 0 devices connected and lists of devices was empty
"""
with patch(
'stf_utils.common.stfapi.SmartphoneTestingFarmAPI.get_all_devices',
self.all_devices_mock,
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.get_device',
self.get_device_mock,
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.add_device',
Mock(),
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.remote_connect',
self.remote_connect_mock,
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.delete_device',
Mock(),
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.remote_disconnect',
Mock(),
), patch('stf_utils.common.adb.device_is_ready',
Mock(return_value=True)), patch(
'stf_utils.common.adb.connect',
Mock(return_value=True)), patch(
'stf_utils.common.adb.disconnect',
Mock(return_value=True)):
stf = SmartphoneTestingFarmClient(
host="http://host.domain",
common_api_path="/api/v1",
oauth_token="test token",
device_spec=device_spec,
devices_file_path="./devices",
shutdown_emulator_on_disconnect=True)
stf.connect_devices()
wait_for(
lambda: self.assertTrue(stf.shutdown_emulator_on_disconnect))
wait_for(lambda: self.assertEqual(
len(stf.device_groups[0].get("added_devices")),
int(device_spec[0].get("amount"))))
wait_for(lambda: self.assertEqual(
len(stf.device_groups[0].get("connected_devices")),
int(device_spec[0].get("amount"))))
stf.close_all()
wait_for(lambda: self.assertEqual(
len(stf.device_groups[0].get("added_devices")), 0))
wait_for(lambda: self.assertEqual(
len(stf.device_groups[0].get("connected_devices")), 0))
def test_rebuild_preload_vm(self):
"""
- call OpenstackClone.delete(try_to_rebuild=True)
Expected: vm has been rebuilded and added in pool
"""
self.clone.delete(try_to_rebuild=True)
wait_for(lambda: self.clone.ready is True)
def test_persistent(self):
timer = Timer(0.1, test(), "timer", persist=True)
timer.register(self.app)
for _ in range(2):
wait_for(self.app, "flag")
self.app.reset()
timer.unregister()
def test_persistent(self):
timer = Timer(0.1, test(), "timer", persist=True)
timer.register(self.app)
for _ in range(2):
wait_for(self.app, "flag")
self.app.reset()
timer.unregister()
def test_exception_in_rebuild_vm_if_vm_exist(self):
"""
- call OpenstackClone.create()
- exception in OpenstackClone.delete(try_to_rebuild=True)
Expected: vm has been deleted
"""
self.clone.delete(try_to_rebuild=True)
wait_for(lambda: self.clone.ready is False)
self.assertTrue(self.clone.deleted)
def test_rebuild_after_delete_vm_if_vm_does_not_exist(self):
"""
- get_vm return None
- call OpenstackClone.delete(try_to_rebuild=True)
Expected: vm has not been deleted
"""
self.clone.delete(try_to_rebuild=True)
wait_for(lambda: self.clone.ready is False)
self.assertIsNone(self.clone.deleted)
def test_ping_success(self):
"""
- call OpenstackClone.create()
- ping success
Expected: vm has been created
"""
self.clone.create()
wait_for(lambda: self.clone.ready)
self.assertTrue(self.clone.ready)
def test_vm_in_error_status(self):
"""
- call OpenstackClone.create()
- first call server.status.lower() return "build",
second call return "error"
third call return "active"
Expected: vm has been rebuilded
"""
self.clone.create()
wait_for(lambda: self.clone.ready is True)
self.assertTrue(self.clone.ready)
def test_create_vm_with_get_ip(self):
"""
- call OpenstackClone.create()
- check_vm_exist is True
- ping successful
- ready is True
- get_ip return mocked ip address and mac
Expected: vm has been created
"""
self.clone.create()
wait_for(lambda: self.clone.ready is True)
self.assertEqual(self.clone.ip, "127.0.0.1")
def test_connect_devices(self, device_spec):
"""
- set config with 1 device
- try to connect devices
Expected: 1 device connected and 1 device in connected_devices list
- stop stf-connect
Expected: 0 devices connected and lists of devices was empty
"""
with patch(
'stf_utils.common.stfapi.SmartphoneTestingFarmAPI.get_all_devices', self.all_devices_mock,
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.get_device', self.get_device_mock,
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.add_device', Mock(),
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.remote_connect', self.remote_connect_mock,
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.delete_device', Mock(),
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.remote_disconnect', Mock(),
), patch(
'stf_utils.common.adb.device_is_ready', Mock(return_value=True)
), patch(
'stf_utils.common.adb.connect', Mock(return_value=True)
), patch(
'stf_utils.common.adb.disconnect', Mock(return_value=True)
):
stf = SmartphoneTestingFarmClient(
host="http://host.domain",
common_api_path="/api/v1",
oauth_token="test token",
device_spec=device_spec,
devices_file_path="./devices",
shutdown_emulator_on_disconnect=True
)
stf.connect_devices()
wait_for(lambda: self.assertTrue(stf.shutdown_emulator_on_disconnect))
wait_for(lambda: self.assertEqual(len(stf.device_groups[0].get("added_devices")), int(device_spec[0].get("amount"))))
wait_for(lambda: self.assertEqual(len(stf.device_groups[0].get("connected_devices")), int(device_spec[0].get("amount"))))
stf.close_all()
wait_for(lambda: self.assertEqual(len(stf.device_groups[0].get("added_devices")), 0))
wait_for(lambda: self.assertEqual(len(stf.device_groups[0].get("connected_devices")), 0))
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_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_connect_new_device_after_device_lost(self, device_spec):
"""
- set config with 1 device
- try to connect devices
Expected: 1 device connected and 1 device in connected_devices list
- start devices watcher
- got 'False' in device_is_ready method (connected device is not available)
Expected: 0 devices connected and lists of devices was empty
(device was removed from stf-connect and device by adb was disconnected)
- try to connect available devices
Expected: 1 device connected and 1 device in connected_devices list
"""
def raise_exception():
raise Exception('something ugly happened in adb connect')
with patch(
'stf_connect.client.SmartphoneTestingFarmClient.get_all_devices', self.all_devices_mock,
), patch(
'stf_connect.client.SmartphoneTestingFarmClient.get_device', self.get_device_mock,
), patch(
'stf_connect.client.SmartphoneTestingFarmClient.add_device', Mock(),
), patch(
'stf_connect.client.SmartphoneTestingFarmClient.remote_connect', self.remote_connect_mock,
), patch(
'common.adb.device_is_ready', Mock(side_effect=[False, True, True])
), patch(
'common.adb.connect', Mock(side_effect=[True, raise_exception, True])
), patch(
'common.adb.disconnect', Mock(return_value=True)
):
stf = SmartphoneTestingFarmClient(
host="http://host.domain",
common_api_path="/api/v1",
oauth_token="test token",
device_spec=device_spec,
devices_file_path="./devices",
shutdown_emulator_on_disconnect=True
)
stf.connect_devices()
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("added_devices")) == int(device_spec[0].get("amount"))))
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("connected_devices")) == int(device_spec[0].get("amount"))))
self.watcher = STFConnectedDevicesWatcher(stf)
self.watcher.start()
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("added_devices")) == 0))
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("connected_devices")) == 0))
stf.connect_devices()
self.assertTrue(wait_for(lambda: stf.shutdown_emulator_on_disconnect))
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("added_devices")) == int(device_spec[0].get("amount"))))
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("connected_devices")) == int(device_spec[0].get("amount"))))
def test_connect_new_device_after_device_lost(self, device_spec):
"""
- set config with 1 device
- try to connect devices
Expected: 1 device connected and 1 device in connected_devices list
- start devices watcher
- got 'False' in device_is_ready method (connected device is not available)
Expected: 0 devices connected and lists of devices was empty
(device was removed from stf-connect and device by adb was disconnected)
- try to connect available devices
Expected: 1 device connected and 1 device in connected_devices list
"""
def raise_exception():
raise Exception('something ugly happened in adb connect')
with patch(
'stf_utils.common.stfapi.SmartphoneTestingFarmAPI.get_all_devices', self.all_devices_mock,
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.get_device', self.get_device_mock,
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.add_device', Mock(),
), patch(
'stf_utils.stf_connect.client.SmartphoneTestingFarmClient.remote_connect', self.remote_connect_mock,
), patch(
'stf_utils.common.adb.device_is_ready', Mock(side_effect=[False, True, True])
), patch(
'stf_utils.common.adb.connect', Mock(side_effect=[True, raise_exception, True])
), patch(
'stf_utils.common.adb.disconnect', Mock(return_value=True)
):
stf = SmartphoneTestingFarmClient(
host="http://host.domain",
common_api_path="/api/v1",
oauth_token="test token",
device_spec=device_spec,
devices_file_path="./devices",
shutdown_emulator_on_disconnect=True
)
stf.connect_devices()
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("added_devices")) == int(device_spec[0].get("amount"))))
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("connected_devices")) == int(device_spec[0].get("amount"))))
self.watcher = STFConnectedDevicesWatcher(stf)
self.watcher.start()
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("added_devices")) == 0))
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("connected_devices")) == 0))
stf.connect_devices()
self.assertTrue(wait_for(lambda: stf.shutdown_emulator_on_disconnect))
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("added_devices")) == int(device_spec[0].get("amount"))))
self.assertTrue(wait_for(lambda: len(stf.device_groups[0].get("connected_devices")) == int(device_spec[0].get("amount"))))
def testSequence(self):
frames = mock.Mock()
sequence = Sequence(frames, [0], [1], 400, 10)
frames.assert_not_called()
self.assertFalse(sequence.isRunning())
sequence.setFrame(2)
self.assertEqual(sequence.current_frame, 2)
sequence.setFrame(-1)
self.assertEqual(sequence.current_frame, 9)
sequence.start()
self.assertTrue(sequence.isRunning())
sequence.stop()
self.assertEqual(sequence.current_frame, 9)
frames.assert_called()
frames.reset_mock()
sequence.start()
self.assertTrue(sequence.isRunning())
wait_for(lambda: not sequence.isRunning(), 500)
self.assertFalse(sequence.isRunning())
def test_stop_artifact_collector(self):
"""
- stop artifact collector
Expected: all tasks were deleted
"""
from vmpool.artifact_collector import ArtifactCollector, Task
from multiprocessing.pool import AsyncResult
art_collector = ArtifactCollector(database=Mock())
task = AsyncResult(cache={1: ""}, callback=None)
task._job = 1
task._ready = True
art_collector.in_queue = {
1: [Task('my_task', task)]
}
art_collector.stop()
self.assertTrue(wait_for(
lambda: len(art_collector.get_queue()) == 0))
def testName(self):
wait_for(self._conf_comp, "value", "Yes")
self.assertEqual(self._conf_comp.value, "Yes")
def testName(self):
wait_for(self._conf_comp, "value", "Yes")
self.assertEqual(self._conf_comp.value, "Yes")
def test_basic(self):
timer = Timer(0.1, test(), "timer")
timer.register(self.app)
wait_for(self.app, "flag")
self.app.reset()
def test_basic(self):
timer = Timer(0.1, test(), "timer")
timer.register(self.app)
wait_for(self.app, "flag")
self.app.reset()
