|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Aspire.Hosting.ApplicationModel;
using Aspire.Hosting.Testing;
using Aspire.Hosting.Utils;
namespace Aspire.Hosting.Azure.Kusto.Tests;
public class AddAzureKustoTests
{
[Fact]
public void AddAzureKustoCluster_ShouldCreateAzureKustoClusterResourceWithCorrectName()
{
// Arrange
const string name = "kusto";
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster(name);
// Assert
Assert.NotNull(resourceBuilder);
Assert.NotNull(resourceBuilder.Resource);
Assert.Equal(name, resourceBuilder.Resource.Name);
Assert.IsType<AzureKustoClusterResource>(resourceBuilder.Resource);
}
[Theory]
[InlineData(null, "latest")]
[InlineData("custom-tag", "custom-tag")]
public void RunAsEmulator_ShouldConfigureContainerImageWithCorrectTag(string? customTag, string expectedTag)
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("test-kusto").RunAsEmulator(containerBuilder =>
{
if (!string.IsNullOrEmpty(customTag))
{
containerBuilder.WithImageTag(customTag);
}
});
// Assert
var containerAnnotation = resourceBuilder.Resource.Annotations.OfType<ContainerImageAnnotation>().SingleOrDefault();
Assert.NotNull(containerAnnotation);
Assert.Equal(expectedTag, containerAnnotation.Tag);
}
[Theory]
[InlineData(null)]
[InlineData(9090)]
public void RunAsEmulator_ShouldConfigureHttpEndpoint(int? port)
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("kusto").RunAsEmulator(containerBuilder =>
{
containerBuilder.WithEndpoint("http", endpoint => endpoint.Port = port);
});
// Assert
var endpointAnnotations = resourceBuilder.Resource.Annotations.OfType<EndpointAnnotation>().ToList();
var httpEndpoint = endpointAnnotations.SingleOrDefault(e => e.Name == "http");
Assert.NotNull(httpEndpoint);
Assert.Equal(port, httpEndpoint.Port);
Assert.Equal(AzureKustoEmulatorContainerDefaults.DefaultTargetPort, httpEndpoint.TargetPort);
Assert.Equal("http", httpEndpoint.UriScheme);
}
[Fact]
public void RunAsEmulator_ShouldAddEmulatorResourceAnnotation()
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
const string resourceName = "test-kusto";
// Act
var resourceBuilder = builder.AddAzureKustoCluster(resourceName).RunAsEmulator();
// Assert
var emulatorAnnotation = resourceBuilder.Resource.Annotations.OfType<EmulatorResourceAnnotation>().SingleOrDefault();
Assert.NotNull(emulatorAnnotation);
}
[Fact]
public async Task RunAsEmulator_RespectsConfigurationCallback()
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("kusto").RunAsEmulator(builder =>
{
builder.WithAnnotation(new ContainerNameAnnotation() { Name = "custom-kusto-emulator" });
builder.WithContainerRuntimeArgs("--memory", "4G");
});
// Assert
var nameAnnotation = resourceBuilder.Resource.Annotations.OfType<ContainerNameAnnotation>().SingleOrDefault();
Assert.NotNull(nameAnnotation);
Assert.Equal("custom-kusto-emulator", nameAnnotation.Name);
var argsAnnotation = resourceBuilder.Resource.Annotations.OfType<ContainerRuntimeArgsCallbackAnnotation>().SingleOrDefault();
Assert.NotNull(argsAnnotation);
Assert.Equivalent(new[] { "--memory", "4G" }, await argsAnnotation.GetContainerRuntimeArgs());
}
[Fact]
public async Task RunAsEmulator_SetsEula()
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("kusto").RunAsEmulator();
// Assert
var annotation = resourceBuilder.Resource.Annotations.OfType<EnvironmentCallbackAnnotation>().SingleOrDefault();
Assert.NotNull(annotation);
var env = await builder.GetEnvironmentVariables(annotation);
Assert.Equivalent(new Dictionary<string, object>() { { "ACCEPT_EULA", "Y" } }, env);
}
[Theory]
[InlineData("")]
[InlineData(" ")]
public void AddAzureKustoCluster_WithInvalidName_ShouldThrowArgumentException(string? invalidName)
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act & Assert
Assert.Throws<ArgumentException>(() => builder.AddAzureKustoCluster(invalidName!));
}
[Theory]
[InlineData(null)]
public void AddAzureKustoCluster_WithNullName_ShouldThrowArgumentNullException(string? invalidName)
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act & Assert
Assert.Throws<ArgumentNullException>(() => builder.AddAzureKustoCluster(invalidName!));
}
[Fact]
public void AddAzureKustoCluster_WithNullBuilder_ShouldThrowArgumentNullException()
{
// Act & Assert
Assert.Throws<ArgumentNullException>(() => ((IDistributedApplicationBuilder)null!).AddAzureKustoCluster("test"));
}
[Fact]
public void RunAsEmulator_WithNullBuilder_ShouldThrowArgumentNullException()
{
// Act & Assert
Assert.Throws<ArgumentNullException>(() => ((IResourceBuilder<AzureKustoClusterResource>)null!).RunAsEmulator());
}
[Fact]
public void AzureKustoClusterResource_ShouldImplementIResourceWithConnectionString()
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("kusto");
// Assert
Assert.IsType<IResourceWithConnectionString>(resourceBuilder.Resource, exactMatch: false);
}
[Theory]
[InlineData(true)]
[InlineData(false)]
public void IsEmulator_ShouldReturnWhenRunAsEmulator(bool runAsEmulator)
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
var resourceBuilder = builder.AddAzureKustoCluster("test-kusto");
// Act
if (runAsEmulator)
{
resourceBuilder = resourceBuilder.RunAsEmulator();
}
// Assert
Assert.Equal(runAsEmulator, resourceBuilder.Resource.IsEmulator);
}
[Theory]
[InlineData(true)]
[InlineData(false)]
public void RunAsEmulator_WithVolume_ShouldConfigureVolumeAnnotation(bool isReadOnly)
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("test-kusto").RunAsEmulator(containerBuilder =>
{
containerBuilder.WithVolume($"{builder.GetVolumePrefix()}-test-kusto-data", "/data", isReadOnly);
});
// Assert
var volumeAnnotation = resourceBuilder.Resource.Annotations.OfType<ContainerMountAnnotation>().SingleOrDefault();
Assert.NotNull(volumeAnnotation);
Assert.Equal($"{builder.GetVolumePrefix()}-test-kusto-data", volumeAnnotation.Source);
Assert.Equal("/data", volumeAnnotation.Target);
Assert.Equal(ContainerMountType.Volume, volumeAnnotation.Type);
Assert.Equal(isReadOnly, volumeAnnotation.IsReadOnly);
}
[Theory]
[InlineData(true)]
[InlineData(false)]
public void RunAsEmulator_WithBindMount_ShouldConfigureBindMountAnnotation(bool isReadOnly)
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("test-kusto").RunAsEmulator(containerBuilder =>
{
containerBuilder.WithBindMount("./custom-data", "/data", isReadOnly);
});
// Assert
var mountAnnotation = resourceBuilder.Resource.Annotations.OfType<ContainerMountAnnotation>().SingleOrDefault();
Assert.NotNull(mountAnnotation);
Assert.Equal(Path.Combine(builder.AppHostDirectory, "custom-data"), mountAnnotation.Source);
Assert.Equal("/data", mountAnnotation.Target);
Assert.Equal(ContainerMountType.BindMount, mountAnnotation.Type);
Assert.Equal(isReadOnly, mountAnnotation.IsReadOnly);
}
[Fact]
public void RunAsEmulator_WithBothVolumeAndBindMount_ShouldHaveBothAnnotations()
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("test-kusto").RunAsEmulator(containerBuilder =>
{
containerBuilder.WithVolume("volume-data", "/data")
.WithBindMount("./config", "/app/config", isReadOnly: true);
});
// Assert
var mountAnnotations = resourceBuilder.Resource.Annotations.OfType<ContainerMountAnnotation>().ToList();
Assert.Equal(2, mountAnnotations.Count);
var volumeAnnotation = mountAnnotations.SingleOrDefault(a => a.Type == ContainerMountType.Volume);
Assert.NotNull(volumeAnnotation);
Assert.Equal("volume-data", volumeAnnotation.Source);
Assert.Equal("/data", volumeAnnotation.Target);
var bindMountAnnotation = mountAnnotations.SingleOrDefault(a => a.Type == ContainerMountType.BindMount);
Assert.NotNull(bindMountAnnotation);
Assert.Equal("/app/config", bindMountAnnotation.Target);
Assert.True(bindMountAnnotation.IsReadOnly);
}
[Fact]
public void RunAsEmulator_WithCustomImage_ShouldUseSpecifiedValues()
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
const string customRegistry = "custom.registry.com";
const string customImage = "custom-kusto-image";
const string customTag = "custom-tag";
// Act
var resourceBuilder = builder.AddAzureKustoCluster("test-kusto").RunAsEmulator(containerBuilder =>
{
containerBuilder.WithImageRegistry(customRegistry).WithImage(customImage).WithImageTag(customTag);
});
// Assert
var containerImageAnnotation = resourceBuilder.Resource.Annotations.OfType<ContainerImageAnnotation>().SingleOrDefault();
Assert.NotNull(containerImageAnnotation);
Assert.Equal(customRegistry, containerImageAnnotation.Registry);
Assert.Equal(customImage, containerImageAnnotation.Image);
Assert.Equal(customTag, containerImageAnnotation.Tag);
}
[Fact]
public void RunAsEmulator_WithCustomLifetime_ShouldConfigureLifetimeAnnotation()
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("test-kusto").RunAsEmulator(containerBuilder =>
{
containerBuilder.WithLifetime(ContainerLifetime.Persistent);
});
// Assert
var lifetimeAnnotation = resourceBuilder.Resource.Annotations.OfType<ContainerLifetimeAnnotation>().SingleOrDefault();
Assert.NotNull(lifetimeAnnotation);
Assert.Equal(ContainerLifetime.Persistent, lifetimeAnnotation.Lifetime);
}
[Fact]
public void AddAzureKustoCluster_ShouldAddHealthCheckAnnotation()
{
// Arrange
const string name = "kusto";
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var kustoServer = builder.AddAzureKustoCluster(name);
// Assert
Assert.Single(kustoServer.Resource.Annotations, annotation => annotation is HealthCheckAnnotation hca && hca.Key == $"{name}_check");
}
[Fact]
public void AddDatabase_ShouldAddHealthCheckAnnotation()
{
// Arrange
const string name = "db";
using var builder = TestDistributedApplicationBuilder.Create();
var kusto = builder.AddAzureKustoCluster("kusto");
// Act
var database = kusto.AddReadWriteDatabase(name);
// Assert
Assert.Single(database.Resource.Annotations, annotation => annotation is HealthCheckAnnotation hca && hca.Key == $"{name}_check");
}
[Theory]
[InlineData(9090)]
[InlineData(8080)]
[InlineData(1234)]
public void WithHostPort_ShouldSetHttpEndpointPort(int port)
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
// Act
var resourceBuilder = builder.AddAzureKustoCluster("kusto")
.RunAsEmulator(c => c.WithHostPort(port));
// Assert
var endpointAnnotations = resourceBuilder.Resource.Annotations.OfType<EndpointAnnotation>().ToList();
var httpEndpoint = endpointAnnotations.SingleOrDefault(e => e.Name == "http");
Assert.NotNull(httpEndpoint);
Assert.Equal(port, httpEndpoint.Port);
Assert.Equal(AzureKustoEmulatorContainerDefaults.DefaultTargetPort, httpEndpoint.TargetPort);
Assert.Equal("http", httpEndpoint.UriScheme);
}
[Fact]
public void WithHostPort_ShouldThrowArgumentNullException_WhenBuilderIsNull()
{
// Arrange
IResourceBuilder<AzureKustoClusterResource> builder = null!;
// Act & Assert
var exception = Assert.Throws<ArgumentNullException>(() => builder.RunAsEmulator(c => c.WithHostPort(8080)));
Assert.Equal("builder", exception.ParamName);
}
[Fact]
public void GetDatabaseCreationScript_WithoutCreationScriptAnnotation_ShouldReturnDefaultCommand()
{
// Arrange
using var builder = TestDistributedApplicationBuilder.Create();
var kusto = builder.AddAzureKustoCluster("kusto");
var database = kusto.AddReadWriteDatabase("testdb");
// Act
var script = database.Resource.GetDatabaseCreationScript();
// Assert
Assert.Equal(".create database testdb persist (h\"/kustodata/dbs/testdb/md\", h\"/kustodata/dbs/testdb/data\") ifnotexists", script);
}
[Fact]
public void GetDatabaseCreationScript_WithVolatileCreationScript_ShouldReturnCustomScript()
{
// Arrange
const string expected = ".create database testdb volatile";
using var builder = TestDistributedApplicationBuilder.Create();
var kusto = builder.AddAzureKustoCluster("kusto");
var database = kusto.AddReadWriteDatabase("testdb")
.WithCreationScript(expected);
// Act
var script = database.Resource.GetDatabaseCreationScript();
// Assert
Assert.Equal(expected, script);
}
[Fact]
public void GetDatabaseCreationScript_WithMultipleAnnotations_ShouldReturnLastAnnotation()
{
// Arrange
const string first = ".create database testdb persist (@'/some/path')";
const string second = ".create database testdb volatile";
using var builder = TestDistributedApplicationBuilder.Create();
var kusto = builder.AddAzureKustoCluster("kusto");
var database = kusto.AddReadWriteDatabase("testdb")
.WithCreationScript(first)
.WithCreationScript(second);
// Act
var script = database.Resource.GetDatabaseCreationScript();
// Assert
Assert.Equal(second, script);
}
}
file static class TestingExtensions
{
public static async Task<Dictionary<string, object>> GetEnvironmentVariables(this IDistributedApplicationTestingBuilder builder, EnvironmentCallbackAnnotation annotation)
{
var context = new EnvironmentCallbackContext(builder.ExecutionContext);
await annotation.Callback(context);
return context.EnvironmentVariables;
}
public static async Task<IList<object>> GetContainerRuntimeArgs(this ContainerRuntimeArgsCallbackAnnotation annotation)
{
var results = new List<object>();
var context = new ContainerRuntimeArgsCallbackContext(results);
await annotation.Callback(context);
return context.Args;
}
}
|