reform 2.2.4 → 2.3.3

data/test/errors_old_api.rb

@@ -0,0 +1,230 @@
+require "test_helper"
+
+class ErrorsTest < MiniTest::Spec
+  class AlbumForm < TestForm
+    property :title
+    validation do
+      required(:title).filled
+    end
+
+    property :artists, default: []
+    property :producer do
+      property :name
+    end
+
+    property :hit do
+      property :title
+      validation do
+        required(:title).filled
+      end
+    end
+
+    collection :songs do
+      property :title
+      validation do
+        required(:title).filled
+      end
+    end
+
+    property :band do # yepp, people do crazy stuff like that.
+      property :name
+      property :label do
+        property :name
+        validation do
+          required(:name).filled
+        end
+      end
+      # TODO: make band a required object.
+
+      validation do
+        configure do
+          config.messages_file = "test/fixtures/dry_error_messages.yml"
+
+          def good_musical_taste?(value)
+            value != "Nickelback"
+          end
+        end
+
+        required(:name).filled(:good_musical_taste?)
+      end
+    end
+
+    validation do
+      required(:title).filled
+      required(:artists).each(:str?)
+      required(:producer).schema do
+        required(:name).filled
+      end
+    end
+  end
+
+  let(:album_title) { "Blackhawks Over Los Angeles" }
+  let(:album) do
+    OpenStruct.new(
+      title: album_title,
+      hit: song,
+      songs: songs, # TODO: document this requirement,
+      band: Struct.new(:name, :label).new("Epitaph", OpenStruct.new),
+      producer: Struct.new(:name).new("Sun Records")
+    )
+  end
+  let(:song)  { OpenStruct.new(title: "Downtown") }
+  let(:songs) { [song = OpenStruct.new(title: "Calling"), song] }
+  let(:form)  { AlbumForm.new(album) }
+
+  describe "#validate with invalid array property" do
+    it do
+      _(form.validate(
+        title: "Swimming Pool - EP",
+        band: {
+          name: "Marie Madeleine",
+          label: {name: "Ekler'o'shocK"}
+        },
+        artists: [42, "Good Charlotte", 43]
+      )).must_equal false
+      _(form.errors.messages).must_equal(artists: {0 => ["must be a string"], 2 => ["must be a string"]})
+      _(form.errors.size).must_equal(1)
+    end
+  end
+
+  describe "#errors without #validate" do
+    it do
+      _(form.errors.size).must_equal 0
+    end
+  end
+
+  describe "blank everywhere" do
+    before do
+      form.validate(
+        "hit" => {"title" => ""},
+        "title" => "",
+        "songs" => [{"title" => ""}, {"title" => ""}],
+        "producer" => {"name" => ""}
+      )
+    end
+
+    it do
+      _(form.errors.messages).must_equal(
+        title: ["must be filled"],
+        "hit.title": ["must be filled"],
+        "songs.title": ["must be filled"],
+        "band.label.name": ["must be filled"],
+        "producer.name": ["must be filled"]
+      )
+    end
+
+    # it do
+    #   form.errors.must_equal({:title  => ["must be filled"]})
+    #   TODO: this should only contain local errors?
+    # end
+
+    # nested forms keep their own Errors:
+    it { _(form.producer.errors.messages).must_equal(name: ["must be filled"]) }
+    it { _(form.hit.errors.messages).must_equal(title: ["must be filled"]) }
+    it { _(form.songs[0].errors.messages).must_equal(title: ["must be filled"]) }
+
+    it do
+      _(form.errors.messages).must_equal(
+        title: ["must be filled"],
+        "hit.title": ["must be filled"],
+        "songs.title": ["must be filled"],
+        "band.label.name": ["must be filled"],
+        "producer.name": ["must be filled"]
+      )
+      _(form.errors.size).must_equal(5)
+    end
+  end
+
+  describe "#validate with main form invalid" do
+    it do
+      _(form.validate("title" => "", "band" => {"label" => {name: "Fat Wreck"}}, "producer" => nil)).must_equal false
+      _(form.errors.messages).must_equal(title: ["must be filled"], producer: ["must be a hash"])
+      _(form.errors.size).must_equal(2)
+    end
+  end
+
+  describe "#validate with middle nested form invalid" do
+    before { @result = form.validate("hit" => {"title" => ""}, "band" => {"label" => {name: "Fat Wreck"}}) }
+
+    it { _(@result).must_equal false }
+    it { _(form.errors.messages).must_equal("hit.title": ["must be filled"]) }
+    it { _(form.errors.size).must_equal(1) }
+  end
+
+  describe "#validate with collection form invalid" do
+    before { @result = form.validate("songs" => [{"title" => ""}], "band" => {"label" => {name: "Fat Wreck"}}) }
+
+    it { _(@result).must_equal false }
+    it { _(form.errors.messages).must_equal("songs.title": ["must be filled"]) }
+    it { _(form.errors.size).must_equal(1) }
+  end
+
+  describe "#validate with collection and 2-level-nested invalid" do
+    before { @result = form.validate("songs" => [{"title" => ""}], "band" => {"label" => {}}) }
+
+    it { _(@result).must_equal false }
+    it { _(form.errors.messages).must_equal("songs.title": ["must be filled"], "band.label.name": ["must be filled"]) }
+    it { _(form.errors.size).must_equal(2) }
+  end
+
+  describe "#validate with nested form using :base invalid" do
+    it do
+      result = form.validate("songs" => [{"title" => "Someday"}], "band" => {"name" => "Nickelback", "label" => {"name" => "Roadrunner Records"}})
+      _(result).must_equal false
+      _(form.errors.messages).must_equal("band.name": ["you're a bad person"])
+      _(form.errors.size).must_equal(1)
+    end
+  end
+
+  describe "#add" do
+    let(:album_title) { nil }
+    it do
+      form.errors.add(:before, "validate")
+      form.errors.add(:before, "validate 2")
+      form.errors.add(:title, "before validate")
+      result = form.validate("songs" => [{"title" => "Someday"}], "band" => {"name" => "Nickelback", "label" => {"name" => "Roadrunner Records"}})
+      _(result).must_equal false
+      _(form.errors.messages).must_equal(before: ["validate", "validate 2"], title: ["before validate", "must be filled"], "band.name": ["you're a bad person"])
+      # add a new custom error
+      form.errors.add(:policy, "error_text")
+      _(form.errors.messages).must_equal(before: ["validate", "validate 2"], title: ["before validate", "must be filled"], "band.name": ["you're a bad person"], policy: ["error_text"])
+      # does not duplicate errors
+      form.errors.add(:title, "must be filled")
+      _(form.errors.messages).must_equal(before: ["validate", "validate 2"], title: ["before validate", "must be filled"], "band.name": ["you're a bad person"], policy: ["error_text"])
+      # merge existing errors
+      form.errors.add(:policy, "another error")
+      _(form.errors.messages).must_equal(before: ["validate", "validate 2"], title: ["before validate", "must be filled"], "band.name": ["you're a bad person"], policy: ["error_text", "another error"])
+    end
+  end
+
+  describe "correct #validate" do
+    before do
+      @result = form.validate(
+        "hit"   => {"title" => "Sacrifice"},
+        "title" => "Second Heat",
+        "songs" => [{"title" => "Heart Of A Lion"}],
+        "band"  => {"label" => {name: "Fat Wreck"}}
+      )
+    end
+
+    it { _(@result).must_equal true }
+    it { _(form.hit.title).must_equal "Sacrifice" }
+    it { _(form.title).must_equal "Second Heat" }
+    it { _(form.songs.first.title).must_equal "Heart Of A Lion" }
+    it do
+      skip "WE DON'T NEED COUNT AND EMPTY? ON THE CORE ERRORS OBJECT"
+      _(form.errors.size).must_equal(0)
+      _(form.errors.empty?).must_equal(true)
+    end
+  end
+
+  describe "Errors#to_s" do
+    before { form.validate("songs" => [{"title" => ""}], "band" => {"label" => {}}) }
+
+    # to_s is aliased to messages
+    it {
+      skip "why do we need Errors#to_s ?"
+      _(form.errors.to_s).must_equal "{:\"songs.title\"=>[\"must be filled\"], :\"band.label.name\"=>[\"must be filled\"]}"
+    }
+  end
+end

