Python server.Server类代码示例

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 main(args):

    print("running server")
    serv = Server(path=args.path)
    serv.run()

    wait(5)

    print("running source pattern=1")
    sources = TestSources(video_port=3000, audio_port=4000)
    sources.new_test_video(pattern=1)

    wait(5)

    print("running gst-switch-ui")
    # the & will run this in the background so control returns 
    # and we can bring up the 2nd source 
    call("gst-switch-ui &", shell=True)

    wait(5)
       
    print("running source pattern=18")
    sources.new_test_video(pattern=18)

    raw_input("hit enter:")


    # need to kill off the processes.

    # a better wy of doing is would be to use
    # https://docs.python.org/2/library/subprocess.html#subprocess.Popen.kill
    # but I don't feel like figuring it out :p

    call("pkill gst-switch-ui", shell=True)
    call("pkill gst-switch-srv", shell=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 test_run_process(self):
     """Test _run_process method"""
     serv = Server(path='abc')
     serv._start_process = Mock(return_value=MockProcess())
     serv.gst_option_string = ''
     ret = serv._run_process()
     assert ret is not None

 def test_kill_fail(self):
     """Test when kill fails"""
     serv = Server(path=PATH)
     serv.proc = 1
     serv.pid = -300
     with pytest.raises(ServerProcessError):
         serv.kill()

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 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_run(self):
     """Test the run method"""
     serv = Server(path='abc')
     serv._run_process = Mock(return_value=MockProcess())
     serv.run()
     assert serv.pid == 1
     assert serv.proc is not None

def main(args):

    print("running server")
    serv = Server(path=args.path)
    serv.run()

    wait(5)

    print("running source pattern=1")
    sources = TestSources(video_port=3000, audio_port=4000)
    sources.new_test_video(pattern=1)

    wait(5)

    print("running gst-switch-ui")
    # the & will run this in the background so control returns 
    # and we can bring up the 2nd source 

    # Replaced call with subprocess.Popen. 
    SwitchUi = subprocess.Popen("gst-switch-ui &",shell=True)

    wait(5)
       
    print("running source pattern=18")
    sources.new_test_video(pattern=18)

    raw_input("hit enter:")


    # Replaced pkill call with Popen.kill
    subprocess.Popen.kill(SwitchUi)
    serv.kill()

 def test_raises_oserror(self):
     """Test what happens when ProcessMonitor raises an OSError"""
     with patch("gstswitch.server.ProcessMonitor") as mock:
         mock.side_effect = OSError()
         serv = Server(path="abc")
         with pytest.raises(ServerProcessError):
             serv._start_process("cmd")

 def test_kill(self, monkeypatch):
     """Test kill ServerProcessError"""
     serv = Server(path='abc')
     serv.proc = Mock()
     monkeypatch.setattr(os, 'kill', Mock(side_effect=OSError))
     with pytest.raises(ServerProcessError):
         serv.kill()

 def test_gcov_flush_fail(self):
     """Test when gcov_flush fails"""
     serv = Server(path=PATH)
     serv.proc = 1
     serv.pid = -300
     with pytest.raises(ServerProcessError):
         serv.gcov_flush()

 def test_raises_enoent(self):
     """Test what happens when ProcessMonitor raises an OSError ENOENT"""
     with patch("gstswitch.server.ProcessMonitor") as mock:
         mock.side_effect = OSError(ENOENT, "not found")
         serv = Server(path="abc")
         with pytest.raises(PathError):
             serv._start_process("cmd")

 def test_log_to_stderr(self):
     """Test log_to_file=False property"""
     with patch("gstswitch.server.ProcessMonitor") as mock:
         serv = Server(path="abc")
         serv.log_to_file = False
         serv._start_process("cmd")
         mock.assert_called_with("cmd")

 def test_start_process_error(self, monkeypatch):
     """Test _start_process method"""
     with patch("subprocess.Popen.__init__") as mock:
         mock.side_effect = OSError
         serv = Server(path="abc")
         with pytest.raises(ServerProcessError):
             serv._start_process("def")