Python binaryTypeの例

コード例 #1

ファイル: parser_test.py プロジェクト: tobgu/stompest

 def test_binary_body_invalid_eof(self):
     parser = StompParser()
     body = b'MESSAGE\ncontent-length:4\n\n\xf0\x00\n\t\x00'
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)
     self.assertRaises(
         StompFrameError, parser.add,
         b'MESSAGE\ncontent-length:4\n\n\xf0\n\t\xff\x01\n\nCONNECT\n\x00'
     )  # \x00 behind invalid EOF
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)
     self.assertRaises(StompFrameError, parser.add,
                       b'MESSAGE\ncontent-length:4\n\n\xf0\n\t\xff\x01\x00'
                       )  # \x00 just behind invalid EOF
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)
     self.assertRaises(StompFrameError, parser.add,
                       b'MESSAGE\ncontent-length:4\n\n\xf0\x00\n\t\x01'
                       )  # \x00 before invalid EOF
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)
     self.assertRaises(StompFrameError, parser.add,
                       b'MESSAGE\ncontent-length:4\n\n\xf0\n\t\x00\x01'
                       )  # \x00 just before invalid EOF
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)

コード例 #2

ファイル: parser_test.py プロジェクト: nikipore/stompest

 def test_dont_unescape_bad_characters(self):
     parser = StompParser(StompSpec.VERSION_1_2)
     frame = commands.send('*queue')
     parser.add(binaryType(frame))
     self.assertEqual(parser.get(), frame)
     for badCharacter in (b'\r', b'\n', b'\c', b'\\', b':', b'\\h'):
         self.assertRaises(StompFrameError, parser.add, binaryType(frame).replace(b'*', badCharacter))
     self.assertRaises(StompFrameError, parser.add, binaryType(commands.send('queue\\')))
     self.assertIsNone(parser.get())

コード例 #3

    def test_unescape(self):
        frameBytes = ("""%s
\\n\\\\:\\c\t\\n

\x00""" % StompSpec.DISCONNECT).encode()

        frame = StompFrame(command=StompSpec.DISCONNECT,
                           headers={'\n\\': ':\t\n'},
                           version=StompSpec.VERSION_1_1)
        self.assertEqual(binaryType(frame), frameBytes)

        frameBytes = ("""%s
\\n\\\\:\\c\t\\r

\x00""" % StompSpec.DISCONNECT).encode()

        frame = StompFrame(command=StompSpec.DISCONNECT,
                           headers={'\n\\': ':\t\r'},
                           version=StompSpec.VERSION_1_2)
        self.assertEqual(binaryType(frame), frameBytes)

        frameBytes = ("""%s
\\n\\\\:\\c\t\r

\x00""" % StompSpec.DISCONNECT).encode()

        frame = StompFrame(command=StompSpec.DISCONNECT,
                           headers={'\n\\': ':\t\r'},
                           version=StompSpec.VERSION_1_1)
        self.assertEqual(binaryType(frame), frameBytes)

        frameBytes = ("""%s

\\::\t\r


\x00""" % StompSpec.DISCONNECT).encode()

        frame = StompFrame(command=StompSpec.DISCONNECT,
                           headers={'\n\\': ':\t\r\n'},
                           version=StompSpec.VERSION_1_0)
        self.assertEqual(binaryType(frame), frameBytes)

        frameBytes = ("""%s

\\::\t\r


\x00""" % StompSpec.CONNECT).encode()

        frame = StompFrame(command=StompSpec.CONNECT,
                           headers={'\n\\': ':\t\r\n'})
        for version in StompSpec.VERSIONS:
            frame.version = version
            self.assertEqual(binaryType(frame), frameBytes)

コード例 #4

ファイル: parser_profile.py プロジェクト: tobgu/stompest

def main():
    parser = StompParser(version=StompSpec.VERSION_1_2)
    frame = binaryType(binaryFrame) + binaryType(textFrame) + binaryType(heartBeatFrame)
    for _ in createRange(N):
        for j in itertools.count():
            packet = frame[j * SLICE:(j + 1) * SLICE]
            if not packet:
                break
            parser.add(packet)
        while parser.canRead():
            parser.get()

コード例 #5

ファイル: parser_test.py プロジェクト: tobgu/stompest

 def test_dont_unescape_bad_characters(self):
     parser = StompParser(StompSpec.VERSION_1_2)
     frame = commands.send('*queue')
     parser.add(binaryType(frame))
     self.assertEqual(parser.get(), frame)
     for badCharacter in (b'\r', b'\n', b'\c', b'\\', b':', b'\\h'):
         self.assertRaises(StompFrameError, parser.add,
                           binaryType(frame).replace(b'*', badCharacter))
     self.assertRaises(StompFrameError, parser.add,
                       binaryType(commands.send('queue\\')))
     self.assertIsNone(parser.get())

コード例 #6

