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)); }