public async Task Delete_SystemRelation_Returns_204()
{
//Arrange
var system1 = await ItSystemHelper.CreateItSystemInOrganizationAsync(CreateName(), OrganizationId, AccessModifier.Public);
var system2 = await ItSystemHelper.CreateItSystemInOrganizationAsync(CreateName(), OrganizationId, AccessModifier.Public);
var usage1 = await ItSystemHelper.TakeIntoUseAsync(system1.Id, OrganizationId);
var usage2 = await ItSystemHelper.TakeIntoUseAsync(system2.Id, OrganizationId);
var input = new CreateSystemRelationDTO
{
FromUsageId = usage1.Id,
ToUsageId = usage2.Id,
Description = A <string>(),
Reference = A <string>(),
};
using (var response = await SystemRelationHelper.SendPostRelationRequestAsync(input))
{
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var createdRelation = await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
//Act
using (var deleteResponse = await SystemRelationHelper.SendDeleteRelationRequestAsync(usage1.Id, createdRelation.Id))
{
//Assert
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
}
}
public async Task Deleting_Contract_Clears_ContractField_In_All_AssociatedRelations()
{
//Arrange
var input = await PrepareFullRelationAsync(true, false, false);
//Act
using (var response = await SystemRelationHelper.SendPostRelationRequestAsync(input))
{
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var relation = await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.NotNull(relation.Contract);
using (var deleteContractRequest = await ItContractHelper.SendDeleteContractRequestAsync(input.ContractId.GetValueOrDefault()))
using (var getAfterDeleteResponse = await SystemRelationHelper.SendGetRelationRequestAsync(input.FromUsageId, relation.Id))
{
//Assert
Assert.Equal(HttpStatusCode.OK, deleteContractRequest.StatusCode);
Assert.Equal(HttpStatusCode.OK, getAfterDeleteResponse.StatusCode);
var relationAfterChange = await getAfterDeleteResponse.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.Null(relationAfterChange.Contract);
}
}
}
public async Task Deleting_Interface_Clears_InterfaceField_In_All_Relations_To_Old_Exposing_System()
{
//Arrange
var input = await PrepareFullRelationAsync(false, false, true);
//Act
using (var response = await SystemRelationHelper.SendPostRelationRequestAsync(input))
{
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var relation = await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.NotNull(relation.Interface);
using (var removeExhibitResponse = await InterfaceExhibitHelper.SendRemoveExhibitRequest(input.InterfaceId.GetValueOrDefault())) //Must remove exposition to allow deletion
using (var deleteInterfaceResponse = await InterfaceHelper.SendDeleteInterfaceRequestAsync(input.InterfaceId.GetValueOrDefault()))
using (var getAfterDeleteResponse = await SystemRelationHelper.SendGetRelationRequestAsync(input.FromUsageId, relation.Id))
{
//Assert
Assert.Equal(HttpStatusCode.OK, removeExhibitResponse.StatusCode);
Assert.Equal(HttpStatusCode.OK, deleteInterfaceResponse.StatusCode);
Assert.Equal(HttpStatusCode.OK, getAfterDeleteResponse.StatusCode);
var relationAfterChange = await getAfterDeleteResponse.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.Null(relationAfterChange.Interface);
}
}
}
public async Task Post_SystemRelation_Returns_201(bool withContract, bool withInterface, bool withFrequency)
{
//Arrange
var input = await PrepareFullRelationAsync(withContract, withInterface, withFrequency);
//Act
using (var response = await SystemRelationHelper.SendPostRelationRequestAsync(input))
{
//Assert
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var relationsFrom = (await SystemRelationHelper.GetRelationsFromAsync(input.FromUsageId)).ToList();
var relationsTo = (await SystemRelationHelper.GetRelationsToAsync(input.ToUsageId)).ToList();
var fromDto = Assert.Single(relationsFrom);
var toDto = Assert.Single(relationsTo);
fromDto.ToExpectedObject().ShouldMatch(toDto); //Same relation should yield same data at the dto level
Assert.Equal(input.FromUsageId, fromDto.FromUsage.Id);
Assert.Equal(input.ToUsageId, fromDto.ToUsage.Id);
Assert.Equal(input.Description, fromDto.Description);
Assert.Equal(input.Reference, fromDto.Reference);
Assert.Equal(input.ContractId, fromDto.Contract?.Id);
Assert.Equal(input.InterfaceId, fromDto.Interface?.Id);
Assert.Equal(input.FrequencyTypeId, fromDto.FrequencyType?.Id);
}
}
public async Task Changing_Exposing_System_On_Interface_Clears_InterfaceField_In_All_Relations_To_Old_Exposing_System()
{
//Arrange
var newExhibitor = await ItSystemHelper.CreateItSystemInOrganizationAsync(A <string>(), TestEnvironment.DefaultOrganizationId, AccessModifier.Public);
var input = await PrepareFullRelationAsync(false, false, true);
//Act
using (var response = await SystemRelationHelper.SendPostRelationRequestAsync(input))
using (var changeExposingSystem = await InterfaceExhibitHelper.SendCreateExhibitRequest(newExhibitor.Id, input.InterfaceId.GetValueOrDefault()))
{
//Assert
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal(HttpStatusCode.Created, changeExposingSystem.StatusCode);
var relation = await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.NotNull(relation.Interface);
using (var getAfterDeleteResponse = await SystemRelationHelper.SendGetRelationRequestAsync(input.FromUsageId, relation.Id))
{
Assert.Equal(HttpStatusCode.OK, getAfterDeleteResponse.StatusCode);
var relationAfterChange = await getAfterDeleteResponse.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.Null(relationAfterChange.Interface);
}
}
}
public async Task Changing_Exposing_System_To_Same_As_Existing_Does_Nothing()
{
//Arrange
var input = await PrepareFullRelationAsync(false, false, true);
var toUsage = await ItSystemHelper.GetItSystemUsage(input.ToUsageId);
//Act
using (var response = await SystemRelationHelper.SendPostRelationRequestAsync(input))
using (var changeExposingSystem = await InterfaceExhibitHelper.SendCreateExhibitRequest(toUsage.ItSystemId, input.InterfaceId.GetValueOrDefault()))
{
//Assert
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal(HttpStatusCode.Created, changeExposingSystem.StatusCode);
var relation = await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.NotNull(relation.Interface);
using (var getAfterDeleteResponse = await SystemRelationHelper.SendGetRelationRequestAsync(input.FromUsageId, relation.Id))
{
Assert.Equal(HttpStatusCode.OK, getAfterDeleteResponse.StatusCode);
var relationAfterChange = await getAfterDeleteResponse.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.NotNull(relationAfterChange.Interface); //interface should not have been cleared since the same exhibitor was provided as the existing --> no change
}
}
}
public async Task Can_Edit_SystemUsageWithRelations_Resets_Interface()
{
//Arrange
var input = await PrepareFullRelationAsync(true, true, true);
await SystemRelationHelper.SendPostRelationRequestAsync(input);
var relations = await SystemRelationHelper.GetRelationsFromAsync(input.FromUsageId);
var relationToEdit = relations.Single();
var edited = PrepareEditedRelation(relationToEdit, relationToEdit.ToUsage, relationToEdit.Contract, relationToEdit.FrequencyType, null);
//Act
using (var response = await SystemRelationHelper.SendPatchRelationRequestAsync(edited))
{
//Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var relationDTO = await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.Equal(input.FromUsageId, relationDTO.FromUsage.Id);
Assert.Equal(edited.ToUsage.Id, relationDTO.ToUsage.Id);
Assert.Equal(edited.Description, relationDTO.Description);
Assert.Equal(edited.Reference, relationDTO.Reference);
Assert.NotNull(relationDTO.FrequencyType);
Assert.NotNull(relationDTO.Contract);
Assert.Null(relationDTO.Interface);
}
}
public async Task Can_Get_AvailableDestinationSystems()
{
//Arrange
var prefix = CreateName();
var source = await ItSystemHelper.CreateItSystemInOrganizationAsync(CreateName(), OrganizationId, AccessModifier.Public);
var target1 = await ItSystemHelper.CreateItSystemInOrganizationAsync(prefix + 1, OrganizationId, AccessModifier.Public);
var target2 = await ItSystemHelper.CreateItSystemInOrganizationAsync(prefix + 2, OrganizationId, AccessModifier.Public);
var ignoredSystem = await ItSystemHelper.CreateItSystemInOrganizationAsync(CreateName(), OrganizationId, AccessModifier.Public);
var sourceUsage = await ItSystemHelper.TakeIntoUseAsync(source.Id, OrganizationId);
var targetUsage1 = await ItSystemHelper.TakeIntoUseAsync(target1.Id, OrganizationId);
var targetUsage2 = await ItSystemHelper.TakeIntoUseAsync(target2.Id, OrganizationId);
await ItSystemHelper.TakeIntoUseAsync(ignoredSystem.Id, OrganizationId);
//Act
var availableDestinationSystems = (await SystemRelationHelper.GetAvailableDestinationSystemsAsync(sourceUsage.Id, prefix))?.ToList();
//Assert
Assert.NotNull(availableDestinationSystems);
Assert.Equal(2, availableDestinationSystems.Count);
Assert.True(new[] { targetUsage1.Id, targetUsage2.Id }.SequenceEqual(availableDestinationSystems.Select(x => x.Id)));
}
private static async Task AssertRelationExists(SystemRelationDTO expectedRelation, ItSystemUsageDTO usage, bool hasInterface = false, bool hasFrequency = false, bool hasContract = false)
{
var response = await SystemRelationHelper.SendGetRelationRequestAsync(usage.Id, expectedRelation.Id);
var relation = await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
Assert.Equal(expectedRelation.Id, relation.Id);
Assert.Equal(expectedRelation.Description, relation.Description);
if (hasInterface)
{
AssertEqualNamedEntities(expectedRelation.Interface, relation.Interface);
}
else
{
Assert.Null(relation.Interface);
}
if (hasFrequency)
{
AssertEqualNamedEntities(expectedRelation.FrequencyType, relation.FrequencyType);
}
else
{
Assert.Null(relation.FrequencyType);
}
if (hasContract)
{
AssertEqualNamedEntities(expectedRelation.Contract, relation.Contract);
}
else
{
Assert.Null(relation.Contract);
}
}
public async Task Can_Delete_SystemUsageWithRelations()
{
//Arrange
var input = await PrepareFullRelationAsync(false, false, false);
using (await SystemRelationHelper.SendPostRelationRequestAsync(input))
using (var deletionResponse = await ItSystemHelper.SendRemoveUsageAsync(input.FromUsageId, OrganizationId))
using (var getAfterDeleteResponse = await SystemRelationHelper.SendGetRelationRequestAsync(input.FromUsageId, OrganizationId))
{
Assert.Equal(HttpStatusCode.OK, deletionResponse.StatusCode);
Assert.Equal(HttpStatusCode.NotFound, getAfterDeleteResponse.StatusCode);
}
}
public async Task Can_Get_AvailableOptions()
{
//Arrange
var input = await PrepareFullRelationAsync(true, true, true);
//Act
var options = await SystemRelationHelper.GetAvailableOptionsAsync(input.FromUsageId, input.ToUsageId);
//Assert
Assert.NotNull(options);
var interfaceDTO = Assert.Single(options.AvailableInterfaces);
Assert.Equal(input.InterfaceId.Value, interfaceDTO.Id);
Assert.Contains(options.AvailableContracts.Select(x => x.Id), x => x == input.ContractId);
Assert.Contains(options.AvailableFrequencyTypes.Select(x => x.Id), x => x == input.FrequencyTypeId);
}
public async Task Can_Get_SystemRelations_AssociatedWithContract()
{
//Arrange
var input = await PrepareFullRelationAsync(true, false, false);
//Act
using (var response = await SystemRelationHelper.SendPostRelationRequestAsync(input))
{
//Assert
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var relationsToContract = (await SystemRelationHelper.GetRelationsAssociatedWithContractAsync(input.ContractId.GetValueOrDefault(-1))).ToList();
var originalRelations = (await SystemRelationHelper.GetRelationsFromAsync(input.FromUsageId)).ToList();
var relationFromContractResponse = Assert.Single(relationsToContract);
var relationFromOriginalResponse = Assert.Single(originalRelations);
relationFromContractResponse.ToExpectedObject().ShouldMatch(relationFromOriginalResponse); //Same relation should yield same data at the dto level
}
}
public async Task Deleting_ToSystemUsage_Removes_Relation()
{
//Arrange
var input = await PrepareFullRelationAsync(false, false, false);
//Act
using (var response = await SystemRelationHelper.SendPostRelationRequestAsync(input))
{
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var relation = await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>();
using (var deleteUsageResponse = await ItSystemHelper.SendRemoveUsageAsync(input.ToUsageId, TestEnvironment.DefaultOrganizationId))
{
//Assert
Assert.Equal(HttpStatusCode.OK, deleteUsageResponse.StatusCode);
var relations = (await SystemRelationHelper.GetRelationsFromAsync(input.FromUsageId)).ToList();
Assert.Empty(relations.Where(x => x.Id == relation.Id));
}
}
}
private static async Task <SystemRelationDTO> CreateSystemRelation(
int fromSystemId,
int toSystemId,
string description,
int?interfaceId,
int?frequencyTypeId,
int?contractId)
{
var relationDTO = new CreateSystemRelationDTO()
{
FromUsageId = fromSystemId,
ToUsageId = toSystemId,
Description = description,
InterfaceId = interfaceId,
FrequencyTypeId = frequencyTypeId,
ContractId = contractId
};
var response = await SystemRelationHelper.SendPostRelationRequestAsync(relationDTO);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
return(await response.ReadResponseBodyAsKitosApiResponseAsync <SystemRelationDTO>());
}
public async Task Can_Get_SystemRelations_Defined_In_Organization()
{
//Arrange
var input1 = await PrepareFullRelationAsync(false, false, false);
var input2 = await PrepareFullRelationAsync(false, false, false);
var input3 = await PrepareFullRelationAsync(false, false, false);
var input4 = await PrepareFullRelationAsync(false, false, false);
await SystemRelationHelper.PostRelationAsync(input1);
await SystemRelationHelper.PostRelationAsync(input2);
await SystemRelationHelper.PostRelationAsync(input3);
await SystemRelationHelper.PostRelationAsync(input4);
const int pageSize = 2;
const int firstPageNumber = 0;
const int secondPageNumber = firstPageNumber + 1;
var twoPages = (await SystemRelationHelper.GetRelationsDefinedInOrganization(TestEnvironment.DefaultOrganizationId, firstPageNumber, pageSize * 2)).ToList();
Assert.Equal(pageSize * 2, twoPages.Count); //We expect all 4 to be there
//Act
var firstPage = await SystemRelationHelper.GetRelationsDefinedInOrganization(TestEnvironment.DefaultOrganizationId, firstPageNumber, pageSize);
var secondPage = await SystemRelationHelper.GetRelationsDefinedInOrganization(TestEnvironment.DefaultOrganizationId, secondPageNumber, pageSize);
//Assert - first page with 2 items
Assert.Equal(twoPages.Take(pageSize).Select(x => x.Id), firstPage.Select(x => x.Id));
//Assert - second page with 1 item since there are only 3 in total
Assert.Equal(twoPages.Skip(pageSize).Take(pageSize).Select(x => x.Id).ToList(), secondPage.Select(x => x.Id).ToList());
}
