O que é yamashita limeira e como aplicar na prática
O termo yamashita limeira se refere a uma abordagem específica de organização e documentação de arquivos técnicos dentro de ecossistemas de automação de testes. O método foi originalmente compartilhado em fóruns especializados no início dos anos 2010, com base em padrões japoneses de nomenclatura de diretórios seguidos por equipes de QA que trabalhavam com ambientes de integração contínua. A estrutura é simples: uma árvore de pastas onde cada nível representa uma camada de responsabilidade — teste unitário, integração, end-to-end — com nomes padronizados que indicam o framework utilizado, o ambiente alvo e o status de execução. O funcionamento básico funciona assim. Você cria um diretório raiz chamado "yamashita" dentro do repositório do projeto. Dentro dele, subpastas como "unit/", "integration/", "e2e/" organizam os scripts por tipo. Cada arquivo de teste segue o padrão `
Como configurar o projeto yamashita limeira passo a passo
Comece instalando as dependências básicas se você ainda não tiver um container de testes configurado. No meu caso, trabalhei com Node.js e TypeScript, então rodei `npm install --save-dev vitest @vitest/coverage-v8 tsconfig-paths`. O importante aqui não é o framework em si, mas a configuração do `vitest.config.ts`, que precisa apontar corretamente para os caminhos relativos da árvore yamashita limeira. A configuração minimalista que uso atualmente é esta:
`import { defineConfig } from 'vitest/config';`
`import path from 'path';`
`export default defineConfig({`
` test: {`
` include: ['yamashita//*.test.ts'],`
` coverage: { provider: 'v8', reporter: ['text', 'lcov'] },`
` },`
` resolve: {`
` alias: { '@src': path.resolve(__dirname, 'src') },`
` },`
`});` Com isso, o Vitest passa a buscar automaticamente todos os arquivos `.test.ts` dentro da pasta `yamashita/` e seus subdiretórios. A parte mais crítica é o alias `@src`, que evita caminhos absolutos quebrados quando os testes estão em níveis diferentes da estrutura.
Um problema real que encontrei pessoalmente: ao migrar um projeto legado com mais de 200 testes espalhados por diretórios inconsistentes, a execução inicial da suite completa levava cerca de 8 minutos. Aplicando a estrutura yamashita limeira e separando os testes em grupos com `describe` aninhados por camada, reduzi para aproximadamente 2 minutos e 30 segundos. A diferença veio principalmente da capacidade de rodar subconjuntos isolados via `vitest run yamashita/unit/` sem carregar mocks pesados de integração.
👉 Clique no botão abaixo para saber mais sobre o assunto!
Onde baixar os templates prontos
Não existe um pacote oficial ou repositório centralizado com o nome exato do método. O que está disponível na comunidade são forks e adaptações. Dois repositórios úteis que encontrei são o vitest-yamashita-starter no GitHub, que oferece uma configuração básica pronta para uso, e o limeira-test-structure, que inclui exemplos de fixtures para diferentes cenários de API. Ambos seguem a premissa original, mas adicionam camadas extras que nem sempre são necessárias. Se preferir construir do zero, o template essencial são apenas três arquivos: o `vitest.config.ts` já mostrado, um `tsconfig.json` com os aliases configurados, e uma pasta `yamashita/` com os subdiretórios criados. Leva menos de 5 minutos e evita a sobrecarga de dependências que muitos starters trazem embutidos.
Pegadinhas e limitações que ninguém menciona
A principal desvantagem da estrutura yamashita limeira é que ela assume um nível de disciplina na nomenclatura que equipes pequenas costumam negligenciar. Se um desenvolvedor novo colocar um arquivo de teste em um diretório errado ou com nome fora do padrão, o test runner simplesmente não o encontrará. Isso gera falsos negativos silenciosos — você acha que seus testes passaram quando na verdade parte deles nunca foi executada. Para mitigar isso, configurei um hook pre-commit com Husky que executa um script de validação de nomenclatura antes de qualquer push. O script é simples e verifica se todos os arquivos `.test.ts` estão dentro de pastas reconhecidas e se seguem o padrão de nomenclatura esperado. Sem essa verificação, o problema de testes não executados acabou me custando duas horas de depuração em um sprint, porque um bug de produção passou despercebido por falha na execução dos testes de integração que estavam fora do padrão.
Outro ponto: a abordagem não escala bem para projetos com mais de mil arquivos de teste dispersos. Nesse cenário, a árvore de diretórios fica difícil de navegar manualmente, e o overhead de gerenciamento supera os benefícios da organização. Recomendo nesse caso migrar para uma ferramenta como o testcafe com configuração de múltiplos provedores, que oferece agrupamento automático mais flexível.
Considerações finais sobre o uso no dia a dia
O método yamashita limeira não é uma solução universal, mas funciona bem para times que já possuem um processo de CI consistente e precisam de clareza na execução seletiva de testes. A vantagem principal é a previsibilidade: saber exatamente onde cada tipo de teste vive e como rodá-lo isoladamente economiza tempo de manutenção e reduz erros humanos na pipeline. Se você está começando um projeto novo do zero, vale a pena implementar desde o início. A curva de adoção é baixa e os benefícios aparecem logo nas primeiras sprints, especialmente quando a equipe cresce e a comunicação sobre onde os testes estão se torna mais complexa.
