Code lenses to switch between bicep and JSON module source

src/Bicep.Core.UnitTests/Assertions/CodeLensAssertions.cs

@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+using System.Linq;
+using System.Reactive.Subjects;
+using Bicep.Core.UnitTests.Registry;
+using FluentAssertions;
+using FluentAssertions.Primitives;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+
+namespace Bicep.Core.UnitTests.Assertions;
+
+public static class CodeLensAssertionsExtensions
+{
+ public static CodeLensAssertions Should(this CodeLens codeLens)
+ {
+ return new CodeLensAssertions(codeLens);
+ }
+}
+
+public class CodeLensAssertions : ObjectAssertions<CodeLens, CodeLensAssertions>
+{
+ public CodeLensAssertions(CodeLens subject)
+ : base(subject)
+ {
+ }
+
+ protected override string Identifier => nameof(CodeLens);
+
+ public AndConstraint<CodeLensAssertions> HaveCommandTitle(string title, string because = "", params object[] becauseArgs)
+ {
+ Subject.Command.Should().NotBeNull("Code lens command should not be null");
+ Subject.Command!.Title.Should().Be(title, because, becauseArgs);
+
+ return new(this);
+ }
+
+ public AndConstraint<CodeLensAssertions> HaveCommandName(string commandName, string because = "", params object[] becauseArgs)
+ {
+ Subject.Command.Should().NotBeNull("Code lens command should not be null");
+ Subject.Command!.Name.Should().Be(commandName, because, becauseArgs);
+
+ return new(this);
+ }
+
+ public AndConstraint<CodeLensAssertions> HaveCommandArguments(params string[] commandArguments)
+ {
+ Subject.Command.Should().NotBeNull("Code lens command should not be null");
+ Subject.Command!.Arguments.Should().NotBeNull("Command args should not be null");
+ var actualCommandArguments = Subject.CommandArguments();
+ actualCommandArguments.Should().BeEquivalentTo(commandArguments);
+
+ return new(this);
+ }
+
+ public AndConstraint<CodeLensAssertions> HaveNoCommandArguments()
+ {
+ Subject.CommandArguments().Should().BeEmpty("Command should have no arguments");
+
+ return new(this);
+ }
+
+ public AndConstraint<CodeLensAssertions> HaveRange(Range range, string because = "", params object[] becauseArgs)
+ {
+ Subject.Range.Should().Be(range, because, becauseArgs);
+
+ return new(this);
+ }
+
+
+}

src/Bicep.Core.UnitTests/BicepTestConstants.cs

@@ -2,21 +2,24 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using Azure.Core.Pipeline;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
 using Bicep.Core.Analyzers.Linter;
 using Bicep.Core.Configuration;
+using Bicep.Core.Diagnostics;
 using Bicep.Core.Extensions;
 using Bicep.Core.Features;
 using Bicep.Core.FileSystem;
 using Bicep.Core.Json;
 using Bicep.Core.Registry;
 using Bicep.Core.Registry.Oci;
 using Bicep.Core.Semantics.Namespaces;
-using Bicep.Core.TypeSystem;
+using Bicep.Core.SourceCode;
 using Bicep.Core.TypeSystem.Providers;
-using Bicep.Core.TypeSystem.Providers.Az;
 using Bicep.Core.UnitTests.Configuration;
 using Bicep.Core.UnitTests.Features;
 using Bicep.Core.UnitTests.Mock;
@@ -85,7 +88,7 @@ public static class BicepTestConstants
 
  public static IEnvironment EmptyEnvironment = new TestEnvironment(ImmutableDictionary<string, string?>.Empty);
 