ファイル: frame_test.py プロジェクト: nikipore/stompest

    def test_non_string_headers(self):
        message = {'command': 'MESSAGE', 'headers': {123: 456}}
        frame = StompFrame(**message)
        self.assertEqual(frame.command, 'MESSAGE')
        self.assertEqual(frame.headers, {123: 456})
        self.assertEqual(dict(frame), {'command': 'MESSAGE', 'headers': {123: 456}})
        self.assertEqual(binaryType(frame), b'MESSAGE\n123:456\n\n\x00')

        message = {'command': 'MESSAGE', 'headers': {123: 456}}
        frame = StompFrame(**message)
        self.assertEqual(binaryType(frame), b'MESSAGE\n123:456\n\n\x00')
        self.assertEqual(eval(repr(frame)), frame)

コード例 #7

ファイル: parser_test.py プロジェクト: nikipore/stompest

    def test_reset_succeeds(self):
        frame = StompFrame(
            command=StompSpec.SEND,
            headers={'foo': 'bar', 'hello ': 'there-world with space ', 'empty-value':'', '':'empty-header', StompSpec.DESTINATION_HEADER: '/queue/blah'},
            body=b'some stuff\nand more'
        )
        parser = StompParser()

        parser.add(binaryType(frame))
        parser.reset()
        self.assertIsNone(parser.get())
        parser.add(binaryType(frame)[:20])
        self.assertIsNone(parser.get())

コード例 #8

    def test_receive_multiple_frames_extra_newlines(self):
        headers = {'x': 'y'}
        body = b'testing 1 2 3'
        frame = StompFrame(StompSpec.MESSAGE, headers, body)

        transport = self._get_receive_mock(b'\n\n' + binaryType(frame) + b'\n' + binaryType(frame) + b'\n')
        frame_ = transport.receive()
        self.assertEqual(frame, frame_)
        frame_ = transport.receive()
        self.assertEqual(frame, frame_)
        self.assertEqual(1, transport._socket.recv.call_count)

        self.assertRaises(StompConnectionError, transport.receive)
        self.assertEqual(transport._socket, None)

コード例 #9

ファイル: transport_test.py プロジェクト: tobgu/stompest

    def test_receive_multiple_frames_extra_newlines(self):
        headers = {'x': 'y'}
        body = b'testing 1 2 3'
        frame = StompFrame(StompSpec.MESSAGE, headers, body)

        transport = self._get_receive_mock(b'\n\n' + binaryType(frame) + b'\n' + binaryType(frame) + b'\n')
        frame_ = transport.receive()
        self.assertEqual(frame, frame_)
        frame_ = transport.receive()
        self.assertEqual(frame, frame_)
        self.assertEqual(1, transport._socket.recv.call_count)

        self.assertRaises(StompConnectionError, transport.receive)
        self.assertEqual(transport._socket, None)

コード例 #10

 def test_binary_body(self):
     body = b'\xf0\x00\x0a\x09'
     headers = {'content-length': str(len(body))}
     frame = StompFrame(StompSpec.MESSAGE, headers, body)
     self.assertEqual(frame.body, body)
     self.assertEqual(binaryType(frame),
                      b'MESSAGE\ncontent-length:4\n\n\xf0\x00\n\t\x00')

コード例 #11

    def test_encoding(self):
        key = b'fen\xc3\xaatre'.decode('utf-8')
        value = b'\xc2\xbfqu\xc3\xa9 tal?'.decode('utf-8')
        command = StompSpec.DISCONNECT
        message = {
            'command': command,
            'headers': {
                key: value
            },
            'version': StompSpec.VERSION_1_1
        }
        frame = StompFrame(**message)
        self.assertEqual(message['headers'], frame.headers)
        self.assertEqual(dict(frame), message)

        self.assertEqual(eval(repr(frame)), frame)
        frame.version = StompSpec.VERSION_1_1
        self.assertEqual(eval(repr(frame)), frame)
        expectedResult = (command + '\n' + key + ':' + value +
                          '\n\n\x00').encode('utf-8')
        self.assertEqual(binaryType(frame), expectedResult)

        otherFrame = StompFrame(**message)
        self.assertEqual(frame, otherFrame)

        frame.version = StompSpec.VERSION_1_0
        self.assertRaises(UnicodeEncodeError, binaryType, frame)

コード例 #12

ファイル: parser_test.py プロジェクト: tobgu/stompest

    def test_binary_body(self):
        body = b'\xf0\x00\x0a\x09'
        headers = {StompSpec.CONTENT_LENGTH_HEADER: textType(len(body))}
        frame = StompFrame(StompSpec.MESSAGE, body=body)
        frame.setContentLength()
        frameBytes = binaryType(frame)
        self.assertTrue(frameBytes.endswith(b'\x00'))
        parser = StompParser()
        for _ in range(2):
            for (j, _) in enumerate(frameBytes):
                parser.add(frameBytes[j:j + 1])
            frame = parser.get()
            self.assertEqual(StompSpec.MESSAGE, frame.command)
            self.assertEqual(headers, frame.headers)
            self.assertEqual(body, frame.body)
        self.assertEqual(parser.get(), None)

        frames = 2 * frameBytes
        split = len(frameBytes) - 1
        chunks = [frames[:split], frames[split:]]
        parser.add(chunks.pop(0))
        self.assertEqual(parser.get(), None)
        parser.add(chunks.pop(0))
        self.assertEqual(parser.get(), frame)
        self.assertEqual(parser.get(), frame)
        self.assertEqual(parser.get(), None)

        split = len(frameBytes) + 1
        chunks = [frames[:split], frames[split:]]
        parser.add(chunks.pop(0))
        self.assertEqual(parser.get(), frame)
        self.assertEqual(parser.get(), None)
        parser.add(chunks.pop(0))
        self.assertEqual(parser.get(), frame)
        self.assertEqual(parser.get(), None)

