public async Task NonexistentNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.DeleteReservedNamespaceAsync("Nonexistent.Namespace."));
}
public async Task DeleteOwnerFromNamespaceSuccessfully()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefix = "microsoft.";
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(prefix, StringComparison.OrdinalIgnoreCase));
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var owner = testUsers.First();
existingNamespace.Owners.Add(owner);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, users: testUsers);
await service.DeleteOwnerFromReservedNamespaceAsync(prefix, owner.Username);
service
.MockReservedNamespaceRepository
.Verify(x => x.CommitChangesAsync());
service
.MockPackageService
.Verify(p => p.UpdatePackageVerifiedStatusAsync(
It.IsAny <IReadOnlyCollection <PackageRegistration> >(), It.IsAny <bool>()),
Times.Never);
Assert.False(existingNamespace.Owners.Contains(owner));
}
public async Task WillMarkPackageRegistrationVerifiedFlagCorrectly(bool shouldMarkIdVerified)
{
var id = "Microsoft.Aspnet.Mvc";
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefixes = new List <string> {
"microsoft.", "microsoft.aspnet."
};
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var firstUser = testUsers.First();
var matchingNamepsaces = testNamespaces
.Where(rn => prefixes.Any(pr => id.StartsWith(pr, StringComparison.OrdinalIgnoreCase)))
.ToList();
prefixes.ForEach(p => {
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(p, StringComparison.OrdinalIgnoreCase));
existingNamespace.Owners.Add(firstUser);
});
var reservedNamespaceService = new Mock <IReservedNamespaceService>();
IReadOnlyCollection <ReservedNamespace> userOwnedMatchingNamespaces = matchingNamepsaces;
reservedNamespaceService.Setup(s => s.IsPushAllowed(It.IsAny <string>(), It.IsAny <User>(), out userOwnedMatchingNamespaces))
.Returns(shouldMarkIdVerified);
var packageUploadService = CreateService(reservedNamespaceService: reservedNamespaceService);
var nugetPackage = PackageServiceUtility.CreateNuGetPackage(id: id);
var package = await packageUploadService.GeneratePackageAsync(id, nugetPackage.Object, new PackageStreamMetadata(), firstUser);
Assert.Equal(shouldMarkIdVerified, package.PackageRegistration.IsVerified);
}
public async Task WillMarkPackageRegistrationNotVerifiedIfIdMatchesNonOwnedSharedNamespace()
{
var id = "Microsoft.Aspnet.Mvc";
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefixes = new List <string> {
"microsoft.", "microsoft.aspnet."
};
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var firstUser = testUsers.First();
var lastUser = testUsers.Last();
prefixes.ForEach(p => {
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(p, StringComparison.OrdinalIgnoreCase));
existingNamespace.IsSharedNamespace = true;
existingNamespace.Owners.Add(firstUser);
});
var reservedNamespaceService = new Mock <IReservedNamespaceService>();
IReadOnlyCollection <ReservedNamespace> userOwnedMatchingNamespaces = new List <ReservedNamespace>();
reservedNamespaceService.Setup(s => s.IsPushAllowed(It.IsAny <string>(), It.IsAny <User>(), out userOwnedMatchingNamespaces))
.Returns(true);
var packageUploadService = CreateService(reservedNamespaceService: reservedNamespaceService);
var nugetPackage = PackageServiceUtility.CreateNuGetPackage(id: id);
var package = await packageUploadService.GeneratePackageAsync(id, nugetPackage.Object, new PackageStreamMetadata(), lastUser);
Assert.False(package.PackageRegistration.IsVerified);
}
public async Task ExistingNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var newNamespace = testNamespaces.FirstOrDefault();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.AddReservedNamespaceAsync(newNamespace));
}
public async Task DeletingInvalidOwnerFromNamespaceThrowsException(string username)
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = testNamespaces.First();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces);
await Assert.ThrowsAsync <ArgumentException>(async() => await service.DeleteOwnerFromReservedNamespaceAsync(existingNamespace.Value, username));
}
public async Task NonExistentNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var existingUser = testUsers.First();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, users: testUsers);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.DeleteOwnerFromReservedNamespaceAsync("Non.Existent.Namespace.", existingUser.Username));
}
public async Task DeletingNonExistentUserFromNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = testNamespaces.First();
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, users: testUsers);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.DeleteOwnerFromReservedNamespaceAsync(existingNamespace.Value, "NonExistentUser"));
}
public async Task NonExistentNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var testPackageRegistrations = ReservedNamespaceServiceTestData.GetRegistrations();
var existingReg = testPackageRegistrations.First();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, packageRegistrations: testPackageRegistrations);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.AddPackageRegistrationToNamespaceAsync("Non.Existent.Namespace.", existingReg));
}
public async Task LiberalNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
// test case has a namespace with "Microsoft." as the value.
var newNamespace = new ReservedNamespace("Micro", isSharedNamespace: false, isPrefix: true);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.AddReservedNamespaceAsync(newNamespace));
}
public void NonExistentNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var testPackageRegistrations = ReservedNamespaceServiceTestData.GetRegistrations();
var existingReg = testPackageRegistrations.First();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, packageRegistrations: testPackageRegistrations);
Assert.Throws <InvalidOperationException>(() => service.RemovePackageRegistrationFromNamespace("Non.Existent.Namespace.", existingReg));
}
public async Task ExistingNamespaceWithDifferentPrefixStateThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var newNamespace = testNamespaces.FirstOrDefault(x => x.Value == "jquery");
newNamespace.IsPrefix = !newNamespace.IsPrefix;
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.AddReservedNamespaceAsync(newNamespace));
}
public async Task AddingOwnerToAbsoluteNamespaceMarksOnlyAbsoluteRegistrationsVerified()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = new ReservedNamespace("Microsoft", isSharedNamespace: false, isPrefix: false);
testNamespaces.Add(existingNamespace);
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var owner1 = testUsers.First(u => u.Username == "test1");
var registrations = ReservedNamespaceServiceTestData.GetRegistrations();
var pr1 = registrations.ToList().FirstOrDefault(pr => (pr.Id == "Microsoft.Package1"));
var pr2 = registrations.ToList().FirstOrDefault(pr => (pr.Id == "Microsoft.Package2"));
var pr3 = registrations.ToList().FirstOrDefault(pr => (pr.Id == "Microsoft.AspNet.Package2"));
var pr4 = new PackageRegistration {
Id = "Microsoft", IsVerified = false
};
registrations.Add(pr4);
pr1.Owners.Add(owner1);
pr2.Owners.Add(owner1);
pr3.Owners.Add(owner1);
pr4.Owners.Add(owner1);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, users: testUsers, packageRegistrations: registrations);
Assert.True(existingNamespace.PackageRegistrations.Count() == 0);
await service.AddOwnerToReservedNamespaceAsync(existingNamespace.Value, owner1.Username);
service
.MockReservedNamespaceRepository
.Verify(x => x.CommitChangesAsync());
service
.MockPackageService
.Verify(p => p.UpdatePackageVerifiedStatusAsync(
It.IsAny <IReadOnlyCollection <PackageRegistration> >(), It.IsAny <bool>()),
Times.Once);
Assert.True(existingNamespace.Owners.Contains(owner1));
// Only Microsoft.Package1 should match the namespace
Assert.True(existingNamespace.PackageRegistrations.Count() == 1);
existingNamespace
.PackageRegistrations
.ToList()
.ForEach(pr =>
{
Assert.True(pr.IsVerified);
Assert.True(pr.Id == pr4.Id);
});
Assert.False(pr1.IsVerified);
Assert.False(pr3.IsVerified);
Assert.False(pr2.IsVerified);
}
public void PackageRegistrationIsAddedSuccessfully()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = testNamespaces.First();
var testPackageRegistrations = ReservedNamespaceServiceTestData.GetRegistrations();
var existingReg = testPackageRegistrations.First();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, packageRegistrations: testPackageRegistrations);
service.AddPackageRegistrationToNamespace(existingNamespace.Value, existingReg);
Assert.True(existingNamespace.PackageRegistrations.Contains(existingReg));
}
public async Task AddingExistingOwnerToTheNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefix = "microsoft.";
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(prefix, StringComparison.OrdinalIgnoreCase));
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var owner = testUsers.First();
existingNamespace.Owners.Add(owner);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, users: testUsers);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.AddOwnerToReservedNamespaceAsync(existingNamespace.Value, owner.Username));
}
public async Task DeletingNonOwnerFromNamespaceThrowsException()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefix = "microsoft.";
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(prefix, StringComparison.OrdinalIgnoreCase));
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var user1 = testUsers.First(u => u.Username == "test1");
var user2 = testUsers.First(u => u.Username == "test2");
existingNamespace.Owners.Add(user1);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, users: testUsers);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await service.DeleteOwnerFromReservedNamespaceAsync(prefix, user2.Username));
}
public void PackageRegistrationIsRemovedFromNamespaceSuccessfully()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = testNamespaces.First();
var testPackageRegistrations = ReservedNamespaceServiceTestData.GetRegistrations();
var existingReg = testPackageRegistrations.First();
existingNamespace.PackageRegistrations.Add(existingReg);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, packageRegistrations: testPackageRegistrations);
service.RemovePackageRegistrationFromNamespace(existingNamespace.Value, existingReg);
Assert.False(existingNamespace.PackageRegistrations.Contains(existingReg));
}
public void CommitChangesIsNotExecuted()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = testNamespaces.First();
var testPackageRegistrations = ReservedNamespaceServiceTestData.GetRegistrations();
var existingReg = testPackageRegistrations.First();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, packageRegistrations: testPackageRegistrations);
service.AddPackageRegistrationToNamespace(existingNamespace.Value, existingReg);
service
.MockReservedNamespaceRepository
.Verify(x => x.CommitChangesAsync(), Times.Never);
}
public async void RemoveNamespaceSuccesfullyDeletesNamespace(string value)
{
// Arrange.
var namespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = namespaces.Where(rn => rn.Value.Equals(value, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
var reservedNamespaceService = new TestableReservedNamespaceService(reservedNamespaces: namespaces);
var controller = new ReservedNamespaceController(reservedNamespaceService);
// Act & Assert.
JsonResult result = await controller.RemoveNamespace(existingNamespace);
dynamic data = result.Data;
Assert.True(data.success);
}
public async void AddNamespaceSuccessfullyAddsNewNamespaces(string value, bool isSharedNamespace, bool isPrefix)
{
// Arrange.
var namespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var newNamespace = new ReservedNamespace(value, isSharedNamespace, isPrefix);
var reservedNamespaceService = new TestableReservedNamespaceService(reservedNamespaces: namespaces);
var controller = new ReservedNamespaceController(reservedNamespaceService);
// Act & Assert.
JsonResult result = await controller.AddNamespace(newNamespace);
dynamic data = result.Data;
Assert.True(data.success);
}
public async Task PackageRegistrationIsAddedWithCommitSuccessfully()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = testNamespaces.First();
var testPackageRegistrations = ReservedNamespaceServiceTestData.GetRegistrations();
var existingReg = testPackageRegistrations.First();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, packageRegistrations: testPackageRegistrations);
await service.AddPackageRegistrationToNamespaceAsync(existingNamespace.Value, existingReg, commitChanges : true);
service
.MockReservedNamespaceRepository
.Verify(x => x.CommitChangesAsync());
Assert.True(existingNamespace.PackageRegistrations.Contains(existingReg));
}
public async Task CommitChangesIsNotExecuted()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var existingNamespace = testNamespaces.First();
var testPackageRegistrations = ReservedNamespaceServiceTestData.GetRegistrations();
var existingReg = testPackageRegistrations.First();
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, packageRegistrations: testPackageRegistrations);
await service.AddPackageRegistrationToNamespaceAsync(existingNamespace.Value, existingReg, commitChanges : false);
service
.MockReservedNamespaceRepository
.Verify(x => x.CommitChangesAsync(), Times.Never);
Assert.True(existingNamespace.PackageRegistrations.Contains(existingReg));
}
public async void AddNamespaceDoesNotReturnSuccessForInvalidNamespaces()
{
// Arrange.
var namespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var newNamespace = namespaces.First();
var reservedNamespaceService = new TestableReservedNamespaceService(reservedNamespaces: namespaces);
var controller = new ReservedNamespaceController(reservedNamespaceService);
// Act & Assert.
JsonResult result = await controller.AddNamespace(newNamespace);
dynamic data = result.Data;
Assert.False(data.success);
}
public async void AddOwnerSuccessfullyAddsOwnerToReservedNamespace(string value, string username)
{
// Arrange.
var namespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var allUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var existingNamespace = namespaces.Where(rn => rn.Value.Equals(value, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
var reservedNamespaceService = new TestableReservedNamespaceService(reservedNamespaces: namespaces, users: allUsers);
var controller = new ReservedNamespaceController(reservedNamespaceService);
// Act & Assert.
JsonResult result = await controller.AddOwner(existingNamespace, username);
dynamic data = result.Data;
Assert.True(data.success);
}
public async void RemoveNamespaceDoesNotReturnSuccessForInvalidNamespaces(string value)
{
// Arrange.
var namespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var invalidNamespace = new ReservedNamespace();
invalidNamespace.Value = value;
var reservedNamespaceService = new TestableReservedNamespaceService(reservedNamespaces: namespaces);
var controller = new ReservedNamespaceController(reservedNamespaceService);
// Act & Assert.
JsonResult result = await controller.RemoveNamespace(invalidNamespace);
dynamic data = result.Data;
Assert.False(data.success);
}
public void OwnedNamespacesAllowsPush(string id)
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefix = "microsoft.";
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(prefix, StringComparison.OrdinalIgnoreCase));
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var firstUser = testUsers.First();
existingNamespace.Owners.Add(firstUser);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, users: testUsers);
var isPushAllowed = service.IsPushAllowed(id, firstUser, out IReadOnlyCollection <ReservedNamespace> matchingNamespaces);
Assert.True(isPushAllowed);
Assert.NotEmpty(matchingNamespaces);
Assert.True(matchingNamespaces.Count() == 1);
}
public async Task DeletingOwnerFromNamespaceMarksRegistrationsUnverified()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefix = "microsoft.";
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(prefix, StringComparison.OrdinalIgnoreCase));
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var owner1 = testUsers.First(u => u.Username == "test1");
var owner2 = testUsers.First(u => u.Username == "test2");
var registrations = ReservedNamespaceServiceTestData.GetRegistrations();
var pr1 = registrations.ToList().FirstOrDefault(pr => (pr.Id == "Microsoft.Package1"));
var pr2 = registrations.ToList().FirstOrDefault(pr => (pr.Id == "Microsoft.Package2"));
var pr3 = registrations.ToList().FirstOrDefault(pr => (pr.Id == "Microsoft.AspNet.Package2"));
pr1.Owners.Add(owner1);
pr2.Owners.Add(owner1);
pr3.Owners.Add(owner2);
pr1.IsVerified = true;
pr2.IsVerified = true;
pr3.IsVerified = true;
existingNamespace.Owners.Add(owner1);
existingNamespace.PackageRegistrations.Add(pr1);
existingNamespace.PackageRegistrations.Add(pr2);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces, users: testUsers, packageRegistrations: registrations);
Assert.True(existingNamespace.PackageRegistrations.Count == 2);
await service.DeleteOwnerFromReservedNamespaceAsync(prefix, owner1.Username);
service
.MockReservedNamespaceRepository
.Verify(x => x.CommitChangesAsync());
service
.MockPackageService
.Verify(p => p.UpdatePackageVerifiedStatusAsync(
It.IsAny <IReadOnlyCollection <PackageRegistration> >(), It.IsAny <bool>()),
Times.Once);
Assert.False(existingNamespace.Owners.Contains(owner1));
Assert.True(existingNamespace.PackageRegistrations.Count == 0);
Assert.False(pr1.IsVerified);
Assert.False(pr2.IsVerified);
Assert.True(pr3.IsVerified);
}
public async Task LiberalNamespaceForExactMatchIsAllowed()
{
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
// test case has a namespace with "Microsoft." as the value.
var newNamespace = new ReservedNamespace("Micro", isSharedNamespace: false, isPrefix: false /*exact match*/);
var service = new TestableReservedNamespaceService(reservedNamespaces: testNamespaces);
await service.AddReservedNamespaceAsync(newNamespace);
service.MockReservedNamespaceRepository.Verify(
x => x.InsertOnCommit(
It.Is <ReservedNamespace>(
rn => rn.Value == newNamespace.Value &&
rn.IsPrefix == newNamespace.IsPrefix &&
rn.IsSharedNamespace == newNamespace.IsSharedNamespace)));
service.MockReservedNamespaceRepository.Verify(x => x.CommitChangesAsync());
}
public async void RemoveOwnerDoesNotReturnSuccessForInvalidData(string value, string username)
{
// Arrange.
var namespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var allUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var existingNamespace = namespaces.Where(rn => rn.Value.Equals(value, StringComparison.OrdinalIgnoreCase)).FirstOrDefault() ?? new ReservedNamespace();
existingNamespace.Value = value;
var reservedNamespaceService = new TestableReservedNamespaceService(reservedNamespaces: namespaces, users: allUsers);
var controller = new ReservedNamespaceController(reservedNamespaceService);
// Act & Assert.
JsonResult result = await controller.RemoveOwner(existingNamespace, username);
dynamic data = result.Data;
Assert.False(data.success);
}
public void SearchFindsMatchingPrefixes(string query, int foundCount, int notFoundCount)
{
// Arrange.
var namespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var reservedNamespaceService = new TestableReservedNamespaceService(reservedNamespaces: namespaces);
var controller = new ReservedNamespaceController(reservedNamespaceService);
// Act.
JsonResult jsonResult = controller.SearchPrefix(query);
// Assert
dynamic data = jsonResult.Data;
var resultModelList = data.Prefixes as IEnumerable <ReservedNamespaceResultModel>;
var found = resultModelList.Where(r => r.isExisting);
var notFound = resultModelList.Where(r => !r.isExisting);
Assert.Equal(foundCount, found.Count());
Assert.Equal(notFoundCount, notFound.Count());
}