def get_encode_port(num):
"""Test get_encode_port - num times"""
video_port = 3000
serv = Server(path=PATH, video_port=video_port)
try:
serv.run()
sources = TestSources(video_port=video_port)
sources.new_test_video()
expected_res = [video_port + 2] * num
controller = Controller()
controller.establish_connection()
res = []
for _ in range(num):
res.append(controller.get_encode_port())
assert expected_res == res
finally:
if serv.proc:
poll = serv.proc.poll()
if poll == -11:
print "SEGMENTATION FAULT OCCURRED"
print "ERROR CODE - {0}".format(poll)
serv.terminate(1)
log = open('server.log')
print log.read()
def get_encode_port(num):
"""Test get_encode_port - num times"""
video_port = 3000
serv = Server(path=PATH, video_port=video_port)
try:
serv.run()
sources = TestSources(video_port=video_port)
sources.new_test_video()
expected_res = [video_port + 2] * num
controller = Controller()
controller.establish_connection()
res = []
for _ in range(num):
res.append(controller.get_encode_port())
assert expected_res == res
finally:
if serv.proc:
poll = serv.proc.poll()
if poll == -11:
print "SEGMENTATION FAULT OCCURRED"
print "ERROR CODE - {0}".format(poll)
serv.terminate(1)
log = open('server.log')
print log.read()
def get_audio_port(num):
"""Test get_audio_port"""
audio_port = 8000
serv = Server(path=PATH, audio_port=audio_port)
try:
serv.run()
sources = TestSources(audio_port=audio_port)
sources.new_test_audio()
expected_res = [3003] * num
controller = Controller()
controller.establish_connection()
res = []
for _ in range(num):
res.append(controller.get_audio_port())
assert expected_res == res
finally:
if serv.proc:
poll = serv.proc.poll()
if poll == -11:
print("SEGMENTATION FAULT OCCURRED")
print("ERROR CODE - {0}".format(poll))
serv.terminate(1)
log = open('server.log')
print(log.read())
def get_preview_ports(num):
"""Get Preview Ports when num number of sources are added"""
video_port = 3000
serv = Server(path=PATH, video_port=video_port)
try:
serv.run()
sources = TestSources(video_port=video_port)
expected_res = [ i for i in range(3003, 3003 + num)]
controller = Controller()
res = []
for _ in range(num):
sources.new_test_video()
controller.establish_connection()
res = controller.get_preview_ports()
print res
assert expected_res == res
finally:
if serv.proc:
poll = serv.proc.poll()
if poll == -11:
print "SEGMENTATION FAULT OCCURRED"
print "ERROR CODE - {0}".format(poll)
serv.terminate(1)
log = open('server.log')
print log.read()
def test_normal(self, monkeypatch):
"""Test if the parameters are valid"""
monkeypatch.setattr(Connection, 'connect_dbus', Mock())
monkeypatch.setattr(Connection, 'signal_subscribe', Mock())
controller = Controller(address='unix:abstract=abcd')
controller.establish_connection()
assert controller.connection is not None
def test_normal(self, monkeypatch):
"""Test if the parameters are valid"""
monkeypatch.setattr(Connection, 'connect_dbus', Mock())
monkeypatch.setattr(Connection, 'signal_subscribe', Mock())
controller = Controller(address='unix:abstract=abcd')
controller.establish_connection()
assert controller.connection is not None
def do_adjust_pip(self, line):
c = Controller()
c.establish_connection()
if len(line.split()) != 4:
print "Inavlid number of arguments"
return
print c.adjust_pip(*map(int, line.split()))
def do_adjust_pip(self, line):
c = Controller()
c.establish_connection()
if len(line.split()) != 4:
print "Inavlid number of arguments"
return
print c.adjust_pip(*map(int, line.split()))
def get_preview_ports(num):
"""Get Preview Ports when num number of sources are added"""
video_port = 3000
serv = Server(path=PATH, video_port=video_port)
try:
serv.run()
sources = TestSources(video_port=video_port)
expected_res = [i for i in range(3003, 3003 + num)]
controller = Controller()
res = []
for _ in range(num):
sources.new_test_video()
controller.establish_connection()
res = controller.get_preview_ports()
print res
assert expected_res == res
finally:
if serv.proc:
poll = serv.proc.poll()
if poll == -11:
print "SEGMENTATION FAULT OCCURRED"
print "ERROR CODE - {0}".format(poll)
serv.terminate(1)
log = open('server.log')
print log.read()
def test_on_preview_port_added(self):
"""Create a Controller object, call add a source method and
check that the callback fires
"""
serv = Server(path=PATH, video_port=3000)
try:
serv.run()
controller = Controller()
controller.establish_connection()
test_cb = Mock(side_effect=lambda mode, serve, type:
self.quit_mainloop_after(2))
controller.on_preview_port_added(test_cb)
sources = TestSources(video_port=3000)
sources.new_test_video()
sources.new_test_video()
GLib.timeout_add_seconds(5, self.quit_mainloop)
self.run_mainloop()
print(test_cb.call_args_list)
test_cb.assert_any_call(3003, 1, 7)
test_cb.assert_any_call(3004, 1, 8)
assert test_cb.call_count == 2
serv.terminate(1)
finally:
serv.terminate_and_output_status(cov=True)
def get_audio_port(num):
"""Test get_audio_port"""
audio_port = 8000
serv = Server(path=PATH, audio_port=audio_port)
try:
serv.run()
sources = TestSources(audio_port=audio_port)
sources.new_test_audio()
expected_res = [3003] * num
controller = Controller()
controller.establish_connection()
res = []
for _ in range(num):
res.append(controller.get_audio_port())
assert expected_res == res
finally:
if serv.proc:
poll = serv.proc.poll()
if poll == -11:
print("SEGMENTATION FAULT OCCURRED")
print("ERROR CODE - {0}".format(poll))
serv.terminate(1)
log = open('server.log')
print(log.read())
def get_encode_port(self):
"""Create a Controller object and call get_encode_port method"""
res = []
controller = Controller()
controller.establish_connection()
for _ in range(self.NUM * self.FACTOR):
res.append(controller.get_encode_port())
return res
def get_preview_ports(self):
"""Create Controller object and call get_preview_ports method"""
res = []
controller = Controller()
controller.establish_connection()
for _ in range(self.NUM * self.FACTOR):
res.append(controller.get_preview_ports())
return res
def get_compose_port(self):
"""Create Controller and call get_compose_port method"""
res = []
controller = Controller()
controller.establish_connection()
for _ in range(self.NUM * self.FACTOR):
res.append(controller.get_compose_port())
return res
def do_set_composite_mode(self, line):
try:
val = self.COMPOSITE_MAPPING[line.lower()]
except KeyError:
print "Invalid"
return
c = Controller()
c.establish_connection()
print c.set_composite_mode(val)
def do_switch(self, line):
try:
val = self.SWITCH_MAPPING[line.lower()]
except KeyError:
print "Invalid"
return
c = Controller()
c.establish_connection()
print c.switch(self.SWITCH_MAPPING[line.split()[0]], int(line.split()[1]))
def do_set_composite_mode(self, line):
try:
val = self.COMPOSITE_MAPPING[line.lower()]
except KeyError:
print "Invalid"
return
c = Controller()
c.establish_connection()
print c.set_composite_mode(val)
def do_switch(self, line):
try:
val = self.SWITCH_MAPPING[line.lower()]
except KeyError:
print "Invalid"
return
c = Controller()
c.establish_connection()
print c.switch(self.SWITCH_MAPPING[line.split()[0]],
int(line.split()[1]))
def test_action_fails(self):
"""Test what happens if the requested action fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(
return_variant=True, should_fail=True)
assert controller.click_video(1, 2, 3, 4) is False
def test_action_fails(self):
"""Test what happens if the requested action fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=True,
should_fail=True)
assert controller.click_video(1, 2, 3, 4) is False
def test_action_fails(self):
"""Test what happens if the requested action fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=True,
should_fail=True)
assert controller.switch(Controller.VIDEO_CHANNEL_A, 2) is False
def test_unpack(self):
"""Test if unpack fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=False)
with pytest.raises(ConnectionReturnError):
controller.switch(Controller.VIDEO_CHANNEL_A, 2)
def test_unpack(self):
"""Test if unpack fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(True)
with pytest.raises(ConnectionReturnError):
controller.click_video(1, 2, 3, 4)
def test_action_fails(self):
"""Test what happens if the requested action fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(
return_variant=True, should_fail=True)
assert controller.switch(Controller.VIDEO_CHANNEL_A, 2) is False
def test_normal(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(True)
face = [(1, 2, 3, 4), (1, 1, 1, 1)]
controller.mark_tracking(face)
def test_normal(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(True)
face = [(1, 2, 3, 4), (1, 1, 1, 1)]
controller.mark_tracking(face)
def test_unpack(self):
"""Test if unpack fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=False)
with pytest.raises(ConnectionReturnError):
controller.new_record()
def test_unpack(self):
"""Test if unpack fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(True)
with pytest.raises(ConnectionReturnError):
controller.switch(Controller.VIDEO_CHANNEL_A, 2)
def test_unpack(self):
"""Test if unpack fails"""
controller = Controller(address='unix:abstract=abcde')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(True)
with pytest.raises(ConnectionReturnError):
controller.click_video(1, 2, 3, 4)
def test_unpack(self):
"""Test if unpack fails"""
controller = Controller(address='unix:abstract=abcdefghijk')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(True)
with pytest.raises(ConnectionReturnError):
controller.set_composite_mode(1)
def test_unpack(self):
"""Test if unpack fails"""
controller = Controller(address='unix:abstract=abcdefghijk')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(True)
with pytest.raises(ConnectionReturnError):
controller.set_composite_mode(1)
def test_on_new_mode_online(self):
"""Create a Controller object, call on_new_mode_online method and
check that the callback fires
"""
serv = Server(path=PATH)
try:
serv.run()
controller = Controller()
controller.establish_connection()
test_cb = Mock(side_effect=self.quit_mainloop)
controller.on_new_mode_online(test_cb)
controller.set_composite_mode(0)
GLib.timeout_add_seconds(5, self.quit_mainloop)
self.run_mainloop()
test_cb.assert_called_once_with(0)
serv.terminate(1)
finally:
serv.terminate_and_output_status(cov=True)
vid1 = subprocess.Popen(
cmd_vid1.split(),
bufsize=-1,
shell=False)
vid2 = subprocess.Popen(
cmd_vid2.split(),
bufsize=-1,
shell=False)
time.sleep(1)
sources = TestSources(audio_port=a_port)
sources.new_test_audio()
sources.new_test_audio()
controller = Controller()
controller.establish_connection()
cmd = PATH
cmd += """gst-switch-ui"""
cmd = " ".join(cmd.split())
with open('ui.log', 'w') as tempf:
ui_process = subprocess.Popen(
cmd.split(),
stdout=tempf,
stderr=tempf,
bufsize=-1,
shell=False)
params = [(65,3004), (65, 3003)]
i = 0
p = psutil.Process(s.pid)
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=True)
assert controller.adjust_pip(1, 2, 3, 4) == 1
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(False)
assert controller.set_composite_mode(1) is True
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=True)
assert controller.adjust_pip(1, 2, 3, 4) == 1
def establish_connection(self):
"""Create Controller object and call establish_connection"""
controller = Controller()
controller.establish_connection()
# print(controller.connection)
assert controller.connection is not None
def do_get_preview_ports(self, line):
c = Controller()
c.establish_connection()
print c.get_preview_ports()
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(False)
assert controller.switch(Controller.VIDEO_CHANNEL_A, 2) is True
class IntegrationTestbase(object):
"""Base class for integration tests."""
# Tests are not allowed to have an __init__ method
def setup_method(self, _):
"""Set up called automatically before every test_XXXX method."""
self.log = logging.getLogger()
self.log.setLevel(logging.DEBUG)
logging.basicConfig(
format="%(filename)s:%(lineno)d (%(funcName)s): %(message)s")
self.serv = None
self._sources = None
self.controller = None
def setup_server(self, record_file=False):
"""Set up a gst-switch server for testing."""
assert self.serv is None
self.log.info("setting up Server")
self.serv = Server(path=PATH, video_format="debug",
record_file=record_file)
self.log.info("running Server")
self.serv.run()
assert self.serv.is_alive()
self.log.info("waiting for Server to open Controller-Port")
self.serv.wait_for_output('tcp:host=::,port=5000')
self.log.info("setting up TestSources")
self._sources = TestSources(
video_port=self.serv.video_port,
audio_port=self.serv.audio_port)
def setup_controller(self):
"""Create Controller object and call setup_controller."""
self.log.info("setting up Controller")
self.controller = Controller()
self.log.info("connecting Controller to Server")
self.controller.establish_connection()
self.serv.wait_for_output('registered: ')
assert self.controller.connection is not None
def new_test_video(self, pattern=None):
"""Start a new Video-Testsource and wait until it's ready"""
self.serv.wait_for_output(':::3000')
self._sources.new_test_video(pattern=pattern)
def setup_video_sources(self, count):
""" Starts some Test-Video streams and waits until they are ready
"""
self.log.info("starting 2 test-video sources")
for _ in range(0, count):
self.new_test_video()
self.log.info("waiting for the test-video sources to come up")
self.wait_for_sources(count)
def new_test_audio(self, freq=110, wave=AudioSrc.WAVE_SINE):
"""Start a new Audio-Testsource and wait until it's ready"""
self.serv.wait_for_output(':::4000')
self._sources.new_test_audio(freq=freq, wave=wave)
def setup_audio_sources(self, count):
""" Starts some Test-Audio streams and waits until they are ready
"""
self.log.info("starting 2 test-audio sources")
for _ in range(0, count):
self.new_test_audio()
self.log.info("waiting for the test-audio sources to come up")
self.wait_for_sources(count)
def wait_for_sources(self, count):
""" Blocks until the Server has reported, that the right number of
preview-ports are is started
"""
self.log.info("waiting for Server to start preview-port-outputs")
self.serv.wait_for_output('tcpserversink name=sink', count=count)
def teardown_method(self, _):
"""Tear down called automatically after every test_XXXX method."""
self.controller = None
# Kill all the sources
if self._sources is not None:
self.log.info("terminating Video-TestSource")
self._sources.terminate_video()
self.log.info("terminating Audio-TestSource")
self._sources.terminate_audio()
self._sources = None
if self.serv is not None:
self.log.info("terminating Server")
self.serv.terminate(cov=True)
if self.serv.proc:
poll = self.serv.proc.poll()
if poll == -11:
self.log.error("Server exited with Segmentation Fault")
if poll != 0:
self.log.error("Server exited Error Eode %s", poll)
log = open('server.log')
print(log.read())
self.serv = None
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(False)
assert controller.set_composite_mode(1) is True
def do_get_audio_port(self, line):
c = Controller()
c.establish_connection()
print c.get_audio_port()
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(False)
assert controller.click_video(1, 2, 3, 4) is True
def do_get_preview_ports(self, line):
c = Controller()
c.establish_connection()
print c.get_preview_ports()
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=True)
assert controller.get_composite_mode() is Controller.COMPOSITE_NONE
def do_get_audio_port(self, line):
c = Controller()
c.establish_connection()
print c.get_audio_port()
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=True)
assert controller.switch(Controller.VIDEO_CHANNEL_A, 2) is True
def establish_connection(self):
"""Create Controller object and call establish_connection"""
controller = Controller()
controller.establish_connection()
# print controller.connection
assert controller.connection is not None
class IntegrationTestbase(object):
"""Base class for integration tests."""
# Tests are not allowed to have an __init__ method
def setup_method(self, _):
"""Set up called automatically before every test_XXXX method."""
self.log = logging.getLogger()
self.log.setLevel(logging.DEBUG)
logging.basicConfig(
format="%(filename)s:%(lineno)d (%(funcName)s): %(message)s")
self.serv = None
self._sources = None
self.controller = None
def setup_server(self, record_file=False):
"""Set up a gst-switch server for testing."""
assert self.serv is None
self.log.info("setting up Server")
self.serv = Server(path=PATH,
video_format="debug",
record_file=record_file)
self.log.info("running Server")
self.serv.run()
assert self.serv.is_alive()
self.log.info("waiting for Server to open Controller-Port")
self.serv.wait_for_output('tcp:host=::,port=5000')
self.log.info("setting up TestSources")
self._sources = TestSources(video_port=self.serv.video_port,
audio_port=self.serv.audio_port)
def setup_controller(self):
"""Create Controller object and call setup_controller."""
self.log.info("setting up Controller")
self.controller = Controller()
self.log.info("connecting Controller to Server")
self.controller.establish_connection()
self.serv.wait_for_output('registered: ')
assert self.controller.connection is not None
def new_test_video(self, pattern=None):
"""Start a new Video-Testsource and wait until it's ready"""
self.serv.wait_for_output(':::3000')
self._sources.new_test_video(pattern=pattern)
def setup_video_sources(self, count):
""" Starts some Test-Video streams and waits until they are ready
"""
self.log.info("starting 2 test-video sources")
for _ in range(0, count):
self.new_test_video()
self.log.info("waiting for the test-video sources to come up")
self.wait_for_sources(count)
def new_test_audio(self, freq=110, wave=AudioSrc.WAVE_SINE):
"""Start a new Audio-Testsource and wait until it's ready"""
self.serv.wait_for_output(':::4000')
self._sources.new_test_audio(freq=freq, wave=wave)
def setup_audio_sources(self, count):
""" Starts some Test-Audio streams and waits until they are ready
"""
self.log.info("starting 2 test-audio sources")
for _ in range(0, count):
self.new_test_audio()
self.log.info("waiting for the test-audio sources to come up")
self.wait_for_sources(count)
def wait_for_sources(self, count):
""" Blocks until the Server has reported, that the right number of
preview-ports are is started
"""
self.log.info("waiting for Server to start preview-port-outputs")
self.serv.wait_for_output('tcpserversink name=sink', count=count)
def teardown_method(self, _):
"""Tear down called automatically after every test_XXXX method."""
self.controller = None
# Kill all the sources
if self._sources is not None:
self.log.info("terminating Video-TestSource")
self._sources.terminate_video()
self.log.info("terminating Audio-TestSource")
self._sources.terminate_audio()
self._sources = None
if self.serv is not None:
self.log.info("terminating Server")
self.serv.terminate(cov=True)
if self.serv.proc:
poll = self.serv.proc.poll()
if poll == -11:
self.log.error("Server exited with Segmentation Fault")
if poll != 0:
self.log.error("Server exited Error Eode %s", poll)
log = open('server.log')
print(log.read())
self.serv = None
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(False)
assert controller.click_video(1, 2, 3, 4) is True
audio_port = s.audio_port
# connects a gstreamer module to view the output of the gst-switch-srv
output = PreviewSinks()
output.run()
# adding two test video sources
sources = TestSources(video_port=video_port, audio_port=audio_port)
sources.new_test_audio()
sources.new_test_audio()
sources.new_test_video()
sources.new_test_video()
sources.new_test_video(timeoverlay=True)
controller = Controller()
controller.establish_connection()
res = []
tests_get = [controller.get_compose_port,
controller.get_encode_port,
controller.get_audio_port,
controller.get_preview_ports,
]
test_set_composite_mode = controller.set_composite_mode
# testing random 10 modes
for x in tests_get:
print x.__name__, x()
time.sleep(1)
modes = [0, 3, 2, 1, 0, 1, 2, 3, 0]
for mode in modes:
def test_normal_unpack(self):
"""Test if valid"""
controller = Controller(address='unix:abstract=abcdef')
controller.establish_connection = Mock(return_value=None)
controller.connection = MockConnection(return_variant=True)
assert controller.get_composite_mode() is Controller.COMPOSITE_NONE