コード例 #13

ファイル: parser_test.py プロジェクト: nikipore/stompest

    def test_binary_body(self):
        body = b'\xf0\x00\x0a\x09'
        headers = {StompSpec.CONTENT_LENGTH_HEADER: textType(len(body))}
        frame = StompFrame(StompSpec.MESSAGE, body=body)
        frame.setContentLength()
        frameBytes = binaryType(frame)
        self.assertTrue(frameBytes.endswith(b'\x00'))
        parser = StompParser()
        for _ in range(2):
            for (j, _) in enumerate(frameBytes):
                parser.add(frameBytes[j:j + 1])
            frame = parser.get()
            self.assertEqual(StompSpec.MESSAGE, frame.command)
            self.assertEqual(headers, frame.headers)
            self.assertEqual(body, frame.body)
        self.assertEqual(parser.get(), None)

        frames = 2 * frameBytes
        split = len(frameBytes) - 1
        chunks = [frames[:split], frames[split:]]
        parser.add(chunks.pop(0))
        self.assertEqual(parser.get(), None)
        parser.add(chunks.pop(0))
        self.assertEqual(parser.get(), frame)
        self.assertEqual(parser.get(), frame)
        self.assertEqual(parser.get(), None)

        split = len(frameBytes) + 1
        chunks = [frames[:split], frames[split:]]
        parser.add(chunks.pop(0))
        self.assertEqual(parser.get(), frame)
        self.assertEqual(parser.get(), None)
        parser.add(chunks.pop(0))
        self.assertEqual(parser.get(), frame)
        self.assertEqual(parser.get(), None)

コード例 #14

    def test_send(self):
        frame = StompFrame(StompSpec.MESSAGE)

        transport = self._get_send_mock()
        transport.send(frame)
        self.assertEqual(1, transport._socket.sendall.call_count)
        args, _ = transport._socket.sendall.call_args
        self.assertEqual(binaryType(frame), args[0])

コード例 #15

ファイル: parser_test.py プロジェクト: nikipore/stompest

 def test_frames_with_optional_newlines_succeeds(self):
     parser = StompParser()
     disconnect = commands.disconnect()
     frame = b'\n' + binaryType(disconnect) + b'\n'
     parser.add(2 * frame)
     for _ in range(2):
         self.assertEqual(parser.get(), disconnect)
     self.assertIsNone(parser.get())

コード例 #16

ファイル: frame_test.py プロジェクト: nikipore/stompest

    def test_unescape(self):
        frameBytes = ("""%s
\\n\\\\:\\c\t\\n

\x00""" % StompSpec.DISCONNECT).encode()

        frame = StompFrame(command=StompSpec.DISCONNECT, headers={'\n\\': ':\t\n'}, version=StompSpec.VERSION_1_1)
        self.assertEqual(binaryType(frame), frameBytes)

        frameBytes = ("""%s
\\n\\\\:\\c\t\\r

\x00""" % StompSpec.DISCONNECT).encode()

        frame = StompFrame(command=StompSpec.DISCONNECT, headers={'\n\\': ':\t\r'}, version=StompSpec.VERSION_1_2)
        self.assertEqual(binaryType(frame), frameBytes)

        frameBytes = ("""%s
\\n\\\\:\\c\t\r

\x00""" % StompSpec.DISCONNECT).encode()

        frame = StompFrame(command=StompSpec.DISCONNECT, headers={'\n\\': ':\t\r'}, version=StompSpec.VERSION_1_1)
        self.assertEqual(binaryType(frame), frameBytes)

        frameBytes = ("""%s

\\::\t\r


\x00""" % StompSpec.DISCONNECT).encode()

        frame = StompFrame(command=StompSpec.DISCONNECT, headers={'\n\\': ':\t\r\n'}, version=StompSpec.VERSION_1_0)
        self.assertEqual(binaryType(frame), frameBytes)

        frameBytes = ("""%s

\\::\t\r


\x00""" % StompSpec.CONNECT).encode()

        frame = StompFrame(command=StompSpec.CONNECT, headers={'\n\\': ':\t\r\n'})
        for version in StompSpec.VERSIONS:
            frame.version = version
            self.assertEqual(binaryType(frame), frameBytes)

コード例 #17

