reform 2.2.4 → 2.6.2

data/test/deserialize_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 require "representable/json"
 
 class DeserializeTest < MiniTest::Spec
@@ -6,11 +6,11 @@ class DeserializeTest < MiniTest::Spec
   Album = Struct.new(:title, :artist)
   Artist = Struct.new(:name, :callname)
 
-  class JsonAlbumForm < Reform::Form
+  class JsonAlbumForm < TestForm
     module Json
       def deserialize(params)
         deserializer.new(self).
-        # extend(Representable::Debug).
+          # extend(Representable::Debug).
           from_json(params)
       end
 
@@ -18,7 +18,7 @@ class DeserializeTest < MiniTest::Spec
         Disposable::Rescheme.from(self.class,
           include:          [Representable::JSON],
           superclass:       Representable::Decorator,
-          definitions_from: lambda { |inline| inline.definitions },
+          definitions_from: ->(inline) { inline.definitions },
           options_from:     :deserializer,
           exclude_options:  [:populator]
         )
@@ -26,15 +26,13 @@ class DeserializeTest < MiniTest::Spec
     end
     include Json
 
-
     property :title
     property :artist, populate_if_empty: Artist do
       property :name
     end
   end
 
-
-  let (:artist) { Artist.new("A-ha") }
+  let(:artist) { Artist.new("A-ha") }
   it do
     artist_id = artist.object_id
 
@@ -43,13 +41,13 @@ class DeserializeTest < MiniTest::Spec
 
     form.validate(json)
 
-    form.title.must_equal "Apocalypse Soon"
-    form.artist.name.must_equal "Mute"
-    form.artist.model.object_id.must_equal artist_id
+    assert_equal form.title, "Apocalypse Soon"
+    assert_equal form.artist.name, "Mute"
+    assert_equal form.artist.model.object_id, artist_id
   end
 
   describe "infering the deserializer from another form should NOT copy its populators" do
-    class CompilationForm < Reform::Form
+    class CompilationForm < TestForm
       property :artist, populator: ->(options) { self.artist = Artist.new(nil, options[:fragment].to_s) } do
         property :name
       end
@@ -62,20 +60,19 @@ class DeserializeTest < MiniTest::Spec
     # also tests the Form#deserializer API. # FIXME.
     it "uses deserializer inferred from JsonAlbumForm but deserializes/populates to CompilationForm" do
       form = CompilationForm.new(Album.new)
-      form.validate("artist"=> {"name" => "Horowitz"}) # the deserializer doesn't know symbols.
+      form.validate("artist" => {"name" => "Horowitz"}) # the deserializer doesn't know symbols.
       form.sync
-      form.artist.model.must_equal Artist.new("Horowitz", %{{"name"=>"Horowitz"}})
+      assert_equal form.artist.model, Artist.new("Horowitz", %{{"name"=>"Horowitz"}})
     end
   end
 end
 
