Python tutils.raises函数代码示例

def test_client_greeting_assert_socks5():
    raw = tutils.treader("\x00\x00")
    msg = socks.ClientGreeting.from_file(raw)
    tutils.raises(socks.SocksError, msg.assert_socks5)

    raw = tutils.treader("HTTP/1.1 200 OK" + " " * 100)
    msg = socks.ClientGreeting.from_file(raw)
    try:
        msg.assert_socks5()
    except socks.SocksError as e:
        assert "Invalid SOCKS version" in str(e)
        assert "HTTP" not in str(e)
    else:
        assert False

    raw = tutils.treader("GET / HTTP/1.1" + " " * 100)
    msg = socks.ClientGreeting.from_file(raw)
    try:
        msg.assert_socks5()
    except socks.SocksError as e:
        assert "Invalid SOCKS version" in str(e)
        assert "HTTP" in str(e)
    else:
        assert False

    raw = tutils.treader("XX")
    tutils.raises(
        socks.SocksError,
        socks.ClientGreeting.from_file,
        raw,
        fail_early=True)

def test_always_bytes():
    assert strutils.always_bytes(bytes(bytearray(range(256)))) == bytes(bytearray(range(256)))
    assert strutils.always_bytes("foo") == b"foo"
    with tutils.raises(ValueError):
        strutils.always_bytes(u"\u2605", "ascii")
    with tutils.raises(TypeError):
        strutils.always_bytes(42, "ascii")

def test_settings_frame_to_bytes():
    f = SettingsFrame(
        length=0,
        flags=Frame.FLAG_NO_FLAGS,
        stream_id=0x0)
    assert f.to_bytes().encode('hex') == '000000040000000000'

    f = SettingsFrame(
        length=0,
        flags=SettingsFrame.FLAG_ACK,
        stream_id=0x0)
    assert f.to_bytes().encode('hex') == '000000040100000000'

    f = SettingsFrame(
        length=6,
        flags=SettingsFrame.FLAG_ACK,
        stream_id=0x0,
        settings={
            SettingsFrame.SETTINGS.SETTINGS_ENABLE_PUSH: 1})
    assert f.to_bytes().encode('hex') == '000006040100000000000200000001'

    f = SettingsFrame(
        length=12,
        flags=Frame.FLAG_NO_FLAGS,
        stream_id=0x0,
        settings={
            SettingsFrame.SETTINGS.SETTINGS_ENABLE_PUSH: 1,
            SettingsFrame.SETTINGS.SETTINGS_MAX_CONCURRENT_STREAMS: 0x12345678})
    assert f.to_bytes().encode('hex') == '00000c040000000000000200000001000312345678'

    f = SettingsFrame(
        length=0,
        flags=Frame.FLAG_NO_FLAGS,
        stream_id=0x1234567)
    tutils.raises(ValueError, f.to_bytes)

def test_too_large_frames():
    f = DataFrame(
        length=9000,
        flags=Frame.FLAG_END_STREAM,
        stream_id=0x1234567,
        payload='foobar' * 3000)
    tutils.raises(FrameSizeError, f.to_bytes)

    def test_ignore(self):
        spec = '304:h"Alternate-Protocol"="mitmproxy-will-remove-this"'
        n = self.pathod(spec)
        self._ignore_on()
        i = self.pathod(spec)
        i2 = self.pathod(spec)
        self._ignore_off()

        assert i.status_code == i2.status_code == n.status_code == 304
        assert "Alternate-Protocol" in i.headers
        assert "Alternate-Protocol" in i2.headers
        assert "Alternate-Protocol" not in n.headers

        # Test that we get the original SSL cert
        if self.ssl:
            i_cert = SSLCert(i.sslinfo.certchain[0])
            i2_cert = SSLCert(i2.sslinfo.certchain[0])
            n_cert = SSLCert(n.sslinfo.certchain[0])

            assert i_cert == i2_cert
            assert i_cert != n_cert

        # Test Non-HTTP traffic
        spec = "200:i0,@100:d0"  # this results in just 100 random bytes
        # mitmproxy responds with bad gateway
        assert self.pathod(spec).status_code == 502
        self._ignore_on()
        tutils.raises(
            "invalid server response",
            self.pathod,
            spec)  # pathoc tries to parse answer as HTTP
        self._ignore_off()