ファイル: parser_test.py プロジェクト: tobgu/stompest

 def test_frames_with_optional_newlines_succeeds(self):
     parser = StompParser()
     disconnect = commands.disconnect()
     frame = b'\n' + binaryType(disconnect) + b'\n'
     parser.add(2 * frame)
     for _ in range(2):
         self.assertEqual(parser.get(), disconnect)
     self.assertIsNone(parser.get())

コード例 #18

    def test_send(self):
        frame = StompFrame(StompSpec.MESSAGE)

        transport = self._get_send_mock()
        transport.send(frame)
        self.assertEqual(1, transport._socket.sendall.call_count)
        args, _ = transport._socket.sendall.call_args
        self.assertEqual(binaryType(frame), args[0])

コード例 #19

ファイル: parser_test.py プロジェクト: nikipore/stompest

    def test_strip_line_delimiter(self):
        queue = '/queue/test'
        frame = commands.send(queue)
        frameWithStripLineDelimiter = commands.send(queue + '\r')
        for (version, stripLineDelimiter) in [
            (StompSpec.VERSION_1_0, False),
            (StompSpec.VERSION_1_1, False),
            (StompSpec.VERSION_1_2, True)
        ]:
            parser = StompParser(version)
            parser.add(binaryType(frameWithStripLineDelimiter))
            self.assertEqual(parser.get(), frame if stripLineDelimiter else frameWithStripLineDelimiter)

        frameWithCarriageReturn = commands.send(queue + '\r', version=StompSpec.VERSION_1_2)
        parser = StompParser(StompSpec.VERSION_1_2)
        parser.add(binaryType(frameWithCarriageReturn))
        self.assertEqual(parser.get().headers[StompSpec.DESTINATION_HEADER], queue + '\r')

コード例 #20

ファイル: parser_test.py プロジェクト: nikipore/stompest

 def test_binary_body_invalid_eof(self):
     parser = StompParser()
     body = b'MESSAGE\ncontent-length:4\n\n\xf0\x00\n\t\x00'
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)
     self.assertRaises(StompFrameError, parser.add, b'MESSAGE\ncontent-length:4\n\n\xf0\n\t\xff\x01\n\nCONNECT\n\x00') # \x00 behind invalid EOF
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)
     self.assertRaises(StompFrameError, parser.add, b'MESSAGE\ncontent-length:4\n\n\xf0\n\t\xff\x01\x00') # \x00 just behind invalid EOF
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)
     self.assertRaises(StompFrameError, parser.add, b'MESSAGE\ncontent-length:4\n\n\xf0\x00\n\t\x01') # \x00 before invalid EOF
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)
     self.assertRaises(StompFrameError, parser.add, b'MESSAGE\ncontent-length:4\n\n\xf0\n\t\x00\x01') # \x00 just before invalid EOF
     parser.add(body)
     self.assertEqual(binaryType(parser.get()), body)

コード例 #21

    def test_non_string_headers(self):
        message = {'command': 'MESSAGE', 'headers': {123: 456}}
        frame = StompFrame(**message)
        self.assertEqual(frame.command, 'MESSAGE')
        self.assertEqual(frame.headers, {123: 456})
        self.assertEqual(dict(frame), {
            'command': 'MESSAGE',
            'headers': {
                123: 456
            }
        })
        self.assertEqual(binaryType(frame), b'MESSAGE\n123:456\n\n\x00')

        message = {'command': 'MESSAGE', 'headers': {123: 456}}
        frame = StompFrame(**message)
        self.assertEqual(binaryType(frame), b'MESSAGE\n123:456\n\n\x00')
        self.assertEqual(eval(repr(frame)), frame)

コード例 #22

ファイル: parser_test.py プロジェクト: tobgu/stompest

    def test_reset_succeeds(self):
        frame = StompFrame(command=StompSpec.SEND,
                           headers={
                               'foo': 'bar',
                               'hello ': 'there-world with space ',
                               'empty-value': '',
                               '': 'empty-header',
                               StompSpec.DESTINATION_HEADER: '/queue/blah'
                           },
                           body=b'some stuff\nand more')
        parser = StompParser()

        parser.add(binaryType(frame))
        parser.reset()
        self.assertIsNone(parser.get())
        parser.add(binaryType(frame)[:20])
        self.assertIsNone(parser.get())

コード例 #23

ファイル: parser_test.py プロジェクト: nikipore/stompest

 def test_frames_with_heart_beats_succeeds(self):
     parser = StompParser(version=StompSpec.VERSION_1_1)
     disconnect = commands.disconnect()
     frame = b'\n' + binaryType(disconnect) + b'\n'
     parser.add(2 * frame)
     frames = []
     while parser.canRead():
         frames.append(parser.get())
     self.assertEqual(frames, [StompHeartBeat(), disconnect, StompHeartBeat(), StompHeartBeat(), disconnect, StompHeartBeat()])
     self.assertIsNone(parser.get())

