public ReservedNamespaceAuditRecord(ReservedNamespace reservedNamespace, AuditedReservedNamespaceAction action, string username, IEnumerable <PackageRegistration> registrations) : base(action) { if (reservedNamespace == null) { throw new ArgumentNullException(nameof(reservedNamespace)); } Value = reservedNamespace.Value; AffectedReservedNamespace = AuditedReservedNamespace.CreateFrom(reservedNamespace); Action = action; if (!string.IsNullOrWhiteSpace(username)) { AffectedOwner = username; if (registrations != null && registrations.Any()) { var registrationAction = GetPackageRegistrationAction(action); AffectedRegistrations = registrations .Select(pr => new PackageRegistrationAuditRecord(pr, registrationAction, username)) .ToArray(); } } }
private static void AppendReservedNamespace(string completedListPath, ReservedNamespace reservedNamespace) { using (var fileStream = new FileStream(completedListPath, FileMode.Append, FileAccess.Write)) using (var writer = new StreamWriter(fileStream)) { writer.WriteLine($"{reservedNamespace.Value}{(reservedNamespace.IsPrefix ? "*" : string.Empty)}"); } }
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 static AuditedReservedNamespace CreateFrom(ReservedNamespace reservedNamespace) { return(new AuditedReservedNamespace { Value = reservedNamespace.Value, IsSharedNamespace = reservedNamespace.IsSharedNamespace, IsPrefix = reservedNamespace.IsPrefix, }); }
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 ReservedNamespaceResultModel(ReservedNamespace reservedNamespace, bool isExisting) { if (reservedNamespace == null) { throw new ArgumentNullException(nameof(reservedNamespace)); } prefix = new ReservedNamespace(reservedNamespace.Value, isSharedNamespace: reservedNamespace.IsSharedNamespace, isPrefix: reservedNamespace.IsPrefix); registrations = reservedNamespace.PackageRegistrations?.Select(pr => pr.Id).ToArray(); owners = reservedNamespace.Owners?.Select(u => u.Username).ToArray(); this.isExisting = isExisting; }
public async Task <JsonResult> AddOwner(ReservedNamespace prefix, string owner) { try { await _reservedNamespaceService.AddOwnerToReservedNamespaceAsync(prefix.Value, owner); return(Json(new { success = true, message = string.Format(Strings.ReservedNamespace_OwnerAdded, owner, prefix.Value) })); } catch (Exception ex) when(ex is InvalidOperationException || ex is ArgumentException) { return(Json(new { success = false, message = ex.Message })); } }
public async Task <JsonResult> RemoveNamespace(ReservedNamespace existingNamespace) { try { await _reservedNamespaceService.DeleteReservedNamespaceAsync(existingNamespace.Value); return(Json(new { success = true, message = string.Format(Strings.ReservedNamespace_PrefixRemoved, existingNamespace.Value) })); } catch (Exception ex) when(ex is InvalidOperationException || ex is ArgumentException) { return(Json(new { success = false, message = ex.Message })); } }
public async Task <JsonResult> AddNamespace(ReservedNamespace newNamespace) { try { await _reservedNamespaceService.AddReservedNamespaceAsync(newNamespace); return(Json(new { success = true, message = string.Format(Strings.ReservedNamespace_PrefixAdded, newNamespace.Value) })); } catch (InvalidOperationException ex) { return(Json(new { success = false, message = ex.Message })); } }
public async Task <JsonResult> RemoveOwner(ReservedNamespace prefix, string owner) { try { await _reservedNamespaceService.DeleteOwnerFromReservedNamespaceAsync(prefix.Value, owner, commitAsTransaction : true); return(Json(new { success = true, message = string.Format(Strings.ReservedNamespace_OwnerRemoved, owner, prefix.Value) })); } catch (Exception ex) when(ex is InvalidOperationException || ex is ArgumentException) { return(Json(new { success = false, message = ex.Message })); } }
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 NewNamespaceIsReservedCorrectly(string value, bool isShared, bool isPrefix) { var newNamespace = new ReservedNamespace(value, isSharedNamespace: isShared, isPrefix: isPrefix); var service = new TestableReservedNamespaceService(); 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 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 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 void InvalidActionsThrowException(AuditedReservedNamespaceAction action) { var prefix = new ReservedNamespace("microsoft.", isSharedNamespace: false, isPrefix: true); var registrationsList = new List <PackageRegistration> { new PackageRegistration { Id = "Microsoft.Package1" }, new PackageRegistration { Id = "Microsoft.AspNet.Package2" }, new PackageRegistration { Id = "Microsoft.Package2" } }; var owner = new User("microsoft"); // Act Assert.Throws <ArgumentException>(() => new ReservedNamespaceAuditRecord(prefix, action, owner.Username, registrations: registrationsList)); }
public async Task RestrictiveNamespaceUnderPrivateNamespacesIsMarkedAsAppropriate(bool isSharedNamespace) { var namespaces = new List <ReservedNamespace> { new ReservedNamespace("xunit.", isSharedNamespace: false, isPrefix: true), new ReservedNamespace("xunit.extentions.", isSharedNamespace: false, isPrefix: true), }; var newNamespace = new ReservedNamespace("xunit.extentions.someuser.", isSharedNamespace, isPrefix: true); var service = new TestableReservedNamespaceService(reservedNamespaces: namespaces); await service.AddReservedNamespaceAsync(newNamespace); service.MockReservedNamespaceRepository.Verify( x => x.InsertOnCommit( It.Is <ReservedNamespace>( rn => rn.Value == newNamespace.Value && rn.IsPrefix == newNamespace.IsPrefix && rn.IsSharedNamespace == isSharedNamespace))); service.MockReservedNamespaceRepository.Verify(x => x.CommitChangesAsync()); }
public void Constructor_SetsProperties() { // Arrange var prefix = new ReservedNamespace("microsoft.", isSharedNamespace: false, isPrefix: true); var registrationsList = new List <PackageRegistration> { new PackageRegistration { Id = "Microsoft.Package1" }, new PackageRegistration { Id = "Microsoft.AspNet.Package2" }, new PackageRegistration { Id = "Microsoft.Package2" } }; var owner = new User("microsoft"); // Act var record = new ReservedNamespaceAuditRecord(prefix, AuditedReservedNamespaceAction.AddOwner, owner.Username, registrations: registrationsList); // Assert Assert.Equal(prefix.Value, record.Value); Assert.NotNull(record.AffectedReservedNamespace); Assert.NotNull(record.AffectedRegistrations); Assert.NotNull(record.AffectedOwner); Assert.Equal(prefix.Value, record.AffectedReservedNamespace.Value); Assert.Equal(prefix.IsSharedNamespace, record.AffectedReservedNamespace.IsSharedNamespace); Assert.Equal(prefix.IsPrefix, record.AffectedReservedNamespace.IsPrefix); Assert.Equal(AuditedReservedNamespaceAction.AddOwner, record.Action); Assert.Equal(registrationsList.Count, record.AffectedRegistrations.Length); Assert.Equal(owner.Username, record.AffectedOwner); }
public async Task EmptyOrNullNamespaceThrowsException(string value) { var service = new TestableReservedNamespaceService(); var addNamespace = new ReservedNamespace(value, isSharedNamespace: false, isPrefix: true); await Assert.ThrowsAsync <ArgumentException>(async() => await service.AddReservedNamespaceAsync(addNamespace)); }
private static List <ReservedNamespace> ReadReservedNamespaces(string path) { var uniqueReservedNamespaces = new HashSet <ReservedNamespace>(new ReservedNamespaceComparer()); var output = new List <ReservedNamespace>(); int lineNumber = 0; string line; using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read)) using (var reader = new StreamReader(fileStream)) { while ((line = reader.ReadLine()) != null) { lineNumber++; if (string.IsNullOrWhiteSpace(line)) { continue; } var value = line.Trim(); var isPrefix = false; if (line.EndsWith("*")) { value = value.Substring(0, value.Length - 1); isPrefix = true; } // Ensure the reserved namespace is actually a valid package ID. var validatedPrefix = value; if (isPrefix) { // Prefix reserved namespaces can end with '-' and '.'. Package IDs cannot. if (value.EndsWith("-") || value.EndsWith(".")) { validatedPrefix = validatedPrefix.Substring(0, validatedPrefix.Length - 1); } } if (!PackageIdValidator.IsValidPackageId(validatedPrefix)) { Console.WriteLine($"Line {lineNumber}: Ignoring invalid reserved namespace (validated: '{validatedPrefix}', original: '{line}')."); continue; } var reservedNamespace = new ReservedNamespace { Value = value, IsPrefix = isPrefix, IsSharedNamespace = false, }; if (!uniqueReservedNamespaces.Add(reservedNamespace)) { Console.WriteLine($"Line {lineNumber}: Ignoring duplicate reserved namespace."); continue; } output.Add(reservedNamespace); } } return(output); }
public ReservedNamespaceAuditRecord(ReservedNamespace reservedNamespace, AuditedReservedNamespaceAction action) : this(reservedNamespace, action, username : null, registrations : null) { }