reform 2.3.0.rc1 → 2.3.0.rc2

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)
@@ -38,13 +36,13 @@ 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"
@@ -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

@@ -86,6 +86,9 @@ en:
             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"
+  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"

data/test/form_new_api.rb

@@ -0,0 +1,57 @@
+require "test_helper"
+
+class FormTest < MiniTest::Spec
+  Artist = Struct.new(:name)
+
+  class AlbumForm < TestForm
+    property :title
+
+    property :hit do
+      property :title
+    end
+
+    collection :songs do
+      property :title
+    end
+
+    property :band do # yepp, people do crazy stuff like that.
+      property :label do
+        property :name
+      end
+    end
+  end
+
+  describe "::dup" do
+    let(:cloned) { AlbumForm.clone }
+
+    # #dup is called in Op.inheritable_attr(:contract_class), it must be subclass of the original one.
+    it { cloned.wont_equal AlbumForm }
+    it { AlbumForm.definitions.wont_equal cloned.definitions }
+
+    it do
+      # currently, forms need a name for validation, even without AM.
+      cloned.singleton_class.class_eval do
+        def name
+          "Album"
+        end
+      end
+
+      cloned.validation do
+        params { required(:title).filled }
+      end
+
+      cloned.new(OpenStruct.new).validate({})
+    end
+  end
+
+  describe "#initialize" do
+    class ArtistForm < TestForm
+      property :name
+      property :current_user, virtual: true
+    end
+
+    it "allows injecting :virtual options" do
+      ArtistForm.new(Artist.new, current_user: Object).current_user.must_equal Object
+    end
+  end
+end

data/test/{form_test.rb → form_old_api.rb}

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class FormTest < MiniTest::Spec
   Artist = Struct.new(:name)
@@ -22,7 +22,7 @@ class FormTest < MiniTest::Spec
   end
 
   describe "::dup" do
-    let (:cloned) { AlbumForm.clone }
+    let(:cloned) { AlbumForm.clone }
 
     # #dup is called in Op.inheritable_attr(:contract_class), it must be subclass of the original one.
     it { cloned.wont_equal AlbumForm }