data/test/feature_test.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 class FeatureInheritanceTest < BaseTest
   Song  = Struct.new(:title, :album, :composer)
   Album = Struct.new(:name, :songs, :artist)
@@ -21,7 +19,7 @@ class FeatureInheritanceTest < BaseTest
   #   end
   # end
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     feature Date # feature.
     property :name
 
@@ -38,17 +36,17 @@ class FeatureInheritanceTest < BaseTest
     end
   end
 
-  let (:song)               { Song.new("Broken") }
-  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
-  let (:composer)           { Artist.new("Greg Graffin") }
-  let (:artist)             { Artist.new("Bad Religion") }
-  let (:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
+  let(:song)               { Song.new("Broken") }
+  let(:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let(:composer)           { Artist.new("Greg Graffin") }
+  let(:artist)             { Artist.new("Bad Religion") }
+  let(:album)              { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   it do
-    form.date.must_equal "May 16"
-    form.songs[0].date.must_equal "May 16"
+    _(form.date).must_equal "May 16"
+    _(form.songs[0].date).must_equal "May 16"
   end
 
   # it { subject.class.include?(Reform::Form::ActiveModel) }
@@ -62,4 +60,4 @@ class FeatureInheritanceTest < BaseTest
   # it { subject.band.label.is_a?(Reform::Form::ActiveModel) }
   # it { subject.band.label.is_a?(Reform::Form::Coercion) }
   # it { subject.band.label.is_a?(Reform::Form::MultiParameterAttributes) }
-end
+end

data/test/fixtures/dry_error_messages.yml

@@ -1,44 +1,94 @@
-array?: "%{name} must be an array"
+en:
+  errors:
+    array?: "must be an array"
 
-empty?: "%{name} cannot be empty"
+    empty?: "must be empty"
 
-exclusion?: "%{name} must not be one of: %{list}"
+    excludes?: "must not include %{value}"
 
-eql?: "%{name} must be equal to %{eql_value}"
+    excluded_from?:
+      arg:
+        default: "must not be one of: %{list}"
+        range: "must not be one of: %{list_left} - %{list_right}"
 
-filled?: "%{name} must be filled"
+    eql?: "must be equal to %{left}"
 
-format?: "%{name} is in invalid format"
+    not_eql?: "must not be equal to %{left}"
 
-gt?: "%{name} must be greater than %{num} (%{value} was given)"
+    filled?: "must be filled"
 
-gteq?: "%{name} must be greater than or equal to %{num}"
+    format?: "is in invalid format"
 
-hash?: "%{name} must be a hash"
+    number?: "must be a number"
 
-inclusion?: "%{name} must be one of: %{list}"
+    odd?: "must be odd"
 
-int?: "%{name} must be an integer"
+    even?: "must be even"
 
-key?: "%{name} is missing"
+    gt?: "must be greater than %{num}"
 
-lt?: "%{name} must be less than %{num} (%{value} was given)"
+    gteq?: "must be greater than or equal to %{num}"
 
-lteq?: "%{name} must be less than or equal to %{num}"
+    hash?: "must be a hash"
 
-max_size?: "%{name} size cannot be greater than %{num}"
+    included_in?:
+      arg:
+        default: "must be one of: %{list}"
+        range: "must be one of: %{list_left} - %{list_right}"
 
-min_size?: "%{name} size cannot be less than %{num}"
+    includes?: "must include %{value}"
 
-nil?: "%{name} cannot be nil"
+    bool?: "must be boolean"
 
-size?:
-  range: "%{name} size must be within %{left} - %{right}"
-  default: "%{name} size must be %{num}"
+    true?: "must be true"
 
-str?: "%{name} must be a string"
+    false?: "must be false"
 
-good_musical_taste?: "you're a bad person"
+    int?: "must be an integer"
 
-form_access_validation?: "this doesn't look like a Reform form dude!!"
+    float?: "must be a float"
 
+    decimal?: "must be a decimal"
+
+    date?: "must be a date"
+
+    date_time?: "must be a date time"
+
+    time?: "must be a time"
+
+    key?: "is missing"
+
+    attr?: "is missing"
+
+    lt?: "must be less than %{num}"
+
+    lteq?: "must be less than or equal to %{num}"
+
+    max_size?: "size cannot be greater than %{num}"
+
+    min_size?: "size cannot be less than %{num}"
+
+    none?: "cannot be defined"
+
+    str?: "must be a string"
+
+    type?: "must be %{type}"
+
+    size?:
+      arg:
+        default: "size must be %{size}"
+        range: "size must be within %{size_left} - %{size_right}"
+
+      value:
+        string:
+          arg:
+            default: "length must be %{size}"
+            range: "length must be within %{size_left} - %{size_right}"
+
+    good_musical_taste?: "you're a bad person"
+
+    a_song?: "must have at least one enabled song"
+    with_last_name?: "must have last name"
+de:
+  errors:
+      filled?: "muss abgefüllt sein"

data/test/fixtures/dry_new_api_error_messages.yml

@@ -0,0 +1,104 @@
+en:
+  dry_validation:
+    errors:
+      array?: "must be an array"
+
+      empty?: "must be empty"
+
+      excludes?: "must not include %{value}"
+
+      excluded_from?:
+        arg:
+          default: "must not be one of: %{list}"
+          range: "must not be one of: %{list_left} - %{list_right}"
+
+      eql?: "must be equal to %{left}"
+
+      not_eql?: "must not be equal to %{left}"
+
+      filled?: "must be filled"
+
+      format?: "is in invalid format"
+
+      number?: "must be a number"
+
+      odd?: "must be odd"
+
+      even?: "must be even"
+
+      gt?: "must be greater than %{num}"
+
+      gteq?: "must be greater than or equal to %{num}"
+
+      hash?: "must be a hash"
+
+      included_in?:
+        arg:
+          default: "must be one of: %{list}"
+          range: "must be one of: %{list_left} - %{list_right}"
+
+      includes?: "must include %{value}"
+
+      bool?: "must be boolean"
+
+      true?: "must be true"
+
+      false?: "must be false"
+
+      int?: "must be an integer"
+
+      float?: "must be a float"
+
+      decimal?: "must be a decimal"
+
+      date?: "must be a date"
+
+      date_time?: "must be a date time"
+
+      time?: "must be a time"
+
+      key?: "is missing"
+
+      attr?: "is missing"
+
+      lt?: "must be less than %{num}"
+
+      lteq?: "must be less than or equal to %{num}"
+
+      max_size?: "size cannot be greater than %{num}"
+
+      min_size?: "size cannot be less than %{num}"
+
+      none?: "cannot be defined"
+
+      str?: "must be a string"
+
+      type?: "must be %{type}"
+
+      size?:
+        arg:
+          default: "size must be %{size}"
+          range: "size must be within %{size_left} - %{size_right}"
+
+        value:
+          string:
+            arg:
+              default: "length must be %{size}"
+              range: "length must be within %{size_left} - %{size_right}"
+
+
+
+      rules:
+        name:
+          good_musical_taste?: "you're a bad person"
+        title:
+          good_musical_taste?: "you're a bad person"
+        songs:
+          a_song?: "must have at least one enabled song"
+        artist:
+          with_last_name?: "must have last name"
+
+de:
+  dry_validation:
+    errors:
+      filled?: "muss abgefüllt sein"