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