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