Changes before error encountered

Co-authored-by: samtrion <[email protected]>

Author: Copilot

src/NetEvolve.HealthChecks.Azure.Synapse/ClientCreation.cs

@@ -3,6 +3,7 @@ namespace NetEvolve.HealthChecks.Azure.Synapse;
 using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.Linq;
 using global::Azure.Analytics.Synapse.Artifacts;
 using global::Azure.Identity;
 using Microsoft.Extensions.DependencyInjection;
@@ -40,12 +41,34 @@ IServiceProvider serviceProvider
                 var tokenCredential = serviceProvider.GetService<TokenCredential>() ?? new DefaultAzureCredential();
                 return new ArtifactsClient(options.WorkspaceUri, tokenCredential);
             case SynapseClientCreationMode.ConnectionString:
-                // Note: For connection string mode, we'll need to parse the connection string to extract workspace URI
+                // For connection string mode, we extract the workspace URI from the connection string
                 // and use DefaultAzureCredential for authentication
+                var workspaceUri = ExtractWorkspaceUriFromConnectionString(options.ConnectionString);
                 var credential = serviceProvider.GetService<TokenCredential>() ?? new DefaultAzureCredential();
-                return new ArtifactsClient(options.WorkspaceUri, credential);
+                return new ArtifactsClient(workspaceUri, credential);
             default:
                 throw new UnreachableException($"Invalid client creation mode `{options.Mode}`.");
         }
     }
+
+    private static Uri ExtractWorkspaceUriFromConnectionString(string? connectionString)
+    {
+        if (string.IsNullOrWhiteSpace(connectionString))
+        {
+            throw new ArgumentException("Connection string cannot be null or empty.", nameof(connectionString));
+        }
+
+        // Simple connection string parsing for Synapse
+        // Expected format: "Endpoint=https://myworkspace.dev.azuresynapse.net;..."
+        var parts = connectionString.Split(';', StringSplitOptions.RemoveEmptyEntries);
+        var endpointPart = parts.FirstOrDefault(p => p.Trim().StartsWith("Endpoint=", StringComparison.OrdinalIgnoreCase));
+        
+        if (endpointPart is null)
+        {
+            throw new ArgumentException("Connection string must contain an 'Endpoint=' parameter.", nameof(connectionString));
+        }
+
+        var endpointValue = endpointPart.Split('=', 2)[1];
+        return new Uri(endpointValue);
+    }
 }

src/NetEvolve.HealthChecks.Azure.Synapse/SynapseWorkspaceAvailableConfigure.cs

@@ -1,6 +1,7 @@
 namespace NetEvolve.HealthChecks.Azure.Synapse;
 
 using System;
+using System.Linq;
 using System.Threading;
 using global::Azure.Analytics.Synapse.Artifacts;
 using Microsoft.Extensions.Configuration;
@@ -85,6 +86,34 @@ private static ValidateOptionsResult ValidateModeConnectionString(SynapseWorkspa
             );
         }
 
+        // Validate that connection string contains an Endpoint parameter
+        try
+        {
+            var parts = options.ConnectionString.Split(';', StringSplitOptions.RemoveEmptyEntries);
+            var endpointPart = parts.FirstOrDefault(p => p.Trim().StartsWith("Endpoint=", StringComparison.OrdinalIgnoreCase));
+            
+            if (endpointPart is null)
+            {
+                return Fail(
+                    "The connection string must contain an 'Endpoint=' parameter when using ConnectionString mode."
+                );
+            }
+
+            var endpointValue = endpointPart.Split('=', 2)[1];
+            if (!Uri.TryCreate(endpointValue, UriKind.Absolute, out _))
+            {
+                return Fail(
+                    "The Endpoint in the connection string must be a valid absolute URI."
+                );
+            }
+        }
+        catch (Exception)
+        {
+            return Fail(
+                "Invalid connection string format. Expected format: 'Endpoint=https://myworkspace.dev.azuresynapse.net;'"
+            );
+        }
+
         return Success;
     }
 

src/NetEvolve.HealthChecks.Azure.Synapse/SynapseWorkspaceAvailableHealthCheck.cs

@@ -29,23 +29,22 @@ CancellationToken cancellationToken
         var clientCreation = _serviceProvider.GetRequiredService<ClientCreation>();
         var artifactsClient = clientCreation.GetArtifactsClient(name, options, _serviceProvider);
 
