public async Task _1826Regression()
{
string packageName = "NuGetGallery.FunctionalTests.Fluent._1826RegressionTest";
string ticks = DateTime.Now.Ticks.ToString();
string version = new Version(ticks.Substring(0, 6) + "." + ticks.Substring(6, 6) + "." + ticks.Substring(12, 6)).ToString();
string newPackageLocation = await _packageCreationHelper.CreatePackage(packageName, version, null, null, null, null, null, @"
<group>
<dependency id=""jQuery"" version=""2.1.0"" />
</group>
<group targetFramework="".NETFramework4.0"">
<dependency id=""Newtonsoft.Json"" version=""6.0.1"" />
<dependency id=""jQuery"" version=""2.1.0"" />
</group>
");
// Log on using the test account.
I.LogOn(EnvironmentSettings.TestAccountName, EnvironmentSettings.TestAccountPassword);
// Navigate to the upload page and upload the package.
I.UploadPackageUsingUI(newPackageLocation);
I.Click("#verifyUploadSubmit");
// Validate that the package has uploaded.
I.Expect.Url(UrlHelper.BaseUrl + @"packages/" + packageName + "/" + version);
I.Expect.Count(1).Of("h4:contains('All Frameworks')");
I.Expect.Count(1).Of("h4:contains('.NETFramework 4.0')");
}
public async Task LockedPackageCannotBeModified()
{
// Arrange
string version = "2.0.0";
var packageCreationHelper = new PackageCreationHelper(TestOutputHelper);
var location = await packageCreationHelper.CreatePackage(LockedPackageId, version);
// Act & Assert
// 1. Try to upload package
TestOutputHelper.WriteLine($"1. Trying to upload package '{LockedPackageId}', version '{version}' to locked package id.");
var processResult = await _commandlineHelper.UploadPackageAsync(location, UrlHelper.V2FeedPushSourceUrl);
Assert.True(processResult.ExitCode != 0, "Package push succeeded, although was expected to fail.");
Assert.Contains("locked", processResult.StandardError);
// 2. Try unlisting the locked package
// Perform a sanity check that the package exists
await _clientSdkHelper.VerifyPackageExistsInV2Async(LockedPackageId, LockedPackageVersion);
TestOutputHelper.WriteLine($"5. Trying to unlist locked package '{LockedPackageId}', version '{LockedPackageVersion}'.");
processResult = await _commandlineHelper.DeletePackageAsync(LockedPackageId, LockedPackageVersion, UrlHelper.V2FeedPushSourceUrl);
Assert.True(processResult.ExitCode != 0, "Package delete succeeded, although was expected to fail.");
Assert.Contains("locked", processResult.StandardError);
}
public override IEnumerator <WebTestRequest> GetRequestEnumerator()
{
var defaultExtractionRule = AssertAndValidationHelper.GetDefaultExtractHiddenFields();
// Do initial login
var logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return(logonGet);
var logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return(logonPost);
var uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return(uploadRequest);
var packageId = $"UploadPackageFromUI.{DateTimeOffset.UtcNow.Ticks}";
var packageCreationHelper = new PackageCreationHelper();
var packageFullPath = packageCreationHelper.CreatePackage(packageId).Result;
var uploadPostRequest = AssertAndValidationHelper.GetUploadPostRequestForPackage(this, packageFullPath);
yield return(uploadPostRequest);
//This second get request to upload is to put us on the new "Verify Page"
// which is just the upload page in a different state.
// This is to get the RequestVerificationToken for the folloing request. (upload and verify were merged onto the same page).
var uploadRequest2 = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return(uploadRequest2);
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.GetPackagePageUrl(packageId, "1.0.0"), packageId);
yield return(verifyUploadPostRequest);
}
public async Task DuplicatePushesAreRejectedAndNotDeleted()
{
// Arrange
using (var client = new HttpClient())
{
var packageCreationHelper = new PackageCreationHelper(TestOutputHelper);
var packageId = $"{nameof(DuplicatePushesAreRejectedAndNotDeleted)}.{DateTime.UtcNow.Ticks}";
for (var i = 0; i < 10; i++)
{
if (i > 0)
{
TestOutputHelper.WriteLine(string.Empty);
TestOutputHelper.WriteLine(new string('=', 80));
TestOutputHelper.WriteLine(string.Empty);
}
var packageVersion = $"1.0.{i}";
TestOutputHelper.WriteLine($"Starting package {packageId} {packageVersion}...");
var packagePath = await packageCreationHelper.CreatePackage(packageId, packageVersion);
var tasks = new List <Task <HttpStatusCode> >();
var barrier = new Barrier(TaskCount);
// Act
for (var taskIndex = 0; taskIndex < TaskCount; taskIndex++)
{
tasks.Add(PushAsync(client, packagePath, barrier));
}
var statusCodes = await Task.WhenAll(tasks);
// Assert
for (var taskIndex = 1; taskIndex <= statusCodes.Length; taskIndex++)
{
TestOutputHelper.WriteLine($"Task {taskIndex:D2} push: HTTP {(int)statusCodes[taskIndex - 1]}");
}
var downloadUrl = $"{UrlHelper.V2FeedRootUrl}package/{packageId}/{packageVersion}";
using (var response = await client.GetAsync(downloadUrl))
{
TestOutputHelper.WriteLine($"Package download: HTTP {(int)response.StatusCode}");
Assert.Equal(response.StatusCode, HttpStatusCode.OK);
var expectedBytes = File.ReadAllBytes(packagePath);
var actualPackageBytes = await response.Content.ReadAsByteArrayAsync();
// The file length assertion is easier to read in the log.
Assert.Equal(expectedBytes.Length, actualPackageBytes.Length);
Assert.Equal(expectedBytes, actualPackageBytes);
}
Assert.Equal(1, statusCodes.Count(x => x == HttpStatusCode.Created));
Assert.Equal(TaskCount - 1, statusCodes.Count(x => x == HttpStatusCode.Conflict));
}
}
}
public override IEnumerator <WebTestRequest> GetRequestEnumerator()
{
ExtractHiddenFields defaultExtractionRule = AssertAndValidationHelper.GetDefaultExtractHiddenFields();
//Do initial login
WebTestRequest logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return(logonGet);
logonGet = null;
WebTestRequest logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return(logonPost);
logonPost = null;
WebTestRequest uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return(uploadRequest);
if (this.LastResponse.ResponseUri.ToString().Contains("verify-upload"))
{
WebTestRequest cancelGet = AssertAndValidationHelper.GetCancelGetRequest();
yield return(cancelGet);
cancelGet = null;
uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return(uploadRequest);
}
uploadRequest = null;
//Upload a new package.
string packageId = this.Name + DateTime.Now.Ticks.ToString();
string version = "1.0.0";
string minClientVersion = "2.3";
string packageFullPath = PackageCreationHelper.CreatePackage(packageId, version, minClientVersion);
WebTestRequest uploadPostRequest = AssertAndValidationHelper.GetUploadPostRequestForPackage(this, packageFullPath);
yield return(uploadPostRequest);
uploadPostRequest = null;
WebTestRequest verifyUploadRequest = new WebTestRequest(UrlHelper.VerifyUploadPageUrl);
verifyUploadRequest.ExtractValues += new EventHandler <ExtractionEventArgs>(defaultExtractionRule.Extract);
yield return(verifyUploadRequest);
verifyUploadRequest = null;
WebTestRequest verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.GetPackagePageUrl(packageId, "1.0.0"), packageId);
yield return(verifyUploadPostRequest);
verifyUploadPostRequest = null;
}
private async Task PushDuplicates(string packageId, string packageVersion, bool isFirstTask)
{
using (var client = new HttpClient())
{
var packageCreationHelper = new PackageCreationHelper(TestOutputHelper);
if (!isFirstTask)
{
TestOutputHelper.WriteLine(string.Empty);
TestOutputHelper.WriteLine(new string('=', 80));
TestOutputHelper.WriteLine(string.Empty);
}
TestOutputHelper.WriteLine($"Starting package {packageId} {packageVersion}...");
var packagePath = await packageCreationHelper.CreatePackage(packageId, packageVersion);
var tasks = new List <Task <HttpStatusCode> >();
var barrier = new Barrier(TaskCount);
// Act
for (var taskIndex = 0; taskIndex < TaskCount; taskIndex++)
{
tasks.Add(PushAsync(client, packagePath, barrier));
}
var statusCodes = await Task.WhenAll(tasks);
// Assert
for (var taskIndex = 1; taskIndex <= statusCodes.Length; taskIndex++)
{
TestOutputHelper.WriteLine($"{packageId}/{packageVersion} Task {taskIndex:D2} push: HTTP {(int)statusCodes[taskIndex - 1]}");
}
//Wait for the packages to be available in V2(due to async validation)
await _clientSdkHelper.VerifyPackageExistsInV2Async(packageId, packageVersion);
var downloadUrl = $"{UrlHelper.V2FeedRootUrl}package/{packageId}/{packageVersion}";
using (var response = await client.GetAsync(downloadUrl))
{
TestOutputHelper.WriteLine($"Package {packageId}/{packageVersion} download: HTTP {(int)response.StatusCode}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var actualPackageBytes = await response.Content.ReadAsByteArrayAsync();
using (var stream = new MemoryStream(actualPackageBytes))
using (var packageReader = new PackageArchiveReader(stream))
{
Assert.Equal(packageId, packageReader.NuspecReader.GetId());
Assert.Equal(packageVersion, packageReader.NuspecReader.GetVersion().ToNormalizedString());
}
}
Assert.Equal(1, statusCodes.Count(x => x == HttpStatusCode.Created));
Assert.Equal(TaskCount - 1, statusCodes.Count(x => x == HttpStatusCode.Conflict));
}
}
public override IEnumerator <WebTestRequest> GetRequestEnumerator()
{
// Temporary workaround for the SSL issue, which keeps the upload test from working with cloudapp.net sites
if (!UrlHelper.BaseUrl.Contains("nugettest.org") && !UrlHelper.BaseUrl.Contains("nuget.org"))
{
yield break;
}
var defaultExtractionRule = AssertAndValidationHelper.GetDefaultExtractHiddenFields();
// Do initial login
var logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return(logonGet);
var logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return(logonPost);
var uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return(uploadRequest);
if (LastResponse.ResponseUri.ToString().Contains("verify-upload"))
{
// If there is a upload in progress, try to submit that upload instead of creating a new package (since we are just going to verify that upload goes through UI).
// Extract the package Id of the pending upload.
var response = LastResponse.BodyString;
var startIndex = response.IndexOf("<p>", StringComparison.Ordinal);
var endIndex = response.IndexOf("</p>", startIndex, StringComparison.Ordinal);
var packageId = response.Substring(startIndex + 3, endIndex - (startIndex + 3));
AddCommentToResult(packageId); //Adding the package ID to result for debugging.
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.VerifyUploadPageUrl, Constants.ReadOnlyModeError, 503);
yield return(verifyUploadPostRequest);
}
else
{
// The API key is part of the nuget.config file that is present under the solution dir.
var packageId = DateTime.Now.Ticks.ToString();
var packageCreationHelper = new PackageCreationHelper();
var packageFullPath = packageCreationHelper.CreatePackage(packageId).Result;
var uploadPostRequest = AssertAndValidationHelper.GetUploadPostRequestForPackage(this, packageFullPath);
yield return(uploadPostRequest);
var verifyUploadRequest = new WebTestRequest(UrlHelper.VerifyUploadPageUrl);
verifyUploadRequest.ExtractValues += defaultExtractionRule.Extract;
yield return(verifyUploadRequest);
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.GetPackagePageUrl(packageId, "1.0.0"), packageId);
yield return(verifyUploadPostRequest);
}
}
public override IEnumerator <WebTestRequest> GetRequestEnumerator()
{
//run this test only if read-only mode is set. This is to avoid false failures while doing Run all tests locally.
if (!EnvironmentSettings.ReadOnlyMode.Equals("True", StringComparison.OrdinalIgnoreCase))
{
yield break;
}
var defaultExtractionRule = AssertAndValidationHelper.GetDefaultExtractHiddenFields();
// Do initial login
var logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return(logonGet);
var logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return(logonPost);
var uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return(uploadRequest);
if (LastResponse.ResponseUri.ToString().Contains("verify-upload"))
{
// if there is a upload in progress, try to submit that upload instead of creating a new package (since we are just going to verify that upload doesn't go through).
//Extract the package Id of the pending upload.
var response = LastResponse.BodyString;
var startIndex = response.IndexOf("<p>", StringComparison.Ordinal);
var endIndex = response.IndexOf("</p>", startIndex, StringComparison.Ordinal);
var packageId = response.Substring(startIndex + 3, endIndex - (startIndex + 3));
AddCommentToResult(packageId); //Adding the package ID to result for debugging.
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.VerifyUploadPageUrl, Constants.ReadOnlyModeError, 503);
yield return(verifyUploadPostRequest);
}
else
{
// The API key is part of the nuget.config file that is present under the solution dir.
var packageId = DateTime.Now.Ticks.ToString();
var packageCreationHelper = new PackageCreationHelper();
var packageFullPath = packageCreationHelper.CreatePackage(packageId).Result;
var uploadPostRequest = AssertAndValidationHelper.GetUploadPostRequestForPackage(this, packageFullPath);
yield return(uploadPostRequest);
var verifyUploadRequest = new WebTestRequest(UrlHelper.VerifyUploadPageUrl);
verifyUploadRequest.ExtractValues += defaultExtractionRule.Extract;
yield return(verifyUploadRequest);
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.VerifyUploadPageUrl, Constants.ReadOnlyModeError, 503);
yield return(verifyUploadPostRequest);
}
}
public override IEnumerator<WebTestRequest> GetRequestEnumerator()
{
//run this test only if read-only mode is set. This is to avoid false failures while doing Run all tests locally.
if (!EnvironmentSettings.ReadOnlyMode.Equals("True", StringComparison.OrdinalIgnoreCase))
{
yield break;
}
var defaultExtractionRule = AssertAndValidationHelper.GetDefaultExtractHiddenFields();
// Do initial login
var logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return logonGet;
var logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return logonPost;
var uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return uploadRequest;
if (LastResponse.ResponseUri.ToString().Contains("verify-upload"))
{
// if there is a upload in progress, try to submit that upload instead of creating a new package (since we are just going to verify that upload doesn't go through).
//Extract the package Id of the pending upload.
var response = LastResponse.BodyString;
var startIndex = response.IndexOf("<p>", StringComparison.Ordinal);
var endIndex = response.IndexOf("</p>", startIndex, StringComparison.Ordinal);
var packageId = response.Substring(startIndex + 3, endIndex - (startIndex + 3));
AddCommentToResult(packageId); //Adding the package ID to result for debugging.
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.VerifyUploadPageUrl, Constants.ReadOnlyModeError, 503);
yield return verifyUploadPostRequest;
}
else
{
// The API key is part of the nuget.config file that is present under the solution dir.
var packageId = DateTime.Now.Ticks.ToString();
var packageCreationHelper = new PackageCreationHelper();
var packageFullPath = packageCreationHelper.CreatePackage(packageId).Result;
var uploadPostRequest = AssertAndValidationHelper.GetUploadPostRequestForPackage(this, packageFullPath);
yield return uploadPostRequest;
var verifyUploadRequest = new WebTestRequest(UrlHelper.VerifyUploadPageUrl);
verifyUploadRequest.ExtractValues += defaultExtractionRule.Extract;
yield return verifyUploadRequest;
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.VerifyUploadPageUrl, Constants.ReadOnlyModeError, 503);
yield return verifyUploadPostRequest;
}
}
public override IEnumerator <WebTestRequest> GetRequestEnumerator()
{
ExtractHiddenFields defaultExtractionRule = AssertAndValidationHelper.GetDefaultExtractHiddenFields();
//Do initial login
WebTestRequest logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return(logonGet);
logonGet = null;
WebTestRequest logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return(logonPost);
logonPost = null;
WebTestRequest uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return(uploadRequest);
uploadRequest = null;
//Upload a new package.
string packageId = this.Name + DateTime.Now.Ticks.ToString();
string version = "1.0.0";
string minClientVersion = "2.3";
string packageFullPath = PackageCreationHelper.CreatePackage(packageId, version, minClientVersion);
//Do initial login to be able to perform package management.
logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return(logonGet);
logonGet = null;
logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return(logonPost);
logonPost = null;
System.Threading.Thread.Sleep(60000);
WebTestRequest packageRequest = new WebTestRequest(UrlHelper.GetPackagePageUrl(packageId));
//Rule to check manage my packages contains a html link to the newly uploaded package.
ValidationRuleFindText requiredMinVersionValidationRule = AssertAndValidationHelper.GetValidationRuleForFindText(minClientVersion);
packageRequest.ValidateResponse += new EventHandler <ValidationEventArgs>(requiredMinVersionValidationRule.Validate);
yield return(packageRequest);
packageRequest = null;
}
public override IEnumerator<WebTestRequest> GetRequestEnumerator()
{
ExtractHiddenFields defaultExtractionRule = AssertAndValidationHelper.GetDefaultExtractHiddenFields();
//Do initial login
WebTestRequest logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return logonGet;
logonGet = null;
WebTestRequest logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return logonPost;
logonPost = null;
WebTestRequest uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return uploadRequest;
uploadRequest = null;
string packageId = DateTime.Now.Ticks.ToString();
string packageFullPath = PackageCreationHelper.CreatePackage(packageId);
WebTestRequest uploadPostRequest = AssertAndValidationHelper.GetUploadPostRequestForPackage(this, packageFullPath);
yield return uploadPostRequest;
uploadPostRequest = null;
WebTestRequest verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0");
yield return verifyUploadPostRequest;
verifyUploadPostRequest = null;
System.Threading.Thread.Sleep(60000);
WebTestRequest packageRequest = new WebTestRequest(UrlHelper.GetPackagePageUrl(packageId));
ValidationRuleFindText findTextRule = AssertAndValidationHelper.GetValidationRuleForFindText("Contact Us");
packageRequest.ValidateResponse += new EventHandler<ValidationEventArgs>(findTextRule.Validate);
yield return packageRequest;
packageRequest = null;
// Log off
WebTestRequest logOffGet = AssertAndValidationHelper.GetLogOffGetRequest();
yield return logOffGet;
logOffGet = null;
packageRequest = new WebTestRequest(UrlHelper.GetPackagePageUrl(packageId));
//Rule to check manage my packages contains a html link to the newly uploaded package.
ValidationRuleFindText reportAbuseValidationRule = AssertAndValidationHelper.GetValidationRuleForFindText("Report Abuse");
packageRequest.ValidateResponse += new EventHandler<ValidationEventArgs>(reportAbuseValidationRule.Validate);
yield return packageRequest;
packageRequest = null;
}
public override IEnumerator<WebTestRequest> GetRequestEnumerator()
{
// Temporary workaround for the SSL issue, which keeps the upload test from working with cloudapp.net sites
if (!UrlHelper.BaseUrl.Contains("nugettest.org") && !UrlHelper.BaseUrl.Contains("nuget.org"))
yield break;
var defaultExtractionRule = AssertAndValidationHelper.GetDefaultExtractHiddenFields();
// Do initial login
var logonGet = AssertAndValidationHelper.GetLogonGetRequest();
yield return logonGet;
var logonPost = AssertAndValidationHelper.GetLogonPostRequest(this);
yield return logonPost;
var uploadRequest = AssertAndValidationHelper.GetHttpRequestForUrl(UrlHelper.UploadPageUrl);
yield return uploadRequest;
if (LastResponse.ResponseUri.ToString().Contains("verify-upload"))
{
// If there is a upload in progress, try to submit that upload instead of creating a new package (since we are just going to verify that upload goes through UI).
// Extract the package Id of the pending upload.
var response = LastResponse.BodyString;
var startIndex = response.IndexOf("<p>", StringComparison.Ordinal);
var endIndex = response.IndexOf("</p>", startIndex, StringComparison.Ordinal);
var packageId = response.Substring(startIndex + 3, endIndex - (startIndex + 3));
AddCommentToResult(packageId); //Adding the package ID to result for debugging.
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.VerifyUploadPageUrl, Constants.ReadOnlyModeError, 503);
yield return verifyUploadPostRequest;
}
else
{
// The API key is part of the nuget.config file that is present under the solution dir.
var packageId = DateTime.Now.Ticks.ToString();
var packageCreationHelper = new PackageCreationHelper();
var packageFullPath = packageCreationHelper.CreatePackage(packageId).Result;
var uploadPostRequest = AssertAndValidationHelper.GetUploadPostRequestForPackage(this, packageFullPath);
yield return uploadPostRequest;
var verifyUploadRequest = new WebTestRequest(UrlHelper.VerifyUploadPageUrl);
verifyUploadRequest.ExtractValues += defaultExtractionRule.Extract;
yield return verifyUploadRequest;
var verifyUploadPostRequest = AssertAndValidationHelper.GetVerifyPackagePostRequestForPackage(this, packageId, "1.0.0", UrlHelper.GetPackagePageUrl(packageId, "1.0.0"), packageId);
yield return verifyUploadPostRequest;
}
}
public async Task PackagesAppearInFeedInOrderTest()
{
// This test uploads/unlists packages in a particular order to test the timestamps of the packages in the feed.
// Because it waits for previous requests to finish before starting new ones, it will only catch ordering issues if these issues are greater than a second or two.
// This is consistent with the time frame in which we've seen these issues in the past, but if new issues arise that are on a smaller scale, this test will not catch it!
var uploadedPackageIds = new List <string>();
var version = "1.0.0";
var startingTime = DateTime.UtcNow;
// Upload the packages in order.
var uploadStartTimestamp = DateTime.UtcNow.AddMinutes(-1);
for (var i = 0; i < PackagesInOrderNumPackages; i++)
{
var packageId = UploadHelper.GetUniquePackageId();
var packageFullPath = await _packageCreationHelper.CreatePackage(packageId, version);
var commandOutput = await _commandlineHelper.UploadPackageAsync(packageFullPath, UrlHelper.V2FeedPushSourceUrl);
Assert.True(
commandOutput.ExitCode == 0,
$"Push failed with exit code {commandOutput.ExitCode}{Environment.NewLine}{commandOutput.StandardError}");
uploadedPackageIds.Add(packageId);
}
await Task.WhenAll(uploadedPackageIds.Select(id => _clientSdkHelper.VerifyPackageExistsInV2Async(id, version, listed: true)));
await CheckPackageTimestampsInOrder(uploadedPackageIds, "Created", uploadStartTimestamp, version);
// Unlist the packages in order.
var unlistedPackageIds = new List <string>();
var unlistStartTimestamp = DateTime.UtcNow.AddMinutes(-1);
foreach (var uploadedPackageId in uploadedPackageIds)
{
await _commandlineHelper.DeletePackageAsync(uploadedPackageId, version, UrlHelper.V2FeedPushSourceUrl);
unlistedPackageIds.Add(uploadedPackageId);
}
await Task.WhenAll(unlistedPackageIds.Select(id => _clientSdkHelper.VerifyPackageExistsInV2Async(id, version, listed: false)));
await CheckPackageTimestampsInOrder(unlistedPackageIds, "LastEdited", unlistStartTimestamp, version);
}
private async Task <HttpResponseMessage> PushPackageAsync(string apiKey, string packageId, string clientVersion = null)
{
var packageCreationHelper = new PackageCreationHelper(TestOutputHelper);
var packagePath = await packageCreationHelper.CreatePackage(packageId);
using (var httpClient = new HttpClient())
using (var request = new HttpRequestMessage(HttpMethod.Put, UrlHelper.V2FeedPushSourceUrl))
{
request.Headers.Add(Constants.NuGetHeaderApiKey, EnvironmentSettings.TestSecurityPoliciesAccountApiKey);
if (clientVersion != null)
{
request.Headers.Add(Constants.NuGetHeaderClientVersion, clientVersion);
}
request.Content = new StreamContent(new FileStream(packagePath, FileMode.Open));
return(await httpClient.SendAsync(request));
}
}
public async Task EditAndSearch()
{
// Use the same package name, but force the version to be unique.
string packageName = "NuGetGallery.FunctionalTests.Fluent.EditAndSearch";
string ticks = DateTime.Now.Ticks.ToString();
string version = new Version(ticks.Substring(0, 6) + "." + ticks.Substring(6, 6) + "." + ticks.Substring(12, 6)).ToString();
string newPackageLocation = await _packageCreationHelper.CreatePackage(packageName, version);
// Log on using the test account.
I.LogOn(EnvironmentSettings.TestAccountName, EnvironmentSettings.TestAccountPassword);
// Navigate to the upload page.
I.UploadPackageUsingUI(newPackageLocation);
// Edit the package.
I.Click("#Edit_VersionTitleButton");
string newTitle = string.Format("This title is accurate as of {0}.", DateTime.Now.ToString("F"));
I.Enter(newTitle).In("#Edit_VersionTitle");
I.Click("#verifyUploadSubmit");
// Re-load and validate that the edit has been applied.
// The edit can be applied anytime within ten mins. to be considered successful. This tries 20 times with a 30 sec. timeout.
bool applied = false;
for (int i = 0; i < 20; i++)
{
I.Enter(newTitle).In("#searchBoxInput");
I.Click("#searchBoxSubmit");
// Starting API V3, we have removed the search sort order
//I.Select("Recent").From("#sortOrder");
try
{
I.Expect.Count(2).Of("h1:contains('" + newTitle + "')");
applied = true;
}
catch
{
// We expect an exception after 30 seconds if the edit hasn't been applied yet.
}
}
Assert.True(applied, "The edit doesn't appear to have been applied after ten minutes.");
}
private async Task<HttpResponseMessage> PushPackageAsync(string apiKey, string packageId, string clientVersion = null, string protocolVersion = null)
{
var packageCreationHelper = new PackageCreationHelper(TestOutputHelper);
var packagePath = await packageCreationHelper.CreatePackage(packageId);
using (var httpClient = new HttpClient())
using (var request = new HttpRequestMessage(HttpMethod.Put, UrlHelper.V2FeedPushSourceUrl))
{
request.Headers.Add(Constants.NuGetHeaderApiKey, GalleryConfiguration.Instance.Account.ApiKey);
if (clientVersion != null)
{
request.Headers.Add(Constants.NuGetHeaderClientVersion, clientVersion);
}
if (protocolVersion != null)
{
request.Headers.Add(Constants.NuGetHeaderProtocolVersion, protocolVersion);
}
request.Content = new StreamContent(new FileStream(packagePath, FileMode.Open));
return await httpClient.SendAsync(request);
}
}
/// <summary>
/// Creates a package with the specified Id and Version and uploads it and checks if the upload has suceeded.
/// This will be used by test classes which tests scenarios on top of upload.
/// </summary>
/// <param name="packageId"></param>
/// <param name="version"></param>
public static void UploadNewPackageAndVerify(string packageId, string version = "1.0.0", string minClientVersion = null, string title = null, string tags = null, string description = null, string licenseUrl = null, string dependencies = null)
{
if (string.IsNullOrEmpty(packageId))
{
packageId = DateTime.Now.Ticks.ToString();
}
string packageFullPath = PackageCreationHelper.CreatePackage(packageId, version, minClientVersion, title, tags, description, licenseUrl, dependencies);
string standardOutput = string.Empty;
string standardError = string.Empty;
int exitCode = CmdLineHelper.UploadPackage(packageFullPath, UrlHelper.V2FeedPushSourceUrl, out standardOutput, out standardError);
Assert.IsTrue((exitCode == 0), "The package upload via Nuget.exe did not succeed properly. Check the logs to see the process error and output stream. Exit Code: " + exitCode + ". Error message: \"" + standardError + "\"");
Console.WriteLine(standardOutput);
Console.WriteLine(standardError);
Assert.IsTrue(ClientSDKHelper.CheckIfPackageVersionExistsInSource(packageId, version, UrlHelper.V2FeedRootUrl), "Package {0} with version {1} is not found in the site {2} after uploading.", packageId, version, UrlHelper.V2FeedRootUrl);
//Delete package from local disk so once it gets uploaded
if (File.Exists(packageFullPath))
{
File.Delete(packageFullPath);
Directory.Delete(Path.GetFullPath(Path.GetDirectoryName(packageFullPath)), true);
}
}
public void MinClientVersionFromUI()
{
// Use the same package name, but force the version to be unique.
string packageName = "NuGetGallery.FunctionalTests.Fluent.MinClientVersionFromUITest";
string ticks = DateTime.Now.Ticks.ToString();
string version = new System.Version(ticks.Substring(0, 6) + "." + ticks.Substring(6, 6) + "." + ticks.Substring(12, 6)).ToString();
string newPackageLocation = PackageCreationHelper.CreatePackage(packageName, version, "2.7");
// Log on using the test account.
I.LogOn(EnvironmentSettings.TestAccountName, EnvironmentSettings.TestAccountPassword);
// Navigate to the upload page.
I.UploadPackageUsingUI(newPackageLocation);
// Submit on the validate upload page.
I.Click("input[value='Submit']");
// Validate that the minclientversion is shown to the user on the package page.
I.Expect.Url(UrlHelper.BaseUrl + @"packages/" + packageName + "/" + version);
string expectedMinClientVersion = @"p:contains('Requires NuGet 2.7 or higher')";
I.Expect.Count(1).Of(expectedMinClientVersion);
}
public async Task EditPackageAsPartOfUpload()
{
// Use the same package name, but force the version to be unique.
string packageName = "NuGetGallery.FunctionalTests.Fluent.EditPackageAsPartOfUploadTest";
string ticks = DateTime.Now.Ticks.ToString();
string version = new Version(ticks.Substring(0, 6) + "." + ticks.Substring(6, 6) + "." + ticks.Substring(12, 6)).ToString();
string newPackageLocation = await _packageCreationHelper.CreatePackage(packageName, version);
// Log on using the test account.
I.LogOn(EnvironmentSettings.TestAccountName, EnvironmentSettings.TestAccountPassword);
// Navigate to the upload page.
I.UploadPackageUsingUI(newPackageLocation);
// Edit the package.
I.Click("#Edit_VersionTitleButton");
string newTitle = string.Format("This title is accurate as of {0}.", DateTime.Now.ToString("F"));
I.Enter(newTitle).In("#Edit_VersionTitle");
I.Click("#Edit_DescriptionButton");
string newDescription = string.Format("This description is accurate as of {0}.", DateTime.Now.ToString("F"));
I.Enter(newDescription).In("#Edit_Description");
I.Click("#Edit_SummaryButton");
string newSummary = string.Format("This summary is accurate as of {0}.", DateTime.Now.ToString("F"));
I.Enter(newSummary).In("#Edit_Summary");
I.Click("#Edit_IconUrlButton");
string newIconUrl = string.Format("http://microsoft.com/IconUrl/{0}", DateTime.Now.ToString("FFFFFFF"));
I.Enter(newIconUrl).In("#Edit_IconUrl");
I.Click("#Edit_ProjectUrlButton");
string newHomePageUrl = string.Format("http://microsoft.com/HomePageUrl/{0}", DateTime.Now.ToString("FFFFFFF"));
I.Enter(newHomePageUrl).In("#Edit_ProjectUrl");
I.Click("#Edit_AuthorsButton");
string newAuthors = string.Format("These authors are accurate as of {0}.", DateTime.Now.ToString("F"));
I.Enter(newAuthors).In("#Edit_Authors");
I.Click("#Edit_CopyrightButton");
string newCopyright = string.Format("Copyright {0}.", DateTime.Now.ToString("F"));
I.Enter(newCopyright).In("#Edit_Copyright");
I.Click("#Edit_TagsButton");
string newTags = string.Format("These tags are accurate as of {0}.", DateTime.Now.ToString("F"));
I.Enter(newTags).In("#Edit_Tags");
I.Click("#Edit_ReleaseNotesButton");
string newReleaseNotes = string.Format("These release notes are accurate as of {0}.", DateTime.Now.ToString("F"));
I.Enter(newReleaseNotes).In("#Edit_ReleaseNotes");
I.Click("#verifyUploadSubmit");
// Validate that the edit is queued.
I.Expect.Url(UrlHelper.BaseUrl + @"packages/" + packageName + "/" + version);
string expectedDescription = @"p:contains('" + newDescription + "')";
string unexpectedSummary = @"contains('" + newSummary + "')";
string unexpectedIconUrl = "img[src='" + newIconUrl + "']";
string defaultIconUrl = UrlHelper.BaseUrl + "Content/Images/packageDefaultIcon.png";
string expectedIconUrl = "img[src='" + defaultIconUrl + "']";
string expectedHomePageUrl = "a[href='" + newHomePageUrl + "']";
string unexpectedCopyright = @"contains('" + newCopyright + "')";
string expectedReleaseNotes = @"p:contains('" + newReleaseNotes + "')";
string editPending = @"p:contains('An edit is pending for this package version.')";
I.Expect.Count(1).Of(expectedDescription);
I.Expect.Count(0).Of(unexpectedSummary); // Summary is not present on the package page.
I.Expect.Count(0).Of(unexpectedIconUrl);
I.Expect.Count(1).Of(expectedIconUrl);
I.Expect.Count(1).Of(expectedHomePageUrl);
I.Expect.Text(newAuthors).In("p[class=authors]");
I.Expect.Count(0).Of(unexpectedCopyright); // Copyright is not present on the package page.
I.Expect.Count(1).Of(expectedReleaseNotes);
string[] tags = newTags.Split(" ,;".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string tag in tags)
{
I.Expect.Text(tag).In("a[title='Search for " + tag + "']");
}
// Validate the pending edit message.
I.Expect.Count(1).Of(editPending);
// Re-load and validate that the edit has been applied.
// The edit can be applied anytime within 5 mins. to be considered successful. This tries 10 times with a 30 sec. timeout.
bool applied = false;
for (int i = 0; i < 10; i++)
{
I.Open(UrlHelper.BaseUrl + @"Packages/" + packageName + "/" + version);
I.Expect.Count(1).Of(expectedDescription);
try
{
I.Expect.Count(0).Of(editPending);
applied = true;
}
catch
{
// We expect an exception if the edit hasn't been applied yet.
}
}
Assert.True(applied, "The edit doesn't appear to have been applied after five minutes.");
}
public async Task VerifyScopedApiKeys()
{
// Arrange
var packageCreationHelper = new PackageCreationHelper(TestOutputHelper);
var commandlineHelper = new CommandlineHelper(TestOutputHelper);
var packageId = "ScopedApiKeysTest_" + DateTime.Now.Ticks;
var version1 = "1.0.0";
var version2 = "2.0.0";
string package1FullPath = null;
string package2FullPath = null;
try
{
package1FullPath = await packageCreationHelper.CreatePackage(packageId, version1);
package2FullPath = await packageCreationHelper.CreatePackage(packageId, version2);
// 1. Try to upload package using 'unlist' api key => expect failure
TestOutputHelper.WriteLine($"1. Trying to upload package '{packageId}', version '{version1}' using 'unlist' API key. Expected result: failure.");
var processResult = await commandlineHelper.UploadPackageAsync(package1FullPath, UrlHelper.V2FeedPushSourceUrl, EnvironmentSettings.TestAccountApiKey_Unlist);
Assert.True(processResult.ExitCode != 0, "Package push succeeded, although was expected to fail.");
// 2. Try to upload package using 'push version' api key => expect failure
TestOutputHelper.WriteLine($"2. Trying to upload package '{packageId}', version '{version1}' using 'push version' API key. Expected result: failure.");
processResult = await commandlineHelper.UploadPackageAsync(package1FullPath, UrlHelper.V2FeedPushSourceUrl, EnvironmentSettings.TestAccountApiKey_PushVersion);
Assert.True(processResult.ExitCode != 0, "Package push succeeded, although was expected to fail.");
// 3. Upload package using 'push' api key => expect success
TestOutputHelper.WriteLine($"3. Trying to upload package '{packageId}', version '{version1}' using 'push' API key. Expected result: success.");
await _clientSdkHelper.UploadExistingPackage(package1FullPath, EnvironmentSettings.TestAccountApiKey_Push);
// 4. Upload new version of package using 'push version' api key => expect success
TestOutputHelper.WriteLine($"4. Trying to upload package '{packageId}', version '{version2}' using 'push version' API key. Expected result: success.");
await _clientSdkHelper.UploadExistingPackage(package2FullPath, EnvironmentSettings.TestAccountApiKey_PushVersion);
// Verify the existence of the two pushed packages.
await _clientSdkHelper.VerifyPackageExistsInV2Async(packageId, version1);
await _clientSdkHelper.VerifyPackageExistsInV2Async(packageId, version2);
// 5. Try unlisting package version1 using 'push' api key => expect failture
TestOutputHelper.WriteLine($"5. Trying to unlist package '{packageId}', version '{version1}' using 'push' API key. Expected result: failure.");
processResult = await commandlineHelper.DeletePackageAsync(packageId, version1, UrlHelper.V2FeedPushSourceUrl, EnvironmentSettings.TestAccountApiKey_Push);
Assert.True(processResult.ExitCode != 0, "Package delete succeeded, although was expected to fail.");
// 6. Try unlisting package version2 using 'push version' api key => expect failture
TestOutputHelper.WriteLine($"6. Trying to unlist package '{packageId}', version '{version2}' using 'push' API key. Expected result: failure.");
processResult = await commandlineHelper.DeletePackageAsync(packageId, version2, UrlHelper.V2FeedPushSourceUrl, EnvironmentSettings.TestAccountApiKey_PushVersion);
Assert.True(processResult.ExitCode != 0, "Package delete succeeded, although was expected to fail.");
// 7. Unlist both packages using 'unlist' api key => expect succees
TestOutputHelper.WriteLine($"7. Trying to unlist package '{packageId}', version '{version1}' using 'unlist' API key. Expected result: success.");
await _clientSdkHelper.UnlistPackage(packageId, version1, EnvironmentSettings.TestAccountApiKey_Unlist);
TestOutputHelper.WriteLine($"8. Trying to unlist package '{packageId}', version '{version2}' using 'unlist' API key. Expected result: success.");
await _clientSdkHelper.UnlistPackage(packageId, version2, EnvironmentSettings.TestAccountApiKey_Unlist);
}
finally
{
_clientSdkHelper.CleanCreatedPackage(package1FullPath);
_clientSdkHelper.CleanCreatedPackage(package2FullPath);
}
}
