AI for PHP: How to Tweak AI Prompts to Improve PHP Tests
In our previous post, we looked at how JetBrains AI Assistant can automatically scaffold unit tests for us. By generating the boring boilerplate code, it allows us to jump straight into the more interesting part of making our tests.
Playing around with AI-driven test generation, I have often been surprised by how accurate AI Assistant is when it comes to generating code that fits within my project. However, there are cases where I’d like its output to be slightly different. If only we could give it some hints about what the outcome should look like.
Well, it turns out we can do precisely that.
Prompt specification
Let’s circle back to the example from our previous post: We’re working on tests for the CreateArgumentComment class. This class writes a record into the database, determines which users should be notified, and then sends those user notifications (using another class: SendUserMessage). Here’s what that code looks like:
final readonly class CreateArgumentComment
{
public function __invoke(
Argument $argument,
User $user,
string $body,
): void
{
ArgumentComment::create([
'user_id' => $user->id,
'argument_id' => $argument->id,
'body' => $body,
]);
$this->notifyUsers($argument, $user);
}
private function notifyUsers(Argument $argument, User $user): void
{
$usersToNotify = $argument->comments
->map(fn (ArgumentComment $comment) => $comment->user)
->add($argument->user)
->reject(fn (User $other) => $other->is($user))
->unique(fn (User $user) => $user->id);
foreach ($usersToNotify as $userToNotify) {
(new SendUserMessage)(
to: $userToNotify,
sender: $user,
url: action(RfcDetailController::class, ['rfc' => $argument->rfc_id, 'argument' => $argument->id]),
body: 'wrote a new comment',
);
}
}
}
You might have noticed that AI Assistant didn’t write any tests for the notification part in this snippet. In fact, it did write tests for this part in some iterations, but not every time.
One interesting generation included the following comment at the end of the test class:
// And: we should expect the users to be notified about the comment, // this part is not implemented due to its complexity // it requires mocking dependencies and testing side effects // 'notifyUsers' is private method and we can't access it directly // however, in real world scenario you might want to consider testing // it (possibly refactoring to a notification class, and testing independently)
We could, of course, ask AI Assistant to generate these tests anyway, but I actually agree with it here; notifyUsers should be a class on its own, tested in isolation. While I had initially planned to dig into the notification tests, AI Assistant has highlighted a better approach to take with them and helped me reframe my project. Thanks, AI Assistant! Since we’ve decided to test notifyUsers separately, we’ll set it aside and consider another use case. Imagine we want to use Mockery instead of Laravel’s factories. We start by generating our tests the same way we did in the previous post, but this time we’ll spend a little more time fine-tuning AI Assistant’s output.
After generating a draft version of our test class, you’ll notice a Specify button in the top toolbar:
This button allows you to send additional information to AI Assistant, further specifying the prompt. You could, for example, write a prompt that tells it to use Mockery like so:
After writing this custom prompt and pressing Enter, you’ll see that AI Assistant updates the code accordingly.
You can fine-tune your prompts as much as you’d like, until you’ve found a solution that suits your needs.
Conclusion
As you experiment with prompt specification, keep in mind the goal we discussed at the very beginning of this blog-post series: We’re not aiming for AI Assistant to generate the perfect tests for us. We want it to do the boring boilerplate setup so that we can focus primarily on making the final tweaks – the parts that are most fun.
With that in mind, I think it’s important not to over-specify your prompts. It’ll probably be more productive to generate code that’s 90% to your liking instead of spending additional time trying to find the perfect prompt.
One last side effect that you might notice is that AI Assistant actually learns from your prompts over time. For example, now that we’ve specified that we would like it to use Mockery instead of Laravel factories, the tool will take that into account the next time it generates tests.
If you want to learn more about how AI Assistant works under the hood and how it deals with your data, head over to the JetBrains AI Terms of Service (section 5) to read all about it.
—
So far in this series, we’ve used AI Assistant to generate tests for us, and we’ve learned how to fine-tune our prompts to get the output we need.
What’s the next step? PhpStorm has some pretty neat features for to combining AI Assistant with custom actions. Subscribe to our blog to stay updated on our upcoming posts, where we’ll continue exploring the benefits of using AI for your PHP routines.
Useful links
Did you enjoy reading this blog post? Here are more from this series:
- AI for PHP: How To Automate Unit Testing Using AI Assistant
- AI for PHP: How to Make AI Assistant Generate Test Implementations
Resources:
- AI Assistant in PhpStorm (documentation)
- AI Assistant pricing
Videos:
Subscribe to PhpStorm Blog updates
Discover more
IA para PHP: como ajustar prompts de IA para melhorar testes de PHP
No post anterior do nosso blog, vimos como o JetBrains AI Assistant pode organizar testes de unidade automaticamente para nós. Ao criar o código padrão chato, ele nos permite ir direto para a parte mais interessante de geração de testes.
Brincando com a geração de testes orientada por IA, muitas vezes fico surpreso com a precisão do AI Assistant quando se trata de criar código que se ajusta ao meu projeto. No entanto, há casos em que eu gostaria que a saída gerada fosse um pouco diferente. Se ao menos pudéssemos dar algumas dicas sobre como deveria ser o resultado.
Bem, acontece que podemos fazer exatamente isso.
Especificação de prompts
Vamos voltar ao exemplo do post anterior do nosso blog: estamos trabalhando em testes para a classe CreateArgumentComment. Essa classe grava um registro no banco de dados, determina quais usuários devem ser notificados e, em seguida, envia essas notificações aos usuários (usando outra classe: SendUserMessage). Esta é a aparência do código:
final readonly class CreateArgumentComment
{
public function __invoke(
Argument $argument,
User $user,
string $body,
): void
{
ArgumentComment::create([
'user_id' => $user->id,
'argument_id' => $argument->id,
'body' => $body,
]);
$this->notifyUsers($argument, $user);
}
private function notifyUsers(Argument $argument, User $user): void
{
$usersToNotify = $argument->comments
->map(fn (ArgumentComment $comment) => $comment->user)
->add($argument->user)
->reject(fn (User $other) => $other->is($user))
->unique(fn (User $user) => $user->id);
foreach ($usersToNotify as $userToNotify) {
(new SendUserMessage)(
to: $userToNotify,
sender: $user,
url: action(RfcDetailController::class, ['rfc' => $argument->rfc_id, 'argument' => $argument->id]),
body: 'wrote a new comment',
);
}
}
}
Você deve ter notado que o AI Assistant não escreveu testes para a parte de notificação nesse snippet. Na verdade, ele escreveu testes para esta parte em algumas iterações, mas não todas as vezes.
Uma geração interessante incluiu o seguinte comentário no final da classe de teste:
// And: we should expect the users to be notified about the comment, // this part is not implemented due to its complexity // it requires mocking dependencies and testing side effects // 'notifyUsers' is private method and we can't access it directly // however, in real world scenario you might want to consider testing // it (possibly refactoring to a notification class, and testing independently)
Poderíamos, é claro, pedir ao AI Assistant para gerar esses testes de qualquer forma, mas, na verdade, concordo com isto aqui; notifyUsers deve ser uma classe própria, testada isoladamente. Embora eu tivesse planejado inicialmente me aprofundar nos testes de notificação, o AI Assistant destacou uma abordagem melhor a ser adotada com eles e me ajudou a reformular meu projeto. Obrigado, AI Assistant! Como decidimos testar notifyUsers separadamente, deixaremos isso de lado e consideraremos outro caso de uso. Imagine que queiramos usar o Mockery em vez das factories do Laravel. Começamos gerando nossos testes da mesma forma que fizemos no post anterior do nosso blog, mas, desta vez, gastaremos um pouco mais de tempo ajustando a saída do AI Assistant.
Depois de gerar uma versão rascunho da nossa classe de teste, você notará um botão Specify na barra de ferramentas superior:
Este botão permite enviar informações adicionais ao AI Assistant, especificando ainda mais o prompt. Você poderia, por exemplo, escrever um prompt que diga para usar o Mockery assim:
Depois de escrever este prompt personalizado e pressionar Enter, você verá que o AI Assistant atualiza o código de acordo.
Você pode ajustar seus prompts o quanto quiser até encontrar uma solução que atenda às suas necessidades.
Conclusão
Ao experimentar a especificação de prompts, tenha em mente o objetivo que discutimos no início desta série de posts: não pretendemos que o AI Assistant gere os testes perfeitos para nós. Queremos que ele faça a configuração padrão chata, para que possamos nos concentrar principalmente em fazer os ajustes finais: as partes que são mais divertidas.
Com isso em mente, acho importante não especificar demais seus prompts. Provavelmente, será mais produtivo gerar um código 90% do seu agrado, em vez de gastar mais tempo tentando encontrar o prompt perfeito.
Um último efeito colateral que você pode notar é que o AI Assistant realmente aprende com suas instruções ao longo do tempo. Por exemplo, agora que especificamos que gostaríamos de usar o Mockery em vez das factories do Laravel, a ferramenta levará isso em consideração na próxima vez que gerar testes.
Se quiser saber mais sobre como o AI Assistant funciona nos bastidores e como ele lida com seus dados, acesse os Termos de Serviço do JetBrains AI (seção 5) para ler tudo sobre isso.
—
Até agora nesta série, usamos o AI Assistant para gerar testes para nós e aprendemos como ajustar nossos prompts para obter o resultado de que precisamos.
Qual é o próximo passo? O PhpStorm tem alguns recursos bastante interessantes para combinar o AI Assistant com ações personalizadas. Assine nosso blog para ficar em dia sobre nossos próximos posts, nos quais continuaremos explorando os benefícios de usar a IA em rotinas PHP.
Links úteis
Recursos:
- AI Assistant no PhpStorm (documentação)
- Preços do AI Assistant
Vídeos:
- Introdução ao JetBrains AI Assistant
- Usando PHP e IA para construir um conversor de Markdown para vídeo
Artigo original em inglês por:
Subscribe to PhpStorm Blog updates
Discover more
IA para PHP: cómo optimizar las peticiones a la IA para mejorar las pruebas de PHP
En nuestro artículo anterior, vimos cómo JetBrains AI Assistant puede estructurar automáticamente las pruebas de unidad por nosotros. Al generar el aburrido código reutilizable, nos permite saltar directamente a la parte más interesante de la creación de pruebas.
Al experimentar con la generación de pruebas con la IA, a menudo me he sorprendido de lo preciso que es AI Assistant a la hora de generar código que se ajuste a mi proyecto. Sin embargo, hay casos en los que me gustaría que el resultado fuera ligeramente diferente. Si pudiéramos darle algunas pistas sobre cómo debería ser el resultado…
Pues resulta que precisamente podemos hacerlo.
Peticiones más específicas
Volvamos al ejemplo de nuestro artículo anterior: estamos trabajando en las pruebas para la clase CreateArgumentComment. Esta clase escribe un registro en la base de datos, determina a qué usuarios notificar y, a continuación, envía esas notificaciones a los usuarios (utilizando otra clase: SendUserMessage). Este es el aspecto de ese código:
final readonly class CreateArgumentComment
{
public function __invoke(
Argument $argument,
User $user,
string $body,
): void
{
ArgumentComment::create([
'user_id' => $user->id,
'argument_id' => $argument->id,
'body' => $body,
]);
$this->notifyUsers($argument, $user);
}
private function notifyUsers(Argument $argument, User $user): void
{
$usersToNotify = $argument->comments
->map(fn (ArgumentComment $comment) => $comment->user)
->add($argument->user)
->reject(fn (User $other) => $other->is($user))
->unique(fn (User $user) => $user->id);
foreach ($usersToNotify as $userToNotify) {
(new SendUserMessage)(
to: $userToNotify,
sender: $user,
url: action(RfcDetailController::class, ['rfc' => $argument->rfc_id, 'argument' => $argument->id]),
body: 'wrote a new comment',
);
}
}
}
Se habrá dado cuenta de que AI Assistant no ha escrito ninguna prueba para la parte de notificación en este fragmento. De hecho, ha escrito pruebas para esta parte en algunas iteraciones, pero no siempre.
Una generación interesante ha incluido el siguiente comentario al final de la clase de prueba:
// And: we should expect the users to be notified about the comment, // this part is not implemented due to its complexity // it requires mocking dependencies and testing side effects // 'notifyUsers' is private method and we can't access it directly // however, in real world scenario you might want to consider testing // it (possibly refactoring to a notification class, and testing independently)
Naturalmente, podríamos pedir a AI Assistant que genere estas pruebas de todos modos, pero en realidad estoy de acuerdo con él en esto; notifyUsers debería ser una clase por sí misma, probada de forma aislada. Aunque en un principio había planeado profundizar en las pruebas de notificación, AI Assistant ha resaltado un mejor enfoque respecto a ellas y me ha ayudado a replantear mi proyecto. ¡Gracias, AI Assistant! Puesto que hemos decidido probar notifyUsers por separado, lo dejaremos a un lado y consideraremos otro caso práctico. Imaginemos que queremos utilizar Mockery en lugar de las factories de Laravel. Empezaremos generando nuestras pruebas del mismo modo que en el artículo anterior, pero esta vez dedicaremos un poco más de tiempo a pulir el resultado de AI Assistant.
Tras generar una versión borrador de nuestra clase de prueba, verá el botón Specifyen la barra de herramientas superior:
Este botón le permite enviar información adicional a AI Assistant, para que su petición sea incluso más específica. Podría, por ejemplo, indicarle que utilice Mockery de esta forma:
Tras escribir esta petición personalizada y pulsar Intro, verá que AI Assistant actualiza el código en consecuencia.
Puede optimizar sus peticiones tanto como desee, hasta que encuentre una solución que se adapte a sus necesidades.
Conclusión
A medida que experimente con la especificación de sus peticiones, tenga en cuenta el objetivo que comentamos al principio de esta serie de artículos del blog: no pretendemos que AI Assistant genere las pruebas perfectas para nosotros. Queremos que se encargue de la aburrida configuración repetitiva para que podamos centrarnos principalmente en hacer los retoques finales, que son las partes más divertidas.
Teniendo esto en cuenta, creo que es importante no especificar en exceso las peticiones. Probablemente será más productivo generar un código que esté a su gusto en un 90 %, en lugar de dedicar más tiempo a intentar encontrar la petición perfecta.
Una última consecuencia que tal vez haya notado es que AI Assistant aprende de sus peticiones con el tiempo. Por ejemplo, ahora que hemos especificado que queremos que utilice Mockery en lugar de las factories de Laravel, la herramienta lo tendrá en cuenta la próxima vez que genere pruebas.
Si desea saber más sobre cómo funciona AI Assistant entre bastidores y cómo trata sus datos, consulte las Condiciones de servicio de JetBrains AI (sección 5).
—
Hasta ahora, en esta serie, hemos utilizado AI Assistant para que genere pruebas por nosotros, y hemos aprendido a optimizar nuestras peticiones para obtener el resultado que necesitamos.
¿Cuál es el siguiente paso? PhpStorm tiene algunas funcionalidades muy interesantes para combinar AI Assistant con acciones personalizadas. Suscríbase a nuestro blog para estar al día de nuestras próximas publicaciones, en las que seguiremos explorando las ventajas de utilizar la IA para sus rutinas PHP.
Enlaces útiles
Recursos:
- AI Assistant en PhpStorm (documentación)
- Precios de AI Assistant
Vídeos:
- Presentación de JetBrains AI Assistant
- Utilización de PHP y de la IA para crear un convertidor de Markdown a vídeo
Artículo original en inglés de:
Subscribe to PhpStorm Blog updates