impl: a manual test for ProtoJSON conformance (#2339)

Automating this test will take some doing, the driver is in the Protobuf repository and it is implemented in C++.

Author: coryan

.sidekick.toml

@@ -28,6 +28,9 @@ protobuf-src-extracted-name = 'protobuf-29.3'
 protobuf-src-root           = 'https://github.com/protocolbuffers/protobuf/releases/download/v29.3/protobuf-29.3.tar.gz'
 protobuf-src-sha256         = '008a11cc56f9b96679b4c285fd05f46d317d685be3ab524b2a310be0fbad987e'
 protobuf-src-subdir         = 'src'
+conformance-extracted-name  = 'protobuf-29.3'
+conformance-root            = 'https://github.com/protocolbuffers/protobuf/releases/download/v29.3/protobuf-29.3.tar.gz'
+conformance-sha256          = '008a11cc56f9b96679b4c285fd05f46d317d685be3ab524b2a310be0fbad987e'
 
 [codec]
 # The default version for all crates. This can be overridden in the crate's

Cargo.lock

@@ -29,6 +29,7 @@ default-members = [
   "src/gax-internal",
   "src/integration-tests",
   "src/lro",
+  "src/protojson-conformance",
   "src/pubsub",
   "src/root",
   "src/spanner",
@@ -250,6 +251,7 @@ members = [
   "src/generated/type",
   "src/integration-tests",
   "src/lro",
+  "src/protojson-conformance",
   "src/pubsub",
   "src/root",
   "src/spanner",

Cargo.toml

@@ -0,0 +1,35 @@
+# Copyright 2025 Google LLC
+#
+# 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
+#
+#     https://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.
+
+[package]
+description       = "Google Cloud client libraries for Rust: ProtoJSON conformance"
+edition.workspace = true
+name              = "protojson-conformance"
+publish           = false
+version           = "0.0.0"
+
+[dependencies]
+anyhow.workspace      = true
+bytes.workspace       = true
+crc32c.workspace      = true
+futures.workspace     = true
+prost.workspace       = true
+prost-types.workspace = true
+serde.workspace       = true
+serde_json.workspace  = true
+serde_with.workspace  = true
+tokio.workspace       = true
+# Local dependencies
+wkt.workspace = true
+gaxi          = { workspace = true, features = ["_internal-grpc-client"] }

src/protojson-conformance/Cargo.toml

@@ -0,0 +1,54 @@
+# Google Cloud client libraries for Rust: ProtoJSON conformance
+
+This directory contains a test to verify the client libraries follow the
+[ProtoJSON] specification.
+
+The conformance test is a Rust binary, it accepts serialized messages from its
+stdin, and returns serialized messages in stdout. A driver in the
+[Protocol Buffers repository] exercises the conformance test by providing
+specific inputs and validating the output.
+
+## Compiling the conformance test
+
+In this guide we will assume you used `$HOME/rust-conformance` to build the
+conformance test. Change the directories below if needed.
+
+```shell
+cd $HOME
+git clone https://github.com/googleapis/google-cloud-rust rust-conformance
+cd rust-conformance
+cargo build -p protojson-conformance
+```
+
+## Compiling the test runner
+
+We will also need to checkout the Protobuf code:
+
+```shell
+cd $HOME
+git clone -b 31.x https://github.com/protocolbuffers/protobuf.git
+cd protobuf
+```
+
+Install bazelisk:
+
+```shell
+curl -fsSL https://github.com/bazelbuild/bazelisk/releases/download/v1.26.0/bazelisk-darwin-arm64 -o bazelisk
+chmod 755 bazelisk
+./bazelisk version
+```
+
+```shell
+USE_BAZEL_VERSION=8.2.1 ./bazelisk build --repo_env=BAZEL_NO_APPLE_CPP_TOOLCHAIN=1 --enable_bzlmod  //conformance:conformance_test_runner
+```
+
+## Running
+
+Use bazelisk to compile and run the test program:
+
+```shell
+USE_BAZEL_VERSION=8.2.1 ./bazelisk run --repo_env=BAZEL_NO_APPLE_CPP_TOOLCHAIN=1 --enable_bzlmod  //conformance:conformance_test_runner $HOME/rust-conformance/target/debug/protojson-conformance
+```
+
+[protocol buffers repository]: https://github.com/protocolbuffers/protobuf/blob/main/conformance/README.md
+[protojson]: https://protobuf.dev/programming-guides/json/

src/protojson-conformance/README.md

@@ -0,0 +1,17 @@
+// Copyright 2025 Google LLC
+//
+// 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
+//
+//     https://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.
+
+pub mod gapic;
+#[allow(non_snake_case)]
+pub mod test_protos;

src/protojson-conformance/src/generated.rs

@@ -0,0 +1,26 @@
+# Copyright 2025 Google LLC
+#
+# 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
+#
+#     https://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.
+
+[general]
+language             = 'rust'
+specification-source = 'conformance'
+
+[source]
+roots        = 'conformance'
+include-list = 'conformance.proto'
+
+[codec]
+copyright-year    = '2025'
+template-override = 'templates/convert-prost'
+module-path       = 'crate::generated::gapic::model'

src/protojson-conformance/src/generated/convert/.sidekick.toml

@@ -0,0 +1,195 @@
+// Copyright 2025 Google LLC
+//
+// 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
+//
+//     https://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.
+//
+// Code generated by sidekick. DO NOT EDIT.
+
+impl gaxi::prost::ToProto<WireFormat> for crate::generated::gapic::model::WireFormat {
+    type Output = i32;
+    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
+        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic::model::WireFormat"))
+    }
+}
+
+impl gaxi::prost::ToProto<TestCategory> for crate::generated::gapic::model::TestCategory {
+    type Output = i32;
+    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
+        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic::model::TestCategory"))
+    }
+}
+
+impl gaxi::prost::ToProto<TestStatus> for crate::generated::gapic::model::TestStatus {
+    type Output = TestStatus;
+    fn to_proto(self) -> std::result::Result<TestStatus, gaxi::prost::ConvertError> {
+        Ok(Self::Output {
+            name: self.name.to_proto()?,
+            failure_message: self.failure_message.to_proto()?,
+            matched_name: self.matched_name.to_proto()?,
+        })
+    }
+}
+
+impl gaxi::prost::FromProto<crate::generated::gapic::model::TestStatus> for TestStatus {
+    fn cnv(self) -> std::result::Result<crate::generated::gapic::model::TestStatus, gaxi::prost::ConvertError> {
+        Ok(
+            crate::generated::gapic::model::TestStatus::new()
+                .set_name(self.name)
+                .set_failure_message(self.failure_message)
+                .set_matched_name(self.matched_name)
+        )
+    }
+}
+
+impl gaxi::prost::ToProto<FailureSet> for crate::generated::gapic::model::FailureSet {
+    type Output = FailureSet;
+    fn to_proto(self) -> std::result::Result<FailureSet, gaxi::prost::ConvertError> {
+        Ok(Self::Output {
+            test: self.test
+                .into_iter()
+                .map(|v| v.to_proto())
+                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
+        })
+    }
+}
+
+impl gaxi::prost::FromProto<crate::generated::gapic::model::FailureSet> for FailureSet {
+    fn cnv(self) -> std::result::Result<crate::generated::gapic::model::FailureSet, gaxi::prost::ConvertError> {
+        Ok(
+            crate::generated::gapic::model::FailureSet::new()
+                .set_test(self.test.into_iter().map(|v| v.cnv())
+                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
+        )
+    }
+}
+
+impl gaxi::prost::ToProto<conformance_request::Payload> for crate::generated::gapic::model::conformance_request::Payload {
+    type Output = conformance_request::Payload;
+    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
+        match self {
+            Self::ProtobufPayload(v) => Ok(Self::Output::ProtobufPayload(v.to_proto()?)),
+            Self::JsonPayload(v) => Ok(Self::Output::JsonPayload(v.to_proto()?)),
+            Self::JspbPayload(v) => Ok(Self::Output::JspbPayload(v.to_proto()?)),
+            Self::TextPayload(v) => Ok(Self::Output::TextPayload(v.to_proto()?)),
+        }
+    }
+}
+
+impl gaxi::prost::FromProto<crate::generated::gapic::model::conformance_request::Payload> for conformance_request::Payload {
+    fn cnv(self) -> std::result::Result<crate::generated::gapic::model::conformance_request::Payload, gaxi::prost::ConvertError> {
+        use crate::generated::gapic::model::conformance_request::Payload as T;
+        match self {
+            Self::ProtobufPayload(v) => Ok(T::from_protobuf_payload(v.cnv()?)),
+            Self::JsonPayload(v) => Ok(T::from_json_payload(v.cnv()?)),
+            Self::JspbPayload(v) => Ok(T::from_jspb_payload(v.cnv()?)),
+            Self::TextPayload(v) => Ok(T::from_text_payload(v.cnv()?)),
+        }
+    }
+}
+
+impl gaxi::prost::ToProto<ConformanceRequest> for crate::generated::gapic::model::ConformanceRequest {
+    type Output = ConformanceRequest;
+    fn to_proto(self) -> std::result::Result<ConformanceRequest, gaxi::prost::ConvertError> {
+        Ok(Self::Output {
+            requested_output_format: self.requested_output_format.to_proto()?,
+            message_type: self.message_type.to_proto()?,
+            test_category: self.test_category.to_proto()?,
+            jspb_encoding_options: self.jspb_encoding_options.map(|v| v.to_proto()).transpose()?,
+            print_unknown_fields: self.print_unknown_fields.to_proto()?,
+            payload: self.payload.map(|v| v.to_proto()).transpose()?,
+        })
+    }
+}
+
+impl gaxi::prost::FromProto<crate::generated::gapic::model::ConformanceRequest> for ConformanceRequest {
+    fn cnv(self) -> std::result::Result<crate::generated::gapic::model::ConformanceRequest, gaxi::prost::ConvertError> {
+        Ok(
+            crate::generated::gapic::model::ConformanceRequest::new()
+                .set_requested_output_format(self.requested_output_format)
+                .set_message_type(self.message_type)
+                .set_test_category(self.test_category)
+                .set_or_clear_jspb_encoding_options(self.jspb_encoding_options.map(|v| v.cnv()).transpose()?)
+                .set_print_unknown_fields(self.print_unknown_fields)
+                .set_payload(self.payload.map(|v| v.cnv()).transpose()?)
+        )
+    }
+}
+
+impl gaxi::prost::ToProto<conformance_response::Result> for crate::generated::gapic::model::conformance_response::Result {
+    type Output = conformance_response::Result;
+    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
+        match self {
+            Self::ParseError(v) => Ok(Self::Output::ParseError(v.to_proto()?)),
+            Self::SerializeError(v) => Ok(Self::Output::SerializeError(v.to_proto()?)),
+            Self::TimeoutError(v) => Ok(Self::Output::TimeoutError(v.to_proto()?)),
+            Self::RuntimeError(v) => Ok(Self::Output::RuntimeError(v.to_proto()?)),
+            Self::ProtobufPayload(v) => Ok(Self::Output::ProtobufPayload(v.to_proto()?)),
+            Self::JsonPayload(v) => Ok(Self::Output::JsonPayload(v.to_proto()?)),
+            Self::Skipped(v) => Ok(Self::Output::Skipped(v.to_proto()?)),
+            Self::JspbPayload(v) => Ok(Self::Output::JspbPayload(v.to_proto()?)),
+            Self::TextPayload(v) => Ok(Self::Output::TextPayload(v.to_proto()?)),
+        }
+    }
+}
+
+impl gaxi::prost::FromProto<crate::generated::gapic::model::conformance_response::Result> for conformance_response::Result {
+    fn cnv(self) -> std::result::Result<crate::generated::gapic::model::conformance_response::Result, gaxi::prost::ConvertError> {
+        use crate::generated::gapic::model::conformance_response::Result as T;
+        match self {
+            Self::ParseError(v) => Ok(T::from_parse_error(v.cnv()?)),
+            Self::SerializeError(v) => Ok(T::from_serialize_error(v.cnv()?)),
+            Self::TimeoutError(v) => Ok(T::from_timeout_error(v.cnv()?)),
+            Self::RuntimeError(v) => Ok(T::from_runtime_error(v.cnv()?)),
+            Self::ProtobufPayload(v) => Ok(T::from_protobuf_payload(v.cnv()?)),
+            Self::JsonPayload(v) => Ok(T::from_json_payload(v.cnv()?)),
+            Self::Skipped(v) => Ok(T::from_skipped(v.cnv()?)),
+            Self::JspbPayload(v) => Ok(T::from_jspb_payload(v.cnv()?)),
+            Self::TextPayload(v) => Ok(T::from_text_payload(v.cnv()?)),
+        }
+    }
+}
+
+impl gaxi::prost::ToProto<ConformanceResponse> for crate::generated::gapic::model::ConformanceResponse {
+    type Output = ConformanceResponse;
+    fn to_proto(self) -> std::result::Result<ConformanceResponse, gaxi::prost::ConvertError> {
+        Ok(Self::Output {
+            result: self.result.map(|v| v.to_proto()).transpose()?,
+        })
+    }
+}
+
+impl gaxi::prost::FromProto<crate::generated::gapic::model::ConformanceResponse> for ConformanceResponse {
+    fn cnv(self) -> std::result::Result<crate::generated::gapic::model::ConformanceResponse, gaxi::prost::ConvertError> {
+        Ok(
+            crate::generated::gapic::model::ConformanceResponse::new()
+                .set_result(self.result.map(|v| v.cnv()).transpose()?)
+        )
+    }
+}
+
+impl gaxi::prost::ToProto<JspbEncodingConfig> for crate::generated::gapic::model::JspbEncodingConfig {
+    type Output = JspbEncodingConfig;
+    fn to_proto(self) -> std::result::Result<JspbEncodingConfig, gaxi::prost::ConvertError> {
+        Ok(Self::Output {
+            use_jspb_array_any_format: self.use_jspb_array_any_format.to_proto()?,
+        })
+    }
+}
+
+impl gaxi::prost::FromProto<crate::generated::gapic::model::JspbEncodingConfig> for JspbEncodingConfig {
+    fn cnv(self) -> std::result::Result<crate::generated::gapic::model::JspbEncodingConfig, gaxi::prost::ConvertError> {
+        Ok(
+            crate::generated::gapic::model::JspbEncodingConfig::new()
+                .set_use_jspb_array_any_format(self.use_jspb_array_any_format)
+        )
+    }
+}