Revert "[gprpp] Add ValidationErrors::message retrieval" (#32767)

Reverts grpc/grpc#32761

BUILD

@@ -2719,7 +2719,6 @@ grpc_cc_library(
         "//src/core:lib/service_config/service_config_impl.h",
     ],
     external_deps = [
-        "absl/status",
         "absl/status:statusor",
         "absl/strings",
         "absl/types:optional",

src/core/BUILD

@@ -3348,7 +3348,6 @@ grpc_cc_library(
     hdrs = ["lib/json/json_object_loader.h"],
     external_deps = [
         "absl/meta:type_traits",
-        "absl/status",
         "absl/status:statusor",
         "absl/strings",
         "absl/types:optional",

src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.cc

@@ -1026,7 +1026,6 @@ class OutlierDetectionLbFactory : public LoadBalancingPolicyFactory {
     }
     if (!errors.ok()) {
       return errors.status(
-          absl::StatusCode::kInvalidArgument,
           "errors validating outlier_detection LB policy config");
     }
     return MakeRefCounted<OutlierDetectionLbConfig>(outlier_detection_config,

src/core/ext/xds/xds_cluster.cc

@@ -656,10 +656,7 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
     }
   }
   // Return result.
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument,
-                         "errors validating Cluster resource");
-  }
+  if (!errors.ok()) return errors.status("errors validating Cluster resource");
   return cds_update;
 }
 

src/core/ext/xds/xds_endpoint.cc

@@ -432,10 +432,7 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
     }
   }
   // Return result.
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument,
-                         "errors parsing EDS resource");
-  }
+  if (!errors.ok()) return errors.status("errors parsing EDS resource");
   return eds_resource;
 }
 

src/core/ext/xds/xds_listener.cc

@@ -502,10 +502,7 @@ absl::StatusOr<XdsListenerResource> LdsResourceParseClient(
     lds_update.listener = HttpConnectionManagerParse(
         /*is_client=*/true, context, std::move(*extension), &errors);
   }
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument,
-                         "errors validating ApiListener");
-  }
+  if (!errors.ok()) return errors.status("errors validating ApiListener");
   return std::move(lds_update);
 }
 
@@ -1049,10 +1046,7 @@ absl::StatusOr<XdsListenerResource> LdsResourceParseServer(
     }
   }
   // Return result.
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument,
-                         "errors validating server Listener");
-  }
+  if (!errors.ok()) return errors.status("errors validating server Listener");
   XdsListenerResource lds_update;
   lds_update.listener = std::move(tcp_listener);
   return lds_update;

src/core/ext/xds/xds_route_config.cc

@@ -1125,8 +1125,7 @@ XdsResourceType::DecodeResult XdsRouteConfigResourceType::Decode(
   auto rds_update = XdsRouteConfigResource::Parse(context, resource, &errors);
   if (!errors.ok()) {
     absl::Status status =
-        errors.status(absl::StatusCode::kInvalidArgument,
-                      "errors validating RouteConfiguration resource");
+        errors.status("errors validating RouteConfiguration resource");
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_ERROR, "[xds_client %p] invalid RouteConfiguration %s: %s",
               context.client, result.name->c_str(), status.ToString().c_str());

src/core/lib/gprpp/validation_errors.cc

@@ -42,14 +42,8 @@ bool ValidationErrors::FieldHasErrors() const {
   return field_errors_.find(absl::StrJoin(fields_, "")) != field_errors_.end();
 }
 
-absl::Status ValidationErrors::status(absl::StatusCode code,
-                                      absl::string_view prefix) const {
+absl::Status ValidationErrors::status(absl::string_view prefix) const {
   if (field_errors_.empty()) return absl::OkStatus();
-  return absl::Status(code, message(prefix));
-}
-
-std::string ValidationErrors::message(absl::string_view prefix) const {
-  if (field_errors_.empty()) return "";
   std::vector<std::string> errors;
   for (const auto& p : field_errors_) {
     if (p.second.size() > 1) {
@@ -60,7 +54,8 @@ std::string ValidationErrors::message(absl::string_view prefix) const {
           absl::StrCat("field:", p.first, " error:", p.second[0]));
     }
   }
-  return absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]");
+  return absl::InvalidArgumentError(
+      absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]"));
 }
 
 }  // namespace grpc_core

src/core/lib/gprpp/validation_errors.h

