Beispiel #1
0
    def test_close(self):
        """``dockerpty.io`` Demuxer proxies to Stream to close it"""
        fake_stream = MagicMock()

        io.Demuxer(fake_stream).close()

        self.assertTrue(fake_stream.close.called)
Beispiel #2
0
    def test_set_blocking(self):
        """``dockerpty.io`` Demuxer leverages the Stream for 'set_blocking'"""
        fake_stream = MagicMock()

        io.Demuxer(fake_stream).set_blocking('some value')

        self.assertTrue(fake_stream.set_blocking.called)
Beispiel #3
0
    def test_init(self):
        """``dockerpty.io`` Demuxer only requires a Stream for init"""
        fake_stream = MagicMock()

        demuxer = io.Demuxer(fake_stream)

        self.assertTrue(isinstance(demuxer, io.Demuxer))
Beispiel #4
0
    def test_do_write_no_attr(self):
        """``dockerpty.io`` Demuxer return False if the Stream object has no 'do_write' attribute"""
        fake_stream = FakeObj()
        demuxer = io.Demuxer(fake_stream)

        answer = demuxer.do_write()

        self.assertFalse(answer)
Beispiel #5
0
    def test_do_write(self):
        """``dockerpty.io`` Demuxer proxies to the Stream for 'do_write'"""
        fake_stream = MagicMock()
        demuxer = io.Demuxer(fake_stream)

        demuxer.do_write()

        self.assertTrue(fake_stream.do_write.called)
Beispiel #6
0
    def test_write(self):
        """``dockerpty.io`` Demuxer proxies writes to the Stream object"""
        fake_stream = MagicMock()
        demuxer = io.Demuxer(fake_stream)

        demuxer.write(b'some data')

        self.assertTrue(fake_stream.write.called)
Beispiel #7
0
    def test_repr(self):
        """``dockerpty.io`` Demuxer has a handy repr"""
        fake_stream = FakeObj()
        demuxer = io.Demuxer(fake_stream)

        the_repr = '{}'.format(demuxer)
        expected = 'Demuxer(some object)'

        self.assertEqual(the_repr, expected)
Beispiel #8
0
    def test_read_zero(self):
        """``dockerpty.io`` Demuxer returns None if there's no data to read"""
        fake_stream = MagicMock()
        demuxer = io.Demuxer(fake_stream)
        demuxer._next_packet_size = lambda x: 0

        output = demuxer.read()

        self.assertTrue(output is None)
Beispiel #9
0
    def test_fileno(self):
        """``dockerpty.io`` Demuxer leverages the Stream for 'fileno'"""
        fake_stream = MagicMock()
        fake_stream.fileno.return_value = 345

        fileno = io.Demuxer(fake_stream).fileno()
        expected = 345

        self.assertEqual(expected, fileno)
Beispiel #10
0
    def test_next_packet_size_zero_read(self):
        """``dockerpty.io`` Demuxer '_next_packet_size' returns zero if nothing is read from the Stream"""
        fake_stream = MagicMock()
        fake_stream.read.return_value = b''
        demuxer = io.Demuxer(fake_stream)

        answer = demuxer._next_packet_size()
        expected = 0

        self.assertEqual(answer, expected)
Beispiel #11
0
    def test_next_packet_size(self):
        """``dockerpty.io`` Demuxer pulls the payload size from the header from Docker"""
        fake_stream = MagicMock()
        fake_stream.read.return_value = b'12345678'
        demuxer = io.Demuxer(fake_stream)

        answer = demuxer._next_packet_size()
        expected = 0

        self.assertEqual(answer, expected)
Beispiel #12
0
    def test_next_packet_size_remain(self):
        """``dockerpty.io`` Demuxer _next_packet_size handles remainders"""
        fake_stream = MagicMock()
        fake_stream.read.return_value = b'12345678'
        demuxer = io.Demuxer(fake_stream)
        demuxer.remain = 2

        answer = demuxer._next_packet_size()
        expected = 0

        self.assertEqual(answer, expected)
Beispiel #13
0
    def test_read_closed_stream(self):
        """``dockerpty.io`` Demuxer returns as much as it can if the stream closes"""
        fake_stream = MagicMock()
        fake_stream.read.side_effect = [b'some', b'']
        demuxer = io.Demuxer(fake_stream)
        demuxer._next_packet_size = lambda x: 10

        output = demuxer.read()
        expected = b'some'

        self.assertEqual(output, expected)
Beispiel #14
0
    def test_read(self):
        """``dockerpty.io`` Demuxer reads N bytes of data, and returns it"""
        fake_stream = MagicMock()
        fake_stream.read.return_value = b'some data!'
        demuxer = io.Demuxer(fake_stream)
        demuxer._next_packet_size = lambda x: 10

        data = demuxer.read()
        expected = b'some data!'

        self.assertEqual(data, expected)
Beispiel #15
0
 def sockets(self):
     """
     Return a single socket which is processing all I/O to exec
     """
     socket = self.client.exec_start(self.exec_id,
                                     socket=True,
                                     tty=sys.stdin.isatty())
     stream = io.Stream(socket)
     if self.is_process_tty():  #pylint: disable=R1705
         return stream
     else:
         return io.Demuxer(stream)
Beispiel #16
0
 def attach_socket(key):
     if info['Config']['Attach{0}'.format(key.capitalize())]:
         socket = self.client.attach_socket(
             self.container,
             {
                 key: 1,
                 'stream': 1,
                 'logs': self.logs
             },
         )
         stream = io.Stream(socket)
         #pylint: disable=R1705
         if info['Config']['Tty']:
             return stream
         else:
             return io.Demuxer(stream)
     else:
         return None