strategy to fire polymorphic rules

I’m evaluating Octopus and am unable to model a couple of use cases, so I’m wondering if I’m just “doing it wrong”.

• An ability to define a rule on an trait of abstract type and derive the rules across the type hierarchy. I don’t think is supported, or at least the shapes example doesn’t exercise it.
• Map field names to errors. I think I’m just missing something, as the documentation explicitly suggests that this case should work by default.

All four of the following tests fail:

class OctopusValidationTest extends BaseUnitTest {

  import octopus.syntax._
  import octopus.dsl._

  trait HasName {
    val name: String
  }
  sealed trait Pet extends HasName
  object Pet {
    implicit val nameIsRequiredAndCantStartWithZ: Validator[Pet] = Validator[Pet]
      .rule(_.name.nonEmpty, "is required")
      .rule(_.name.startsWith("Z"), "can't start with Z")
  }

  case class Dog(name: String) extends Pet
  object Dog {
    implicit val allDogsMustBeNamedRooney: Validator[Dog] = Validator[Dog]
      .rule(_.name == "Rooney", "is not Rooney")
  }

  case class Cat(name: String) extends Pet
  object Cat {
    implicit val allCatNamesLessThanFive: Validator[Cat] = Validator[Cat]
      .rule(_.name.length < 5, "is too long")
  }

  def validate[T <: Pet: Validator](pet: T) = pet.validate.toFieldErrMapping

  // this test fails because the error is ("","is not Rooney")
  test("dogs name is not rooney") {
    val notRooney = Dog("Bart")
    val errors = validate(notRooney)
    errors should have size 1
    errors should contain theSameElementsAs List(
      ("name", "is not Rooney")
    )
  }

  // this test fails because the error is ("","is too long")
  test("cats name is too long") {
    val rumpelstiltskin = Cat("Rumpelstiltskin")
    val errors = validate(rumpelstiltskin)
    errors should have size 1
    errors should contain theSameElementsAs List(
      ("name", "is too long")
    )
  }

  // this only tests concrete rule, how do we trigger the pet rule?
  test("pets name isEmpty and not Rooney") {
    val emptyDog = Dog("")
    validate(emptyDog) should have size 2
  }

  // this only tests concrete rule, how do we trigger the pet rule?
  test("cats name is too long and starts with Z") {
    val zumpelstiltskin = Cat("Zumpelstiltskin")
    validate(zumpelstiltskin) should have size 2
  }
}

[andyczerwonka]

Found it, data used a HashMap in the API, that it fails on that type. It I change it to a Map, works fine.

[andyczerwonka]

@krzemin Yes, the second approach is fine. It does find the concrete rules. The following test now passes.

  test("a family with a few pets") {
    val failingPets = List(Cat("Zumpelstiltskin"), Dog(""))
    val family = Family("", Dog("Rooney"), failingPets)
    val errors = validate(family)
    errors should have size 5
    errors should contain theSameElementsAs List(
      ("otherPets[0].name", "can't start with Z"),
      ("otherPets[0].name", "is too long"),
      ("otherPets[1].name", "is required"),
      ("otherPets[1].name", "is not Rooney"),
      ("name", "is required")
    )
  }

It would be nice to be able to construct the message using the object for each rule. I think I saw a feature request around that.