private static EconomyYear CreateEconomyYear(ItProject project, int yearNumber)
{
return(new EconomyYear
{
YearNumber = yearNumber,
});
}
public void DeleteHandoverParticipant_Returns_BadInput_If_Participant_Not_Found_In_Handover_Participants()
{
//Arrange
var projectId = A <int>();
var participantId = A <int>();
var user = new User {
Id = participantId
};
var itProject = new ItProject {
Handover = new Handover {
Participants = new List <User> {
new User()
{
Id = A <int>()
}
}
}
};
ExpectGetProjectByIdReturns(projectId, itProject);
ExpectAllowModifyProjectReturns(itProject, true);
ExpectGetUserReturns(participantId, user);
//Act
var result = _sut.DeleteHandoverParticipant(projectId, participantId);
//Assert
Assert.False(result.Ok);
Assert.Equal(OperationFailure.BadInput, result.Error);
}
public void DeleteHandoverParticipant_Returns_Success()
{
//Arrange
var projectId = A <int>();
var participantId = A <int>();
var user = new User()
{
Id = participantId
};
var itProject = new ItProject()
{
Handover = new Handover()
{
Participants = new List <User>()
{
new User()
{
Id = A <int>()
}, user
}
}
};
ExpectGetProjectByIdReturns(projectId, itProject);
ExpectAllowModifyProjectReturns(itProject, true);
ExpectGetUserReturns(participantId, user);
//Act
var result = _sut.DeleteHandoverParticipant(projectId, participantId);
//Assert
Assert.True(result.Ok);
Assert.False(itProject.Handover.Participants.Contains(user));
_itProjectRepo.Verify(x => x.Save(), Times.Once);
}
public void DeleteProject_Returns_Ok()
{
//Arrange
var id = A <int>();
var databaseTransaction = new Mock <IDatabaseTransaction>();
var itProject = new ItProject()
{
Handover = new Handover()
{
Participants = new List <User>()
{
new User()
}
}
};
_itProjectRepo.Setup(x => x.GetByKey(id)).Returns(itProject);
_authorizationContext.Setup(x => x.AllowDelete(itProject)).Returns(true);
_transactionManager.Setup(x => x.Begin(IsolationLevel.ReadCommitted)).Returns(databaseTransaction.Object);
_referenceService.Setup(x => x.DeleteByProjectId(id)).Returns(Result <IEnumerable <ExternalReference>, OperationFailure> .Success(new ExternalReference[0]));
//Act
var result = _sut.DeleteProject(id);
//Assert
Assert.True(result.Ok);
_itProjectRepo.Verify(x => x.DeleteWithReferencePreload(itProject), Times.Once);
_itProjectRepo.Verify(x => x.Save(), Times.Once);
databaseTransaction.Verify(x => x.Commit(), Times.Once);
Assert.Empty(itProject.Handover.Participants); //Make sure participants were emptied prior to deletion
}
public void AddHandoverParticipant_Returns_Conflict_If_Participant_Already_Added()
{
//Arrange
var projectId = A <int>();
var participantId = A <int>();
var user = new User()
{
Id = participantId
};
var itProject = new ItProject()
{
Handover = new Handover()
{
Participants = new List <User>()
{
user
}
}
};
ExpectGetProjectByIdReturns(projectId, itProject);
ExpectAllowModifyProjectReturns(itProject, true);
ExpectGetUserReturns(participantId, user);
//Act
var result = _sut.AddHandoverParticipant(projectId, participantId);
//Assert
Assert.False(result.Ok);
Assert.Equal(OperationFailure.Conflict, result.Error);
}
public static ItProject Create(string name, int organizationId)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
var itProject = new ItProject
{
Name = name,
OrganizationId = organizationId,
};
InitializeAccessModifier(itProject);
InitializePhases(itProject);
InitializeEconomyYears(itProject);
InitializeHandover(itProject);
InitializeGoalStatus(itProject);
return(itProject);
}
private static void InitializePhases(ItProject itProject)
{
itProject.CurrentPhase = 1;
itProject.Phase1 = CreateItProjectPhase(PhaseNames.Phase1);
itProject.Phase2 = CreateItProjectPhase(PhaseNames.Phase2);
itProject.Phase3 = CreateItProjectPhase(PhaseNames.Phase3);
itProject.Phase4 = CreateItProjectPhase(PhaseNames.Phase4);
itProject.Phase5 = CreateItProjectPhase(PhaseNames.Phase5);
}
/// <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 (ItProject != null && ItProject.HasUserWriteAccess(user))
{
return(true);
}
return(base.HasUserWriteAccess(user));
}
private static void InitializeEconomyYears(ItProject project)
{
project.EconomyYears = new List <EconomyYear>
{
CreateEconomyYear(project, 0),
CreateEconomyYear(project, 1),
CreateEconomyYear(project, 2),
CreateEconomyYear(project, 3),
CreateEconomyYear(project, 4),
CreateEconomyYear(project, 5)
};
}
public void DeleteProject_Returns_Forbidden()
{
//Arrange
var id = A <int>();
var itProject = new ItProject();
_itProjectRepo.Setup(x => x.GetByKey(id)).Returns(itProject);
_authorizationContext.Setup(x => x.AllowDelete(itProject)).Returns(false);
//Act
var result = _sut.DeleteProject(id);
//Assert
Assert.False(result.Ok);
Assert.Equal(OperationFailure.Forbidden, result.Error);
}
public void DeleteHandoverParticipant_Returns_Forbidden()
{
//Arrange
var projectId = A <int>();
var participantId = A <int>();
var itProject = new ItProject();
ExpectGetProjectByIdReturns(projectId, itProject);
ExpectAllowModifyProjectReturns(itProject, false);
//Act
var result = _sut.DeleteHandoverParticipant(projectId, participantId);
//Assert
Assert.False(result.Ok);
Assert.Equal(OperationFailure.Forbidden, result.Error);
}
public void DeleteHandoverParticipant_Returns_BadInput_If_User_Not_Found()
{
//Arrange
var projectId = A <int>();
var participantId = A <int>();
var itProject = new ItProject();
ExpectGetProjectByIdReturns(projectId, itProject);
ExpectAllowModifyProjectReturns(itProject, true);
ExpectGetUserReturns(participantId, default(User));
//Act
var result = _sut.DeleteHandoverParticipant(projectId, participantId);
//Assert
Assert.False(result.Ok);
Assert.Equal(OperationFailure.BadInput, result.Error);
}
private ItProject CreateItProject(AccessModifier accessModifier, bool hasAssignedWriteAccess)
{
var itProject = new ItProject
{
AccessModifier = accessModifier
};
if (hasAssignedWriteAccess)
{
itProject.Rights = new List <ItProjectRight>()
{
new() { UserId = _userId, Role = new ItProjectRole {
HasWriteAccess = true
} },
};
}
return(itProject);
}
private Maybe <OperationFailure> CanAddParticipant(ItProject itProject, User user)
{
if (itProject == null)
{
return(OperationFailure.NotFound);
}
if (!_authorizationContext.AllowModify(itProject))
{
return(OperationFailure.Forbidden);
}
if (user == null)
{
return(OperationFailure.BadInput);
}
if (itProject.Handover.Participants.Any(p => p.Id == user.Id))
{
return(OperationFailure.Conflict);
}
return(Maybe <OperationFailure> .None);
}
public void UpdateKLE_Given_Summary_Updates_ItProject()
{
//Arrange
var updateObjects = SetupUpdateObjects();
const int itProjectKey = 1;
var itProject = new ItProject
{
Id = itProjectKey,
TaskRefs = new List <TaskRef> {
updateObjects.removedTaskRef
}
};
updateObjects.removedTaskRef.ItProjects = new List <ItProject> {
itProject
};
//Act
_sut.UpdateKLE(0);
//Assert
Assert.False(itProject.TaskRefs.Contains(updateObjects.removedTaskRef));
}
private void ExpectAllowModifyProjectReturns(ItProject itProject, bool value)
{
_authorizationContext.Setup(x => x.AllowModify(itProject)).Returns(value);
}
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 ExpectGetProjectReturns(int id, ItProject project)
{
_projectRepository.Setup(x => x.GetById(id)).Returns(project);
}
private void ExpectGetProjectByIdReturns(int projectId, ItProject itProject)
{
_specificProjectRepo.Setup(x => x.GetById(projectId)).Returns(itProject);
}
private static void InitializeAccessModifier(ItProject itProject)
{
itProject.AccessModifier = AccessModifier.Local;
}
private static void InitializeGoalStatus(ItProject itProject)
{
itProject.GoalStatus = new GoalStatus();
}
private static void InitializeHandover(ItProject itProject)
{
itProject.Handover = new Handover();
}
