public void DoesNotSendNoticeIfUserDoesNotAllowEmails()
{
var requestingOwner = new User {
Username = "******", EmailAddress = "*****@*****.**"
};
var newOwner = new User {
Username = "******", EmailAddress = "*****@*****.**"
};
var package = new PackageRegistration {
Id = "CoolStuff"
};
var request = new PackageOwnerRequest
{
PackageRegistration = package,
RequestingOwner = requestingOwner,
NewOwner = newOwner
};
var messageService = TestableMessageService.Create(
GetService <AuthenticationService>(),
GetConfigurationService());
messageService.SendPackageOwnerRequestCancellationNotice(requestingOwner, newOwner, package);
Assert.Empty(messageService.MockMailSender.Sent);
}
public void SendsNotice()
{
var requestingOwner = new User {
Username = "******", EmailAddress = "*****@*****.**", EmailAllowed = true
};
var newOwner = new User {
Username = "******", EmailAddress = "*****@*****.**"
};
var package = new PackageRegistration {
Id = "CoolStuff"
};
var request = new PackageOwnerRequest
{
PackageRegistration = package,
RequestingOwner = requestingOwner,
NewOwner = newOwner
};
var messageService = TestableMessageService.Create(
GetService <AuthenticationService>(),
GetConfigurationService());
messageService.SendPackageOwnerRequestRejectionNotice(requestingOwner, newOwner, package);
var message = messageService.MockMailSender.Sent.Last();
Assert.Equal(requestingOwner.EmailAddress, message.To[0].Address);
Assert.Equal(TestGalleryNoReplyAddress.Address, message.From.Address);
Assert.Equal(newOwner.EmailAddress, message.ReplyToList.Single().Address);
Assert.Equal("[Joe Shmoe] The user 'Noob' has rejected your request to add them as an owner of the package 'CoolStuff'.", message.Subject);
Assert.Contains("The user 'Noob' has rejected your request to add them as an owner of the package 'CoolStuff'.", message.Body);
}
public async Task DeletePackageOwnershipRequest(PackageOwnerRequest request, bool commitChanges = true)
{
_packageOwnerRequestRepository.DeleteOnCommit(request);
if (commitChanges)
{
await _packageOwnerRequestRepository.CommitChangesAsync();
}
}
public OwnerRequestsListItemViewModel(PackageOwnerRequest request, IPackageService packageService, User currentUser)
{
Request = request;
var package = packageService.FindPackageByIdAndVersion(request.PackageRegistration.Id, version: null, semVerLevelKey: SemVerLevelKey.SemVer2, allowPrerelease: true);
Package = new ListPackageItemViewModel(package, currentUser);
CanAccept = ActionsRequiringPermissions.HandlePackageOwnershipRequest.CheckPermissions(currentUser, Request.NewOwner) == PermissionsCheckResult.Allowed;
CanCancel = Package.CanManageOwners;
}
private OwnerRequestsListItemViewModel CreateOwnerRequestsListItemViewModel(PackageOwnerRequest request, User currentUser)
{
var package = PackageService.FindPackageByIdAndVersion(request.PackageRegistration.Id, version: null, semVerLevelKey: SemVerLevelKey.SemVer2, allowPrerelease: true);
var packageViewModel = _listPackageItemViewModelFactory.Create(package, currentUser);
return(new OwnerRequestsListItemViewModel
{
Request = request,
Package = packageViewModel,
CanAccept = ActionsRequiringPermissions.HandlePackageOwnershipRequest.CheckPermissions(currentUser, request.NewOwner) == PermissionsCheckResult.Allowed,
CanCancel = packageViewModel.CanManageOwners,
});
}
public async Task<PackageOwnerRequest> CreatePackageOwnerRequestAsync(PackageRegistration package, User currentOwner, User newOwner)
{
var existingRequest = FindExistingPackageOwnerRequest(package, newOwner);
if (existingRequest != null)
{
return existingRequest;
}
var newRequest = new PackageOwnerRequest
{
PackageRegistrationKey = package.Key,
RequestingOwnerKey = currentOwner.Key,
NewOwnerKey = newOwner.Key,
ConfirmationCode = CryptographyService.GenerateToken(),
RequestDate = DateTime.UtcNow
};
_packageOwnerRequestRepository.InsertOnCommit(newRequest);
await _packageOwnerRequestRepository.CommitChangesAsync();
return newRequest;
}
public PackageOwnerRequest CreatePackageOwnerRequest(PackageRegistration package, User currentOwner, User newOwner)
{
var existingRequest = FindExistingPackageOwnerRequest(package, newOwner);
if (existingRequest != null)
{
return(existingRequest);
}
var newRequest = new PackageOwnerRequest
{
PackageRegistrationKey = package.Key,
RequestingOwnerKey = currentOwner.Key,
NewOwnerKey = newOwner.Key,
ConfirmationCode = Crypto.GenerateToken(),
RequestDate = DateTime.UtcNow
};
_packageOwnerRequestRepository.InsertOnCommit(newRequest);
_packageOwnerRequestRepository.CommitChanges();
return(newRequest);
}
public async Task <PackageOwnerRequest> AddPackageOwnershipRequest(PackageRegistration package, User requestingOwner, User newOwner)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (requestingOwner == null)
{
throw new ArgumentNullException(nameof(requestingOwner));
}
if (newOwner == null)
{
throw new ArgumentNullException(nameof(newOwner));
}
var existingRequest = GetPackageOwnershipRequests(package: package, newOwner: newOwner).FirstOrDefault();
if (existingRequest != null)
{
return(existingRequest);
}
var newRequest = new PackageOwnerRequest
{
PackageRegistrationKey = package.Key,
RequestingOwnerKey = requestingOwner.Key,
NewOwnerKey = newOwner.Key,
ConfirmationCode = CryptographyService.GenerateToken(),
RequestDate = DateTime.UtcNow
};
_packageOwnerRequestRepository.InsertOnCommit(newRequest);
await _packageOwnerRequestRepository.CommitChangesAsync();
return(newRequest);
}
public async Task RequestIsDeletedSuccessfully()
{
var package = new PackageRegistration {
Key = 2, Id = "pkg42"
};
var user1 = new User {
Key = 101, Username = "******"
};
var packageOwnerRequestService = new Mock <IPackageOwnerRequestService>();
var pendingRequest = new PackageOwnerRequest
{
PackageRegistration = package,
NewOwner = user1,
ConfirmationCode = "token"
};
packageOwnerRequestService.Setup(x => x.GetPackageOwnershipRequests(It.IsAny <PackageRegistration>(), It.IsAny <User>(), It.IsAny <User>())).Returns(new[] { pendingRequest }).Verifiable();
packageOwnerRequestService.Setup(x => x.DeletePackageOwnershipRequest(It.IsAny <PackageOwnerRequest>(), true)).Returns(Task.CompletedTask).Verifiable();
var service = CreateService(packageOwnerRequestService: packageOwnerRequestService, useDefaultSetup: false);
await service.DeletePackageOwnershipRequestAsync(packageRegistration : package, newOwner : user1);
packageOwnerRequestService.Verify(x => x.DeletePackageOwnershipRequest(pendingRequest, true));
}
public void RemovesRelatedPendingOwnerRequest()
{
var packageOwnerRequest = new PackageOwnerRequest { PackageRegistrationKey = 2, NewOwnerKey = 100, ConfirmationCode = "secret-token" };
var package = new PackageRegistration { Key = 2, Id = "pkg42" };
var pendingOwner = new User { Key = 100, Username = "******" };
var repository = new Mock<IEntityRepository<PackageOwnerRequest>>();
repository.Setup(r => r.DeleteOnCommit(packageOwnerRequest)).Verifiable();
repository.Setup(r => r.CommitChanges()).Verifiable();
repository.Setup(r => r.GetAll()).Returns(
new[]
{
new PackageOwnerRequest { PackageRegistrationKey = 1, NewOwnerKey = 100, ConfirmationCode = "super-secret-token" },
packageOwnerRequest
}.AsQueryable());
var service = CreateService(packageOwnerRequestRepo: repository);
service.AddPackageOwner(package, pendingOwner);
repository.VerifyAll();
}
public void RemovesPendingPackageOwner()
{
var packageOwnerRequest = new PackageOwnerRequest
{
PackageRegistrationKey = 1,
RequestingOwnerKey = 99,
NewOwnerKey = 200
};
var packageOwnerRequestRepository = new Mock<IEntityRepository<PackageOwnerRequest>>();
packageOwnerRequestRepository.Setup(r => r.GetAll()).Returns(new[] { packageOwnerRequest }.AsQueryable());
packageOwnerRequestRepository.Setup(r => r.DeleteOnCommit(packageOwnerRequest)).Verifiable();
packageOwnerRequestRepository.Setup(r => r.CommitChanges()).Verifiable();
var service = CreateService(packageOwnerRequestRepo: packageOwnerRequestRepository);
var pendingOwner = new User { Key = 200 };
var owner = new User();
var package = new PackageRegistration { Key = 1, Owners = new List<User> { owner } };
service.RemovePackageOwner(package, pendingOwner);
Assert.Contains(owner, package.Owners);
packageOwnerRequestRepository.VerifyAll();
}
public PackageOwnerRequest CreatePackageOwnerRequest(PackageRegistration package, User currentOwner, User newOwner)
{
var existingRequest = FindExistingPackageOwnerRequest(package, newOwner);
if (existingRequest != null)
{
return existingRequest;
}
var newRequest = new PackageOwnerRequest
{
PackageRegistrationKey = package.Key,
RequestingOwnerKey = currentOwner.Key,
NewOwnerKey = newOwner.Key,
ConfirmationCode = Crypto.GenerateToken(),
RequestDate = DateTime.UtcNow
};
_packageOwnerRequestRepository.InsertOnCommit(newRequest);
_packageOwnerRequestRepository.CommitChanges();
return newRequest;
}
public async Task DeletePackageOwnershipRequest(PackageOwnerRequest request)
{
_packageOwnerRequestRepository.DeleteOnCommit(request);
await _packageOwnerRequestRepository.CommitChangesAsync();
}
public PackageOwnerRequest CreatePackageOwnerRequest(PackageRegistration package, User currentOwner, User newOwner)
{
var existingRequest = FindExistingPackageOwnerRequest(package, newOwner);
if (existingRequest != null) return existingRequest;
var newRequest = new PackageOwnerRequest
{
PackageRegistrationKey = package.Key,
RequestingOwnerKey = currentOwner.Key,
NewOwnerKey = newOwner.Key,
ConfirmationCode = cryptoSvc.GenerateToken(),
RequestDate = DateTime.UtcNow
};
packageOwnerRequestRepository.InsertOnCommit(newRequest);
packageOwnerRequestRepository.CommitChanges();
InvalidateCache(package);
Cache.InvalidateCacheItem(string.Format("maintainerpackages-{0}", newOwner.Username));
NotifyIndexingService(package.Packages.FirstOrDefault());
return newRequest;
}
public OwnerRequestsListItemViewModel(PackageOwnerRequest request, IPackageService packageService)
{
Request = request;
Package = packageService.FindPackageByIdAndVersion(request.PackageRegistration.Id, version: null, semVerLevelKey: SemVerLevelKey.SemVer2, allowPrerelease: true);
}
