public async Task ThenItShouldPostSearchRequestToManagementGroupsEndpoint(LoadManagementGroupsRequest request)
{
request.AggregatesRequest = null;
await _repository.LoadManagementGroupsAsync(request, _cancellationToken);
var expectedTranslatedRequest = new GetSquashedEntitiesRequest
{
EntityName = request.EntityName,
EntityReferences = request.EntityReferences.Select(er =>
new SquasherEntityReference
{
AdapterRecordReferences = er.AdapterRecordReferences.Select(arr =>
new SquasherAdapterReference
{
SourceSystemName = arr.SourceSystemName,
SourceSystemId = arr.SourceSystemId,
}).ToArray(),
}).ToArray(),
Fields = request.Fields,
Live = request.Live,
PointInTime = request.PointInTime,
};
Func <Parameter, bool> isExpectedBody = (body) =>
body != null &&
(string)body.Value == JsonConvert.SerializeObject(expectedTranslatedRequest);
Expression <Func <IRestRequest, bool> > isExpectedRequest = (req) =>
req.Method == Method.POST &&
req.Resource == "get-squashed-entity" &&
isExpectedBody(req.Parameters.SingleOrDefault(p => p.Type == ParameterType.RequestBody));
_restClientMock.Verify(c => c.ExecuteTaskAsync(It.Is(isExpectedRequest), _cancellationToken),
Times.Once);
}
public async Task ThenItShouldReturnDeserializedResponseFromApi(LoadManagementGroupsRequest request,
EntityCollection <ManagementGroup> results)
{
_restClientMock.Setup(c => c.ExecuteTaskAsync(It.IsAny <RestRequest>(), _cancellationToken))
.ReturnsAsync(new RestResponse
{
Content = JsonConvert.SerializeObject(results),
StatusCode = HttpStatusCode.OK,
ResponseStatus = ResponseStatus.Completed,
});
var actual = await _repository.LoadManagementGroupsAsync(request, _cancellationToken);
Assert.IsNotNull(actual);
Assert.AreEqual(results.SquashedEntityResults.Length, actual.SquashedEntityResults.Length);
for (var i = 0; i < results.SquashedEntityResults.Length; i++)
{
var expectedEntity = results.SquashedEntityResults[i].SquashedEntity;
var actualEntity = actual.SquashedEntityResults[i].SquashedEntity;
Assert.AreEqual(expectedEntity.Name, actualEntity.Name,
$"Expected entity {i} to have Name {expectedEntity.Name} but was {actualEntity.Name}");
Assert.AreEqual(expectedEntity.Type, actualEntity.Type,
$"Expected entity {i} to have Type {expectedEntity.Type} but was {actualEntity.Type}");
Assert.AreEqual(expectedEntity.Identifier, actualEntity.Identifier,
$"Expected entity {i} to have Identifier {expectedEntity.Identifier} but was {actualEntity.Identifier}");
Assert.AreEqual(expectedEntity.Code, actualEntity.Code,
$"Expected entity {i} to have Code {expectedEntity.Code} but was {actualEntity.Code}");
Assert.AreEqual(expectedEntity.CompaniesHouseNumber, actualEntity.CompaniesHouseNumber,
$"Expected entity {i} to have CompaniesHouseNumber {expectedEntity.CompaniesHouseNumber} but was {actualEntity.CompaniesHouseNumber}");
}
}
private async Task <SquashedEntityResult <ManagementGroup>[]> LoadManagementGroupsAsync(
EntityLinkBatchResult[] links,
string[] fields,
DateTime?pointInTime,
CancellationToken cancellationToken)
{
_logger.Debug($"Loading {links.Length} management groups");
// Get distinct list of pointers to squash (multiple providers might be linked to same management group)
var managementGroupPointers = links
.Where(result => result.Links != null)
.SelectMany(result => result.Links.Select(link =>
new EntityReference
{
SourceSystemName = link.SourceSystemName,
SourceSystemId = link.SourceSystemId,
}))
.GroupBy(x => $"{x.SourceSystemName.ToLower()}:{x.SourceSystemId.ToLower()}")
.Select(x => new AggregateEntityReference
{
AdapterRecordReferences = new[]
{
x.First(),
},
})
.ToArray();
// If there are not references then don't try loading
if (managementGroupPointers.Length == 0)
{
return(new SquashedEntityResult <ManagementGroup> [0]);
}
// Got to Squash'em all
var request = new LoadManagementGroupsRequest()
{
EntityReferences = managementGroupPointers.ToArray(),
Fields = fields,
Live = _executionContextManager.GraphExecutionContext.QueryLive,
PointInTime = pointInTime,
};
var entityCollection = await _entityRepository.LoadManagementGroupsAsync(request, cancellationToken);
return(entityCollection.SquashedEntityResults);
}
private async Task <ManagementGroup[]> LoadAsync(
AggregateEntityReference[] references,
Dictionary <string, object> arguments,
string[] fields,
CancellationToken cancellationToken)
{
if (references.Length == 0)
{
return(new ManagementGroup[0]);
}
var request = new LoadManagementGroupsRequest
{
EntityReferences = references,
Fields = fields,
Live = _executionContextManager.GraphExecutionContext.QueryLive,
PointInTime = arguments.GetPointInTimeArgument(),
};
var loadResult = await _entityRepository.LoadManagementGroupsAsync(request, cancellationToken);
return(loadResult.SquashedEntityResults.Select(x => x.SquashedEntity).ToArray());
}
public async Task <EntityCollection <ManagementGroup> > LoadManagementGroupsAsync(LoadManagementGroupsRequest request, CancellationToken cancellationToken)
{
return(await LoadAsync <ManagementGroup>(request, cancellationToken));
}
