public Result <ItInterface, OperationFailure> Create(int organizationId, string name, string interfaceId, AccessModifier?accessModifier = default) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (!IsItInterfaceIdAndNameUnique(interfaceId, name, organizationId)) { return(OperationFailure.Conflict); } var newInterface = new ItInterface { Name = name, OrganizationId = organizationId, ItInterfaceId = interfaceId ?? string.Empty, Uuid = Guid.NewGuid(), AccessModifier = accessModifier.GetValueOrDefault(AccessModifier.Public) }; if (!_authorizationContext.AllowCreate <ItInterface>(organizationId, newInterface)) { return(OperationFailure.Forbidden); } var createdInterface = _repository.Insert(newInterface); _repository.Save(); return(createdInterface); }
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); }
private bool ValidateNewReport( BrokenExternalReferencesReport report, ItInterface includedInterfaceWhichFails, EndpointValidationError expectedInterfaceError, BrokenLinkCause brokenLinkCauseForInterface, ExternalReference includedReferenceWhichFails, EndpointValidationError expectedReferenceError, BrokenLinkCause brokenLinkCauseForReference) { Assert.Equal(_now, report.Created); var brokenLinkInInterface = Assert.Single(report.BrokenInterfaceLinks); Assert.Same(includedInterfaceWhichFails, brokenLinkInInterface.BrokenReferenceOrigin); Assert.Equal(brokenLinkInInterface.ErrorResponseCode, (int?)expectedInterfaceError.StatusCode); Assert.Equal(brokenLinkInInterface.Cause, brokenLinkCauseForInterface); Assert.Equal(brokenLinkInInterface.ValueOfCheckedUrl, includedInterfaceWhichFails.Url); var brokenLinkInExternalReference = Assert.Single(report.BrokenExternalReferences); Assert.Same(includedReferenceWhichFails, brokenLinkInExternalReference.BrokenReferenceOrigin); Assert.Equal(brokenLinkInExternalReference.ErrorResponseCode, (int?)expectedReferenceError.StatusCode); Assert.Equal(brokenLinkInExternalReference.ValueOfCheckedUrl, includedReferenceWhichFails.URL); Assert.Equal(brokenLinkInExternalReference.Cause, brokenLinkCauseForReference); return(true); }
private void ResetInterfaceOnRelations(ItInterface affectedInterface, IDatabaseTransaction transaction) { var systemRelations = affectedInterface.AssociatedSystemRelations.ToList(); if (systemRelations.Any()) { foreach (var systemRelation in systemRelations) { var fromSystemUsage = systemRelation.FromSystemUsage; var result = fromSystemUsage.ModifyUsageRelation( relationId: systemRelation.Id, toSystemUsage: systemRelation.ToSystemUsage, changedDescription: systemRelation.Description, changedReference: systemRelation.Reference, relationInterface: Maybe <ItInterface> .None, //Remove the interface binding toContract: systemRelation.AssociatedContract, toFrequency: systemRelation.UsageFrequency); if (result.Failed) { throw new InvalidOperationException($"Failed to modify system relation. Error: {result.Error}"); } } _systemUsageRepository.Save(); transaction.Commit(); } }
/// <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 (ItInterface != null && ItInterface.HasUserWriteAccess(user)) { return(true); } return(base.HasUserWriteAccess(user)); }
public void ChangeExposingSystem_Returns_Forbidden_If_Modification_Access_To_Interface_Is_Denied() { //Arrange var interfaceId = A <int>(); var itInterface = new ItInterface(); ExpectGetInterfaceReturns(interfaceId, itInterface); ExpectAllowModifyReturns(itInterface, false); //Act var result = _sut.ChangeExposingSystem(interfaceId, A <int>()); //Assert Assert.Equal(OperationFailure.Forbidden, result.Error); }
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); }
private SystemRelation CreateRelation(ItInterface affectedInterface) { var fromSystemUsage = new ItSystemUsage { Id = A <int>() }; var systemRelation = new SystemRelation(fromSystemUsage) { RelationInterface = affectedInterface, ToSystemUsage = new ItSystemUsage { Id = A <int>() } }; fromSystemUsage.UsageRelations.Add(systemRelation); return(systemRelation); }
public void ChangeExposingSystem_Returns_BadInput_If_System_Id_Is_Invalid() { //Arrange var interfaceId = A <int>(); var itInterface = new ItInterface(); var newSystemId = A <int>(); ExpectGetInterfaceReturns(interfaceId, itInterface); ExpectAllowModifyReturns(itInterface, true); ExpectGetSystemReturns(newSystemId, default(ItSystem)); //Act var result = _sut.ChangeExposingSystem(interfaceId, newSystemId); //Assert Assert.Equal(OperationFailure.BadInput, result.Error); }
public async Task ExecuteAsync_Checks_System_And_Interface_External_Links_And_Replaces_Report() { //Arrange var includedInterfaceWhichFails = new ItInterface { Url = $"https://www.test-interface.com/{A<int>()}" }; var includedInterfaceWhichDoesNotFail = new ItInterface { Url = $"https://www.test-interface.com/{A<int>()}" }; var excludedInterface = new ItInterface { Url = null }; var excludedReference = new ExternalReference { URL = $"{_rootUrl.Url.AbsoluteUri}/internal-links-are-ignored" }; var includedReferenceWhichFails = new ExternalReference { URL = $"https://www.test-system.com/{A<int>()}" }; var includedReferenceWhichDoesNotFail = new ExternalReference { URL = $"https://www.test-system.com/{A<int>()}" }; _interfaceRepository.Setup(x => x.GetInterfacesWithExternalReferenceDefined()).Returns(new[] { includedInterfaceWhichFails, includedInterfaceWhichDoesNotFail, excludedInterface }.AsQueryable()); _referenceRepository.Setup(x => x.GetByRootType(ReferenceRootType.System)).Returns(new[] { excludedReference, includedReferenceWhichFails, includedReferenceWhichDoesNotFail }.AsQueryable()); var expectedInterfaceError = new EndpointValidationError(EndpointValidationErrorType.CommunicationError); var expectedReferenceError = new EndpointValidationError(EndpointValidationErrorType.ErrorResponseCode, HttpStatusCode.NotFound); ExpectEndpointValidationResult(includedInterfaceWhichFails.Url, expectedInterfaceError); ExpectEndpointValidationResult(includedInterfaceWhichDoesNotFail.Url); ExpectEndpointValidationResult(includedReferenceWhichFails.URL, expectedReferenceError); ExpectEndpointValidationResult(includedReferenceWhichDoesNotFail.URL); //Act var result = await _sut.ExecuteAsync(); //Assert Assert.True(result.Ok); _brokenExternalReferencesReportRepository.Verify( x => x.ReplaceCurrentReport(It.Is <BrokenExternalReferencesReport>(report => ValidateNewReport(report, includedInterfaceWhichFails, expectedInterfaceError, BrokenLinkCause.CommunicationError, includedReferenceWhichFails, expectedReferenceError, BrokenLinkCause.ErrorResponse))), Times.Once); }
public void Delete_Returns_Forbidden() { //Arrange var interfaceId = A <int>(); var itInterface = new ItInterface() { InterfaceId = interfaceId }; ExpectGetInterfaceReturns(interfaceId, itInterface); ExpectAllowDeleteReturns(itInterface, false); //Act var result = _sut.Delete(interfaceId); //Assert Assert.False(result.Ok); Assert.Equal(OperationFailure.Forbidden, result.Error); }
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 Delete_Returns_Conflict_If_Interface_Is_Exhibited() { //Arrange var interfaceId = A <int>(); var itInterface = new ItInterface { InterfaceId = interfaceId, ExhibitedBy = new ItInterfaceExhibit() }; ExpectGetInterfaceReturns(interfaceId, itInterface); ExpectAllowDeleteReturns(itInterface, true); //Act var result = _sut.Delete(interfaceId); //Assert Assert.False(result.Ok); Assert.Equal(OperationFailure.Conflict, result.Error); }
private void Handle_InterfaceDeleted_Resets_Interface_On_Associated_Relations() { //Arrange var affectedInterface = new ItInterface(); affectedInterface.AssociatedSystemRelations = new List <SystemRelation>() { CreateRelation(affectedInterface), CreateRelation(affectedInterface), }; var transaction = new Mock <IDatabaseTransaction>(); _transactionManager.Setup(x => x.Begin(IsolationLevel.ReadCommitted)).Returns(transaction.Object); //Act _sut.Handle(new EntityDeletedEvent <ItInterface>(affectedInterface)); //Assert that all interface fields were reset Assert.True(affectedInterface.AssociatedSystemRelations.All(x => x.RelationInterface == null)); _systemUsageRepository.Verify(x => x.Save(), Times.Once); transaction.Verify(x => x.Commit(), Times.Once); }
public void Delete_Returns_Ok_And_Raises_Domain_Event() { //Arrange var interfaceId = A <int>(); var dataRow1 = new DataRow { Id = A <int>() }; var dataRow2 = new DataRow { Id = A <int>() }; var interfaceToDelete = new ItInterface { InterfaceId = interfaceId, DataRows = new List <DataRow>() { dataRow1, dataRow2 } }; var transaction = new Mock <IDatabaseTransaction>(); ExpectGetInterfaceReturns(interfaceId, interfaceToDelete); ExpectAllowDeleteReturns(interfaceToDelete, true); _transactionManager.Setup(x => x.Begin(IsolationLevel.Serializable)).Returns(transaction.Object); //Act var result = _sut.Delete(interfaceId); //Assert Assert.True(result.Ok); _domainEvents.Verify(x => x.Raise(It.Is <EntityDeletedEvent <ItInterface> >(d => d.Entity == interfaceToDelete)), Times.Once); _dataRowRepository.Verify(x => x.DeleteByKey(dataRow1.Id), Times.Once); _dataRowRepository.Verify(x => x.DeleteByKey(dataRow2.Id), Times.Once); _dataRowRepository.Verify(x => x.Save(), Times.Once); _interfaceRepository.Verify(x => x.DeleteWithReferencePreload(interfaceToDelete), Times.Once); _interfaceRepository.Verify(x => x.Save(), Times.Once); transaction.Verify(x => x.Commit(), Times.Once); }
public ExposingSystemChanged(ItInterface affectedInterface, Maybe <ItSystem> previousSystem, Maybe <ItSystem> newSystem) { AffectedInterface = affectedInterface; PreviousSystem = previousSystem; NewSystem = newSystem; }
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); }
private void ExpectGetInterfaceReturns(int interfaceId, ItInterface value) { _interfaceRepository.Setup(x => x.GetByKey(interfaceId)).Returns(value); }
private void ExpectAllowDeleteReturns(ItInterface itInterface, bool value) { _authorizationContext.Setup(x => x.AllowDelete(itInterface)).Returns(value); }