private Mock <PackageService> SetupPackageService()
{
var packageRegistrationRepository = new Mock <IEntityRepository <PackageRegistration> >();
packageRegistrationRepository
.Setup(x => x.GetAll())
.Returns(PackageRegistrations.AsQueryable())
.Verifiable();
var packageRepository = new Mock <IEntityRepository <Package> >();
var certificateRepository = new Mock <IEntityRepository <Certificate> >();
var auditingService = new TestAuditingService();
var telemetryService = new Mock <ITelemetryService>();
var securityPolicyService = new Mock <ISecurityPolicyService>();
var entitiesContext = new Mock <IEntitiesContext>();
var contentObjectService = new Mock <IContentObjectService>();
var featureFlagService = new Mock <IFeatureFlagService>();
featureFlagService.Setup(x => x.ArePatternSetTfmHeuristicsEnabled()).Returns(true);
var packageService = new Mock <PackageService>(
packageRegistrationRepository.Object,
packageRepository.Object,
certificateRepository.Object,
auditingService,
telemetryService.Object,
securityPolicyService.Object,
entitiesContext.Object,
contentObjectService.Object,
featureFlagService.Object);
packageService.CallBase = true;
return(packageService);
}
public TestableUserServiceWithDBFaking(FakeEntitiesContext context = null)
{
FakeEntitiesContext = context ?? new FakeEntitiesContext();
Config = (MockConfig = new Mock <IAppConfiguration>()).Object;
UserRepository = new EntityRepository <User>(FakeEntitiesContext);
Auditing = new TestAuditingService();
}
private Mock <PackageService> SetupPackageService()
{
var packageRegistrationRepository = new Mock <IEntityRepository <PackageRegistration> >();
packageRegistrationRepository
.Setup(x => x.GetAll())
.Returns(PackageRegistrations.AsQueryable())
.Verifiable();
var packageRepository = new Mock <IEntityRepository <Package> >();
var certificateRepository = new Mock <IEntityRepository <Certificate> >();
var auditingService = new TestAuditingService();
var telemetryService = new Mock <ITelemetryService>();
var securityPolicyService = new Mock <ISecurityPolicyService>();
var packageService = new Mock <PackageService>(
packageRegistrationRepository.Object,
packageRepository.Object,
certificateRepository.Object,
auditingService,
telemetryService.Object,
securityPolicyService.Object);
packageService.CallBase = true;
return(packageService);
}
public TestableApiController(MockBehavior behavior = MockBehavior.Default)
{
OwinContext = Fakes.CreateOwinContext();
EntitiesContext = (MockEntitiesContext = new Mock <IEntitiesContext>()).Object;
PackageService = (MockPackageService = new Mock <IPackageService>(behavior)).Object;
UserService = (MockUserService = new Mock <IUserService>(behavior)).Object;
NugetExeDownloaderService = (MockNuGetExeDownloaderService = new Mock <INuGetExeDownloaderService>(MockBehavior.Strict)).Object;
ContentService = (MockContentService = new Mock <IContentService>()).Object;
StatisticsService = (MockStatisticsService = new Mock <IStatisticsService>()).Object;
IndexingService = (MockIndexingService = new Mock <IIndexingService>()).Object;
AutoCuratePackage = (MockAutoCuratePackage = new Mock <IAutomaticallyCuratePackageCommand>()).Object;
MockPackageFileService = new Mock <IPackageFileService>(MockBehavior.Strict);
MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>()))
.Returns(Task.CompletedTask);
PackageFileService = MockPackageFileService.Object;
MessageService = (MockMessageService = new Mock <IMessageService>()).Object;
MockConfigurationService = new Mock <IGalleryConfigurationService>();
MockConfigurationService.SetupGet(s => s.Features.TrackPackageDownloadCountInLocalDatabase)
.Returns(false);
ConfigurationService = MockConfigurationService.Object;
AuditingService = new TestAuditingService();
TestUtility.SetupHttpContextMockForUrlGeneration(new Mock <HttpContextBase>(), this);
}
public TestableApiController(MockBehavior behavior = MockBehavior.Default)
{
OwinContext = Fakes.CreateOwinContext();
EntitiesContext = (MockEntitiesContext = new Mock<IEntitiesContext>()).Object;
PackageService = (MockPackageService = new Mock<IPackageService>(behavior)).Object;
UserService = (MockUserService = new Mock<IUserService>(behavior)).Object;
NugetExeDownloaderService = (MockNuGetExeDownloaderService = new Mock<INuGetExeDownloaderService>(MockBehavior.Strict)).Object;
ContentService = (MockContentService = new Mock<IContentService>()).Object;
StatisticsService = (MockStatisticsService = new Mock<IStatisticsService>()).Object;
IndexingService = (MockIndexingService = new Mock<IIndexingService>()).Object;
AutoCuratePackage = (MockAutoCuratePackage = new Mock<IAutomaticallyCuratePackageCommand>()).Object;
MockPackageFileService = new Mock<IPackageFileService>(MockBehavior.Strict);
MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny<Package>(), It.IsAny<Stream>()))
.Returns(Task.CompletedTask);
PackageFileService = MockPackageFileService.Object;
MessageService = (MockMessageService = new Mock<IMessageService>()).Object;
MockConfigurationService = new Mock<ConfigurationService>();
MockConfigurationService.SetupGet(s => s.Features.TrackPackageDownloadCountInLocalDatabase)
.Returns(false);
ConfigurationService = MockConfigurationService.Object;
AuditingService = new TestAuditingService();
TestUtility.SetupHttpContextMockForUrlGeneration(new Mock<HttpContextBase>(), this);
}
private Mock <PackageService> SetupPackageService()
{
var packageRegistrationRepository = new Mock <IEntityRepository <PackageRegistration> >();
packageRegistrationRepository
.Setup(x => x.GetAll())
.Returns(PackageRegistrations.AsQueryable())
.Verifiable();
var packageRepository = new Mock <IEntityRepository <Package> >();
var packageOwnerRequestService = new Mock <IPackageOwnerRequestService>();
var packageNamingConflictValidator = new PackageNamingConflictValidator(
packageRegistrationRepository.Object,
packageRepository.Object);
var auditingService = new TestAuditingService();
var packageService = new Mock <PackageService>(
packageRegistrationRepository.Object,
packageRepository.Object,
packageOwnerRequestService.Object,
packageNamingConflictValidator,
auditingService);
packageService.CallBase = true;
return(packageService);
}
public TestableUserService()
{
Config = (MockConfig = new Mock <IAppConfiguration>()).Object;
UserRepository = (MockUserRepository = new Mock <IEntityRepository <User> >()).Object;
CredentialRepository = (MockCredentialRepository = new Mock <IEntityRepository <Credential> >()).Object;
Auditing = new TestAuditingService();
// Set ConfirmEmailAddress to a default of true
MockConfig.Setup(c => c.ConfirmEmailAddresses).Returns(true);
}
public TestableUserServiceWithDBFaking(FakeEntitiesContext context = null)
{
FakeEntitiesContext = context ?? new FakeEntitiesContext();
Config = (MockConfig = new Mock <IAppConfiguration>()).Object;
UserRepository = new EntityRepository <User>(FakeEntitiesContext);
RoleRepository = new EntityRepository <Role>(FakeEntitiesContext);
Auditing = new TestAuditingService();
TelemetryService = new TelemetryService(
new Mock <IDiagnosticsSource>().Object,
new Mock <ITelemetryClient>().Object);
}
private static Mock <PackageService> SetupPackageService(Package package)
{
var packageRegistrationRepository = new Mock <IEntityRepository <PackageRegistration> >();
var packageRepository = new Mock <IEntityRepository <Package> >();
var certificateRepository = new Mock <IEntityRepository <Certificate> >();
var auditingService = new TestAuditingService();
var telemetryService = new Mock <ITelemetryService>();
var securityPolicyService = new Mock <ISecurityPolicyService>();
var entitiesContext = new Mock <IEntitiesContext>();
var contentObjectService = new Mock <IContentObjectService>();
var featureFlagService = new Mock <IFeatureFlagService>();
featureFlagService.Setup(x => x.ArePatternSetTfmHeuristicsEnabled()).Returns(true);
var packageService = new Mock <PackageService>(
packageRegistrationRepository.Object,
packageRepository.Object,
certificateRepository.Object,
auditingService,
telemetryService.Object,
securityPolicyService.Object,
entitiesContext.Object,
contentObjectService.Object,
featureFlagService.Object);
packageService.CallBase = true;
packageService
.Setup(s => s.FindPackageByIdAndVersionStrict("test", "1.0.0"))
.Returns(package)
.Verifiable();
packageService
.Setup(s => s.EnrichPackageFromNuGetPackage(
It.IsAny <Package>(),
It.IsAny <PackageArchiveReader>(),
It.IsAny <PackageMetadata>(),
It.IsAny <PackageStreamMetadata>(),
It.IsAny <User>()))
.CallBase()
.Verifiable();
packageService
.Setup(s => s.UpdateIsLatestAsync(
It.IsAny <PackageRegistration>(),
It.IsAny <bool>()))
.Returns(Task.CompletedTask)
.Verifiable();
return(packageService);
}
public async Task SaveAuditRecordAsync_FailedAuthenticatedOperationAuditRecord()
{
var expiresIn = new TimeSpan(days: 1, hours: 2, minutes: 3, seconds: 4);
var auditRecord = new FailedAuthenticatedOperationAuditRecord(
usernameOrEmail: "a",
action: AuditedAuthenticatedOperationAction.PackagePushAttemptByNonOwner,
attemptedPackage: new AuditedPackageIdentifier("b", "c"),
attemptedCredential: new Credential(CredentialTypes.ApiKey.V2, value: "d", expiration: expiresIn));
var service = new TestAuditingService(async(string auditData, string resourceType, string filePath, string action, DateTime timestamp) =>
{
Assert.Equal("FailedAuthenticatedOperation", resourceType);
Assert.Equal("all", filePath);
Assert.Equal("packagepushattemptbynonowner", action);
Assert.InRange(timestamp, DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow.AddMinutes(1));
var jObject = JObject.Parse(auditData);
var record = jObject["Record"];
Assert.Equal("a", record["UsernameOrEmail"].Value <string>());
var attemptedPackage = record["AttemptedPackage"];
Assert.Equal("b", attemptedPackage["Id"].Value <string>());
Assert.Equal("c", attemptedPackage["Version"].Value <string>());
var attemptedCredential = record["AttemptedCredential"];
Assert.Equal(0, attemptedCredential["Key"].Value <int>());
Assert.Equal(CredentialTypes.ApiKey.V2, attemptedCredential["Type"].Value <string>());
Assert.Equal(JTokenType.Null, attemptedCredential["Value"].Type);
Assert.Equal(JTokenType.Null, attemptedCredential["Description"].Type);
Assert.False(attemptedCredential["Scopes"].ToObject <IList <object> >().Any());
Assert.Equal(JTokenType.Null, attemptedCredential["Identity"].Type);
Assert.Equal(DateTime.MinValue, attemptedCredential["Created"].Value <DateTime>());
var expiresUtc = DateTime.UtcNow.Add(expiresIn);
Assert.InRange(attemptedCredential["Expires"].Value <DateTime>(), expiresUtc.AddMinutes(-1), expiresUtc.AddMinutes(1));
Assert.Equal(JTokenType.Null, attemptedCredential["LastUsed"].Type);
await VerifyActor(jObject);
return(null);
});
await service.SaveAuditRecordAsync(auditRecord);
}
public TestableUserService()
{
Config = (MockConfig = new Mock <IAppConfiguration>()).Object;
SecurityPolicyService = (MockSecurityPolicyService = new Mock <ISecurityPolicyService>()).Object;
UserRepository = (MockUserRepository = new Mock <IEntityRepository <User> >()).Object;
CredentialRepository = (MockCredentialRepository = new Mock <IEntityRepository <Credential> >()).Object;
EntitiesContext = (MockEntitiesContext = new Mock <IEntitiesContext>()).Object;
ContentObjectService = (MockConfigObjectService = new Mock <IContentObjectService>()).Object;
Auditing = new TestAuditingService();
// Set ConfirmEmailAddress to a default of true
MockConfig.Setup(c => c.ConfirmEmailAddresses).Returns(true);
MockDatabase = new Mock <IDatabase>();
MockEntitiesContext.Setup(c => c.GetDatabase()).Returns(MockDatabase.Object);
}
private static Mock <PackageService> SetupPackageService(Package package)
{
var packageRegistrationRepository = new Mock <IEntityRepository <PackageRegistration> >();
var packageRepository = new Mock <IEntityRepository <Package> >();
var certificateRepository = new Mock <IEntityRepository <Certificate> >();
var packageNamingConflictValidator = new PackageNamingConflictValidator(
packageRegistrationRepository.Object,
packageRepository.Object);
var auditingService = new TestAuditingService();
var telemetryService = new Mock <ITelemetryService>();
var securityPolicyService = new Mock <ISecurityPolicyService>();
var packageService = new Mock <PackageService>(
packageRegistrationRepository.Object,
packageRepository.Object,
certificateRepository.Object,
packageNamingConflictValidator,
auditingService,
telemetryService.Object,
securityPolicyService.Object);
packageService.CallBase = true;
packageService
.Setup(s => s.FindPackageByIdAndVersionStrict("test", "1.0.0"))
.Returns(package)
.Verifiable();
packageService
.Setup(s => s.EnrichPackageFromNuGetPackage(
It.IsAny <Package>(),
It.IsAny <PackageArchiveReader>(),
It.IsAny <PackageMetadata>(),
It.IsAny <PackageStreamMetadata>(),
It.IsAny <User>()))
.CallBase()
.Verifiable();
packageService
.Setup(s => s.UpdateIsLatestAsync(
It.IsAny <PackageRegistration>(),
It.IsAny <bool>()))
.Returns(Task.CompletedTask)
.Verifiable();
return(packageService);
}
private static Mock <PackageService> SetupPackageService(Package package)
{
var packageRegistrationRepository = new Mock <IEntityRepository <PackageRegistration> >();
var packageRepository = new Mock <IEntityRepository <Package> >();
var packageOwnerRequestRepo = new Mock <IEntityRepository <PackageOwnerRequest> >();
var diagnosticsService = new Mock <IDiagnosticsService>();
var entitiesContext = new Mock <IEntitiesContext>();
var configuration = new Mock <IAppConfiguration>();
var indexingService = new Mock <IIndexingService>();
var packageNamingConflictValidator = new PackageNamingConflictValidator(
packageRegistrationRepository.Object,
packageRepository.Object);
var auditingService = new TestAuditingService();
var packageService = new Mock <PackageService>(
packageRegistrationRepository.Object,
packageRepository.Object,
packageOwnerRequestRepo.Object,
entitiesContext.Object,
configuration.Object,
diagnosticsService.Object,
indexingService.Object,
packageNamingConflictValidator,
auditingService);
packageService.CallBase = true;
packageService
.Setup(s => s.FindPackageByIdAndVersion("test", "1.0.0", true))
.Returns(package)
.Verifiable();
packageService
.Setup(s => s.EnrichPackageFromNuGetPackage(
It.IsAny <Package>(),
It.IsAny <PackageArchiveReader>(),
It.IsAny <PackageMetadata>(),
It.IsAny <PackageStreamMetadata>(),
It.IsAny <User>()))
.CallBase()
.Verifiable();
return(packageService);
}
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 TestableUserService()
{
Config = (MockConfig = new Mock <IAppConfiguration>()).Object;
SecurityPolicyService = (MockSecurityPolicyService = new Mock <ISecurityPolicyService>()).Object;
UserRepository = (MockUserRepository = new Mock <IEntityRepository <User> >()).Object;
RoleRepository = (MockRoleRepository = new Mock <IEntityRepository <Role> >()).Object;
CredentialRepository = (MockCredentialRepository = new Mock <IEntityRepository <Credential> >()).Object;
OrganizationRepository = (MockOrganizationRepository = new Mock <IEntityRepository <Organization> >()).Object;
EntitiesContext = (MockEntitiesContext = new Mock <IEntitiesContext>()).Object;
ContentObjectService = (MockConfigObjectService = new Mock <IContentObjectService>()).Object;
DateTimeProvider = (MockDateTimeProvider = new Mock <IDateTimeProvider>()).Object;
Auditing = new TestAuditingService();
TelemetryService = (MockTelemetryService = new Mock <ITelemetryService>()).Object;
DiagnosticsSource = (MockDiagnosticsSource = new Mock <IDiagnosticsSource>()).Object;
// Set ConfirmEmailAddress to a default of true
MockConfig.Setup(c => c.ConfirmEmailAddresses).Returns(true);
MockDatabase = new Mock <IDatabase>();
MockEntitiesContext.Setup(c => c.GetDatabase()).Returns(MockDatabase.Object);
}
public TestableReservedNamespaceService(
IList <ReservedNamespace> reservedNamespaces = null,
IList <PackageRegistration> packageRegistrations = null,
IList <User> users = null)
{
ReservedNamespaces = reservedNamespaces ?? new List <ReservedNamespace>();
PackageRegistrations = packageRegistrations ?? new List <PackageRegistration>();
Users = users ?? new List <User>();
EntitiesContext = SetupEntitiesContext().Object;
MockReservedNamespaceRepository = SetupReservedNamespaceRepository();
ReservedNamespaceRepository = MockReservedNamespaceRepository.Object;
MockPackageService = SetupPackageService();
PackageService = MockPackageService.Object;
UserService = new TestableUserServiceWithDBFaking();
((TestableUserServiceWithDBFaking)UserService).Users = Users;
AuditingService = new TestAuditingService();
}
public async Task SaveAuditRecordAsync_PackageRegistrationAuditRecord()
{
var packageRegistration = new PackageRegistration()
{
DownloadCount = 1,
Id = "a",
Key = 2
};
var auditRecord = new PackageRegistrationAuditRecord(packageRegistration, AuditedPackageRegistrationAction.AddOwner, owner: "b");
var service = new TestAuditingService(async(string auditData, string resourceType, string filePath, string action, DateTime timestamp) =>
{
Assert.Equal("PackageRegistration", resourceType);
Assert.Equal("a", filePath);
Assert.Equal("addowner", action);
Assert.InRange(timestamp, DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow.AddMinutes(1));
var jObject = JObject.Parse(auditData);
var record = jObject["Record"];
Assert.Equal("a", record["Id"].Value <string>());
var registrationRecord = record["RegistrationRecord"];
Assert.Equal("a", registrationRecord["Id"].Value <string>());
Assert.Equal(1, registrationRecord["DownloadCount"].Value <int>());
Assert.Equal(2, registrationRecord["Key"].Value <int>());
Assert.Equal("b", record["Owner"].Value <string>());
Assert.Equal("AddOwner", record["Action"].Value <string>());
await VerifyActor(jObject);
return(null);
});
await service.SaveAuditRecordAsync(auditRecord);
}
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));
}
public TestableUserService()
{
Config = (MockConfig = new Mock<IAppConfiguration>()).Object;
UserRepository = (MockUserRepository = new Mock<IEntityRepository<User>>()).Object;
CredentialRepository = (MockCredentialRepository = new Mock<IEntityRepository<Credential>>()).Object;
Auditing = new TestAuditingService();
// Set ConfirmEmailAddress to a default of true
MockConfig.Setup(c => c.ConfirmEmailAddresses).Returns(true);
}
public async Task SaveAuditRecordAsync_UserAuditRecord()
{
var user = new User()
{
CreatedUtc = DateTime.Now,
Credentials = new List <Credential>()
{
new Credential(
CredentialTypes.Password.V3,
value: "a",
expiration: new TimeSpan(days: 1, hours: 2, minutes: 3, seconds: 4))
},
EmailAddress = "b",
Roles = new List <Role>()
{
new Role()
{
Key = 5, Name = "c"
}
},
UnconfirmedEmailAddress = "d",
Username = "******"
};
var auditRecord = new UserAuditRecord(user, AuditedUserAction.Login, user.Credentials.First());
var service = new TestAuditingService(async(string auditData, string resourceType, string filePath, string action, DateTime timestamp) =>
{
Assert.Equal("User", resourceType);
Assert.Equal("e", filePath);
Assert.Equal("login", action);
Assert.InRange(timestamp, DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow.AddMinutes(1));
var jObject = JObject.Parse(auditData);
var record = jObject["Record"];
Assert.Equal("e", record["Username"].Value <string>());
Assert.Equal("b", record["EmailAddress"].Value <string>());
Assert.Equal("d", record["UnconfirmedEmailAddress"].Value <string>());
Assert.Equal("c", record["Roles"].ToObject <IList <string> >().Single());
var credentials = record["Credentials"];
var credential = credentials.AsEnumerable().Single();
Assert.Equal(0, credential["Key"].Value <int>());
Assert.Equal(CredentialTypes.Password.V3, credential["Type"].Value <string>());
Assert.Equal(JTokenType.Null, credential["Value"].Type);
Assert.Equal(JTokenType.Null, credential["Description"].Type);
Assert.False(credential["Scopes"].ToObject <IList <object> >().Any());
Assert.Equal(JTokenType.Null, credential["Identity"].Type);
Assert.Equal(DateTime.MinValue, credential["Created"].Value <DateTime>());
Assert.Equal(user.Credentials.First().Expires.Value, credential["Expires"].Value <DateTime>());
Assert.Equal(JTokenType.Null, credential["LastUsed"].Type);
var affectedCredential = record["AffectedCredential"].AsJEnumerable().Single();
Assert.Equal(0, affectedCredential["Key"].Value <int>());
Assert.Equal(CredentialTypes.Password.V3, affectedCredential["Type"].Value <string>());
Assert.Equal(JTokenType.Null, affectedCredential["Value"].Type);
Assert.Equal(JTokenType.Null, affectedCredential["Description"].Type);
Assert.Empty(affectedCredential["Scopes"].AsJEnumerable());
Assert.Equal(JTokenType.Null, affectedCredential["Identity"].Type);
Assert.Equal(DateTime.MinValue, affectedCredential["Created"].Value <DateTime>());
Assert.Equal(user.Credentials.First().Expires.Value, affectedCredential["Expires"].Value <DateTime>());
Assert.Equal(JTokenType.Null, affectedCredential["LastUsed"].Type);
Assert.Equal(JTokenType.Null, record["AffectedEmailAddress"].Type);
Assert.Equal("Login", record["Action"].Value <string>());
await VerifyActor(jObject);
return(null);
});
await service.SaveAuditRecordAsync(auditRecord);
}
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 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));
}
public async Task SaveAuditRecordAsync_PackageAuditRecord()
{
var package = new Package()
{
Copyright = "a",
Created = DateTime.Now,
#pragma warning disable CS0612 // Type or member is obsolete
Deleted = true,
#pragma warning restore CS0612 // Type or member is obsolete
Description = "b",
DownloadCount = 1,
#pragma warning disable CS0612 // Type or member is obsolete
ExternalPackageUrl = "c",
#pragma warning restore CS0612 // Type or member is obsolete
FlattenedAuthors = "d",
FlattenedDependencies = "e",
Hash = "f",
HashAlgorithm = "g",
HideLicenseReport = true,
IconUrl = "h",
IsLatest = true,
IsLatestStable = true,
IsPrerelease = true,
Key = 2,
Language = "i",
LastEdited = DateTime.Now.AddMinutes(1),
LastUpdated = DateTime.Now.AddMinutes(2),
LicenseNames = "j",
LicenseReportUrl = "k",
LicenseUrl = "l",
Listed = true,
MinClientVersion = "m",
NormalizedVersion = "n",
PackageFileSize = 3,
PackageRegistration = new PackageRegistration()
{
Id = "o"
},
PackageRegistrationKey = 4,
PackageStatusKey = PackageStatus.Deleted,
ProjectUrl = "p",
Published = DateTime.Now.AddMinutes(3),
ReleaseNotes = "q",
RequiresLicenseAcceptance = true,
DevelopmentDependency = true,
Summary = "r",
Tags = "s",
Title = "t",
UserKey = 5,
Version = "u"
};
var auditRecord = new PackageAuditRecord(package, AuditedPackageAction.Create, reason: "v");
var service = new TestAuditingService(async(string auditData, string resourceType, string filePath, string action, DateTime timestamp) =>
{
Assert.Equal("Package", resourceType);
Assert.Equal("o/u", filePath);
Assert.Equal("create", action);
Assert.InRange(timestamp, DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow.AddMinutes(1));
var jObject = JObject.Parse(auditData);
var record = jObject["Record"];
Assert.Equal("o", record["Id"].Value <string>());
Assert.Equal("u", record["Version"].Value <string>());
Assert.Equal("f", record["Hash"].Value <string>());
var packageRecord = record["PackageRecord"];
Assert.Equal(4, packageRecord["PackageRegistrationKey"].Value <int>());
Assert.Equal("a", packageRecord["Copyright"].Value <string>());
Assert.Equal(package.Created.ToUniversalTime(), packageRecord["Created"].Value <DateTime>());
Assert.Equal("b", packageRecord["Description"].Value <string>());
Assert.Equal("q", packageRecord["ReleaseNotes"].Value <string>());
Assert.Equal(1, packageRecord["DownloadCount"].Value <int>());
Assert.Equal(JTokenType.Null, packageRecord["ExternalPackageUrl"].Type);
Assert.Equal("g", packageRecord["HashAlgorithm"].Value <string>());
Assert.Equal("f", packageRecord["Hash"].Value <string>());
Assert.Equal("h", packageRecord["IconUrl"].Value <string>());
Assert.True(packageRecord["IsLatest"].Value <bool>());
Assert.True(packageRecord["IsLatestStable"].Value <bool>());
Assert.Equal(package.LastUpdated.ToUniversalTime(), packageRecord["LastUpdated"].Value <DateTime>());
Assert.Equal(package.LastEdited.Value.ToUniversalTime(), packageRecord["LastEdited"].Value <DateTime>());
Assert.Equal("l", packageRecord["LicenseUrl"].Value <string>());
Assert.True(packageRecord["HideLicenseReport"].Value <bool>());
Assert.Equal("i", packageRecord["Language"].Value <string>());
Assert.Equal(package.Published.ToUniversalTime(), packageRecord["Published"].Value <DateTime>());
Assert.Equal(3, packageRecord["PackageFileSize"].Value <int>());
Assert.Equal("p", packageRecord["ProjectUrl"].Value <string>());
Assert.True(packageRecord["RequiresLicenseAcceptance"].Value <bool>());
Assert.True(packageRecord["DevelopmentDependency"].Value <bool>());
Assert.Equal("r", packageRecord["Summary"].Value <string>());
Assert.Equal("s", packageRecord["Tags"].Value <string>());
Assert.Equal("t", packageRecord["Title"].Value <string>());
Assert.Equal("u", packageRecord["Version"].Value <string>());
Assert.Equal("n", packageRecord["NormalizedVersion"].Value <string>());
Assert.Equal("j", packageRecord["LicenseNames"].Value <string>());
Assert.Equal("k", packageRecord["LicenseReportUrl"].Value <string>());
Assert.True(packageRecord["Listed"].Value <bool>());
Assert.True(packageRecord["IsPrerelease"].Value <bool>());
Assert.Equal("d", packageRecord["FlattenedAuthors"].Value <string>());
Assert.Equal("e", packageRecord["FlattenedDependencies"].Value <string>());
Assert.Equal(2, packageRecord["Key"].Value <int>());
Assert.Equal("m", packageRecord["MinClientVersion"].Value <string>());
Assert.Equal(5, packageRecord["UserKey"].Value <int>());
Assert.True(packageRecord["Deleted"].Value <bool>());
Assert.Equal(1, packageRecord["PackageStatusKey"].Value <int>());
var registrationRecord = record["RegistrationRecord"];
Assert.Equal("o", registrationRecord["Id"].Value <string>());
Assert.Equal(0, registrationRecord["DownloadCount"].Value <int>());
Assert.Equal(0, registrationRecord["Key"].Value <int>());
Assert.Equal("v", record["Reason"].Value <string>());
Assert.Equal("Create", record["Action"].Value <string>());
await VerifyActor(jObject);
return(null);
});
await service.SaveAuditRecordAsync(auditRecord);
}
private static Mock<PackageService> SetupPackageService(Package package)
{
var packageRegistrationRepository = new Mock<IEntityRepository<PackageRegistration>>();
var packageRepository = new Mock<IEntityRepository<Package>>();
var packageOwnerRequestRepo = new Mock<IEntityRepository<PackageOwnerRequest>>();
var indexingService = new Mock<IIndexingService>();
var packageNamingConflictValidator = new PackageNamingConflictValidator(
packageRegistrationRepository.Object,
packageRepository.Object);
var auditingService = new TestAuditingService();
var packageService = new Mock<PackageService>(
packageRegistrationRepository.Object,
packageRepository.Object,
packageOwnerRequestRepo.Object,
indexingService.Object,
packageNamingConflictValidator,
auditingService);
packageService.CallBase = true;
packageService
.Setup(s => s.FindPackageByIdAndVersion("test", "1.0.0", true))
.Returns(package)
.Verifiable();
packageService
.Setup(s => s.EnrichPackageFromNuGetPackage(
It.IsAny<Package>(),
It.IsAny<PackageArchiveReader>(),
It.IsAny<PackageMetadata>(),
It.IsAny<PackageStreamMetadata>(),
It.IsAny<User>()))
.CallBase()
.Verifiable();
return packageService;
}
public TestableUserServiceWithDBFaking()
{
Config = (MockConfig = new Mock<IAppConfiguration>()).Object;
UserRepository = new EntityRepository<User>(FakeEntitiesContext = new FakeEntitiesContext());
Auditing = new TestAuditingService();
}
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));
}
