public void Can_ChangeName()
{
//Arrange
var name = A <string>();
var registration = new DataProcessingRegistration();
//Act
var result = _sut.ChangeName(registration, name);
//Assert
Assert.True(result.IsNone);
Assert.Equal(name, registration.Name);
}
public void ChangeName_Returns_BadInput(string name)
{
//Arrange
var registration = new DataProcessingRegistration()
{
Name = A <string>()
};
//Act
var result = _sut.ChangeName(registration, name);
//Assert
AssertModificationFailure(result, OperationFailure.BadInput);
}
public void Can_Clear()
{
//Arrange
var dataProcessingRegistration = new DataProcessingRegistration {
OrganizationId = A <int>(), BasisForTransfer = new DataProcessingBasisForTransferOption()
};
//Act
var result = _sut.Clear(dataProcessingRegistration);
//Assert
Assert.True(result.Ok);
Assert.Null(dataProcessingRegistration.BasisForTransfer);
}
private Maybe <OperationError> ValidateNewName(int organizationId, string name, Maybe <int> exceptId)
{
if (!DataProcessingRegistration.IsNameValid(name))
{
return(new OperationError("Name is invalid", OperationFailure.BadInput));
}
if (ExistingDataProcessingRegistrationWithSameNameInOrganization(organizationId, name, exceptId))
{
return(new OperationError("Existing DataProcessingRegistration", OperationFailure.Conflict));
}
return(Maybe <OperationError> .None);
}
public void Handle_Deleted_Deletes_ReadModel()
{
//Arrange
var registration = new DataProcessingRegistration
{
Id = A <int>(),
};
//Act
_sut.Handle(new EntityDeletedEvent <DataProcessingRegistration>(registration));
//Assert
_repository.Verify(x => x.DeleteBySourceId(registration.Id), Times.Once);
}
public void Cannot_Clear_If_Already_Cleared()
{
//Arrange
var dataProcessingRegistration = new DataProcessingRegistration {
OrganizationId = A <int>()
};
//Act
var result = _sut.Clear(dataProcessingRegistration);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadState, result.Error.FailureType);
}
public Result <ItSystemUsage, OperationError> RemoveSystem(DataProcessingRegistration registration, int systemId)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
return(_repository
.GetSystemUsage(systemId)
.FromNullable()
.Match
(
registration.RemoveSystem,
() => new OperationError("System ID is not valid", OperationFailure.BadInput)
));
}
public void Can_Add()
{
//Arrange
var registration = new DataProcessingRegistration();
_repository.Setup(x => x.Insert(registration)).Returns <DataProcessingRegistration>(x => x);
//Act
var processingAgreement = _sut.Add(registration);
//Assert
Assert.Same(registration, processingAgreement);
VerifyLifeCycleEvent(registration, LifeCycleEventType.Created);
VerifySaved();
}
private Result <Organization, OperationError> ExecuteDataProcessorChange(
DataProcessingRegistration registration,
int organizationId,
Func <DataProcessingRegistration, Func <Organization, Result <Organization, OperationError> > > getCommand)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
return
(_organizationRepository
.GetById(organizationId)
.Select(getCommand(registration))
.Match(result => result, () => new OperationError("Invalid organization id", OperationFailure.BadInput)));
}
public void Handle_Created_Adds_New_ReadModel()
{
//Arrange
var registration = new DataProcessingRegistration
{
Id = A <int>(),
Name = A <string>(),
OrganizationId = A <int>()
};
//Act
_sut.Handle(new EntityCreatedEvent <DataProcessingRegistration>(registration));
//Assert
_repository.Verify(x => x.Add(MatchSourceData(registration)), Times.Once);
}
public void Delete_Returns_True_If_Found_And_Deleted()
{
//Arrange
var id = A <int>();
var registration = new DataProcessingRegistration();
_repository.Setup(x => x.GetByKey(id)).Returns(registration);
//Act
var deleted = _sut.DeleteById(id);
//Assert
_repository.Verify(x => x.DeleteWithReferencePreload(registration), Times.Once);
Assert.True(deleted);
VerifyLifeCycleEvent(registration, LifeCycleEventType.Deleted);
VerifySaved();
}
public void Cannot_RemoveSubDataProcessor_If_Not_Present()
{
//Arrange
var organization = new Organization {
Id = A <int>()
};
var dataProcessingRegistration = new DataProcessingRegistration();
ExpectGetOrganizationByIdReturns(organization.Id, organization);
//Act
var result = _sut.RemoveSubDataProcessor(dataProcessingRegistration, organization.Id);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
}
public void Cannot_Assign_If_Option_Is_Unavailable()
{
//Arrange
var dataProcessingRegistration = new DataProcessingRegistration {
OrganizationId = A <int>()
};
var optionId = A <int>();
_optionsServiceMock.Setup(x => x.GetAvailableOption(dataProcessingRegistration.OrganizationId, optionId)).Returns(Maybe <DataProcessingBasisForTransferOption> .None);
//Act
var result = _sut.Assign(dataProcessingRegistration, optionId);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
}
public void Cannot_Remove_If_CountryId_Is_Invalid()
{
//Arrange
var countryId = A <int>();
var registration = new DataProcessingRegistration
{
OrganizationId = A <int>()
};
ExpectGetOptionReturns(registration, countryId, Maybe <DataProcessingCountryOption> .None);
//Act
var result = _sut.Remove(registration, countryId);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
}
public void Cannot_Assign_If_OversightOption_Is_Not_Available()
{
//Arrange
var registration = new DataProcessingRegistration
{
OrganizationId = A <int>()
};
var oversightOptionId = A <int>();
ExpectGetAvailableOptionReturns(registration, oversightOptionId, Maybe <DataProcessingOversightOption> .None);
//Act
var result = _sut.Assign(registration, oversightOptionId);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
}
public void Cannot_RemoveSystem_If_System_Is_Not_Found()
{
//Arrange
var organizationId = A <int>();
var systemId = A <int>();
var registration = new DataProcessingRegistration {
OrganizationId = organizationId
};
_systemRepository.Setup(x => x.GetSystemUsage(systemId)).Returns(default(ItSystemUsage));
//Act
var result = _sut.RemoveSystem(registration, systemId);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
}
public void Can_Assign()
{
//Arrange
var dataProcessingRegistration = new DataProcessingRegistration {
OrganizationId = A <int>()
};
var optionId = A <int>();
var optionFromService = new DataProcessingBasisForTransferOption();
_optionsServiceMock.Setup(x => x.GetAvailableOption(dataProcessingRegistration.OrganizationId, optionId)).Returns(optionFromService);
//Act
var result = _sut.Assign(dataProcessingRegistration, optionId);
//Assert
Assert.True(result.Ok);
Assert.Same(dataProcessingRegistration.BasisForTransfer, optionFromService);
}
public IQueryable <ItSystemUsage> GetApplicableSystems(DataProcessingRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
return
(registration
.SystemUsages
.Select(x => x.Id)
.ToList()
.Transform
(
idsInUse => _repository
.GetSystemUsagesFromOrganization(registration.OrganizationId)
.ExceptEntitiesWithIds(idsInUse)
));
}
private DataProcessingRegistrationDTO ToDTO(DataProcessingRegistration value)
{
var assignableDataProcessingRegistrationOptions = _dataProcessingRegistrationOptionsApplicationService.GetAssignableDataProcessingRegistrationOptions(value.OrganizationId).Value;
var enabledCountryOptions = GetIdsOfAvailableCountryOptions(assignableDataProcessingRegistrationOptions);
var enabledBasisForTransferOptions = GetIdsOfAvailableBasisForTransferOptions(assignableDataProcessingRegistrationOptions);
var enabledDataResponsibleOptions = GetIdsOfAvailableDataResponsibleOptions(assignableDataProcessingRegistrationOptions);
var enabledRoles = GetIdsOfAvailableRoles(assignableDataProcessingRegistrationOptions);
var enabledOversightOptions = GetIdsOfAvailableOversightOptions(assignableDataProcessingRegistrationOptions);
int organizationId = value.OrganizationId;
return(ToDTO(
value,
GetLocalRoleDescriptionOverrides(_dataProcessingRegistrationOptionsApplicationService.GetAssignableDataProcessingRegistrationOptions(organizationId)),
enabledCountryOptions,
enabledBasisForTransferOptions,
enabledDataResponsibleOptions,
enabledRoles,
enabledOversightOptions));
}
public override bool Execute(KitosContext dbContext)
{
var commonOrg = dbContext.GetOrganization(TestOrganizations.CommonOrg);
var globalAdmin = dbContext.GetGlobalAdmin();
var agreement = new DataProcessingRegistration()
{
Name = _name,
ObjectOwnerId = globalAdmin.Id,
OrganizationId = commonOrg.Id,
LastChangedByUserId = globalAdmin.Id
};
agreement = dbContext.DataProcessingRegistrations.Add(agreement);
dbContext.SaveChanges();
var readModel = new DataProcessingRegistrationReadModel();
var update = new DataProcessingRegistrationReadModelUpdate(
new GenericRepository <DataProcessingRegistrationRoleAssignmentReadModel>(dbContext),
new OptionsService <DataProcessingRegistration, DataProcessingBasisForTransferOption, LocalDataProcessingBasisForTransferOption>
(
new GenericRepository <LocalDataProcessingBasisForTransferOption>(dbContext),
new GenericRepository <DataProcessingBasisForTransferOption>(dbContext)
),
new OptionsService <DataProcessingRegistration, DataProcessingDataResponsibleOption, LocalDataProcessingDataResponsibleOption>
(
new GenericRepository <LocalDataProcessingDataResponsibleOption>(dbContext),
new GenericRepository <DataProcessingDataResponsibleOption>(dbContext)
),
new OptionsService <DataProcessingRegistration, DataProcessingOversightOption, LocalDataProcessingOversightOption>
(
new GenericRepository <LocalDataProcessingOversightOption>(dbContext),
new GenericRepository <DataProcessingOversightOption>(dbContext)
)
);
update.Apply(agreement, readModel);
dbContext.DataProcessingRegistrationReadModels.Add(readModel);
dbContext.SaveChanges();
return(true);
}
public void Cannot_Assign_If_Country_Is_Not_Available()
{
//Arrange
var registration = new DataProcessingRegistration
{
TransferToInsecureThirdCountries = YesNoUndecidedOption.Yes,
OrganizationId = A <int>()
};
var countryId = A <int>();
ExpectGetAvailableOptionReturns(registration, countryId, Maybe <DataProcessingCountryOption> .None);
//Act
var result = _sut.Assign(registration, countryId);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
}
public void Cannot_AssignSubDataProcessor_If_Already_Assigned()
{
//Arrange
var existingProcessor = new Organization {
Id = A <int>()
};
var dataProcessingRegistration = new DataProcessingRegistration()
{
SubDataProcessors = { existingProcessor }, HasSubDataProcessors = YesNoUndecidedOption.Yes
};
ExpectGetOrganizationByIdReturns(existingProcessor.Id, existingProcessor);
//Act
var result = _sut.AssignSubDataProcessor(dataProcessingRegistration, existingProcessor.Id);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.Conflict, result.Error.FailureType);
}
public void Handle_Updated_Schedules_Async_Update()
{
//Arrange
var registration = new DataProcessingRegistration
{
Id = A <int>(),
Name = A <string>(),
OrganizationId = A <int>()
};
_repository.Setup(x => x.GetBySourceId(registration.Id)).Returns(new DataProcessingRegistrationReadModel());
//Act
_sut.Handle(new EntityUpdatedEvent <DataProcessingRegistration>(registration));
//Assert
_pendingUpdatesRepository.Verify(x => x.Add(It.Is <PendingReadModelUpdate>(pru =>
pru.Category == PendingReadModelUpdateSourceCategory.DataProcessingRegistration &&
pru.SourceId == registration.Id)));
}
private void Notify(DataProcessingRegistration dataProcessingRegistration, LifeCycleEventType changeType)
{
switch (changeType)
{
case LifeCycleEventType.Created:
_domainEvents.Raise(new EntityCreatedEvent <DataProcessingRegistration>(dataProcessingRegistration));
break;
case LifeCycleEventType.Updated:
_domainEvents.Raise(new EntityUpdatedEvent <DataProcessingRegistration>(dataProcessingRegistration));
break;
case LifeCycleEventType.Deleted:
_domainEvents.Raise(new EntityDeletedEvent <DataProcessingRegistration>(dataProcessingRegistration));
break;
default:
throw new ArgumentOutOfRangeException(nameof(changeType), changeType, null);
}
}
public void Can_Assign()
{
//Arrange
var registration = new DataProcessingRegistration
{
OrganizationId = A <int>()
};
var oversightOptionId = A <int>();
var oversightOption = new DataProcessingOversightOption();
ExpectGetAvailableOptionReturns(registration, oversightOptionId, oversightOption);
//Act
var result = _sut.Assign(registration, oversightOptionId);
//Assert
Assert.True(result.Ok);
Assert.Same(oversightOption, result.Value);
Assert.True(registration.OversightOptions.Contains(oversightOption));
}
public void Cannot_RemoveSubDataProcessor_If_Not_Applicable()
{
//Arrange
var existingProcessor = new Organization {
Id = A <int>()
};
var dpId = A <int>();
var dataProcessingRegistration = new DataProcessingRegistration {
SubDataProcessors = { existingProcessor }
};
ExpectGetOrganizationByIdReturns(dpId, Maybe <Organization> .None);
//Act
var result = _sut.RemoveSubDataProcessor(dataProcessingRegistration, dpId);
//Assert
Assert.True(result.Failed);
Assert.Equal(OperationFailure.BadInput, result.Error.FailureType);
}
public void Can_RemoveSubDataProcessor()
{
//Arrange
var existingProcessor = new Organization {
Id = A <int>()
};
var dataProcessingRegistration = new DataProcessingRegistration()
{
SubDataProcessors = { existingProcessor }
};
ExpectGetOrganizationByIdReturns(existingProcessor.Id, existingProcessor);
//Act
var result = _sut.RemoveSubDataProcessor(dataProcessingRegistration, existingProcessor.Id);
//Assert
Assert.True(result.Ok);
Assert.Same(existingProcessor, result.Value);
Assert.False(dataProcessingRegistration.SubDataProcessors.Contains(existingProcessor));
}
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);
}