-
 class ValidateWithBlockTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
   Album = Struct.new(:title, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title
     property :artist, populate_if_empty: Artist do
       property :name
@@ -90,15 +87,15 @@ class ValidateWithBlockTest < MiniTest::Spec
     deserializer = Disposable::Rescheme.from(AlbumForm,
       include:          [Representable::JSON],
       superclass:       Representable::Decorator,
-      definitions_from: lambda { |inline| inline.definitions },
+      definitions_from: ->(inline) { inline.definitions },
       options_from:     :deserializer
     )
 
-    form.validate(json) do |params|
+    assert form.validate(json) { |params|
       deserializer.new(form).from_json(params)
-    end.must_equal true # with block must return result, too.
+    } # with block must return result, too.
 
-    form.title.must_equal "Apocalypse Soon"
-    form.artist.name.must_equal "Mute"
+    assert_equal form.title, "Apocalypse Soon"
+    assert_equal form.artist.name, "Mute"
   end
 end

data/test/docs/validation_test.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+require 'reform/form/dry'
+
+class DocsDryVTest < Minitest::Spec
+  #:basic
+  class AlbumForm < Reform::Form
+    feature Reform::Form::Dry
+
+    property :name
+
+    validation do
+      params do
+        required(:name).filled
+      end
+    end
+  end
+  #:basic end
+
+  it 'validates correctly' do
+    form = DocsDryVTest::AlbumForm.new(Album.new(nil, nil, nil))
+    result = form.call(name: nil)
+
+    refute result.success?
+    assert_equal({ name: ['must be filled'] }, form.errors.messages)
+  end
+end
+
+class DocsDryVWithRulesTest < Minitest::Spec
+  #:basic_with_rules
+  class AlbumForm < Reform::Form
+    feature Reform::Form::Dry
+
+    property :name
+
+    validation name: :default do
+      option :form
+
+      params do
+        required(:name).filled
+      end
+
+      rule(:name) do
+        key.failure('must be unique') if Album.where.not(id: form.model.id).where(name: value).exists?
+      end
+    end
+  end
+  #:basic_with_rules end
+
+  it 'validates correctly' do
+    Album = Struct.new(:name, :songs, :artist, :user)
+    form = DocsDryVWithRulesTest::AlbumForm.new(Album.new(nil, nil, nil, nil))
+    result = form.call(name: nil)
+
+    refute result.success?
+    assert_equal({ name: ['must be filled'] }, form.errors.messages)
+  end
+end
+
+class DryVWithNestedTest < Minitest::Spec
+  #:nested
+  class AlbumForm < Reform::Form
+    feature Reform::Form::Dry
+
+    property :name
+
+    validation do
+      params { required(:name).filled }
+    end
+
+    property :artist do
+      property :name
+
+      validation do
+        params { required(:name).filled }
+      end
+    end
+  end
+  #:nested end
+
+  it 'validates correctly' do
+    form = DryVWithNestedTest::AlbumForm.new(Album.new(nil, nil, Artist.new(nil)))
+    result = form.call(name: nil, artist: { name: '' })
+
+    refute result.success?
+    assert_equal({ name: ['must be filled'], 'artist.name': ['must be filled'] }, form.errors.messages)
+  end
+end
+
+class DryVValGroupTest < Minitest::Spec
+  class AlbumForm < Reform::Form
+    feature Reform::Form::Dry
+
+    property :name
+    property :artist
+    #:validation_groups
+    validation name: :default do
+      params { required(:name).filled }
+    end
+
+    validation name: :artist, if: :default do
+      params { required(:artist).filled }
+    end
+
+    validation name: :famous, after: :default do
+      params { optional(:artist) }
+
+      rule(:artist) do
+        if value
+          key.failure('only famous artist') unless value =~ /famous/
+        end
+      end
+    end
+    #:validation_groups end
+  end
+
+  it 'validates correctly' do
+    form = DryVValGroupTest::AlbumForm.new(Album.new(nil, nil, nil))
+    result = form.call(name: nil)
+
+    refute result.success?
+    assert_equal({ name: ['must be filled'] }, result.errors.messages)
+
+    result = form.call(name: 'Title')
+    refute result.success?
+    assert_equal({ artist: ['must be filled'] }, result.errors.messages)
+
+    result = form.call(name: 'Title', artist: 'Artist')
+    refute result.success?
+    assert_equal({ artist: ['only famous artist'] }, result.errors.messages)
+
+    result = form.call(name: 'Title', artist: 'Artist famous')
+    assert result.success?
+  end
+end

data/test/errors_test.rb

@@ -1,20 +1,28 @@
 require "test_helper"
 
 class ErrorsTest < MiniTest::Spec
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title
+    validation do
+      params { required(:title).filled }
+    end
+
+    property :artists, default: []
+    property :producer do
+      property :name
+    end
 
     property :hit do
       property :title
       validation do
-        required(:title).filled
+        params { required(:title).filled }
       end
     end
 
     collection :songs do
       property :title
       validation do
-        required(:title).filled
+        params { required(:title).filled }
       end
     end
 
@@ -23,143 +31,195 @@ class ErrorsTest < MiniTest::Spec
       property :label do
         property :name
         validation do
-          required(:name).filled
+          params { required(:name).filled }
         end
       end
       # TODO: make band a required object.
 
       validation do
-        # required(:name).filled(:music_taste_ok?)
+        config.messages.load_paths << "test/fixtures/dry_error_messages.yml"
 
-        configure do
-          config.messages_file = "test/validation/errors.yml"
+        params { required(:name).filled }
 
-          def music_taste_ok?(value)
-            value != "Nickelback"
-            # errors.add(:base, "You are a bad person") if name == "Nickelback"
-          end
-        end
+        rule(:name) { key.failure(:good_musical_taste?) if value == "Nickelback" }
       end
-      # validate :music_taste_ok?
-
-    # private
-    #   def music_taste_ok?
-    #     errors.add(:base, "You are a bad person") if name == "Nickelback"
-    #   end
     end
 
     validation do
-      required(:title).filled
+      params do
+        required(:title).filled
+        required(:artists).each(:str?)
+        required(:producer).hash do
+          required(:name).filled
+        end
+      end
     end
   end
 
-  let (:album) do
+  let(:album_title) { "Blackhawks Over Los Angeles" }
+  let(:album) do
     OpenStruct.new(
-      :title  => "Blackhawks Over Los Angeles",
-      :hit    => song,
-      :songs  => songs, # TODO: document this requirement,
-
-      :band => Struct.new(:name, :label).new("Epitaph", 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) }
-
+  let(:song)  { OpenStruct.new(title: "Downtown") }
+  let(:songs) { [song = OpenStruct.new(title: "Calling"), song] }
+  let(:form)  { AlbumForm.new(album) }
 
-  describe "incorrect #validate" do
-    before { form.validate(
-      "hit"   =>{"title" => ""},
-      "title" => "",
-      "songs" => [{"title" => ""}, {"title" => ""}]) } # FIXME: what happens if item is missing?
+  describe "#validate with invalid array property" do
+    it do
+      refute form.validate(
+        title: "Swimming Pool - EP",
+        band: {
+          name: "Marie Madeleine",
+          label: {name: "Ekler'o'shocK"}
+        },
+        artists: [42, "Good Charlotte", 43]
+      )
+      assert_equal form.errors.messages, artists: {0 => ["must be a string"], 2 => ["must be a string"]}
+      assert_equal form.errors.size, 1
+    end
+  end
 
+  describe "#errors without #validate" do
     it do
-      form.errors.messages.must_equal({
-        :title  => ["must be filled"],
-        :"hit.title"=>["must be filled"],
-        :"songs.title"=>["must be filled"],
-        :"band.label.name"=>["is missing"]
-      })
+      assert_equal form.errors.size, 0
+    end
+  end
+
+  describe "blank everywhere" do
+    before do
+      form.validate(
+        "hit" => {"title" => ""},
+        "title" => "",
+        "songs" => [{"title" => ""}, {"title" => ""}],
+        "producer" => {"name" => ""}
+      )
     end
 
     it do
-      #form.errors.must_equal({:title  => ["must be filled"]})
-      # TODO: this should only contain local errors?
+      assert_equal form.errors.messages,{
+        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.hit.errors.messages.must_equal({:title=>["must be filled"]}) }
-    it { form.songs[0].errors.messages.must_equal({:title=>["must be filled"]}) }
+    it { assert_equal form.producer.errors.messages, name: ["must be filled"] }
+    it { assert_equal form.hit.errors.messages, title: ["must be filled"] }
+    it { assert_equal form.songs[0].errors.messages, 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"=>["is missing"]
-      })
+      assert_equal form.errors.messages, {
+        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"]
+      }
+      assert_equal form.errors.size, 5
     end
   end
 
