Валидация данных — отнюдь не новое явление в разработке программного обеспечения. Она была, есть и будет оставаться актуальной задачей, которая не терпит халатности. Комплексная (comprehensive) валидация данных преследует две следующие цели:
Препятствовать внедрению недопустимых состояний в наши приложения
Аккумулировать максимально полный список причин отказа в валидации (Это не может быть достигнуто с помощью Either[E, A], так как это монадическая структура — поддерживает вычисление по сокращенной схеме (short circuiting) в вызовах flatMap и производит возврат, как только встречает первый Left, поэтому нам нужно что-то другое)
В этой статье мы с вами будем решать практическую задачу — реализуем комплексную валидацию для ситуации, когда пользователь пытается создать пароль для своего профиля.
Наша цель — аккумулировать ошибки валидации таким образом, чтобы пользователь увидел все допущенные им ошибки в пользовательском интерфейсе одновременно и мог изменить свой пароль в соответствии с нашими требования за одну попытку.
Но для начала нам необходимо убедиться в том, что предоставленный пароль соответствует стандартам безопасности, т.е. он должен быть проверен на соответствие четырем бизнес-правилам:
Он должен быть не пустым (кто бы мог подумать?!)
Он должен содержать хотя бы один символ в верхнем регистре
Чтобы считаться достаточно длинным, он должен содержать более 8 символов
Он должен содержать хотя бы один из этих специальных символов: !@#$%^&*()
С этим нам поможет знаменитая библиотека cats, а именно конструкции, которые можно найти в пакете cats.data, такие как: Validated (избавляет нас от ограничений Either[E, A]), NonEmptyList и специальный псевдоним типа, связанный с упомянутым выше.
Прежде всего, давайте познакомимся с Validated и NonEmptyList, а затем перейдем к реализации.
Validated — это структура данных, представляющая из себя тип-сумму из двух case-классов Valid или Invalid, которая оборачивает базовые данные, подлежащие проверке.
Простой пример, демонстрирующий иерархию Validated:
sealed trait Validated[+E, +A] { // куча абстрактных методов } object Validated { final case class Valid(data: A) extends Validated[Nothing, A] final case class Invalid(error: E) extends Validated[E, Nothing] }
Таким образом, очевидно, что левая часть +E предназначена для хранения ошибок валидации, а правая часть +A — для хранения переданных значений.
На первый взгляд это выглядит так же, как и Either[+E, +A] с его Left и Right частями, но на практике работает по-другому.
Простой пример создания Valid данных:
import cats.data.Validated val validPass: Validated[Nothing, String] = Validated.Valid("MyPassword!2#")
Простой пример создания Invalid данных:
import cats.data.Validated val invalidPass: Validated[String, Nothing] = Validated.Invalid("The password is invalid due to ...")
А для того, чтобы обернуть что-либо в Validated, мы можем использовать методы расширения:
import cats.syntax.all._ val validPass: Validated[Nothing, String] = "MyPassword!2#".valid val invalidPass: Validated[String, Nothing] = "The password is invalid due to ...".invalid
Достаточно просто, не так ли?
Теперь давайте разберемся с NonEmptyList. Как следует из названия, это, по сути, непустой список. Иногда NonEmptyList называют Nel (тут намеренный каламбур с Nil, который является пустым списком), и он основан на реализации односвязного списка.
Простая демонстрация использования NonEmptyList:
import cats.data.NonEmptyList val oneElementList: NonEmptyList[Int] = NonEmptyList.one(1) val maybeNonEmptyList1: Option[NonEmptyList[Int]] = NonEmptyList.fromList(Nil) // None, из-за параметра Nil val maybeNonEmptyList2: Option[NonEmptyList[Int]] = NonEmptyList.fromList(List(1, 2, 3)) // Some(...) из-за параметра List(1, 2, 3) NonEmptyList.fromListUnsafe(Nil) //выбрасывает исключение из-за параметра Nil
Еще проще, не правда ли?
А теперь посмотрим на тот самый псевдоним типа, который подходит для наших целей:
type ValidatedNel[+E, +A] = Validated[NonEmptyList[E], A]
Таким образом, после применения правил валидации мы получаем либо NonEmptyList ошибок — E, либо данные — A, которые удовлетворяют нашим правилам валидации.
Отлично! Теперь давайте создадим доменную модель для пароля и связанную с ней ADT иерархии ошибок:
final case class Password(value: String) extends AnyVal // value class object Password { // ADT ошибок валидации sealed trait ValidationError object ValidationError { case object IsEmpty extends ValidationError case object LacksUppercaseChar extends ValidationError case object IsShort extends ValidationError case object LacksSpecialSymbol extends ValidationError } }
Пока все выглядит достаточно просто. Теперь давайте разработаем протокол, который описывает проверку пароля на высоком уровне:
import Password.ValidationError trait PasswordValidations { def validate(password: String): ValidatedNel[ValidationError, Password] }
И, наконец, напишем реализацию в объекте-компаньоне PasswordValidations:
def create: PasswordValidations = password => { import Password.ValidationError import Password.ValidationError._ def validate( condition: Boolean, failureReason: ValidationError ): ValidatedNel[ValidationError, Unit] = if (!condition) failureReason.invalidNel else ().valid def isNonEmpty = validate(password.nonEmpty, IsEmpty) def containsUpperCaseCharacter = validate(password.exists(_.isUpper), LacksUppercaseChar) def isLong = validate(password.length > 8, IsShort) def hasSpecialSymbol = validate( password.exists(c => "!@#$%^&*()".contains(c.toString)), LacksSpecialSymbol ) // Здесь нам необходимо вызвать следующие методы: // 1. isNonEmpty // 2. containsUpperCaseCharacter // 3. isLong // 4. hasSpecialSymbol // и аккумулировать ошибки в канале Invalid, если таковые имеются // или вернуть проверенный пароль, обернутый конструктором Valid ??? } }
Мы почти у цели. Теперь нам нужен способ задействовать все четыре внутренние функции валидации и:
Если хотя бы один или несколько из них не пройдены — возвращается конкатенированный
Invalid(NonEmptyList[ValidationError](...))Если все пройдены — возвращаем
Valid(Password(...))
Существует несколько способов сделать это, но здесь я покажу вам только свой любимый подход, заключающийся в использовании метода расширения .tupled, который определяется на кортежах произвольных значений, обернутых чем-то вроде Option, Either или, в нашем случае, Validated.
Под капотом .tupled использует typeclass Semigroupal и операцию произведения для достижения следующих целей:
import cats.syntax.all._ val maybe1 = Option(1) val maybe2 = Option(2) val result: Option[(Int, Int)] = (maybe1, maybe2).tupled // Some(1, 1)
В нашем случае кортеж будет содержать вызовы внутренних функций с типом возврата: ValidatedNel[ValidationError, Unit].
Таким образом, мы можем написать что-то вроде:
import cats.syntax.all._ // .tupled объединяет списки NonEmptyList[ValidationError], если они являются невалидными (Invalid) // и перебирает значения Unit, если они являются валидными (Valid) val result: ValidatedNel[ValidationError, (Unit, Unit, Unit, Unit)] = ( isNonEmpty, containsUpperCaseCharacter, isLong, hasSpecialSymbol ).tupled
Но... этого недостаточно, мы хотим иметь в конце такую сигнатуру: ValidatedNel[ValidationError, Password], чтобы мы могли легко вызвать map на результае как:
result.map(_ => Password(password)) // ValidatedNel[ValidationError, Password]
или использовать метод расширения .as, что делает его еще более лаконичным и читабельным:
result.as(Password(password)) // ValidatedNel[ValidationError, Password]
Итак, теперь давайте соберем все воедино:
object PasswordValidations { def create: PasswordValidations = password => { import Password.ValidationError import Password.ValidationError._ def validate( condition: Boolean, failureReason: ValidationError ): ValidatedNel[ValidationError, Unit] = if (!condition) failureReason.invalidNel else ().valid def isNonEmpty = validate(password.nonEmpty, IsEmpty) def containsUpperCaseCharacter = validate(password.exists(_.isUpper), LacksUppercaseChar) def isLong = validate(password.length > 8, IsShort) def hasSpecialSymbol = validate( password.exists(c => "!@#$%^&*()".contains(c.toString)), LacksSpecialSymbol ) ( isNonEmpty, containsUpperCaseCharacter, isLong, hasSpecialSymbol ).tupled.as(Password(password)) } }
Теперь давайте напишем тесты для нашего сервиса валидации:
Ожидается Invalid(NonEmptyList(IsEmpty, LacksUppercaseChar, IsShort, LacksSpecalSymbol)), поскольку все четыре правила не удовлетворены:
import Password.ValidationError._ val service = PasswordValidations.create val expected = NonEmptyList.fromListUnsafe { List(IsEmpty, LacksUppercaseChar, IsShort, LacksSpecialSymbol) }.invalid assert(service.validate("") == expected)
Ожидается Invalid(NonEmptyList(LacksUppercaseChar, IsShort)):
import Password.ValidationError._ val service = PasswordValidations.create val expected = NonEmptyList.fromListUnsafe { List(LacksUppercaseChar, IsShort) }.invalid assert(service.validate("pa$$") == expected)
Ожидается Valid(Password(...)), так как он соответствует всем четырем правилам:
import Password.ValidationError._ val service = PasswordValidations.create val pass = "Very$trongPassword123" val expected = Password(pass).valid assert(service.validate(pass) == expected)
В заключение приглашаем всех, у кого есть опыт работы со Scala, на открытый урок по теме «Type classes в Scala», который пройдет 14 декабря. В результате вебинара сформируется понимание того, что такое type class паттерн, из каких компонентов он состоит и как с его помощью решаются конкретные задачи. Записаться на урок можно на странице курса.
