Мы можем объединить допустимый экземпляр и набор недопустимых полей (так что каждое поле, если оно будет скопировано, приведет к сбою проверки), чтобы получить недопустимый объект, используя shapeless.

Shapeless позволяет вам представить свой класс в виде списка пар ключ-значение, которые по-прежнему строго типизированы и поддерживают некоторые высокоуровневые операции, а также обратное преобразование из этого представления в исходный класс.

В приведенном ниже примере я предоставлю недопустимый экземпляр для каждого предоставленного поля.

import shapeless._, record._
import shapeless.labelled.FieldType
import shapeless.ops.record.Updater

Подробное введение

Давайте представим, что у нас есть класс данных и его действительный экземпляр (нам нужен только один, поэтому его можно жестко закодировать)

case class User(id: String, name: String, about: String, age: Int) {
  def isValid = id.length == 3 && name.nonEmpty && age >= 0
}
val someValidUser = User("oo7", "Frank", "A good guy", 42)
assert(someValidUser.isValid)

Затем мы можем определить класс, который будет использоваться для недопустимых значений:

case class BogusUserFields(name: String, id: String, age: Int)
val bogusData = BogusUserFields("", "1234", -5)

Экземпляры таких классов могут быть предоставлены с помощью ScalaCheck. Гораздо проще написать генератор, в котором все поля вызовут сбой. Порядок полей не имеет значения, важны их имена и типы. Здесь мы исключили about из User набора полей, чтобы мы могли сделать то, о чем вы просили (загрузив только подмножество полей, которые вы хотите протестировать).

Затем мы используем LabelledGeneric[T] для преобразования User и BogusUserFields в соответствующее значение записи (позже мы преобразуем User обратно)

val userLG = LabelledGeneric[User]
val bogusLG = LabelledGeneric[BogusUserFields]

val validUserRecord = userLG.to(someValidUser)
val bogusRecord = bogusLG.to(bogusData)

Записи представляют собой списки пар ключ-значение, поэтому мы можем использовать head для получения одного сопоставления, а оператор + поддерживает добавление/замену поля в другую запись. Давайте выберем каждое недопустимое поле в нашем пользователе по одному. Кроме того, вот обратное преобразование в действии:

val invalidUser1 = userLG.from(validUserRecord + bogusRecord.head)// invalid name
val invalidUser2 = userLG.from(validUserRecord + bogusRecord.tail.head)// invalid ID
val invalidUser3 = userLG.from(validUserRecord + bogusRecord.tail.tail.head) // invalid age

assert(List(invalidUser1, invalidUser2, invalidUser3).forall(!_.isValid))

Поскольку мы в основном применяем одну и ту же функцию (validUserRecord + _) к каждой паре ключ-значение в нашем bogusRecord, мы также можем использовать оператор map, за исключением того, что мы используем его с необычной — полиморфной — функцией. Мы также можем легко преобразовать его в List, потому что теперь все элементы будут одного типа.

object polymerge extends Poly1 {
  implicit def caseField[K, V](implicit upd: Updater[userLG.Repr, FieldType[K, V]]) =
    at[FieldType[K, V]](upd(validUserRecord, _))
}

val allInvalidUsers = bogusRecord.map(polymerge).toList.map(userLG.from)
assert(allInvalidUsers == List(invalidUser1, invalidUser2, invalidUser3))

Обобщение и удаление всех шаблонов

Весь смысл этого заключался в том, что мы можем обобщить его для работы с любыми двумя произвольными классами. Кодирование всех взаимосвязей и операций немного громоздко, и мне потребовалось некоторое время, чтобы разобраться со всеми ошибками implicit not found, поэтому я пропущу подробности.

class Picks[A, AR <: HList](defaults: A)(implicit lgA: LabelledGeneric.Aux[A, AR]) {
  private val defaultsRec = lgA.to(defaults)

  object mergeIntoTemplate extends Poly1 {
    implicit def caseField[K, V](implicit upd: Updater[AR, FieldType[K, V]]) =
      at[FieldType[K, V]](upd(defaultsRec, _))
  }

  def from[B, BR <: HList, MR <: HList, F <: Poly](options: B)
    (implicit
      optionsLG: LabelledGeneric.Aux[B, BR],
      mapper: ops.hlist.Mapper.Aux[mergeIntoTemplate.type, BR, MR],
      toList: ops.hlist.ToTraversable.Aux[MR, List, AR]
    ) = {
    optionsLG.to(options).map(mergeIntoTemplate).toList.map(lgA.from)
  }
}

Итак, вот он в действии:

val cp = new Picks(someValidUser)
assert(cp.from(bogusData) == allInvalidUsers)

К сожалению, вы не можете написать new Picks(someValidUser).from(bogusData), потому что неявно для mapper требуется стабильный идентификатор. С другой стороны, экземпляр cp можно повторно использовать с другими типами:

case class BogusName(name: String)
assert(cp.from(BogusName("")).head == someValidUser.copy(name = ""))

И теперь это работает для всех типов! И фиктивные данные должны быть любым подмножеством полей класса, поэтому они будут работать даже для самого класса.

case class Address(country: String, city: String, line_1: String, line_2: String) {
  def isValid = Seq(country, city, line_1, line_2).forall(_.nonEmpty)
}

val acp = new Picks(Address("Test country", "Test city", "Test line 1", "Test line 2"))
val invalidAddresses = acp.from(Address("", "", "", ""))
assert(invalidAddresses.forall(!_.isValid))

Вы можете увидеть работающий код на странице ScalaFiddle.