public void SetFilters_Returns_Empty_String_For_No_Filter()
{
var searchModel = new LearningAimsSearchModel();
var oDataQuery = string.Empty;
var frameworkFilterMock = new Mock <IFrameworkODataFilter>();
var frameworkFilters = new List <IFrameworkODataFilter> {
frameworkFilterMock.Object
};
var standardsFilterMock = new Mock <IStandardODataFilter>();
var standardsFilters = new List <IStandardODataFilter> {
standardsFilterMock.Object
};
var filterMock = new Mock <ILearningAimsODataFilter>();
filterMock
.Setup(m => m.ApplyFilter(searchModel))
.Returns(oDataQuery);
var oDataLevelFilters = new List <ILearningAimsODataFilter>
{
filterMock.Object
};
var parameters = new SearchParameters();
var queryService = new ODataQueryService(oDataLevelFilters, frameworkFilters, standardsFilters);
queryService.SetLearningAimFilters(searchModel, parameters);
parameters.Filter.Should().Be(oDataQuery);
}
public LearningAimsSearchModel GetLearningAimsSearchModel(BasicSearchModel basicSearchModel)
{
var searchModel = new LearningAimsSearchModel();
if (!string.IsNullOrEmpty(basicSearchModel.SearchTerm))
{
searchModel.SearchTerm = basicSearchModel.SearchTerm;
}
if (!string.IsNullOrEmpty(basicSearchModel.Level))
{
searchModel.Levels.Add(basicSearchModel.Level);
}
if (!string.IsNullOrEmpty(basicSearchModel.AwardingBody))
{
searchModel.AwardingBodies.Add(basicSearchModel.AwardingBody);
}
if (!string.IsNullOrEmpty(basicSearchModel.TeachingYear))
{
searchModel.TeachingYears.Add(basicSearchModel.TeachingYear);
}
return(searchModel);
}
public async Task GetLarsLearningDeliveries_Returns_Valid_Aims()
{
var learnAimRef = "12345678";
var azureLearningAim = new LearningAimModel
{
LearnAimRef = learnAimRef
};
var apiLearningAim = new Models.LearningAimModel
{
LearnAimRef = learnAimRef
};
var searchModel = new LearningAimsSearchModel
{
SearchTerm = learnAimRef
};
var searchResult = new DocumentSearchResult <LearningAimModel>(
new List <SearchResult <LearningAimModel> >
{
new SearchResult <LearningAimModel>(azureLearningAim)
},
1,
0,
null,
SearchContinuationToken.CreateTestToken("foo"));
var mapperMock = new Mock <IMapper <LearningAimModel, Models.LearningAimModel> >();
mapperMock.Setup(m => m.Map(azureLearningAim)).Returns(apiLearningAim);
var indexServiceMock = new Mock <ILearningDeliveryIndexService>();
var azureServiceMock = new Mock <IAzureService>();
azureServiceMock
.Setup(m => m.SearchIndexAsync <LearningAimModel>(indexServiceMock.Object, learnAimRef, It.IsAny <SearchParameters>()))
.ReturnsAsync(searchResult);
var queryServiceMock = new Mock <IODataQueryService>();
var searchTermFormattingServiceMock = new Mock <ISearchTermFormattingService>();
searchTermFormattingServiceMock
.Setup(f => f.FormatSearchTerm(learnAimRef))
.Returns(learnAimRef);
var service = new AzureLearningAimsService(
mapperMock.Object,
indexServiceMock.Object,
queryServiceMock.Object,
azureServiceMock.Object,
searchTermFormattingServiceMock.Object);
var result = (await service.GetLarsLearningDeliveries(searchModel)).ToList();
azureServiceMock.Verify(m => m.SearchIndexAsync <LearningAimModel>(indexServiceMock.Object, learnAimRef, It.IsAny <SearchParameters>()), Times.Once);
result.Should().HaveCount(1);
result.Single().Should().BeSameAs(apiLearningAim);
}
public string ApplyFilter(LearningAimsSearchModel searchModel)
{
var searchFilter = searchModel.FundingStreams;
if (!(searchFilter?.Any() ?? false) || searchFilter.All(string.IsNullOrWhiteSpace))
{
return(string.Empty);
}
var stringBuilder = new StringBuilder();
stringBuilder.Append("(");
foreach (var filter in searchFilter)
{
if (stringBuilder.Length > 1)
{
stringBuilder.Append(" or ");
}
stringBuilder.AppendFormat(FilterODataString, filter.ToUpper(), searchModel.TeachingYears.FirstOrDefault());
}
stringBuilder.Append(")");
return(stringBuilder.ToString());
}
public async Task GetLearningAims_CallsAzureSearchService_GetLarsLearningDeliveries()
{
var searchModel = new LearningAimsSearchModel();
var learningAimModels = new List <LearningAimModel>();
var azureServiceMock = new Mock <IAzureLearningAimsService>();
azureServiceMock
.Setup(m => m.GetLarsLearningDeliveries(searchModel))
.ReturnsAsync(learningAimModels);
var searchCleaningServiceMock = new Mock <ISearchCleaningService>();
searchCleaningServiceMock
.Setup(m => m.EscapeSearchSpecialCharacters(It.IsAny <string>()))
.Returns(string.Empty);
searchCleaningServiceMock
.Setup(m => m.EscapeFilterSpecialCharacters(It.IsAny <string>()))
.Returns(string.Empty);
var service = new LearningAimAzureService(azureServiceMock.Object, searchCleaningServiceMock.Object);
var result = await service.GetLearningAims(searchModel);
azureServiceMock.Verify(m => m.GetLarsLearningDeliveries(searchModel), Times.Once);
result.Should().AllBeEquivalentTo(learningAimModels);
}
public async Task <IEnumerable <LearningAimModel> > GetLearningAimsAsync(
[FromBody] LearningAimsSearchModel searchParameters)
{
var aims = await _unitService.GetLearningAims(searchParameters);
return(aims);
}
public Task <IEnumerable <LearningAimModel> > GetLearningAims(LearningAimsSearchModel searchParameters)
{
searchParameters.SearchTerm = _searchCleaningService.EscapeSearchSpecialCharacters(searchParameters.SearchTerm);
searchParameters.FundingStreams = CleanFilter(searchParameters.FundingStreams);
searchParameters.AwardingBodies = CleanFilter(searchParameters.AwardingBodies);
searchParameters.Levels = CleanFilter(searchParameters.Levels);
return(_azureSearchService.GetLarsLearningDeliveries(searchParameters));
}
public void SetFilters_With_Different_Filters_Returns_Valid_OData_Query()
{
var searchModel = new LearningAimsSearchModel
{
Levels = new List <string>
{
"1"
},
AwardingBodies = new List <string>
{
"Test"
}
};
var levelOData = $"(Level eq '{searchModel.Levels.Single()}')";
var awardingBodyOData = $"(AwardingBodyCode eq '{searchModel.AwardingBodies.Single()}' or AwardingBodyName eq '{searchModel.AwardingBodies.Single()}')";
var oDataQuery = $"{levelOData} and {awardingBodyOData}";
var frameworkFilterMock = new Mock <IFrameworkODataFilter>();
var frameworkFilters = new List <IFrameworkODataFilter> {
frameworkFilterMock.Object
};
var standardsFilterMock = new Mock <IStandardODataFilter>();
var standardsFilters = new List <IStandardODataFilter> {
standardsFilterMock.Object
};
var levelFilterMock = new Mock <ILearningAimsODataFilter>();
levelFilterMock
.Setup(m => m.ApplyFilter(searchModel))
.Returns(levelOData);
var awardingBodyFilterMock = new Mock <ILearningAimsODataFilter>();
awardingBodyFilterMock
.Setup(m => m.ApplyFilter(searchModel))
.Returns(awardingBodyOData);
var oDataLevelFilters = new List <ILearningAimsODataFilter>
{
levelFilterMock.Object,
awardingBodyFilterMock.Object
};
var parameters = new SearchParameters();
var queryService = new ODataQueryService(oDataLevelFilters, frameworkFilters, standardsFilters);
queryService.SetLearningAimFilters(searchModel, parameters);
parameters.Filter.Should().Be(oDataQuery);
}
public void ApplyFilter_Returns_Empty_String_For_No_Filter(string searchFilter)
{
var searchModel = new LearningAimsSearchModel
{
FundingStreams = new List <string>
{
searchFilter
}
};
var fundingStreamOData = string.Empty;
var filter = new FundingStreamODataFilter();
var result = filter.ApplyFilter(searchModel);
result.Should().Be(fundingStreamOData);
}
public void ApplyFilter_Returns_Valid_OData()
{
var searchModel = new LearningAimsSearchModel
{
Levels = new List <string>
{
"Test"
}
};
var awardingBodyOData = $"(Level eq '{searchModel.Levels.Single()}')";
var filter = new LevelODataFilter();
var result = filter.ApplyFilter(searchModel);
result.Should().Be(awardingBodyOData);
}
public void ApplyFilter_Returns_Valid_OData()
{
var searchModel = new LearningAimsSearchModel
{
TeachingYears = new List <string>
{
"1920"
}
};
var oData = $"(AcademicYears/any(ay:ay/AcademicYear eq '{searchModel.TeachingYears.Single()}'))";
var filter = new AcademicYearODataFilter();
var result = filter.ApplyFilter(searchModel);
result.Should().Be(oData);
}
public void ApplyFilter_Returns_Empty_String_For_No_Filter(string searchFilter)
{
var searchModel = new LearningAimsSearchModel
{
Levels = new List <string>
{
searchFilter
}
};
var awardingBodyOData = string.Empty;
var filter = new LevelODataFilter();
var result = filter.ApplyFilter(searchModel);
result.Should().Be(awardingBodyOData);
}
public void ApplyFilter_Returns_Empty_String_For_No_Filter(string searchFilter)
{
var searchModel = new LearningAimsSearchModel
{
TeachingYears = new List <string>
{
searchFilter
}
};
var academicYearOData = string.Empty;
var filter = new AcademicYearODataFilter();
var result = filter.ApplyFilter(searchModel);
result.Should().Be(academicYearOData);
}
public async Task GetLearningAimsAsync_Calls_LearningAimService_GetLearningAims()
{
var searchModel = new LearningAimsSearchModel();
var learningAimModels = new List <LearningAimModel>();
var serviceMock = new Mock <ILearningAimService>();
serviceMock
.Setup(m => m.GetLearningAims(searchModel))
.ReturnsAsync(learningAimModels);
var controller = new LearningAimsController(serviceMock.Object);
var result = await controller.GetLearningAimsAsync(searchModel);
serviceMock.Verify(m => m.GetLearningAims(searchModel), Times.Once);
result.Should().AllBeEquivalentTo(learningAimModels);
}
public void ApplyFilter_Multiple_Terms_Returns_Valid_OData()
{
var searchModel = new LearningAimsSearchModel
{
Levels = new List <string>
{
"Test1",
"Test2"
}
};
var awardingBodyOData = $"(Level eq '{searchModel.Levels[0]}' or Level eq '{searchModel.Levels[1]}')";
var filter = new LevelODataFilter();
var result = filter.ApplyFilter(searchModel);
result.Should().Be(awardingBodyOData);
}
public void SetLearningAimFilters(LearningAimsSearchModel searchModel, SearchParameters parameters)
{
var odataQuery = new StringBuilder();
foreach (var filter in _learningAimOdataFilters)
{
var filterString = filter.ApplyFilter(searchModel);
if (odataQuery.Length != 0 && !string.IsNullOrEmpty(filterString))
{
odataQuery.Append(Concatenation);
}
odataQuery.Append(filterString);
}
parameters.Filter = odataQuery.ToString();
}
public void SetFilters_ReturnValid_OData_Query_Multiple_Levels()
{
var searchModel = new LearningAimsSearchModel
{
Levels = new List <string>
{
"1",
"Entry Level",
"3"
}
};
var oDataQuery = $"(Level eq '{searchModel.Levels[0]}' or Level eq '{searchModel.Levels[1]}' or Level eq '{searchModel.Levels[2]}')";
var frameworkFilterMock = new Mock <IFrameworkODataFilter>();
var frameworkFilters = new List <IFrameworkODataFilter> {
frameworkFilterMock.Object
};
var standardsFilterMock = new Mock <IStandardODataFilter>();
var standardsFilters = new List <IStandardODataFilter> {
standardsFilterMock.Object
};
var filterMock = new Mock <ILearningAimsODataFilter>();
filterMock
.Setup(m => m.ApplyFilter(searchModel))
.Returns(oDataQuery);
var oDataLevelFilters = new List <ILearningAimsODataFilter>
{
filterMock.Object
};
var parameters = new SearchParameters();
var queryService = new ODataQueryService(oDataLevelFilters, frameworkFilters, standardsFilters);
queryService.SetLearningAimFilters(searchModel, parameters);
parameters.Filter.Should().Be(oDataQuery);
}
public void ApplyFilter_Returns_Valid_OData()
{
var searchModel = new LearningAimsSearchModel
{
TeachingYears = new List <string>
{
"1920"
},
FundingStreams = new List <string>
{
"TEST"
}
};
var fundingStreamOData =
$"(AcademicYears/any(ay:ay/Validities/any(v:v/ValidityCategory eq '{searchModel.FundingStreams.Single()}') and ay/AcademicYear eq '{searchModel.TeachingYears.Single()}'))";
var filter = new FundingStreamODataFilter();
var result = filter.ApplyFilter(searchModel);
result.Should().Be(fundingStreamOData);
}
public async Task <IEnumerable <LearningAimModel> > GetLearningAims(LearningAimsSearchModel content)
{
var response = await _clientService.PostAsync <LearningAimsSearchModel, IEnumerable <LearningAimModel> >(Url, content);
return(response);
}
public string ApplyFilter(LearningAimsSearchModel searchModel)
{
return(ApplyFilter(searchModel.TeachingYears));
}
public string ApplyFilter(LearningAimsSearchModel searchModel)
{
return(ApplyFilter(searchModel.AwardingBodies));
}
private void SetFilters(LearningAimsSearchModel searchModel, SearchParameters parameters)
{
_oDataQueryService.SetLearningAimFilters(searchModel, parameters);
}
public async Task <IEnumerable <Models.LearningAimModel> > GetLarsLearningDeliveries(LearningAimsSearchModel searchModel)
{
var parameters = GetDefaultParameters();
SetFilters(searchModel, parameters);
var searchTerm = FormatSearchTerm(searchModel.SearchTerm);
IEnumerable <Models.LearningAimModel> learningAims;
learningAims = await SearchIndex(searchTerm, parameters);
return(learningAims);
}
public string ApplyFilter(LearningAimsSearchModel searchModel)
{
return(ApplyFilter(searchModel.Levels));
}
