feat(generator): add CreateFilesFromResources (googleapis#11291)

scotthart · web-flow · commit 2e574a93abf3 · 2023-04-17T17:00:35.000Z
diff --git a/generator/internal/discovery_file.h b/generator/internal/discovery_file.h
@@ -36,6 +36,12 @@ class DiscoveryFile {
                 std::string package_name, std::string version,
                 std::vector<DiscoveryTypeVertex const*> types);
 
+  std::string const& file_path() const { return file_path_; }
+  std::string const& package_name() const { return package_name_; }
+  std::string resource_name() const {
+    return (resource_ ? resource_->name() : "");
+  }
+
   DiscoveryFile& AddImportPath(std::string import_path) {
     import_paths_.insert(std::move(import_path));
     return *this;
diff --git a/generator/internal/discovery_to_proto.cc b/generator/internal/discovery_to_proto.cc
@@ -257,6 +257,23 @@ Status ProcessMethodRequestsAndResponses(
   return {};
 }
 
+std::vector<DiscoveryFile> CreateFilesFromResources(
+    std::map<std::string, DiscoveryResource> const& resources,
+    std::string const& product_name, std::string const& version,
+    std::string const& output_path) {
+  std::vector<DiscoveryFile> files;
+  files.reserve(resources.size());
+  for (auto const& r : resources) {
+    files.push_back(DiscoveryFile{
+        &r.second, r.second.FormatFilePath(product_name, version, output_path),
+        r.second.FormatPackageName(product_name, version), version,
+        r.second.GetRequestTypesList()}
+                        .AddImportPath("/google/cloud/$product_name$/$version$/"
+                                       "internal/common.proto"));
+  }
+  return files;
+}
+
 Status GenerateProtosFromDiscoveryDoc(std::string const& url,
                                       std::string const&, std::string const&,
                                       std::string const&) {
diff --git a/generator/internal/discovery_to_proto.h b/generator/internal/discovery_to_proto.h
@@ -15,6 +15,7 @@
 #ifndef GOOGLE_CLOUD_CPP_GENERATOR_INTERNAL_DISCOVERY_TO_PROTO_H
 #define GOOGLE_CLOUD_CPP_GENERATOR_INTERNAL_DISCOVERY_TO_PROTO_H
 
+#include "generator/internal/discovery_file.h"
 #include "generator/internal/discovery_resource.h"
 #include "generator/internal/discovery_type_vertex.h"
 #include "google/cloud/status_or.h"
@@ -54,6 +55,12 @@ Status ProcessMethodRequestsAndResponses(
     std::map<std::string, DiscoveryResource>& resources,
     std::map<std::string, DiscoveryTypeVertex>& types);
 
+// Creates a DiscoveryFile object for each DiscoveryResource in resources.
+std::vector<DiscoveryFile> CreateFilesFromResources(
+    std::map<std::string, DiscoveryResource> const& resources,
+    std::string const& product_name, std::string const& version,
+    std::string const& output_path);
+
 Status GenerateProtosFromDiscoveryDoc(std::string const& url,
                                       std::string const& protobuf_proto_path,
                                       std::string const& googleapis_proto_path,
diff --git a/generator/internal/discovery_to_proto_test.cc b/generator/internal/discovery_to_proto_test.cc
@@ -30,6 +30,7 @@ using ::testing::Eq;
 using ::testing::HasSubstr;
 using ::testing::IsEmpty;
 using ::testing::Key;
+using ::testing::SizeIs;
 using ::testing::UnorderedElementsAre;
 
 TEST(ExtractTypesFromSchemaTest, Success) {
@@ -792,6 +793,62 @@ TEST(ProcessMethodRequestsAndResponsesTest, TypeInsertError) {
                        HasSubstr("Unable to insert type Foos.CreateRequest")));
 }
 
+TEST(CreateFilesFromResourcesTest, NonEmptyResources) {
+  auto constexpr kResourceJson = R"""({
+  "methods": {
+    "create": {
+      "scopes": [
+        "https://www.googleapis.com/auth/cloud-platform"
+      ],
+      "path": "projects/{project}/zones/{zone}/myResources/{fooId}",
+      "httpMethod": "POST",
+      "parameters": {
+        "project": {
+          "type": "string"
+        },
+        "zone": {
+          "type": "string"
+        },
+        "fooId": {
+          "type": "string"
+        }
+      },
+      "response": {
+        "$ref": "Operation"
+      },
+      "request": {
+        "$ref": "Foo"
+      },
+      "parameterOrder": [
+        "project",
+        "zone",
+        "fooId"
+      ]
+    }
+  }
+})""";
+  auto const resource_json =
+      nlohmann::json::parse(kResourceJson, nullptr, false);
+  ASSERT_TRUE(resource_json.is_object());
+  std::map<std::string, DiscoveryResource> resources;
+  resources.emplace("foos", DiscoveryResource("foos", "", "", resource_json));
+  auto result =
+      CreateFilesFromResources(resources, "product_name", "version", "tmp");
+  ASSERT_THAT(result, SizeIs(1));
+  EXPECT_THAT(result.front().resource_name(), Eq("foos"));
+  EXPECT_THAT(result.front().file_path(),
+              Eq("tmp/google/cloud/product_name/foos/version/foos.proto"));
+  EXPECT_THAT(result.front().package_name(),
+              Eq("google.cloud.cpp.product_name.foos.version"));
+}
+
+TEST(CreateFilesFromResourcesTest, EmptyResources) {
+  std::map<std::string, DiscoveryResource> resources;
+  auto result =
+      CreateFilesFromResources(resources, "product_name", "version", "tmp");
+  EXPECT_THAT(result, IsEmpty());
+}
+
 }  // namespace
 }  // namespace generator_internal
 }  // namespace cloud
