public void TestPostCanFindTheMethodButHangFireIsNotRunning()
{
HeyRememberDto heyObj = new HeyRememberDto()
{
Domain = "Hey.Api.Rest.Tests",
Name = "Test",
DomainSpecificData = $"[{JsonConvert.SerializeObject(DateTime.Now)}, \"abc\"]"
};
var scheduleTypeMock = new Mock <IScheduleType>();
scheduleTypeMock
.Setup(type => type.Prototype())
.Returns(scheduleTypeMock.Object);
scheduleTypeMock
.Setup(type => type.Schedule(It.IsAny <HeyRememberDeferredExecution>()))
.Throws <Exception>();
var scheduleTypeFactoryMock = new Mock <IJobRepository>();
scheduleTypeFactoryMock
.Setup(factory => factory.MakeASchedulePrototype(It.IsAny <HeyRememberDto>()))
.Returns(scheduleTypeMock.Object);
var heyController = new HeyController(new HeyService(scheduleTypeFactoryMock.Object, new LogExceptionHandler()));
var response = heyController.Post(heyObj);
Assert.IsInstanceOf <ExceptionResult>(response);
scheduleTypeMock.Verify(type => type.Schedule(It.IsAny <HeyRememberDeferredExecution>()));
}
// PUT: api/Hey/5
public IHttpActionResult Put(string id, [FromBody] HeyRememberDto heyRemember)
{
heyRemember.Id = id;
IHeyResponse heyResponse = _heyService.Update(id, heyRemember);
return(heyResponse.Execute(this));
}
public string Schedule(HeyRememberDeferredExecution deferredExecution)
{
HeyRememberDto heyRemember = deferredExecution.HeyRemember;
DateTime when = heyRemember.When[0];
string id = $"{heyRemember.Type}/{when}/{heyRemember.CronExpression}".GetHashCode().ToString();
RecurringJob.AddOrUpdate(id, () => deferredExecution.Execute(deferredExecution.HeyRemember), heyRemember.CronExpression, TimeZoneInfo.Utc);
return(id);
}
public void TestWithCronExpression_ShouldReturnRecurringScheduleType()
{
HeyRememberDto heyRemember = new HeyRememberDto
{
CronExpression = "* * * * * *"
};
IScheduleType scheduleType = _repository.MakeASchedulePrototype(heyRemember);
Assert.IsInstanceOf(typeof(RecurringScheduleType), scheduleType);
}
public void TestWithEmptyCronExpression_ShouldReturnDelayedScheduleType()
{
HeyRememberDto heyRemember = new HeyRememberDto
{
CronExpression = string.Empty
};
IScheduleType scheduleType = _repository.MakeASchedulePrototype(heyRemember);
Assert.IsInstanceOf(typeof(DelayedScheduleType), scheduleType);
}
public void TestPostCantFindTheAssembly()
{
HeyRememberDto heyObj = new HeyRememberDto()
{
Domain = "Banana"
};
var response = _heyController.Post(heyObj);
Assert.IsInstanceOf <ExceptionResult>(response);
_scheduleTypeMock.Verify(type => type.Schedule(It.IsAny <HeyRememberDeferredExecution>()), Times.Never);
}
public List <HeyRememberResultDto> GetJobs(string id, bool listSucceded = false)
{
List <HeyRememberResultDto> filteredScheduled = _scheduled
.Select(pair => new KeyValuePair <string, HeyRememberDto>(pair.Key, (HeyRememberDto)pair.Value.Job.Args[0]))
.Where(pair => pair.Value.Id == id)
.Select(pair => new HeyRememberResultDto(pair.Key, pair.Value, HeyRememberStatus.Scheduled))
.ToList();
List <HeyRememberResultDto> filteredFailed = _failed
.Select(pair => new KeyValuePair <string, HeyRememberDto>(pair.Key, (HeyRememberDto)pair.Value.Job.Args[0]))
.Where(pair => pair.Value.Id == id)
.Select(pair => new HeyRememberResultDto(pair.Key, pair.Value, HeyRememberStatus.Failed))
.ToList();
List <HeyRememberResultDto> filteredProcessing = _processing
.Select(pair => new KeyValuePair <string, HeyRememberDto>(pair.Key, (HeyRememberDto)pair.Value.Job.Args[0]))
.Where(pair => pair.Value.Id == id)
.Select(pair => new HeyRememberResultDto(pair.Key, pair.Value, HeyRememberStatus.Processing))
.ToList();
var jobs = new List <HeyRememberResultDto>();
jobs.AddRange(filteredScheduled);
jobs.AddRange(filteredFailed);
jobs.AddRange(filteredProcessing);
if (listSucceded)
{
List <HeyRememberResultDto> succededProcessing = _succeded
.Select(pair => new KeyValuePair <string, HeyRememberDto>(pair.Key, (HeyRememberDto)pair.Value.Job.Args[0]))
.Where(pair => pair.Value.Id == id)
.Select(pair => new HeyRememberResultDto(pair.Key, pair.Value, HeyRememberStatus.Succeded))
.ToList();
jobs.AddRange(succededProcessing);
}
//Recurring
List <HeyRememberResultDto> filteredRecurring = _recurring
.Select(recurringDto =>
{
HeyRememberDto nextDateHeyRember = (HeyRememberDto)recurringDto.Job.Args[0];
nextDateHeyRember.When[0] = new FindDatesFromHeyRemember(nextDateHeyRember).Next();
return(new HeyRememberResultDto(recurringDto.Id, nextDateHeyRember, HeyRememberStatus.Recurring));
})
.Where(heyRememberRes => heyRememberRes.HeyRemember.Id == id)
.ToList();
jobs.InsertRange(0, filteredRecurring);
return(jobs);
}
public void TestPostCantFindTheNamespace()
{
HeyRememberDto heyObj = new HeyRememberDto()
{
Domain = "Hey.Api.Rest",
Type = "Banana"
};
var response = _heyController.Post(heyObj);
Assert.IsInstanceOf <BadRequestErrorMessageResult>(response);
_scheduleTypeMock.Verify(type => type.Schedule(It.IsAny <HeyRememberDeferredExecution>()), Times.Never);
}
public void TestPostCanFindTheMethod()
{
HeyRememberDto heyObj = new HeyRememberDto()
{
Domain = "Hey.Api.Rest.Tests",
Name = "Test",
DomainSpecificData = $"[{JsonConvert.SerializeObject(DateTime.Now)}, \"abc\"]"
};
var response = _heyController.Post(heyObj);
Assert.IsInstanceOf <CreatedAtRouteNegotiatedContentResult <HeyRememberDto> >(response);
_scheduleTypeMock.Verify(type => type.Schedule(It.IsAny <HeyRememberDeferredExecution>()));
}
public async Task WhenTheDomainCantBeFoundAsAnAssemblyMustReturnBadRequest()
{
var client = new HttpClient();
var heyObj = new HeyRememberDto()
{
Domain = "Hey.Banana",
};
using (var response = await client.PostAsJsonAsync("http://localhost:60402/api/Hey", heyObj))
{
Assert.AreEqual(HttpStatusCode.InternalServerError, response.StatusCode);
}
}
public void TestPostCantMatchMethodArguments()
{
HeyRememberDto heyObj = new HeyRememberDto()
{
Domain = "Hey.Api.Rest.Tests",
Name = "Test",
DomainSpecificData = $"[{JsonConvert.SerializeObject(DateTime.Now)}, 1]"
};
var response = _heyController.Post(heyObj);
Assert.IsInstanceOf <BadRequestErrorMessageResult>(response);
_scheduleTypeMock.Verify(type => type.Schedule(It.IsAny <HeyRememberDeferredExecution>()), Times.Never);
}
public void GivenAHeyRemember_WithACronExpression_NextDateShouldEvaluteAsFollows(string cronExpression, string expectedDateStr, string startingDateStr)
{
DateTime startingDate = DateTime.Parse(startingDateStr);
HeyRememberDto hey = new HeyRememberDto()
{
When = new [] { startingDate },
CronExpression = cronExpression
};
DateTime expected = DateTime.Parse(expectedDateStr);
FindDatesFromHeyRemember findDates = new FindDatesFromHeyRemember(hey);
DateTime nextDate = findDates.Next(startingDate);
Assert.AreEqual(expected, nextDate);
}
public void GivenAHeyRemember_WithACronExpression_IfScheduledToday_NextDateShouldEvaluteAsFollows()
{
DateTime startingDate = DateTime.UtcNow;
DateTime expected = startingDate.AddMinutes(30);
HeyRememberDto hey = new HeyRememberDto()
{
When = new[] { startingDate },
CronExpression = $"{expected.Minute} {expected.Hour} * * *"
};
FindDatesFromHeyRemember findDates = new FindDatesFromHeyRemember(hey);
DateTime nextDate = findDates.Next(startingDate);
Assert.That(nextDate, Is.EqualTo(expected).Within(TimeSpan.FromMinutes(1)));
}
public void TestGetOfARecurringJobById()
{
_heyController.Post(_recurringHeyRemember);
_repository.Refresh();
HeyRememberDto expectedHeyRemember = new HeyRememberDto(_recurringHeyRemember)
{
When = { [0] = new FindDatesFromHeyRemember(_recurringHeyRemember).Next() }
};
IEnumerable <HeyRememberResultDto> result = _heyController.Get(_recurringId);
Assert.AreEqual(1, result.Count());
Assert.AreEqual(HeyRememberStatus.Recurring, result.First().Status);
Assert.AreEqual(expectedHeyRemember, result.First().HeyRemember);
}
public IMethodBinder Find(HeyRememberDto heyRemember)
{
var assembly = Assembly.Load($"{heyRemember.Domain}");
string myNamespace = $"{heyRemember.Domain}" +
$"{(heyRemember.Type != string.Empty ? "." : "")}" +
$"{heyRemember.Type}";
MethodInfo fireMeMethod = assembly
.GetTypes()
.Where(t => t.Namespace == myNamespace)
.SelectMany(t => t.GetMethods())
.FirstOrDefault(m => HasAttribute(m) && m.GetCustomAttribute <FireMeAttribute>().Id == heyRemember.Name);
return(fireMeMethod != null
? (IMethodBinder) new MethodBinder(fireMeMethod, heyRemember, _exceptionHandler)
: new MethodNotFound(heyRemember));
}
public void TestUpdateOfAScheduledJob()
{
HeyRememberDto scheduledCopy = new HeyRememberDto(_scheduledHeyRemember);
scheduledCopy.When[0] += TimeSpan.FromMinutes(60);
IHttpActionResult resultAction = _heyController.Put(_scheduledId, scheduledCopy);
Assert.IsInstanceOf <CreatedAtRouteNegotiatedContentResult <HeyRememberDto> >(resultAction);
_repository.Refresh();
IEnumerable <HeyRememberResultDto> result = _heyController.Get(_scheduledId);
Assert.AreEqual(1, result.Count());
Assert.AreEqual(HeyRememberStatus.Scheduled, result.First().Status);
Assert.AreEqual(scheduledCopy, result.First().HeyRemember);
}
public void TestUpdateOfARecurringJob()
{
HeyRememberDto recurringCopy = new HeyRememberDto(_recurringHeyRemember);
recurringCopy.When[0] += TimeSpan.FromMinutes(60);
IHttpActionResult resultAction = _heyController.Put(_recurringId, recurringCopy);
recurringCopy.When[0] = new FindDatesFromHeyRemember(recurringCopy).Next();
Assert.IsInstanceOf <CreatedAtRouteNegotiatedContentResult <HeyRememberDto> >(resultAction);
_repository.Refresh();
IEnumerable <HeyRememberResultDto> result = _heyController.Get(_recurringId);
Assert.AreEqual(1, result.Count());
Assert.AreEqual(HeyRememberStatus.Recurring, result.First().Status);
Assert.AreEqual(recurringCopy, result.First().HeyRemember);
}
public void SetUp()
{
_httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(_httpConfiguration);
_postUri = "http://localhost/api/Hey";
_heyObj = new HeyRememberDto()
{
Domain = "TestDomain",
Type = "TestType",
Name = "TestId",
};
_httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, _postUri)
{
Content = new ObjectContent(typeof(HeyRememberDto), _heyObj, new JsonMediaTypeFormatter())
};
}
public IHeyResponse Make(IScheduleType prototype, IHttpReturnType returnType)
{
HeyRememberDto heyRemember = _methodBinder.CreateDeferredExecution().HeyRemember;
BinderCanCallTheMethod binderCanCall = new BinderCanCallTheMethod(_methodBinder);
if (binderCanCall.Can)
{
return(new OkHeyResponse(_methodBinder, prototype.Prototype(), returnType));
}
if (binderCanCall.ExecutionResultEnum == MethodExecutionResultEnum.Empty)
{
return(new MethodNotFoundHeyResponse(heyRemember));
}
if (!binderCanCall.ParametersOk)
{
return(new ParametersErrorHeyResponse(heyRemember, binderCanCall.ParametersOkNum));
}
return(new BindingFailedHeyResponse(heyRemember));
}
public async Task TestPostJsonOnARealHttpCommunicationWithNoIdMustSetToDeafult()
{
var client = new HttpClient();
var heyObj = new HeyRememberDto()
{
Domain = "Hey.Soardi",
Type = "Mail",
Name = "Note",
When = new[] { DateTime.Now + TimeSpan.FromSeconds(60), DateTime.UtcNow },
DomainSpecificData = "[10343, \"[email protected]\"]"
};
string id = HttpUtility.UrlEncode(heyObj.DomainSpecificData);
using (var response = await client.PostAsJsonAsync("http://localhost:60401/api/Hey", heyObj))
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.True(response.Headers.Location.ToString().StartsWith("http://localhost:60401/api/Hey/Hey.Soardi/Mail/Note/Default"));
}
}
public async Task TestPostJsonOnARealHttpCommunication()
{
var client = new HttpClient();
var heyObj = new HeyRememberDto()
{
Domain = "Hey.Soardi",
Type = "Mail",
Name = "Note",
Id = "1952",
When = new[] { DateTime.Now + TimeSpan.FromDays(1), DateTime.UtcNow },
DomainSpecificData = "[10343, \"[email protected]\"]"
};
string id = HttpUtility.UrlEncode(heyObj.DomainSpecificData);
using (var response = await client.PostAsJsonAsync("http://localhost.fiddler:60401/api/Hey", heyObj))
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
}
public IHttpActionResult Execute(HeyController controller)
{
HeyRememberDeferredExecution deferredExecution = _methodBinder.CreateDeferredExecution();
HeyRememberDto heyRemember = deferredExecution.HeyRemember;
try
{
string jobId = _scheduleType.Schedule(deferredExecution);
string heyId = $"{heyRemember.Domain}/{(heyRemember.Type != string.Empty ? heyRemember.Type + "/" : string.Empty)}{heyRemember.Name}/{heyRemember.Id}/{jobId}";
_log.Info($"{heyRemember} scheduled on {heyId}");
var heyRememberReturn = new HeyRememberDto(heyRemember);
heyRememberReturn.When[0] = new FindDatesFromHeyRemember(heyRememberReturn).Next();
return(_returnType.Return(heyId, heyRememberReturn, controller));
}
catch (Exception ex)
{
_log.Error($"{heyRemember}: Error while trying to schedule job", ex);
return(controller.ExposedInternalServerError(ex));
}
}
public MethodExecutionResultEnum Execute(HeyRememberDto heyRemember)
{
var now = DateTime.UtcNow;
if (now < heyRemember.When[0].ToUniversalTime())
{
_log.Info($"{heyRemember}, will be executed on {heyRemember.When[0]}");
return(MethodExecutionResultEnum.Empty);
}
ResolveMethodByFireMeAttribute resolveMethod = new ResolveMethodByFireMeAttribute(_exceptionHandler);
IMethodBinder binder = resolveMethod.Find(heyRemember);
MethodExecutionResultEnum result = binder.Invoke();
_log.Info($"execution of {heyRemember}: {result}");
if (result != MethodExecutionResultEnum.Ok)
{
throw new DeferredExecutionException($"The execution of {heyRemember} failed: see logs for details");
}
return(result);
}
public IHeyResponse Create(HeyRememberDto heyRemember, bool update = false)
{
try
{
FindMethodService findService = new FindMethodService(heyRemember, new ResolveMethodByFireMeAttribute(_exceptionHandler));
return(update
? findService.UpdateResponse(_repository.MakeASchedulePrototype(heyRemember))
: findService.CreateNewResponse(_repository.MakeASchedulePrototype(heyRemember)));
}
catch (Exception ex)
{
if (_exceptionHandler != null)
{
_exceptionHandler.Handle(ex);
return(new ErrorHeyResponse(ex, heyRemember));
}
else
{
throw;
}
}
}
public string Schedule(HeyRememberDeferredExecution deferredExecution)
{
HeyRememberDto heyRemember = deferredExecution.HeyRemember;
return(BackgroundJob.Schedule(() => deferredExecution.Execute(heyRemember), new DateTimeOffset(heyRemember.When[0])));
}
public ErrorHeyResponse(Exception exception, HeyRememberDto heyRemember)
{
_exception = exception;
_heyRemember = heyRemember;
_log = LogManager.GetLogger(GetType());
}
public IHttpActionResult Post([FromBody] HeyRememberDto heyRemember)
{
IHeyResponse heyResponse = _heyService.Create(heyRemember);
return(heyResponse.Execute(this));
}
public MethodNotFound(HeyRememberDto heyRemember)
{
_heyRemember = heyRemember;
}
public HeyRememberResultDto(string jobId, HeyRememberDto heyRemember, HeyRememberStatus status)
{
JobId = jobId;
Status = status;
HeyRemember = heyRemember;
}
public IScheduleType MakeASchedulePrototype(HeyRememberDto heyRemember)
{
return(heyRemember.CronExpression == string.Empty
? DelayedScheduleType.MakePrototype()
: RecurringScheduleType.MakePrototype());
}
