O problema

Estou escrevendo testes unitários para um microserviço feito com TypeScript, testando funções que buscam dados no banco de dados, removem determinadas propriedades do objeto e o retorna para o cliente. Preciso ter certeza de que os dados estão sendo removidos, e para não reescrever todo o payload no meu arquivo de testes exceto pelas propriedades removidas, busquei uma solução mais simples.

Exemplo

// Função a ser testada

function fetchFromDatabase() {
  const payload = {
    id: 1,
    name: 'Vitor',
    secret: 'My secret'
  }

  delete payload.secret

  return payload
}

...

// Arquivo de teste (usando o chai, mas poderia ser qualquer lib de testes)

function testMyFunction() {
  const mock = {
    id: 1,
    name: 'Vitor',
    secret: 'My secret'
  }
  insertIntoDatabase(mock) // Exemplo adicionando um mock no banco de dados

  const result = fetchFromDatabase()

  const { secret, ...allowedProperties } = mock // Onde a mágica acontece.

  expect(result).to.be.eql(allowedProperties) // returns: true
}

O que aconteceu?

Usamos o destructuring para selecionar as propriedades que não queremos, e com o spread operator (...) salvamos todo o resto (propriedades que queremos) dentro de allowedProperties.

E o delete?

Na função que é testada é usada a keyword delete, mas poderia ser facilmente substituída pela nossa "técnica" de destructuring + spread operator.

No JavaScript temos a keyword delete, que remove uma propriedade de um objeto.

const obj = { name: 'Vitor', role: 'Developer' }

delete obj.role

console.log(obj) // { name: 'Vitor' }

Entretanto, como podemos ver, ao usarmos o delete o nosso objeto é mutado. Particularmente, não é um comportamento que gosto de manter na minha base de código, pois pode dificultar os meus testes e criar side effects difíceis de debugar.