public void TestConstructorWithBadNumberOfCards(int numberOfCards)
{
// ARRANGE
IAxiom axiom = new Axiom();
ICard topCard = new Card(Colour.Blue, Number.Five, axiom);
// ACT
ArgumentOutOfRangeException argumentOutOfRangeException = null;
IRuleScore ruleScore = null;
try
{
ruleScore = new RuleScore(
numberOfCards: numberOfCards,
topCard: topCard);
}
catch (ArgumentOutOfRangeException ex)
{
argumentOutOfRangeException = ex;
}
// ASSERT
if (argumentOutOfRangeException != null)
{
Console.WriteLine(argumentOutOfRangeException.ToString());
}
Assert.IsNotNull(argumentOutOfRangeException, "Expected exception not thrown");
Assert.IsNull(ruleScore, "ruleScore == null");
}
public async Task <IActionResult> CreateNewTemplate(TemplateInDto templateIn)
{
var createTemplateResult = await _templateService.NewTemplate(templateIn);
switch (createTemplateResult)
{
case BadRequestTypedResult <TemplateEntity> badRequestTypedResult:
ModelState.AddModelError(badRequestTypedResult.Key, badRequestTypedResult.ErrorMessage);
return(ValidationProblem(ModelState));
case FailedTypedResult <TemplateEntity> failedTypedResult:
return(Problem(failedTypedResult.Error.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: failedTypedResult.Error.Message));
case NotFoundTypedResult <TemplateEntity> notFoundTypedResult:
return(NotFound());
case SuccessfulTypedResult <TemplateEntity> successfulTypedResult:
return(Ok(Mapper.Map <TemplateEntity, TemplateOutDto>(successfulTypedResult.Value)));
default:
{
var argException = new ArgumentOutOfRangeException(nameof(createTemplateResult));
return(Problem(argException.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: argException.Message));
}
}
}
public async Task <IActionResult> GetSingleTemplateRevision([FromRoute, ObjectIdValidation] string templateId,
[FromRoute, ObjectIdValidation] string templateRevisionId)
{
var getTemplateRevisionResult =
await _templateService.GetTemplateRevision(ObjectId.Parse(templateId), ObjectId.Parse(templateRevisionId));
switch (getTemplateRevisionResult)
{
case BadRequestTypedResult <TemplateRevisionEntity> badRequestTypedResult:
ModelState.AddModelError(badRequestTypedResult.Key, badRequestTypedResult.ErrorMessage);
return(ValidationProblem(ModelState));
case FailedTypedResult <TemplateRevisionEntity> failedTypedResult:
return(Problem(failedTypedResult.Error.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: failedTypedResult.Error.Message));
case NotFoundTypedResult <TemplateRevisionEntity> _:
return(NotFound());
case SuccessfulTypedResult <TemplateRevisionEntity> successfulTypedResult:
return(Ok(Mapper.Map <TemplateRevisionEntity, TemplateRevisionOutDto>(successfulTypedResult.Value)));
default:
{
var argException = new ArgumentOutOfRangeException(nameof(getTemplateRevisionResult));
return(Problem(argException.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: argException.Message));
}
}
}
private static void test2()
{
Console.Clear();
Console.WriteLine("test2");
DateTime?fecha;
int year = 2018;
int month = 20;
int day = 40;
try
{
fecha = new DateTime(year, month, day);
}
catch (ArgumentOutOfRangeException e)
{
string mensaje = String.Format("La fecha {0}-{1}-{2} no es válida", year, month, day);
ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException(mensaje, e);
Console.WriteLine(ex.ToString());
}
}
public async Task <IActionResult> GetTemplates(DateTimeOffset?dateBefore = null, string nameContains = null,
string descriptionContains = null, int limit = 100, int skip = 0)
{
var getTemplatesFilter = new GetTemplatesFilter()
{
NameContains = nameContains,
DescriptionContains = descriptionContains,
DateBefore = dateBefore,
Limit = Math.Clamp(limit, 0, 1000),
Skip = Math.Max(0, skip)
};
var getTemplatesResult = await _templateService.GetTemplates(getTemplatesFilter);
switch (getTemplatesResult)
{
case BadRequestTypedResult <IEnumerable <TemplateEntity> > badRequestTypedResult:
ModelState.AddModelError(badRequestTypedResult.Key, badRequestTypedResult.ErrorMessage);
return(ValidationProblem(ModelState));
case FailedTypedResult <IEnumerable <TemplateEntity> > failedTypedResult:
return(Problem(failedTypedResult.Error.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: failedTypedResult.Error.Message));
case NotFoundTypedResult <IEnumerable <TemplateEntity> > _:
return(NotFound());
case SuccessfulTypedResult <IEnumerable <TemplateEntity> > successfulTypedResult:
return(Ok(new FilteredDtoOut <GetTemplatesFilter, TemplateOutDto>(getTemplatesFilter,
Mapper.Map <IEnumerable <TemplateEntity>, IEnumerable <TemplateOutDto> >(successfulTypedResult.Value))));
default:
{
var argException = new ArgumentOutOfRangeException(nameof(getTemplatesResult));
return(Problem(argException.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: argException.Message));
}
}
}
public async Task <IActionResult> GetTemplateRevisions([FromRoute, ObjectIdValidation] string templateId, int limit = 100, int skip = 0,
DateTimeOffset?dateBefore = null)
{
var getTemplateRevisionsFilter = new GetTemplateRevisionsFilter()
{
Limit = Math.Clamp(limit, 0, 1000),
Skip = Math.Max(0, skip),
DateBefore = dateBefore
};
var getTemplateRevisionResult =
await _templateService.GetFilteredTemplateRevisions(ObjectId.Parse(templateId), getTemplateRevisionsFilter);
switch (getTemplateRevisionResult)
{
case BadRequestTypedResult <IEnumerable <TemplateRevisionEntity> > badRequestTypedResult:
ModelState.AddModelError(badRequestTypedResult.Key, badRequestTypedResult.ErrorMessage);
return(ValidationProblem(ModelState));
case FailedTypedResult <IEnumerable <TemplateRevisionEntity> > failedTypedResult:
return(Problem(failedTypedResult.Error.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: failedTypedResult.Error.Message));
case NotFoundTypedResult <IEnumerable <TemplateRevisionEntity> > _:
return(NotFound());
case SuccessfulTypedResult <IEnumerable <TemplateRevisionEntity> > successfulTypedResult:
return(Ok(new FilteredDtoOut <GetTemplateRevisionsFilter, TemplateRevisionOutDto>(getTemplateRevisionsFilter,
Mapper.Map <IEnumerable <TemplateRevisionEntity>, IEnumerable <TemplateRevisionOutDto> >(successfulTypedResult.Value))));
default:
{
var argException = new ArgumentOutOfRangeException(nameof(getTemplateRevisionResult));
return(Problem(argException.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: argException.Message));
}
}
}
public void ProcessPendingCrashesSendsErrorAttachment()
{
var mockFile1 = Mock.Of <File>();
var mockFile2 = Mock.Of <File>();
var mockExceptionFile1 = Mock.Of <File>();
var mockExceptionFile2 = Mock.Of <File>();
var mockErrorLogHelper = Mock.Of <ErrorLogHelper>();
ErrorLogHelper.Instance = mockErrorLogHelper;
var lastExpectedManagedErrorLog = new ManagedErrorLog
{
Id = Guid.NewGuid(),
Timestamp = DateTime.Now,
AppLaunchTimestamp = DateTime.Now,
Device = new Microsoft.AppCenter.Ingestion.Models.Device()
};
var olderExpectedManagedErrorLog = new ManagedErrorLog
{
Id = Guid.NewGuid(),
Timestamp = lastExpectedManagedErrorLog.Timestamp.Value.AddDays(-1),
AppLaunchTimestamp = lastExpectedManagedErrorLog.Timestamp.Value.AddDays(-1),
Device = new Microsoft.AppCenter.Ingestion.Models.Device()
};
var validErrorAttachment = GetValidErrorAttachmentLog();
var expectedException = new ArgumentOutOfRangeException();
// Stub get/read/delete error files.
Mock.Get(ErrorLogHelper.Instance).Setup(instance => instance.InstanceGetErrorLogFiles()).Returns(new List <File> {
mockFile1, mockFile2
});
Mock.Get(ErrorLogHelper.Instance).Setup(instance => instance.InstanceReadErrorLogFile(mockFile1)).Returns(lastExpectedManagedErrorLog);
Mock.Get(ErrorLogHelper.Instance).Setup(instance => instance.InstanceReadErrorLogFile(mockFile2)).Returns(olderExpectedManagedErrorLog);
Mock.Get(ErrorLogHelper.Instance).Setup(instance => instance.InstanceGetStoredExceptionFile(lastExpectedManagedErrorLog.Id)).Returns(mockExceptionFile1);
Mock.Get(ErrorLogHelper.Instance).Setup(instance => instance.InstanceGetStoredExceptionFile(olderExpectedManagedErrorLog.Id)).Returns(mockExceptionFile2);
Mock.Get(ErrorLogHelper.Instance).Setup(instance => instance.InstanceReadExceptionFile(mockExceptionFile1)).Returns(expectedException.ToString());
// Implement attachments callback.
string actualException = null;
Crashes.GetErrorAttachments = errorReport =>
{
if (errorReport.Id == lastExpectedManagedErrorLog.Id.ToString())
{
actualException = errorReport.StackTrace;
return(new List <ErrorAttachmentLog> {
validErrorAttachment
});
}
return(null);
};
Crashes.SetEnabledAsync(true).Wait();
Crashes.Instance.OnChannelGroupReady(_mockChannelGroup.Object, string.Empty);
Crashes.Instance.ProcessPendingErrorsTask.Wait();
// Verify attachment log has been queued to the channel. (And only one attachment log).
_mockChannel.Verify(channel => channel.EnqueueAsync(validErrorAttachment), Times.Once());
_mockChannel.Verify(channel => channel.EnqueueAsync(It.IsAny <ErrorAttachmentLog>()), Times.Once());
// Verify that the attachment has been modified with the right fields.
Assert.AreEqual(lastExpectedManagedErrorLog.Id, validErrorAttachment.ErrorId);
Assert.AreNotEqual(Guid.Empty, validErrorAttachment.ErrorId);
// Verify exception was attached to report in the callback.
Assert.AreEqual(expectedException.ToString(), actualException);
}
public async Task <IActionResult> Send([FromRoute, ObjectIdValidation] string templateId, SendInDto sendIn)
{
var foundTemplateResult = await _templateService.GetLatestTemplateRevision(ObjectId.Parse(templateId));
TemplateRevisionEntity foundTemplateEntity;
switch (foundTemplateResult)
{
case BadRequestTypedResult <TemplateRevisionEntity> badRequestTypedResult:
ModelState.AddModelError(badRequestTypedResult.Key, badRequestTypedResult.ErrorMessage);
return(ValidationProblem(ModelState));
case FailedTypedResult <TemplateRevisionEntity> failedTypedResult:
return(Problem(failedTypedResult.Error.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: failedTypedResult.Error.Message));
case NotFoundTypedResult <TemplateRevisionEntity> _:
return(NotFound());
case SuccessfulTypedResult <TemplateRevisionEntity> successfulTypedResult:
foundTemplateEntity = successfulTypedResult.Value;
break;
default:
{
var argException = new ArgumentOutOfRangeException(nameof(foundTemplateResult));
return(Problem(argException.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: argException.Message));
}
}
if (string.IsNullOrWhiteSpace(sendIn.From) && string.IsNullOrWhiteSpace(foundTemplateEntity.DefaultFrom))
{
ModelState.AddModelError(nameof(sendIn.From), $"{nameof(sendIn.From)} is required");
return(ValidationProblem(ModelState));
}
var newMailIn = new NewEmailInDto()
{
From = sendIn.From ?? foundTemplateEntity.DefaultFrom,
ToRecipients = sendIn.ToRecipients ?? foundTemplateEntity.DefaultToRecipients,
CcRecipients = sendIn.CcRecipients ?? foundTemplateEntity.DefaultCcRecipients,
BccRecipients = sendIn.BccRecipients ?? foundTemplateEntity.DefaultBccRecipients,
Subject = Handlebars.Compile(foundTemplateEntity.SubjectTemplate)(sendIn.Data),
Body = Handlebars.Compile(foundTemplateEntity.BodyTemplate)(sendIn.Data)
};
var newMailResult = await _mailService.CreateMail(newMailIn);
switch (newMailResult)
{
case BadRequestTypedResult <bool> badRequestTypedResult:
ModelState.AddModelError(badRequestTypedResult.Key, badRequestTypedResult.ErrorMessage);
return(ValidationProblem(ModelState));
case FailedTypedResult <bool> failedTypedResult:
return(Problem(failedTypedResult.Error.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: failedTypedResult.Error.Message));
case NotFoundTypedResult <bool> _:
return(NotFound());
case SuccessfulTypedResult <bool> _:
return(NoContent());
default:
{
var argException = new ArgumentOutOfRangeException(nameof(foundTemplateResult));
return(Problem(argException.ToString(), statusCode: StatusCodes.Status500InternalServerError,
title: argException.Message));
}
}
}