public async Task SearchAsync_ReturnsMatches()
{
var list = new List <CourseDto>
{
new CourseDto {
Name = "Response1"
},
new CourseDto {
Name = "Other Response"
}
};
SetupTextFixture(s =>
{
var mock = new Mock <ICourseService>();
mock.Setup(m => m.SearchAsync("David")).ReturnsAsync(ResponseMeta <List <CourseDto> > .CreateSuccess(list));
s.AddTransient <ICourseService>(_ => mock.Object);
});
var api = new CourseApi();
var response = await api.SearchAsync("David");
Assert.IsTrue(response.Success);
response.Item.Should().BeEquivalentTo(list);
}
public async Task <ResponseMeta> AddAsync(CourseDto dto)
{
if (dto.Id != null)
{
return(ResponseMeta <CourseDto> .CreateFailure(ResponseFailureType.IdRequiredNull));
}
using (var context = await _contextFactory)
{
var model = dto.ToModel();
try
{
await context.Courses.AddAsync(model);
await context.SaveChangesAsync();
}
catch (Exception ex)
{
return(ResponseMeta <CourseDto> .CreateFailure(ex.ToString()));
}
return(ResponseMeta.CreateSuccess());
}
}
public async Task <ResponseMeta> UpdateAsync(CourseDto dto)
{
using (var context = await _contextFactory)
{
if (dto.Id == null)
{
return(ResponseMeta.CreateFailure(ResponseFailureType.IdRequired));
}
var existing = await context.Courses.FirstOrDefaultAsync(m => m.Id == dto.Id);
if (existing == null)
{
return(ResponseMeta.CreateFailure(ResponseFailureType.EntityNotFound));
}
var model = dto.ToModel();
try
{
context.Entry(existing).CurrentValues.SetValues(model);
await context.SaveChangesAsync();
}
catch (Exception ex)
{
return(ResponseMeta.CreateFailure(ex.ToString()));
}
return(ResponseMeta.CreateSuccess());
}
}
public void FromModifiedXml(ModifiedXmlDocument doc, string path)
{
Result = doc.GetStringFromXml(path + "/RESULT");
Meta = new ResponseMeta();
Meta.FromModifiedXml(doc, path);
Status = new OrderStatus();
Status.FromModifiedXml(doc, path + "/STATUS");
}
protected ApiResponse(HttpStatusCode status_number, object result = null, string errorMessage = null)
{
Meta = new ResponseMeta
{
StatusNumber = (int)status_number,
Message = errorMessage
};
Data = result;
}
public async Task <string> Add(CloudTable responseMetasTable, HttpResponseMessage response)
{
var responseMeta = new ResponseMeta(response, DateTimeOffset.UtcNow);
logger.LogDebug($"Adding new response meta:\n{responseMeta}");
await tableRepository.Add(responseMetasTable, responseMeta);
return(responseMeta.RowKey);
}
protected ApiPaginationResponse(HttpStatusCode status_number, long page, long totalPages, object result = null, string errorMessage = null)
{
Meta = new ResponseMeta
{
StatusNumber = (int)status_number,
Message = errorMessage,
Page = page,
TotalPages = totalPages
};
Data = result;
}
public async Task <ResponseMeta <SettingsDto> > GetSettings()
{
using (var context = await _contextFactory)
{
var list = context.Settings.ToList();
var settings = new SettingsDto();
settings.CourseImageUrl = list.FirstOrDefault(s => s.Key == "CourseImageUrl")?.Value;
return(ResponseMeta <SettingsDto> .CreateSuccess(settings));
}
}
public ResponseMetaDisplayable(ResponseMeta responseMeta)
{
if (responseMeta == null)
{
throw new ArgumentNullException("responseMeta");
}
BlobKey = responseMeta.RowKey;
ReceivedOn = DateTimeOffset.Parse(responseMeta.RowKey);
IsSuccess = bool.Parse(responseMeta.PartitionKey);
StatusCode = responseMeta.StatusCode;
Headers = responseMeta.Headers;
}
public async Task <ResponseMeta <CourseDto> > GetAsync(long id)
{
using (var context = await _contextFactory)
{
var model = await context.Courses.FirstOrDefaultAsync(m => m.Id == id);
if (model == null)
{
return(ResponseMeta <CourseDto> .CreateFailure(ResponseFailureType.EntityNotFound));
}
return(ResponseMeta <CourseDto> .CreateSuccess(model.ToDto()));
}
}
public async Task <ResponseMeta <List <CourseDto> > > SearchAsync(string search)
{
using (var context = await _contextFactory)
{
var items = context.Courses.ToList();
var recs = context.Courses
.Where(c => c.Name.Contains(search))
.Take(25)
.ToList()
.Select(c => c.ToDto())
.ToList();
return(ResponseMeta <List <CourseDto> > .CreateSuccess(recs));
}
}
public async Task AddAsync_ReturnsSuccess()
{
SetupTextFixture(s =>
{
var mock = new Mock <ICourseService>();
mock.Setup(m => m.AddAsync(It.IsAny <CourseDto>())).ReturnsAsync(ResponseMeta.CreateSuccess());
s.AddTransient <ICourseService>(_ => mock.Object);
});
var api = new CourseApi();
var response = await api.AddAsync(Dtos.CourseDto);
Assert.IsTrue(response.Success);
}
public async Task GetSettings_ReturnsSettings()
{
SetupTextFixture(s =>
{
var mock = new Mock <ISettingsService>();
mock.Setup(m => m.GetSettings()).ReturnsAsync(ResponseMeta <SettingsDto> .CreateSuccess(Dtos.SettingsDto));
s.AddTransient <ISettingsService>(_ => mock.Object);
});
var api = new SettingsApi();
var response = await api.GetSettings();
Assert.IsTrue(response.Success);
response.Item.Should().BeEquivalentTo(Dtos.SettingsDto);
}
public async Task GetCourseInfoForCourse_BubblesErrors()
{
SetupTextFixture(s =>
{
var mock = new Mock <ICourseInfoService>();
mock.Setup(m => m.GetCourseInfoForCourse(1)).ReturnsAsync(ResponseMeta <CourseInfoDto> .CreateFailure(ResponseFailureType.IdRequired));
s.AddTransient <ICourseInfoService>(_ => mock.Object);
});
var api = new CourseInfoApi();
var response = await api.GetCourseInfoForCourse(1);
Assert.IsFalse(response.Success);
Assert.AreEqual(ResponseFailureType.IdRequired, response.FailureType);
}
public async Task GetCourseInfoForCourse_ReturnsCourseInfo()
{
SetupTextFixture(s =>
{
var mock = new Mock <ICourseInfoService>();
mock.Setup(m => m.GetCourseInfoForCourse(1)).ReturnsAsync(ResponseMeta <CourseInfoDto> .CreateSuccess(Dtos.CourseInfoDto));
s.AddTransient <ICourseInfoService>(_ => mock.Object);
});
var api = new CourseInfoApi();
var response = await api.GetCourseInfoForCourse(1);
Assert.IsTrue(response.Success);
response.Item.Should().BeEquivalentTo(Dtos.CourseInfoDto);
}
public async Task GetHolesForCourse_ReturnsCourse()
{
SetupTextFixture(s =>
{
var mock = new Mock <IHoleService>();
mock.Setup(m => m.GetHolesForCourse(1)).ReturnsAsync(ResponseMeta <List <HoleDto> > .CreateSuccess(Dtos.HoleDtoList));
s.AddTransient <IHoleService>(_ => mock.Object);
});
var api = new HoleApi();
var response = await api.GetHolesForCourse(1);
Assert.IsTrue(response.Success);
response.Item.Should().BeEquivalentTo(Dtos.HoleDtoList);
}
public async Task <ResponseMeta> DeleteAsync(long id)
{
using (var context = await _contextFactory)
{
var model = await context.Courses.FirstOrDefaultAsync(m => m.Id == id);
if (model == null)
{
return(ResponseMeta.CreateFailure(ResponseFailureType.EntityNotFound));
}
context.Courses.Remove(model);
await context.SaveChangesAsync();
return(ResponseMeta.CreateSuccess());
}
}
public async Task AddAsync_BubblesErrors()
{
SetupTextFixture(s =>
{
var mock = new Mock <ICourseService>();
mock.Setup(m => m.AddAsync(It.IsAny <CourseDto>())).ReturnsAsync(ResponseMeta.CreateFailure(ResponseFailureType.IdRequired, new[] { "oh no" }));
s.AddTransient <ICourseService>(_ => mock.Object);
});
var api = new CourseApi();
var response = await api.AddAsync(new CourseDto());
Assert.IsFalse(response.Success);
Assert.AreEqual(ResponseFailureType.IdRequired, response.FailureType);
Assert.AreEqual("oh no", response.Errors.First());
}
public async Task <ResponseMeta <List <HoleDto> > > GetHolesForCourse(long courseId)
{
using (var context = await _contextFactory)
{
var course = await context.Courses
.Include(c => c.Holes)
.FirstOrDefaultAsync(c => c.Id == courseId);
if (course == null)
{
return(ResponseMeta <List <HoleDto> > .CreateFailure(ResponseFailureType.EntityNotFound));
}
var holes = course.Holes
.Select(h => h.ToDto())
.ToList();
return(ResponseMeta <List <HoleDto> > .CreateSuccess(holes));
}
}
public static async Task <ResponseMeta> GetResponseAsync(this HttpResponseMessage response)
{
if (response.IsSuccessStatusCode)
{
return(ResponseMeta.CreateSuccess());
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
dynamic dyn = JObject.Parse(await response.Content.ReadAsStringAsync());
return(ResponseMeta.CreateFailure
(
(ResponseFailureType)dyn.FailureType,
dyn.Errors.ToObject <string[]>()
));
}
else
{
throw new Exception($"Fatal error on request, response status: {response.StatusCode}");
}
}
public ErrorResult(ResponseMeta response)
{
_response = response ?? throw new ArgumentNullException(nameof(response));
}
public ErrorChecker()
{
Meta = new ResponseMeta();
Errors = new List <ErrorRow>();
}
protected ResponseBase()
{
Meta = new ResponseMeta();
}