コード例 #24

    def test_frame_without_headers_and_body(self):
        message = {'command': StompSpec.DISCONNECT}
        frame = StompFrame(**message)
        self.assertEqual(frame.headers, {})
        self.assertEqual(dict(frame), message)
        self.assertEqual(binaryType(frame), ("""\
%s

\x00""" % StompSpec.DISCONNECT).encode())
        self.assertEqual(eval(repr(frame)), frame)

コード例 #25

ファイル: parser_test.py プロジェクト: nikipore/stompest

    def test_add_multiple_frames_per_read(self):
        body1 = b'boo'
        body2 = b'hoo'
        headers = {'x': 'y'}
        frameBytes = binaryType(StompFrame(StompSpec.MESSAGE, headers, body1)) + binaryType(StompFrame(StompSpec.MESSAGE, headers, body2))
        parser = StompParser()
        parser.add(frameBytes)

        frame = parser.get()
        self.assertEqual(StompSpec.MESSAGE, frame.command)
        self.assertEqual(headers, frame.headers)
        self.assertEqual(body1, frame.body)

        frame = parser.get()
        self.assertEqual(StompSpec.MESSAGE, frame.command)
        self.assertEqual(headers, frame.headers)
        self.assertEqual(body2, frame.body)

        self.assertIsNone(parser.get())

コード例 #26

    def test_duplicate_headers(self):
        rawHeaders = (('foo', 'bar1'), ('foo', 'bar2'))
        headers = dict(reversed(rawHeaders))
        message = {
            'command': StompSpec.SEND,
            'body': b'some stuff\nand more',
            'rawHeaders': rawHeaders
        }
        frame = StompFrame(**message)
        self.assertEqual(frame.headers, headers)
        self.assertEqual(frame.rawHeaders, rawHeaders)
        rawFrame = b'SEND\nfoo:bar1\nfoo:bar2\n\nsome stuff\nand more\x00'
        self.assertEqual(binaryType(frame), rawFrame)

        frame.unraw()
        self.assertEqual(frame.headers, headers)
        self.assertEqual(frame.rawHeaders, None)
        rawFrame = b'SEND\nfoo:bar1\n\nsome stuff\nand more\x00'
        self.assertEqual(binaryType(frame), rawFrame)

コード例 #27

ファイル: frame_test.py プロジェクト: nikipore/stompest

    def test_frame_without_headers_and_body(self):
        message = {'command': StompSpec.DISCONNECT}
        frame = StompFrame(**message)
        self.assertEqual(frame.headers, {})
        self.assertEqual(dict(frame), message)
        self.assertEqual(binaryType(frame), ("""\
%s

\x00""" % StompSpec.DISCONNECT).encode())
        self.assertEqual(eval(repr(frame)), frame)

コード例 #28

ファイル: frame_test.py プロジェクト: nikipore/stompest

    def test_duplicate_headers(self):
        rawHeaders = (('foo', 'bar1'), ('foo', 'bar2'))
        headers = dict(reversed(rawHeaders))
        message = {
            'command': StompSpec.SEND,
            'body': b'some stuff\nand more',
            'rawHeaders': rawHeaders
        }
        frame = StompFrame(**message)
        self.assertEqual(frame.headers, headers)
        self.assertEqual(frame.rawHeaders, rawHeaders)
        rawFrame = b'SEND\nfoo:bar1\nfoo:bar2\n\nsome stuff\nand more\x00'
        self.assertEqual(binaryType(frame), rawFrame)

        frame.unraw()
        self.assertEqual(frame.headers, headers)
        self.assertEqual(frame.rawHeaders, None)
        rawFrame = b'SEND\nfoo:bar1\n\nsome stuff\nand more\x00'
        self.assertEqual(binaryType(frame), rawFrame)

コード例 #29

ファイル: parser_test.py プロジェクト: tobgu/stompest

    def test_strip_line_delimiter(self):
        queue = '/queue/test'
        frame = commands.send(queue)
        frameWithStripLineDelimiter = commands.send(queue + '\r')
        for (version, stripLineDelimiter) in [(StompSpec.VERSION_1_0, False),
                                              (StompSpec.VERSION_1_1, False),
                                              (StompSpec.VERSION_1_2, True)]:
            parser = StompParser(version)
            parser.add(binaryType(frameWithStripLineDelimiter))
            self.assertEqual(
                parser.get(),
                frame if stripLineDelimiter else frameWithStripLineDelimiter)

        frameWithCarriageReturn = commands.send(queue + '\r',
                                                version=StompSpec.VERSION_1_2)
        parser = StompParser(StompSpec.VERSION_1_2)
        parser.add(binaryType(frameWithCarriageReturn))
        self.assertEqual(parser.get().headers[StompSpec.DESTINATION_HEADER],
                         queue + '\r')

コード例 #30

ファイル: parser_test.py プロジェクト: nikipore/stompest

    def test_frame_parse_succeeds(self):
        frame = StompFrame(
            StompSpec.SEND,
            {'foo': 'bar', 'hello ': 'there-world with space ', 'empty-value':'', '':'empty-header', StompSpec.DESTINATION_HEADER: '/queue/blah'},
            b'some stuff\nand more'
        )

        parser = StompParser()
        parser.add(binaryType(frame))
        self.assertEqual(parser.get(), frame)
        self.assertIsNone(parser.get())