-
   describe "#validate with main form invalid" do
     it do
-      form.validate("title"=>"", "band"=>{"label"=>{:name => "Fat Wreck"}}).must_equal false
-      form.errors.messages.must_equal({:title=>["must be filled"]})
+      refute form.validate("title" => "", "band" => {"label" => {name: "Fat Wreck"}}, "producer" => nil)
+      assert_equal form.errors.messages, title: ["must be filled"], producer: ["must be a hash"]
+      assert_equal form.errors.size, 2
     end
   end
 
-
   describe "#validate with middle nested form invalid" do
-    before { @result = form.validate("hit"=>{"title" => ""}, "band"=>{"label"=>{:name => "Fat Wreck"}}) }
+    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 { refute @result }
+    it { assert_equal form.errors.messages, "hit.title": ["must be filled"] }
+    it { assert_equal form.errors.size, 1 }
   end
 
-
   describe "#validate with collection form invalid" do
-    before { @result = form.validate("songs"=>[{"title" => ""}], "band"=>{"label"=>{:name => "Fat Wreck"}}) }
+    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 { refute @result }
+    it { assert_equal form.errors.messages, "songs.title": ["must be filled"] }
+    it { assert_equal form.errors.size, 1 }
   end
 
-
   describe "#validate with collection and 2-level-nested invalid" do
