reform 2.3.0.rc1 → 2.5.0

data/test/contract/custom_error_test.rb

@@ -0,0 +1,55 @@
+require "test_helper"
+
+class CustomerErrorTest < MiniTest::Spec
+  let(:key)            { :name }
+  let(:error_text)     { "text2" }
+  let(:starting_error) { [OpenStruct.new(errors: {title: ["text1"]})] }
+
+  let(:custom_error) { Reform::Contract::CustomError.new(key, error_text, @results) }
+
+  before { @results = starting_error }
+
+  it "base class structure" do
+    assert_equal custom_error.success?, false
+    assert_equal custom_error.failure?, true
+    assert_equal custom_error.errors, key => [error_text]
+    assert_equal custom_error.messages, key => [error_text]
+    assert_equal custom_error.hint, {}
+  end
+
+  describe "updates @results accordingly" do
+    it "add new key" do
+      custom_error
+
+      assert_equal @results.size, 2
+      errors = @results.map(&:errors)
+
+      assert_equal errors[0], starting_error.first.errors
+      assert_equal errors[1], custom_error.errors
+    end
+
+    describe "when key error already exists in @results" do
+      let(:key) { :title }
+
+      it "merge errors text" do
+        custom_error
+
+        assert_equal @results.size, 1
+
+        assert_equal @results.first.errors.values, [%w[text1 text2]]
+      end
+
+      describe "add error text is already" do
+        let(:error_text) { "text1" }
+
+        it 'does not create duplicates' do
+          custom_error
+
+          assert_equal @results.size, 1
+
+          assert_equal @results.first.errors.values, [%w[text1]]
+        end
+      end
+    end
+  end
+end

data/test/contract_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class ContractTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
@@ -16,19 +16,19 @@ class ContractTest < MiniTest::Spec
     properties :year, :style, readable: false
 
     validation do
-      required(:name).filled
+      params { required(:name).filled }
     end
 
     collection :songs do
       property :title
       validation do
-        required(:title).filled
+        params { required(:title).filled }
       end
 
       property :composer do
         property :name
         validation do
-          required(:name).filled
+          params { required(:name).filled }
         end
       end
     end
@@ -36,42 +36,42 @@ class ContractTest < MiniTest::Spec
     property :artist, form: ArtistForm
   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", 123, [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", 123, [song, song_with_composer], artist) }
 
-  let (:form) { AlbumForm.new(album) }
+  let(:form) { AlbumForm.new(album) }
 
   # accept `property form: SongForm`.
   it do
-    form.artist.must_be_instance_of ArtistForm
+    assert form.artist.is_a? ArtistForm
   end
 
   describe ".properties" do
     it "defines a property when called with one argument" do
-      form.must_respond_to :duration
+      assert_respond_to form, :duration
     end
 
     it "defines several properties when called with multiple arguments" do
-      form.must_respond_to :year
-      form.must_respond_to :style
+      assert_respond_to form, :year
+      assert_respond_to form, :style
     end
 
     it "passes options to each property when options are provided" do
       readable = AlbumForm.new(album).options_for(:style)[:readable]
-      readable.must_equal false
+      assert_equal readable, false
     end
 
     it "returns the list of defined properties" do
       returned_value = AlbumForm.properties(:hello, :world, virtual: true)
-      returned_value.must_equal [:hello, :world]
+      assert_equal returned_value, %i[hello world]
     end
   end
 
   describe "#options_for" do
-    it { AlbumForm.options_for(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
-    it { AlbumForm.new(album).options_for(:name).extend(Declarative::Inspect).inspect.must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
+    it { assert_equal AlbumForm.options_for(:name).extend(Declarative::Inspect).inspect, "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
+    it { assert_equal AlbumForm.new(album).options_for(:name).extend(Declarative::Inspect).inspect, "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
   end
 end

data/test/default_test.rb

@@ -16,7 +16,7 @@ class DefaultTest < Minitest::Spec
   it do
     form = AlbumForm.new(Album.new(nil, [Song.new]))
 
-    form.name.must_equal "Wrong"
-    form.songs[0].title.must_equal "It's Catching Up"
+    assert_equal form.name, "Wrong"
+    assert_equal form.songs[0].title, "It's Catching Up"
   end
-end
+end

data/test/deserialize_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 require "representable/json"
 
 class DeserializeTest < MiniTest::Spec
@@ -10,7 +10,7 @@ class DeserializeTest < MiniTest::Spec
     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,9 +41,9 @@ 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
@@ -62,14 +60,13 @@ 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)
@@ -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,24 +1,28 @@
 require "test_helper"
 
-# TODO:
-# This test should, at some point soon, only test the `Errors` object and its
-# Rails-ish API. No validation specifics, etc. to be tested here.
-
 class ErrorsTest < MiniTest::Spec
   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
 
@@ -27,154 +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
-        configure do
-          config.messages_file = "test/fixtures/dry_error_messages.yml"
+        config.messages.load_paths << "test/fixtures/dry_error_messages.yml"
 
-          def good_musical_taste?(value)
-            value != "Nickelback"
-          end
-        end
+        params { required(:name).filled }
 
-        required(:name).filled(:good_musical_taste?)
+        rule(:name) { key.failure(:good_musical_taste?) if value == "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 "#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.size.must_equal 0
+      assert_equal form.errors.size, 0
     end
   end
 
   describe "blank everywhere" do
-    before { form.validate(
-      "hit"   =>{"title" => ""},
-      "title" => "",
-      "songs" => [{"title" => ""}, {"title" => ""}]) } # FIXME: what happens if item 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"]
-      })
+    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"=>["must be filled"]
-      })
-      form.errors.size.must_equal(4)
+      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"]})
-      form.errors.size.must_equal(1)
+      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 { form.errors.size.must_equal(1) }
+    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 { form.errors.size.must_equal(1) }
+    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"=>["must be filled"]}) }
-    it { form.errors.size.must_equal(2) }
+    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're a bad person"]})
-      form.errors.size.must_equal(1)
+      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 "#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 { @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" }
+    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"
-      form.errors.size.must_equal(0)
-      form.errors.empty?.must_equal(true)
+      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 {
       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\"]}" }
+      assert_equal form.errors.to_s, "{:\"songs.title\"=>[\"must be filled\"], :\"band.label.name\"=>[\"must be filled\"]}"
+    }
   end
 end