コード例 #31

ファイル: frame_test.py プロジェクト: nikipore/stompest

    def test_frame(self):
        message = {'command': StompSpec.SEND, 'headers': {StompSpec.DESTINATION_HEADER: '/queue/world'}, 'body': b'two\nlines'}
        frame = StompFrame(**message)
        self.assertEqual(message['headers'], frame.headers)
        self.assertEqual(dict(frame), message)
        self.assertEqual(binaryType(frame), ("""\
%s
%s:/queue/world

two
lines\x00""" % (StompSpec.SEND, StompSpec.DESTINATION_HEADER)).encode())
        self.assertEqual(eval(repr(frame)), frame)

コード例 #32

ファイル: parser_test.py プロジェクト: tobgu/stompest

 def test_no_newline(self):
     headers = {'x': 'y'}
     body = b'testing 1 2 3'
     frameBytes = binaryType(StompFrame(StompSpec.MESSAGE, headers, body))
     self.assertTrue(frameBytes.endswith(b'\x00'))
     parser = StompParser()
     parser.add(frameBytes)
     frame = parser.get()
     self.assertEqual(StompSpec.MESSAGE, frame.command)
     self.assertEqual(headers, frame.headers)
     self.assertEqual(body, frame.body)
     self.assertEqual(parser.get(), None)

コード例 #33

    def test_receive_binary(self):
        body = binascii.a2b_hex('f0000a09')
        headers = {StompSpec.CONTENT_LENGTH_HEADER: str(len(body))}
        frame = StompFrame(StompSpec.MESSAGE, headers, body)

        transport = self._get_receive_mock(binaryType(frame))
        frame_ = transport.receive()
        self.assertEqual(frame, frame_)
        self.assertEqual(1, transport._socket.recv.call_count)

        self.assertRaises(StompConnectionError, transport.receive)
        self.assertEqual(transport._socket, None)

コード例 #34

ファイル: parser_test.py プロジェクト: nikipore/stompest

 def test_no_newline(self):
     headers = {'x': 'y'}
     body = b'testing 1 2 3'
     frameBytes = binaryType(StompFrame(StompSpec.MESSAGE, headers, body))
     self.assertTrue(frameBytes.endswith(b'\x00'))
     parser = StompParser()
     parser.add(frameBytes)
     frame = parser.get()
     self.assertEqual(StompSpec.MESSAGE, frame.command)
     self.assertEqual(headers, frame.headers)
     self.assertEqual(body, frame.body)
     self.assertEqual(parser.get(), None)

コード例 #35

    def test_receive_binary(self):
        body = binascii.a2b_hex('f0000a09')
        headers = {StompSpec.CONTENT_LENGTH_HEADER: str(len(body))}
        frame = StompFrame(StompSpec.MESSAGE, headers, body)

        transport = self._get_receive_mock(binaryType(frame))
        frame_ = transport.receive()
        self.assertEqual(frame, frame_)
        self.assertEqual(1, transport._socket.recv.call_count)

        self.assertRaises(StompConnectionError, transport.receive)
        self.assertEqual(transport._socket, None)

コード例 #36

ファイル: parser_test.py プロジェクト: tobgu/stompest

    def test_add_multiple_frames_per_read(self):
        body1 = b'boo'
        body2 = b'hoo'
        headers = {'x': 'y'}
        frameBytes = binaryType(StompFrame(
            StompSpec.MESSAGE, headers, body1)) + binaryType(
                StompFrame(StompSpec.MESSAGE, headers, body2))
        parser = StompParser()
        parser.add(frameBytes)

        frame = parser.get()
        self.assertEqual(StompSpec.MESSAGE, frame.command)
        self.assertEqual(headers, frame.headers)
        self.assertEqual(body1, frame.body)

        frame = parser.get()
        self.assertEqual(StompSpec.MESSAGE, frame.command)
        self.assertEqual(headers, frame.headers)
        self.assertEqual(body2, frame.body)

        self.assertIsNone(parser.get())

コード例 #37

ファイル: transport_test.py プロジェクト: tobgu/stompest

    def test_receive_multiple_frames_per_read(self):
        body1 = b'boo'
        body2 = b'hoo'
        headers = {'x': 'y'}
        frameBytes = binaryType(StompFrame(StompSpec.MESSAGE, headers, body1)) + binaryType(StompFrame(StompSpec.MESSAGE, headers, body2))

        transport = self._get_receive_mock(frameBytes)

        frame = transport.receive()
        self.assertEqual(StompSpec.MESSAGE, frame.command)
        self.assertEqual(headers, frame.headers)
        self.assertEqual(body1, frame.body)
        self.assertEqual(1, transport._socket.recv.call_count)

        frame = transport.receive()
        self.assertEqual(StompSpec.MESSAGE, frame.command)
        self.assertEqual(headers, frame.headers)
        self.assertEqual(body2, frame.body)
        self.assertEqual(1, transport._socket.recv.call_count)

        self.assertRaises(StompConnectionError, transport.receive)
        self.assertEqual(transport._socket, None)

