| private SetupPackageFromInputStream ( Stream packageStream ) : void | ||
| packageStream | Stream | |
| return | void | |
public async Task CreatePackageWillSavePackageFileToFileStorage()
{
// Arrange
var guid = Guid.NewGuid().ToString();
var user = new User() { EmailAddress = "*****@*****.**" };
var userService = new Mock<IUserService>();
var packageRegistration = new PackageRegistration();
packageRegistration.Owners.Add(user);
var controller = new TestableApiController();
controller.MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny<Package>(), It.IsAny<Stream>())).Returns(Task.FromResult(0)).Verifiable();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(user);
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny<string>())).Returns(packageRegistration);
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut(guid);
// Assert
controller.MockPackageFileService.Verify();
}
public void CreatePackageRefreshesNuGetExeIfCommandLinePackageIsUploaded()
{
// Arrange
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("NuGet.CommandLine");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var controller = new TestableApiController();
var apiKey = Guid.NewGuid();
controller.MockPackageService.Setup(p => p.CreatePackage(nuGetPackage.Object, It.IsAny <User>(), true))
.Returns(new Package {
IsLatestStable = true
});
controller.MockNuGetExeDownloaderService.Setup(s => s.UpdateExecutableAsync(nuGetPackage.Object)).Verifiable();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
controller.CreatePackagePut();
// Assert
controller.MockNuGetExeDownloaderService.Verify();
}
public async Task CreatePackageWillSendPackageAddedNotice()
{
// Arrange
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var packageRegistration = new PackageRegistration();
packageRegistration.Id = "theId";
packageRegistration.Owners.Add(user);
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockMessageService.Setup(p => p.SendPackageAddedNotice(package, It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Verifiable();
controller.MockPackageService.Setup(p => p.CreatePackageAsync(It.IsAny <PackageArchiveReader>(), It.IsAny <PackageStreamMetadata>(), It.IsAny <User>(), false))
.Returns(Task.FromResult(package));
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
controller.MockMessageService.Verify();
}
public async Task WritesAnAuditRecord()
{
// Arrange
var user = new User {
EmailAddress = "*****@*****.**"
};
var packageRegistration = new PackageRegistration();
packageRegistration.Id = "theId";
packageRegistration.Owners.Add(user);
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageService.Setup(p => p.CreatePackageAsync(It.IsAny <PackageArchiveReader>(), It.IsAny <PackageStreamMetadata>(), It.IsAny <User>(), false))
.Returns(Task.FromResult(package));
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
Assert.True(controller.AuditingService.WroteRecord <PackageAuditRecord>(ar =>
ar.Action == AuditedPackageAction.Create &&
ar.Id == package.PackageRegistration.Id &&
ar.Version == package.Version));
}
public async Task WillWriteAnAuditRecordIfUserIsNotPackageOwner()
{
// Arrange
var user = new User {
EmailAddress = "*****@*****.**"
};
var packageRegistration = new PackageRegistration();
packageRegistration.Id = "theId";
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny <string>()))
.Returns(packageRegistration);
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
Assert.True(controller.AuditingService.WroteRecord <FailedAuthenticatedOperationAuditRecord>(ar =>
ar.Action == AuditedAuthenticatedOperationAction.PackagePushAttemptByNonOwner &&
ar.AttemptedPackage.Id == package.PackageRegistration.Id &&
ar.AttemptedPackage.Version == package.Version));
}
public async Task CreatePackageWillReturn400IfPackageIsInvalid()
{
// Arrange
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var packageRegistration = new PackageRegistration();
packageRegistration.Owners.Add(user);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>()))
.Returns(Task.CompletedTask).Verifiable();
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny <string>()))
.Returns(packageRegistration);
byte[] data = new byte[100];
controller.SetupPackageFromInputStream(new MemoryStream(data));
// Act
ActionResult result = await controller.CreatePackagePut();
// Assert
ResultAssert.IsStatusCode(result, HttpStatusCode.BadRequest);
}
public async Task CreatePackageWillSavePackageFileToFileStorage()
{
// Arrange
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var packageRegistration = new PackageRegistration();
packageRegistration.Owners.Add(user);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>()))
.Returns(Task.CompletedTask).Verifiable();
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny <string>()))
.Returns(packageRegistration);
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
controller.MockPackageFileService.Verify();
}
public async Task CreatePackageWillSavePackageFileToFileStorage()
{
// Arrange
var guid = Guid.NewGuid().ToString();
var fakeUser = new User();
var userService = new Mock <IUserService>();
var packageRegistration = new PackageRegistration();
packageRegistration.Owners.Add(fakeUser);
var controller = new TestableApiController();
controller.MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>())).Returns(Task.FromResult(0)).Verifiable();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny <Guid>())).Returns(fakeUser);
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny <string>())).Returns(packageRegistration);
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut(guid);
// Assert
controller.MockPackageFileService.Verify();
}
public void CreatePackageDoesNotRefreshNuGetExeIfItIsNotLatestStable()
{
// Arrange
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("NuGet.CommandLine");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("2.0.0-alpha"));
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var controller = new TestableApiController();
var apiKey = Guid.NewGuid();
controller.MockPackageService.Setup(p => p.CreatePackage(nuGetPackage.Object, It.IsAny <User>(), false))
.Returns(new Package {
IsLatest = true, IsLatestStable = false
});
controller.MockNuGetExeDownloaderService.Setup(s => s.UpdateExecutableAsync(nuGetPackage.Object)).Verifiable();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
controller.CreatePackagePut();
// Assert
controller.MockNuGetExeDownloaderService.Verify(s => s.UpdateExecutableAsync(It.IsAny <INupkg>()), Times.Never());
controller.MockEntitiesContext.VerifyCommitted();
}
public async Task CreatePackageWillSavePackageFileToFileStorage()
{
// Arrange
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var userService = new Mock <IUserService>();
var packageRegistration = new PackageRegistration();
packageRegistration.Owners.Add(user);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>())).Returns(Task.FromResult(0)).Verifiable();
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny <string>())).Returns(packageRegistration);
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
controller.MockPackageFileService.Verify();
}
public void WillCreateAPackageWithTheUserMatchingTheApiKey()
{
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var matchingUser = new User();
var controller = new TestableApiController();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny <Guid>())).Returns(matchingUser);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePut(Guid.NewGuid().ToString());
controller.MockPackageService.Verify(x => x.CreatePackage(It.IsAny <INupkg>(), matchingUser, true));
}
public void WillCurateThePackageViaApi()
{
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePost();
controller.MockAutoCuratePackage.Verify(x => x.ExecuteAsync(It.IsAny <Package>(), It.IsAny <PackageArchiveReader>(), false));
controller.MockEntitiesContext.VerifyCommitted();
}
public void WillFindTheUserThatMatchesTheApiKey()
{
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var controller = new TestableApiController();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny <Guid>())).Returns(new User());
controller.SetupPackageFromInputStream(nuGetPackage);
var apiKey = Guid.NewGuid();
controller.CreatePackagePut(apiKey.ToString());
controller.MockUserService.Verify(x => x.FindByApiKey(apiKey));
}
public void WillCreateAPackageWithTheUserMatchingTheApiKey()
{
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePut();
controller.MockPackageService.Verify(x => x.CreatePackageAsync(It.IsAny <PackageArchiveReader>(), It.IsAny <PackageStreamMetadata>(), user, false));
controller.MockEntitiesContext.VerifyCommitted();
}
public void WillCreateAPackageWithTheUserMatchingTheApiKey()
{
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var controller = new TestableApiController();
var apiKey = Guid.NewGuid();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePut();
controller.MockPackageService.Verify(x => x.CreatePackage(It.IsAny <INupkg>(), user, true));
}
public void WillCurateThePackageViaAPI()
{
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var controller = new TestableApiController();
var apiKey = Guid.NewGuid();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePost();
controller.MockAutoCuratePackage.Verify(x => x.Execute(It.IsAny <Package>(), nuGetPackage.Object, false));
controller.MockEntitiesContext.VerifyCommitted();
}
public async Task WillReturnConflictIfAPackageWithTheIdAndSameNormalizedVersionAlreadyExists()
{
var version = new SemanticVersion("1.0.042");
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(version);
var user = new User()
{
EmailAddress = "*****@*****.**"
};
var packageRegistration = new PackageRegistration
{
Packages = new List <Package> {
new Package {
Version = "01.00.42", NormalizedVersion = "1.0.42"
}
},
Owners = new List <User> {
user
}
};
var controller = new TestableApiController();
controller.SetCurrentUser(new User());
controller.MockPackageService.Setup(x => x.FindPackageRegistrationById("theId")).Returns(packageRegistration);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
var result = await controller.CreatePackagePut();
// Assert
ResultAssert.IsStatusCode(
result,
HttpStatusCode.Conflict,
String.Format(Strings.PackageExistsAndCannotBeModified, "theId", "1.0.42"));
}
public async Task WillReturnConflictIfAPackageWithTheIdAndSemanticVersionAlreadyExists()
{
var version = new SemanticVersion("1.0.42");
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(version);
var user = new User();
var packageRegistration = new PackageRegistration
{
Packages = new List <Package> {
new Package {
Version = version.ToString()
}
},
Owners = new List <User> {
user
}
};
var controller = new TestableApiController();
controller.MockPackageService.Setup(x => x.FindPackageRegistrationById(It.IsAny <string>())).Returns(packageRegistration);
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny <Guid>())).Returns(user);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
var result = await controller.CreatePackagePut(Guid.NewGuid().ToString());
// Assert
Assert.IsType <HttpStatusCodeWithBodyResult>(result);
var statusCodeResult = (HttpStatusCodeWithBodyResult)result;
Assert.Equal(409, statusCodeResult.StatusCode);
Assert.Equal(String.Format(Strings.PackageExistsAndCannotBeModified, "theId", "1.0.42"), statusCodeResult.StatusDescription);
}
public async Task WillReturnConflictIfAPackageWithTheIdExistsBelongingToAnotherUser()
{
// Arrange
var user = new User {
EmailAddress = "*****@*****.**"
};
var packageId = "theId";
var packageRegistration = new PackageRegistration();
packageRegistration.Id = packageId;
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny <string>()))
.Returns(packageRegistration);
var nuGetPackage = TestPackage.CreateTestPackageStream(packageId, "1.0.42");
controller.SetCurrentUser(new User());
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
var result = await controller.CreatePackagePut();
// Assert
ResultAssert.IsStatusCode(
result,
HttpStatusCode.Conflict,
String.Format(Strings.PackageIdNotAvailable, packageId));
}
public void CreatePackageDoesNotRefreshNuGetExeIfItIsNotLatestStable()
{
// Arrange
var nuGetPackage = new Mock <INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("NuGet.CommandLine");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("2.0.0-alpha"));
var matchingUser = new User();
var controller = new TestableApiController();
controller.MockPackageService.Setup(p => p.CreatePackage(nuGetPackage.Object, It.IsAny <User>(), true))
.Returns(new Package {
IsLatest = true, IsLatestStable = false
});
controller.MockNuGetExeDownloaderService.Setup(s => s.UpdateExecutableAsync(nuGetPackage.Object)).Verifiable();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny <Guid>())).Returns(matchingUser);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
controller.CreatePackagePut(Guid.NewGuid().ToString());
// Assert
controller.MockNuGetExeDownloaderService.Verify(s => s.UpdateExecutableAsync(It.IsAny <INupkg>()), Times.Never());
}
public void WillCreateAPackageFromTheNuGetPackage()
{
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var user = new User() { EmailAddress = "*****@*****.**" };
var controller = new TestableApiController();
var apiKey = Guid.NewGuid();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePut();
controller.MockPackageService.Verify(x => x.CreatePackage(nuGetPackage.Object, It.IsAny<User>(), true));
}
public async Task WillReturnConflictIfAPackageWithTheIdAndSemanticVersionAlreadyExists()
{
var version = new SemanticVersion("1.0.42");
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(version);
var user = new User();
var packageRegistration = new PackageRegistration
{
Packages = new List<Package> { new Package { Version = version.ToString() } },
Owners = new List<User> { user }
};
var controller = new TestableApiController();
controller.MockPackageService.Setup(x => x.FindPackageRegistrationById(It.IsAny<string>())).Returns(packageRegistration);
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(user);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
var result = await controller.CreatePackagePut(Guid.NewGuid().ToString());
// Assert
Assert.IsType<HttpStatusCodeWithBodyResult>(result);
var statusCodeResult = (HttpStatusCodeWithBodyResult)result;
Assert.Equal(409, statusCodeResult.StatusCode);
Assert.Equal(String.Format(Strings.PackageExistsAndCannotBeModified, "theId", "1.0.42"), statusCodeResult.StatusDescription);
}
public void WillCreateAPackageFromTheNuGetPackage()
{
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var controller = new TestableApiController();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(new User());
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePut(Guid.NewGuid().ToString());
controller.MockPackageService.Verify(x => x.CreatePackage(nuGetPackage.Object, It.IsAny<User>(), true));
}
public void CreatePackageDoesNotRefreshNuGetExeIfItIsNotLatestStable()
{
// Arrange
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("NuGet.CommandLine");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("2.0.0-alpha"));
var matchingUser = new User();
var controller = new TestableApiController();
controller.MockPackageService.Setup(p => p.CreatePackage(nuGetPackage.Object, It.IsAny<User>(), true))
.Returns(new Package { IsLatest = true, IsLatestStable = false });
controller.MockNuGetExeDownloaderService.Setup(s => s.UpdateExecutableAsync(nuGetPackage.Object)).Verifiable();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(matchingUser);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
controller.CreatePackagePut(Guid.NewGuid().ToString());
// Assert
controller.MockNuGetExeDownloaderService.Verify(s => s.UpdateExecutableAsync(It.IsAny<INupkg>()), Times.Never());
}
public async Task WillWriteAnAuditRecordIfUserIsNotPackageOwner()
{
// Arrange
var user = new User { EmailAddress = "*****@*****.**" };
var packageRegistration = new PackageRegistration();
packageRegistration.Id = "theId";
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny<string>()))
.Returns(packageRegistration);
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
Assert.True(controller.AuditingService.WroteRecord<FailedAuthenticatedOperationAuditRecord>(ar =>
ar.Action == AuditedAuthenticatedOperationAction.PackagePushAttemptByNonOwner
&& ar.AttemptedPackage.Id == package.PackageRegistration.Id
&& ar.AttemptedPackage.Version == package.Version));
}
public void CreatePackageRefreshesNuGetExeIfCommandLinePackageIsUploaded()
{
// Arrange
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("NuGet.CommandLine");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var matchingUser = new User() { EmailAddress = "*****@*****.**" };
var controller = new TestableApiController();
controller.MockPackageService.Setup(p => p.CreatePackage(nuGetPackage.Object, It.IsAny<User>(), true))
.Returns(new Package { IsLatestStable = true });
controller.MockNuGetExeDownloaderService.Setup(s => s.UpdateExecutableAsync(nuGetPackage.Object)).Verifiable();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(matchingUser);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
controller.CreatePackagePut(Guid.NewGuid().ToString());
// Assert
controller.MockNuGetExeDownloaderService.Verify();
}
public void WillCreateAPackageWithTheUserMatchingTheApiKey()
{
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var matchingUser = new User() { EmailAddress = "*****@*****.**" };
var controller = new TestableApiController();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(matchingUser);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePut(Guid.NewGuid().ToString());
controller.MockPackageService.Verify(x => x.CreatePackage(It.IsAny<INupkg>(), matchingUser, true));
}
public async Task WillUseUserFoundByAuthenticateCredentialOverFindByApiKey()
{
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var correctUser = new User();
var incorrectUser = new User();
var apiKey = Guid.NewGuid();
var controller = new TestableApiController();
controller.MockUserService
.Setup(x => x.AuthenticateCredential(
CredentialTypes.ApiKeyV1,
apiKey.ToString().ToLowerInvariant()))
.Returns(new Credential() { User = correctUser });
controller.MockUserService
.Setup(x => x.FindByApiKey(apiKey))
.Returns(incorrectUser);
controller.SetupPackageFromInputStream(nuGetPackage);
ResultAssert.IsStatusCode(
await controller.CreatePackagePut(apiKey.ToString().ToUpperInvariant()),
HttpStatusCode.Created);
controller.MockPackageService.Verify(p =>
p.CreatePackage(nuGetPackage.Object, correctUser, true));
}
public async Task WillFindUserUsingFindByApiKey()
{
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var user = new User();
var apiKey = Guid.NewGuid();
var controller = new TestableApiController();
controller.MockUserService.Setup(x => x.FindByApiKey(apiKey)).Returns(user);
controller.SetupPackageFromInputStream(nuGetPackage);
ResultAssert.IsStatusCode(
await controller.CreatePackagePut(apiKey.ToString()),
HttpStatusCode.Created);
controller.MockPackageService.Verify(p =>
p.CreatePackage(nuGetPackage.Object, user, true));
}
public void WillCurateThePackageViaAPI()
{
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var user = new User() { EmailAddress = "*****@*****.**" };
var controller = new TestableApiController();
var apiKey = Guid.NewGuid();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePost();
controller.MockAutoCuratePackage.Verify(x => x.Execute(It.IsAny<Package>(), nuGetPackage.Object, false));
controller.MockEntitiesContext.VerifyCommitted();
}
public void WillCreateAPackageWithTheUserMatchingTheApiKey()
{
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var user = new User() { EmailAddress = "*****@*****.**" };
var controller = new TestableApiController();
var apiKey = Guid.NewGuid();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePut();
controller.MockPackageService.Verify(x => x.CreatePackage(It.IsAny<INupkg>(), user, false));
controller.MockEntitiesContext.VerifyCommitted();
}
public async Task WritesAnAuditRecord()
{
// Arrange
var user = new User { EmailAddress = "*****@*****.**" };
var packageRegistration = new PackageRegistration();
packageRegistration.Id = "theId";
packageRegistration.Owners.Add(user);
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageService.Setup(p => p.CreatePackageAsync(It.IsAny<PackageArchiveReader>(), It.IsAny<PackageStreamMetadata>(), It.IsAny<User>(), false))
.Returns(Task.FromResult(package));
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
Assert.True(controller.AuditingService.WroteRecord<PackageAuditRecord>(ar =>
ar.Action == AuditedPackageAction.Create
&& ar.Id == package.PackageRegistration.Id
&& ar.Version == package.Version));
}
public async Task WillReturnConflictIfAPackageWithTheIdExistsBelongingToAnotherUser()
{
// Arrange
var user = new User { EmailAddress = "*****@*****.**" };
var packageId = "theId";
var packageRegistration = new PackageRegistration();
packageRegistration.Id = packageId;
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny<string>()))
.Returns(packageRegistration);
var nuGetPackage = TestPackage.CreateTestPackageStream(packageId, "1.0.42");
controller.SetCurrentUser(new User());
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
var result = await controller.CreatePackagePut();
// Assert
ResultAssert.IsStatusCode(
result,
HttpStatusCode.Conflict,
String.Format(Strings.PackageIdNotAvailable, packageId));
}
public void WillFindTheUserThatMatchesTheApiKey()
{
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("1.0.42"));
var controller = new TestableApiController();
controller.MockUserService.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(new User());
controller.SetupPackageFromInputStream(nuGetPackage);
var apiKey = Guid.NewGuid();
controller.CreatePackagePut(apiKey.ToString());
controller.MockUserService.Verify(x => x.FindByApiKey(apiKey));
}
public void WillCurateThePackageViaApi()
{
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
var user = new User() { EmailAddress = "*****@*****.**" };
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePost();
controller.MockAutoCuratePackage.Verify(x => x.ExecuteAsync(It.IsAny<Package>(), It.IsAny<PackageArchiveReader>(), false));
controller.MockEntitiesContext.VerifyCommitted();
}
public async Task CreatePackageWillReturn400IfPackageIsInvalid()
{
// Arrange
var user = new User() { EmailAddress = "*****@*****.**" };
var packageRegistration = new PackageRegistration();
packageRegistration.Owners.Add(user);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny<Package>(), It.IsAny<Stream>()))
.Returns(Task.CompletedTask).Verifiable();
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny<string>()))
.Returns(packageRegistration);
byte[] data = new byte[100];
controller.SetupPackageFromInputStream(new MemoryStream(data));
// Act
ActionResult result = await controller.CreatePackagePut();
// Assert
ResultAssert.IsStatusCode(result, HttpStatusCode.BadRequest);
}
public async Task WillReturnConflictIfAPackageWithTheIdAndSameNormalizedVersionAlreadyExists()
{
var version = new SemanticVersion("1.0.042");
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("theId");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(version);
var user = new User() { EmailAddress = "*****@*****.**" };
var packageRegistration = new PackageRegistration
{
Packages = new List<Package> { new Package { Version = "01.00.42", NormalizedVersion = "1.0.42" } },
Owners = new List<User> { user }
};
var controller = new TestableApiController();
controller.SetCurrentUser(new User());
controller.MockPackageService.Setup(x => x.FindPackageRegistrationById("theId")).Returns(packageRegistration);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
var result = await controller.CreatePackagePut();
// Assert
ResultAssert.IsStatusCode(
result,
HttpStatusCode.Conflict,
String.Format(Strings.PackageExistsAndCannotBeModified, "theId", "1.0.42"));
}
public void WillCreateAPackageWithTheUserMatchingTheApiKey()
{
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
var user = new User() { EmailAddress = "*****@*****.**" };
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
controller.CreatePackagePut();
controller.MockPackageService.Verify(x => x.CreatePackageAsync(It.IsAny<PackageArchiveReader>(), It.IsAny<PackageStreamMetadata>(), user, false));
controller.MockEntitiesContext.VerifyCommitted();
}
public void CreatePackageDoesNotRefreshNuGetExeIfItIsNotLatestStable()
{
// Arrange
var nuGetPackage = new Mock<INupkg>();
nuGetPackage.Setup(x => x.Metadata.Id).Returns("NuGet.CommandLine");
nuGetPackage.Setup(x => x.Metadata.Version).Returns(new SemanticVersion("2.0.0-alpha"));
var user = new User() { EmailAddress = "*****@*****.**" };
var controller = new TestableApiController();
var apiKey = Guid.NewGuid();
controller.MockPackageService.Setup(p => p.CreatePackage(nuGetPackage.Object, It.IsAny<User>(), false))
.Returns(new Package { IsLatest = true, IsLatestStable = false });
controller.MockNuGetExeDownloaderService.Setup(s => s.UpdateExecutableAsync(nuGetPackage.Object)).Verifiable();
controller.SetCurrentUser(user);
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
controller.CreatePackagePut();
// Assert
controller.MockNuGetExeDownloaderService.Verify(s => s.UpdateExecutableAsync(It.IsAny<INupkg>()), Times.Never());
controller.MockEntitiesContext.VerifyCommitted();
}
public async Task CreatePackageWillSavePackageFileToFileStorage()
{
// Arrange
var user = new User() { EmailAddress = "*****@*****.**" };
var packageRegistration = new PackageRegistration();
packageRegistration.Id = "theId";
packageRegistration.Owners.Add(user);
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny<Package>(), It.IsAny<Stream>()))
.Returns(Task.CompletedTask).Verifiable();
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny<string>()))
.Returns(packageRegistration);
controller.MockPackageService.Setup(p => p.CreatePackageAsync(It.IsAny<PackageArchiveReader>(), It.IsAny<PackageStreamMetadata>(), It.IsAny<User>(), false))
.Returns(Task.FromResult(package));
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
controller.MockPackageFileService.Verify();
}