public static async Task SetPropertyAsync_RemoveExistingProperties()
{
var postbuildEventProjectProperties =
IProjectPropertiesFactory.CreateWithPropertyAndValue("PostBuildEvent", "echo $(ProjectDir)");
var success = await systemUnderTest.TrySetPropertyAsync(" ", postbuildEventProjectProperties);
Assert.True(success);
var result = await postbuildEventProjectProperties.GetUnevaluatedPropertyValueAsync("PostBuildEvent");
Assert.Null(result);
}
public async Task OnSetPropertyValueAsync_ToAnythingOtherThanNone_ReturnsSameValue()
{
var provider = new NeutralLanguageValueProvider();
var projectProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue(NeutralLanguageValueProvider.NeutralLanguagePropertyName, "en-GB");
var updatedValue = await provider.OnSetPropertyValueAsync(NeutralLanguageValueProvider.NeutralLanguagePropertyName, "pt-BR", projectProperties);
var valueInProjectProperties = await projectProperties.GetUnevaluatedPropertyValueAsync(NeutralLanguageValueProvider.NeutralLanguagePropertyName);
Assert.Equal(expected: "pt-BR", actual: updatedValue);
Assert.Equal(expected: "en-GB", actual: valueInProjectProperties);
}
public async Task OnSetPropertyValueAsync_ToNoneValue_DeletesTheProperty()
{
var provider = new NeutralLanguageValueProvider();
var projectProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue(NeutralLanguageValueProvider.NeutralLanguagePropertyName, "en-GB");
var updatedValue = await provider.OnSetPropertyValueAsync(NeutralLanguageValueProvider.NeutralLanguagePropertyName, NeutralLanguageValueProvider.NoneValue, projectProperties);
var valueInProjectProperties = await projectProperties.GetUnevaluatedPropertyValueAsync(NeutralLanguageValueProvider.NeutralLanguagePropertyName);
Assert.Null(updatedValue);
Assert.Null(valueInProjectProperties);
}
public async Task WhenGettingTheValue_ReturnsIconAndManifestIfManifestSet()
{
var provider = new ResourceSpecificationKindValueProvider(ITemporaryPropertyStorageFactory.Create());
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue(ResourceSpecificationKindValueProvider.ApplicationManifestMSBuildProperty, @"C:\alpha\beta\app.config");
var result = await provider.OnGetEvaluatedPropertyValueAsync(
ResourceSpecificationKindValueProvider.ResourceSpecificationKindProperty,
string.Empty,
defaultProperties);
Assert.Equal(expected: ResourceSpecificationKindValueProvider.IconAndManifestValue, actual: result);
}
public async Task WhenGettingTheValue_ReturnsResourceFileIfWin32ResourceIsSet()
{
var provider = new ResourceSpecificationKindValueProvider(ITemporaryPropertyStorageFactory.Create());
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue(ResourceSpecificationKindValueProvider.Win32ResourceMSBuildProperty, @"C:\alpha\beta\gamma.res");
var result = await provider.OnGetEvaluatedPropertyValueAsync(
ResourceSpecificationKindValueProvider.ResourceSpecificationKindProperty,
string.Empty,
defaultProperties);
Assert.Equal(expected: ResourceSpecificationKindValueProvider.ResourceFileValue, actual: result);
}
public static async Task SetPropertyAsync_ExistingProperties()
{
var postbuildEventProjectProperties =
IProjectPropertiesFactory.MockWithPropertyAndValue("PostBuildEvent", "echo $(ProjectDir)").Object;
var success = await systemUnderTest.TrySetPropertyAsync(@"echo ""post build $(OutDir)""", postbuildEventProjectProperties);
Assert.True(success);
var expected = @"echo ""post build $(OutDir)""";
var actual = await postbuildEventProjectProperties.GetUnevaluatedPropertyValueAsync("PostBuildEvent");
Assert.Equal(expected, actual);
}
public void Constructor_NullUnconfiguredProject_ThrowsArgumentNullException()
{
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithPropertyAndValue("ProjectGuid", "7259e9ef-87d1-45a5-95c6-3a8432d23776");
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(delegateProperties);
Assert.Throws <ArgumentNullException>("unconfiguredProject", () =>
{
new ImplicitProjectPropertiesProvider(delegateProvider, IProjectInstancePropertiesProviderFactory.Create(), null);
});
}
public void GetBuildMacroValue(string macroName, string expectedValue, int expectedRetVal)
{
var projectProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue("MyBuildMacro", "MyBuildMacroValue");
var propertiesProvider = IProjectPropertiesProviderFactory.Create(commonProps: projectProperties);
var configuredProjectServices = Mock.Of <ConfiguredProjectServices>(o =>
o.ProjectPropertiesProvider == propertiesProvider);
var configuredProject = ConfiguredProjectFactory.Create(services: configuredProjectServices);
var buildMacroInfo = CreateInstance(configuredProject);
int retVal = buildMacroInfo.GetBuildMacroValue(macroName, out string?macroValue);
Assert.Equal(expectedRetVal, retVal);
Assert.Equal(expectedValue, macroValue);
}
public void BuildMacroInfoTests_GetBuildMacroValue(string macroName, string expectedValue, int expectedRetVal)
{
var projectProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue("MyBuildMacro", "MyBuildMacroValue");
var propertiesProvider = IProjectPropertiesProviderFactory.Create(commonProps: projectProperties);
var configuredProjectServices = Mock.Of <IConfiguredProjectServices>(o =>
o.ProjectPropertiesProvider == propertiesProvider);
var configuredProject = ConfiguredProjectFactory.Create(services: configuredProjectServices);
ActiveConfiguredProject <ConfiguredProject> activeConfiguredProject = ActiveConfiguredProjectFactory.ImplementValue(() => configuredProject);
var threadingService = IProjectThreadingServiceFactory.Create();
var buildMacroInfo = new BuildMacroInfo(activeConfiguredProject, threadingService);
int retVal = buildMacroInfo.GetBuildMacroValue(macroName, out string macroValue);
Assert.Equal(expectedRetVal, retVal);
Assert.Equal(expectedValue, macroValue);
}
public async Task SetApplicationManifest(string appManifestPropValue, string noManifestPropValue, string valueToSet, string expectedAppManifestValue, string expectedNoManifestValue)
{
var provider = new ApplicationManifestValueProvider(UnconfiguredProjectFactory.Create(filePath: @"C:\projectdir\proj.proj"));
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertiesAndValues(new Dictionary <string, string>
{
{ "ApplicationManifest", appManifestPropValue },
{ "NoWin32Manifest", noManifestPropValue }
});
var appManifestValue = await provider.OnSetPropertyValueAsync(valueToSet, defaultProperties);
var noManifestValue = await defaultProperties.GetEvaluatedPropertyValueAsync("NoWin32Manifest");
Assert.Equal(expectedAppManifestValue, appManifestValue);
Assert.Equal(expectedNoManifestValue, noManifestValue);
}
private ConsoleDebugTargetsProvider GetDebugTargetsProvider(string outputType = "exe", Dictionary <string, string> properties = null, IVsDebugger10 debugger = null)
{
_mockFS.WriteAllText(@"c:\test\Project\someapp.exe", "");
_mockFS.CreateDirectory(@"c:\test\Project");
_mockFS.CreateDirectory(@"c:\test\Project\bin\");
_mockFS.WriteAllText(@"c:\program files\dotnet\dotnet.exe", "");
var project = UnconfiguredProjectFactory.Create(filePath: _ProjectFile);
var outputTypeEnum = new PageEnumValue(new EnumValue()
{
Name = outputType
});
var data = new PropertyPageData()
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.OutputTypeProperty,
Value = outputTypeEnum
};
var projectProperties = ProjectPropertiesFactory.Create(project, data);
if (properties == null)
{
properties = new Dictionary <string, string>()
{
{ "RunCommand", @"dotnet" },
{ "RunArguments", "exec " + "\"" + @"c:\test\project\bin\project.dll" + "\"" },
{ "RunWorkingDirectory", @"bin\" },
{ "TargetFrameworkIdentifier", @".NetCoreApp" },
{ "OutDir", @"c:\test\project\bin\" }
};
}
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithPropertiesAndValues(properties);
var delegateProvider = IProjectPropertiesProviderFactory.Create(null, delegatePropertiesMock.Object);
var configuredProjectServices = Mock.Of <ConfiguredProjectServices>(o =>
o.ProjectPropertiesProvider == delegateProvider);
var configuredProject = Mock.Of <ConfiguredProject>(o =>
o.UnconfiguredProject == project &&
o.Services == configuredProjectServices);
var environment = IEnvironmentHelperFactory.ImplementGetEnvironmentVariable(_Path);
return(CreateInstance(project: project, configuredProject: configuredProject, fileSystem: _mockFS, properties: projectProperties, environment: environment, debugger: debugger));
}
public async Task WhenThePropertyIsInherited_TheSavedValueIsRestored()
{
Dictionary <string, string?> propertyNamesAndValues = new()
{
{ "MyProperty", "Beta" }
};
IProjectProperties projectProperties = IProjectPropertiesFactory.CreateWithPropertiesAndValues(
propertyNamesAndValues,
inheritedPropertyNames: new() { "MyProperty" });
ITemporaryPropertyStorage temporaryPropertyStorage = ITemporaryPropertyStorageFactory.Create(
values: new() { { "MyProperty", "Alpha" } });
await projectProperties.RestoreValueIfNotCurrentlySetAsync("MyProperty", temporaryPropertyStorage);
Assert.Contains(new KeyValuePair <string, string?>("MyProperty", "Alpha"), propertyNamesAndValues);
}
public void Constructor_NullDelegatedInstanceProvider_ThrowsArgumentNullException()
{
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithPropertyAndValue("ProjectGuid", "7259e9ef-87d1-45a5-95c6-3a8432d23776");
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(delegateProperties);
var unconfiguredProject = IUnconfiguredProjectFactory.Create();
Assert.Throws <ArgumentNullException>("instanceProvider", () =>
{
new ImplicitProjectPropertiesProvider(delegateProvider,
null,
new ImplicitProjectPropertiesStore <string, string>(unconfiguredProject),
unconfiguredProject);
});
}
public async Task GetPropertyValueTests(string propertyName, string optionStrict, string warningLevel, string treatWarningsAsErrors, string noWarn, string specificWarningsAsErrors, string expectedValue)
{
var provider = new VBWarningsValueProvider();
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertiesAndValues(new Dictionary <string, string?>()
{
{ VBWarningsValueProvider.OptionStrictPropertyName, optionStrict },
{ VBWarningsValueProvider.WarningLevelPropertyName, warningLevel },
{ VBWarningsValueProvider.TreatWarningsAsErrorsPropertyName, treatWarningsAsErrors },
{ VBWarningsValueProvider.NoWarnPropertyName, noWarn },
{ VBWarningsValueProvider.WarningsAsErrorsPropertyName, specificWarningsAsErrors }
});
var result = await provider.OnGetEvaluatedPropertyValueAsync(propertyName, evaluatedPropertyValue : "", defaultProperties);
Assert.Equal(expectedValue, result);
}
public async Task WhenThePropertyIsNotSetAtAll_TheSavedValueIsRestored()
{
Dictionary <string, string?> propertyNamesAndValues = new()
{
{ "MyProperty", null }
};
IProjectProperties projectProperties = IProjectPropertiesFactory.CreateWithPropertiesAndValues(
propertyNamesAndValues,
inheritedPropertyNames: new() { "MyProperty" }); // If a property isn't defined _at all_ it is considered inherited.
ITemporaryPropertyStorage temporaryPropertyStorage = ITemporaryPropertyStorageFactory.Create(
values: new() { { "MyProperty", "Alpha" } });
await projectProperties.RestoreValueIfNotCurrentlySetAsync("MyProperty", temporaryPropertyStorage);
Assert.Contains(new KeyValuePair <string, string?>("MyProperty", "Alpha"), propertyNamesAndValues);
}
private IProjectProperties CreateProjectProperties(Dictionary <string, string> additionalProps, bool saveInProjectFile)
{
additionalProps = additionalProps ?? new Dictionary <string, string>();
// Configure whether AssemblyInfo properties are generated in project file or not.
var saveInProjectFileStr = saveInProjectFile.ToString();
foreach (var kvp in AssemblyInfoProperties.s_assemblyPropertyInfoMap)
{
var generatePropertyInProjectFileName = kvp.Value.GeneratePropertyInProjectFileName;
additionalProps[generatePropertyInProjectFileName] = saveInProjectFileStr;
}
additionalProps["GenerateAssemblyInfo"] = saveInProjectFileStr;
return(IProjectPropertiesFactory.MockWithPropertiesAndValues(additionalProps).Object);
}
public static async Task SetPropertyTest_RemoveExistingProperties()
{
var root = @"<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp1.1</TargetFramework>
<PreBuildEvent>echo $(ProjectDir)</PreBuildEvent>
</PropertyGroup>
</Project>".AsProjectRootElement();
var prebuildEventProjectProperties =
IProjectPropertiesFactory.CreateWithPropertyAndValue("PreBuildEvent", "echo $(ProjectDir)");
await systemUnderTest.SetPropertyAsync(" ", prebuildEventProjectProperties, root);
var result = await prebuildEventProjectProperties.GetUnevaluatedPropertyValueAsync("PreBuildEvent");
Assert.Null(result);
}
public static async Task GetPropertyTest_ExistingProperties()
{
var root = @"
<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp1.1</TargetFramework>
<PreBuildEvent>echo $(ProjectDir)</PreBuildEvent>
</PropertyGroup>
</Project>".AsProjectRootElement();
var expected = "echo $(ProjectDir)";
var projectProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue("PreBuildEvent", expected);
var actual = await systemUnderTest.GetPropertyAsync(root, projectProperties);
Assert.Equal(expected, actual);
}
private static DotNetCoreProjectCompatibilityDetector CreateCompatibilityDetector(out IDialogServices dialogServices,
string?versionDataString = null,
Version?vsVersion = null,
bool isSolutionOpen = false,
bool hasNewProjects = false,
bool usingPreviewSDK = false,
bool isCapabilityMatch = true,
string targetFrameworkMoniker = ".NETCoreApp,Version=v3.0")
{
dialogServices = IDialogServicesFactory.Create();
var additionalReference = dialogServices;
var projectProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue("TargetFrameworkMoniker", targetFrameworkMoniker);
var propertiesProvider = IProjectPropertiesProviderFactory.Create(commonProps: projectProperties);
var project = ConfiguredProjectFactory.Create(services: ConfiguredProjectServicesFactory.Create(projectPropertiesProvider: propertiesProvider));
var scope = hasNewProjects ? IProjectCapabilitiesScopeFactory.Create(new[] { ProjectCapability.DotNet, ProjectCapability.PackageReferences }) : null;
var projectAccessor = new Lazy <IProjectServiceAccessor>(() => IProjectServiceAccessorFactory.Create(scope, project));
var lazyDialogServices = new Lazy <IDialogServices>(() => additionalReference);
var threadHandling = new Lazy <IProjectThreadingService>(() => IProjectThreadingServiceFactory.Create(verifyOnUIThread: false));
var vsShellUtilitiesHelper = new Lazy <IVsShellUtilitiesHelper>(() => IVsShellUtilitiesHelperFactory.Create(string.Empty, vsVersion ?? new Version("16.1")));
var fileSystem = new Lazy <IFileSystem>(() => IFileSystemFactory.Create(existsFunc: x => true, readAllTextFunc: x => versionDataString ?? defaultVersionDataString));
var httpClient = new Lazy <IHttpClient>(() => IHttpClientFactory.Create(versionDataString ?? defaultVersionDataString));
var vsUIShellService = IVsServiceFactory.Create <SVsUIShell, IVsUIShell>(Mock.Of <IVsUIShell>());
var settingsManagerService = IVsServiceFactory.Create <SVsSettingsPersistenceManager, ISettingsManager>(Mock.Of <ISettingsManager>());
var vsSolutionService = IVsServiceFactory.Create <SVsSolution, IVsSolution>(IVsSolutionFactory.CreateWithAdviseUnadviseSolutionEvents(1, isFullyLoaded: isSolutionOpen));
var vsAppIdService = IVsServiceFactory.Create <SVsAppId, IVsAppId>(Mock.Of <IVsAppId>());
var vsShellService = IVsServiceFactory.Create <SVsShell, IVsShell>(Mock.Of <IVsShell>());
var compatibilityDetector = new TestDotNetCoreProjectCompatibilityDetector(projectAccessor,
lazyDialogServices,
threadHandling,
vsShellUtilitiesHelper,
fileSystem,
httpClient,
vsUIShellService,
settingsManagerService,
vsSolutionService,
vsAppIdService,
vsShellService,
hasNewProjects,
usingPreviewSDK,
isCapabilityMatch);
return(compatibilityDetector);
}
public void Provider_ReturnsImplicitPropertyProvider()
{
var unconfiguredProject = IUnconfiguredProjectFactory.Create();
var instanceProvider = IProjectInstancePropertiesProviderFactory.ImplementsGetItemTypeProperties();
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithPropertyAndValue("Something", "NotImportant");
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(delegateProperties);
var propertyStore = new ImplicitProjectPropertiesStore <string, string>(unconfiguredProject);
var provider = new ImplicitProjectPropertiesProvider(delegateProvider, instanceProvider, propertyStore, unconfiguredProject);
var properties = provider.GetItemTypeProperties(null, "");
properties.SetPropertyValueAsync("ProjectGuid", "7259e9ef-87d1-45a5-95c6-3a8432d23776");
Assert.Equal("7259e9ef-87d1-45a5-95c6-3a8432d23776", properties.GetEvaluatedPropertyValueAsync("ProjectGuid").Result);
}
public async Task VerifySetKeyFilePropertyAsync()
{
string projectFolder = @"C:\project\root";
string projectFullPath = $@"{projectFolder}\project.testproj";
string keyFileName = "KeyFile.snk";
string keyFileFullPath = $@"{projectFolder}\{keyFileName}";
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithPropertiesAndValues(new Dictionary <string, string>()
{
{ AssemblyOriginatorKeyFilePropertyName, keyFileFullPath }
});
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(delegateProperties);
// Verify get key file value without intercepted provider.
var properties = delegateProvider.GetProperties("path/to/project.testproj", null, null);
var propertyValue = await properties.GetEvaluatedPropertyValueAsync(AssemblyOriginatorKeyFilePropertyName);
Assert.Equal(keyFileFullPath, propertyValue);
// Verify relative path key file value from intercepted key file provider.
var unconfiguredProject = UnconfiguredProjectFactory.Create(filePath: projectFullPath);
var instanceProvider = IProjectInstancePropertiesProviderFactory.Create();
var keyFileProvider = new AssemblyOriginatorKeyFileValueProvider(unconfiguredProject);
var providerMetadata = IInterceptingPropertyValueProviderMetadataFactory.Create(AssemblyOriginatorKeyFilePropertyName);
var lazyArray = new[] { new Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata>(
() => keyFileProvider, providerMetadata) };
var interceptedProvider = new ProjectFileInterceptedProjectPropertiesProvider(delegateProvider, instanceProvider, unconfiguredProject, lazyArray);
var propertyNames = await properties.GetPropertyNamesAsync();
Assert.Single(propertyNames);
Assert.Equal(AssemblyOriginatorKeyFilePropertyName, propertyNames.First());
properties = interceptedProvider.GetProperties("path/to/project.testproj", null, null);
string newKeyFileName = "KeyFile2.snk";
string newKeyFileFullPath = $@"{projectFolder}\{newKeyFileName}";
await properties.SetPropertyValueAsync(AssemblyOriginatorKeyFilePropertyName, newKeyFileFullPath);
propertyValue = await properties.GetEvaluatedPropertyValueAsync(AssemblyOriginatorKeyFilePropertyName);
Assert.Equal(newKeyFileName, propertyValue);
}
public void Provider_IgnoresPropertyIfAbsent()
{
var unconfiguredProject = IUnconfiguredProjectFactory.Create();
var instanceProvider = IProjectInstancePropertiesProviderFactory.Create();
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithProperty("SomeOtherProperty");
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(delegateProperties);
var provider = new ImplicitProjectPropertiesProvider(delegateProvider, instanceProvider, unconfiguredProject);
var properties = provider.GetProperties("path/to/project.testproj", null, null);
// does not call the set property on the delegated property above
properties.SetPropertyValueAsync("ProjectGuid", "7259e9ef-87d1-45a5-95c6-3a8432d23776");
// verify all the setups
delegatePropertiesMock.VerifyAll();
}
public void Provider_SetsPropertyIfPresent()
{
var unconfiguredProject = IUnconfiguredProjectFactory.Create();
var instanceProvider = IProjectInstancePropertiesProviderFactory.Create();
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithPropertyAndValue("ProjectGuid", "7259e9ef-87d1-45a5-95c6-3a8432d23776");
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(delegateProperties);
var provider = new ImplicitProjectPropertiesProvider(delegateProvider, instanceProvider, unconfiguredProject);
var properties = provider.GetProperties("path/to/project.testproj", null, null);
// calls delegate above with matching values
properties.SetPropertyValueAsync("ProjectGuid", "7259e9ef-87d1-45a5-95c6-3a8432d23776");
// verify all the setups
delegatePropertiesMock.Verify(p => p.SetPropertyValueAsync("ProjectGuid", "7259e9ef-87d1-45a5-95c6-3a8432d23776", null));
}
public static async Task SetPropertyTest_ExistingProperties()
{
var root = @"<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp1.1</TargetFramework>
<PreBuildEvent>echo $(ProjectDir)</PreBuildEvent>
<PostBuildEvent>echo $(ProjectDir)</PostBuildEvent>
</PropertyGroup>
</Project>".AsProjectRootElement();
var prebuildEventProjectProperties =
IProjectPropertiesFactory.MockWithPropertyAndValue("PreBuildEvent", "echo $(ProjectDir)").Object;
await systemUnderTest.SetPropertyAsync(@"echo ""post build $(OutDir)""", prebuildEventProjectProperties, root);
var expected = @"echo ""post build $(OutDir)""";
var actual = await prebuildEventProjectProperties.GetUnevaluatedPropertyValueAsync("PreBuildEvent");
Assert.Equal(expected, actual);
}
public async Task VerifyInterceptedViaSnapshotInstanceCommonPropertiesProviderAsync()
{
var delegatePropertiesMock = IProjectPropertiesFactory.MockWithPropertiesAndValues(
new Dictionary <string, string?>
{
{ MockPropertyName, "DummyValue" }
});
var delegateProperties = delegatePropertiesMock.Object;
var delegateInstanceProvider = IProjectInstancePropertiesProviderFactory.ImplementsGetCommonProperties(delegateProperties);
bool getEvaluatedInvoked = false;
bool getUnevaluatedInvoked = false;
bool setValueInvoked = false;
var mockPropertyProvider = IInterceptingPropertyValueProviderFactory.Create(MockPropertyName,
onGetEvaluatedPropertyValue: (v, p) => { getEvaluatedInvoked = true; return(v); },
onGetUnevaluatedPropertyValue: (v, p) => { getUnevaluatedInvoked = true; return(v); },
onSetPropertyValue: (v, p, d) => { setValueInvoked = true; return(v); });
var unconfiguredProject = UnconfiguredProjectFactory.Create();
var provider = IProjectPropertiesProviderFactory.Create();
var interceptedProvider = new ProjectFileInterceptedViaSnapshotProjectPropertiesProvider(provider, delegateInstanceProvider, unconfiguredProject, new[] { mockPropertyProvider });
var properties = interceptedProvider.GetCommonProperties(projectInstance: null);
// Verify interception for GetEvaluatedPropertyValueAsync.
string?propertyValue = await properties.GetEvaluatedPropertyValueAsync(MockPropertyName);
Assert.True(getEvaluatedInvoked);
// Verify interception for GetUnevaluatedPropertyValueAsync.
propertyValue = await properties.GetUnevaluatedPropertyValueAsync(MockPropertyName);
Assert.True(getUnevaluatedInvoked);
// Verify interception for SetPropertyValueAsync.
await properties.SetPropertyValueAsync(MockPropertyName, "NewValue", null);
Assert.True(setValueInvoked);
}
private static InterceptedProjectPropertiesProviderBase CreateInstance(FrameworkName configuredTargetFramework)
{
var data = new PropertyPageData(ConfigurationGeneral.SchemaName, ConfigurationGeneral.TargetFrameworkMonikerProperty, configuredTargetFramework.FullName);
var project = UnconfiguredProjectFactory.Create();
var properties = ProjectPropertiesFactory.Create(project, data);
var delegateProvider = IProjectPropertiesProviderFactory.Create();
var instancePropertiesMock = IProjectPropertiesFactory
.MockWithProperty(TargetFrameworkPropertyName);
var instanceProperties = instancePropertiesMock.Object;
var instanceProvider = IProjectInstancePropertiesProviderFactory.ImplementsGetCommonProperties(instanceProperties);
var targetFrameworkProvider = new TargetFrameworkValueProvider(properties);
var providerMetadata = IInterceptingPropertyValueProviderMetadataFactory.Create(TargetFrameworkPropertyName);
var lazyArray = new[] { new Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata>(
() => targetFrameworkProvider, providerMetadata) };
return(new ProjectFileInterceptedViaSnapshotProjectPropertiesProvider(delegateProvider, instanceProvider, project, lazyArray));
}
public async Task CheckValueAsync(string effectiveAnalysisLevel, string expectedWarningLevelOverriddenValue)
{
var provider = new WarningLevelOverriddenValueProvider();
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue(
WarningLevelOverriddenValueProvider.EffectiveAnalysisLevelPropertyName,
effectiveAnalysisLevel);
var unevaluatedResult = await provider.OnGetUnevaluatedPropertyValueAsync(
WarningLevelOverriddenValueProvider.WarningLevelOverriddenPropertyName,
string.Empty,
defaultProperties);
Assert.Equal(expectedWarningLevelOverriddenValue, actual: unevaluatedResult);
var evaluatedResult = await provider.OnGetEvaluatedPropertyValueAsync(
WarningLevelOverriddenValueProvider.WarningLevelOverriddenPropertyName,
string.Empty,
defaultProperties);
Assert.Equal(expectedWarningLevelOverriddenValue, actual: evaluatedResult);
}
public async Task SetApplicationManifestKind(string newValue, string?currentApplicationManifestPropertyValue, string?currentNoManifestPropertyValue, string?expectedAppManifestPropertyValue, string?expectedNoManifestPropertyValue, string?expectedStoredValue)
{
Dictionary <string, string> storageDictionary = new();
var storage = ITemporaryPropertyStorageFactory.Create(storageDictionary);
Dictionary <string, string?> defaultPropertiesDictionary = new();
defaultPropertiesDictionary["ApplicationManifest"] = currentApplicationManifestPropertyValue;
defaultPropertiesDictionary["NoWin32Manifest"] = currentNoManifestPropertyValue;
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertiesAndValues(defaultPropertiesDictionary);
var provider = new ApplicationManifestKindValueProvider(storage);
await provider.OnSetPropertyValueAsync("", newValue, defaultProperties);
defaultPropertiesDictionary.TryGetValue("ApplicationManifest", out string?finalAppManifestPropertyValue);
defaultPropertiesDictionary.TryGetValue("NoWin32Manifest", out string?finalNoManifestPropertyValue);
storageDictionary.TryGetValue("ApplicationManifestKind", out string?finalStoredValue);
Assert.Equal(expectedAppManifestPropertyValue, finalAppManifestPropertyValue);
Assert.Equal(expectedNoManifestPropertyValue, finalNoManifestPropertyValue);
Assert.Equal(expectedStoredValue, finalStoredValue);
}
public async Task SetPackageLicenseKind(string newValue, string?currentExpressionPropertyValue, string?currentFilePropertyValue, string?expectedExpressionPropertyValue, string?expectedFilePropertyValue, string?expectedStoredValue)
{
Dictionary <string, string> storageDictionary = new();
var storage = ITemporaryPropertyStorageFactory.Create(storageDictionary);
Dictionary <string, string?> defaultPropertiesDictionary = new();
defaultPropertiesDictionary["PackageLicenseExpression"] = currentExpressionPropertyValue;
defaultPropertiesDictionary["PackageLicenseFile"] = currentFilePropertyValue;
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertiesAndValues(defaultPropertiesDictionary);
var provider = new PackageLicenseKindValueProvider(storage);
await provider.OnSetPropertyValueAsync("", newValue, defaultProperties);
defaultPropertiesDictionary.TryGetValue("PackageLicenseExpression", out string?finalExpressionPropertyValue);
defaultPropertiesDictionary.TryGetValue("PackageLicenseFile", out string?finalFilePropertyValue);
storageDictionary.TryGetValue("PackageLicenseKind", out string?finalStoredValue);
Assert.Equal(expectedExpressionPropertyValue, finalExpressionPropertyValue);
Assert.Equal(expectedFilePropertyValue, finalFilePropertyValue);
Assert.Equal(expectedStoredValue, finalStoredValue);
}
public async Task GetApplicationManifestKind(string applicationManifestPropertyValue, string noManifestPropertyValue, string?storedValue, string expectedValue)
{
Dictionary <string, string>?storedValues = null;
if (storedValue is not null)
{
storedValues = new Dictionary <string, string>
{
{ "ApplicationManifestKind", storedValue }
};
}
var storage = ITemporaryPropertyStorageFactory.Create(storedValues);
var provider = new ApplicationManifestKindValueProvider(storage);
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertiesAndValues(new Dictionary <string, string?>
{
{ "ApplicationManifest", applicationManifestPropertyValue },
{ "NoWin32Manifest", noManifestPropertyValue }
});
var kindValue = await provider.OnGetEvaluatedPropertyValueAsync(string.Empty, string.Empty, defaultProperties);
Assert.Equal(expected: expectedValue, actual: kindValue);
}
