Add support for generic services

build/Build.cs

@@ -146,9 +146,10 @@ ITargetDefinition TestDefinition(ITargetDefinition targetDefinition, Target depe
                 .SetVerbosity(DotNetVerbosity.Normal));
         });
 
+    [PublicAPI]
     Target CopyToLocalPackages => _ => _
         .OnlyWhenStatic(() => IsLocalBuild)
-        .TriggeredBy(Pack)
+        .DependsOn(Pack)
         .Executes(() =>
         {
             EnsureExistingDirectory(LocalPackagesDirectory);

source/Halibut.TestUtils.Contracts/IGenericService`.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Halibut.TestUtils.Contracts
+{
+    public interface IGenericService<in T>
+    {
+        string GetInfo(T value);
+    }
+
+    public interface IAsyncGenericService<in T>
+    {
+        Task<string> GetInfoAsync(T value, CancellationToken cancellationToken);
+    }
+}

source/Halibut.Tests/GenericServiceFixture.cs

@@ -0,0 +1,31 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Halibut.Logging;
+using Halibut.Tests.Support.TestAttributes;
+using Halibut.Tests.Support.TestCases;
+using Halibut.Tests.TestServices.Async;
+using Halibut.TestUtils.Contracts;
+using NUnit.Framework;
+
+namespace Halibut.Tests
+{
+    public class GenericServiceFixture : BaseTest
+    {
+        [Test]
+        [LatestClientAndLatestServiceTestCases(testNetworkConditions: false)]
+        public async Task GenericServiceNamesAreCorrectlyCalled(ClientAndServiceTestCase clientAndServiceTestCase)
+        {
+            await using var clientAndService = await clientAndServiceTestCase.CreateTestCaseBuilder()
+                .WithGenericService<string>()
+                .WithGenericService<double>()
+                .WithHalibutLoggingLevel(LogLevel.Info)
+                .Build(CancellationToken);
+
+            var stringClient = clientAndService.CreateClient<IGenericService<string>, IAsyncClientGenericService<string>>();
+            (await stringClient.GetInfoAsync("Cool string")).Should().Be("String => Cool string");
+
+            var doubleClient = clientAndService.CreateClient<IGenericService<double>, IAsyncClientGenericService<double>>();
+            (await doubleClient.GetInfoAsync(6.54321)).Should().Be("Double => 6.54321");
+        }
+    }
+}

source/Halibut.Tests/Support/BackwardsCompatibility/LatestClientAndPreviousServiceVersionBuilder.cs

@@ -109,13 +109,21 @@ public LatestClientAndPreviousServiceVersionBuilder WithTentacleServices()
         }
 
         IClientAndServiceBuilder IClientAndServiceBuilder.WithCachingService() => WithCachingService();
-
+
+
         public IClientAndServiceBuilder WithCachingService()
         {
             availableServices.HasCachingService = true;
             return this;
         }
 
+        IClientAndServiceBuilder IClientAndServiceBuilder.WithGenericService<T>() => WithGenericService<T>();
+        public IClientAndServiceBuilder WithGenericService<T>()
+        {
+            availableServices.HasGenericService = true;
+            return this;
+        }
+
         IClientAndServiceBuilder IClientAndServiceBuilder.WithProxy()
         {
             return WithProxy();
@@ -156,7 +164,7 @@ IClientAndServiceBuilder IClientAndServiceBuilder.NoService()
         {
             return NoService();
         }
-        
+
         IClientAndServiceBuilder IClientAndServiceBuilder.WithForcingClientProxyType(ForceClientProxyType forceClientProxyType)
         {
             return WithForcingClientProxyType(forceClientProxyType);
@@ -177,7 +185,7 @@ async Task<IClientAndService> IClientAndServiceBuilder.Build(CancellationToken c
         {
             return await Build(cancellationToken);
         }
-        
+
         public async Task<ClientAndService> Build(CancellationToken cancellationToken)
         {
             var logger = new SerilogLoggerBuilder().Build().ForContext<LatestClientAndPreviousServiceVersionBuilder>();
@@ -368,12 +376,12 @@ public TService CreateClient<TService>(Action<ServiceEndPoint> modifyServiceEndp
                 modifyServiceEndpoint(serviceEndpoint);
                 return new AdaptToSyncOrAsyncTestCase().Adapt<TService, TClientService>(forceClientProxyType, Client, serviceEndpoint);
             }
-            
+
             public TAsyncClientWithOptions CreateClientWithOptions<TService, TSyncClientWithOptions, TAsyncClientWithOptions>()
             {
                 return CreateClientWithOptions<TService, TSyncClientWithOptions, TAsyncClientWithOptions>(_ => { });
             }
-            
+
             public TAsyncClientWithOptions CreateClientWithOptions<TService, TSyncClientWithOptions, TAsyncClientWithOptions>(Action<ServiceEndPoint> modifyServiceEndpoint)
             {
                 var serviceEndpoint = ServiceEndPoint;
@@ -389,7 +397,7 @@ public TService CreateClient<TService>(Action<ServiceEndPoint> modifyServiceEndp
             public async ValueTask DisposeAsync()
             {
                 var logger = new SerilogLoggerBuilder().Build().ForContext<ClientAndService>();
-                
+
                 logger.Information("****** ****** ****** ****** ****** ****** ******");
                 logger.Information("****** CLIENT AND SERVICE DISPOSE CALLED  ******");
                 logger.Information("*     Subsequent errors should be ignored      *");

source/Halibut.Tests/Support/BackwardsCompatibility/OldServiceAvailableServices.cs

@@ -11,5 +11,6 @@ public OldServiceAvailableServices(bool hasStandardServices, bool hasCachingServ
         public bool HasStandardServices { get; set; }
         public bool HasCachingService { get; set; }
         public bool HasTentacleServices { get; set; }
+        public bool HasGenericService { get; set; }
     }
 }

source/Halibut.Tests/Support/BackwardsCompatibility/PreviousClientVersionAndLatestServiceBuilder.cs

@@ -117,6 +117,11 @@ IClientAndServiceBuilder IClientAndServiceBuilder.WithCachingService()
             throw new Exception("Caching service is not supported, when testing on the old Client. Since the old client is on external CLR which does not have the new caching attributes which this service is used to test.");
         }
 
+        public IClientAndServiceBuilder WithGenericService<T>()
+        {
+            throw new NotSupportedException("Generic services are not supported when testing the old client");
+        }
+
         public PreviousClientVersionAndLatestServiceBuilder WithMultipleParametersTestService(IMultipleParametersTestService multipleParametersTestService)
         {
             this.multipleParametersTestService = multipleParametersTestService;
@@ -128,13 +133,13 @@ public PreviousClientVersionAndLatestServiceBuilder WithComplexObjectService(ICo
             this.complexObjectService = complexObjectService;
             return this;
         }
-        
+
         public PreviousClientVersionAndLatestServiceBuilder WithLockService(ILockService lockService)
         {
             this.lockService = lockService;
             return this;
         }
-        
+
         public PreviousClientVersionAndLatestServiceBuilder WithCountingService(ICountingService countingService)
         {
             this.countingService = countingService;
@@ -185,7 +190,7 @@ public PreviousClientVersionAndLatestServiceBuilder WithProxy()
 
             return this;
         }
-        
+
         IClientAndServiceBuilder IClientAndServiceBuilder.WithHalibutLoggingLevel(LogLevel halibutLogLevel)
         {
             return WithHalibutLoggingLevel(halibutLogLevel);
@@ -202,7 +207,7 @@ async Task<IClientAndService> IClientAndServiceBuilder.Build(CancellationToken c
         {
             return await Build(cancellationToken);
         }
-        
+
         public PreviousClientVersionAndLatestServiceBuilder NoService()
         {
             throw new NotImplementedException();
@@ -212,7 +217,7 @@ IClientAndServiceBuilder IClientAndServiceBuilder.NoService()
         {
             return NoService();
         }
-        
+
         IClientAndServiceBuilder IClientAndServiceBuilder.WithForcingClientProxyType(ForceClientProxyType forceClientProxyType)
         {
             throw new Exception("Not supported");
@@ -240,7 +245,7 @@ public async Task<ClientAndService> Build(CancellationToken cancellationToken)
                 .WithLogFactory(new TestContextLogCreator("ProxyClient", halibutLogLevel).ToCachingLogFactory())
                 .WithAsyncHalibutFeatureEnabled()
                 .Build();
-            
+
             proxyClient.Trust(serviceCertAndThumbprint.Thumbprint);
 
             var serviceFactory = new DelegateServiceFactory()
@@ -464,9 +469,9 @@ public TService CreateClient<TService>(Action<ServiceEndPoint> modifyServiceEndp
                 {
                     throw new Exception($"Unsupported, since types within {typeof(TClientService)} would not actually be passed on to the remote process which holds the actual client under test.", e);
                 }
-                
+
                 var serviceEndpoint = new ServiceEndPoint(serviceUri, serviceCertAndThumbprint.Thumbprint, Client.TimeoutsAndLimits);
-                
+
                 return ProxyClient.CreateAsyncClient<TService, TClientService>(serviceEndpoint);
             }
 
@@ -479,12 +484,12 @@ public TService CreateClient<TService>(Action<ServiceEndPoint> modifyServiceEndp
             {
                 return CreateClientWithOptions<TService, TSyncClientWithOptions, TAsyncClientWithOptions>(_ => { });
             }
-            
+
             public TAsyncClientWithOptions CreateClientWithOptions<TService, TSyncClientWithOptions, TAsyncClientWithOptions>(Action<ServiceEndPoint> modifyServiceEndpoint)
             {
                 throw new NotSupportedException("Not supported since the options can not be passed to the external binary.");
             }
-            
+
             public TAsyncClientService CreateAsyncClient<TService, TAsyncClientService>()
             {
                 return Client.CreateAsyncClient<TService, TAsyncClientService>(ServiceEndPoint);

source/Halibut.Tests/Support/IClientAndServiceBuilder.cs

@@ -15,6 +15,7 @@ public interface IClientAndServiceBuilder
         IClientAndServiceBuilder WithTentacleServices();
         IClientAndServiceBuilder WithHalibutLoggingLevel(LogLevel info);
         IClientAndServiceBuilder WithCachingService();
+        IClientAndServiceBuilder WithGenericService<T>();
         IClientAndServiceBuilder NoService();
         IClientAndServiceBuilder WithForcingClientProxyType(ForceClientProxyType forceClientProxyType);
         IClientAndServiceBuilder WithServiceAsyncHalibutFeatureEnabled();