public void ChangeExposingSystem_Returns_Ok_When_Existing_And_New_Are_Equal()
{
//Arrange
var interfaceId = A <int>();
var existingSystem = new ItSystem()
{
Id = A <int>()
};
var itInterface = new ItInterface()
{
ExhibitedBy = new ItInterfaceExhibit()
{
ItSystem = existingSystem
}
};
ExpectGetInterfaceReturns(interfaceId, itInterface);
ExpectAllowModifyReturns(itInterface, true);
ExpectGetSystemReturns(existingSystem.Id, existingSystem);
ExpectAllowReadReturns(existingSystem, true);
var transaction = new Mock <IDatabaseTransaction>();
_transactionManager.Setup(x => x.Begin(It.IsAny <IsolationLevel>())).Returns(transaction.Object);
//Act
var result = _sut.ChangeExposingSystem(interfaceId, existingSystem.Id);
//Assert that no changes were saved
Assert.True(result.Ok);
transaction.Verify(x => x.Commit(), Times.Never);
_interfaceRepository.Verify(x => x.Save(), Times.Never);
}
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);
}
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 Apply_Returns_Items_With_Uuid_Match()
{
//Arrange
var correctId = A <Guid>();
var incorrectId = A <Guid>();
var matched = new ItSystem {
BelongsTo = new Organization()
{
Uuid = correctId
}
};
var excludedNoRightsHolder = new ItSystem {
BelongsTo = null
};
var excludedWrongUuid = new ItSystem {
BelongsTo = new Organization {
Uuid = incorrectId
}
};
var input = new[] { excludedWrongUuid, matched, excludedNoRightsHolder }.AsQueryable();
var sut = new QueryByRightsHolder(correctId);
//Act
var result = sut.Apply(input);
//Assert
var itSystem = Assert.Single(result);
Assert.Same(matched, itSystem);
}
public void Apply_Returns_Items_With_Key_Match()
{
//Arrange
var correctId = A <string>();
var incorrectId = A <string>();
var matched = new ItSystem {
TaskRefs = new List <TaskRef>()
{
new() { TaskKey = correctId }
}
};
var excludedNoTaskRefs = new ItSystem {
TaskRefs = new List <TaskRef>()
};
var excludedWrongUuid = new ItSystem {
TaskRefs = new List <TaskRef>()
{
new() { TaskKey = incorrectId }
}
};
var input = new[] { excludedWrongUuid, matched, excludedNoTaskRefs }.AsQueryable();
var sut = new QueryByTaskRef(key: correctId);
//Act
var result = sut.Apply(input);
//Assert
var itSystem = Assert.Single(result);
Assert.Same(matched, itSystem);
}
private static ItSystemResponseDTO ToDTO(ItSystem arg)
{
return(new()
{
Uuid = arg.Uuid,
Name = arg.Name,
RightsHolder = arg.BelongsTo?.Transform(organization => organization.MapOrganizationResponseDTO()),
BusinessType = arg.BusinessType?.Transform(businessType => businessType.MapIdentityNamePairDTO()),
Description = arg.Description,
CreatedBy = arg.ObjectOwner.MapIdentityNamePairDTO(),
Created = arg.Created,
Deactivated = arg.Disabled,
FormerName = arg.PreviousName,
LastModified = arg.LastChanged,
LastModifiedBy = arg.LastChangedByUser.Transform(user => user.MapIdentityNamePairDTO()),
ParentSystem = arg.Parent?.Transform(parent => parent.MapIdentityNamePairDTO()),
UrlReference = arg.Reference?.URL,
ExposedInterfaces = arg
.ItInterfaceExhibits
.Select(exhibit => exhibit.ItInterface)
.ToList()
.Select(x => x.MapIdentityNamePairDTO())
.ToList(),
RecommendedArchiveDutyResponse = new RecommendedArchiveDutyResponseDTO(arg.ArchiveDutyComment, arg.ArchiveDuty.ToDTOType()),
UsingOrganizations = arg
.Usages
.Select(systemUsage => systemUsage.Organization)
.Select(organization => organization.MapOrganizationResponseDTO())
.ToList(),
KLE = arg
.TaskRefs
.Select(taskRef => new IdentityNamePairResponseDTO(taskRef.Uuid, taskRef.TaskKey))
.ToList()
});
}
public void Apply_Returns_Items_With_MoreThanOrEqualToUsages()
{
//Arrange
var correctId = A <Guid>();
var incorrectId = A <Guid>();
const int gtEq = 2;
var matchedOnEq = new ItSystem {
Usages = { new ItSystemUsage(), new ItSystemUsage() }
};
var matchedOnGte = new ItSystem {
Usages = { new ItSystemUsage(), new ItSystemUsage(), new ItSystemUsage() }
};
var lessThanLowerBound = new ItSystem {
Usages = new List <ItSystemUsage> {
new()
}
};
var input = new[] { matchedOnEq, lessThanLowerBound, matchedOnGte }.AsQueryable();
var sut = new QueryByNumberOfUsages(gtEq);
//Act
var result = sut.Apply(input).ToList();
//Assert
Assert.Equal(2, result.Count);
Assert.Equal(new [] { matchedOnEq, matchedOnGte }, result.ToArray());
}
private ItSystemUsage CreateSystemUsage(ItSystem system, ItContract contract, int orgId)
{
return(new ItSystemUsage()
{
Id = Math.Abs(A <int>()),
ItSystem = system,
Contracts = contract != null ? new List <ItContractItSystemUsage>()
{
new ItContractItSystemUsage()
{
ItContract = contract
},
} : new List <ItContractItSystemUsage>(),
OrganizationId = orgId,
isBusinessCritical = A <DataOptions>(),
DPIA = A <DataOptions>(),
riskAssessment = A <DataOptions>(),
LinkToDirectoryUrl = A <string>(),
HostedAt = A <HostedAt>(),
preriskAssessment = A <RiskLevel>(),
SensitiveDataLevels = new List <ItSystemUsageSensitiveDataLevel>()
{
new ItSystemUsageSensitiveDataLevel()
{
SensitivityDataLevel = A <SensitiveDataLevel>()
}
}
});
}
public void Apply_Returns_Items_With_Uuid_Match()
{
//Arrange
var correctId = A <Guid>();
var incorrectId = A <Guid>();
var matched = new ItSystem {
BusinessType = new BusinessType {
Uuid = correctId
}
};
var excludedNoBusinessType = new ItSystem {
BusinessType = null
};
var excludedWrongUuid = new ItSystem {
BusinessType = new BusinessType {
Uuid = incorrectId
}
};
var input = new[] { excludedWrongUuid, matched, excludedNoBusinessType }.AsQueryable();
var sut = new QueryByBusinessType(correctId);
//Act
var result = sut.Apply(input);
//Assert
var itSystem = Assert.Single(result);
Assert.Same(matched, itSystem);
}
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 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 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 IEnumerable <ItInterface> GetExposedInterfaces()
{
return(ItSystem
.FromNullable()
.Select(system => system.ItInterfaceExhibits)
.Select(interfaceExhibits => interfaceExhibits.Select(interfaceExhibit => interfaceExhibit.ItInterface))
.Select(interfaces => interfaces.ToList())
.GetValueOrFallback(new List <ItInterface>()));
}
/// <summary>
/// Determines whether a user has write access to this instance.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>
/// <c>true</c> if user has write access, otherwise <c>false</c>.
/// </returns>
public override bool HasUserWriteAccess(User user)
{
if (ItSystem != null && ItSystem.HasUserWriteAccess(user))
{
return(true);
}
return(base.HasUserWriteAccess(user));
}
private ItSystemUsage CreateSystemUsage(int organizationId, ItSystem itSystem)
{
return(new ItSystemUsage
{
OrganizationId = organizationId,
Id = A <int>(),
ItSystemId = itSystem.Id,
ItSystem = itSystem
});
}
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);
}
private static IEnumerable <ItSystem> GetHierarchyParents(ItSystem itSystem)
{
var parents = new List <ItSystem>();
if (itSystem.Parent != null)
{
parents.Add(itSystem.Parent);
parents.AddRange(GetHierarchyParents(itSystem.Parent));
}
return(parents);
}
private ItSystem CreateTestItSystem(AccessModifier accessModifier, bool hasAssignedWriteAccess = false)
{
var testItSystem = new ItSystem {
AccessModifier = accessModifier
};
if (hasAssignedWriteAccess)
{
testItSystem.ObjectOwnerId = _userId;
}
return(testItSystem);
}
private static IEnumerable <ItSystem> GetHierarchyChildren(ItSystem itSystem)
{
var systems = new List <ItSystem>();
systems.AddRange(itSystem.Children);
foreach (var child in itSystem.Children)
{
var children = GetHierarchyChildren(child);
systems.AddRange(children);
}
return(systems);
}
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);
}
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 ItSystemUsageMigration(
ItSystemUsage systemUsage,
ItSystem fromItSystem,
ItSystem toItSystem,
IEnumerable <ItProject> affectedProjects,
IEnumerable <ItContract> affectedContracts,
IEnumerable <SystemRelation> affectedRelations)
{
SystemUsage = systemUsage;
FromItSystem = fromItSystem;
ToItSystem = toItSystem;
AffectedProjects = affectedProjects.ToList().AsReadOnly();
AffectedContracts = affectedContracts.ToList().AsReadOnly();
AffectedSystemRelations = affectedRelations.ToList().AsReadOnly();
}
public void ChangeExposingSystem_Returns_Forbidden_If_Read_Access_To_System_Is_Denied()
{
//Arrange
var interfaceId = A <int>();
var itInterface = new ItInterface();
var newSystemId = A <int>();
var itSystem = new ItSystem();
ExpectGetInterfaceReturns(interfaceId, itInterface);
ExpectAllowModifyReturns(itInterface, true);
ExpectGetSystemReturns(newSystemId, itSystem);
ExpectAllowReadReturns(itSystem, false);
//Act
var result = _sut.ChangeExposingSystem(interfaceId, newSystemId);
//Assert
Assert.Equal(OperationFailure.Forbidden, result.Error);
}
public void Add_Returns_Forbidden_If_ReadAccess_To_ItSystem_Is_Declined()
{
//Arrange
var itSystemUsage = new ItSystemUsage {
ItSystemId = A <int>(), OrganizationId = A <int>()
};
var itSystem = new ItSystem();
SetupRepositoryQueryWith(Enumerable.Empty <ItSystemUsage>());
_authorizationContext.Setup(x => x.AllowCreate <ItSystemUsage>(itSystemUsage.OrganizationId, itSystemUsage)).Returns(true);
_systemRepository.Setup(x => x.GetSystem(itSystemUsage.ItSystemId)).Returns(itSystem);
_authorizationContext.Setup(x => x.AllowReads(itSystem)).Returns(false);
//Act
var result = _sut.Add(itSystemUsage);
//Assert
Assert.False(result.Ok);
Assert.Equal(OperationFailure.Forbidden, result.Error);
}
public void GetAccessRightsForEntity_Returns_Based_On_AccessRights(bool allowRead, bool allowModify, bool allowDelete)
{
//Arrange
var id = A <int>();
var itSystem = new ItSystem();
_systemRepository.Setup(x => x.GetByKey(id)).Returns(itSystem);
ExpectAllowReadReturns(allowRead, itSystem);
ExpectAllowModifyReturns(allowModify, itSystem);
ExpectAllowDeleteReturns(allowDelete, itSystem);
//Act
var responseMessage = _sut.GetAccessRightsForEntity(id, true);
//Assert
var dto = ExpectResponseOf <EntityAccessRightsDTO>(responseMessage);
Assert.Equal(allowRead, dto.CanView);
Assert.Equal(allowModify, dto.CanEdit);
Assert.Equal(allowDelete, dto.CanDelete);
}
public void Add_Returns_Forbidden_If_Usage_Of_Local_System_In_Other_Org_Is_Attempted()
{
//Arrange
var itSystemUsage = new ItSystemUsage {
ItSystemId = A <int>(), OrganizationId = A <int>()
};
var itSystem = new ItSystem()
{
OrganizationId = itSystemUsage.OrganizationId + 1, AccessModifier = AccessModifier.Local
};
SetupRepositoryQueryWith(Enumerable.Empty <ItSystemUsage>());
_authorizationContext.Setup(x => x.AllowCreate <ItSystemUsage>(itSystemUsage.OrganizationId, itSystemUsage)).Returns(true);
_systemRepository.Setup(x => x.GetSystem(itSystemUsage.ItSystemId)).Returns(itSystem);
_authorizationContext.Setup(x => x.AllowReads(itSystem)).Returns(true);
//Act
var result = _sut.Add(itSystemUsage);
//Assert
Assert.False(result.Ok);
Assert.Equal(OperationFailure.Forbidden, result.Error);
}
public void UpdateKLE_Given_Summary_Updates_ItSystem()
{
//Arrange
var updateObjects = SetupUpdateObjects();
const int itSystemKey = 1;
var itSystem = new ItSystem
{
Id = itSystemKey,
TaskRefs = new List <TaskRef> {
updateObjects.removedTaskRef
}
};
updateObjects.removedTaskRef.ItSystems = new List <ItSystem> {
itSystem
};
//Act
_sut.UpdateKLE(0);
//Assert
Assert.False(itSystem.TaskRefs.Contains(updateObjects.removedTaskRef));
}
public static NamedEntityWithEnabledStatusDTO MapToNamedEntityWithEnabledStatusDTO(this ItSystem source)
{
return(new NamedEntityWithEnabledStatusDTO(source.Id, source.Name, source.Disabled));
}
public void Apply_Generates_Correct_Read_Model()
{
//Arrange
var outgoingRelationItSystem = new ItSystem
{
Id = A<int>(),
Name = A<string>()
};
var outgoingRelationInterface = new ItInterface
{
Id = A<int>(),
Name = A<string>()
};
var outgoingRelationItSystemUsage = new ItSystemUsage
{
Id = A<int>(),
OrganizationId = A<int>(),
ItSystem = outgoingRelationItSystem
};
var outgoingRelation = new SystemRelation(outgoingRelationItSystemUsage)
{
Id = A<int>(),
RelationInterface = outgoingRelationInterface,
ToSystemUsage = outgoingRelationItSystemUsage
};
var incomingRelationItSystem = new ItSystem
{
Id = A<int>(),
Name = A<string>()
};
var incomingRelationItSystemUsage = new ItSystemUsage
{
Id = A<int>(),
OrganizationId = A<int>(),
ItSystem = incomingRelationItSystem
};
var incomingRelation = new SystemRelation(incomingRelationItSystemUsage)
{
Id = A<int>()
};
var supplier = new Organization
{
Id = A<int>(),
Name = A<string>()
};
var user = new User
{
Id = A<int>(),
Name = A<string>(),
LastName = A<string>(),
Email = $"{A<string>()}@{A<string>()}.dk"
};
var right = new ItSystemRight
{
Id = A<int>(),
User = user,
UserId = user.Id,
RoleId = A<int>()
};
var contract = new ItContract
{
Id = A<int>(),
Name = A<string>(),
Supplier = supplier
};
var project = new ItProject
{
Id = A<int>(),
Name = A<string>()
};
var dataProcessingRegistration = new DataProcessingRegistration()
{
Id = A<int>(),
Name = A<string>(),
IsAgreementConcluded = A<YesNoIrrelevantOption>()
};
var parentSystem = new ItSystem
{
Id = A<int>(),
Name = A<string>(),
Disabled = A<bool>()
};
var system = new ItSystem
{
Id = A<int>(),
OrganizationId = A<int>(),
Name = A<string>(),
Disabled = A<bool>(),
Parent = parentSystem,
Uuid = A<Guid>(),
BelongsTo = new Organization
{
Id = A<int>(),
Name = A<string>()
},
BusinessType = new BusinessType
{
Id = A<int>(),
Name = A<string>()
},
TaskRefs = new List<TaskRef>
{
new TaskRef
{
Id = A<int>(),
TaskKey = A<string>(),
Description = A<string>()
}
}
};
var systemUsage = new ItSystemUsage
{
Id = A<int>(),
OrganizationId = A<int>(),
ItSystem = system,
Active = A<bool>(),
ExpirationDate = DateTime.Now.AddDays(-1),
Version = A<string>(),
LocalCallName = A<string>(),
LocalSystemId = A<string>(),
Rights = new List<ItSystemRight>
{
right
},
Reference = new ExternalReference
{
Id = A<int>(),
Title = A<string>(),
ExternalReferenceId = A<string>(),
URL = A<string>()
},
ObjectOwnerId = user.Id,
ObjectOwner = user,
LastChangedByUserId = user.Id,
LastChangedByUser = user,
LastChanged = A<DateTime>(),
Concluded = A<DateTime>(),
ItProjects = new List<ItProject>
{
project
},
ArchiveDuty = A<ArchiveDutyTypes>(),
Registertype = A<bool>(),
riskAssessment = DataOptions.YES,
RiskSupervisionDocumentationUrlName = A<string>(),
RiskSupervisionDocumentationUrl = A<string>(),
LinkToDirectoryUrlName = A<string>(),
LinkToDirectoryUrl = A<string>(),
AssociatedDataProcessingRegistrations = new List<DataProcessingRegistration>
{
dataProcessingRegistration
},
GeneralPurpose = A<string>(),
HostedAt = A<HostedAt>(),
UsageRelations = new List<SystemRelation>
{
outgoingRelation
},
UsedByRelations = new List<SystemRelation>
{
incomingRelation
}
};
// Add ResponsibleOrganizationUnit
var organizationUnit = new OrganizationUnit
{
Id = A<int>(),
Name = A<string>()
};
var systemUsageOrgUnitUsage = new ItSystemUsageOrgUnitUsage
{
OrganizationUnit = organizationUnit,
OrganizationUnitId = organizationUnit.Id,
ItSystemUsage = systemUsage,
ItSystemUsageId = systemUsage.Id
};
systemUsage.ResponsibleUsage = systemUsageOrgUnitUsage;
_businessTypeService.Setup(x => x.GetOption(system.OrganizationId, system.BusinessType.Id)).Returns(Maybe<(BusinessType, bool)>.Some((system.BusinessType, true)));
// Add MainContract
var mainContract = new ItContractItSystemUsage
{
ItContractId = contract.Id,
ItContract = contract,
ItSystemUsageId = systemUsage.Id,
ItSystemUsage = systemUsage
};
systemUsage.MainContract = mainContract;
// Add SensitiveDataLevel
var sensitiveDataLevel = new ItSystemUsageSensitiveDataLevel
{
Id = A<int>(),
ItSystemUsage = systemUsage,
SensitivityDataLevel = A<SensitiveDataLevel>()
};
systemUsage.SensitiveDataLevels = new List<ItSystemUsageSensitiveDataLevel> { sensitiveDataLevel };
// Add ArchivePeriod
var archivePeriods = new List<ArchivePeriod>
{
new ArchivePeriod
{
Id = A<int>(),
ItSystemUsage = systemUsage,
StartDate = DateTime.Now.AddDays(-1),
EndDate = DateTime.Now.AddDays(1)
}
};
systemUsage.ArchivePeriods = archivePeriods;
var readModel = new ItSystemUsageOverviewReadModel();
//Act
_sut.Apply(systemUsage, readModel);
//Assert
//System usage
Assert.Equal(systemUsage.Id, readModel.SourceEntityId);
Assert.Equal(systemUsage.OrganizationId, readModel.OrganizationId);
Assert.Equal(systemUsage.IsActive, readModel.IsActive);
Assert.Equal(systemUsage.Version, readModel.Version);
Assert.Equal(systemUsage.LocalCallName, readModel.LocalCallName);
Assert.Equal(systemUsage.LocalSystemId, readModel.LocalSystemId);
Assert.Equal(user.Id, readModel.ObjectOwnerId);
Assert.Equal(user.GetFullName(), readModel.ObjectOwnerName);
Assert.Equal(user.Id, readModel.LastChangedById);
Assert.Equal(user.GetFullName(), readModel.LastChangedByName);
Assert.Equal(systemUsage.LastChanged, readModel.LastChangedAt);
Assert.Equal(systemUsage.Concluded, readModel.Concluded);
Assert.Equal(systemUsage.ArchiveDuty, readModel.ArchiveDuty);
Assert.Equal(systemUsage.Registertype, readModel.IsHoldingDocument);
Assert.Equal(systemUsage.RiskSupervisionDocumentationUrlName, readModel.RiskSupervisionDocumentationName);
Assert.Equal(systemUsage.RiskSupervisionDocumentationUrl, readModel.RiskSupervisionDocumentationUrl);
Assert.Equal(systemUsage.LinkToDirectoryUrlName, readModel.LinkToDirectoryName);
Assert.Equal(systemUsage.LinkToDirectoryUrl, readModel.LinkToDirectoryUrl);
Assert.Equal(systemUsage.GeneralPurpose, readModel.GeneralPurpose);
Assert.Equal(systemUsage.HostedAt, readModel.HostedAt);
// Sensitive data levels
var rmSensitiveDataLevel = Assert.Single(readModel.SensitiveDataLevels);
Assert.Equal(sensitiveDataLevel.SensitivityDataLevel, rmSensitiveDataLevel.SensitivityDataLevel);
Assert.Equal(sensitiveDataLevel.SensitivityDataLevel.GetReadableName(), readModel.SensitiveDataLevelsAsCsv);
//System
Assert.Equal(system.Name, readModel.SystemName);
Assert.Equal(system.Disabled, readModel.ItSystemDisabled);
Assert.Equal(system.Uuid.ToString("D"), readModel.ItSystemUuid);
Assert.Equal(system.BelongsTo.Id, readModel.ItSystemRightsHolderId);
Assert.Equal(system.BelongsTo.Name, readModel.ItSystemRightsHolderName);
Assert.Equal(system.BusinessType.Id, readModel.ItSystemBusinessTypeId);
Assert.Equal(system.BusinessType.Name, readModel.ItSystemBusinessTypeName);
//Parent System
Assert.Equal(parentSystem.Name, readModel.ParentItSystemName);
Assert.Equal(parentSystem.Id, readModel.ParentItSystemId);
Assert.Equal(parentSystem.Disabled, readModel.ParentItSystemDisabled);
//Assigned Roles
var roleAssignment = Assert.Single(readModel.RoleAssignments);
Assert.Equal(user.Id, roleAssignment.UserId);
Assert.Equal(user.GetFullName(), roleAssignment.UserFullName);
Assert.Equal(right.RoleId, roleAssignment.RoleId);
Assert.Equal(user.Email, roleAssignment.Email);
//Responsible Organization Unit
Assert.Equal(organizationUnit.Id, readModel.ResponsibleOrganizationUnitId);
Assert.Equal(organizationUnit.Name, readModel.ResponsibleOrganizationUnitName);
//KLE
Assert.Equal(system.TaskRefs.First().TaskKey, readModel.ItSystemKLEIdsAsCsv);
Assert.Equal(system.TaskRefs.First().Description, readModel.ItSystemKLENamesAsCsv);
var taskRef = Assert.Single(readModel.ItSystemTaskRefs);
Assert.Equal(system.TaskRefs.First().TaskKey, taskRef.KLEId);
Assert.Equal(system.TaskRefs.First().Description, taskRef.KLEName);
//Reference
Assert.Equal(systemUsage.Reference.Title, readModel.LocalReferenceTitle);
Assert.Equal(systemUsage.Reference.URL, readModel.LocalReferenceUrl);
Assert.Equal(systemUsage.Reference.ExternalReferenceId, readModel.LocalReferenceDocumentId);
//Main Contract
Assert.Equal(contract.Id, readModel.MainContractId);
Assert.Equal(contract.Supplier.Id, readModel.MainContractSupplierId);
Assert.Equal(contract.Supplier.Name, readModel.MainContractSupplierName);
Assert.Equal(contract.IsActive, readModel.MainContractIsActive.GetValueOrDefault(false));
Assert.True(readModel.HasMainContract);
//Projects
Assert.Equal(project.Name, readModel.ItProjectNamesAsCsv);
var rmProject = Assert.Single(readModel.ItProjects);
Assert.Equal(project.Id, rmProject.ItProjectId);
Assert.Equal(project.Name, rmProject.ItProjectName);
//ArchivePeriods
var rmArchivePeriod = Assert.Single(readModel.ArchivePeriods);
Assert.Equal(archivePeriods.First().StartDate, rmArchivePeriod.StartDate);
Assert.Equal(archivePeriods.First().EndDate, rmArchivePeriod.EndDate);
Assert.Equal(archivePeriods.First().EndDate, readModel.ActiveArchivePeriodEndDate);
//DataProcessingRegistrations
Assert.Equal(dataProcessingRegistration.Name, readModel.DataProcessingRegistrationNamesAsCsv);
Assert.Equal(dataProcessingRegistration.IsAgreementConcluded.GetValueOrDefault(YesNoIrrelevantOption.UNDECIDED).GetReadableName(), readModel.DataProcessingRegistrationsConcludedAsCsv);
var rmDataProcessingRegistration = Assert.Single(readModel.DataProcessingRegistrations);
Assert.Equal(dataProcessingRegistration.Name, rmDataProcessingRegistration.DataProcessingRegistrationName);
Assert.Equal(dataProcessingRegistration.IsAgreementConcluded, rmDataProcessingRegistration.IsAgreementConcluded);
//Outgoing Relation interfaces
Assert.Equal(outgoingRelationInterface.Name, readModel.DependsOnInterfacesNamesAsCsv);
var rmDependsOnInterface = Assert.Single(readModel.DependsOnInterfaces);
Assert.Equal(outgoingRelationInterface.Id, rmDependsOnInterface.InterfaceId);
Assert.Equal(outgoingRelationInterface.Name, rmDependsOnInterface.InterfaceName);
//Outgoing Relation systems
Assert.Equal(outgoingRelationItSystem.Name, readModel.OutgoingRelatedItSystemUsagesNamesAsCsv);
var rmDependsOnSystem = Assert.Single(readModel.OutgoingRelatedItSystemUsages);
Assert.Equal(outgoingRelationItSystemUsage.Id, rmDependsOnSystem.ItSystemUsageId);
Assert.Equal(outgoingRelationItSystem.Name, rmDependsOnSystem.ItSystemUsageName);
//Incoming Relations
Assert.Equal(incomingRelationItSystem.Name, readModel.IncomingRelatedItSystemUsagesNamesAsCsv);
var rmIncomingRelatedSystemUsage = Assert.Single(readModel.IncomingRelatedItSystemUsages);
Assert.Equal(incomingRelationItSystemUsage.Id, rmIncomingRelatedSystemUsage.ItSystemUsageId);
Assert.Equal(incomingRelationItSystem.Name, rmIncomingRelatedSystemUsage.ItSystemUsageName);
}
public void Apply_Generates_DataProcessingRegistrationCsv_Correctly_With_Multiple_DataProcessingRegistrations()
{
//Arrange
var dpr1 = new DataProcessingRegistration
{
Id = A<int>(),
Name = A<string>(),
IsAgreementConcluded = YesNoIrrelevantOption.YES
};
var dpr2 = new DataProcessingRegistration
{
Id = A<int>(),
Name = A<string>(),
IsAgreementConcluded = YesNoIrrelevantOption.NO
};
var dpr3 = new DataProcessingRegistration
{
Id = A<int>(),
Name = A<string>(),
IsAgreementConcluded = YesNoIrrelevantOption.IRRELEVANT
};
var dpr4 = new DataProcessingRegistration
{
Id = A<int>(),
Name = A<string>(),
IsAgreementConcluded = YesNoIrrelevantOption.UNDECIDED
};
var dpr5 = new DataProcessingRegistration
{
Id = A<int>(),
Name = A<string>(),
IsAgreementConcluded = YesNoIrrelevantOption.UNDECIDED
};
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>()
{
dpr1,
dpr2,
dpr3,
dpr4,
dpr5
}
};
var readModel = new ItSystemUsageOverviewReadModel();
//Act
_sut.Apply(systemUsage, readModel);
//Assert
Assert.Equal($"{dpr1.Name}, {dpr2.Name}, {dpr3.Name}, {dpr4.Name}, {dpr5.Name}", readModel.DataProcessingRegistrationNamesAsCsv);
Assert.Equal($"{dpr1.IsAgreementConcluded.GetValueOrDefault().GetReadableName()}, " +
$"{dpr2.IsAgreementConcluded.GetValueOrDefault().GetReadableName()}, " +
$"{dpr3.IsAgreementConcluded.GetValueOrDefault().GetReadableName()}", readModel.DataProcessingRegistrationsConcludedAsCsv);
}
