public void DeleteCommand_DeleteFromHttpSource() { var tempPath = Path.GetTempPath(); var mockServerEndPoint = "http://localhost:1234/"; // Arrange var server = new MockServer(mockServerEndPoint); server.Start(); bool deleteRequestIsCalled = false; server.Delete.Add("/nuget/testPackage1/1.1", request => { deleteRequestIsCalled = true; return HttpStatusCode.OK; }); // Act string[] args = new string[] { "delete", "testPackage1", "1.1.0", "-Source", mockServerEndPoint + "nuget", "-NonInteractive" }; int r = Program.Main(args); server.Stop(); // Assert Assert.Equal(0, r); Assert.True(deleteRequestIsCalled); }
public async Task UserAgentHeader() { MockServer .Given(Request.Create().UsingGet()) .RespondWith(CreateResponse("{\"status\":\"active\"}", "application/json")); await _client.GetAuthorizationsApi().FindAuthorizationByIdAsync("id"); var request = MockServer.LogEntries.Last(); StringAssert.StartsWith("influxdb-client-csharp/1.", request.RequestMessage.Headers["User-Agent"].First()); StringAssert.EndsWith(".0.0", request.RequestMessage.Headers["User-Agent"].First()); }
public void ItShouldBePossibleToChangeTheDefaultUrl() { const string aNewUrl = "http://localhost:15948/"; MockServer.Stop(); MockServer.Url = aNewUrl; MockServer.Start(); var mapping = GivenAMapping(new MappingForTest()); var httpStatusCode = GetHttpStatusCode(() => MakeHttpRequest(aNewUrl, mapping.Path, mapping.RequestHttpMethod)); httpStatusCode.Should().Be((int)mapping.ResponseStatusCode); }
public static void AssertAuthorized(this MockServer server, HttpContext http, Dictionary <string, string> parameters = null, bool isSudo = false, Func <string, bool> isCreate = null) { var controller = AuthMountController.From(http) ?? SecretMountController.From(http); if (controller == null) { throw new System.Security.SecurityException("permission denied"); } AssertAuthorized(server, controller, parameters, isSudo, isCreate); }
public void PushCommand_PushToServerWontRetryForever() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); MemoryStream memoryStream = new MemoryStream(); TextWriter writer = new StreamWriter(memoryStream); Console.SetOut(writer); string outputFileName = Path.Combine(packageDirectory, "t1.nupkg"); var server = new MockServer(mockServerEndPoint); server.Get.Add("/push", r => "OK"); server.Put.Add("/push", r => new Action <HttpListenerResponse>( response => { response.AddHeader("WWW-Authenticate", "NTLM"); response.StatusCode = (int)HttpStatusCode.Unauthorized; })); server.Start(); // Act var args = "push " + packageFileName + " -Source " + mockServerEndPoint + "push -NonInteractive"; var r1 = CommandRunner.Run( nugetexe, packageDirectory, args, waitForExit: true, timeOutInMilliseconds: 10000); server.Stop(); // Assert Assert.NotEqual(0, r1.Item1); Assert.Contains("Please provide credentials for:", r1.Item2); Assert.Contains("UserName:", r1.Item2); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); } }
public API_Moq_HttpContext setupNormalRequestValues() { var genericIdentity = new GenericIdentity("genericIdentity"); IPrincipal genericPrincipal = new GenericPrincipal(genericIdentity, new string[] {}); MockContext.Setup(context => context.User).Returns(() => { return(genericPrincipal); }); MockContext.SetupSet(context => context.User).Callback((IPrincipal principal) => { genericPrincipal = principal; }); MockContext.Setup(context => context.Cache).Returns(HttpRuntime.Cache); //Response var outputStream = new MemoryStream(); var redirectTarget = ""; var contentType = ""; MockResponse.SetupGet(response => response.ContentType).Returns(() => { return(contentType); }); MockResponse.SetupSet(response => response.ContentType).Callback((string value) => { contentType = value; }); MockResponse.SetupGet(response => response.Cache).Returns(new Mock <HttpCachePolicyBase>().Object); MockResponse.Setup(response => response.Cookies).Returns(new HttpCookieCollection()); MockResponse.Setup(response => response.Headers).Returns(new NameValueCollection()); MockResponse.Setup(response => response.OutputStream).Returns(outputStream); MockResponse.Setup(response => response.Write(It.IsAny <string>())).Callback((string code) => { HttpContextBase.response_Write(code); //outputStream.Write(code.asciiBytes(), 0, code.size()); }); MockResponse.Setup(response => response.AddHeader(It.IsAny <string>(), It.IsAny <string>())).Callback((string name, string value) => MockResponse.Object.Headers.Add(name, value)); MockResponse.Setup(response => response.Redirect(It.IsAny <string>())).Callback((string target) => { redirectTarget = target; throw new Exception("Thread was being aborted."); }); MockResponse.Setup(response => response.IsRequestBeingRedirected).Returns(() => redirectTarget.valid()); MockResponse.Setup(response => response.RedirectLocation).Returns(() => redirectTarget); //Server MockServer.Setup(server => server.MapPath(It.IsAny <string>())).Returns((string path) => BaseDir.pathCombine(path)); MockServer.Setup(server => server.Transfer(It.IsAny <string>())).Callback((string target) => { redirectTarget = target; throw new Exception("Thread was being aborted."); }); // use the redirectTarget to hold this value MockServer.Setup(server => server.Transfer(It.IsAny <string>(), It.IsAny <bool>())).Callback((string target, bool preserveForm) => { redirectTarget = target; throw new Exception("Thread was being aborted."); }); // use the redirectTarget to hold this value return(this); }
public ApprenticeAccountsInnerApiMock WithApprentice(Apprentice apprentice) { MockServer .Given( Request.Create() .WithPath($"/apprentices/{apprentice.ApprenticeUrlId()}") .UsingGet() ) .RespondWith( Response.Create() .WithBodyAsJson(apprentice) ); return(this); }
public static void GetUpdatesWithTimeout() { MockServer.ServerOkResponse.ResetRequestLogs(); MockServer.AddNewRouter("/botToken/getUpdates*", ResponseStringGetUpdatesResult.ExpectedBodyWithObjectMessage); mBotOkResponse.GetUpdates(timeout: 10); var request = MockServer.ServerOkResponse.SearchLogsFor(Requests.WithUrl("/botToken/getUpdates*").UsingPost()); ConsoleUtlis.PrintResult(request); Assert.AreEqual("/botToken/getUpdates?timeout=10", request.FirstOrDefault()?.Url); }
public async Task SplitPointList() { MockServer .Given(Request.Create().WithPath("/api/v2/write").UsingPost()) .RespondWith(CreateResponse("{}")); var writeApi = _influxDbClient.GetWriteApiAsync(); var points = new List <PointData> { PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(1L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(2L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(3L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(4L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(5L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(6L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(7L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(8L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(9L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(10L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(11L, WritePrecision.S), PointData.Measurement("h2o").Tag("location", "coyote_creek").Field("water_level", 10.0D) .Timestamp(12L, WritePrecision.S) }; var batches = points .Select((x, i) => new { Index = i, Value = x }) .GroupBy(x => x.Index / 5) .Select(x => x.Select(v => v.Value).ToList()) .ToList(); foreach (var batch in batches) { await writeApi.WritePointsAsync("my-bucket", "my-org", batch); } Assert.AreEqual(3, MockServer.LogEntries.Count()); }
public void Retry() { var listener = new EventListener(_writeApi); MockServer .Given(Request.Create().WithPath("/api/v2/write").UsingPost()) .InScenario("Retry") .WillSetStateTo("Retry Started") .RespondWith(CreateResponse("token is temporarily over quota", 429)); MockServer .Given(Request.Create().WithPath("/api/v2/write").UsingPost()) .InScenario("Retry") .WhenStateIs("Retry Started") .WillSetStateTo("Retry Finished") .RespondWith(CreateResponse("{}")); _writeApi.WriteRecord("b1", "org1", WritePrecision.Ns, "h2o_feet,location=coyote_creek level\\ description=\"feet 1\",water_level=1.0 1"); // // First request got Retry exception // var retriableErrorEvent = listener.Get <WriteRetriableErrorEvent>(); Assert.AreEqual("token is temporarily over quota", retriableErrorEvent.Exception.Message); Assert.AreEqual(429, ((HttpException)retriableErrorEvent.Exception).Status); Assert.AreEqual(1000, retriableErrorEvent.RetryInterval); // // Second request success // var writeSuccessEvent = listener.Get <WriteSuccessEvent>(); Assert.AreEqual("h2o_feet,location=coyote_creek level\\ description=\"feet 1\",water_level=1.0 1", writeSuccessEvent.LineProtocol); Assert.AreEqual(2, MockServer.LogEntries.Count()); Assert.AreEqual($"{MockServer.Urls[0]}/api/v2/write?org=org1&bucket=b1&precision=ns", MockServer.LogEntries.ToList()[0].RequestMessage.Url); Assert.AreEqual("h2o_feet,location=coyote_creek level\\ description=\"feet 1\",water_level=1.0 1", MockServer.LogEntries.ToList()[0].RequestMessage.Body); Assert.AreEqual($"{MockServer.Urls[0]}/api/v2/write?org=org1&bucket=b1&precision=ns", MockServer.LogEntries.ToList()[1].RequestMessage.Url); Assert.AreEqual("h2o_feet,location=coyote_creek level\\ description=\"feet 1\",water_level=1.0 1", MockServer.LogEntries.ToList()[1].RequestMessage.Body); }
public MockServer() { listener = new HttpListener(); //Add allowed prefixes for listener listener.Prefixes.Add(SERVER); listener.Prefixes.Add(SERVER + "2013-09-01/users/"); listener.Prefixes.Add(SERVER + "2013-09-01/file/"); listener.Prefixes.Add(SERVER + "2015-09-01/script/"); listener.Prefixes.Add(SERVER + "2013-09-01/classes/"); listener.Prefixes.Add(SERVER + "2013-09-01/installation/"); listener.Start(); instance = this; //Call to listen request WaitForNewRequest(); }
public async Task WithAuthentication() { FluxClient = FluxClientFactory.Create(new FluxConnectionOptions(MockServerUrl, "my-user", "my-password".ToCharArray())); MockServer.Given(Request.Create() .WithPath("/api/v2/query") .WithParam("u", new ExactMatcher("my-user")) .WithParam("p", new ExactMatcher("my-password")) .UsingPost()) .RespondWith(CreateResponse()); var result = await FluxClient.QueryAsync("from(bucket:\"telegraf\")"); AssertSuccessResult(result); }
public async void Connect_Should_Return_Connected_On_Valid_Data(int readTimeout, int writeTimeout, int pingTimeout) { //Arrange var connector = new EthernetConnector(new TcpSocket("127.0.0.1", 10619)); using var mockServer = new MockServer(new TcpServer(10619)); mockServer.Start(); //Act var result = await connector.Connect(readTimeout, writeTimeout, pingTimeout); mockServer.Stop(); //Assert Assert.Equal(ConnectionStatus.Connected, result); }
public async Task Error() { MockServer.Stop(); try { await FluxClient.Version(); Assert.Fail(); } catch (InfluxException e) { Assert.IsNotEmpty(e.Message); } }
public void HandleServerException() { RemotingMock cc = new RemotingMock(typeof(ICruiseManager)); cc.ExpectAndThrow("Run", new Exception("server exception"), new IsAnything(), new IsAnything()); TcpChannel channel = new TcpChannel(2334); using (MockServer server = new MockServer(cc.MarshalByRefInstance, channel, "MockCruise.rem")) { Runner runner = new Runner(); runner.Url = "tcp://localhost:2334/MockCruise.rem"; runner.Run("myProject"); } }
public LoginService Construct() { ILoginServer server; if (useMockData) { server = new MockServer(); } else { server = new LoginServer(); } return(new LoginService(server)); }
public CachingTestContext(TestDirectory testDirectory, MockServer mockServer, INuGetExe nuGetExe) { TestDirectory = testDirectory; MockServer = mockServer; NuGetExe = nuGetExe; PackageFramework = FrameworkConstants.CommonFrameworks.Net45; PackageIdentityA = new PackageIdentity("TestPackageA", new NuGetVersion("1.0.0")); PackageIdentityB = new PackageIdentity("TestPackageB", new NuGetVersion("1.0.0")); InitializeFiles(); InitializeServer(); MockServer.Start(); }
public void AddDetection_ResponsiveOptions_Disable_IncludeWebApi() { var builder = MockServer.WebHostBuilder(options => { options.Responsive.Disable = true; options.Responsive.IncludeWebApi = true; }); var exception = Assert.Throws <InvalidOperationException>(() => { using var server = new TestServer(builder); }); Assert.Equal("IncludeWebApi is not needed if already Disable", exception.Message); }
public ApprenticeAccountsInnerApiMock WithPing() { MockServer .Given( Request.Create() .WithPath($"/ping") .UsingGet() ) .RespondWith( Response.Create() .WithStatusCode((int)HttpStatusCode.OK) ); return(this); }
private void InitializeServer() { var baseUrl = MockServer.Uri.TrimEnd(new[] { '/' }); var builder = new MockResponseBuilder(baseUrl); CurrentSource = builder.GetV2Source(); V2Source = builder.GetV2Source(); V3Source = builder.GetV3Source(); AddPackageEndpoints(builder, PackageIdentityA, () => CurrentPackageAPath, () => IsPackageAAvailable); AddPackageEndpoints(builder, PackageIdentityB, () => PackageBPath, () => IsPackageBAvailable); // Add the V3 service index. MockServer.Get.Add( builder.GetV3IndexPath(), request => { return(new Action <HttpListenerResponse>(response => { var mockResponse = builder.BuildV3IndexResponse(MockServer.Uri); response.ContentType = mockResponse.ContentType; MockServer.SetResponseContent(response, mockResponse.Content); })); }); // Add the V2 "service index". var v2IndexPath = builder.GetV2IndexPath(); MockServer.Get.Add( v2IndexPath, request => { return(new Action <HttpListenerResponse>(response => { if (!request.RawUrl.EndsWith(v2IndexPath)) { response.StatusCode = 404; return; } var mockResponse = builder.BuildV2IndexResponse(); response.ContentType = mockResponse.ContentType; MockServer.SetResponseContent(response, mockResponse.Content); })); }); }
public void PushCommand_PushToServer() { var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); MemoryStream memoryStream = new MemoryStream(); TextWriter writer = new StreamWriter(memoryStream); Console.SetOut(writer); string outputFileName = Path.Combine(packageDirectory, "t1.nupkg"); var server = new MockServer(mockServerEndPoint); server.Get.Add("/push", r => "OK"); server.Put.Add("/push", r => { byte[] buffer = MockServer.GetPushedPackage(r); using (var of = new FileStream(outputFileName, FileMode.Create)) { of.Write(buffer, 0, buffer.Length); } return(HttpStatusCode.Created); }); server.Start(); // Act string[] args = new string[] { "push", packageFileName, "-Source", mockServerEndPoint + "push" }; int ret = Program.Main(args); writer.Close(); server.Stop(); // Assert Assert.Equal(0, ret); var output = Encoding.Default.GetString(memoryStream.ToArray()); Assert.Contains("Your package was pushed.", output); AssertFileEqual(packageFileName, outputFileName); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); } }
public async Task ReadingEmptySessionDoesNotCreateCookie() { var builder = MockServer.WebHostBuilder(context => { context.Session.SetString("Key", "Value"); return(Task.FromResult(0)); }); using var server = MockServer.Server(builder); var client = server.CreateClient(); var response = await client.GetAsync("/"); response.EnsureSuccessStatusCode(); Assert.True(response.Headers.TryGetValues("Set-Cookie", out var values)); Assert.Single(values); }
public void IfAndOnlyIfInitialSlashIsNotPresent_UpdateMappings_ShouldAddIt(string path, string expectedPath) { var mappingInfoViewModels = new List <MappingInfoViewModel> { new MappingInfoViewModel(A.Fake <IEditResponseWindowFactory>()) { Path = path } }; MockServer.UpdateMappings(mappingInfoViewModels); var wireMockMappings = GetWireMockMappings(); wireMockMappings.Single().Request.Path.Matchers.Single().Pattern.Should().Be(expectedPath); }
/// <summary> /// Sets up the server for the steps of running 3 Push commands. First is the initial push, followed by a duplicate push, followed by a new package push. /// Depending on the options of the push, the duplicate will either be a warning or an error and permit or prevent the third push. /// </summary> /// <param name="server">Server object to modify.</param> /// <param name="outputPathFunc">Function to determine path to output package.</param> /// <param name="responseCodeFunc">Function to determine which HttpStatusCode to return.</param> private static void SetupMockServerForSkipDuplicate(MockServer server, Func <int, string> outputPathFunc, Func <int, HttpStatusCode> responseCodeFunc) { int packageCounter = 0; server.Put.Add("/push", (Func <HttpListenerRequest, object>)((r) => { packageCounter++; var outputPath = outputPathFunc(packageCounter); MockServer.SavePushedPackage(r, outputPath); return(responseCodeFunc(packageCounter)); })); }
private static void StartTest(string body) { MockServer.AddNewRouter("/botToken/getUpdates", body); mBotOkResponse.GetUpdates(); var request = MockServer.ServerOkResponse.SearchLogsFor(Requests.WithUrl("/botToken/getUpdates").UsingPost()); ConsoleUtlis.PrintResult(request); Assert.Multiple(() => { Assert.AreEqual("/botToken/getUpdates", request.FirstOrDefault()?.Url); Assert.Throws <Exception>(() => mBotBadResponse.GetUpdates()); }); }
public ApprenticeCommitmentsInnerApiMock WithApprenticeshipsResponseForApprentice(Apprentice apprentice, GetApprenticeApprenticeshipsResult apprenticeshipsResult) { MockServer .Given( Request.Create() .WithPath($"/apprentices/{apprentice.ApprenticeUrlId()}/apprenticeships") .UsingGet() ) .RespondWith( Response.Create() .WithStatusCode((int)HttpStatusCode.OK) .WithBodyAsJson(apprenticeshipsResult) ); return(this); }
public async Task WithBasicAuthentication() { FluxClient = FluxClientFactory.Create(new FluxConnectionOptions(MockServerUrl, "my-user", "my-password".ToCharArray(), FluxConnectionOptions.AuthenticationType.BasicAuthentication)); var auth = System.Text.Encoding.UTF8.GetBytes("my-user:my-password"); MockServer.Given(Request.Create() .WithPath("/ping") .WithHeader("Authorization", new ExactMatcher("Basic " + Convert.ToBase64String(auth))) .UsingGet()) .RespondWith(Response.Create().WithStatusCode(204)); Assert.IsTrue(await FluxClient.PingAsync()); }
public async Task QueryError() { MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost()) .RespondWith(CreateErrorResponse("Flux query is not valid")); try { await FluxClient.QueryRawAsync("from(bucket:\"telegraf\")"); Assert.Fail(); } catch (InfluxException e) { Assert.That(e.Message.Equals("Flux query is not valid")); } }
private void SetUpCrlDistributionPoint() { lock (_crlServerRunningLock) { if (!_crlServerRunning) { CrlServer.Get.Add( "/", request => { var urlSplits = request.RawUrl.Split('/').Where(s => !string.IsNullOrEmpty(s)).ToArray(); if (urlSplits.Length != 2 || !urlSplits[1].EndsWith(".crl")) { return(new Action <HttpListenerResponse>(response => { response.StatusCode = 404; })); } else { var crlName = urlSplits[1]; var crlPath = Path.Combine(TestDirectory, crlName); if (File.Exists(crlPath)) { return(new Action <HttpListenerResponse>(response => { response.ContentType = "application/pkix-crl"; response.StatusCode = 200; var content = File.ReadAllBytes(crlPath); MockServer.SetResponseContent(response, content); })); } else { return(new Action <HttpListenerResponse>(response => { response.StatusCode = 404; })); } } }); CrlServer.Start(); _crlServerRunning = true; } } }
public async Task Test9() { MockServer server = new MockServer("test9"); var service = new Service(); ServiceCodec.Instance.Debug = true; service.Use(Log.IOHandler) .Use(Log.InvokeHandler) .Add <int, int, Task <int> >(Sum) .Bind(server); var client = new Client("mock://test9"); var r1 = client.InvokeAsync <int>("sum", new object[] { 1, 2 }); var r2 = client.InvokeAsync <int>("sum", new object[] { 3, 4 }); Assert.AreEqual(10, await client.InvokeAsync <int>("sum", new object[] { r1, r2 })); server.Close(); }
public async Task GetAllAsyncTest() { //Arrange string expected = "Teste"; IEnumerable <RedisKey> keys = new List <RedisKey> { new RedisKey("Teste") }; MockServer.Setup(m => m.Keys(It.IsAny <int>(), It.IsAny <RedisValue>(), It.IsAny <int>(), It.IsAny <long>(), It.IsAny <int>(), It.IsAny <CommandFlags>())) .Returns(keys); MockDB.Setup(m => m.StringGetAsync(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns(Task.FromResult(new RedisValue("Teste"))); //Act var actual = await RedisContext.GetAllAsync(); //Assert Assert.IsTrue(actual.ContainsKey(expected)); }
public Server ResolveServer() { lastMockServer = new MockServer(); return lastMockServer; }
public void RestoreCommand_FromHttpSource() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var workingDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://*****:*****@" <packages> <package id=""testPackage1"" version=""1.1.0"" /> </packages>"); var server = new MockServer(mockServerEndPoint); bool getPackageByVersionIsCalled = false; bool packageDownloadIsCalled = false; server.Get.Add("/nuget/Packages(Id='testPackage1',Version='1.1.0')", r => new Action<HttpListenerResponse>(response => { getPackageByVersionIsCalled = true; response.ContentType = "application/atom+xml;type=entry;charset=utf-8"; var odata = server.ToOData(package); MockServer.SetResponseContent(response, odata); })); server.Get.Add("/package/testPackage1", r => new Action<HttpListenerResponse>(response => { packageDownloadIsCalled = true; response.ContentType = "application/zip"; using (var stream = package.GetStream()) { var content = stream.ReadAllBytes(); MockServer.SetResponseContent(response, content); } })); server.Get.Add("/nuget", r => "OK"); server.Start(); // Act var args = "restore packages.config -PackagesDirectory . -Source " + mockServerEndPoint + "nuget"; var r1 = CommandRunner.Run( nugetexe, workingDirectory, args, waitForExit: true); server.Stop(); // Assert Assert.Equal(0, r1.Item1); Assert.True(getPackageByVersionIsCalled); Assert.True(packageDownloadIsCalled); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); Util.DeleteDirectory(workingDirectory); } }
public void InstallCommand_DownloadPackageWhenHashChanges() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var workingDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; try { // Arrange Util.CreateDirectory(packageDirectory); Util.CreateDirectory(workingDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); var package = new ZipPackage(packageFileName); MachineCache.Default.RemovePackage(package); // add the package to machine cache MachineCache.Default.AddPackage(package); // create a new package. Now this package has different hash value from the package in // the machine cache. packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); package = new ZipPackage(packageFileName); var server = new MockServer(mockServerEndPoint); string findPackagesByIdRequest = string.Empty; bool packageDownloadIsCalled = false; server.Get.Add("/nuget/FindPackagesById()", r => new Action<HttpListenerResponse>(response => { findPackagesByIdRequest = r.Url.ToString(); response.ContentType = "application/atom+xml;type=feed;charset=utf-8"; string feed = server.ToODataFeed(new[] { package }, "FindPackagesById"); MockServer.SetResponseContent(response, feed); })); server.Get.Add("/nuget/Packages(Id='testPackage1',Version='1.1.0')", r => new Action<HttpListenerResponse>(response => { response.ContentType = "application/atom+xml;type=entry;charset=utf-8"; var p1 = server.ToOData(package); MockServer.SetResponseContent(response, p1); })); server.Get.Add("/package/testPackage1", r => new Action<HttpListenerResponse>(response => { packageDownloadIsCalled = true; response.ContentType = "application/zip"; using (var stream = package.GetStream()) { var content = stream.ReadAllBytes(); MockServer.SetResponseContent(response, content); } })); server.Get.Add("/nuget", r => "OK"); server.Start(); // Act var args = "install testPackage1 -Source " + mockServerEndPoint + "nuget"; var r1 = CommandRunner.Run( nugetexe, workingDirectory, args, waitForExit: true); server.Stop(); // Assert Assert.Equal(0, r1.Item1); Assert.Contains("$filter=IsLatestVersion", findPackagesByIdRequest); // verifies that package is downloaded from server since the cached version has // a different hash from the package on the server. Assert.True(packageDownloadIsCalled); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); Util.DeleteDirectory(workingDirectory); } }
public void InstallCommand_WillTryNewVersionsByAppendingZeros() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var workingDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; try { // Arrange Util.CreateDirectory(workingDirectory); // deleting testPackage1 from machine cache var packages = MachineCache.Default.FindPackagesById("testPackage1"); foreach (var p in packages) { MachineCache.Default.RemovePackage(p); } var server = new MockServer(mockServerEndPoint); List<string> requests = new List<string>(); server.Get.Add("/nuget/Packages", r => { requests.Add(r.Url.ToString()); return HttpStatusCode.NotFound; }); server.Get.Add("/nuget", r => "OK"); server.Start(); // Act var args = "install testPackage1 -Version 1.1 -Source " + mockServerEndPoint + "nuget"; var r1 = CommandRunner.Run( nugetexe, workingDirectory, args, waitForExit: true); server.Stop(); // Assert Assert.Equal(1, r1.Item1); Assert.Equal(3, requests.Count); Assert.True(requests[0].EndsWith("Packages(Id='testPackage1',Version='1.1')")); Assert.True(requests[1].EndsWith("Packages(Id='testPackage1',Version='1.1.0')")); Assert.True(requests[2].EndsWith("Packages(Id='testPackage1',Version='1.1.0.0')")); } finally { // Cleanup Util.DeleteDirectory(workingDirectory); } }
public void ListCommand_AllVersionsPrerelease() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName1 = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); var packageFileName2 = Util.CreateTestPackage("testPackage2", "2.1", packageDirectory); var package1 = new ZipPackage(packageFileName1); var package2 = new ZipPackage(packageFileName2); var server = new MockServer(mockServerEndPoint); string searchRequest = string.Empty; server.Get.Add("/nuget/$metadata", r => MockServerResource.NuGetV2APIMetadata); server.Get.Add("/nuget/Search()", r => new Action<HttpListenerResponse>(response => { searchRequest = r.Url.ToString(); response.ContentType = "application/atom+xml;type=feed;charset=utf-8"; string feed = server.ToODataFeed(new[] { package1, package2 }, "Search"); MockServer.SetResponseContent(response, feed); })); server.Get.Add("/nuget", r => "OK"); server.Start(); // Act var args = "list test -AllVersions -Prerelease -Source " + mockServerEndPoint + "nuget"; var r1 = CommandRunner.Run( nugetexe, tempPath, args, waitForExit: true); server.Stop(); // Assert Assert.Equal(0, r1.Item1); // verify that the output is detailed var expectedOutput = "testPackage1 1.1.0" + Environment.NewLine + "testPackage2 2.1" + Environment.NewLine; Assert.Equal(expectedOutput, r1.Item2); Assert.DoesNotContain("$filter", searchRequest); Assert.Contains("searchTerm='test", searchRequest); Assert.Contains("includePrerelease=true", searchRequest); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); } }
public void PushCommand_PushToServerIntegratedWindowsAuthenticationDisableBuffering() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; IPrincipal getUser = null; IPrincipal putUser = null; try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); string outputFileName = Path.Combine(packageDirectory, "t1.nupkg"); var server = new MockServer(mockServerEndPoint); server.Listener.AuthenticationSchemes = AuthenticationSchemes.IntegratedWindowsAuthentication; server.Get.Add("/nuget", r => new Action<HttpListenerResponse, IPrincipal>((res, user) => { getUser = user; res.StatusCode = (int)HttpStatusCode.OK; })); server.Put.Add("/nuget", r => new Action<HttpListenerResponse, IPrincipal>((res, user) => { putUser = user; res.StatusCode = (int)HttpStatusCode.OK; })); server.Start(); // Act var args = "push " + packageFileName + " -Source " + mockServerEndPoint + "nuget -DisableBuffering"; var r1 = CommandRunner.Run( nugetexe, packageDirectory, args, waitForExit: true, timeOutInMilliseconds: 10000); server.Stop(); // Assert if (EnvironmentUtility.IsNet45Installed) { Assert.Equal(0, r1.Item1); var currentUser = WindowsIdentity.GetCurrent(); Assert.Equal("NTLM", getUser.Identity.AuthenticationType); Assert.Equal(currentUser.Name, getUser.Identity.Name); Assert.Equal("NTLM", putUser.Identity.AuthenticationType); Assert.Equal(currentUser.Name, putUser.Identity.Name); } else { // On .net 4.0, the process will get killed since integrated windows // authentication won't work when buffering is disabled. Assert.Equal(1, r1.Item1); Assert.Contains("Failed to process request. 'Unauthorized'", r1.Item3); Assert.Contains("This request requires buffering data to succeed.", r1.Item3); } } finally { // Cleanup Util.DeleteDirectory(packageDirectory); } }
public void PushCommand_PushToServerIntegratedWindowsAuthentication() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; IPrincipal getUser = null; IPrincipal putUser = null; try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); string outputFileName = Path.Combine(packageDirectory, "t1.nupkg"); var server = new MockServer(mockServerEndPoint); server.Listener.AuthenticationSchemes = AuthenticationSchemes.IntegratedWindowsAuthentication; server.Get.Add("/nuget", r => new Action<HttpListenerResponse, IPrincipal>((res, user) => { getUser = user; res.StatusCode = (int)HttpStatusCode.OK; })); server.Put.Add("/nuget", r => new Action<HttpListenerResponse, IPrincipal>((res, user) => { putUser = user; res.StatusCode = (int)HttpStatusCode.OK; })); server.Start(); // Act var args = "push " + packageFileName + " -Source " + mockServerEndPoint + "nuget"; var r1 = CommandRunner.Run( nugetexe, packageDirectory, args, waitForExit: true, timeOutInMilliseconds: 10000); server.Stop(); // Assert Assert.Equal(0, r1.Item1); var currentUser = WindowsIdentity.GetCurrent(); Assert.Equal("NTLM", getUser.Identity.AuthenticationType); Assert.Equal(currentUser.Name, getUser.Identity.Name); Assert.Equal("NTLM", putUser.Identity.AuthenticationType); Assert.Equal(currentUser.Name, putUser.Identity.Name); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); } }
public void PushCommand_PushToServerBasicAuthDisableBuffering() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; List<string> credentialForGetRequest = new List<string>(); List<string> credentialForPutRequest = new List<string>(); try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); string outputFileName = Path.Combine(packageDirectory, "t1.nupkg"); var server = new MockServer(mockServerEndPoint); server.Listener.AuthenticationSchemes = AuthenticationSchemes.Basic; server.Get.Add("/nuget", r => { var h = r.Headers["Authorization"]; var credential = System.Text.Encoding.Default.GetString(Convert.FromBase64String(h.Substring(6))); credentialForGetRequest.Add(credential); return HttpStatusCode.OK; }); server.Put.Add("/nuget", r => new Action<HttpListenerResponse>(res => { var h = r.Headers["Authorization"]; var credential = System.Text.Encoding.Default.GetString(Convert.FromBase64String(h.Substring(6))); credentialForPutRequest.Add(credential); if (credential.Equals("testuser:testpassword", StringComparison.OrdinalIgnoreCase)) { res.StatusCode = (int)HttpStatusCode.OK; } else { res.AddHeader("WWW-Authenticate", "Basic "); res.StatusCode = (int)HttpStatusCode.Unauthorized; } })); server.Start(); // Act Environment.SetEnvironmentVariable("FORCE_NUGET_EXE_INTERACTIVE", "true"); var args = "push " + packageFileName + " -Source " + mockServerEndPoint + "nuget -DisableBuffering"; var r1 = CommandRunner.Run( nugetexe, packageDirectory, args, waitForExit: true, timeOutInMilliseconds: 10000, inputAction: (w) => { // This user/password pair is first sent to // GET /nuget, then PUT /nuget w.WriteLine("a"); w.WriteLine("b"); // Send another user/password pair to PUT w.WriteLine("c"); w.WriteLine("d"); // Now send the right user/password to PUT w.WriteLine("testuser"); w.WriteLine("testpassword"); }); server.Stop(); // Assert Assert.Equal(0, r1.Item1); Assert.Equal(1, credentialForGetRequest.Count); Assert.Equal("a:b", credentialForGetRequest[0]); Assert.Equal(3, credentialForPutRequest.Count); Assert.Equal("a:b", credentialForPutRequest[0]); Assert.Equal("c:d", credentialForPutRequest[1]); Assert.Equal("testuser:testpassword", credentialForPutRequest[2]); } finally { // Cleanup Environment.SetEnvironmentVariable("FORCE_NUGET_EXE_INTERACTIVE", String.Empty); Util.DeleteDirectory(packageDirectory); } }
public void PushCommand_PushToServerWontRetryForever() { var targetDir = ConfigurationManager.AppSettings["TargetDir"]; var nugetexe = Path.Combine(targetDir, "nuget.exe"); var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); string outputFileName = Path.Combine(packageDirectory, "t1.nupkg"); var server = new MockServer(mockServerEndPoint); server.Get.Add("/push", r => "OK"); server.Put.Add("/push", r => new Action<HttpListenerResponse>( response => { response.AddHeader("WWW-Authenticate", "NTLM"); response.StatusCode = (int)HttpStatusCode.Unauthorized; })); server.Start(); // Act var args = "push " + packageFileName + " -Source " + mockServerEndPoint + "push -NonInteractive"; var r1 = CommandRunner.Run( nugetexe, packageDirectory, args, waitForExit: true, timeOutInMilliseconds: 10000); server.Stop(); // Assert Assert.NotEqual(0, r1.Item1); Assert.Contains("Please provide credentials for:", r1.Item2); Assert.Contains("UserName:", r1.Item2); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); } }
public void PushCommand_PushToServerWithInvalidRedirectionLocation() { var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); MemoryStream memoryStream = new MemoryStream(); TextWriter writer = new StreamWriter(memoryStream); Console.SetOut(writer); Console.SetError(writer); var server = new MockServer(mockServerEndPoint); server.Get.Add("/redirect", r => "OK"); server.Put.Add("/redirect", r => HttpStatusCode.Redirect); server.Start(); // Act string[] args = new string[] { "push", packageFileName, "-Source", mockServerEndPoint + "redirect" }; int ret = Program.Main(args); writer.Close(); server.Stop(); // Assert var output = Encoding.Default.GetString(memoryStream.ToArray()); Assert.NotEqual(0, ret); Assert.Contains("The remote server returned an error: (302)", output); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); } }
public void PushCommand_PushToServerFollowRedirection() { var tempPath = Path.GetTempPath(); var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); var mockServerEndPoint = "http://localhost:1234/"; try { // Arrange Util.CreateDirectory(packageDirectory); var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory); MemoryStream memoryStream = new MemoryStream(); TextWriter writer = new StreamWriter(memoryStream); Console.SetOut(writer); string outputFileName = Path.Combine(packageDirectory, "t1.nupkg"); var server = new MockServer(mockServerEndPoint); server.Get.Add("/redirect", r => "OK"); server.Put.Add("/redirect", r => new Action<HttpListenerResponse>( res => { res.Redirect(mockServerEndPoint + "nuget"); })); server.Put.Add("/nuget", r => { byte[] buffer = MockServer.GetPushedPackage(r); using (var of = new FileStream(outputFileName, FileMode.Create)) { of.Write(buffer, 0, buffer.Length); } return HttpStatusCode.Created; }); server.Start(); // Act string[] args = new string[] { "push", packageFileName, "-Source", mockServerEndPoint + "redirect" }; int ret = Program.Main(args); writer.Close(); server.Stop(); // Assert var output = Encoding.Default.GetString(memoryStream.ToArray()); Assert.Equal(0, ret); Assert.Contains("Your package was pushed.", output); AssertFileEqual(packageFileName, outputFileName); } finally { // Cleanup Util.DeleteDirectory(packageDirectory); } }