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