def test_inherited_method_names(tmpdir):
    thrift_file = tmpdir.join('service.thrift')
    thrift_file.write('''
        service Base { string hello() }
        service Foo extends Base {}
        service Bar extends Base {}
    ''')

    service = thrift.load(str(thrift_file), 'myservice')

    server = TChannel('server')

    @server.thrift.register(service.Foo, method='hello')
    def foo_hello(request):
        return 'foo'

    @server.thrift.register(service.Bar, method='hello')
    def bar_hello(request):
        return 'bar'

    server.listen()

    client = TChannel('client')

    res = yield client.thrift(service.Foo.hello(), hostport=server.hostport)
    assert res.body == 'foo'

    res = yield client.thrift(service.Bar.hello(), hostport=server.hostport)
    assert res.body == 'bar'

def test_service_inheritance(tmpdir):
    path = tmpdir.join('myservice.thrift')
    path.write('''
        service Base { bool healthy() }

        service MyService extends Base {
            i32 getValue()
        }
    ''')
    service = thrift.load(str(path), service='myservice')

    server = TChannel('server')
    server.listen()

    @server.thrift.register(service.MyService)
    def getValue(request):
        return 42

    @server.thrift.register(service.MyService)
    def healthy(request):
        return True

    client = TChannel('client', known_peers=[server.hostport])

    response = yield client.thrift(service.MyService.getValue())
    assert response.body == 42

    response = yield client.thrift(service.MyService.healthy())
    assert response.body is True

def test_thriftrw_client_without_service_or_hostport_specified():
    client = thrift.load(
        'tests/data/idls/ThriftTest.thrift',
    )

    with pytest.raises(ValueError):
        client.ThriftTest.testVoid()

def test_service_inheritance_with_import(tmpdir):
    tmpdir.join('shared/base.thrift').write(
        'service Base { bool healthy() }', ensure=True
    )

    inherited = tmpdir.join('myservice.thrift')
    inherited.write('''
        include "./shared/base.thrift"

        service MyService extends base.Base {
            i32 getValue()
        }
    ''')

    service = thrift.load(str(inherited), service='myservice')

    server = TChannel('server')

    @server.thrift.register(service.MyService)
    def getValue(request):
        return 42

    @server.thrift.register(service.MyService)
    def healthy(request):
        return True

    server.listen()

    client = TChannel('client', known_peers=[server.hostport])

    response = yield client.thrift(service.MyService.getValue())
    assert response.body == 42

    response = yield client.thrift(service.MyService.healthy())
    assert response.body is True

def test_thriftrw_client_with_service_or_hostport_specified(hostport, service):
    client = thrift.load(
        'tests/data/idls/ThriftTest.thrift',
        hostport=hostport,
        service=service,
    )

    assert client.ThriftTest.testVoid()

def thrift_module(tmpdir, request):
    thrift_file = tmpdir.join('service.thrift')
    thrift_file.write('''
        service Service {
            bool healthy()
        }
    ''')
    return thrift.load(str(thrift_file), request.node.name)

def client_ttypes(use_thriftrw_client):
    """Provides access to generated types for the server."""

    if use_thriftrw_client:
        return thrift.load(
            path='tests/data/idls/ThriftTest.thrift',
        )
    else:
        return _ttypes

def ThriftTest(use_thriftrw_server):
    """Used by servers to register endpoints for ThriftTest."""

    if use_thriftrw_server:
        return thrift.load(
            'tests/data/idls/ThriftTest.thrift',
        ).ThriftTest
    else:
        return _ThriftTest

def SecondService(use_thriftrw_server):
    """Used by servers to register endpoints for SecondService."""

    if use_thriftrw_server:
        return thrift.load(
            'tests/data/idls/ThriftTest.thrift',
        ).SecondService
    else:
        return _SecondService

def request_thrift(tchannel, hostport):
    ThriftTest = thrift.load(
        path='tests/data/idls/ThriftTest.thrift',
        service='server',
    ).SecondService

    return tchannel.thrift(
        ThriftTest.blahBlah(),
        hostport=hostport,
    )

def register_thrift(tchannel):

    ThriftTest = thrift.load(
        path='tests/data/idls/ThriftTest.thrift',
        service='server',
    ).SecondService

    @tchannel.thrift.register(ThriftTest)
    def hello(request):
        return

