Adopt client structure specs (Azure#51261)

Author: JoshLove-msft

eng/packages/http-client-csharp/eng/scripts/Generate.ps1

@@ -57,12 +57,8 @@ $failingSpecs = @(
     Join-Path 'http' 'versioning' 'renamedFrom'
     Join-Path 'http' 'versioning' 'returnTypeChangedFrom'
     Join-Path 'http' 'versioning' 'typeChangedFrom'
-    Join-Path 'http' 'client' 'naming'
+    Join-Path 'http' 'client' 'naming' # pending until https://github.com/microsoft/typespec/issues/5653 is resolved
     Join-Path 'http' 'resiliency' 'srv-driven'
-    Join-Path 'http' 'client' 'structure' 'client-operation-group'
-    Join-Path 'http' 'client' 'structure' 'renamed-operation'
-    Join-Path 'http' 'client' 'structure' 'multi-client'
-    Join-Path 'http' 'client' 'structure' 'two-operation-group'
     Join-Path 'http' 'response' 'status-code-range' # Response namespace conflicts with Azure.Response
     # Azure scenarios not yet buildable
     Join-Path 'http' 'client' 'namespace'

eng/packages/http-client-csharp/generator/Azure.Generator/src/Properties/launchSettings.json

@@ -75,11 +75,31 @@
       "commandName": "Executable",
       "executablePath": "dotnet"
     },
+    "http-client-structure-client-operation-group": {
+      "commandLineArgs": "$(SolutionDir)/../dist/generator/Microsoft.TypeSpec.Generator.dll $(SolutionDir)/TestProjects/Spector/http/client/structure/client-operation-group -g AzureStubGenerator",
+      "commandName": "Executable",
+      "executablePath": "dotnet"
+    },
     "http-client-structure-default": {
       "commandLineArgs": "$(SolutionDir)/../dist/generator/Microsoft.TypeSpec.Generator.dll $(SolutionDir)/TestProjects/Spector/http/client/structure/default -g AzureStubGenerator",
       "commandName": "Executable",
       "executablePath": "dotnet"
     },
+    "http-client-structure-multi-client": {
+      "commandLineArgs": "$(SolutionDir)/../dist/generator/Microsoft.TypeSpec.Generator.dll $(SolutionDir)/TestProjects/Spector/http/client/structure/multi-client -g AzureStubGenerator",
+      "commandName": "Executable",
+      "executablePath": "dotnet"
+    },
+    "http-client-structure-renamed-operation": {
+      "commandLineArgs": "$(SolutionDir)/../dist/generator/Microsoft.TypeSpec.Generator.dll $(SolutionDir)/TestProjects/Spector/http/client/structure/renamed-operation -g AzureStubGenerator",
+      "commandName": "Executable",
+      "executablePath": "dotnet"
+    },
+    "http-client-structure-two-operation-group": {
+      "commandLineArgs": "$(SolutionDir)/../dist/generator/Microsoft.TypeSpec.Generator.dll $(SolutionDir)/TestProjects/Spector/http/client/structure/two-operation-group -g AzureStubGenerator",
+      "commandName": "Executable",
+      "executablePath": "dotnet"
+    },
     "http-encode-bytes": {
       "commandLineArgs": "$(SolutionDir)/../dist/generator/Microsoft.TypeSpec.Generator.dll $(SolutionDir)/TestProjects/Spector/http/encode/bytes -g AzureStubGenerator",
       "commandName": "Executable",

eng/packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Client/Structure/ClientOperationGroup/ClientOperationGroupTests.cs

@@ -0,0 +1,95 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+extern alias ClientStructureClientOperationGroup;
+using System.Linq;
+using System.Threading.Tasks;
+using ClientStructureClientOperationGroup::Client.Structure.AnotherClientOperationGroup;
+using ClientStructureClientOperationGroup::Client.Structure.ClientOperationGroup;
+using NUnit.Framework;
+using ClientType = ClientStructureClientOperationGroup::Client.Structure.Service.ClientType;
+
+namespace TestProjects.Spector.Tests.Http.Client.Structure.ClientOperationGroup
+{
+    public class ClientOperationGroupTests : SpectorTestBase
+    {
+        [Test]
+        public void VerifyMethods()
+        {
+            /*check methods in FirstClient. */
+            var methodsOfFirstClient = typeof(FirstClient).GetMethods();
+            Assert.IsNotNull(methodsOfFirstClient);
+            Assert.AreEqual(2, methodsOfFirstClient.Where(method => method.Name.EndsWith("Async")).Count());
+            Assert.IsNotNull(typeof(FirstClient).GetMethods().Where(m => m.Name == "OneAsync").FirstOrDefault());
+            //check existence of method to get the operation group client
+            Assert.AreNotEqual(null, typeof(FirstClient).GetMethod("GetGroup3Client"));
+            Assert.AreNotEqual(null, typeof(FirstClient).GetMethod("GetGroup4Client"));
+            /*check methods in operation group3 client. */
+            var methodsOfGroup3 = typeof(Group3).GetMethods();
+            Assert.IsNotNull(methodsOfGroup3);
+            Assert.AreEqual(4, methodsOfGroup3.Where(method => method.Name.EndsWith("Async")).ToArray().Length);
+            Assert.IsNotNull(typeof(Group3).GetMethods().Where(m => m.Name == "TwoAsync").FirstOrDefault());
+            Assert.IsNotNull(typeof(Group3).GetMethods().Where(m => m.Name == "ThreeAsync").FirstOrDefault());
+            /*check methods in operation group4 client. */
+            var methodsOfGroup4 = typeof(Group4).GetMethods();
+            Assert.IsNotNull(methodsOfGroup4);
+            Assert.AreEqual(2, methodsOfGroup4.Where(method => method.Name.EndsWith("Async")).ToArray().Length);
+            Assert.IsNotNull(typeof(Group4).GetMethods().Where(m => m.Name == "FourAsync").FirstOrDefault());
+
+            /*check methods in SecondClient. */
+            var methodsOfSecondClient = typeof(SubNamespaceSecondClient).GetMethods();
+            Assert.IsNotNull(methodsOfSecondClient);
+            Assert.AreEqual(2, methodsOfSecondClient.Where(method => method.Name.EndsWith("Async")).Count());
+            Assert.IsNotNull(typeof(SubNamespaceSecondClient).GetMethods().Where(m => m.Name == "FiveAsync").FirstOrDefault());
+            //check existence of method to get the operation group client
+            Assert.AreNotEqual(null, typeof(SubNamespaceSecondClient).GetMethod("GetGroup5Client"));
+            /*check methods in operation group5 client. */
+            var methodsOfGroup5 = typeof(Group5).GetMethods();
+            Assert.IsNotNull(methodsOfGroup5);
+            Assert.AreEqual(2, methodsOfGroup5.Where(method => method.Name.EndsWith("Async")).ToArray().Length);
+            Assert.IsNotNull(typeof(Group5).GetMethods().Where(m => m.Name == "SixAsync").FirstOrDefault());
+        }
+
+        [SpectorTest]
+        public Task One() => Test(async (host) =>
+        {
+            var response = await new FirstClient(host, ClientType.ClientOperationGroup, null).OneAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Two() => Test(async (host) =>
+        {
+            var response = await new FirstClient(host, ClientType.ClientOperationGroup, null).GetGroup3Client().TwoAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Three() => Test(async (host) =>
+        {
+            var response = await new FirstClient(host, ClientType.ClientOperationGroup, null).GetGroup3Client().ThreeAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Four() => Test(async (host) =>
+        {
+            var response = await new FirstClient(host, ClientType.ClientOperationGroup, null).GetGroup4Client().FourAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Five() => Test(async (host) =>
+        {
+            var response = await new SubNamespaceSecondClient(host, ClientType.ClientOperationGroup, null).FiveAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Six() => Test(async (host) =>
+        {
+            var response = await new SubNamespaceSecondClient(host, ClientType.ClientOperationGroup, null).GetGroup5Client().SixAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+    }
+}

eng/packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Client/Structure/Default/DefaultTests.cs

@@ -0,0 +1,99 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+extern alias ClientStructureDefault;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using ClientStructureDefault::Client.Structure.Service;
+using ClientStructureDefault::Client.Structure.Service._Baz;
+using ClientStructureDefault::Client.Structure.Service._Qux;
+using NUnit.Framework;
+
+namespace TestProjects.Spector.Tests.Http.Client.Structure.Default
+{
+    public class DefaultTests : SpectorTestBase
+    {
+        [TestCase(typeof(ServiceClient), new string[] { "One", "Two" })]
+        [TestCase(typeof(Foo), new string[] { "Three", "Four" })]
+        [TestCase(typeof(Bar), new string[] { "Five", "Six" })]
+        [TestCase(typeof(BazFoo), new string[] { "Seven" })]
+        [TestCase(typeof(Qux), new string[] { "Eight" })]
+        [TestCase(typeof(QuxBar), new string[] { "Nine" })]
+
+        public void Client_Structure_default_methods(Type client, string[] methodNames)
+        {
+            var methods = client.GetMethods();
+            Assert.IsNotNull(methods);
+            Assert.AreEqual(methodNames.Length * 2, methods.Where(method => method.Name.EndsWith("Async")).ToArray().Length); // Double the methods to account for protocol methods
+            /* check the existence of the methods. */
+            foreach (var methodName in methodNames)
+            {
+                Assert.IsNotNull(methods.Where(m => m.Name == $"{methodName}Async").FirstOrDefault());
+            }
+        }
+
+        [SpectorTest]
+        public Task Client_Structure_default_One() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).OneAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Client_Structure_default_Two() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).TwoAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Client_Structure_default_Three() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).GetFooClient().ThreeAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Client_Structure_default_Four() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).GetFooClient().FourAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Client_Structure_default_Five() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).GetBarClient().FiveAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Client_Structure_default_Six() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).GetBarClient().SixAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Client_Structure_default_Seven() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).GetBazClient().GetBazFooClient().SevenAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Client_Structure_default_Eight() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).GetQuxClient().EightAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task Client_Structure_default_Nine() => Test(async (host) =>
+        {
+            var response = await new ServiceClient(host, ClientType.Default).GetQuxClient().GetQuxBarClient().NineAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+    }
+}

eng/packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Client/Structure/MultiClient/MultiClientTests.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+extern alias ClientStructureMultiClient;
+using System.Linq;
+using System.Threading.Tasks;
+using ClientStructureMultiClient::Client.Structure.MultiClient;
+using NUnit.Framework;
+using ClientType = ClientStructureMultiClient::Client.Structure.Service.ClientType;
+
+namespace TestProjects.Spector.Tests.Http.Client.Structure.MultiClient
+{
+    public class MultiClientTests : SpectorTestBase
+    {
+        [Test]
+        public void VerifyMethods()
+        {
+            /*cheeck methods in ClientAClient. */
+            var methodsOfClientA = typeof(ClientAClient).GetMethods();
+            Assert.IsNotNull(methodsOfClientA);
+            Assert.AreEqual(6, methodsOfClientA.Where(method => method.Name.EndsWith("Async")).Count());
+            Assert.IsNotNull(typeof(ClientAClient).GetMethods().Where(m => m.Name == "RenamedOneAsync").FirstOrDefault());
+            Assert.IsNotNull(typeof(ClientAClient).GetMethods().Where(m => m.Name == "RenamedThreeAsync").FirstOrDefault());
+            Assert.IsNotNull(typeof(ClientAClient).GetMethods().Where(m => m.Name == "RenamedFiveAsync").FirstOrDefault());
+
+            /*cheeck methods in ClientBClient. */
+            var methodsOfClientB = typeof(ClientBClient).GetMethods();
+            Assert.IsNotNull(methodsOfClientB);
+            Assert.AreEqual(6, methodsOfClientB.Where(method => method.Name.EndsWith("Async")).Count());
+            Assert.IsNotNull(typeof(ClientBClient).GetMethods().Where(m => m.Name == "RenamedTwoAsync").FirstOrDefault());
+            Assert.IsNotNull(typeof(ClientBClient).GetMethods().Where(m => m.Name == "RenamedFourAsync").FirstOrDefault());
+            Assert.IsNotNull(typeof(ClientBClient).GetMethods().Where(m => m.Name == "RenamedSixAsync").FirstOrDefault());
+        }
+
+        [SpectorTest]
+        public Task RenamedOne() => Test(async (host) =>
+        {
+            var response = await new ClientAClient(host, ClientType.MultiClient, null).RenamedOneAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedTwo() => Test(async (host) =>
+        {
+            var response = await new ClientBClient(host, ClientType.MultiClient, null).RenamedTwoAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedThree() => Test(async (host) =>
+        {
+            var response = await new ClientAClient(host, ClientType.MultiClient, null).RenamedThreeAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedFour() => Test(async (host) =>
+        {
+            var response = await new ClientBClient(host, ClientType.MultiClient, null).RenamedFourAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedFive() => Test(async (host) =>
+        {
+            var response = await new ClientAClient(host, ClientType.MultiClient, null).RenamedFiveAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedSix() => Test(async (host) =>
+        {
+            var response = await new ClientBClient(host, ClientType.MultiClient, null).RenamedSixAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+    }
+}

eng/packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Client/Structure/RenamedOperation/RenamedOperationTests.cs

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+extern alias ClientStructureRenamedOperation;
+using System.Linq;
+using System.Threading.Tasks;
+using ClientStructureRenamedOperation::Client.Structure.RenamedOperation;
+using ClientStructureRenamedOperation::Client.Structure.Service;
+using NUnit.Framework;
+
+namespace TestProjects.Spector.Tests.Http.Client.Structure.RenamedOperation
+{
+    public class RenamedOperationTests : SpectorTestBase
+    {
+        [Test]
+        public void VerifyMethods()
+        {
+            /*check methods in RenamedOperationClient. */
+            var methodsRenamedOperation = typeof(RenamedOperationClient).GetMethods();
+            Assert.IsNotNull(methodsRenamedOperation);
+            Assert.AreEqual(6, methodsRenamedOperation.Where(method => method.Name.EndsWith("Async")).Count());
+            Assert.IsNotNull(typeof(RenamedOperationClient).GetMethods().Where(m => m.Name == "RenamedOneAsync").FirstOrDefault());
+            Assert.IsNotNull(typeof(RenamedOperationClient).GetMethods().Where(m => m.Name == "RenamedThreeAsync").FirstOrDefault());
+            Assert.IsNotNull(typeof(RenamedOperationClient).GetMethods().Where(m => m.Name == "RenamedFiveAsync").FirstOrDefault());
+            Assert.IsNotNull(typeof(RenamedOperationClient).GetMethods().Where(m => m.Name == "GetGroupClient").FirstOrDefault());
+        }
+
+        [SpectorTest]
+        public Task RenamedOne() => Test(async (host) =>
+        {
+            var response = await new RenamedOperationClient(host, ClientType.RenamedOperation, null).RenamedOneAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedThree() => Test(async (host) =>
+        {
+            var response = await new RenamedOperationClient(host, ClientType.RenamedOperation, null).RenamedThreeAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedFive() => Test(async (host) =>
+        {
+            var response = await new RenamedOperationClient(host, ClientType.RenamedOperation, null).RenamedFiveAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        // Check OperationGroup
+        [SpectorTest]
+        public Task RenamedTwo() => Test(async (host) =>
+        {
+            var response = await new RenamedOperationClient(host, ClientType.RenamedOperation, null).GetGroupClient().RenamedTwoAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedFour() => Test(async (host) =>
+        {
+            var response = await new RenamedOperationClient(host, ClientType.RenamedOperation, null).GetGroupClient().RenamedFourAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+
+        [SpectorTest]
+        public Task RenamedSix() => Test(async (host) =>
+        {
+            var response = await new RenamedOperationClient(host, ClientType.RenamedOperation, null).GetGroupClient().RenamedSixAsync();
+            Assert.AreEqual(204, response.Status);
+        });
+    }
+}