Módulo 5: Teste de unidade e depuração
MÓDULO DE APRENDIZAGEM
Observe que você pode seguir os exemplos apresentados aqui, mas isso não é necessário.
Há várias maneiras de testar uma função do Lambda. A mais simples é usar e desenvolver os testes unitários fornecidos nos modelos do AWS Lambda Project. Um executor de testes familiar em um IDE ou o simples teste dotnet é tudo o que você precisa para executar os testes.
Outra opção é usar a ferramenta de teste AWS .NET Mock Lambda. Ela está em pré-visualização no momento. Isso permite testar e depurar as funções do Lambda. A ferramenta está incluída como parte do Kit de ferramentas da AWS para Visual Studio. Mas você pode baixá-lo para uso com a linha de comando, com o VS Code e o Rider.
Se você estiver desenvolvendo funções do Lambda que estão implantadas em contêineres, o Runtime Interface Emulator permitirá que você teste as funções em execução no contêiner.
Existem ferramentas de terceiros, como o localstack, que você pode usar para testar as funções localmente, mas a melhor maneira de realizar testes funcionais é implantar as funções do Lambda na AWS e testá-las lá. A AWS oferece a todas as contas 1 milhão de solicitações gratuitas por mês; até 3,2 milhões de segundos de tempo de computação por mês. Portanto, há muito poucos motivos para você não testar as funções na Nuvem AWS.
Consulte estas duas páginas para obter mais informações sobre preços: Comece com o nível gratuito da AWS e Preço do AWS Lambda.
Com essas ferramentas de teste locais, também é fácil realizar algumas depurações. Um breve exemplo será mostrado posteriormente.
Tempo para a conclusão
30 minutos
Projeto de teste xUnit
dotnet new lambda.EmptyFunction -n FunctionWithTestProject
cd FunctionWithTestProject/test/FunctionWithTestProject.TestsAbra o arquivo FunctionWithTestProject.Tests.csproj e você verá uma referência ao projeto da função do Lambda.
<ProjectReference Include="..\..\src\FunctionWithTestProject\FunctionWithTestProject.csproj" />
Na linha de comando, execute os testes usando:
dotnet testStarting test execution, please wait...
A total of 1 test files matched the specified pattern.
Passed! - Failed: 0, Passed: 1, Skipped: 0, Total: 1, Duration: < 1 ms - FunctionWithTestProject.Tests.dll (net6.0)No Visual Studio, acesse o menu Teste e selecione Executar todos os testes. Isso também abrirá o Test Explorer, onde você verá os resultados dos testes.
Ao alterar o código na função, você atualiza o teste da mesma forma que faria com um projeto de teste normal. Como esse é um projeto de teste como qualquer outro que você escreve, você poderá usar as mesmas bibliotecas para ajudá-lo, como o moq.
A ferramenta de teste AWS .NET Mock Lambda
Conforme mencionado acima, se você estiver usando o Kit de ferramentas da AWS no Visual Studio, a ferramenta já estará incluída.
Você pode usar a ferramenta com o Visual Studio, o VS Code, o Rider ou na linha de comando.
A linha de comando permite que você execute em dois modos:
1. Com uma interface de usuário baseada em navegador da Web
2. Sem interface de usuário
As próximas etapas mostram como usar a ferramenta na linha de comando, mas, se preferir, passe para a seção sobre o Visual Studio.
Instalar o Kit de ferramentas
Na linha de comando, execute:
dotnet tool install -g Amazon.Lambda.TestTool-6.0
dotnet tool update -g Amazon.Lambda.TestTool-6.0
Teste de linha de comando
Para executar o teste na linha de comando, você precisará especificar a opção --no-ui e passar em uma carga. O escape da carga variará dependendo da shell que você estiver usando. O texto abaixo funciona para o PowerShell.
Na linha de comando, execute:
dotnet lambda-test-tool-6.0 --no-ui --payload '\"hello\"'
dotnet lambda-test-tool-6.0 --no-ui --payload '"hello"'AWS .NET Core 6.0 Mock Lambda Test Tool (0.12.3)
Loaded local Lambda runtime from project output C:\dev\FunctionWithTestProject\src\FunctionWithTestProject\bin/Debug/net6.0
Executing Lambda function without web interface
Found Lambda config file C:\dev\FunctionWithTestProject\src\FunctionWithTestProject\aws-lambda-tools-defaults.json
... Using config file C:\dev\FunctionWithTestProject\src\FunctionWithTestProject\aws-lambda-tools-defaults.json
... Using function handler FunctionWithTestProject::FunctionWithTestProject.Function::FunctionHandler
... Using payload with the value "hello"
... Setting AWS_PROFILE environment variable to default.
... No default AWS region configured. The --region switch can be used to configure an AWS Region.
Captured Log information:
Request executed successfully
Response:
"HELLO"
Press any key to exit Teste de interface de usuário da Web, lançado na linha de comando
Você também pode usar a ferramenta na linha de comando para iniciar uma interface de usuário da Web para testes.
Na interface do usuário, insira sua própria carga, mas não será necessário se preocupar em escapar nesse caso. Selecione também em um conjunto de exemplos de cargas de solicitação. Isso permite que você simule as solicitações de outros serviços da AWS, como S3, Kinesis, SQS etc.
Mas, por enquanto, digite "hello" (incluindo as aspas) como carga e pressione o botão Executar função.
Na seção de resposta, você verá o que a função retornou.
Visual Studio
Abra o projeto FunctionWithTestProject/src/FunctionWithTestProject no Visual Studio.
O Visual Studio criará um diretório de propriedades e, dentro desse diretório, um arquivo launchsettings.json que conecta a ferramenta de teste AWS .NET Mock Lambda ao seu código.
O arquivo ficará mais ou menos assim -
{
"profiles": {
"Mock Lambda Test Tool": {
"commandName": "Executable",
"commandLineArgs": "--port 5050",
"workingDirectory": ".\\bin\\$(Configuration)\\net6.0",
"executablePath": "%USERPROFILE%\\.dotnet\\tools\\dotnet-lambda-test-tool-6.0.exe"
}
}
}VS Code
Para usar a ferramenta de teste AWS .NET Mock Lambda no VS Code, siga estas instruções: https://github.com/aws/aws-lambda-dotnet/tree/master/Tools/LambdaTestTool#configure-for-visual-studio-code
Observação:
1. altere o dotnet-lambda-test-tool-3.1 para dotnet-lambda-test-tool-6.0.
2. se você estiver usando o dotnet-lambda-test-tool-6.0 em Linux ou Mac, não terá uma extensão.exe.
Rider
Emulador de contêineres e interface de runtime
Se você estiver implantando funções do Lambda dentro de contêineres, poderá realizar outra camada de testes locais usando o AWS Runtime Interface Emulator (RIE). Você não precisa instalar nenhuma ferramenta nova, as ferramentas serão automaticamente empacotadas dentro do contêiner que você criou.
Neste exemplo, você escreverá uma aplicação sem servidor que terá dois manipuladores de funções.
Crie um novo projeto baseado em contêiner usando:
dotnet new serverless.image.EmptyServerless --name TestingFunctionWithRIECOPY "bin/Release/lambda-publish" .public APIGatewayProxyResponse Get(APIGatewayProxyRequest request, ILambdaContext context)
{
context.Logger.LogInformation($"Get method invoked. You requested {request.PathParameters["Id"]}");
var response = new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = $"You were looking for something with an Id of : {request.PathParameters["Id"]}",
Headers = new Dictionary<string, string> {
{
"Content-Type",
"application/json"
}
}
};
return response;
}cd TestingFunctionWithRIE/src/TestingFunctionWithRIE
dotnet build -c Release -o .\bin\Release\lambda-publish\
Verifique se o Docker está em execução e, em seguida, crie o contêiner:
docker build -t testing_function_with_rie:latest .
docker run -it -p 9000:8080 testing_function_with_rie:latest TestingFunctionWithRIE::TestingFunctionWithRIE.Functions::GetSe você tiver mais de um manipulador de função no código, teste um de cada vez, iniciando o contêiner e passando o manipulador de função apropriado a cada vez.
Por fim, faça uma solicitação HTTP para o Runtime Interface Emulator. Você pode usar o Fiddler, Postman, Insomnia, etc. Abaixo está a solicitação para usar com o VS Code Rest Client ou o Rider Http Client:
POST http://localhost:9000/2015-03-31/functions/function/invocations HTTP/1.1
content-type: application/json
{
"PathParameters": {
"Id": "999"
}
}HTTP/1.1 200 OK
Date: Fri, 29 Jul 2022 18:03:56 GMT
Content-Length: 148
Content-Type: text/plain; charset=utf-8
Connection: close
{
"statusCode": 200,
"headers": {
"Content-Type": "application/json"
},
"body": "You were looking for something with an Id of : 999",
"isBase64Encoded": false
}dotnet build -c Release -o .\bin\Release\lambda-publish\ ; docker build -t testing_function_with_rie:latest . ; docker run -it -p 9000:8080 testing_function_with_rie:latest TestingFunctionWithRIE::TestingFunctionWithRIE.Functions::Get
Testar a função do Lambda na AWS
As ferramentas acima são ótimas para testar a função do Lambda localmente e, embora existam ferramentas para ajudar você com ambientes simulados da AWS, a melhor maneira de testar a função é no serviço AWS Lambda.
A AWS tem um nível gratuito generoso, que permite executar gratuitamente um milhão de solicitações do Lambda por mês. Se você ultrapassar esse limite, as próximas 1 milhão de execuções custarão USD 0,20 ou USD 0,0000002 por execução. Há algumas ressalvas sobre preços relacionados ao uso da memória e ao runtime. Consulte - Comece com o nível gratuito da AWS e os preços do AWS Lambda para obter mais informações.
Embora as ferramentas do emulador possam ser ótimas se você não tiver conectividade com a Internet, você poderá descobrir que elas não se comportam exatamente da mesma forma que os serviços reais da AWS. Testar as funções do Lambda na AWS significa que não haverá surpresas quando chegar a hora de implantar o código.
Tudo o que você precisa fazer é criar um projeto de teste no .NET. O modelo xUnit é uma boa escolha. A partir daí, escreva testes funcionais direcionados às funções do Lambda que você implanta na AWS.
dotnet new xunit -n LambdaTestProject
Para ver um passo a passo sobre como testar as funções do Lambda no .NET implantadas na AWS, consulte a postagem do blog Desenvolver as funções .NET Core do AWS Lambda.
Depuração
Talvez você queira depurar a função do Lambda localmente de tempos em tempos. Há duas maneiras fáceis de fazer isso:
1. Colocar um ponto de interrupção no projeto de teste unitário e, em seguida, entrar na função.
2. Iniciar a ferramenta de teste AWS .NET Mock Lambda no IDE, colocando um ponto de interrupção na função e executando a função na ferramenta de teste.
Usar o projeto de teste unitário
Abra o projeto de teste e coloque um ponto de interrupção no código exatamente onde ele chama a função do Lambda.
Depure o teste. Quando você atingir o ponto de interrupção, entre na função do Lambda.
Usar a ferramenta de teste AWS .NET Mock Lambda
No Visual Studio, abra o projeto da função, não o projeto de teste.
Coloque um ponto de interrupção no manipulador de funções. Na interface de usuário da Web, adicione a entrada da função e pressione Executar.
Seu ponto de interrupção será atingido e você poderá depurar a função do Lambda, como em qualquer outro método.
Conclusão
Ao se acostumar a escrever funções do Lambda, você poderá alternar entre as diferentes formas de testar as funções, mas é altamente recomendável usar o serviço real do AWS Lambda o mais rápido possível para testar o código. É o melhor lugar para fazer isso.
Você também viu como depurar uma função localmente, permitindo que percorrer o código e ver o que está acontecendo.
Verificação de conhecimento
1. Quais IDEs permitem que você execute os testes de unidade da função do Lambda? (selecione uma)
b. VS Code
c. Rider
d. Todas as opções acima
2. O que a ferramenta de teste AWS .NET Mock Lambda permite que você faça? (selecione uma)
b. Simule os serviços da AWS para que a função do Lambda chame
c. Execute testes de desempenho nas funções do Lambda
d. Invoque o código da função localmente
3. Para qual tipo de função do Lambda o Runtime Interface Emulator é adequado? (selecione uma)
b. Funções do Lambda baseadas em contêiner
c. Funções do Lambda em runtime personalizados
d. Todos os tipos de função do Lambda
Respostas: 1-d, 2-d, 3-b
Conclusão
Ao se acostumar a escrever funções do Lambda, você poderá alternar entre as diferentes formas de testar as funções, mas é altamente recomendável usar o serviço real do AWS Lambda o mais rápido possível para testar o código. É o melhor lugar para fazer isso.
Você também viu como depurar uma função localmente, permitindo que percorrer o código e ver o que está acontecendo.