def permutate_adjust_pip(num, delay):
"""Adjust_pip num number of times"""
import random
video_port = 3000
serv = Server(path=PATH, video_port=video_port)
try:
serv.run()
sources = TestSources(video_port=video_port)
sources.new_test_video(pattern=6)
sources.new_test_video(pattern=5)
preview = PreviewSinks()
preview.run()
controller = Controller()
for _ in range(num):
xpos = random.randrange(-20, 20)
ypos = random.randrange(-20, 20)
res = controller.adjust_pip(xpos, ypos, 0, 0)
time.sleep(delay)
assert res is not None
preview.terminate()
sources.terminate_video()
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_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_multiple_handler_calls(self, monkeypatch):
"""Test that the various Handler gets calles"""
monkeypatch.setattr(Connection, 'connect_dbus', Mock())
controller = Controller(address='unix:abstract=abcd')
signals = ('preview_port_added', 'preview_port_removed',
'new_mode_online', 'show_face_marker', 'show_track_marker',
'select_face')
test_cbs = {}
for signal in signals:
test_cbs[signal] = Mock()
getattr(controller, 'on_' + signal)(test_cbs[signal])
getattr(controller, 'on_' + signal)(test_cbs[signal])
getattr(controller, 'on_' + signal)(test_cbs[signal])
for signal in signals:
controller.cb_signal_handler(
None, ':0',
'/us/timvideos/gstswitch/SwitchControllerInterface',
'us.timvideos.gstswitch.SwitchControllerInterface', signal,
GLib.Variant('(i)', (123, )), None)
for signal in signals:
test_cbs[signal].assert_called_with(123)
assert test_cbs[signal].call_count == 3
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 switch(self, channel, port, index):
"""Create Controller object and call switch method"""
for _ in range(self.NUM):
serv = Server(path=PATH)
try:
serv.run()
sources = TestSources(3000)
sources.new_test_video(pattern=4)
sources.new_test_video(pattern=5)
preview = PreviewSinks(3001)
preview.run()
out_file = "output-{0}.data".format(index)
video_sink = VideoFileSink(PATH, 3001, out_file)
time.sleep(3)
controller = Controller()
res = controller.switch(channel, port)
print res
time.sleep(3)
video_sink.terminate()
sources.terminate_video()
preview.terminate()
serv.terminate(1)
finally:
if serv.proc:
poll = serv.proc.poll()
print self.__class__
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 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 new_record(self):
"""Create a Controller object and call new_record method"""
res = []
controller = Controller()
for _ in range(self.NUM * self.FACTOR):
res.append(controller.new_record())
return res
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_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 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 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(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 test_signal_name_collision(self, monkeypatch):
"""Test that nothing happens when a signal is on the bus which name
collides with an attribute also starting with 'callbacks_'
"""
monkeypatch.setattr(Connection, 'connect_dbus', Mock())
controller = Controller(address='unix:abstract=abcd')
controller.callbacks_foobar = 123
controller.cb_signal_handler(None, ':0', '/foo/bar', 'foo.bar',
'foobar', None, None)
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 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 test_invalid_callback(self, monkeypatch):
"""Test that a ValueError is raised when a not-callable object is
registered as callback-handler
"""
monkeypatch.setattr(Connection, 'connect_dbus', Mock())
for signal in ('preview_port_added', 'preview_port_removed',
'new_mode_online', 'show_face_marker',
'show_track_marker', 'select_face'):
test_cb = 123
controller = Controller(address='unix:abstract=abcd')
with pytest.raises(ValueError):
getattr(controller, 'on_' + signal)(test_cb)
def set_composite_mode(self, mode, generate_frames=False):
"""Create Controller object and call set_composite_mode method"""
for _ in range(self.NUM):
serv = Server(path=PATH)
try:
serv.run()
preview = PreviewSinks()
preview.run()
out_file = 'output-{0}.data'.format(mode)
video_sink = VideoFileSink(PATH, serv.video_port + 1, out_file)
sources = TestSources(video_port=3000)
sources.new_test_video(pattern=4)
sources.new_test_video(pattern=5)
time.sleep(3)
# expected_result = [mode != 3] * self.FACTOR
# print mode, expected_result
controller = Controller()
res = controller.set_composite_mode(mode)
print res
time.sleep(3)
video_sink.terminate()
preview.terminate()
sources.terminate_video()
serv.terminate(1)
if not generate_frames:
if mode == 3:
assert res is False
else:
assert res is True
assert self.verify_output(mode, out_file) is True
# assert expected_result == res
finally:
if serv.proc:
poll = serv.proc.poll()
print self.__class__
if poll == -11:
print "SEGMENTATION FAULT OCCURRED"
print "ERROR CODE - {0}".format(poll)
serv.terminate(1)
log = open('server.log')
print log.read()
def click_video(self,
xpos,
ypos,
width,
heigth,
index,
generate_frames=False):
"""Create Controller object and call click_video method"""
for _ in range(self.NUM):
serv = Server(path=PATH)
try:
serv.run()
sources = TestSources(video_port=3000)
preview = PreviewSinks()
preview.run()
out_file = "output-{0}.data".format(index)
video_sink = VideoFileSink(PATH, 3001, out_file)
sources.new_test_video(pattern=4)
sources.new_test_video(pattern=5)
controller = Controller()
time.sleep(1)
res = controller.click_video(xpos, ypos, width, heigth)
print res
time.sleep(1)
sources.terminate_video()
preview.terminate()
video_sink.terminate()
serv.terminate(1)
if not generate_frames:
assert res is not None
assert self.verify_output(index, out_file) is True
finally:
if serv.proc:
poll = serv.proc.poll()
print self.__class__
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_single_handler_calls(self, monkeypatch):
"""Test that the various Handler gets calles"""
monkeypatch.setattr(Connection, 'connect_dbus', Mock())
for signal in ('preview_port_added', 'preview_port_removed',
'new_mode_online', 'show_face_marker',
'show_track_marker', 'select_face'):
test_cb = Mock()
controller = Controller(address='unix:abstract=abcd')
getattr(controller, 'on_' + signal)(test_cb)
controller.cb_signal_handler(
None, ':0',
'/us/timvideos/gstswitch/SwitchControllerInterface',
'us.timvideos.gstswitch.SwitchControllerInterface', signal,
GLib.Variant('(iii)', (
5,
10,
20,
)), None)
test_cb.assert_called_once_with(5, 10, 20)
def permutate_composite_mode(num, delay):
"""Change composite mode num number of times"""
import random
video_port = 3000
serv = Server(path=PATH, video_port=video_port)
try:
serv.run()
sources = TestSources(video_port=video_port)
sources.new_test_video(pattern=6)
sources.new_test_video(pattern=5)
preview = PreviewSinks()
preview.run()
controller = Controller()
res = controller.set_composite_mode(0)
assert res is True
prev_mode = 0
for _ in range(num - 1):
time.sleep(delay)
mode = random.randint(0, 3)
expected_res = bool(prev_mode ^ mode)
prev_mode = mode
assert expected_res == controller.set_composite_mode(mode)
preview.terminate()
sources.terminate_video()
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_interface_normal(self):
"""Test when the interface is valid"""
default_interface = "info.duzy.gst.switch.SwitchControllerInterface"
conn = Controller(default_interface=default_interface)
assert default_interface == conn.default_interface
def test_interface_dot(self):
"""Test when the default_interface has <2 dots"""
default_interface = ['.', 'info.', 'info']
for interface in default_interface:
with pytest.raises(ValueError):
Controller(default_interface=interface)
def test_interface_none(self):
"""Test when the default_interface is null"""
default_interface = [None, '', [], {}]
for interface in default_interface:
with pytest.raises(ValueError):
Controller(default_interface=interface)
def test_object_path_normal(self):
"""Test when object_path is valid"""
object_path = "/info/duzy/gst/switch/SwitchController"
conn = Controller(object_path=object_path)
assert conn.object_path == object_path