-        // Check workspace availability by trying to get pipeline service
-        var pipelineTask = Task.FromResult(true); // Simple connectivity check
         try
         {
-            // Try to call a simple method to test connectivity
-            var pipelineService = artifactsClient.Pipeline;
-            pipelineTask = Task.FromResult(pipelineService is not null);
+            // Test connectivity by trying to access the LinkedService service
+            // This is a basic connectivity check to the Synapse workspace
+            var linkedServiceClient = artifactsClient.LinkedService;
+            var healthCheckTask = Task.FromResult(linkedServiceClient is not null);
+
+            var (isValid, result) = await healthCheckTask
+                .WithTimeoutAsync(options.Timeout, cancellationToken)
+                .ConfigureAwait(false);
+
+            return HealthCheckState(isValid && result, name);
         }
-        catch
+        catch (Exception ex)
         {
-            pipelineTask = Task.FromResult(false);
+            return HealthCheckUnhealthy(failureStatus, name, ex: ex);
         }
-
-        var (isValid, result) = await pipelineTask
-            .WithTimeoutAsync(options.Timeout, cancellationToken)
-            .ConfigureAwait(false);
-
-        return HealthCheckState(isValid && result, name);
     }
 }

tests/NetEvolve.HealthChecks.Tests.Unit/Azure.Synapse/SynapseWorkspaceAvailableConfigureTests.cs

@@ -0,0 +1,98 @@
+namespace NetEvolve.HealthChecks.Tests.Unit.Azure.Synapse;
+
+using System;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using NetEvolve.Extensions.TUnit;
+using NetEvolve.HealthChecks.Azure.Synapse;
+
+[TestGroup($"{nameof(Azure)}.{nameof(Synapse)}")]
+public class SynapseWorkspaceAvailableConfigureTests
+{
+    [Test]
+    public void Validate_WhenArgumentsAreValidForConnectionString_ShouldReturnSuccess()
+    {
+        // Arrange
+        var configuration = new ConfigurationBuilder().Build();
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var configure = new SynapseWorkspaceAvailableConfigure(configuration, serviceProvider);
+        var options = new SynapseWorkspaceAvailableOptions
+        {
+            ConnectionString = "Endpoint=https://myworkspace.dev.azuresynapse.net;",
+            Mode = SynapseClientCreationMode.ConnectionString,
+            Timeout = 100
+        };
+
+        // Act
+        var result = configure.Validate("Test", options);
+
+        // Assert
+        Assert.True(result.Succeeded);
+    }
+
+    [Test]
+    public void Validate_WhenArgumentsAreValidForDefaultAzureCredentials_ShouldReturnSuccess()
+    {
+        // Arrange
+        var configuration = new ConfigurationBuilder().Build();
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var configure = new SynapseWorkspaceAvailableConfigure(configuration, serviceProvider);
+        var options = new SynapseWorkspaceAvailableOptions
+        {
+            WorkspaceUri = new Uri("https://myworkspace.dev.azuresynapse.net"),
+            Mode = SynapseClientCreationMode.DefaultAzureCredentials,
+            Timeout = 100
+        };
+
+        // Act
+        var result = configure.Validate("Test", options);
+
+        // Assert
+        Assert.True(result.Succeeded);
+    }
+
+    [Test]
+    public void Validate_WhenConnectionStringIsInvalid_ShouldReturnFailure()
+    {
+        // Arrange
+        var configuration = new ConfigurationBuilder().Build();
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var configure = new SynapseWorkspaceAvailableConfigure(configuration, serviceProvider);
+        var options = new SynapseWorkspaceAvailableOptions
+        {
+            ConnectionString = "InvalidConnectionString",
+            Mode = SynapseClientCreationMode.ConnectionString,
+            Timeout = 100
+        };
+
+        // Act
+        var result = configure.Validate("Test", options);
+
+        // Assert
+        Assert.False(result.Succeeded);
+        Assert.Contains("Endpoint", result.FailureMessage);
+    }
+
+    [Test]
+    public void Validate_WhenWorkspaceUriIsNull_ShouldReturnFailure()
+    {
+        // Arrange
+        var configuration = new ConfigurationBuilder().Build();
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var configure = new SynapseWorkspaceAvailableConfigure(configuration, serviceProvider);
+        var options = new SynapseWorkspaceAvailableOptions
+        {
+            WorkspaceUri = null,
+            Mode = SynapseClientCreationMode.DefaultAzureCredentials,
+            Timeout = 100
+        };
+
+        // Act
+        var result = configure.Validate("Test", options);
+
+        // Assert
+        Assert.False(result.Succeeded);
+        Assert.Contains("workspace uri cannot be null", result.FailureMessage);
+    }
+}