grpc-swift/Tests/GRPCCodeGenTests/Internal/StructuredSwift+MetadataTests.swift

/*
 * Copyright 2024, gRPC Authors All rights reserved.
 *
 * 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.
 */

import Testing

@testable import GRPCCodeGen

extension StructuedSwiftTests {
  @Suite("Metadata")
  struct Metadata {
    @Test("typealias Input = <Name>", arguments: AccessModifier.allCases)
    func methodInputTypealias(access: AccessModifier) {
      let decl: TypealiasDescription = .methodInput(accessModifier: access, name: "Foo")
      let expected = "\(access) typealias Input = Foo"
      #expect(render(.typealias(decl)) == expected)
    }

    @Test("typealias Output = <Name>", arguments: AccessModifier.allCases)
    func methodOutputTypealias(access: AccessModifier) {
      let decl: TypealiasDescription = .methodOutput(accessModifier: access, name: "Foo")
      let expected = "\(access) typealias Output = Foo"
      #expect(render(.typealias(decl)) == expected)
    }

    @Test(
      "static let descriptor = GRPCCore.MethodDescriptor(...)",
      arguments: AccessModifier.allCases
    )
    func staticMethodDescriptorProperty(access: AccessModifier) {
      let decl: VariableDescription = .methodDescriptor(
        accessModifier: access,
        literalFullyQualifiedService: "foo.Foo",
        literalMethodName: "Bar"
      )

      let expected = """
        \(access) static let descriptor = GRPCCore.MethodDescriptor(
          service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "foo.Foo"),
          method: "Bar"
        )
        """
      #expect(render(.variable(decl)) == expected)
    }

    @Test(
      "static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService:)",
      arguments: AccessModifier.allCases
    )
    func staticServiceDescriptorProperty(access: AccessModifier) {
      let decl: VariableDescription = .serviceDescriptor(
        accessModifier: access,
        literalFullyQualifiedService: "foo.Bar"
      )

      let expected = """
        \(access) static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "foo.Bar")
        """
      #expect(render(.variable(decl)) == expected)
    }

    @Test("extension GRPCCore.ServiceDescriptor { ... }", arguments: AccessModifier.allCases)
    func staticServiceDescriptorPropertyExtension(access: AccessModifier) {
      let decl: ExtensionDescription = .serviceDescriptor(
        accessModifier: access,
        propertyName: "foo",
        literalFullyQualifiedService: "echo.EchoService"
      )

      let expected = """
        extension GRPCCore.ServiceDescriptor {
          \(access) static let foo = GRPCCore.ServiceDescriptor(fullyQualifiedService: "echo.EchoService")
        }
        """
      #expect(render(.extension(decl)) == expected)
    }

    @Test(
      "static let descriptors: [GRPCCore.MethodDescriptor] = [...]",
      arguments: AccessModifier.allCases
    )
    func staticMethodDescriptorsArray(access: AccessModifier) {
      let decl: VariableDescription = .methodDescriptorsArray(
        accessModifier: access,
        methodNamespaceNames: ["Foo", "Bar", "Baz"]
      )

      let expected = """
        \(access) static let descriptors: [GRPCCore.MethodDescriptor] = [
          Foo.descriptor,
          Bar.descriptor,
          Baz.descriptor
        ]
        """
      #expect(render(.variable(decl)) == expected)
    }

    @Test("enum <Method> { ... }", arguments: AccessModifier.allCases)
    func methodNamespaceEnum(access: AccessModifier) {
      let decl: EnumDescription = .methodNamespace(
        accessModifier: access,
        name: "Foo",
        literalMethod: "Foo",
        literalFullyQualifiedService: "bar.Bar",
        inputType: "FooInput",
        outputType: "FooOutput"
      )

      let expected = """
        \(access) enum Foo {
          \(access) typealias Input = FooInput
          \(access) typealias Output = FooOutput
          \(access) static let descriptor = GRPCCore.MethodDescriptor(
            service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "bar.Bar"),
            method: "Foo"
          )
        }
        """
      #expect(render(.enum(decl)) == expected)
    }

    @Test("enum Method { ... }", arguments: AccessModifier.allCases)
    func methodsNamespaceEnum(access: AccessModifier) {
      let decl: EnumDescription = .methodsNamespace(
        accessModifier: access,
        literalFullyQualifiedService: "bar.Bar",
        methods: [
          .init(
            documentation: "",
            name: .init(base: "Foo", generatedUpperCase: "Foo", generatedLowerCase: "foo"),
            isInputStreaming: false,
            isOutputStreaming: false,
            inputType: "FooInput",
            outputType: "FooOutput"
          )
        ]
      )

      let expected = """
        \(access) enum Method {
          \(access) enum Foo {
            \(access) typealias Input = FooInput
            \(access) typealias Output = FooOutput
            \(access) static let descriptor = GRPCCore.MethodDescriptor(
              service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "bar.Bar"),
              method: "Foo"
            )
          }
          \(access) static let descriptors: [GRPCCore.MethodDescriptor] = [
            Foo.descriptor
          ]
        }
        """
      #expect(render(.enum(decl)) == expected)
    }

    @Test("enum Method { ... } (no methods)", arguments: AccessModifier.allCases)
    func methodsNamespaceEnumNoMethods(access: AccessModifier) {
      let decl: EnumDescription = .methodsNamespace(
        accessModifier: access,
        literalFullyQualifiedService: "bar.Bar",
        methods: []
      )

      let expected = """
        \(access) enum Method {
          \(access) static let descriptors: [GRPCCore.MethodDescriptor] = []
        }
        """
      #expect(render(.enum(decl)) == expected)
    }

    @Test("enum <Service> { ... }", arguments: AccessModifier.allCases)
    func serviceNamespaceEnum(access: AccessModifier) {
      let decl: EnumDescription = .serviceNamespace(
        accessModifier: access,
        name: "Foo",
        literalFullyQualifiedService: "Foo",
        methods: [
          .init(
            documentation: "",
            name: .init(base: "Bar", generatedUpperCase: "Bar", generatedLowerCase: "bar"),
            isInputStreaming: false,
            isOutputStreaming: false,
            inputType: "BarInput",
            outputType: "BarOutput"
          )
        ]
      )

      let expected = """
        \(access) enum Foo {
          \(access) static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "Foo")
          \(access) enum Method {
            \(access) enum Bar {
              \(access) typealias Input = BarInput
              \(access) typealias Output = BarOutput
              \(access) static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "Foo"),
                method: "Bar"
              )
            }
            \(access) static let descriptors: [GRPCCore.MethodDescriptor] = [
              Bar.descriptor
            ]
          }
        }
        """
      #expect(render(.enum(decl)) == expected)
    }

    @Test("enum <Service> { ... } (no methods)", arguments: AccessModifier.allCases)
    func serviceNamespaceEnumNoMethods(access: AccessModifier) {
      let decl: EnumDescription = .serviceNamespace(
        accessModifier: access,
        name: "Foo",
        literalFullyQualifiedService: "Foo",
        methods: []
      )

      let expected = """
        \(access) enum Foo {
          \(access) static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "Foo")
          \(access) enum Method {
            \(access) static let descriptors: [GRPCCore.MethodDescriptor] = []
          }
        }
        """

      #expect(render(.enum(decl)) == expected)
    }
  }
}