@@ -58,8 +58,7 @@ namespace grpc_core {
 //       }
 //     }
 //   }
-//   return errors.status(absl::StatusCode::kInvalidArgument,
-//                        "errors validating foo.bar");
+//   return errors.status("errors validating foo.bar");
 // }
 class ValidationErrors {
  public:
@@ -101,13 +100,7 @@ class ValidationErrors {
   bool FieldHasErrors() const GPR_ATTRIBUTE_NOINLINE;
 
   // Returns the resulting status of parsing.
-  // If there are no errors, this will return an Ok status instead of using the
-  // prefix argument.
-  absl::Status status(absl::StatusCode code, absl::string_view prefix) const;
-
-  // Returns the resulting error message
-  // If there are no errors, this will return an empty string.
-  std::string message(absl::string_view prefix) const;
+  absl::Status status(absl::string_view prefix) const;
 
   // Returns true if there are no errors.
   bool ok() const { return field_errors_.empty(); }

src/core/lib/json/json_object_loader.h

@@ -26,7 +26,6 @@
 #include <vector>
 
 #include "absl/meta/type_traits.h"
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -590,9 +589,7 @@ absl::StatusOr<T> LoadFromJson(
   ValidationErrors errors;
   T result{};
   json_detail::LoaderForType<T>()->LoadInto(json, args, &result, &errors);
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument, error_prefix);
-  }
+  if (!errors.ok()) return errors.status(error_prefix);
   return std::move(result);
 }
 
@@ -603,9 +600,7 @@ absl::StatusOr<RefCountedPtr<T>> LoadRefCountedFromJson(
   ValidationErrors errors;
   auto result = MakeRefCounted<T>();
   json_detail::LoaderForType<T>()->LoadInto(json, args, result.get(), &errors);
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument, error_prefix);
-  }
+  if (!errors.ok()) return errors.status(error_prefix);
   return std::move(result);
 }
 

src/core/lib/service_config/service_config_impl.cc

@@ -23,7 +23,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
@@ -88,10 +87,7 @@ absl::StatusOr<RefCountedPtr<ServiceConfig>> ServiceConfigImpl::Create(
   if (!json.ok()) return json.status();
   ValidationErrors errors;
   auto service_config = Create(args, *json, json_string, &errors);
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument,
-                         "errors validating service config");
-  }
+  if (!errors.ok()) return errors.status("errors validating service config");
   return service_config;
 }
 

test/core/gprpp/validation_errors_test.cc

@@ -34,8 +34,7 @@ TEST(ValidationErrors, NoErrors) {
   }
   EXPECT_TRUE(errors.ok());
   EXPECT_EQ(errors.size(), 0);
-  absl::Status status = errors.status(absl::StatusCode::kInvalidArgument,
-                                      "errors validating config");
+  absl::Status status = errors.status("errors validating config");
   EXPECT_TRUE(status.ok()) << status;
 }
 
@@ -50,8 +49,7 @@ TEST(ValidationErrors, OneError) {
   }
   EXPECT_FALSE(errors.ok());
   EXPECT_EQ(errors.size(), 1);
-  absl::Status status = errors.status(absl::StatusCode::kInvalidArgument,
-                                      "errors validating config");
+  absl::Status status = errors.status("errors validating config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -71,8 +69,7 @@ TEST(ValidationErrors, MultipleErrorsForSameField) {
   }
   EXPECT_FALSE(errors.ok());
   EXPECT_EQ(errors.size(), 1);
-  absl::Status status = errors.status(absl::StatusCode::kInvalidArgument,
-                                      "errors validating config");
+  absl::Status status = errors.status("errors validating config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating config: [field:foo.bar errors:["
@@ -92,8 +89,7 @@ TEST(ValidationErrors, ErrorsForMultipleFields) {
   }
   EXPECT_FALSE(errors.ok());
   EXPECT_EQ(errors.size(), 2);
-  absl::Status status = errors.status(absl::StatusCode::kInvalidArgument,
-                                      "errors validating config");
+  absl::Status status = errors.status("errors validating config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating config: ["
@@ -101,25 +97,6 @@ TEST(ValidationErrors, ErrorsForMultipleFields) {
       << status;
 }
 
-TEST(ValidationErrors, MessageMatchesStatusMessage) {
-  ValidationErrors errors;
-  {
-    ValidationErrors::ScopedField field(&errors, "foo");
-    {
-      ValidationErrors::ScopedField field(&errors, ".bar");
-      errors.AddError("value smells funny");
-    }
-    errors.AddError("too hot");
-  }
-  EXPECT_FALSE(errors.ok());
-  EXPECT_EQ(errors.size(), 2);
-  absl::Status status = errors.status(absl::StatusCode::kInvalidArgument,
-                                      "errors validating config");
-  std::string message = errors.message("errors validating config");
-  EXPECT_EQ(status.message(), message)
-      << status << " does not match " << message;
-}
-
 }  // namespace
 }  // namespace testing
 }  // namespace grpc_core

