public void IsEnabled_MultipleExperimentsOverriddenWithDifferentEnvVars_DoNotConflict()
{
var forcedOffExperiment = new ExperimentationConstants("TestExp1", "TEST_EXP_1");
var forcedOnExperiment = new ExperimentationConstants("TestExp2", "TEST_EXP_2");
var noOverrideExperiment = new ExperimentationConstants("TestExp3", "TEST_EXP_3");
var flightsEnabled = new Dictionary <string, bool>()
{
{ forcedOffExperiment.FlightFlag, true },
{ forcedOnExperiment.FlightFlag, true },
{ noOverrideExperiment.FlightFlag, true },
};
var envVars = new Dictionary <string, string>()
{
{ forcedOnExperiment.FlightEnvironmentVariable, "1" },
{ forcedOffExperiment.FlightEnvironmentVariable, "0" },
};
var envVarWrapper = new TestEnvironmentVariableReader(envVars);
var service = new NuGetExperimentationService(envVarWrapper, new TestVisualStudioExperimentalService(flightsEnabled), _outputConsoleProvider);
service.IsExperimentEnabled(forcedOffExperiment).Should().BeFalse();
service.IsExperimentEnabled(forcedOnExperiment).Should().BeTrue();
service.IsExperimentEnabled(noOverrideExperiment).Should().BeTrue();
OutputMessages.Should().ContainMatch($"*{forcedOffExperiment.FlightFlag}*{forcedOffExperiment.FlightEnvironmentVariable}*0*");
OutputMessages.Should().ContainMatch($"*{forcedOnExperiment.FlightFlag}*{forcedOnExperiment.FlightEnvironmentVariable}*1*");
OutputMessages.Should().NotContainMatch($"*{noOverrideExperiment.FlightFlag}*{noOverrideExperiment.FlightEnvironmentVariable}*");
}
public async Task HttpFileSystemBasedFindPackageByIdResource_EnhancedHttpRetrySettings()
{
const int testTryCount = 7;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.IsEnabledEnvironmentVariableName] = bool.TrueString,
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = testTryCount.ToString(),
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = "0"
});
using (var test = await HttpFileSystemBasedFindPackageByIdResourceTest.CreateAsync(testEnvironmentVariableReader))
{
var exception = await Assert.ThrowsAsync <FatalProtocolException>(
() => test.Resource.GetPackageDownloaderAsync(
new PackageIdentity(id: "socketexception", version: NuGetVersion.Parse("1.2.3")),
test.SourceCacheContext,
NullLogger.Instance,
CancellationToken.None));
// THe only features that really turn on are the extra retries (the exception here just ensures the new codepath gets covered)
// So we'll make sure that the number of tries seen matches the number above.
Assert.Equal(HttpFileSystemBasedFindPackageByIdResourceTest.SocketExceptionCallsMade, testTryCount);
}
}
public async Task HttpRetryHandler_EnhancedRetryAllowsSettingMoreRetries()
{
// Arrange
var tries = 0;
var sent503 = false;
Func <HttpRequestMessage, HttpResponseMessage> handler = requestMessage =>
{
tries++;
// Return 503 for the first 2 tries
if (tries > 10)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
else
{
sent503 = true;
return(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable));
}
};
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.IsEnabledEnvironmentVariableName] = bool.TrueString,
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = "11",
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = "3"
});
EnhancedHttpRetryHelper helper = new EnhancedHttpRetryHelper(testEnvironmentVariableReader);
Assert.Equal(helper.IsEnabled, true);
// Enhanced retry mode causes a random 0-199 ms jitter so we can't time it in this test
// but we can make sure the setting got through
Assert.Equal(helper.DelayInMilliseconds, 3);
Assert.Equal(helper.RetryCount, 11);
var retryHandler = new HttpRetryHandler(testEnvironmentVariableReader);
var testHandler = new HttpRetryTestHandler(handler);
var httpClient = new HttpClient(testHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, TestUrl))
{
MaxTries = helper.RetryCount,
RequestTimeout = Timeout.InfiniteTimeSpan,
// HttpRetryHandler will override with values from NUGET_ENHANCED_NETWORK_RETRY_DELAY_MILLISECONDS
// so set this to a value that will cause test timeout if the correct value is not honored.
RetryDelay = TimeSpan.FromMilliseconds(int.MaxValue) // = about 24 days
};
var log = new TestLogger();
// Act
using (var response = await retryHandler.SendAsync(request, log, CancellationToken.None))
{
// Assert
Assert.True(sent503);
Assert.Equal(11, tries);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public void GetSpecDependencies_WithAssetTargetFallback_AndDependencyResolutionVariableSpecified_ReturnsCorrectDependencies(string assetTargetFallbackEnvironmentVariableValue, int dependencyCount)
{
// Arrange
var net60Framework = FrameworkConstants.CommonFrameworks.Net60;
var net472Framework = FrameworkConstants.CommonFrameworks.Net472;
var packageSpec = ProjectTestHelpers.GetPackageSpec(rootPath: "C:\\", projectName: "A", framework: net472Framework.GetShortFolderName(), dependencyName: "x");
var envVarWrapper = new TestEnvironmentVariableReader(new Dictionary <string, string> {
{ "NUGET_USE_LEGACY_ASSET_TARGET_FALLBACK_DEPENDENCY_RESOLUTION", assetTargetFallbackEnvironmentVariableValue }
});
var dependencyProvider = new PackageSpecReferenceDependencyProvider(new List <ExternalProjectReference>(), NullLogger.Instance, envVarWrapper);
var assetTargetFallback = new AssetTargetFallbackFramework(net60Framework, new List <NuGetFramework> {
net472Framework
});
// Act
var dependencies = dependencyProvider.GetSpecDependencies(packageSpec, assetTargetFallback);
// Assert
dependencies.Should().HaveCount(dependencyCount);
if (dependencyCount > 0)
{
dependencies[0].Name.Should().Be("x");
}
}
public async Task IsFeatureEnabledAsync_MultipleFeaturesOverriddenWithDifferentEnvVars_DoNotConflict()
{
var forcedOff = new NuGetFeatureFlagConstants("TestExp1", "TEST_EXP_1", defaultState: false);
var forcedOn = new NuGetFeatureFlagConstants("TestExp2", "TEST_EXP_2", defaultState: false);
var noOverride = new NuGetFeatureFlagConstants("TestExp3", "TEST_EXP_3", defaultState: false);
var envVars = new Dictionary <string, string>()
{
{ forcedOn.EnvironmentVariable, "1" },
{ forcedOff.EnvironmentVariable, "0" },
};
var envVarWrapper = new TestEnvironmentVariableReader(envVars);
var vsFeatureFlags = Mock.Of <IVsFeatureFlags>();
Mock.Get(vsFeatureFlags)
.Setup(x => x.IsFeatureEnabled(
It.IsAny <string>(), It.IsAny <bool>()))
.Returns(true);
_globalProvider.AddService(typeof(SVsFeatureFlags), vsFeatureFlags);
var service = new NuGetFeatureFlagService(envVarWrapper, AsyncServiceProvider.GlobalProvider);
(await service.IsFeatureEnabledAsync(forcedOff)).Should().BeFalse();
(await service.IsFeatureEnabledAsync(forcedOn)).Should().BeTrue();
(await service.IsFeatureEnabledAsync(noOverride)).Should().BeTrue();
}
public async Task HttpFileSystemBasedFindPackageByIdResource_EnhancedHttpRetrySettings()
{
const int testTryCount = 7;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
{ "NUGET_ENABLE_EXPERIMENTAL_HTTP_RETRY", "true" },
{ "NUGET_EXPERIMENTAL_MAX_NETWORK_TRY_COUNT", $"{testTryCount}" },
{ "NUGET_EXPERIMENTAL_NETWORK_RETRY_DELAY_MILLISECONDS", "0" }
});
using (var test = await HttpFileSystemBasedFindPackageByIdResourceTest.CreateAsync(testEnvironmentVariableReader))
{
var exception = await Assert.ThrowsAsync <FatalProtocolException>(
() => test.Resource.GetPackageDownloaderAsync(
new PackageIdentity(id: "socketexception", version: NuGetVersion.Parse("1.2.3")),
test.SourceCacheContext,
NullLogger.Instance,
CancellationToken.None));
// THe only features that really turn on are the extra retries (the exception here just ensures the new codepath gets covered)
// So we'll make sure that the number of tries seen matches the number above.
Assert.Equal(HttpFileSystemBasedFindPackageByIdResourceTest.SocketExceptionCallsMade, testTryCount);
}
}
public void IsEnabled_WithEnabledFlightAndForcedEnabledEnvVar_ReturnsTrue()
{
var constant = ExperimentationConstants.PackageManagerBackgroundColor;
var envVars = new Dictionary <string, string>()
{
{ constant.FlightEnvironmentVariable, "1" },
};
var envVarWrapper = new TestEnvironmentVariableReader(envVars);
var service = new NuGetExperimentationService(envVarWrapper, new TestVisualStudioExperimentalService());
service.IsExperimentEnabled(ExperimentationConstants.PackageManagerBackgroundColor).Should().BeTrue();
}
public void IsEnabled_WithEnvVarWithIncorrectValue_WithEnvironmentVariable__ReturnsFalse(string value)
{
var constant = ExperimentationConstants.PackageManagerBackgroundColor;
var envVars = new Dictionary <string, string>()
{
{ constant.FlightEnvironmentVariable, value },
};
var envVarWrapper = new TestEnvironmentVariableReader(envVars);
var service = new NuGetExperimentationService(envVarWrapper, new TestVisualStudioExperimentalService());
service.IsExperimentEnabled(ExperimentationConstants.PackageManagerBackgroundColor).Should().BeFalse();
}
public async Task HttpRetryHandler_MultipleTriesUntilSuccess()
{
// Arrange
TimeSpan retryDelay = TimeSpan.Zero;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = MaxTries.ToString(),
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = retryDelay.TotalMilliseconds.ToString()
});
var tries = 0;
var sent503 = false;
Func <HttpRequestMessage, HttpResponseMessage> handler = requestMessage =>
{
tries++;
// Return 503 for the first 2 tries
if (tries > 2)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
else
{
sent503 = true;
return(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable));
}
};
var retryHandler = new HttpRetryHandler(testEnvironmentVariableReader);
var testHandler = new HttpRetryTestHandler(handler);
var httpClient = new HttpClient(testHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, TestUrl))
{
MaxTries = MaxTries,
RequestTimeout = Timeout.InfiniteTimeSpan,
RetryDelay = retryDelay
};
var log = new TestLogger();
// Act
using (var response = await retryHandler.SendAsync(request, log, CancellationToken.None))
{
// Assert
Assert.True(sent503);
Assert.Equal(3, tries);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task HttpRetryHandler_AppliesTimeoutToRequestsIndividually()
{
// Arrange
// 20 requests that take 250ms each for a total of 5 seconds (plus noise).
var requestDuration = TimeSpan.FromMilliseconds(250);
var maxTries = 20;
var retryDelay = TimeSpan.Zero;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = maxTries.ToString(),
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = retryDelay.TotalMilliseconds.ToString()
});
// Make the request timeout longer than each request duration but less than the total
// duration of all attempts.
var requestTimeout = TimeSpan.FromMilliseconds(4000);
var hits = 0;
Func <HttpRequestMessage, CancellationToken, Task <HttpResponseMessage> > handler = async(requestMessage, token) =>
{
hits++;
await Task.Delay(requestDuration);
return(new HttpResponseMessage(HttpStatusCode.InternalServerError));
};
var retryHandler = new HttpRetryHandler(testEnvironmentVariableReader);
var testHandler = new HttpRetryTestHandler(handler);
var httpClient = new HttpClient(testHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, TestUrl))
{
MaxTries = maxTries,
RequestTimeout = requestTimeout,
RetryDelay = retryDelay
};
var log = new TestLogger();
// Act
using (await retryHandler.SendAsync(request, log, CancellationToken.None))
{
}
// Assert
Assert.Equal(maxTries, hits);
}
public async Task IsFeatureEnabledAsync_WithEnvVarNotSetWithEnabledFeatureFromWithFeatureFlagService_ReturnsExpectedResult(bool isFeatureEnabled, bool expectedResult)
{
var featureFlagConstant = new NuGetFeatureFlagConstants("featureFlag", "featureEnvVar", defaultState: false);
var envVarWrapper = new TestEnvironmentVariableReader(new Dictionary <string, string>());
var vsFeatureFlags = Mock.Of <IVsFeatureFlags>();
Mock.Get(vsFeatureFlags)
.Setup(x => x.IsFeatureEnabled(
It.IsAny <string>(), It.IsAny <bool>()))
.Returns(isFeatureEnabled);
_globalProvider.AddService(typeof(SVsFeatureFlags), vsFeatureFlags);
var service = new NuGetFeatureFlagService(envVarWrapper, AsyncServiceProvider.GlobalProvider);
(await service.IsFeatureEnabledAsync(featureFlagConstant)).Should().Be(expectedResult);
}
public async Task HttpRetryHandler_MultipleTriesTimed()
{
// Arrange
TimeSpan retryDelay = SmallTimeout;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = MaxTries.ToString(),
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = retryDelay.TotalMilliseconds.ToString()
});
Func <HttpRequestMessage, HttpResponseMessage> handler = requestMessage =>
{
return(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable));
};
var minTime = GetRetryMinTime(MaxTries, SmallTimeout);
var retryHandler = new HttpRetryHandler(testEnvironmentVariableReader);
var testHandler = new HttpRetryTestHandler(handler);
var httpClient = new HttpClient(testHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, TestUrl))
{
MaxTries = MaxTries,
RequestTimeout = Timeout.InfiniteTimeSpan,
RetryDelay = retryDelay
};
var log = new TestLogger();
// Act
var timer = new Stopwatch();
timer.Start();
using (await retryHandler.SendAsync(request, log, CancellationToken.None))
{
}
timer.Stop();
// Assert
Assert.True(
timer.Elapsed >= minTime,
$"Expected this to take at least: {minTime} But it finished in: {timer.Elapsed}");
}
public void IsEnabled_WithEnvVarDisabled_WithExperimentalServiceEnabled_ReturnsFalse()
{
var constant = ExperimentationConstants.PackageManagerBackgroundColor;
var flightsEnabled = new Dictionary <string, bool>()
{
{ constant.FlightFlag, true },
};
var envVars = new Dictionary <string, string>()
{
{ constant.FlightEnvironmentVariable, "0" },
};
var envVarWrapper = new TestEnvironmentVariableReader(envVars);
var service = new NuGetExperimentationService(envVarWrapper, new TestVisualStudioExperimentalService(flightsEnabled));
service.IsExperimentEnabled(ExperimentationConstants.PackageManagerBackgroundColor).Should().BeFalse();
}
public void HttpRetryHandler_EnhancedRetryOnByDefault(string value, bool expectedValue)
{
// Arrange
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.IsEnabledEnvironmentVariableName] = value,
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = null,
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = null
});
// Act
EnhancedHttpRetryHelper helper = new EnhancedHttpRetryHelper(testEnvironmentVariableReader);
Assert.Equal(helper.IsEnabled, expectedValue);
Assert.Equal(helper.RetryCount, EnhancedHttpRetryHelper.DefaultRetryCount);
Assert.Equal(helper.DelayInMilliseconds, EnhancedHttpRetryHelper.DefaultDelayMilliseconds);
}
public void IsEnabled_WithEnvVarEnabled_WithExperimentalServiceDisabled_ReturnsTrue()
{
var constant = ExperimentationConstants.PackageManagerBackgroundColor;
var flightsEnabled = new Dictionary <string, bool>()
{
{ constant.FlightFlag, false },
};
var envVars = new Dictionary <string, string>()
{
{ constant.FlightEnvironmentVariable, "1" },
};
var envVarWrapper = new TestEnvironmentVariableReader(envVars);
var service = new NuGetExperimentationService(envVarWrapper, new TestVisualStudioExperimentalService(flightsEnabled), _outputConsoleProvider);
service.IsExperimentEnabled(ExperimentationConstants.PackageManagerBackgroundColor).Should().BeTrue();
OutputMessages.Should().ContainMatch($"*{constant.FlightFlag}*{constant.FlightEnvironmentVariable}*1*");
}
public async Task HttpRetryHandler_CancelsRequestAfterTimeout()
{
// Arrange
TimeSpan retryDelay = TimeSpan.Zero;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = MaxTries.ToString(),
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = retryDelay.TotalMilliseconds.ToString()
});
var requestToken = CancellationToken.None;
Func <HttpRequestMessage, CancellationToken, Task <HttpResponseMessage> > handler = async(requestMessage, token) =>
{
requestToken = token;
await Task.Delay(LargeTimeout, token);
return(new HttpResponseMessage(HttpStatusCode.OK));
};
var retryHandler = new HttpRetryHandler(testEnvironmentVariableReader);
var testHandler = new HttpRetryTestHandler(handler);
var httpClient = new HttpClient(testHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, TestUrl))
{
MaxTries = 1,
RequestTimeout = SmallTimeout,
RetryDelay = retryDelay
};
// Act
Func <Task> actionAsync = () => retryHandler.SendAsync(
request,
new TestLogger(),
CancellationToken.None);
// Assert
await Assert.ThrowsAsync <TimeoutException>(actionAsync);
Assert.True(requestToken.CanBeCanceled);
Assert.True(requestToken.IsCancellationRequested);
}
public async Task IsFeatureEnabledAsync_WithEnvVarWithIncorrectValue_WithEnvironmentVariable__ReturnsFalse(string value)
{
var featureFlagConstant = new NuGetFeatureFlagConstants("featureFlag", "featureEnvVar", defaultState: false);
var envVars = new Dictionary <string, string>()
{
{ featureFlagConstant.EnvironmentVariable, value },
};
var envVarWrapper = new TestEnvironmentVariableReader(envVars);
var vsFeatureFlags = Mock.Of <IVsFeatureFlags>();
Mock.Get(vsFeatureFlags)
.Setup(x => x.IsFeatureEnabled(
It.IsAny <string>(), It.IsAny <bool>()))
.Returns(false);
_globalProvider.AddService(typeof(SVsFeatureFlags), vsFeatureFlags);
var service = new NuGetFeatureFlagService(envVarWrapper, AsyncServiceProvider.GlobalProvider);
(await service.IsFeatureEnabledAsync(featureFlagConstant)).Should().Be(false);
}
public async Task HttpRetryHandler_MultipleTriesNoSuccess()
{
// Arrange
TimeSpan retryDelay = TimeSpan.Zero;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = MaxTries.ToString(),
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = retryDelay.TotalMilliseconds.ToString()
});
var hits = 0;
Func <HttpRequestMessage, HttpResponseMessage> handler = requestMessage =>
{
hits++;
return(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable));
};
var retryHandler = new HttpRetryHandler(testEnvironmentVariableReader);
var testHandler = new HttpRetryTestHandler(handler);
var httpClient = new HttpClient(testHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, TestUrl))
{
MaxTries = MaxTries,
RequestTimeout = Timeout.InfiniteTimeSpan,
RetryDelay = retryDelay
};
var log = new TestLogger();
// Act
using (await retryHandler.SendAsync(request, log, CancellationToken.None))
{
}
// Assert
Assert.Equal(MaxTries, hits);
}
private static async Task <T> ThrowsException <T>(ITestServer server) where T : Exception
{
return(await server.ExecuteAsync(async address =>
{
int maxTries = 2;
TimeSpan retryDelay = TimeSpan.Zero;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = maxTries.ToString(),
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = retryDelay.TotalMilliseconds.ToString()
});
// Arrange
var retryHandler = new HttpRetryHandler(testEnvironmentVariableReader);
var countingHandler = new CountingHandler {
InnerHandler = new HttpClientHandler()
};
var httpClient = new HttpClient(countingHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, address))
{
MaxTries = maxTries,
RetryDelay = retryDelay
};
// Act
Func <Task> actionAsync = () => retryHandler.SendAsync(
request,
new TestLogger(),
CancellationToken.None);
// Act & Assert
var exception = await Assert.ThrowsAsync <T>(actionAsync);
Assert.Equal(2, countingHandler.Hits);
return exception;
}));
}
public async Task GetDependenciesAsync_WhenPackageIsSelectedWithAssetTargetFallback_AndLegacyDependencyResolutionVariableIsSpecified_CorrectDependenciesAreSelected(string envValue, bool areDependenciesSelected)
{
// Arrange
var testLogger = new TestLogger();
var cacheContext = new SourceCacheContext();
var findResource = new Mock <FindPackageByIdResource>();
var wrapper = new TestEnvironmentVariableReader(new Dictionary <string, string>
{
{ "NUGET_USE_LEGACY_ASSET_TARGET_FALLBACK_DEPENDENCY_RESOLUTION", envValue }
});
var net472 = FrameworkConstants.CommonFrameworks.Net472;
var net60 = FrameworkConstants.CommonFrameworks.Net60;
var inputFramework = new AssetTargetFallbackFramework(net60, new List <NuGetFramework> {
net472
});
var packageDependencyGroups = new List <PackageDependencyGroup>();
var net472Group = new PackageDependencyGroup(net472, new PackageDependency[] { new PackageDependency("full.framework", VersionRange.Parse("1.0.0")) });
packageDependencyGroups.Add(net472Group);
findResource.Setup(s => s.GetDependencyInfoAsync(
It.IsAny <string>(),
It.IsAny <NuGetVersion>(),
It.IsAny <SourceCacheContext>(),
It.IsAny <ILogger>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new FindPackageByIdDependencyInfo(
new PackageIdentity("x", NuGetVersion.Parse("1.0.0-beta")),
packageDependencyGroups,
Enumerable.Empty <FrameworkSpecificGroup>()));
var source = new Mock <SourceRepository>();
source.Setup(s => s.GetResourceAsync <FindPackageByIdResource>())
.ReturnsAsync(findResource.Object);
source.SetupGet(s => s.PackageSource)
.Returns(new PackageSource("http://test/index.json"));
var provider = new SourceRepositoryDependencyProvider(
source.Object,
testLogger,
cacheContext,
ignoreFailedSources: true,
ignoreWarning: true,
fileCache: null,
isFallbackFolderSource: false,
wrapper);
// Act
var library = await provider.GetDependenciesAsync(
new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta"), LibraryType.Package),
inputFramework,
cacheContext,
testLogger,
CancellationToken.None);
// Assert
if (areDependenciesSelected)
{
library.Dependencies.Should().HaveCount(1);
var dependencies = library.Dependencies.Single();
dependencies.Name.Should().Be("full.framework");
}
else
{
library.Dependencies.Should().HaveCount(0);
}
}
internal static async Task <HttpFileSystemBasedFindPackageByIdResourceTest> CreateAsync(TestEnvironmentVariableReader testEnvironmentVariableReader = null)
{
var packageIdentity = new PackageIdentity(id: "DeepEqual", version: NuGetVersion.Parse("1.4.0"));
var testDirectory = TestDirectory.Create();
var packageSource = new PackageSource("http://unit.test/v3-flatcontainer");
var package = await SimpleTestPackageUtility.CreateFullPackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var packageBytes = File.ReadAllBytes(package.FullName);
var responses = new Dictionary <string, Func <HttpRequestMessage, Task <HttpResponseMessage> > >
{
{
$"{packageSource.Source}/deepequal/index.json",
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new TestContent(JsonData.DeepEqualFlatContainerIndex)
})
},
{
$"{packageSource.Source}/deepequal/1.4.0/deepequal.1.4.0.nupkg",
_ => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(packageBytes)
})
},
{
$"{packageSource.Source}/a/index.json",
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound))
},
{
$"{packageSource.Source}/socketexception/index.json",
request =>
{
SocketExceptionCallsMade += 1;
throw new Exception("Oh this isn't going well", new IOException("This is what TCP hang-ups look like", new SocketException(123)));
}
},
};
var baseUris = new List <Uri>()
{
packageSource.SourceUri
};
var httpSource = new TestHttpSource(packageSource, responses);
var resource = new HttpFileSystemBasedFindPackageByIdResource(
baseUris,
httpSource,
testEnvironmentVariableReader != null ? testEnvironmentVariableReader : EnvironmentVariableWrapper.Instance);
return(new HttpFileSystemBasedFindPackageByIdResourceTest(
resource,
package,
packageIdentity,
new SourceCacheContext(),
httpSource,
testDirectory));
}
