Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
16 commits
Select commit Hold shift + click to select a range
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -0,0 +1,95 @@
using System.Collections.Immutable;
using System.Composition.Hosting;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.Loader;
using DimensionalQuantities.IntegrationTests.Delivery;
using DimensionalQuantities.IntegrationTests.Fixtures;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Xunit;

namespace DimensionalQuantities.IntegrationTests;

[Collection(typeof(PackageDeliveryCollection))]
public sealed class DeliveredCodeFixTests
{
private readonly PackageDeliveryFixture _fixture;

public DeliveredCodeFixTests(PackageDeliveryFixture fixture)
{
_fixture = fixture;
}

[Fact]
public async Task PackagedMefExportLoadsAndReplacesRawQuantityWithSafeAlias()
{
using PackageSandbox sandbox = _fixture.CreateConsumer();
string extracted = Path.Combine(sandbox.Root, "extracted");
ZipFile.ExtractToDirectory(sandbox.ArchivePath("DimensionalQuantities"), extracted);
string codeFixPath = Path.Combine(extracted, "analyzers/dotnet/cs/DimensionalQuantities.Roslyn.CodeFixes.dll");
AssemblyLoadContext loadContext = new("delivered-fix-" + Guid.NewGuid(), isCollectible: true);
loadContext.Resolving += (_, name) => AssemblyLoadContext.Default.LoadFromAssemblyName(name);
try
{
Assembly delivered = loadContext.LoadFromAssemblyPath(codeFixPath);
using CompositionHost exports = new ContainerConfiguration().WithAssembly(delivered).CreateContainer();
CodeFixProvider provider = Assert.Single(exports.GetExports<CodeFixProvider>());
Assert.Multiple(
() => Assert.Equal(codeFixPath, delivered.Location),
() => Assert.Equal(["DQ0003"], provider.FixableDiagnosticIds));

const string source = """
using DimensionalQuantities.TypeSystem;
using Length = DimensionalQuantities.TypeSystem.Quantity<DimensionalQuantities.TypeSystem.Dimension<
DimensionalQuantities.TypeSystem.TerminalHex1, DimensionalQuantities.TypeSystem.TerminalHex0,
DimensionalQuantities.TypeSystem.TerminalHex0, DimensionalQuantities.TypeSystem.TerminalHex0,
DimensionalQuantities.TypeSystem.TerminalHex0, DimensionalQuantities.TypeSystem.TerminalHex0,
DimensionalQuantities.TypeSystem.TerminalHex0>>;
class Example
{
Quantity<Dimension<TerminalHex1, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>> value;
}
""";
using AdhocWorkspace workspace = new();
Project project = workspace.AddProject("Consumer", LanguageNames.CSharp)
.WithParseOptions(new CSharpParseOptions(LanguageVersion.Preview))
.WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddMetadataReferences(((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator)
.Where(path => !Path.GetFileName(path).StartsWith("DimensionalQuantities", StringComparison.Ordinal))
.Select(path => MetadataReference.CreateFromFile(path)))
.AddMetadataReference(MetadataReference.CreateFromFile(Path.Combine(extracted, "lib/netstandard2.0/DimensionalQuantities.dll")));
Document document = project.AddDocument("Consumer.cs", SourceText.From(source));
Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!;
Diagnostic[] setupErrors = [.. compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)];
if (setupErrors.Length > 0)
{
throw new InvalidOperationException("Invalid code-fix fixture:" + Environment.NewLine + string.Join(Environment.NewLine, setupErrors.Select(diagnostic => diagnostic.ToString())));
}
SyntaxNode root = (await document.GetSyntaxRootAsync(TestContext.Current.CancellationToken))!;
GenericNameSyntax quantity = root.DescendantNodes().OfType<FieldDeclarationSyntax>().Single().Declaration.Type.DescendantNodesAndSelf().OfType<GenericNameSyntax>().First();
Diagnostic diagnostic = Diagnostic.Create(new DiagnosticDescriptor("DQ0003", "Alias", "Use alias", "Usage", DiagnosticSeverity.Info, true),
quantity.GetLocation(), ImmutableDictionary<string, string?>.Empty.Add("AliasName", "Length"));
List<CodeAction> actions = [];
await provider.RegisterCodeFixesAsync(new CodeFixContext(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken));
CodeAction action = Assert.Single(actions);
ApplyChangesOperation operation = Assert.Single((await action.GetOperationsAsync(TestContext.Current.CancellationToken)).OfType<ApplyChangesOperation>());
string updated = (await operation.ChangedSolution.GetDocument(document.Id)!.GetTextAsync(TestContext.Current.CancellationToken)).ToString();
Compilation updatedCompilation = (await operation.ChangedSolution.GetDocument(document.Id)!.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!;
Assert.Multiple(
() => Assert.Equal("Use Length", action.Title),
() => Assert.Contains("""
class Example
{
Length value;
}
""", updated),
() => Assert.Empty(updatedCompilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(d => d.Severity == DiagnosticSeverity.Error)));
}
finally { loadContext.Unload(); }
}
}
147 changes: 147 additions & 0 deletions src/DimensionalQuantities.IntegrationTests/Delivery/PackageSandbox.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,147 @@
using System.Diagnostics;
using System.IO.Compression;
using System.Reflection;
using System.Xml.Linq;

namespace DimensionalQuantities.IntegrationTests.Delivery;

internal sealed class PackageSandbox : IDisposable
{
public string Root { get; } = Path.Combine(Path.GetTempPath(), "dq-consumer-" + Guid.NewGuid().ToString("N"));
public string Feed => Path.Combine(Root, "feed");
public string Consumer => Path.Combine(Root, "consumer");
public string Cache => Path.Combine(Root, "packages");
public string Version { get; private set; } = "";

public PackageSandbox()
{
Directory.CreateDirectory(Feed);
Directory.CreateDirectory(Consumer);
File.WriteAllText(Path.Combine(Root, "NuGet.Config"), $"<configuration><packageSources><clear/><add key=\"local\" value=\"{Feed}\"/></packageSources></configuration>");
}

public async Task Pack(params string[] optionalPackages)
{
string repository = AppContext.BaseDirectory;
while (!File.Exists(Path.Combine(repository, "global.json")))
{
repository = Directory.GetParent(repository)!.FullName;
}

File.Copy(Path.Combine(repository, "global.json"), Path.Combine(Root, "global.json"), overwrite: true);
string configuration = typeof(PackageSandbox).Assembly.GetCustomAttribute<AssemblyConfigurationAttribute>()!.Configuration;

foreach (string id in new[] { "DimensionalQuantities" }.Concat(optionalPackages).Distinct())
{
ProcessResult result = await Run(repository, "pack", Path.Combine(repository, "src", id, id + ".csproj"), "-c", configuration, "--no-build", "--no-restore", "-o", Feed, "-p:NuspecOutputPath=" + Path.Combine(Root, "nuspec", id), "--nologo");
result.EnsureSuccess();
}

using ZipArchive archive = ZipFile.OpenRead(ArchivePath("DimensionalQuantities"));
using Stream stream = archive.Entries.Single(e => e.FullName.EndsWith(".nuspec", StringComparison.Ordinal)).Open();
Version = XDocument.Load(stream).Descendants().Single(e => e.Name.LocalName == "version").Value;
}

public string ArchivePath(string id, bool symbols = false) => Directory.GetFiles(Feed, id + ".*." + (symbols ? "snupkg" : "nupkg"))
.Single(path => Path.GetFileName(path).StartsWith(id + ".", StringComparison.Ordinal) &&
!Path.GetFileName(path)[(id.Length + 1)..].StartsWith("Extensions.", StringComparison.Ordinal));

public PackageSandbox CreateConsumer()
{
PackageSandbox consumer = new();
consumer.Version = Version;
File.Copy(Path.Combine(Root, "global.json"), Path.Combine(consumer.Root, "global.json"));
foreach (string archive in Directory.GetFiles(Feed))
{
File.Copy(archive, Path.Combine(consumer.Feed, Path.GetFileName(archive)));
}
return consumer;
}

public async Task PackProducer(string id, string source, params string[] packageIds)
{
string directory = Path.Combine(Root, id);
Directory.CreateDirectory(directory);
string references = string.Join("\n", packageIds.Select(packageId => $"<PackageReference Include=\"{packageId}\" Version=\"[{Version}]\"/>"));
File.WriteAllText(Path.Combine(directory, id + ".csproj"), $$"""
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net11.0</TargetFramework>
<LangVersion>preview</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<PackageVersion>{{Version}}</PackageVersion>
</PropertyGroup>
<ItemGroup>
{{references}}
</ItemGroup>
</Project>
""");
File.WriteAllText(Path.Combine(directory, id + ".cs"), source);
(await Run(directory, "restore", "--configfile", Path.Combine(Root, "NuGet.Config"), "--packages", Cache, "--nologo")).EnsureSuccess();
(await Run(directory, "pack", "-c", "Release", "--no-restore", "-o", Feed, "--nologo")).EnsureSuccess();
}

public void WriteConsumer(string source, params string[] packageIds)
{
string references = string.Join("\n", packageIds.Select(id => $"<PackageReference Include=\"{id}\" Version=\"[{Version}]\"/>"));
File.WriteAllText(Path.Combine(Consumer, "Consumer.csproj"), $$"""
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup><TargetFramework>net11.0</TargetFramework><OutputType>Exe</OutputType><LangVersion>preview</LangVersion><ImplicitUsings>enable</ImplicitUsings></PropertyGroup>
<ItemGroup>{{references}}</ItemGroup>
</Project>
""");
File.WriteAllText(Path.Combine(Consumer, "Program.cs"), source);
}

public async Task<ProcessResult> BuildConsumer()
{
(await Run(Consumer, "restore", "--configfile", Path.Combine(Root, "NuGet.Config"), "--packages", Cache, "--nologo")).EnsureSuccess();
return await Run(Consumer, "build", "-c", "Release", "--no-restore", "--nologo");
}

public async Task<string> ExecuteConsumer()
{
(await BuildConsumer()).EnsureSuccess();
return await ExecuteBuiltConsumer();
}

public async Task<string> ExecuteBuiltConsumer()
{
ProcessResult result = await Run(Consumer, Path.Combine(Consumer, "bin", "Release", "net11.0", "Consumer.dll"));
result.EnsureSuccess();
return result.Output.Trim();
}

public async Task<ProcessResult> Run(string workingDirectory, params string[] arguments)
{
ProcessStartInfo start = new("dotnet") { WorkingDirectory = workingDirectory, RedirectStandardOutput = true, RedirectStandardError = true };
foreach (string argument in arguments)
{
start.ArgumentList.Add(argument);
}

if (workingDirectory == Consumer)
{
start.Environment["NUGET_PACKAGES"] = Cache;
}

using Process process = Process.Start(start)!;
Task<string> stdout = process.StandardOutput.ReadToEndAsync();
Task<string> stderr = process.StandardError.ReadToEndAsync();
await process.WaitForExitAsync();
return new(process.ExitCode, await stdout + "\n" + await stderr);
}

public void Dispose() => Directory.Delete(Root, recursive: true);

internal sealed record ProcessResult(int ExitCode, string Output)
{
public void EnsureSuccess()
{
if (ExitCode != 0)
{
throw new InvalidOperationException($"dotnet exited {ExitCode}:\n{Output}");
}
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -9,15 +9,16 @@
<ItemGroup>
<PackageReference Include="xunit.v3" Version="4.0.2" />
<PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="2.5.2" />
<PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="5.9.0" />
<PackageReference Include="System.Composition.AttributedModel" Version="10.0.14" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="../DimensionalQuantities/DimensionalQuantities.csproj" />
<ProjectReference Include="../DimensionalQuantities.Roslyn/DimensionalQuantities.Roslyn.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
<Analyzer Include="../DimensionalQuantities/bin/$(Configuration)/netstandard2.0/DimensionalQuantities.dll" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Build" Version="18.11.0" ExcludeAssets="runtime" PrivateAssets="all" />
<PackageReference Include="Microsoft.Build.Locator" Version="1.11.2" />
<PackageReference Include="MSBuild.ProjectCreation" Version="20.0.0" />
<ProjectReference Include="../DimensionalQuantities.Roslyn/DimensionalQuantities.Roslyn.csproj" />
<ProjectReference Include="../DimensionalQuantities.Roslyn.CodeFixes/DimensionalQuantities.Roslyn.CodeFixes.csproj" />
<ProjectReference Include="../DimensionalQuantities.Extensions.Metric/DimensionalQuantities.Extensions.Metric.csproj" />
<ProjectReference Include="../DimensionalQuantities.Extensions.Imperial/DimensionalQuantities.Extensions.Imperial.csproj" />
<ProjectReference Include="../DimensionalQuantities.Extensions.Nautical/DimensionalQuantities.Extensions.Nautical.csproj" />
<ProjectReference Include="../DimensionalQuantities.Extensions.CgsEmag/DimensionalQuantities.Extensions.CgsEmag.csproj" />
</ItemGroup>
</Project>
Original file line number Diff line number Diff line change
@@ -0,0 +1,8 @@
using Xunit;

namespace DimensionalQuantities.IntegrationTests.Fixtures;

[CollectionDefinition]
public sealed class PackageArchiveCollection : ICollectionFixture<PackageArchiveFixture>
{
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,32 @@
using DimensionalQuantities.IntegrationTests.Delivery;
using Xunit;

namespace DimensionalQuantities.IntegrationTests.Fixtures;

public sealed class PackageArchiveFixture : IAsyncLifetime
{
internal PackageSandbox Packages { get; } = new();

public async ValueTask InitializeAsync()
{
try
{
await Packages.Pack(
"DimensionalQuantities.Extensions.Metric",
"DimensionalQuantities.Extensions.Imperial",
"DimensionalQuantities.Extensions.Nautical",
"DimensionalQuantities.Extensions.CgsEmag");
}
catch
{
Packages.Dispose();
throw;
}
}

public ValueTask DisposeAsync()
{
Packages.Dispose();
return ValueTask.CompletedTask;
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,8 @@
using Xunit;

namespace DimensionalQuantities.IntegrationTests.Fixtures;

[CollectionDefinition]
public sealed class PackageDeliveryCollection : ICollectionFixture<PackageDeliveryFixture>
{
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
using DimensionalQuantities.IntegrationTests.Delivery;
using Xunit;

namespace DimensionalQuantities.IntegrationTests.Fixtures;

public sealed class PackageDeliveryFixture : IAsyncLifetime
{
private readonly PackageSandbox _packages = new();

internal PackageSandbox CreateConsumer() => _packages.CreateConsumer();

public async ValueTask InitializeAsync()
{
try
{
await _packages.Pack(
"DimensionalQuantities.Extensions.Metric",
"DimensionalQuantities.Extensions.Imperial",
"DimensionalQuantities.Extensions.Nautical",
"DimensionalQuantities.Extensions.CgsEmag");
}
catch
{
_packages.Dispose();
throw;
}
}

public ValueTask DisposeAsync()
{
_packages.Dispose();
return ValueTask.CompletedTask;
}
}
Loading
Loading