test/core/json/json_object_loader_test.cc

@@ -1095,8 +1095,7 @@ TEST(JsonObjectLoader, LoadFromJsonWithValidationErrors) {
     ValidationErrors errors;
     TestStruct test_struct =
         LoadFromJson<TestStruct>(*json, JsonArgs(), &errors);
-    ASSERT_TRUE(errors.ok()) << errors.status(
-        absl::StatusCode::kInvalidArgument, "unexpected errors");
+    ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
     EXPECT_EQ(test_struct.a, 1);
   }
   // Invalid.
@@ -1106,8 +1105,7 @@ TEST(JsonObjectLoader, LoadFromJsonWithValidationErrors) {
     ASSERT_TRUE(json.ok()) << json.status();
     ValidationErrors errors;
     LoadFromJson<TestStruct>(*json, JsonArgs(), &errors);
-    absl::Status status = errors.status(absl::StatusCode::kInvalidArgument,
-                                        "errors validating JSON");
+    absl::Status status = errors.status("errors validating JSON");
     EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
     EXPECT_EQ(status.message(),
               "errors validating JSON: [field:a error:failed to parse number]")
@@ -1124,8 +1122,7 @@ TEST(JsonObjectLoader, LoadJsonObjectField) {
     ValidationErrors errors;
     auto value = LoadJsonObjectField<int32_t>(json->object(), JsonArgs(), "int",
                                               &errors);
-    ASSERT_TRUE(value.has_value()) << errors.status(
-        absl::StatusCode::kInvalidArgument, "unexpected errors");
+    ASSERT_TRUE(value.has_value()) << errors.status("unexpected errors");
     EXPECT_EQ(*value, 1);
     EXPECT_TRUE(errors.ok());
   }
@@ -1144,8 +1141,7 @@ TEST(JsonObjectLoader, LoadJsonObjectField) {
     auto value = LoadJsonObjectField<int32_t>(json->object(), JsonArgs(),
                                               "not_present", &errors);
     EXPECT_FALSE(value.has_value());
-    auto status = errors.status(absl::StatusCode::kInvalidArgument,
-                                "errors validating JSON");
+    auto status = errors.status("errors validating JSON");
     EXPECT_THAT(status.code(), absl::StatusCode::kInvalidArgument);
     EXPECT_EQ(status.message(),
               "errors validating JSON: ["
@@ -1158,8 +1154,7 @@ TEST(JsonObjectLoader, LoadJsonObjectField) {
     auto value = LoadJsonObjectField<std::string>(json->object(), JsonArgs(),
                                                   "int", &errors);
     EXPECT_FALSE(value.has_value());
-    auto status = errors.status(absl::StatusCode::kInvalidArgument,
-                                "errors validating JSON");
+    auto status = errors.status("errors validating JSON");
     EXPECT_THAT(status.code(), absl::StatusCode::kInvalidArgument);
     EXPECT_EQ(status.message(),
               "errors validating JSON: [field:int error:is not a string]")

test/core/xds/xds_common_types_test.cc

@@ -128,8 +128,7 @@ TEST_F(DurationTest, Basic) {
   google_protobuf_Duration_set_nanos(duration_proto, 2000000);
   ValidationErrors errors;
   Duration duration = ParseDuration(duration_proto, &errors);
-  EXPECT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  EXPECT_TRUE(errors.ok()) << errors.status("unexpected errors");
   EXPECT_EQ(duration, Duration::Milliseconds(1002));
 }
 
@@ -140,8 +139,7 @@ TEST_F(DurationTest, NegativeNumbers) {
   google_protobuf_Duration_set_nanos(duration_proto, -2);
   ValidationErrors errors;
   ParseDuration(duration_proto, &errors);
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation failed");
+  absl::Status status = errors.status("validation failed");
   EXPECT_EQ(status.message(),
             "validation failed: ["
             "field:nanos error:value must be in the range [0, 999999999]; "
@@ -156,8 +154,7 @@ TEST_F(DurationTest, ValuesTooHigh) {
   google_protobuf_Duration_set_nanos(duration_proto, 1000000000);
   ValidationErrors errors;
   ParseDuration(duration_proto, &errors);
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation failed");
+  absl::Status status = errors.status("validation failed");
   EXPECT_EQ(status.message(),
             "validation failed: ["
             "field:nanos error:value must be in the range [0, 999999999]; "
@@ -199,10 +196,7 @@ class CommonTlsConfigTest : public XdsCommonTypesTest {
     ValidationErrors errors;
     CommonTlsContext common_tls_context =
         CommonTlsContext::Parse(decode_context_, upb_proto, &errors);
-    if (!errors.ok()) {
-      return errors.status(absl::StatusCode::kInvalidArgument,
-                           "validation failed");
-    }
+    if (!errors.ok()) return errors.status("validation failed");
     return common_tls_context;
   }
 };
@@ -551,8 +545,7 @@ TEST_F(ExtractXdsExtensionTest, Basic) {
   google_protobuf_Any_set_value(any_proto, StdStringToUpbString(kValue));
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ASSERT_TRUE(extension.has_value());
   EXPECT_EQ(extension->type, "MyType");
   ASSERT_TRUE(absl::holds_alternative<absl::string_view>(extension->value));
@@ -573,8 +566,7 @@ TEST_F(ExtractXdsExtensionTest, TypedStruct) {
                                 StdStringToUpbString(serialized_typed_struct));
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ASSERT_TRUE(extension.has_value());
   EXPECT_EQ(extension->type, "MyType");
   ASSERT_TRUE(absl::holds_alternative<Json>(extension->value));
@@ -595,8 +587,7 @@ TEST_F(ExtractXdsExtensionTest, UdpaTypedStruct) {
                                 StdStringToUpbString(serialized_typed_struct));
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ASSERT_TRUE(extension.has_value());
   EXPECT_EQ(extension->type, "MyType");
   ASSERT_TRUE(absl::holds_alternative<Json>(extension->value));
@@ -615,8 +606,7 @@ TEST_F(ExtractXdsExtensionTest, TypedStructWithoutValue) {
                                 StdStringToUpbString(serialized_typed_struct));
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ASSERT_TRUE(extension.has_value());
   EXPECT_EQ(extension->type, "MyType");
   ASSERT_TRUE(absl::holds_alternative<Json>(extension->value));
@@ -673,8 +663,7 @@ TEST_F(ExtractXdsExtensionTest, TypedStructJsonConversion) {
                                 StdStringToUpbString(serialized_typed_struct));
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ASSERT_TRUE(extension.has_value());
   EXPECT_EQ(extension->type, "envoy.ExtensionType");
   ASSERT_TRUE(absl::holds_alternative<Json>(extension->value));
@@ -693,8 +682,7 @@ TEST_F(ExtractXdsExtensionTest, FieldMissing) {
   ValidationErrors::ScopedField field(&errors, "any");
   auto extension = ExtractXdsExtension(decode_context_, nullptr, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: [field:any error:field not present]")
@@ -706,8 +694,7 @@ TEST_F(ExtractXdsExtensionTest, TypeUrlMissing) {
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: [field:type_url error:field not present]")
@@ -728,8 +715,7 @@ TEST_F(ExtractXdsExtensionTest, TypedStructTypeUrlMissing) {
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: ["
@@ -745,8 +731,7 @@ TEST_F(ExtractXdsExtensionTest, TypeUrlNoSlash) {
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: ["
@@ -769,8 +754,7 @@ TEST_F(ExtractXdsExtensionTest, TypedStructTypeUrlNoSlash) {
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: ["
@@ -786,8 +770,7 @@ TEST_F(ExtractXdsExtensionTest, TypeUrlNothingAfterSlash) {
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: ["
@@ -810,8 +793,7 @@ TEST_F(ExtractXdsExtensionTest, TypedStructTypeUrlNothingAfterSlash) {
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: ["
@@ -831,8 +813,7 @@ TEST_F(ExtractXdsExtensionTest, TypedStructParseFailure) {
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: ["
@@ -855,8 +836,7 @@ TEST_F(ExtractXdsExtensionTest, TypedStructWithInvalidProtobufStruct) {
   ValidationErrors errors;
   auto extension = ExtractXdsExtension(decode_context_, any_proto, &errors);
   ASSERT_FALSE(errors.ok());
-  absl::Status status =
-      errors.status(absl::StatusCode::kInvalidArgument, "validation errors");
+  absl::Status status = errors.status("validation errors");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "validation errors: ["

test/core/xds/xds_http_filters_test.cc

@@ -180,8 +180,7 @@ TEST_F(XdsRouterFilterTest, GenerateFilterConfig) {
   XdsExtension extension = MakeXdsExtension(Router());
   auto config = filter_->GenerateFilterConfig(decode_context_,
                                               std::move(extension), &errors_);
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name, filter_->ConfigProtoName());
   EXPECT_EQ(config->config, Json()) << JsonDump(config->config);
@@ -192,8 +191,7 @@ TEST_F(XdsRouterFilterTest, GenerateFilterConfigTypedStruct) {
   extension.value = Json();
   auto config = filter_->GenerateFilterConfig(decode_context_,
                                               std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -209,8 +207,7 @@ TEST_F(XdsRouterFilterTest, GenerateFilterConfigUnparseable) {
   extension.value = absl::string_view(serialized_resource);
   auto config = filter_->GenerateFilterConfig(decode_context_,
                                               std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -224,8 +221,7 @@ TEST_F(XdsRouterFilterTest, GenerateFilterConfigOverride) {
   XdsExtension extension = MakeXdsExtension(Router());
   auto config = filter_->GenerateFilterConfigOverride(
       decode_context_, std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -312,8 +308,7 @@ INSTANTIATE_TEST_SUITE_P(XdsFaultFilter, XdsFaultInjectionFilterConfigTest,
 TEST_P(XdsFaultInjectionFilterConfigTest, EmptyConfig) {
   XdsExtension extension = MakeXdsExtension(HTTPFault());
   auto config = GenerateConfig(std::move(extension));
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name, filter_->ConfigProtoName());
   EXPECT_EQ(config->config, Json(Json::Object())) << JsonDump(config->config);
@@ -332,8 +327,7 @@ TEST_P(XdsFaultInjectionFilterConfigTest, BasicConfig) {
   fault.mutable_max_active_faults()->set_value(10);
   XdsExtension extension = MakeXdsExtension(fault);
   auto config = GenerateConfig(std::move(extension));
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name, filter_->ConfigProtoName());
   EXPECT_EQ(JsonDump(config->config),
@@ -352,8 +346,7 @@ TEST_P(XdsFaultInjectionFilterConfigTest, HttpAbortCode) {
   abort->set_http_status(404);
   XdsExtension extension = MakeXdsExtension(fault);
   auto config = GenerateConfig(std::move(extension));
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name, filter_->ConfigProtoName());
   EXPECT_EQ(JsonDump(config->config), "{\"abortCode\":\"UNIMPLEMENTED\"}");
@@ -365,8 +358,7 @@ TEST_P(XdsFaultInjectionFilterConfigTest, HeaderAbortAndDelay) {
   fault.mutable_delay()->mutable_header_delay();
   XdsExtension extension = MakeXdsExtension(fault);
   auto config = GenerateConfig(std::move(extension));
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name, filter_->ConfigProtoName());
   EXPECT_EQ(
@@ -383,8 +375,7 @@ TEST_P(XdsFaultInjectionFilterConfigTest, InvalidGrpcStatusCode) {
   fault.mutable_abort()->set_grpc_status(17);
   XdsExtension extension = MakeXdsExtension(fault);
   auto config = GenerateConfig(std::move(extension));
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating filter config: ["
@@ -399,8 +390,7 @@ TEST_P(XdsFaultInjectionFilterConfigTest, InvalidDuration) {
   fault.mutable_delay()->mutable_fixed_delay()->set_seconds(315576000001);
   XdsExtension extension = MakeXdsExtension(fault);
   auto config = GenerateConfig(std::move(extension));
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating filter config: ["
@@ -414,8 +404,7 @@ TEST_P(XdsFaultInjectionFilterConfigTest, TypedStruct) {
   XdsExtension extension = MakeXdsExtension(HTTPFault());
   extension.value = Json();
   auto config = GenerateConfig(std::move(extension));
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating filter config: ["
@@ -429,8 +418,7 @@ TEST_P(XdsFaultInjectionFilterConfigTest, Unparseable) {
   std::string serialized_resource("\0", 1);
   extension.value = absl::string_view(serialized_resource);
   auto config = GenerateConfig(std::move(extension));
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating filter config: ["
@@ -476,8 +464,7 @@ TEST_F(XdsRbacFilterTest, GenerateFilterConfig) {
   XdsExtension extension = MakeXdsExtension(RBAC());
   auto config = filter_->GenerateFilterConfig(decode_context_,
                                               std::move(extension), &errors_);
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name, filter_->ConfigProtoName());
   EXPECT_EQ(config->config, Json(Json::Object())) << JsonDump(config->config);
@@ -488,8 +475,7 @@ TEST_F(XdsRbacFilterTest, GenerateFilterConfigTypedStruct) {
   extension.value = Json();
   auto config = filter_->GenerateFilterConfig(decode_context_,
                                               std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -505,8 +491,7 @@ TEST_F(XdsRbacFilterTest, GenerateFilterConfigUnparseable) {
   extension.value = absl::string_view(serialized_resource);
   auto config = filter_->GenerateFilterConfig(decode_context_,
                                               std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -520,8 +505,7 @@ TEST_F(XdsRbacFilterTest, GenerateFilterConfigOverride) {
   XdsExtension extension = MakeXdsExtension(RBACPerRoute());
   auto config = filter_->GenerateFilterConfigOverride(
       decode_context_, std::move(extension), &errors_);
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name, filter_->OverrideConfigProtoName());
   EXPECT_EQ(config->config, Json(Json::Object())) << JsonDump(config->config);
@@ -532,8 +516,7 @@ TEST_F(XdsRbacFilterTest, GenerateFilterConfigOverrideTypedStruct) {
   extension.value = Json();
   auto config = filter_->GenerateFilterConfigOverride(
       decode_context_, std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating filter config: ["
@@ -548,8 +531,7 @@ TEST_F(XdsRbacFilterTest, GenerateFilterConfigOverrideUnparseable) {
   extension.value = absl::string_view(serialized_resource);
   auto config = filter_->GenerateFilterConfigOverride(
       decode_context_, std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating filter config: ["
@@ -590,8 +572,7 @@ INSTANTIATE_TEST_SUITE_P(XdsRbacFilter, XdsRbacFilterConfigTest,
 
 TEST_P(XdsRbacFilterConfigTest, EmptyConfig) {
   auto config = GenerateConfig(RBAC());
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name,
             GetParam() ? filter_->OverrideConfigProtoName()
@@ -677,8 +658,7 @@ TEST_P(XdsRbacFilterConfigTest, AllPermissionTypes) {
   // or
   policy.add_permissions()->mutable_or_rules()->add_rules()->set_any(true);
   auto config = GenerateConfig(rbac);
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name,
             GetParam() ? filter_->OverrideConfigProtoName()
@@ -804,8 +784,7 @@ TEST_P(XdsRbacFilterConfigTest, AllPrincipalTypes) {
   // or
   policy.add_principals()->mutable_or_ids()->add_ids()->set_any(true);
   auto config = GenerateConfig(rbac);
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name,
             GetParam() ? filter_->OverrideConfigProtoName()
@@ -855,8 +834,7 @@ TEST_P(XdsRbacFilterConfigTest, InvalidFieldsInPolicy) {
   policy.mutable_condition();
   policy.mutable_checked_condition();
   auto config = GenerateConfig(rbac);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             absl::StrCat("errors validating filter config: ["
@@ -885,8 +863,7 @@ TEST_P(XdsRbacFilterConfigTest, InvalidHeaderMatchers) {
   header = policy.add_principals()->mutable_header();
   header->set_name("header_name");
   auto config = GenerateConfig(rbac);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -914,8 +891,7 @@ TEST_P(XdsRbacFilterConfigTest, InvalidStringMatchers) {
   policy.add_permissions()->mutable_url_path()->mutable_path();
   policy.add_principals()->mutable_url_path();
   auto config = GenerateConfig(rbac);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -939,8 +915,7 @@ TEST_P(XdsRbacFilterConfigTest, InvalidPermissionAndPrincipal) {
   policy.add_permissions();
   policy.add_principals();
   auto config = GenerateConfig(rbac);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             absl::StrCat("errors validating filter config: ["
@@ -1009,8 +984,7 @@ TEST_F(XdsStatefulSessionFilterTest, OverrideConfigDisabled) {
   XdsExtension extension = MakeXdsExtension(stateful_session_per_route);
   auto config = filter_->GenerateFilterConfigOverride(
       decode_context_, std::move(extension), &errors_);
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name, filter_->OverrideConfigProtoName());
   EXPECT_EQ(config->config, Json(Json::Object{})) << JsonDump(config->config);
@@ -1041,8 +1015,7 @@ TEST_F(XdsStatefulSessionFilterTest, GenerateFilterConfigTypedStruct) {
   extension.value = Json();
   auto config = filter_->GenerateFilterConfig(decode_context_,
                                               std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -1059,8 +1032,7 @@ TEST_F(XdsStatefulSessionFilterTest, GenerateFilterConfigUnparseable) {
   extension.value = absl::string_view(serialized_resource);
   auto config = filter_->GenerateFilterConfig(decode_context_,
                                               std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -1076,8 +1048,7 @@ TEST_F(XdsStatefulSessionFilterTest, GenerateFilterConfigOverrideTypedStruct) {
   extension.value = Json();
   auto config = filter_->GenerateFilterConfigOverride(
       decode_context_, std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating filter config: ["
@@ -1094,8 +1065,7 @@ TEST_F(XdsStatefulSessionFilterTest, GenerateFilterConfigOverrideUnparseable) {
   extension.value = absl::string_view(serialized_resource);
   auto config = filter_->GenerateFilterConfigOverride(
       decode_context_, std::move(extension), &errors_);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(status.message(),
             "errors validating filter config: ["
@@ -1145,8 +1115,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, MinimalConfig) {
   stateful_session.mutable_session_state()->mutable_typed_config()->PackFrom(
       cookie_state);
   auto config = GenerateConfig(stateful_session);
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name,
             GetParam() ? filter_->OverrideConfigProtoName()
@@ -1165,8 +1134,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, PathAndTtl) {
   stateful_session.mutable_session_state()->mutable_typed_config()->PackFrom(
       cookie_state);
   auto config = GenerateConfig(stateful_session);
-  ASSERT_TRUE(errors_.ok()) << errors_.status(
-      absl::StatusCode::kInvalidArgument, "unexpected errors");
+  ASSERT_TRUE(errors_.ok()) << errors_.status("unexpected errors");
   ASSERT_TRUE(config.has_value());
   EXPECT_EQ(config->config_proto_type_name,
             GetParam() ? filter_->OverrideConfigProtoName()
@@ -1181,8 +1149,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, PathAndTtl) {
 
 TEST_P(XdsStatefulSessionFilterConfigTest, SessionStateUnset) {
   auto config = GenerateConfig(StatefulSession());
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   ASSERT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -1196,8 +1163,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, CookieNotPresent) {
   stateful_session.mutable_session_state()->mutable_typed_config()->PackFrom(
       CookieBasedSessionState());
   auto config = GenerateConfig(stateful_session);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   ASSERT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -1216,8 +1182,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, CookieNameNotPresent) {
   stateful_session.mutable_session_state()->mutable_typed_config()->PackFrom(
       cookie_state);
   auto config = GenerateConfig(stateful_session);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   ASSERT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -1238,8 +1203,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, InvalidTtl) {
   stateful_session.mutable_session_state()->mutable_typed_config()->PackFrom(
       cookie_state);
   auto config = GenerateConfig(stateful_session);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   ASSERT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -1256,8 +1220,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, UnknownSessionStateType) {
   stateful_session.mutable_session_state()->mutable_typed_config()->PackFrom(
       Router());
   auto config = GenerateConfig(stateful_session);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   ASSERT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -1277,8 +1240,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, TypedStructSessionState) {
   typed_struct.set_type_url(typed_config->type_url());
   typed_config->PackFrom(typed_struct);
   auto config = GenerateConfig(stateful_session);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   ASSERT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),
@@ -1298,8 +1260,7 @@ TEST_P(XdsStatefulSessionFilterConfigTest, UnparseableSessionState) {
   stateful_session.mutable_session_state()->mutable_typed_config()->set_value(
       std::string("\0", 1));
   auto config = GenerateConfig(stateful_session);
-  absl::Status status = errors_.status(absl::StatusCode::kInvalidArgument,
-                                       "errors validating filter config");
+  absl::Status status = errors_.status("errors validating filter config");
   ASSERT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
   EXPECT_EQ(
       status.message(),

test/core/xds/xds_lb_policy_registry_test.cc

@@ -84,10 +84,7 @@ absl::StatusOr<std::string> ConvertXdsPolicy(
   ValidationErrors::ScopedField field(&errors, ".load_balancing_policy");
   auto config = XdsLbPolicyRegistry().ConvertXdsLbPolicyConfig(
       context, upb_policy, &errors);
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument,
-                         "validation errors");
-  }
+  if (!errors.ok()) return errors.status("validation errors");
   EXPECT_EQ(config.size(), 1);
   return JsonDump(Json{config[0]});
 }

test/cpp/ext/gcp/observability_config_test.cc

@@ -68,8 +68,7 @@ TEST(GcpObservabilityConfigJsonParsingTest, Basic) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ASSERT_TRUE(config.cloud_logging.has_value());
   ASSERT_EQ(config.cloud_logging->client_rpc_events.size(), 2);
   EXPECT_THAT(config.cloud_logging->client_rpc_events[0].qualified_methods,
@@ -110,8 +109,7 @@ TEST(GcpObservabilityConfigJsonParsingTest, Defaults) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   EXPECT_FALSE(config.cloud_logging.has_value());
   EXPECT_FALSE(config.cloud_monitoring.has_value());
   EXPECT_FALSE(config.cloud_trace.has_value());
@@ -134,8 +132,7 @@ TEST(GcpObservabilityConfigJsonParsingTest, LoggingConfigMethodIllegalSlashes) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  EXPECT_THAT(errors.status(absl::StatusCode::kInvalidArgument, "Parsing error")
-                  .ToString(),
+  EXPECT_THAT(errors.status("Parsing error").ToString(),
               ::testing::AllOf(
                   ::testing::HasSubstr(
                       "field:cloud_logging.client_rpc_events[0].methods[0]"
@@ -161,8 +158,7 @@ TEST(GcpObservabilityConfigJsonParsingTest, LoggingConfigEmptyMethod) {
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
   EXPECT_THAT(
-      errors.status(absl::StatusCode::kInvalidArgument, "Parsing error")
-          .ToString(),
+      errors.status("Parsing error").ToString(),
       ::testing::HasSubstr("field:cloud_logging.client_rpc_events[0].methods[0]"
                            " error:Empty configuration"));
 }
@@ -187,8 +183,7 @@ TEST(GcpObservabilityConfigJsonParsingTest, LoggingConfigWildcardEntries) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ASSERT_TRUE(config.cloud_logging.has_value());
   ASSERT_EQ(config.cloud_logging->client_rpc_events.size(), 1);
   EXPECT_THAT(config.cloud_logging->client_rpc_events[0].qualified_methods,
@@ -220,8 +215,7 @@ TEST(GcpObservabilityConfigJsonParsingTest,
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
   EXPECT_THAT(
-      errors.status(absl::StatusCode::kInvalidArgument, "Parsing error")
-          .ToString(),
+      errors.status("Parsing error").ToString(),
       ::testing::AllOf(
           ::testing::HasSubstr(
               "field:cloud_logging.client_rpc_events[0].methods[0]"
@@ -245,8 +239,7 @@ TEST(GcpObservabilityConfigJsonParsingTest, SamplingRateDefaults) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ASSERT_TRUE(config.cloud_trace.has_value());
   EXPECT_FLOAT_EQ(config.cloud_trace->sampling_rate, 0.05);
 }

test/cpp/ext/gcp/observability_logging_sink_test.cc

@@ -42,8 +42,7 @@ TEST(GcpObservabilityLoggingSinkTest, LoggingConfigEmpty) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_FALSE(sink.FindMatch(true, "foo", "bar").ShouldLog());
@@ -68,8 +67,7 @@ TEST(GcpObservabilityLoggingSinkTest, LoggingConfigClientWildCardEntries) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_EQ(sink.FindMatch(true, "foo", "bar"),
@@ -95,8 +93,7 @@ TEST(GcpObservabilityLoggingSinkTest, LoggingConfigBadPath) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   EXPECT_FALSE(sink.FindMatch(true, "foo", "").ShouldLog());
 }
@@ -119,8 +116,7 @@ TEST(GcpObservabilityLoggingSinkTest,
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_EQ(sink.FindMatch(true, "service", "bar"),
@@ -149,8 +145,7 @@ TEST(GcpObservabilityLoggingSinkTest,
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_EQ(sink.FindMatch(true, "foo", "bar"),
@@ -184,8 +179,7 @@ TEST(GcpObservabilityLoggingSinkTest, LoggingConfigClientMultipleEventEntries) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_EQ(sink.FindMatch(true, "foo", "bar"),
@@ -213,8 +207,7 @@ TEST(GcpObservabilityLoggingSinkTest, LoggingConfigServerWildCardEntries) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_FALSE(sink.FindMatch(true, "foo", "bar").ShouldLog());
@@ -241,8 +234,7 @@ TEST(GcpObservabilityLoggingSinkTest,
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_FALSE(sink.FindMatch(true, "service", "bar").ShouldLog());
@@ -271,8 +263,7 @@ TEST(GcpObservabilityLoggingSinkTest,
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_FALSE(sink.FindMatch(true, "foo", "bar").ShouldLog());
@@ -306,8 +297,7 @@ TEST(GcpObservabilityLoggingSinkTest, LoggingConfigServerMultipleEventEntries) {
   grpc_core::ValidationErrors errors;
   auto config = grpc_core::LoadFromJson<GcpObservabilityConfig>(
       *json, grpc_core::JsonArgs(), &errors);
-  ASSERT_TRUE(errors.ok()) << errors.status(absl::StatusCode::kInvalidArgument,
-                                            "unexpected errors");
+  ASSERT_TRUE(errors.ok()) << errors.status("unexpected errors");
   ObservabilityLoggingSink sink(config.cloud_logging.value(), "test", {});
   // client test
   EXPECT_FALSE(sink.FindMatch(true, "foo", "bar").ShouldLog());