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