Testes automatizados em React Native com Supabase: um guia prático

Lucas Moraes (CEO Toolzz AI)
19 de março de 2026

Testes automatizados são cruciais para garantir a qualidade e a estabilidade de aplicações React Native que utilizam Supabase. No entanto, configurar um ambiente de testes eficiente pode ser desafiador. Este artigo explora estratégias e ferramentas para simplificar e otimizar esse processo, assegurando que sua aplicação permaneça robusta e confiável.

O desafio dos testes com Supabase

Integrar o Supabase em testes automatizados apresenta desafios únicos. As consultas ao banco de dados são frequentemente estruturadas como cadeias (chains) de métodos, o que dificulta a criação de mocks eficazes. Abordagens comuns, como simular o cliente Supabase globalmente, podem levar a problemas de escopo e dificuldades em isolar o comportamento de cada teste.

As soluções tradicionais, como utilizar um banco de dados de teste real ou interceptar requisições HTTP com MSW (Mock Service Worker), podem ser lentas, complexas e introduzir dependências externas. A simulação direta do cliente Supabase, embora mais rápida, muitas vezes resulta em mocks inflexíveis e difíceis de manter.

Injeção de dependência: a chave para testes isolados

A injeção de dependência surge como uma solução elegante para este problema. Em vez de importar o cliente Supabase diretamente nos seus serviços, injete-o como uma dependência no construtor da classe. Isso permite substituir o cliente real por um mock durante os testes, proporcionando controle total sobre o comportamento do banco de dados.

Considere o seguinte exemplo de um serviço de perfil de usuário:

typescript import { SupabaseClient } from '@supabase/supabase-js' import { Database } from '../types/database' import { Profile, ProfileUpdate } from '../types'

export class ProfileService { constructor(private client: SupabaseClient) {}

async getProfile(userId: string): Promise { const { data, error } = await this.client .from('profiles') .select('*') .eq('id', userId) .single()

if (error) throw error
return data

}

async updateProfile(userId: string, updates: ProfileUpdate): Promise { const { data, error } = await this.client .from('profiles') .update({ ...updates, updated_at: new Date().toISOString() }) .eq('id', userId) .select() .single()

if (error) throw error
return data

} }

Em vez de importar o cliente Supabase diretamente, o ProfileService recebe uma instância de SupabaseClient no construtor. Isso possibilita injetar um mock do cliente durante os testes.

Criando um mock chainable

Para simular as consultas chainable do Supabase, você pode criar um mock customizado que imita o comportamento da cadeia de métodos. Esse mock deve retornar o mesmo objeto chain a cada chamada de método, permitindo configurar o valor resolvido no método terminal da cadeia.

typescript export function createSupabaseChainMock(resolvedValue: unknown, error?: unknown) { const chain: Record<string, jest.Mock> = {}

const terminal = error ? jest.fn().mockRejectedValue(error) : jest.fn().mockResolvedValue({ data: resolvedValue, error: null })

const returnChain = jest.fn().mockReturnValue(chain)

// Filter/builder methods: all return the chain for continued chaining chain.select = returnChain chain.insert = returnChain chain.update = returnChain chain.delete = returnChain chain.upsert = returnChain chain.eq = returnChain chain.neq = returnChain chain.gt = returnChain chain.gte = returnChain chain.lt = returnChain chain.lte = returnChain chain.like = returnChain chain.ilike = returnChain chain.in = returnChain chain.is = returnChain chain.order = returnChain chain.limit = returnChain chain.range = returnChain chain.filter = returnChain chain.match = returnChain chain.not = returnChain chain.or = returnChain chain.contains = returnChain chain.containedBy = returnChain chain.overlaps = returnChain

// Terminal calls: resolve the chain chain.single = terminal chain.maybeSingle = terminal chain.then = jest.fn((resolve: (val: unknown) => void) => Promise.resolve({ data: resolvedValue, error: null }).then(resolve) )

return { from: jest.fn().mockReturnValue(chain), chain, } }

Este helper permite definir o valor resolvido ou o erro que será retornado pela consulta, além de verificar se os métodos da cadeia foram chamados com os argumentos corretos.

Simplificando a criação de dados de teste

Para facilitar a criação de dados de teste consistentes e legíveis, utilize data factories. Data factories são funções que retornam objetos com valores padrão, permitindo sobrescrever apenas os campos relevantes para cada teste. Isso reduz a duplicação de código e melhora a clareza dos testes.

typescript import { Profile } from '../../../src/types'

export function createMockProfile(overrides: Partial = {}): Profile { return { id: 'user-uuid-1', updated_at: '2024-01-01T00:00:00Z', username: 'testuser', full_name: 'Test User', avatar_url: null, subscription_tier: 'free', ...overrides, } }

Com data factories, seus testes se tornam mais concisos e fáceis de entender.

Exemplo completo de teste

Combinando a injeção de dependência, o mock chainable e as data factories, seus testes se tornam precisos e legíveis:

typescript import { ProfileService } from '../../src/services/profile-service' import { createSupabaseChainMock } from '../helpers/supabase-chain-mock' import { createMockProfile } from '../helpers/factories/profile.factory'

describe('ProfileService', () => { describe('getProfile', () => { it('returns a profile for a given user', async () => { const mockProfile = createMockProfile({ username: 'dusty' }) const { from, chain } = createSupabaseChainMock(mockProfile) const mockClient = { from } as any

  const service = new ProfileService(mockClient)
  const result = await service.getProfile('user-uuid-1')

  expect(result).toEqual(mockProfile)
  expect(from).toHaveBeenCalledWith('profiles')
  expect(chain.eq).toHaveBeenCalledWith('id', 'user-uuid-1')
  expect(chain.single).toHaveBeenCalled()
})

it('throws when the query fails', async () => {
  const dbError = { message: 'Permission denied', code: '42501' }
  const { from } = createSupabaseChainMock(null, dbError)
  const mockClient = { from } as any

  const service = new ProfileService(mockClient)

  await expect(service.getProfile('user-uuid-1')).rejects.toEqual(dbError)
})

}) })

Este exemplo demonstra como testar o método getProfile do ProfileService de forma isolada e controlada.

Testando autenticação

A API de autenticação do Supabase não utiliza o query builder chainable, o que simplifica o processo de mocking. Você pode criar mocks diretos para os métodos de autenticação, como signInWithPassword e signUp.

typescript function createMockAuthClient(overrides: Record<string, jest.Mock> = {}) { return { auth: { signInWithPassword: jest.fn(), signUp: jest.fn(), signOut: jest.fn(), getSession: jest.fn(), ...overrides, }, } as any }

Conclusão

Testes automatizados são essenciais para o sucesso de qualquer projeto React Native com Supabase. Ao adotar a injeção de dependência, criar mocks chainable e utilizar data factories, você pode simplificar e otimizar seus testes, garantindo a qualidade e a estabilidade da sua aplicação. Implementar essas práticas não apenas economiza tempo e recursos a longo prazo, mas também aumenta a confiança na sua base de código, permitindo que você entregue funcionalidades de forma mais rápida e segura.

Além disso, a Toolzz oferece soluções de automação que podem complementar sua estratégia de testes, permitindo que você se concentre em criar a melhor experiência possível para seus usuários. Com os agentes de IA da Toolzz, você pode automatizar tarefas repetitivas, como a criação de dados de teste, liberando sua equipe para se concentrar em desafios mais complexos e criativos.