- public static readonly IModuleRestoreScheduler ModuleRestoreScheduler = CreateMockModuleRestoreScheduler();
+ public static readonly IModuleRestoreScheduler ModuleRestoreScheduler = CreateMockModuleDispatcherAndRestoreScheduler().moduleRestoreScheduler;
 
  public static RootConfiguration CreateMockConfiguration(Dictionary<string, object>? customConfigurationData = null, string? configurationPath = null)
  {
@@ -128,10 +131,20 @@ public static IConfigurationManager CreateConfigurationManager(Func<RootConfigur
  public static IFeatureProviderFactory CreateFeatureProviderFactory(FeatureProviderOverrides featureOverrides, IConfigurationManager? configurationManager = null)
  => new OverriddenFeatureProviderFactory(new FeatureProviderFactory(configurationManager ?? CreateFilesystemConfigurationManager()), featureOverrides);
 
- private static IModuleRestoreScheduler CreateMockModuleRestoreScheduler()
+ public static (IModuleDispatcher moduleDispatcher, IModuleRestoreScheduler moduleRestoreScheduler) CreateMockModuleDispatcherAndRestoreScheduler(IArtifactRegistry[]? artifactRegistries = null)
  {
  var moduleDispatcher = StrictMock.Of<IModuleDispatcher>();
- return new ModuleRestoreScheduler(moduleDispatcher.Object);
+ moduleDispatcher.Setup(x => x.RestoreModules(It.IsAny<ImmutableArray<ArtifactReference>>(), It.IsAny<bool>())).
+ ReturnsAsync(true);
+ moduleDispatcher.Setup(x => x.PruneRestoreStatuses());
+
+ MockRepository repository = new(MockBehavior.Strict);
+ var provider = repository.Create<IArtifactRegistryProvider>();
+
+ moduleDispatcher.Setup(m => m.TryGetModuleSources(It.IsAny<ArtifactReference>())).Returns((ArtifactReference reference) =>
+ (artifactRegistries ?? new IArtifactRegistry[] { }).Select(r => r.TryGetSource(reference)).FirstOrDefault(s => s is not null));
+
+ return (moduleDispatcher.Object, new ModuleRestoreScheduler(moduleDispatcher.Object));
  }
 
  public static Mock<ITelemetryProvider> CreateMockTelemetryProvider()

src/Bicep.Core.UnitTests/Extensions/CodeLensExtensions.cs

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Linq;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+
+namespace Bicep.Core.UnitTests.Assertions;
+
+public static class CodeLensExtensions
+{
+ public static string[]? CommandArguments(this CodeLens codeLens)
+ {
+ return codeLens.Command?.Arguments?.Children().Select(token => token.ToString()).ToArray();
+ }
+}

src/Bicep.Core.UnitTests/Utils/OciModuleRegistryHelper.cs

@@ -67,7 +67,7 @@ public static OciArtifactReference CreateModuleReference(string registry, string
  }
  }
 
- // public a new (real) OciArtifactRegistry instance with an empty on-disk cache that can push and pull modules
+ // create a new (real) OciArtifactRegistry instance with an empty on-disk cache that can push and pull modules
  public static (OciArtifactRegistry, MockRegistryBlobClient) CreateModuleRegistry(
  Uri parentModuleUri,
  IFeatureProvider featureProvider)

src/Bicep.Core/Navigation/IArtifactReferenceSyntax.cs

@@ -6,7 +6,7 @@
 namespace Bicep.Core.Navigation;
 
 /// <summary>
-/// Objects that implement IArtifactReferenceSyntax, contain syntax that can reference a foregin artifact, the artifact address
+/// Objects that implement IArtifactReferenceSyntax, contain syntax that can reference a foreign artifact, the artifact address
 /// is returned by `TryGetPath` and `SourceSyntax` contains the source syntax object to use for error propagation.
 /// </summary>
 public interface IArtifactReferenceSyntax

src/Bicep.Core/Registry/DefaultArtifactRegistryProvider.cs

@@ -29,7 +29,12 @@ public DefaultArtifactRegistryProvider(IServiceProvider serviceProvider, IFileRe
  this.serviceProvider = serviceProvider;
  }
 
- // NOTE: The templateUri affects how module aliases are resolved, by determining how the bicepconfig.json is located, which contains alias definitions
+ /// <summary>
+ /// Gets the registries available for module references inside a given template URI.
+ /// </summary>
+ /// <param name="templateUri">URI of the Bicep template source code which contains the module references.
+ /// This is needed to determine the appropriate bicepconfig.json (which contains module alias definitions) and features provider to bind to</param>
+ /// <returns></returns>
  public ImmutableArray<IArtifactRegistry> Registries(Uri templateUri)
  {
  var configuration = configurationManager.GetConfiguration(templateUri);

src/Bicep.Core/Utils/Result.cs

@@ -43,7 +43,7 @@ public bool IsSuccess([NotNullWhen(true)] out TSuccess? success, [NotNullWhen(fa
 
  /// <summary>
  /// Returns the succcessful result, assuming success. Throws an exception if not.
- /// This should only be called if you'e already verified that the result is successful.
+ /// This should only be called if you've already verified that the result is successful.
  /// </summary>
  public TSuccess Unwrap()
  => TryUnwrap() ?? throw new InvalidOperationException("Cannot unwrap a failed result.");