def test_default_checksum_type():
    server = TChannel("server")
    server.listen()
    with mock.patch("tchannel.messages.common.compute_checksum", autospec=True) as mock_compute_checksum:
        client = TChannel("client")
        service = thrift.load(
            path="tchannel/health/meta.thrift", service="health_test_server", hostport=server.hostport
        )
        with pytest.raises(FatalProtocolError):
            yield client.thrift(service.Meta.health())

        mock_compute_checksum.assert_called_with(ChecksumType.crc32c, mock.ANY, mock.ANY)

def thrift_service(tmpdir):
    thrift_file = tmpdir.join('service.thrift')
    thrift_file.write('''
        service X {
          string thrift1(1: string hostport), // calls thrift2()
          string thrift2(),
          string thrift3(1: string hostport)  // calls http
          string thrift4(1: string hostport)  // calls raw
        }
    ''')

    return thrift.load(str(thrift_file), 'test-service')

def keyvalue(tmpdir):
    path = tmpdir.join('keyvalue.thrift')
    path.write('''
        exception ItemDoesNotExist {
            1: optional string key
        }

        service KeyValue {
            string getItem(1: string key)
                throws (1: ItemDoesNotExist doesNotExist)
        }
    ''')

    return thrift.load(str(path), service='keyvalue')

def second_service(server, use_thriftrw_client):
    """Used by clients to build requests to SecondService."""

    if use_thriftrw_client:
        return thrift.load(
            path='tests/data/idls/ThriftTest.thrift',
            service='server',
            hostport=server.hostport,
        ).SecondService
    else:
        return thrift_request_builder(
            service='server',
            thrift_module=_SecondService,
            hostport=server.hostport,
        )

def test_default_health():
    server = TChannel("health_test_server")
    server.listen()

    client = TChannel("health_test_client")

    service = thrift.load(
        path='tchannel/health/meta.thrift',
        service='health_test_server',
        hostport=server.hostport,
    )

    resp = yield client.thrift(service.Meta.health())
    assert resp.body.ok is True
    assert resp.body.message is None

def test_routing_delegate_is_propagated_thrift(tmpdir):
    tmpdir.join('service.thrift').write('service Service { bool healthy() }')
    thrift_module = thrift.load(str(tmpdir.join('service.thrift')),
                                service='service')

    server = TChannel('server')
    server.listen()

    @server.thrift.register(thrift_module.Service)
    def healthy(request):
        assert request.transport.routing_delegate == 'delegate'
        return True

    client = TChannel('client', known_peers=[server.hostport])
    res = yield client.thrift(
        thrift_module.Service.healthy(), routing_delegate='delegate'
    )
    assert res.body is True

def test_user_health():
    server = TChannel("health_test_server")

    @server.thrift.register(Meta, method="health")
    def user_health(request):
        return HealthStatus(ok=False, message="from me")

    server.listen()

    client = TChannel("health_test_client")
    service = thrift.load(
        path='tchannel/health/meta.thrift',
        service='health_test_server',
        hostport=server.hostport,
    )

    resp = yield client.thrift(service.Meta.health())
    assert resp.body.ok is False
    assert resp.body.message == "from me"

    def real_call_downstream_tchannel(self, span, trace_request, trace_response, response_writer):

        def handle_response(f):
            response = f.result()
            trace_response.downstream = response.body

            response_writer.write(serializer.obj_to_json(trace_response))
            response_writer.finish()

        downstream = trace_request.downstream
        # XXX cache these
        service = thrift.load(idl_path, service=downstream.serviceName)

        jtr = JoinTraceRequest(trace_request.serverRole, downstream.downstream)
        jtr = join_trace_request_to_thriftrw(service, jtr)
        # with context.RequestContext(span):
        with context.request_context(span):
            f = tchannel.thrift(service.TracedService.joinTrace(jtr),
                                hostport="%s:%s" % (downstream.host, downstream.port))
        tornado.ioloop.IOLoop.current().add_future(f, handle_response)

def test_req_body_is_wire_compat_with_tchannel(service):
    args = {
        'string_thing': 'hi',
        'byte_thing': 1,
        'i32_thing': -1,
        'i64_thing': -34359738368,
    }

    # serialize object using yarpc's thrift.load
    xtruct = service.Xtruct(**args)
    req_body = service.ThriftTest.testStruct(xtruct)
    wire = req_body.__thrift_module__.dumps(req_body)  # non-enveloped

    # now serialize using tchannel's thrift.load
    tch_service = tch_thrift.load(idl, service='...', hostport='...')
    tch_xtruct = tch_service.Xtruct(**args)
    tch_req_body = tch_service.ThriftTest.testStruct(tch_xtruct)
    tch_serializer = tch_req_body.get_serializer()
    tch_wire = tch_serializer.serialize_body(tch_req_body.call_args)

    assert wire == tch_wire