コード例 #38

ファイル: parser_test.py プロジェクト: nikipore/stompest

    def test_decode(self):
        key = b'fen\xc3\xaatre'.decode('utf-8')
        value = b'\xc2\xbfqu\xc3\xa9 tal?'.decode('utf-8')
        headers = {key: value}
        frameBytes = binaryType(StompFrame(command=StompSpec.DISCONNECT, headers=headers, version=StompSpec.VERSION_1_1))

        parser = StompParser(version=StompSpec.VERSION_1_1)
        parser.add(frameBytes)
        frame = parser.get()
        self.assertEqual(frame.headers, headers)

        parser = StompParser(version=StompSpec.VERSION_1_0)
        self.assertRaises(UnicodeDecodeError, parser.add, frameBytes)

コード例 #39

    def test_receive_multiple_frames_per_read(self):
        body1 = b'boo'
        body2 = b'hoo'
        headers = {'x': 'y'}
        frameBytes = binaryType(StompFrame(StompSpec.MESSAGE, headers, body1)) + binaryType(StompFrame(StompSpec.MESSAGE, headers, body2))

        transport = self._get_receive_mock(frameBytes)

        frame = transport.receive()
        self.assertEqual(StompSpec.MESSAGE, frame.command)
        self.assertEqual(headers, frame.headers)
        self.assertEqual(body1, frame.body)
        self.assertEqual(1, transport._socket.recv.call_count)

        frame = transport.receive()
        self.assertEqual(StompSpec.MESSAGE, frame.command)
        self.assertEqual(headers, frame.headers)
        self.assertEqual(body2, frame.body)
        self.assertEqual(1, transport._socket.recv.call_count)

        self.assertRaises(StompConnectionError, transport.receive)
        self.assertEqual(transport._socket, None)

コード例 #40

ファイル: parser_test.py プロジェクト: tobgu/stompest

    def test_frame_parse_succeeds(self):
        frame = StompFrame(
            StompSpec.SEND, {
                'foo': 'bar',
                'hello ': 'there-world with space ',
                'empty-value': '',
                '': 'empty-header',
                StompSpec.DESTINATION_HEADER: '/queue/blah'
            }, b'some stuff\nand more')

        parser = StompParser()
        parser.add(binaryType(frame))
        self.assertEqual(parser.get(), frame)
        self.assertIsNone(parser.get())

コード例 #41

ファイル: parser_test.py プロジェクト: tobgu/stompest

 def test_frames_with_heart_beats_succeeds(self):
     parser = StompParser(version=StompSpec.VERSION_1_1)
     disconnect = commands.disconnect()
     frame = b'\n' + binaryType(disconnect) + b'\n'
     parser.add(2 * frame)
     frames = []
     while parser.canRead():
         frames.append(parser.get())
     self.assertEqual(frames, [
         StompHeartBeat(), disconnect,
         StompHeartBeat(),
         StompHeartBeat(), disconnect,
         StompHeartBeat()
     ])
     self.assertIsNone(parser.get())

コード例 #42

ファイル: parser_test.py プロジェクト: tobgu/stompest

    def test_decode(self):
        key = b'fen\xc3\xaatre'.decode('utf-8')
        value = b'\xc2\xbfqu\xc3\xa9 tal?'.decode('utf-8')
        headers = {key: value}
        frameBytes = binaryType(
            StompFrame(command=StompSpec.DISCONNECT,
                       headers=headers,
                       version=StompSpec.VERSION_1_1))

        parser = StompParser(version=StompSpec.VERSION_1_1)
        parser.add(frameBytes)
        frame = parser.get()
        self.assertEqual(frame.headers, headers)

        parser = StompParser(version=StompSpec.VERSION_1_0)
        self.assertRaises(UnicodeDecodeError, parser.add, frameBytes)

コード例 #43

    def test_frame(self):
        message = {
            'command': StompSpec.SEND,
            'headers': {
                StompSpec.DESTINATION_HEADER: '/queue/world'
            },
            'body': b'two\nlines'
        }
        frame = StompFrame(**message)
        self.assertEqual(message['headers'], frame.headers)
        self.assertEqual(dict(frame), message)
        self.assertEqual(binaryType(frame), ("""\
%s
%s:/queue/world

two
lines\x00""" % (StompSpec.SEND, StompSpec.DESTINATION_HEADER)).encode())
        self.assertEqual(eval(repr(frame)), frame)

コード例 #44

