public void ProcessTests(ProjectComponents components, ProjectOutputType outputType, string startingTfmString, string expectedTfmString, bool tryUpdate)
{
// Arrange
var fixture = new Fixture();
using var mock = AutoMock.GetLoose();
var tfm = ParseTfm(startingTfmString);
var expectedTfm = ParseTfm(expectedTfmString);
var project = new Mock <IProject>();
project.Setup(p => p.OutputType).Returns(outputType);
var state = new Mock <ITargetFrameworkSelectorFilterState>();
state.Setup(s => s.Current).Returns(tfm);
state.Setup(s => s.Project).Returns(project.Object);
state.Setup(s => s.Components).Returns(components);
var filter = mock.Create <WindowsSdkTargetFrameworkSelectorFilter>();
// Act
filter.Process(state.Object);
// Assert
var count = tryUpdate ? Times.Once() : Times.Never();
state.Verify(s => s.TryUpdate(expectedTfm), count);
}
public async Task SdkTypesAsync(string[] sdk, ProjectComponents expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var projectFile = mock.Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(true);
projectFile.Setup(f => f.Sdk).Returns(new HashSet <string>(sdk, StringComparer.OrdinalIgnoreCase));
projectFile.Setup(f => f.GetPropertyValue(It.IsAny <string>())).Returns(string.Empty);
var project = mock.Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.TargetFrameworks).Returns(Array.Empty <TargetFrameworkMoniker>());
project.Setup(p => p.NuGetReferences).Returns(mock.Mock <INuGetReferences>().Object);
var componentIdentifier = mock.Create <WebComponentIdentifier>();
// Act
var components = await componentIdentifier.GetComponentsAsync(project.Object, default).ConfigureAwait(false);
// Assert
Assert.Equal(expected, components);
}
public async Task IsApplicableTests(ProjectComponents component, bool expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var logger = mock.Mock <ILogger <WinformsDefaultFontUpdater> >();
var updater = new WinformsDefaultFontUpdater(logger.Object);
var projectFile = mock.Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(true);
var project = mock.Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.FileInfo).Returns(new FileInfo("./test"));
project.Setup(p => p.GetComponentsAsync(CancellationToken.None)).ReturnsAsync(component);
var context = mock.Mock <IUpgradeContext>();
context.Setup(c => c.Projects).Returns(new[] { project.Object });
// Act
var updaterResult = await updater.IsApplicableAsync(context.Object, ImmutableArray <IProject> .Empty.Add(project.Object), CancellationToken.None).ConfigureAwait(false);
// Assert
Assert.Equal(expected, updaterResult.Result);
}
public async Task SdkPropertiesAsync(string propertyName, string value, ProjectComponents expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
mock.Mock <ITransitiveDependencyIdentifier>()
.Setup(p => p.GetTransitiveDependenciesAsync(It.IsAny <IEnumerable <NuGetReference> >(), It.IsAny <IEnumerable <TargetFrameworkMoniker> >(), default))
.ReturnsAsync(TransitiveClosureCollection.Empty);
var projectFile = new Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(true);
projectFile.Setup(f => f.Sdk).Returns(Array.Empty <string>());
projectFile.Setup(f => f.GetPropertyValue(It.IsAny <string>())).Returns(string.Empty);
projectFile.Setup(f => f.GetPropertyValue(propertyName)).Returns(value);
var project = new Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.NuGetReferences).Returns(mock.Mock <INuGetReferences>().Object);
project.Setup(p => p.TargetFrameworks).Returns(Array.Empty <TargetFrameworkMoniker>());
var componentIdentifier = mock.Create <WindowsComponentIdentifier>();
// Act
var components = await componentIdentifier.GetComponentsAsync(project.Object, default).ConfigureAwait(false);
// Assert
Assert.Equal(expected, components);
}
public async Task TransitiveDependenciesAsync(string name, ProjectComponents expected)
{
// Arrange
var fixture = new Fixture();
using var mock = AutoMock.GetLoose();
var projectFile = mock.Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(false);
var nugetPackages = mock.Mock <INuGetReferences>();
nugetPackages.Setup(p => p.IsTransitivelyAvailableAsync(name, default)).ReturnsAsync(true);
var project = mock.Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.NuGetReferences).Returns(nugetPackages.Object);
var componentIdentifier = mock.Create <WindowsComponentIdentifier>();
// Act
var components = await componentIdentifier.GetComponentsAsync(project.Object, default).ConfigureAwait(false);
// Assert
Assert.Equal(expected, components);
}
public void NonSdkImports(string import, ProjectComponents expected)
{
// Arrange
const int Count = 10;
var fixture = new Fixture();
var imports = fixture.CreateMany <string>(Count).ToList();
imports.Insert(Count / 2, import);
using var mock = AutoMock.GetLoose();
var projectFile = mock.Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(false);
projectFile.Setup(p => p.Imports).Returns(imports);
var project = mock.Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
var componentIdentifier = mock.Create <ComponentIdentifier>();
// Act
var components = componentIdentifier.GetComponents(project.Object);
// Assert
Assert.Equal(expected, components);
}
protected override bool OnSaveCanExecute()
{
return(Project != null &&
!Project.HasErrors &&
ProjectComponents.All(pc => !pc.HasErrors) &&
HasChanges);
}
public void SdkFrameworkReferences(string frameworkReference, ProjectComponents expected)
{
// Arrange
const int Count = 10;
var fixture = new Fixture();
var frameworkReferences = fixture.CreateMany <Reference>(Count).ToList();
frameworkReferences.Insert(Count / 2, new Reference(frameworkReference));
using var mock = AutoMock.GetLoose();
var projectFile = mock.Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(true);
projectFile.Setup(f => f.Sdk).Returns(string.Empty);
projectFile.Setup(f => f.GetPropertyValue(It.IsAny <string>())).Returns(string.Empty);
var project = mock.Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.FrameworkReferences).Returns(frameworkReferences);
var componentIdentifier = mock.Create <ComponentIdentifier>();
// Act
var components = componentIdentifier.GetComponents(project.Object);
// Assert
Assert.Equal(expected, components);
}
public async Task NonSdkReferencesAsync(string reference, ProjectComponents expected)
{
// Arrange
const int Count = 10;
var fixture = new Fixture();
var references = fixture.CreateMany <Reference>(Count).ToList();
references.Insert(Count / 2, new Reference(reference));
using var mock = AutoMock.GetLoose();
var projectFile = mock.Mock <IProjectFile>();
var project = mock.Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.References).Returns(references);
project.Setup(p => p.TargetFrameworks).Returns(Array.Empty <TargetFrameworkMoniker>());
project.Setup(p => p.NuGetReferences).Returns(mock.Mock <INuGetReferences>().Object);
var componentIdentifier = mock.Create <WebComponentIdentifier>();
// Act
var components = await componentIdentifier.GetComponentsAsync(project.Object, default).ConfigureAwait(false);
// Assert
Assert.Equal(expected, components);
}
private void OnAddComponentExecute()
{
var newComponent = new ProjectComponentWrapper(new ProjectComponent());
newComponent.PropertyChanged += ProjectComponentWrapper_PropertyChanged;
ProjectComponents.Add(newComponent);
Project.Model.ProjectComponents.Add(newComponent.Model);
newComponent.ComponentName = ""; // Trigger validation :-)
}
private void OnRemoveComponentExecute()
{
SelectedProjectComponent.PropertyChanged -= ProjectComponentWrapper_PropertyChanged;
_projectRepository.RemoveProjectComponent(SelectedProjectComponent.Model);
ProjectComponents.Remove(SelectedProjectComponent);
SelectedProjectComponent = null;
HasChanges = _projectRepository.HasChanges();
((DelegateCommand)SaveCommand).RaiseCanExecuteChanged();
}
public void TransitiveDependencies(string name, ProjectComponents expected)
{
// Arrange
const int Count = 10;
var fixture = new Fixture();
var dependencies = fixture.CreateMany <NuGetReference>(Count).ToList();
dependencies.Insert(Count / 2, fixture.Create <NuGetReference>() with {
Name = name
});
private void InitializeProjectComponents(ICollection <ProjectComponent> projectComponents)
{
foreach (var wrapper in ProjectComponents)
{
wrapper.PropertyChanged -= ProjectComponentWrapper_PropertyChanged;
}
ProjectComponents.Clear();
foreach (var projectComponent in projectComponents)
{
var wrapper = new ProjectComponentWrapper(projectComponent);
ProjectComponents.Add(wrapper);
wrapper.PropertyChanged += ProjectComponentWrapper_PropertyChanged;
}
}
public async Task NoneMarkedOnItem(ProjectComponents components, bool expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var testobj = new TestObjectNone();
var project = mock.Mock <IProject>();
project.Setup(p => p.GetComponentsAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(components);
// Act
var actual = await project.Object.IsApplicableAsync(testobj, default).ConfigureAwait(false);
// Assert
Assert.Equal(expected, actual);
}
public async Task SdkPropertiesAsync(string propertyName, string value, ProjectComponents expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var projectFile = mock.Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(true);
projectFile.Setup(f => f.Sdk).Returns(string.Empty);
projectFile.Setup(f => f.GetPropertyValue(It.IsAny <string>())).Returns(string.Empty);
projectFile.Setup(f => f.GetPropertyValue(propertyName)).Returns(value);
var project = mock.Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.GetNuGetReferencesAsync(default)).ReturnsAsync(mock.Mock <INuGetReferences>().Object);
public async Task ComponentIdentificationByTfmAsync(string[] tfms, ProjectComponents expectedComponents)
{
// Arrange
using var mock = AutoMock.GetLoose();
var projectFile = new Mock <IProjectFile>();
var project = new Mock <IProject>();
project.Setup(p => p.GetProjectPropertyElements()).Returns(new Mock <IProjectPropertyElements>().Object);
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.TargetFrameworks).Returns(tfms.Select(ParseTfm).ToArray() !);
project.Setup(p => p.NuGetReferences).Returns(new Mock <INuGetReferences>().Object);
// Act
var components = await mock.Create <MauiComponentIdentifier>().GetComponentsAsync(project.Object, default).ConfigureAwait(false);
// Assert
Assert.Equal(expectedComponents, components);
}
public async Task IsApplicableMultiProjectTests(ProjectComponents component1, ProjectComponents component2, bool expected, string[] expectedFileLocations)
{
// Arrange
using var mock = AutoMock.GetLoose();
var logger = mock.Mock <ILogger <WinformsDefaultFontUpdater> >();
var updater = new WinformsDefaultFontUpdater(logger.Object);
var projectFile1 = new Mock <IProjectFile>();
projectFile1.Setup(f => f.IsSdk).Returns(true);
var projectFile2 = new Mock <IProjectFile>();
projectFile2.Setup(f => f.IsSdk).Returns(true);
var project1 = new Mock <IProject>();
project1.Setup(p => p.GetFile()).Returns(projectFile1.Object);
project1.Setup(p => p.FileInfo).Returns(new FileInfo("./test1"));
project1.Setup(p => p.GetComponentsAsync(CancellationToken.None)).ReturnsAsync(component1);
var project2 = new Mock <IProject>();
project2.Setup(p => p.GetFile()).Returns(projectFile2.Object);
project2.Setup(p => p.FileInfo).Returns(new FileInfo("./test2"));
project2.Setup(p => p.GetComponentsAsync(CancellationToken.None)).ReturnsAsync(component2);
var context = mock.Mock <IUpgradeContext>();
context.Setup(c => c.Projects).Returns(new[] { project1.Object, project2.Object });
// Act
var updaterResult = (WindowsDesktopUpdaterResult)await updater.IsApplicableAsync(context.Object, context.Object.Projects.ToImmutableArray(), CancellationToken.None).ConfigureAwait(false);
var fileLocations = updaterResult.FileLocations.Select(i => Path.GetFileNameWithoutExtension(i));
// Assert
Assert.Equal(expected, updaterResult.Result);
Assert.Equal(expectedFileLocations, fileLocations);
}
public void ProcessTests(ProjectComponents components, string expectedTfmString, bool tryUpdate)
{
// Arrange
var fixture = new Fixture();
using var mock = AutoMock.GetLoose();
var expectedTfm = ParseTfm(expectedTfmString);
var state = new Mock <ITargetFrameworkSelectorFilterState>();
state.Setup(s => s.Components).Returns(components);
var filter = mock.Create <MauiTargetFrameworkSelectorFilter>();
// Act
filter.Process(state.Object);
// Assert
var count = tryUpdate ? Times.Once() : Times.Never();
state.Verify(s => s.TryUpdate(expectedTfm), count);
}
public void SdkTypes(string sdk, ProjectComponents expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var projectFile = mock.Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(true);
projectFile.Setup(f => f.Sdk).Returns(sdk);
projectFile.Setup(f => f.GetPropertyValue(It.IsAny <string>())).Returns(string.Empty);
var project = mock.Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
var componentIdentifier = mock.Create <ComponentIdentifier>();
// Act
var components = componentIdentifier.GetComponents(project.Object);
// Assert
Assert.Equal(expected, components);
}
public async Task DoesWebNamespaceConfigUpdaterShowForCSharpAspNetCoreAsync(ProjectComponents components, Language language, bool expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var webNamespaceConfigUpdater = mock.Create <WebNamespaceConfigUpdater>();
var project = new Mock <IProject>();
project.Setup(p => p.Language).Returns(language);
project.Setup(p => p.GetComponentsAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(components);
// Act
var actual = await project.Object.IsApplicableAsync(webNamespaceConfigUpdater, default).ConfigureAwait(false);
// Assert
if (expected)
{
Assert.True(actual, "WebNamespaceConfigUpdater should apply to C# ASP.NET Core");
}
else
{
Assert.False(actual, "WebNamespaceConfigUpdater only applies to C# ASP.NET Core");
}
}
public async Task TransitiveDependenciesAsync(string name, ProjectComponents expected)
{
// Arrange
var fixture = new Fixture();
using var mock = AutoMock.GetLoose();
var projectFile = new Mock <IProjectFile>();
projectFile.Setup(f => f.IsSdk).Returns(false);
var transitive = mock.Mock <ITransitiveDependencyIdentifier>();
var result = new TransitiveClosureCollection(new[] { new NuGetReference(name, string.Empty) }.ToLookup(t => t));
transitive
.Setup(p => p.GetTransitiveDependenciesAsync(It.IsAny <IEnumerable <NuGetReference> >(), It.IsAny <IEnumerable <TargetFrameworkMoniker> >(), default))
.ReturnsAsync(result);
var nugetPackages = new Mock <INuGetReferences>();
nugetPackages.Setup(n => n.PackageReferences).Returns(Enumerable.Empty <NuGetReference>());
var project = new Mock <IProject>();
project.Setup(p => p.GetFile()).Returns(projectFile.Object);
project.Setup(p => p.TargetFrameworks).Returns(Array.Empty <TargetFrameworkMoniker>());
project.Setup(p => p.NuGetReferences).Returns(nugetPackages.Object);
var componentIdentifier = mock.Create <WindowsComponentIdentifier>();
// Act
var components = await componentIdentifier.GetComponentsAsync(project.Object, default).ConfigureAwait(false);
// Assert
Assert.Equal(expected, components);
}
public async Task CanCodeFixersApplyToMultipleLanguagesAsync(ProjectComponents components, Language language, bool expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var testCodefixer = typeof(TestCodeFixer);
var project = mock.Mock <IProject>();
project.Setup(p => p.Language).Returns(language);
project.Setup(p => p.GetComponentsAsync(It.IsAny <CancellationToken>()))
.Returns(new ValueTask <ProjectComponents>(Task.FromResult(components)));
// Act
var actual = await testCodefixer.AppliesToProjectAsync(project.Object, default).ConfigureAwait(false);
// Assert
if (expected)
{
Assert.True(actual, "TestCodeFixer should apply to C# and F# for ASP.NET Core");
}
else
{
Assert.False(actual, "TestCodeFixer only applies to C# and F# for ASP.NET Core");
}
}
public async Task CanConfigUpdaterApplyToMultipleLanguagesAsync(ProjectComponents components, Language language, bool expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var testobj = new TestObjectMultipleLanguage();
var project = mock.Mock <IProject>();
project.Setup(p => p.Language).Returns(language);
project.Setup(p => p.GetComponentsAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(components);
// Act
var actual = await project.Object.IsApplicableAsync(testobj, default).ConfigureAwait(false);
// Assert
if (expected)
{
Assert.True(actual, "TestConfigUpdater should apply to C# and F# for ASP.NET Core");
}
else
{
Assert.False(actual, "TestConfigUpdater only applies to C# and F# for ASP.NET Core");
}
}
public void ProcessTests(ProjectComponents components, bool tryUpdate)
{
// Arrange
var fixture = new Fixture();
using var mock = AutoMock.GetLoose();
var tfm = fixture.Create <TargetFrameworkMoniker>();
var state = new Mock <ITargetFrameworkSelectorFilterState>();
state.Setup(s => s.Components).Returns(components);
state.Setup(s => s.AppBase).Returns(tfm);
var filter = mock.Create <WebProjectTargetFrameworkSelectorFilter>();
// Act
filter.Process(state.Object);
// Assert
var count = tryUpdate ? Times.Once() : Times.Never();
state.Verify(s => s.TryUpdate(tfm), count);
}
public async Task NoDependencies(string[] currentTfms, string current, UpgradeTarget target, ProjectComponents components)
{
// Arrange
var fixture = new Fixture();
var tfm = fixture.Create <TargetFrameworkMoniker>();
var finalTfm = fixture.Create <TargetFrameworkMoniker>();
var filter = new TestFilter(tfm);
using var mock = AutoMock.GetLoose(b => b.RegisterInstance(filter).As <ITargetFrameworkSelectorFilter>());
var project = mock.Mock <IProject>();
project.Setup(p => p.TargetFrameworks).Returns(currentTfms.Select(t => ParseTfm(t)).ToArray());
project.Setup(p => p.GetComponentsAsync(default)).Returns(new ValueTask <ProjectComponents>(components));
/// <summary>
/// Initializes a new instance of the <see cref="ApplicableComponentsAttribute"/> class.
/// </summary>
/// <param name="components">The components that a project must contain for the attributed
/// code fix provider to apply to it.</param>
public ApplicableComponentsAttribute(ProjectComponents components)
{
Components = components;
}
public async Task DoesHttpContextCurrentCodeFixerShowForAspNetCoreCSharpAsync(ProjectComponents components, Language language, bool expected)
{
// Arrange
using var mock = AutoMock.GetLoose();
var httpCommonCodeFixer = typeof(HttpContextCurrentCodeFixer);
var project = mock.Mock <IProject>();
project.Setup(p => p.Language).Returns(language);
project.Setup(p => p.GetComponentsAsync(It.IsAny <CancellationToken>()))
.Returns(new ValueTask <ProjectComponents>(Task.FromResult(components)));
// Act
var actual = await httpCommonCodeFixer.AppliesToProjectAsync(project.Object, default).ConfigureAwait(false);
// Assert
if (expected)
{
Assert.True(actual, "HttpContextCurrentCodeFixer should apply to C# ASP.NET Core");
}
else
{
Assert.False(actual, "HttpContextCurrentCodeFixer only applies to C# ASP.NET Core");
}
}