def test_options():
    o = TO(two="three")
    assert o.keys() == set(["one", "two"])

    assert o.one is None
    assert o.two == "three"
    o.one = "one"
    assert o.one == "one"

    with tutils.raises(TypeError):
        TO(nonexistent = "value")
    with tutils.raises("no such option"):
        o.nonexistent = "value"
    with tutils.raises("no such option"):
        o.update(nonexistent = "value")

    rec = []

    def sub(opts, updated):
        rec.append(copy.copy(opts))

    o.changed.connect(sub)

    o.one = "ninety"
    assert len(rec) == 1
    assert rec[-1].one == "ninety"

    o.update(one="oink")
    assert len(rec) == 2
    assert rec[-1].one == "oink"

 def test_reader_read_error(self):
     s = cStringIO.StringIO("foobar\nfoobar")
     s = tcp.Reader(s)
     o = mock.MagicMock()
     o.read = mock.MagicMock(side_effect=socket.error)
     s.o = o
     tutils.raises(tcp.NetLibDisconnect, s.read, 10)

 def test_writer_flush_error(self):
     s = cStringIO.StringIO()
     s = tcp.Writer(s)
     o = mock.MagicMock()
     o.flush = mock.MagicMock(side_effect=socket.error)
     s.o = o
     tutils.raises(tcp.NetLibDisconnect, s.flush)

    def test_legacy_first_line(self):
        req = tutils.treq()

        assert req.legacy_first_line('relative') == "GET /path HTTP/1.1"
        assert req.legacy_first_line('authority') == "GET address:22 HTTP/1.1"
        assert req.legacy_first_line('absolute') == "GET http://address:22/path HTTP/1.1"
        tutils.raises(http.HttpError, req.legacy_first_line, 'foobar')

def test_too_large_frames():
    f = DataFrame(
        length=9000,
        flags=Frame.FLAG_END_STREAM,
        stream_id=0x1234567,
        payload='foobar' * 3000)
    tutils.raises(HttpSyntaxException, f.to_bytes)

def test_priority_frame_to_bytes():
    f = PriorityFrame(
        length=5,
        flags=(Frame.FLAG_NO_FLAGS),
        stream_id=0x1234567,
        exclusive=True,
        stream_dependency=0x0,
        weight=42)
    assert_equal(f.to_bytes().encode('hex'), '000005020001234567800000002a')

    f = PriorityFrame(
        length=5,
        flags=(Frame.FLAG_NO_FLAGS),
        stream_id=0x1234567,
        exclusive=False,
        stream_dependency=0x7654321,
        weight=21)
    assert_equal(f.to_bytes().encode('hex'), '0000050200012345670765432115')

    f = PriorityFrame(
        length=5,
        flags=Frame.FLAG_NO_FLAGS,
        stream_id=0x0,
        stream_dependency=0x1234567)
    tutils.raises(ValueError, f.to_bytes)

    def test_replay(self):
        o = dump.Options(server_replay=["nonexistent"], kill=True)
        tutils.raises(dump.DumpError, dump.DumpMaster, None, o)

        with tutils.tmpdir() as t:
            p = os.path.join(t, "rep")
            self.flowfile(p)

            o = dump.Options(server_replay=[p], kill=True)
            o.verbosity = 0
            o.flow_detail = 0
            m = dump.DumpMaster(None, o)

            self.cycle(m, b"content")
            self.cycle(m, b"content")

            o = dump.Options(server_replay=[p], kill=False)
            o.verbosity = 0
            o.flow_detail = 0
            m = dump.DumpMaster(None, o)
            self.cycle(m, b"nonexistent")

            o = dump.Options(client_replay=[p], kill=False)
            o.verbosity = 0
            o.flow_detail = 0
            m = dump.DumpMaster(None, o)

def test_invalid_flags():
    tutils.raises(
        ValueError,
        DataFrame,
        flags=ContinuationFrame.FLAG_END_HEADERS,
        stream_id=0x1234567,
        payload='foobar')

def test_push_promise_frame_to_bytes():
    f = PushPromiseFrame(
        length=10,
        flags=Frame.FLAG_NO_FLAGS,
        stream_id=0x1234567,
        promised_stream=0x7654321,
        header_block_fragment='foobar')
    assert_equal(
        f.to_bytes().encode('hex'),
        '00000a05000123456707654321666f6f626172')

    f = PushPromiseFrame(
        length=14,
        flags=HeadersFrame.FLAG_PADDED,
        stream_id=0x1234567,
        promised_stream=0x7654321,
        header_block_fragment='foobar',
        pad_length=3)
    assert_equal(
        f.to_bytes().encode('hex'),
        '00000e0508012345670307654321666f6f626172000000')

    f = PushPromiseFrame(
        length=4,
        flags=Frame.FLAG_NO_FLAGS,
        stream_id=0x0,
        promised_stream=0x1234567)
    tutils.raises(ValueError, f.to_bytes)

    f = PushPromiseFrame(
        length=4,
        flags=Frame.FLAG_NO_FLAGS,
        stream_id=0x1234567,
        promised_stream=0x0)
    tutils.raises(ValueError, f.to_bytes)

def test_bidi():
    b = utils.BiDi(a=1, b=2)
    assert b.a == 1
    assert b.get_name(1) == "a"
    assert b.get_name(5) is None
    tutils.raises(AttributeError, getattr, b, "c")
    tutils.raises(ValueError, utils.BiDi, one=1, two=1)