ファイル: parser_test.py プロジェクト: tobgu/stompest

 def test_body_allowed_commands(self):
     head = binaryType(commands.disconnect()).rstrip(
         StompSpec.FRAME_DELIMITER.encode())
     for (version, bodyAllowed) in [(StompSpec.VERSION_1_0, True),
                                    (StompSpec.VERSION_1_1, False),
                                    (StompSpec.VERSION_1_2, False)]:
         parser = StompParser(version)
         parser.add(head)
         parser.add(b'ouch!')
         try:
             parser.add(StompSpec.FRAME_DELIMITER.encode())
         except StompFrameError:
             if bodyAllowed:
                 raise
         except:
             raise
         else:
             if not bodyAllowed:
                 raise

コード例 #45

ファイル: parser_test.py プロジェクト: nikipore/stompest

 def test_body_allowed_commands(self):
     head = binaryType(commands.disconnect()).rstrip(StompSpec.FRAME_DELIMITER.encode())
     for (version, bodyAllowed) in [
         (StompSpec.VERSION_1_0, True),
         (StompSpec.VERSION_1_1, False),
         (StompSpec.VERSION_1_2, False)
     ]:
         parser = StompParser(version)
         parser.add(head)
         parser.add(b'ouch!')
         try:
             parser.add(StompSpec.FRAME_DELIMITER.encode())
         except StompFrameError:
             if bodyAllowed:
                 raise
         except:
             raise
         else:
             if not bodyAllowed:
                 raise

コード例 #46

ファイル: frame_test.py プロジェクト: nikipore/stompest

    def test_encoding(self):
        key = b'fen\xc3\xaatre'.decode('utf-8')
        value = b'\xc2\xbfqu\xc3\xa9 tal?'.decode('utf-8')
        command = StompSpec.DISCONNECT
        message = {'command': command, 'headers': {key: value}, 'version': StompSpec.VERSION_1_1}
        frame = StompFrame(**message)
        self.assertEqual(message['headers'], frame.headers)
        self.assertEqual(dict(frame), message)

        self.assertEqual(eval(repr(frame)), frame)
        frame.version = StompSpec.VERSION_1_1
        self.assertEqual(eval(repr(frame)), frame)
        expectedResult = (command + '\n' + key + ':' + value + '\n\n\x00').encode('utf-8')
        self.assertEqual(binaryType(frame), expectedResult)

        otherFrame = StompFrame(**message)
        self.assertEqual(frame, otherFrame)

        frame.version = StompSpec.VERSION_1_0
        self.assertRaises(UnicodeEncodeError, binaryType, frame)

コード例 #47

ファイル: transport.py プロジェクト: luciddg/stompest

 def send(self, frame):
     self._write(binaryType(frame))

コード例 #48

ファイル: parser_test.py プロジェクト: nikipore/stompest

 def test_frame_without_header_or_body_succeeds(self):
     parser = StompParser()
     parser.add(binaryType(commands.disconnect()))
     self.assertEqual(parser.get(), commands.disconnect())

コード例 #49

ファイル: broker_simulator.py プロジェクト: nikipore/stompest

 def getFrame(self, command, headers, body):
     return binaryType(StompFrame(command, headers, body, version=self._parser.version))

コード例 #50

ファイル: frame.py プロジェクト: tobgu/stompest

 def __eq__(self, other):
     """Two frames are considered equal if, and only if, they render the same wire-level frame, that is, if their string representation is identical."""
     try:
         return binaryType(other) == binaryType(self)
     except:
         return False

コード例 #51

ファイル: parser_test.py プロジェクト: tobgu/stompest

 def test_frame_without_header_or_body_succeeds(self):
     parser = StompParser()
     parser.add(binaryType(commands.disconnect()))
     self.assertEqual(parser.get(), commands.disconnect())

コード例 #52

 def send(self, frame):
     if self.log.isEnabledFor(logging.DEBUG):
         self.log.debug('Sending %s' % frame.info())
     self.transport.write(binaryType(frame))

コード例 #53

ファイル: transport.py プロジェクト: nikipore/stompest

 def send(self, frame):
     self._write(binaryType(frame))

コード例 #54

ファイル: frame.py プロジェクト: nikipore/stompest

 def __eq__(self, other):
     """Two frames are considered equal if, and only if, they render the same wire-level frame, that is, if their string representation is identical."""
     try:
         return binaryType(other) == binaryType(self)
     except:
         return False

コード例 #55

ファイル: frame_test.py プロジェクト: nikipore/stompest

 def test_binary_body(self):
     body = b'\xf0\x00\x0a\x09'
     headers = {'content-length': str(len(body))}
     frame = StompFrame(StompSpec.MESSAGE, headers, body)
     self.assertEqual(frame.body, body)
     self.assertEqual(binaryType(frame), b'MESSAGE\ncontent-length:4\n\n\xf0\x00\n\t\x00')

コード例 #56

ファイル: broker_simulator.py プロジェクト: tobgu/stompest

 def getFrame(self, command, headers, body):
     return binaryType(
         StompFrame(command, headers, body, version=self._parser.version))

コード例 #57

ファイル: protocol.py プロジェクト: nikipore/stompest

 def send(self, frame):
     if self.log.isEnabledFor(logging.DEBUG):
         self.log.debug("Sending %s" % frame.info())
     self.transport.write(binaryType(frame))