The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#) https://grpc.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

472 lines
17 KiB

#!/usr/bin/env python2.7
# Copyright 2015 gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Generates the appropriate build.json data for all the end2end tests."""
load("//bazel:grpc_build_system.bzl", "grpc_cc_binary", "grpc_cc_library", "is_msvc")
POLLERS = ["epollex", "epoll1", "poll"]
def _fixture_options(
fullstack = True,
includes_proxy = False,
dns_resolver = True,
name_resolution = True,
secure = True,
tracing = False,
_platforms = ["windows", "linux", "mac", "posix"],
is_inproc = False,
is_http2 = True,
supports_proxy_auth = False,
supports_write_buffering = True,
client_channel = True,
supports_msvc = True,):
return struct(
fullstack = fullstack,
includes_proxy = includes_proxy,
dns_resolver = dns_resolver,
name_resolution = name_resolution,
secure = secure,
tracing = tracing,
is_inproc = is_inproc,
is_http2 = is_http2,
supports_proxy_auth = supports_proxy_auth,
supports_write_buffering = supports_write_buffering,
client_channel = client_channel,
supports_msvc = supports_msvc,
#_platforms=_platforms,
)
# maps fixture name to whether it requires the security library
END2END_FIXTURES = {
"h2_compress": _fixture_options(),
"h2_census": _fixture_options(),
# TODO(juanlishen): This is disabled for now, but should be considered to re-enable once we have
# decided how the load reporting service should be enabled.
#'h2_load_reporting': _fixture_options(),
"h2_fakesec": _fixture_options(),
"h2_fd": _fixture_options(
dns_resolver = False,
fullstack = False,
client_channel = False,
_platforms = ["linux", "mac", "posix"],
),
"h2_full": _fixture_options(),
"h2_full+pipe": _fixture_options(_platforms = ["linux"]),
"h2_full+trace": _fixture_options(tracing = True),
"h2_full+workarounds": _fixture_options(),
"h2_http_proxy": _fixture_options(supports_proxy_auth = True),
"h2_oauth2": _fixture_options(),
"h2_proxy": _fixture_options(includes_proxy = True),
"h2_sockpair_1byte": _fixture_options(
fullstack = False,
dns_resolver = False,
client_channel = False,
),
"h2_sockpair": _fixture_options(
fullstack = False,
dns_resolver = False,
client_channel = False,
),
"h2_sockpair+trace": _fixture_options(
fullstack = False,
dns_resolver = False,
tracing = True,
client_channel = False,
),
"h2_ssl": _fixture_options(secure = True),
"h2_local_uds": _fixture_options(secure = True, dns_resolver = False, _platforms = ["linux", "mac", "posix"]),
"h2_local_ipv4": _fixture_options(secure = True, dns_resolver = False, _platforms = ["linux", "mac", "posix"]),
"h2_local_ipv6": _fixture_options(secure = True, dns_resolver = False, _platforms = ["linux", "mac", "posix"]),
"h2_ssl_proxy": _fixture_options(includes_proxy = True, secure = True),
"h2_uds": _fixture_options(
dns_resolver = False,
_platforms = ["linux", "mac", "posix"],
),
"inproc": _fixture_options(
secure = True,
fullstack = False,
dns_resolver = False,
name_resolution = False,
is_inproc = True,
is_http2 = False,
supports_write_buffering = False,
client_channel = False,
),
}
# maps fixture name to whether it requires the security library
END2END_NOSEC_FIXTURES = {
"h2_compress": _fixture_options(secure = False),
"h2_census": _fixture_options(secure = False),
# TODO(juanlishen): This is disabled for now, but should be considered to re-enable once we have
# decided how the load reporting service should be enabled.
#'h2_load_reporting': _fixture_options(),
"h2_fakesec": _fixture_options(),
"h2_fd": _fixture_options(
dns_resolver = False,
fullstack = False,
client_channel = False,
secure = False,
_platforms = ["linux", "mac", "posix"],
supports_msvc = False,
),
"h2_full": _fixture_options(secure = False),
"h2_full+pipe": _fixture_options(secure = False, _platforms = ["linux"], supports_msvc = False),
"h2_full+trace": _fixture_options(secure = False, tracing = True, supports_msvc = False),
"h2_full+workarounds": _fixture_options(secure = False),
"h2_http_proxy": _fixture_options(secure = False, supports_proxy_auth = True),
"h2_proxy": _fixture_options(secure = False, includes_proxy = True),
"h2_sockpair_1byte": _fixture_options(
fullstack = False,
dns_resolver = False,
client_channel = False,
secure = False,
),
"h2_sockpair": _fixture_options(
fullstack = False,
dns_resolver = False,
client_channel = False,
secure = False,
),
"h2_sockpair+trace": _fixture_options(
fullstack = False,
dns_resolver = False,
tracing = True,
secure = False,
client_channel = False,
),
"h2_ssl": _fixture_options(secure = False),
"h2_ssl_proxy": _fixture_options(includes_proxy = True, secure = False),
"h2_uds": _fixture_options(
dns_resolver = False,
_platforms = ["linux", "mac", "posix"],
secure = False,
supports_msvc = False,
),
}
def _test_options(
needs_fullstack = False,
needs_dns = False,
needs_names = False,
proxyable = True,
secure = False,
traceable = False,
exclude_inproc = False,
needs_http2 = False,
needs_proxy_auth = False,
needs_write_buffering = False,
needs_client_channel = False):
return struct(
needs_fullstack = needs_fullstack,
needs_dns = needs_dns,
needs_names = needs_names,
proxyable = proxyable,
secure = secure,
traceable = traceable,
exclude_inproc = exclude_inproc,
needs_http2 = needs_http2,
needs_proxy_auth = needs_proxy_auth,
needs_write_buffering = needs_write_buffering,
needs_client_channel = needs_client_channel,
)
# maps test names to options
END2END_TESTS = {
"bad_hostname": _test_options(needs_names = True),
"bad_ping": _test_options(needs_fullstack = True, proxyable = False),
"binary_metadata": _test_options(),
"resource_quota_server": _test_options(proxyable = False),
"call_creds": _test_options(secure = True),
"call_host_override": _test_options(
needs_fullstack = True,
needs_dns = True,
needs_names = True,
),
"cancel_after_accept": _test_options(),
"cancel_after_client_done": _test_options(),
"cancel_after_invoke": _test_options(),
"cancel_after_round_trip": _test_options(),
"cancel_before_invoke": _test_options(),
"cancel_in_a_vacuum": _test_options(),
"cancel_with_status": _test_options(),
"compressed_payload": _test_options(proxyable = False, exclude_inproc = True),
"connectivity": _test_options(
needs_fullstack = True,
needs_names = True,
proxyable = False,
),
"channelz": _test_options(),
"default_host": _test_options(
needs_fullstack = True,
needs_dns = True,
needs_names = True,
),
"disappearing_server": _test_options(needs_fullstack = True, needs_names = True),
"empty_batch": _test_options(),
"filter_causes_close": _test_options(),
"filter_call_init_fails": _test_options(),
"filter_context": _test_options(),
"graceful_server_shutdown": _test_options(exclude_inproc = True),
"hpack_size": _test_options(
proxyable = False,
traceable = False,
exclude_inproc = True,
),
"high_initial_seqno": _test_options(),
"idempotent_request": _test_options(),
"invoke_large_request": _test_options(),
"keepalive_timeout": _test_options(proxyable = False, needs_http2 = True),
"large_metadata": _test_options(),
"max_concurrent_streams": _test_options(
proxyable = False,
exclude_inproc = True,
),
"max_connection_age": _test_options(exclude_inproc = True),
"max_connection_idle": _test_options(needs_fullstack = True, proxyable = False),
"max_message_length": _test_options(),
"negative_deadline": _test_options(),
"no_error_on_hotpath": _test_options(proxyable = False),
"no_logging": _test_options(traceable = False),
"no_op": _test_options(),
"payload": _test_options(),
# TODO(juanlishen): This is disabled for now because it depends on some generated functions in
# end2end_tests.cc, which are not generated because they would depend on OpenCensus while
# OpenCensus can only be built via Bazel so far.
# 'load_reporting_hook': _test_options(),
"ping_pong_streaming": _test_options(),
"ping": _test_options(needs_fullstack = True, proxyable = False),
"proxy_auth": _test_options(needs_proxy_auth = True),
"registered_call": _test_options(),
"request_with_flags": _test_options(proxyable = False),
"request_with_payload": _test_options(),
# TODO(roth): Remove proxyable=False for all retry tests once we
# have a way for the proxy to propagate the fact that trailing
# metadata is available when initial metadata is returned.
# See https://github.com/grpc/grpc/issues/14467 for context.
"retry": _test_options(needs_client_channel = True, proxyable = False),
"retry_cancellation": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_disabled": _test_options(needs_client_channel = True, proxyable = False),
"retry_exceeds_buffer_size_in_initial_batch": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_exceeds_buffer_size_in_subsequent_batch": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_non_retriable_status": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_non_retriable_status_before_recv_trailing_metadata_started": _test_options(needs_client_channel = True, proxyable = False),
"retry_recv_initial_metadata": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_recv_message": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_server_pushback_delay": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_server_pushback_disabled": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_streaming": _test_options(needs_client_channel = True, proxyable = False),
"retry_streaming_after_commit": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_streaming_succeeds_before_replay_finished": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_throttled": _test_options(
needs_client_channel = True,
proxyable = False,
),
"retry_too_many_attempts": _test_options(
needs_client_channel = True,
proxyable = False,
),
"server_finishes_request": _test_options(),
"shutdown_finishes_calls": _test_options(),
"shutdown_finishes_tags": _test_options(),
"simple_cacheable_request": _test_options(),
"simple_delayed_request": _test_options(needs_fullstack = True),
"simple_metadata": _test_options(),
"simple_request": _test_options(),
"streaming_error_response": _test_options(),
"stream_compression_compressed_payload": _test_options(
proxyable = False,
exclude_inproc = True,
),
"stream_compression_payload": _test_options(exclude_inproc = True),
"stream_compression_ping_pong_streaming": _test_options(exclude_inproc = True),
"trailing_metadata": _test_options(),
"authority_not_supported": _test_options(),
"filter_latency": _test_options(),
"filter_status_code": _test_options(),
"workaround_cronet_compression": _test_options(),
"write_buffering": _test_options(needs_write_buffering = True),
"write_buffering_at_end": _test_options(needs_write_buffering = True),
}
def _compatible(fopt, topt):
if is_msvc:
if not fopt.supports_msvc:
return False
if topt.needs_fullstack:
if not fopt.fullstack:
return False
if topt.needs_dns:
if not fopt.dns_resolver:
return False
if topt.needs_names:
if not fopt.name_resolution:
return False
if not topt.proxyable:
if fopt.includes_proxy:
return False
if not topt.traceable:
if fopt.tracing:
return False
if topt.exclude_inproc:
if fopt.is_inproc:
return False
if topt.needs_http2:
if not fopt.is_http2:
return False
if topt.needs_proxy_auth:
if not fopt.supports_proxy_auth:
return False
if topt.needs_write_buffering:
if not fopt.supports_write_buffering:
return False
if topt.needs_client_channel:
if not fopt.client_channel:
return False
return True
def grpc_end2end_tests():
grpc_cc_library(
name = "end2end_tests",
srcs = ["end2end_tests.cc", "end2end_test_utils.cc"] + [
"tests/%s.cc" % t
for t in sorted(END2END_TESTS.keys())
],
hdrs = [
"tests/cancel_test_helpers.h",
"end2end_tests.h",
],
language = "C++",
deps = [
":cq_verifier",
":ssl_test_data",
":http_proxy",
":proxy",
":local_util",
],
)
for f, fopt in END2END_FIXTURES.items():
grpc_cc_binary(
name = "%s_test" % f,
srcs = ["fixtures/%s.cc" % f],
language = "C++",
deps = [
":end2end_tests",
"//test/core/util:grpc_test_util",
"//:grpc",
"//:gpr",
],
)
for t, topt in END2END_TESTS.items():
#print(_compatible(fopt, topt), f, t, fopt, topt)
if not _compatible(fopt, topt):
continue
for poller in POLLERS:
native.sh_test(
name = "%s_test@%s@poller=%s" % (f, t, poller),
data = [":%s_test" % f],
srcs = ["end2end_test.sh"],
args = [
"$(location %s_test)" % f,
t,
poller,
],
)
def grpc_end2end_nosec_tests():
grpc_cc_library(
name = "end2end_nosec_tests",
srcs = ["end2end_nosec_tests.cc", "end2end_test_utils.cc"] + [
"tests/%s.cc" % t
for t in sorted(END2END_TESTS.keys())
if not END2END_TESTS[t].secure
],
hdrs = [
"tests/cancel_test_helpers.h",
"end2end_tests.h",
],
language = "C++",
deps = [
":cq_verifier",
":ssl_test_data",
":http_proxy",
":proxy",
":local_util",
],
)
for f, fopt in END2END_NOSEC_FIXTURES.items():
if fopt.secure:
continue
grpc_cc_binary(
name = "%s_nosec_test" % f,
srcs = ["fixtures/%s.cc" % f],
language = "C++",
deps = [
":end2end_nosec_tests",
"//test/core/util:grpc_test_util_unsecure",
"//:grpc_unsecure",
"//:gpr",
],
)
for t, topt in END2END_TESTS.items():
#print(_compatible(fopt, topt), f, t, fopt, topt)
if not _compatible(fopt, topt):
continue
if topt.secure:
continue
for poller in POLLERS:
native.sh_test(
name = "%s_nosec_test@%s@poller=%s" % (f, t, poller),
data = [":%s_nosec_test" % f],
srcs = ["end2end_test.sh"],
args = [
"$(location %s_nosec_test)" % f,
t,
poller,
],
)