public async Task WritesAnAuditRecord()
            {
                // Arrange
                var package = new PackageRegistration {
                    Key = 2, Id = "pkg42"
                };
                var pendingOwner = new User {
                    Key = 100, Username = "******"
                };
                var auditingService = new TestAuditingService();
                var service         = CreateService(auditingService: auditingService);

                // Act
                await service.AddPackageOwnerAsync(package, pendingOwner);

                // Assert
                Assert.True(auditingService.WroteRecord <PackageRegistrationAuditRecord>(ar =>
                                                                                         ar.Action == AuditedPackageRegistrationAction.AddOwner &&
                                                                                         ar.Id == package.Id));
            }
            public async Task WritesAnAuditRecord()
            {
                var owner1 = new User {
                    Key = 1, Username = "******"
                };
                var ownerToRemove = new User {
                    Key = 100, Username = "******"
                };
                var package = new PackageRegistration {
                    Key = 2, Id = "pkg42", Owners = new List <User> {
                        owner1, ownerToRemove
                    }
                };
                var auditingService = new TestAuditingService();
                var service         = CreateService(auditingService: auditingService);

                // Act
                await service.RemovePackageOwnerAsync(package, owner1, ownerToRemove);

                // Assert
                Assert.True(auditingService.WroteRecord <PackageRegistrationAuditRecord>(ar =>
                                                                                         ar.Action == AuditedPackageRegistrationAction.RemoveOwner &&
                                                                                         ar.Id == package.Id));
            }
Ejemplo n.º 3
0
            public async Task WritesAnAuditRecord()
            {
                // Arrange
                var packageRegistration = new PackageRegistration { Id = "theId" };
                var package = new Package { Version = "1.0", PackageRegistration = packageRegistration, Listed = true };
                var packageRepository = new Mock<IEntityRepository<Package>>();
                var auditingService = new TestAuditingService();
                var service = CreateService(
                    packageRepository: packageRepository,
                    auditingService: auditingService);

                // Act
                await service.MarkPackageUnlistedAsync(package);

                // Assert
                Assert.True(auditingService.WroteRecord<PackageAuditRecord>(ar =>
                    ar.Action == AuditedPackageAction.Unlist
                    && ar.Id == package.PackageRegistration.Id
                    && ar.Version == package.Version));
            }
Ejemplo n.º 4
0
            public async Task WritesAnAuditRecord()
            {
                // Arrange
                var package = new PackageRegistration { Key = 2, Id = "pkg42" };
                var ownerToRemove = new User { Key = 100, Username = "******" };
                var packageRepository = new Mock<IEntityRepository<Package>>();
                var auditingService = new TestAuditingService();
                var service = CreateService(
                    packageRepository: packageRepository,
                    auditingService: auditingService);

                // Act
                await service.RemovePackageOwnerAsync(package, ownerToRemove);

                // Assert
                Assert.True(auditingService.WroteRecord<PackageRegistrationAuditRecord>(ar =>
                    ar.Action == AuditedPackageRegistrationAction.RemoveOwner
                    && ar.Id == package.Id));
            }
            public async Task WritesAnAuditRecord()
            {
                // Arrange
                var fakeUploadFileService = new Mock<IUploadFileService>();
                var fakeFileStream = new MemoryStream();
                fakeUploadFileService.Setup(x => x.GetUploadFileAsync(TestUtility.FakeUser.Key)).Returns(Task.FromResult<Stream>(fakeFileStream));
                fakeUploadFileService.Setup(x => x.DeleteUploadFileAsync(TestUtility.FakeUser.Key)).Returns(Task.FromResult(0));
                var fakePackageService = new Mock<IPackageService>();
                var fakePackage = new Package { PackageRegistration = new PackageRegistration { Id = "theId" }, Version = "theVersion" };
                fakePackageService.Setup(x => x.CreatePackageAsync(It.IsAny<PackageArchiveReader>(), It.IsAny<PackageStreamMetadata>(), It.IsAny<User>(), It.IsAny<bool>()))
                    .Returns(Task.FromResult(fakePackage));
                var fakeNuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.0");

                var auditingService = new TestAuditingService();

                var controller = CreateController(
                    packageService: fakePackageService,
                    uploadFileService: fakeUploadFileService,
                    fakeNuGetPackage: fakeNuGetPackage,
                    auditingService: auditingService);
                controller.SetCurrentUser(TestUtility.FakeUser);

                // Act
                await controller.VerifyPackage(new VerifyPackageRequest { Listed = true, Edit = null });

                // Assert
                Assert.True(auditingService.WroteRecord<PackageAuditRecord>(ar =>
                    ar.Action == AuditedPackageAction.Create 
                    && ar.Id == fakePackage.PackageRegistration.Id
                    && ar.Version == fakePackage.Version));
            }