-    before { @result = form.validate("songs"=>[{"title" => ""}], "band" => {"label" => {}}) }
+    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"=>["is missing"]}) }
+    it { refute @result }
+    it { assert_equal form.errors.messages, "songs.title": ["must be filled"], "band.label.name": ["must be filled"] }
+    it { assert_equal form.errors.size, 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 are a bad person"]})
+      result = form.validate("songs" => [{"title" => "Someday"}], "band" => {"name" => "Nickelback", "label" => {"name" => "Roadrunner Records"}})
+      refute result
+      assert_equal form.errors.messages, "band.name": ["you're a bad person"]
+      assert_equal form.errors.size, 1
     end
   end
 
-  describe "correct #validate" do
-    before { @result = form.validate(
-      "hit"   => {"title" => "Sacrifice"},
-      "title" => "Second Heat",
-      "songs" => [{"title"=>"Heart Of A Lion"}],
-      "band"  => {"label"=>{:name => "Fat Wreck"}}
-      ) }
-
-    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" }
+  describe "#add" do
+    let(:album_title) { nil }
+    it do
+      result = form.validate("songs" => [{"title" => "Someday"}], "band" => {"name" => "Nickelback", "label" => {"name" => "Roadrunner Records"}})
+      refute result
+      assert_equal form.errors.messages, title: ["must be filled"], "band.name": ["you're a bad person"]
+      # add a new custom error
+      form.errors.add(:policy, "error_text")
+      assert_equal form.errors.messages, title: ["must be filled"], "band.name": ["you're a bad person"], policy: ["error_text"]
+      # does not duplicate errors
+      form.errors.add(:title, "must be filled")
+      assert_equal form.errors.messages, title: ["must be filled"], "band.name": ["you're a bad person"], policy: ["error_text"]
+      # merge existing errors
+      form.errors.add(:policy, "another error")
+      assert_equal form.errors.messages, title: ["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 { assert @result }
+    it { assert_equal form.hit.title, "Sacrifice" }
+    it { assert_equal form.title, "Second Heat" }
+    it { assert_equal form.songs.first.title, "Heart Of A Lion" }
+    it do
+      skip "WE DON'T NEED COUNT AND EMPTY? ON THE CORE ERRORS OBJECT"
+      assert_equal form.errors.size, 0
+      assert form.errors.empty
+    end
+  end
 
   describe "Errors#to_s" do
-    before { form.validate("songs"=>[{"title" => ""}], "band" => {"label" => {}}) }
+    before { form.validate("songs" => [{"title" => ""}], "band" => {"label" => {}}) }
 
     # to_s is aliased to messages
-    it { form.errors.to_s.must_equal "{:\"songs.title\"=>[\"must be filled\"], :\"band.label.name\"=>[\"is missing\"]}" }
+    it {
+      skip "why do we need Errors#to_s ?"
+      assert_equal form.errors.to_s, "{:\"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"
+    assert_equal form.date, "May 16"
+    assert_equal form.songs[0].date, "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