private void ModifyRelation_GivenAnyUserWithItSystemWriteAccess_AllowsModifications(bool allowModifications) { // Arrange var fromSystemUsage = new ItSystemUsage { Id = FromSystemUsageId }; var toSystemUsage = new ItSystemUsage { Id = ToSystemUsageId }; var systemRelation = new SystemRelation(fromSystemUsage) { Id = FromSystemRelationId, ToSystemUsage = toSystemUsage }; fromSystemUsage.UsageRelations = new List <SystemRelation> { systemRelation }; _mockSystemRelationRepository.Setup(r => r.GetByKey(FromSystemRelationId)).Returns(systemRelation); _mockSystemUsageRepository.Setup(r => r.GetByKey(FromSystemUsageId)).Returns(fromSystemUsage); _mockSystemUsageRepository.Setup(r => r.GetByKey(ToSystemUsageId)).Returns(toSystemUsage); _mockAuthorizationContext.Setup(c => c.AllowModify(fromSystemUsage)).Returns(allowModifications); // Act var result = _sut.ModifyRelation(FromSystemUsageId, FromSystemRelationId, ToSystemUsageId, null, null, null, null, null); // Assert Assert.True(allowModifications ? result.Ok : result.Error.FailureType == OperationFailure.Forbidden); }
public void Cannot_RemoveSystem_If_System_Is_Not_AssignedAlready() { //Arrange var organizationId = A <int>(); var systemId = A <int>(); var itSystemUsage = new ItSystemUsage { OrganizationId = A <int>(), Id = A <int>() }; var registration = new DataProcessingRegistration { OrganizationId = organizationId, SystemUsages = { new ItSystemUsage() { Id = A <int>() } } }; _systemRepository.Setup(x => x.GetSystemUsage(systemId)).Returns(itSystemUsage); //Act var result = _sut.RemoveSystem(registration, systemId); //Assert Assert.True(result.Failed); Assert.Equal(OperationFailure.BadInput, result.Error.FailureType); Assert.NotEmpty(registration.SystemUsages); }
public void Apply_Generates_RiskSupervisionDocumentation_As_Null_If_RiskAssessment_Is_Not_Yes() { //Arrange var system = new ItSystem { Id = A<int>(), Name = A<string>() }; var systemUsage = new ItSystemUsage { Id = A<int>(), OrganizationId = A<int>(), ItSystem = system, ObjectOwner = defaultTestUser, LastChangedByUser = defaultTestUser, LastChanged = A<DateTime>(), riskAssessment = DataOptions.DONTKNOW, RiskSupervisionDocumentationUrlName = A<string>(), RiskSupervisionDocumentationUrl = A<string>(), AssociatedDataProcessingRegistrations = new List<DataProcessingRegistration>() }; var readModel = new ItSystemUsageOverviewReadModel(); //Act _sut.Apply(systemUsage, readModel); //Assert Assert.Null(readModel.RiskSupervisionDocumentationName); Assert.Null(readModel.RiskSupervisionDocumentationUrl); }
public void Apply_Generates_Read_Model_When_No_Parent_System() { //Arrange var system = new ItSystem { Id = A<int>(), Name = A<string>() }; var systemUsage = new ItSystemUsage { Id = A<int>(), OrganizationId = A<int>(), ItSystem = system, ObjectOwner = defaultTestUser, LastChangedByUser = defaultTestUser, LastChanged = A<DateTime>(), AssociatedDataProcessingRegistrations = new List<DataProcessingRegistration>() }; var readModel = new ItSystemUsageOverviewReadModel(); //Act _sut.Apply(systemUsage, readModel); //Assert Assert.Null(readModel.ParentItSystemName); Assert.Null(readModel.ParentItSystemId); }
public void UpdateKLE_Given_Summary_Updates_ItSystemUsages() { //Arrange var updateObjects = SetupUpdateObjects(); const int itSystemUsageKey = 1; var itSystemUsage = new ItSystemUsage { Id = itSystemUsageKey, TaskRefs = new List <TaskRef> { updateObjects.removedTaskRef } }; var itSystemUsages = new List <ItSystemUsage> { itSystemUsage }; _mockSystemUsageRepository .Setup(s => s.GetWithReferencePreload(t => t.TaskRefs)) .Returns(itSystemUsages.AsQueryable); //Act _sut.UpdateKLE(0); //Assert Assert.False(itSystemUsage.TaskRefs.Contains(updateObjects.removedTaskRef)); }
public void Add_Returns_Ok(bool sameOrg) { //Arrange var input = new ItSystemUsage { ItSystemId = A <int>(), OrganizationId = A <int>() }; var associatedItSystem = new ItSystem { OrganizationId = sameOrg ? input.OrganizationId : input.OrganizationId + 1, AccessModifier = AccessModifier.Public }; var usageCreatedByRepo = new ItSystemUsage(); SetupRepositoryQueryWith(Enumerable.Empty <ItSystemUsage>()); _authorizationContext.Setup(x => x.AllowCreate <ItSystemUsage>(input.OrganizationId, input)).Returns(true); _systemRepository.Setup(x => x.GetSystem(input.ItSystemId)).Returns(associatedItSystem); _authorizationContext.Setup(x => x.AllowReads(associatedItSystem)).Returns(true); _usageRepository.Setup(x => x.Create()).Returns(usageCreatedByRepo); //Act var result = _sut.Add(input); //Assert Assert.True(result.Ok); var createdUsage = result.Value; Assert.NotSame(input, createdUsage); Assert.Same(usageCreatedByRepo, createdUsage); Assert.Equal(input.OrganizationId, createdUsage.OrganizationId); Assert.Equal(input.ItSystemId, createdUsage.ItSystemId); _usageRepository.Verify(x => x.Insert(usageCreatedByRepo), Times.Once); _usageRepository.Verify(x => x.Save(), Times.Once); }
public void GetRelation_Returns_Ok() { //Arrange var id = A <int>(); var relationId = A <int>(); var systemRelation = CreateRelation(); systemRelation.Id = relationId; var itSystemUsage = new ItSystemUsage { UsageRelations = new List <SystemRelation>() { CreateRelation(), systemRelation } }; ExpectGetUsageByKeyReturns(id, itSystemUsage); ExpectAllowReadReturns(itSystemUsage, true); //Act var relation = _sut.GetRelationFrom(id, relationId); //Assert Assert.True(relation.Ok); Assert.Same(systemRelation, relation.Value); }
public void Handle_Deletes_All_UsedBy_Relations_From_Owner_Usages() { //Arrange var deletedSystemUsage = new ItSystemUsage { Id = A <int>() }; var relation1 = CreateRelation(deletedSystemUsage); var relation2 = CreateRelation(deletedSystemUsage); deletedSystemUsage.UsedByRelations.Add(relation1); deletedSystemUsage.UsedByRelations.Add(relation2); var transaction = new Mock <IDatabaseTransaction>(); _transactionManager.Setup(x => x.Begin(IsolationLevel.ReadCommitted)).Returns(transaction.Object); //Act _sut.Handle(new EntityDeletedEvent <ItSystemUsage>(deletedSystemUsage)); //Assert that model was updated and that deleted relations were marked in repository Assert.False(relation1.FromSystemUsage.UsageRelations.Contains(relation1)); Assert.False(relation2.FromSystemUsage.UsageRelations.Contains(relation2)); _systemRelationRepository.Verify(x => x.Delete(It.IsAny <SystemRelation>()), Times.Exactly(2)); _systemRelationRepository.Verify(x => x.Delete(relation1), Times.Once); _systemRelationRepository.Verify(x => x.Delete(relation2), Times.Once); _systemRelationRepository.Verify(x => x.Save(), Times.Once); _systemUsageRepository.Verify(x => x.Save(), Times.Once); transaction.Verify(x => x.Commit(), Times.Once); }
public void RemoveRelation_Returns_Ok() { //Arrange var id = A <int>(); var relationId = A <int>(); var systemRelation = CreateRelation(); systemRelation.Id = relationId; var itSystemUsage = new ItSystemUsage { UsageRelations = new List <SystemRelation> { CreateRelation(), systemRelation } }; var transaction = new Mock <IDatabaseTransaction>(); _transactionManager.Setup(x => x.Begin(IsolationLevel.ReadCommitted)).Returns(transaction.Object); ExpectGetUsageByKeyReturns(id, itSystemUsage); ExpectAllowModifyReturns(itSystemUsage, true); //Act var relation = _sut.RemoveRelation(id, relationId); //Assert Assert.True(relation.Ok); Assert.Same(systemRelation, relation.Value); _relationRepositoryMock.Verify(x => x.DeleteWithReferencePreload(systemRelation), Times.Once); _relationRepositoryMock.Verify(x => x.Save(), Times.Once); _usageRepository.Verify(x => x.Save(), Times.Once); transaction.Verify(x => x.Commit(), Times.Once); }
public void AddRelation_Returns_Ok() { //Arrange var sourceId = A <int>(); var destinationId = A <int>(); var frequencyId = A <int>(); var contractId = A <int>(); var source = new ItSystemUsage { Id = sourceId, OrganizationId = A <int>() }; ExpectGetUsageByKeyReturns(sourceId, source); ExpectGetUsageByKeyReturns(destinationId, new ItSystemUsage() { Id = sourceId + 1, OrganizationId = source.OrganizationId }); ExpectAllowModifyReturns(source, true); ExpectGetAvailableOptionsReturns(source, frequencyId, new RelationFrequencyType { Id = frequencyId }); _contractRepository.Setup(x => x.GetById(contractId)).Returns(new ItContract() { OrganizationId = source.OrganizationId }); //Act var result = _sut.AddRelation(sourceId, destinationId, null, A <string>(), A <string>(), frequencyId, contractId); //Assert Assert.True(result.Ok); _usageRepository.Verify(x => x.Save(), Times.Once); }
public void AddRelation_Returns_Error_If_Provided_Contract_Is_Not_found() { //Arrange var sourceId = A <int>(); var destinationId = A <int>(); var frequencyId = A <int>(); var contractId = A <int>(); var source = new ItSystemUsage { Id = sourceId, OrganizationId = A <int>() }; ExpectGetUsageByKeyReturns(sourceId, source); ExpectGetUsageByKeyReturns(destinationId, new ItSystemUsage() { Id = sourceId + 1, OrganizationId = source.OrganizationId }); ExpectAllowModifyReturns(source, true); ExpectGetAvailableOptionsReturns(source, frequencyId, new RelationFrequencyType { Id = frequencyId }); _contractRepository.Setup(x => x.GetById(contractId)).Returns(default(ItContract)); //Act var result = _sut.AddRelation(sourceId, destinationId, null, A <string>(), A <string>(), frequencyId, contractId); //Assert AssertAddRelationError(result, OperationFailure.BadInput, "Contract id does not point to a valid contract"); }
private ItSystemUsageOverviewReadModel Test_IsActive_Based_On_ExpirationDate(DateTime expirationDate) { var system = new ItSystem { Id = A<int>(), Name = A<string>() }; var systemUsage = new ItSystemUsage { Id = A<int>(), OrganizationId = A<int>(), ItSystem = system, Active = false, ExpirationDate = DateTime.Now.AddDays(-1), ObjectOwner = defaultTestUser, LastChangedByUser = defaultTestUser, LastChanged = A<DateTime>(), AssociatedDataProcessingRegistrations = new List<DataProcessingRegistration>() }; var readModel = new ItSystemUsageOverviewReadModel(); _sut.Apply(systemUsage, readModel); return readModel; }
public void Can_GetApplicableSystems() { //Arrange var alreadyAssignedSystem = new ItSystemUsage { Id = A <int>() }; var availableSystem = new ItSystemUsage { Id = A <int>() }; var organizationId = A <int>(); var registration = new DataProcessingRegistration { OrganizationId = organizationId, SystemUsages = { alreadyAssignedSystem } }; ExpectSystemsInUse(organizationId, availableSystem, alreadyAssignedSystem); //Act var applicableSystems = _sut.GetApplicableSystems(registration); //Assert var itSystem = Assert.Single(applicableSystems); Assert.Same(availableSystem, itSystem); }
public void Apply_Generates_HostedAt_As_UNDECIDED_If_HostedAt_Is_Null() { //Arrange var system = new ItSystem { Id = A<int>(), Name = A<string>() }; var systemUsage = new ItSystemUsage { Id = A<int>(), OrganizationId = A<int>(), ItSystem = system, ObjectOwner = defaultTestUser, LastChangedByUser = defaultTestUser, LastChanged = A<DateTime>(), AssociatedDataProcessingRegistrations = new List<DataProcessingRegistration>(), HostedAt = null }; var readModel = new ItSystemUsageOverviewReadModel(); //Act _sut.Apply(systemUsage, readModel); //Assert Assert.Equal(HostedAt.UNDECIDED, readModel.HostedAt); }
public ItSystemUsageTest() { _sut = new ItSystemUsage { Id = A <int>(), OrganizationId = A <int>() }; }
private void ExpectAllowedGetMigration(int usageId, ItSystemUsage systemUsage, ItSystem system) { ExpectAllowSystemMigrationReturns(true); ExpectGetSystemUsageReturns(usageId, systemUsage); ExpectAllowReadsReturns(systemUsage, true); ExpectGetSystemReturns(system.Id, system); ExpectAllowReadsReturns(system, true); }
private static IEnumerable <SystemRelation> GetRelationMigrations(ItSystemUsage fromSystemUsage) { return(fromSystemUsage .UsedByRelations .AsEnumerable() .Where(x => x.RelationInterfaceId != null) .ToList() .AsReadOnly()); }
private void AssertGdprExportReportExtracted(ItSystemUsage usage, GDPRExportReport gdprExportReport) { Assert.Equal(usage.ItSystem.Uuid.ToString("D"), gdprExportReport.SystemUuid); Assert.Equal(usage.ItSystem.Name, gdprExportReport.SystemName); Assert.Equal(usage.isBusinessCritical, gdprExportReport.BusinessCritical); Assert.Equal(usage.DPIA, gdprExportReport.DPIA); Assert.Equal(usage.riskAssessment, gdprExportReport.RiskAssessment); Assert.Equal(usage.preriskAssessment, gdprExportReport.PreRiskAssessment); if (!string.IsNullOrEmpty(usage.LinkToDirectoryUrl)) { Assert.True(gdprExportReport.LinkToDirectory); } else { Assert.False(gdprExportReport.LinkToDirectory); } Assert.Equal(usage.AssociatedDataProcessingRegistrations?.Any(x => x.IsAgreementConcluded == YesNoIrrelevantOption.YES) == true, gdprExportReport.DataProcessingAgreementConcluded); if (usage.SensitiveDataLevels.Any(x => x.SensitivityDataLevel == SensitiveDataLevel.NONE)) { Assert.True(gdprExportReport.NoData); } else { Assert.False(gdprExportReport.NoData); } if (usage.SensitiveDataLevels.Any(x => x.SensitivityDataLevel == SensitiveDataLevel.PERSONALDATA)) { Assert.True(gdprExportReport.PersonalData); } else { Assert.False(gdprExportReport.PersonalData); } if (usage.SensitiveDataLevels.Any(x => x.SensitivityDataLevel == SensitiveDataLevel.SENSITIVEDATA)) { Assert.True(gdprExportReport.SensitiveData); } else { Assert.False(gdprExportReport.SensitiveData); } if (usage.SensitiveDataLevels.Any(x => x.SensitivityDataLevel == SensitiveDataLevel.LEGALDATA)) { Assert.True(gdprExportReport.LegalData); } else { Assert.False(gdprExportReport.LegalData); } }
private static void DeleteAccessTypes(ItSystemUsage systemUsage) { if (systemUsage.AccessTypes?.Any() == true) { foreach (var accessType in systemUsage.AccessTypes.ToList()) { systemUsage.AccessTypes.Remove(accessType); } } }
private ItSystemUsage SetupRepositoryQueryWith(int organizationId, int systemId) { var itSystemUsage = new ItSystemUsage { OrganizationId = organizationId, ItSystemId = systemId }; _usageRepository.Setup(x => x.AsQueryable()) .Returns(new[] { itSystemUsage }.AsQueryable()); return(itSystemUsage); }
public override bool Execute(KitosContext context) { var organization = context.GetOrganization(_organizationName); var globalAdmin = context.GetGlobalAdmin(); //Create the new it system var systemWithSameName = GetItSystemnByName(context); if (systemWithSameName != null) { Console.Out.WriteLine($"Existing ITSystem with name {_name} already exists in the database."); return(false); } var itSystem = new ItSystem { Name = _name, ObjectOwnerId = globalAdmin.Id, OrganizationId = organization.Id, LastChangedByUserId = globalAdmin.Id, Uuid = Guid.NewGuid(), ParentId = _parentId }; context.ItSystems.Add(itSystem); context.SaveChanges(); //Enable usage of the system var itSystemUsage = new ItSystemUsage { ItSystemId = itSystem.Id, OrganizationId = organization.Id, ObjectOwnerId = globalAdmin.Id, LastChangedByUserId = globalAdmin.Id }; itSystemUsage.ResponsibleUsage = new ItSystemUsageOrgUnitUsage { ItSystemUsage = itSystemUsage, ItSystemUsageId = itSystemUsage.Id, OrganizationUnit = organization.OrgUnits.First(), OrganizationUnitId = organization.Id }; context.ItSystemUsages.Add(itSystemUsage); context.SaveChanges(); var pendingReadModelUpdate = PendingReadModelUpdate.Create(itSystemUsage, PendingReadModelUpdateSourceCategory.ItSystemUsage); context.PendingReadModelUpdates.Add(pendingReadModelUpdate); context.SaveChanges(); return(true); }
public void Handle_Created_Adds_New_ReadModel() { //Arrange var itSystemUsage = new ItSystemUsage(); //Act _sut.Handle(new EntityCreatedEvent <ItSystemUsage>(itSystemUsage)); //Assert _readModelUpdate.Verify(x => x.Apply(itSystemUsage, It.IsAny <ItSystemUsageOverviewReadModel>()), Times.Once); _repository.Verify(x => x.Add(It.IsAny <ItSystemUsageOverviewReadModel>()), Times.Once); }
public void Apply_Generates_ArchivePeriodEndDate_By_Earliest_StartDate_Of_Still_Valid_ArchivePeriod() { //Arrange var system = new ItSystem { Id = A<int>(), Name = A<string>() }; var systemUsage = new ItSystemUsage { Id = A<int>(), ItSystem = system, ObjectOwner = defaultTestUser, LastChangedByUser = defaultTestUser, LastChanged = A<DateTime>(), AssociatedDataProcessingRegistrations = new List<DataProcessingRegistration>() }; var earliestStartDate = DateTime.Now.AddYears(-1); var endDateOfEarlistStartDate = DateTime.Now.AddDays(A<int>()); var archivePeriods = new List<ArchivePeriod> { new ArchivePeriod { Id = A<int>(), ItSystemUsage = systemUsage, StartDate = DateTime.Now.AddDays(-1), EndDate = DateTime.Now.AddDays(1) }, new ArchivePeriod { Id = A<int>(), ItSystemUsage = systemUsage, StartDate = earliestStartDate, EndDate = endDateOfEarlistStartDate }, new ArchivePeriod { Id = A<int>(), ItSystemUsage = systemUsage, StartDate = DateTime.Now.AddDays(-30), EndDate = endDateOfEarlistStartDate.AddDays(A<int>()) }, }; systemUsage.ArchivePeriods = archivePeriods; var readModel = new ItSystemUsageOverviewReadModel(); //Act _sut.Apply(systemUsage, readModel); //Assert Assert.Equal(endDateOfEarlistStartDate, readModel.ActiveArchivePeriodEndDate); }
public RelationOptionsDTO( ItSystemUsage fromSystemUsage, ItSystemUsage toSystemUsage, IEnumerable <ItInterface> availableInterfaces, IEnumerable <ItContract> availableContracts, IEnumerable <RelationFrequencyType> availableFrequencyTypes) { FromSystemUsage = fromSystemUsage; ToSystemUsage = toSystemUsage; AvailableInterfaces = availableInterfaces; AvailableContracts = availableContracts; AvailableFrequencyTypes = availableFrequencyTypes; }
private void VerifySystemMigrationCommitted(ItSystemUsage systemUsage, ItSystem newSystem, Mock <IDatabaseTransaction> transaction) { //Verify update call to system usage with changed system id that points to the new system _systemUsageRepository .Verify(x => x.Update(It.Is <ItSystemUsage>(usage => usage == systemUsage && systemUsage.ItSystemId == newSystem.Id)), Times.Once); //Verify that transaction is committed transaction.Verify(x => x.Commit(), Times.Once); //Verify that updated domain event was indeed fired _domainEventsMock.Verify(x => x.Raise(It.Is <EntityUpdatedEvent <ItSystemUsage> >(x => x.Entity == systemUsage))); }
public void GetById_Returns() { //Arrange var id = A <int>(); var itSystemUsage = new ItSystemUsage(); ExpectGetUsageByKeyReturns(id, itSystemUsage); //Act var result = _sut.GetById(id); //Assert Assert.Same(itSystemUsage, result); }
public void AddUsageRelationTo_Returns_Error_If_Destination_Equals_Self() { //Arrange var destination = new ItSystemUsage { Id = _sut.Id }; //Act var result = _sut.AddUsageRelationTo(destination, Maybe <ItInterface> .None, A <string>(), A <string>(), Maybe <RelationFrequencyType> .None, Maybe <ItContract> .None); //Assert AssertErrorResult(result, "'From' cannot equal 'To'", OperationFailure.BadInput); }
private ItSystemUsage AddContractToSystemUsage(ItSystemUsage usage, IEnumerable <ItContract> itContracts) { var contractSystemUsages = new List <ItContractItSystemUsage>(); foreach (var contract in itContracts) { var contractSystemUsage = CreateContractItSystemUsage(usage.Id); contractSystemUsage.ItContract = contract; contractSystemUsages.Add(contractSystemUsage); } usage.Contracts = contractSystemUsages; return(usage); }
public void Handle_Deleted_Deletes_ReadModel() { //Arrange var itSystemUsage = new ItSystemUsage { Id = A <int>() }; //Act _sut.Handle(new EntityDeletedEvent <ItSystemUsage>(itSystemUsage)); //Assert _repository.Verify(x => x.DeleteBySourceId(itSystemUsage.Id), Times.Once); }
private SystemRelation CreateRelation(ItSystemUsage deletedSystemUsage) { var fromSystemUsage = new ItSystemUsage { Id = A <int>() }; var systemRelation = new SystemRelation(fromSystemUsage) { FromSystemUsageId = fromSystemUsage.Id, ToSystemUsage = deletedSystemUsage, Id = A <int>() }; fromSystemUsage.UsageRelations.Add(systemRelation); return(systemRelation); }