public Function()
{
var bucketName = "notttechmeet";
Pipeline = new AlexaRequestPipeline(new IAlexaRequestHandler[]
{
new Launch(),
new Events_Next(bucketName),
new Events_Calendar(bucketName),
new EventDetail(),
new EventsAllWithDates(),
new EventsAll(),
new WhatEvent(),
new InvalidReminder(),
new ReminderConfirmation(),
new ReminderDenied(),
new ReminderConfirmed(),
new Help(),
new SessionEnded(),
new FinishedIntents(),
new Fallback()
}, null, new [] { new StateInterceptor() }, null)
{
StatePersistance = Store
};
}
public async Task TwoInterceptorCallsInOrder()
{
var expected = new SkillResponse();
var before = string.Empty;
Handler.Handle(Arg.Any <AlexaRequestInformation <SkillRequest> >()).Returns(c =>
{
before = before + "3";
return(expected);
});
var interceptor = Substitute.For <IAlexaRequestInterceptor <SkillRequest> >();
interceptor.Intercept(Arg.Any <AlexaRequestInformation <SkillRequest> >(), Arg.Any <RequestInterceptorCall <SkillRequest> >()).Returns(c => {
before = before + "1";
var actual = c.Arg <RequestInterceptorCall <SkillRequest> >()(c.Arg <AlexaRequestInformation <SkillRequest> >());
before = before + "5";
return(actual);
});
var secondInterceptor = Substitute.For <IAlexaRequestInterceptor <SkillRequest> >();
secondInterceptor.Intercept(Arg.Any <AlexaRequestInformation <SkillRequest> >(), Arg.Any <RequestInterceptorCall <SkillRequest> >()).Returns(c => {
before = before + "2";
var actual = c.Arg <RequestInterceptorCall <SkillRequest> >()(c.Arg <AlexaRequestInformation <SkillRequest> >());
before = before + "4";
return(actual);
});
var request = new AlexaRequestPipeline(new[] { Handler }, null, new[] { secondInterceptor, interceptor }, null);
await request.Process(new SkillRequest());
Assert.Equal("21354", before);
}
public async Task NoValidRequestHandlerThrowsException()
{
var requestHandler = Substitute.For <IAlexaRequestHandler>();
requestHandler.CanHandle(Arg.Any <AlexaRequestInformation>()).Returns(false);
var request = new AlexaRequestPipeline(new[] { requestHandler });
await Assert.ThrowsAsync <AlexaRequestHandlerNotFoundException>(() => request.Process(new SkillRequest()));
}
public async Task EmptyErrorHandlerThrowsOnException()
{
var requestHandler = Substitute.For <AlwaysTrueRequestHandler>();
requestHandler.Handle(Arg.Any <AlexaRequestInformation <SkillRequest> >()).Throws <InvalidOperationException>();
var request = new AlexaRequestPipeline(new[] { requestHandler });
await Assert.ThrowsAsync <InvalidOperationException>(() => request.Process(new SkillRequest()));
}
public async Task EmptyInterceptorReturnsHandler()
{
var expected = new SkillResponse();
Handler.Handle(Arg.Any <AlexaRequestInformation <SkillRequest> >()).Returns(expected);
var request = new AlexaRequestPipeline(new[] { Handler }, null);
var actual = await request.Process(new SkillRequest());
Assert.Equal(expected, actual);
}
public async Task ValidErrorHandlerReturnsResponse()
{
var errorHandler = Substitute.For <AlwaysTrueErrorHandler <SkillRequest> >();
errorHandler.Handle(Arg.Any <AlexaRequestInformation <SkillRequest> >(), Arg.Any <Exception>()).Returns(new Response.SkillResponse());
var request = new AlexaRequestPipeline(null, new[] { errorHandler });
var response = await request.Process(new SkillRequest());
Assert.NotNull(response);
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req, ILogger log)
{
var json = await req.ReadAsStringAsync();
var skillRequest = JsonConvert.DeserializeObject <SkillRequest>(json);
// Verifies that the request is indeed coming from Alexa.
var isValid = await skillRequest.ValidateRequestAsync(req, log);
if (!isValid)
{
return(new BadRequestResult());
}
bool isFirstRequest = skillRequest.Session.Attributes == null ? true : false;
Game game = new Game();
await game.InitializeGame(skillRequest.Session);
var pipeline = new AlexaRequestPipeline();
pipeline.RequestHandlers.Add(new LaunchIntentHandler(isFirstRequest));
pipeline.RequestHandlers.Add(new SessionEndedRequestHandler());
pipeline.RequestHandlers.Add(new CancelIntentHandler());
pipeline.RequestHandlers.Add(new HelpIntentHandler());
pipeline.RequestHandlers.Add(new CreditsIntentHandler());
pipeline.RequestHandlers.Add(new ContinuePromptIntentHandler());
pipeline.RequestHandlers.Add(new RepeatIntentHandler());
pipeline.RequestHandlers.Add(new FallbackIntentHandler());
pipeline.RequestHandlers.Add(new RulesIntentHandler());
pipeline.RequestHandlers.Add(new NextRuleIntentHandler());
pipeline.RequestHandlers.Add(new PreviousRuleIntentHandler());
pipeline.RequestHandlers.Add(new NewGameIntentHandler());
pipeline.RequestHandlers.Add(new MoreTimeIntentHandler());
pipeline.RequestHandlers.Add(new ShipStatusIntentHandler());
pipeline.RequestHandlers.Add(new ThreatStatusIntentHandler());
pipeline.RequestHandlers.Add(new ThreatInfoIntentHandler());
pipeline.RequestHandlers.Add(new AssignTacticalToWeaponsIntentHandler());
pipeline.RequestHandlers.Add(new FireWeaponsIntentHandler());
pipeline.RequestHandlers.Add(new FireStasisBeamIntentHandler());
pipeline.RequestHandlers.Add(new RechargeShieldsIntentHandler());
pipeline.RequestHandlers.Add(new RepairHullIntentHandler());
pipeline.RequestHandlers.Add(new HealCrewIntentHandler());
pipeline.RequestHandlers.Add(new RemoveThreatFromScannerIntentHandler());
pipeline.RequestHandlers.Add(new TransformCrewIntentHandler());
pipeline.RequestHandlers.Add(new SendCrewOnAMissionIntentHandler());
pipeline.RequestHandlers.Add(new ReturnCrewFromMissionIntentHandler());
pipeline.RequestHandlers.Add(new EndTurnIntentHandler());
pipeline.RequestHandlers.Add(new AlwaysTrueIntentHandler());
var response = await pipeline.Process(skillRequest, game);
return(new OkObjectResult(response));
}
public async Task EmptyRequestHandlerThrowsWhenSet()
{
var errorHandler = Substitute.For <AlwaysTrueErrorHandler>();
errorHandler.Handle(Arg.Any <AlexaRequestInformation>(), Arg.Any <Exception>()).Returns(new Response.SkillResponse());
var request = new AlexaRequestPipeline(null, new[] { errorHandler })
{
RequestHandlerTriggersErrorHandlers = false
};
await Assert.ThrowsAsync <AlexaRequestHandlerNotFoundException>(() => request.Process(new SkillRequest()));
}
public async Task <SkillResponse> ProcessAsync(SkillRequest input)
{
String currentLocale = input.Request.Locale.Split('-')[0];
LocalizationManager.Init(currentLocale);
var request = new AlexaRequestPipeline();
request.RequestHandlers.Add(new LaunchRequestIntentHandler());
request.RequestHandlers.Add(new SessionEndedRequestIntentHandler());
request.RequestHandlers.Add(new CancelIntentHandler());
request.RequestHandlers.Add(new HelpIntentHandler());
request.RequestHandlers.Add(new HelloWorldIntentHandler());
request.ErrorHandlers.Add(new ErrorHandler());
return(await request.Process(input));
}
public async Task ValidFirstRequestReturnsResponse()
{
var expected = ResponseBuilder.Empty();
var requestHandler = Substitute.For <IAlexaRequestHandler <SkillRequest> >();
requestHandler.CanHandle(Arg.Any <AlexaRequestInformation <SkillRequest> >()).Returns(true);
requestHandler.Handle(Arg.Any <AlexaRequestInformation <SkillRequest> >()).Returns(expected);
var errorHandler = Substitute.For <IAlexaErrorHandler <SkillRequest> >();
errorHandler.CanHandle(Arg.Any <AlexaRequestInformation <SkillRequest> >(), Arg.Any <Exception>()).Returns(false);
var request = new AlexaRequestPipeline(new[] { requestHandler }, new[] { errorHandler });
var actual = await request.Process(new SkillRequest());
Assert.Equal(expected, actual);
}
public async Task <SkillResponse> FunctionHandler(SkillRequest input, ILambdaContext context)
{
SkillResponse response = new SkillResponse
{
Response = new ResponseBody()
};
var pipeline = new AlexaRequestPipeline();
pipeline.RequestHandlers.Add(new LaunchRequestHandler());
pipeline.RequestHandlers.Add(new GetClientsIntentRequestHandler());
pipeline.RequestHandlers.Add(new ServerInfoIntentRequestHandler());
pipeline.RequestHandlers.Add(new HelpIntentRequestHandler());
pipeline.RequestHandlers.Add(new StopIntentRequestHandler());
pipeline.RequestHandlers.Add(new AlwaysTrueRequestHandler());
return(await pipeline.Process(input, context));
}
public async Task SpecificExceptionHandlerPicks()
{
var requestHandler = Substitute.For <AlwaysTrueRequestHandler <SkillRequest> >();
requestHandler.Handle(Arg.Any <AlexaRequestInformation <SkillRequest> >()).Throws <InvalidOperationException>();
var specificError = Substitute.For <IAlexaErrorHandler>();
specificError.CanHandle(Arg.Any <AlexaRequestInformation <SkillRequest> >(), Arg.Any <InvalidOperationException>()).Returns(true);
specificError.Handle(Arg.Any <AlexaRequestInformation <SkillRequest> >(), Arg.Any <Exception>()).Returns(new Response.SkillResponse());
var errorHandler = Substitute.For <AlwaysTrueErrorHandler>();
var request = new AlexaRequestPipeline(new[] { requestHandler }, new IAlexaErrorHandler <SkillRequest>[] { specificError, errorHandler });
var response = await request.Process(new SkillRequest());
Assert.NotNull(response);
}
public async Task EmptyRequestHandlersHandledByErrors()
{
var request = new AlexaRequestPipeline();
await Assert.ThrowsAsync <AlexaRequestHandlerNotFoundException>(() => request.Process(new SkillRequest()));
}
public async Task ArgumentNullExceptionIfNoRequest()
{
var request = new AlexaRequestPipeline();
await Assert.ThrowsAsync <ArgumentNullException>(() => request.Process(null));
}
