public void Can_GetApplicableDataProcessingRegistrations()
{
//Arrange
var alreadyAssignedDataProcessingRegistration = new DataProcessingRegistration {
Id = A <int>()
};
var availableDataProcessingRegistration = new DataProcessingRegistration {
Id = A <int>()
};
var organizationId = A <int>();
var contract = new ItContract
{
OrganizationId = organizationId,
DataProcessingRegistrations = { alreadyAssignedDataProcessingRegistration }
};
ExpectDataProcessingRegistrationInOrganization(organizationId, availableDataProcessingRegistration, alreadyAssignedDataProcessingRegistration);
//Act
var applicableDataProcessingRegistrations = _sut.GetApplicableDataProcessingRegistrations(contract);
//Assert
var registration = Assert.Single(applicableDataProcessingRegistrations);
Assert.Same(availableDataProcessingRegistration, registration);
}
public void Can_GetDataProcessingRegistrationsWhichCanBeAssigned()
{
//Arrange
var id = A <int>();
var dataProcessingRegistration1Id = A <int>();
var dataProcessingRegistration2Id = dataProcessingRegistration1Id + 1;
var nameQuery = A <string>();
var contract = new ItContract();
ExpectGetContractReturns(id, contract);
ExpectAllowReadReturns(contract, true);
var dataProcessingRegistrations = new[] { new DataProcessingRegistration()
{
Id = dataProcessingRegistration1Id, Name = $"{nameQuery}{1}"
}, new DataProcessingRegistration()
{
Id = dataProcessingRegistration2Id, Name = $"{nameQuery}{1}"
} };
_contractDataProcessingRegistrationAssignmentService.Setup(x => x.GetApplicableDataProcessingRegistrations(contract)).Returns(dataProcessingRegistrations.AsQueryable());
//Act
var result = _sut.GetDataProcessingRegistrationsWhichCanBeAssigned(id, nameQuery, new Random().Next(2, 100));
//Assert
Assert.True(result.Ok);
Assert.Equal(dataProcessingRegistrations, result.Value);
}
public override bool Execute(KitosContext context)
{
var commonOrg = context.GetOrganization(TestOrganizations.CommonOrg);
var globalAdmin = context.GetGlobalAdmin();
var systemWithSameName = context.ItContracts.AsNoTracking().FirstOrDefault(x => x.Name == _name);
if (systemWithSameName != null)
{
Console.Out.WriteLine($"Existing ItContract with name {_name} already exists in the database.");
return(false);
}
var itContract = new ItContract
{
Name = _name,
ObjectOwnerId = globalAdmin.Id,
OrganizationId = commonOrg.Id,
LastChangedByUserId = globalAdmin.Id,
};
context.ItContracts.Add(itContract);
context.SaveChanges();
return(true);
}
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>()
}
}
});
}
private static IEnumerable <EconomyStream> GetEconomyStreams(ItContract contract)
{
return(contract
.ExternEconomyStreams
.ToList()
.Concat(contract.InternEconomyStreams.ToList()));
}
public void AddUsageRelationTo_Returns_Success_And_Adds_New_Relation()
{
//Arrange
var interfaceId = A <int>();
_sut.UsageRelations.Add(new SystemRelation(new ItSystemUsage()));
var itInterface = new ItInterface
{
Id = interfaceId
};
var destination = new ItSystemUsage
{
Id = A <int>(),
OrganizationId = _sut.OrganizationId,
ItSystem = new ItSystem
{
ItInterfaceExhibits =
{
new ItInterfaceExhibit
{
ItInterface = itInterface
}
}
}
};
var itContract = new ItContract {
OrganizationId = _sut.OrganizationId
};
var frequencyType = new RelationFrequencyType();
var description = A <string>();
var reference = A <string>();
//Act
var result = _sut.AddUsageRelationTo(destination, itInterface, description, reference, frequencyType, itContract);
//Assert
Assert.True(result.Ok);
var newRelation = result.Value;
Assert.True(_sut.UsageRelations.Contains(newRelation));
Assert.Equal(2, _sut.UsageRelations.Count); //existing + the new one
Assert.Equal(itContract, newRelation.AssociatedContract);
Assert.Equal(frequencyType, newRelation.UsageFrequency);
Assert.Equal(destination, newRelation.ToSystemUsage);
Assert.Equal(description, newRelation.Description);
Assert.NotNull(newRelation.Reference);
Assert.Equal(reference, newRelation.Reference);
}
public void GetRelationsAssociatedWithContract_Returns_Forbidden()
{
//Arrange
var id = A <int>();
var itContract = new ItContract();
_contractRepository.Setup(x => x.GetById(id)).Returns(itContract);
ExpectAllowReadReturns(itContract, false);
//Act
var relations = _sut.GetRelationsAssociatedWithContract(id);
//Assert
Assert.False(relations.Ok);
Assert.Equal(OperationFailure.Forbidden, relations.Error.FailureType);
}
/// <summary>
/// Helper test to make it easy to cover the "Missing read access" case
/// </summary>
/// <param name="command"></param>
private void Test_Command_Which_Fails_With_Contract_Insufficient_ReadAccess <TSuccess>(Func <int, Result <TSuccess, OperationError> > command)
{
//Arrange
var id = A <int>();
var contract = new ItContract();
ExpectGetContractReturns(id, contract);
ExpectAllowReadReturns(contract, false);
//Act
var result = command(id);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.Forbidden, result.Error.FailureType);
}
public void Delete_Returns_Forbidden()
{
//Arrange
var contractId = A <int>();
var itContract = new ItContract();
ExpectGetContractReturns(contractId, itContract);
ExpectAllowDeleteReturns(itContract, false);
//Act
var result = _sut.Delete(contractId);
//Assert
Assert.False(result.Ok);
Assert.Equal(OperationFailure.Forbidden, result.Error);
}
private SystemRelation CreateRelation(ItContract deletedContract)
{
var fromSystemUsage = new ItSystemUsage {
Id = A <int>()
};
var systemRelation = new SystemRelation(fromSystemUsage)
{
AssociatedContract = deletedContract,
ToSystemUsage = new ItSystemUsage {
Id = A <int>()
}
};
fromSystemUsage.UsageRelations.Add(systemRelation);
return(systemRelation);
}
public void Cannot_AssignDataProcessingRegistration_If_Registration_Is_Not_Found()
{
//Arrange
var contract = new ItContract {
OrganizationId = A <int>()
};
var dataProcessingRegistrationid = A <int>();
_dataProcessingRegistrationRepository.Setup(x => x.GetById(dataProcessingRegistrationid)).Returns(default(DataProcessingRegistration));
//Act
var result = _sut.AssignDataProcessingRegistration(contract, dataProcessingRegistrationid);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
Assert.Empty(contract.DataProcessingRegistrations);
}
public void AddUsageRelationTo_Returns_Error_If_Contract_Organization_Is_Different()
{
//Arrange
var destination = new ItSystemUsage
{
Id = A <int>(),
OrganizationId = _sut.OrganizationId
};
var itContract = new ItContract {
OrganizationId = _sut.OrganizationId + 1
};
//Act
var result = _sut.AddUsageRelationTo(destination, Maybe <ItInterface> .None, A <string>(), A <string>(), Maybe <RelationFrequencyType> .None, itContract);
//Assert
AssertErrorResult(result, "Attempt to create relation to it contract in a different organization", OperationFailure.BadInput);
}
public void Can_RemoveDataProcessingRegistration()
{
//Arrange
var organizationId = A <int>();
var registration = new DataProcessingRegistration {
OrganizationId = organizationId, Id = A <int>()
};
var contract = new ItContract {
OrganizationId = organizationId, DataProcessingRegistrations = { registration }
};
_dataProcessingRegistrationRepository.Setup(x => x.GetById(registration.Id)).Returns(registration);
//Act
var result = _sut.RemoveDataProcessingRegistration(contract, registration.Id);
//Assert
Assert.True(result.Ok);
Assert.Same(registration, result.Value);
Assert.Empty(contract.DataProcessingRegistrations);
}
public void Can_AssignDataProcessingRegistration()
{
//Arrange
var dataProcessingRegistrationId = A <int>();
var contract = new ItContract {
OrganizationId = A <int>()
};
var dataProcessingRegistration = new DataProcessingRegistration {
OrganizationId = contract.OrganizationId
};
_dataProcessingRegistrationRepository.Setup(x => x.GetById(dataProcessingRegistrationId)).Returns(dataProcessingRegistration);
//Act
var result = _sut.AssignDataProcessingRegistration(contract, dataProcessingRegistrationId);
//Assert
Assert.True(result.Ok);
Assert.Same(dataProcessingRegistration, result.Value);
Assert.True(contract.DataProcessingRegistrations.Contains(dataProcessingRegistration));
}
public void Cannot_RemoveDataProcessingRegistration_If_Registration_Is_Not_AssignedAlready()
{
//Arrange
var organizationId = A <int>();
var registration = new DataProcessingRegistration {
OrganizationId = organizationId, Id = A <int>()
};
var contract = new ItContract {
OrganizationId = organizationId, DataProcessingRegistrations = { new DataProcessingRegistration() }
};
_dataProcessingRegistrationRepository.Setup(x => x.GetById(registration.Id)).Returns(registration);
//Act
var result = _sut.RemoveDataProcessingRegistration(contract, registration.Id);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
Assert.NotEmpty(contract.DataProcessingRegistrations);
}
public void Delete_Deletes_EconomyStreams_And_Raises_Domain_Event_And_Returns_Ok()
{
//Arrange
var contractId = A <int>();
var externEconomyStream1 = CreateEconomyStream();
var externEconomyStream2 = CreateEconomyStream();
var internEconomyStream1 = CreateEconomyStream();
var internEconomyStream2 = CreateEconomyStream();
var itContract = new ItContract
{
ExternEconomyStreams = new List <EconomyStream> {
externEconomyStream1, externEconomyStream2
},
InternEconomyStreams = new List <EconomyStream> {
internEconomyStream1, internEconomyStream2
}
};
var transaction = new Mock <IDatabaseTransaction>();
ExpectGetContractReturns(contractId, itContract);
ExpectAllowDeleteReturns(itContract, true);
_transactionManager.Setup(x => x.Begin(IsolationLevel.ReadCommitted)).Returns(transaction.Object);
_referenceService.Setup(x => x.DeleteByContractId(contractId)).Returns(Result <IEnumerable <ExternalReference>, OperationFailure> .Success(new List <ExternalReference>()));
//Act
var result = _sut.Delete(contractId);
//Assert
Assert.True(result.Ok);
_economyStreamRepository.Verify(x => x.DeleteWithReferencePreload(It.IsAny <EconomyStream>()), Times.Exactly(4));
_economyStreamRepository.Verify(x => x.DeleteWithReferencePreload(externEconomyStream1), Times.Once);
_economyStreamRepository.Verify(x => x.DeleteWithReferencePreload(externEconomyStream2), Times.Once);
_economyStreamRepository.Verify(x => x.DeleteWithReferencePreload(internEconomyStream1), Times.Once);
_economyStreamRepository.Verify(x => x.DeleteWithReferencePreload(internEconomyStream2), Times.Once);
_contractRepository.Verify(x => x.DeleteContract(itContract), Times.Once);
_domainEvents.Verify(x => x.Raise(It.Is <ContractDeleted>(cd => cd.DeletedContract == itContract)), Times.Once);
_referenceService.Verify(x => x.DeleteByContractId(contractId), Times.Once);
transaction.Verify(x => x.Commit(), Times.Once);
}
private void Handle_ContractDeleted_Resets_Contract_On_Associated_Relations()
{
//Arrange
var deletedContract = new ItContract();
deletedContract.AssociatedSystemRelations = new List <SystemRelation>
{
CreateRelation(deletedContract),
CreateRelation(deletedContract),
};
var transaction = new Mock <IDatabaseTransaction>();
_transactionManager.Setup(x => x.Begin(IsolationLevel.ReadCommitted)).Returns(transaction.Object);
//Act
_sut.Handle(new ContractDeleted(deletedContract));
//Assert that all interface fields were reset
Assert.True(deletedContract.AssociatedSystemRelations.All(x => x.AssociatedContract == null));
_systemUsageRepository.Verify(x => x.Save(), Times.Once);
transaction.Verify(x => x.Commit(), Times.Once);
}
public void GetRelationsAssociatedWithContract_Returns_Ok()
{
//Arrange
var id = A <int>();
var associatedSystemRelations = new List <SystemRelation>()
{
CreateRelation(), CreateRelation()
};
var itContract = new ItContract {
AssociatedSystemRelations = associatedSystemRelations
};
_contractRepository.Setup(x => x.GetById(id)).Returns(itContract);
ExpectAllowReadReturns(itContract, true);
//Act
var relations = _sut.GetRelationsAssociatedWithContract(id);
//Assert
Assert.True(relations.Ok);
Assert.True(relations.Value.SequenceEqual(associatedSystemRelations));
}
public void Can_RemoveDataProcessingRegistration()
{
//Arrange
var id = A <int>();
var contract = new ItContract();
var dataProcessingRegistrationId = A <int>();
var dataProcessingRegistration = new DataProcessingRegistration();
ExpectGetContractReturns(id, contract);
ExpectAllowModifyReturns(contract, true);
_contractDataProcessingRegistrationAssignmentService.Setup(x => x.RemoveDataProcessingRegistration(contract, dataProcessingRegistrationId)).Returns(dataProcessingRegistration);
var transaction = new Mock <IDatabaseTransaction>();
_transactionManager.Setup(x => x.Begin(IsolationLevel.ReadCommitted)).Returns(transaction.Object);
//Act
var result = _sut.RemoveDataProcessingRegistration(id, dataProcessingRegistrationId);
//Assert
Assert.True(result.Ok);
Assert.Same(dataProcessingRegistration, result.Value);
transaction.Verify(x => x.Commit());
}
public void AddUsageRelationTo_Returns_Error_If_Selected_Interface_Is_Not_Exposed_By_Target_System()
{
//Arrange
var interfaceId = A <int>();
var destination = new ItSystemUsage
{
Id = A <int>(),
OrganizationId = _sut.OrganizationId,
ItSystem = new ItSystem
{
ItInterfaceExhibits =
{
new ItInterfaceExhibit
{
ItInterface = new ItInterface
{
Id = interfaceId + 1
}
}
}
}
};
var itContract = new ItContract {
OrganizationId = _sut.OrganizationId
};
//Act
var result = _sut.AddUsageRelationTo(destination, new ItInterface()
{
Id = interfaceId
}, A <string>(), A <string>(), Maybe <RelationFrequencyType> .None, itContract);
//Assert
AssertErrorResult(result, "Cannot set interface which is not exposed by the 'to' system", OperationFailure.BadInput);
}
public IQueryable <DataProcessingRegistration> GetApplicableDataProcessingRegistrations(ItContract contract)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
return
(contract
.DataProcessingRegistrations
.Select(x => x.Id)
.ToList()
.Transform
(
idsInUse => _dataProcessingRegistrationRepository
.GetDataProcessingRegistrationsFromOrganization(contract.OrganizationId)
.ExceptEntitiesWithIds(idsInUse)
));
}
public Result <DataProcessingRegistration, OperationError> RemoveDataProcessingRegistration(ItContract contract, int dataProcessingRegistrationId)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
return(_dataProcessingRegistrationRepository
.GetById(dataProcessingRegistrationId)
.Match
(
contract.RemoveDataProcessingRegistration,
() => new OperationError("Data processing registration ID is not valid", OperationFailure.BadInput)
));
}
private void ExpectGetContractReturns(int contractId, ItContract itContract)
{
_contractRepository.Setup(x => x.GetById(contractId)).Returns(itContract);
}
private void ExpectAllowModifyReturns(ItContract itContract, bool value)
{
_authorizationContext.Setup(x => x.AllowModify(itContract)).Returns(value);
}
public void Update(ItContract contract)
{
_domainEvents.Raise(new EntityUpdatedEvent <ItContract>(contract));
_contractRepository.Save();
}
private Result <ItContract, OperationError> WithAuthorizedReadAccessToContract(ItContract contract)
{
return(_authorizationContext.AllowReads(contract) ?
Result <ItContract, OperationError> .Success(contract) :
new OperationError("Not allowed to read contract", OperationFailure.Forbidden));
}
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 DeleteContract(ItContract contract)
{
_contractRepository.DeleteWithReferencePreload(contract);
_contractRepository.Save();
}
public ContractDeleted(ItContract deletedContract)
{
DeletedContract = deletedContract ?? throw new ArgumentNullException(nameof(deletedContract));
}
