reform 2.3.0.rc2 → 2.6.0

data/test/{composition_new_api.rb → composition_test.rb}

@@ -33,8 +33,8 @@ class FormCompositionInheritanceTest < MiniTest::Spec
   Tshirt = Struct.new(:price, :size)
   Measurement = Struct.new(:size)
 
-  it { form.price.must_equal 6 }
-  it { form.price(for_size: :s).must_equal 2 }
+  it { assert_equal form.price, 6 }
+  it { assert_equal form.price(for_size: :s), 2 }
 end
 
 class FormCompositionTest < MiniTest::Spec
@@ -71,24 +71,24 @@ class FormCompositionTest < MiniTest::Spec
   let(:band)       { Band.new("Duran^2") }
 
   # delegation form -> composition works
-  it { form.id.must_equal 1 }
-  it { form.title.must_equal "Rio" }
-  it { form.name.must_equal "Duran Duran" }
-  it { form.requester_id.must_equal 2 }
+  it { assert_equal form.id, 1 }
+  it { assert_equal form.title, "Rio" }
+  it { assert_equal form.name, "Duran Duran" }
+  it { assert_equal form.requester_id, 2 }
   it { assert_nil form.channel }
-  it { form.requester.must_equal "MCP" } # same name as composed model.
+  it { assert_equal form.requester, "MCP" } # same name as composed model.
   it { assert_nil form.captcha }
 
   # #model just returns <Composition>.
-  it { form.mapper.must_be_kind_of Disposable::Composition }
+  it { assert form.mapper.is_a? Disposable::Composition }
 
   # #model[] -> composed models
-  it { form.model[:requester].must_equal requester }
-  it { form.model[:song].must_equal song }
+  it { assert_equal form.model[:requester], requester }
+  it { assert_equal form.model[:song], song }
 
   it "creates Composition for you" do
-    form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb").must_equal true
-    form.validate("title" => "", "name" => "Frenzal Rhomb").must_equal false
+    assert_equal form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb"), true
+    assert_equal form.validate("title" => "", "name" => "Frenzal Rhomb"), false
   end
 
   describe "#save" do
@@ -101,7 +101,7 @@ class FormCompositionTest < MiniTest::Spec
         hash[:title]  = form.title
       end
 
-      hash.must_equal({name: "Duran Duran", title: "Rio"})
+      assert_equal hash, name: "Duran Duran", title: "Rio"
     end
 
     it "provides nested symbolized hash as second block argument" do
@@ -113,11 +113,10 @@ class FormCompositionTest < MiniTest::Spec
         hash = map
       end
 
-      hash.must_equal({
-                        song: {"title" => "Greyhound", "id" => 1, "channel" => "JJJ", "captcha" => "wonderful", "band" => {"title" => "Duran^2"}},
-                        requester: {"name" => "Frenzal Rhomb", "id" => 2, "requester" => "MCP"}
-                      }
-      )
+      assert_equal hash, {
+        song: {"title" => "Greyhound", "id" => 1, "channel" => "JJJ", "captcha" => "wonderful", "band" => {"title" => "Duran^2"}},
+        requester: {"name" => "Frenzal Rhomb", "id" => 2, "requester" => "MCP"}
+      }
     end
 
     it "xxx pushes data to models and calls #save when no block passed" do
@@ -126,16 +125,16 @@ class FormCompositionTest < MiniTest::Spec
       band.extend(Saveable)
 
       form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "captcha" => "1337")
-      form.captcha.must_equal "1337" # TODO: move to separate test.
+      assert_equal form.captcha, "1337" # TODO: move to separate test.
 
       form.save
 
-      requester.name.must_equal "Frenzal Rhomb"
-      requester.saved?.must_equal true
-      song.title.must_equal "Greyhound"
-      song.saved?.must_equal true
-      song.band.title.must_equal "Duran^2"
-      song.band.saved?.must_equal true
+      assert_equal requester.name, "Frenzal Rhomb"
+      assert_equal requester.saved?, true
+      assert_equal song.title, "Greyhound"
+      assert_equal song.saved?, true
+      assert_equal song.band.title, "Duran^2"
+      assert_equal song.band.saved?, true
     end
 
     it "returns true when models all save successfully" do
@@ -143,7 +142,7 @@ class FormCompositionTest < MiniTest::Spec
       requester.extend(Saveable)
       band.extend(Saveable)
 
-      form.save.must_equal true
+      assert_equal form.save, true
     end
 
     it "returns false when one or more models don't save successfully" do
@@ -157,7 +156,7 @@ class FormCompositionTest < MiniTest::Spec
       requester.extend(Saveable)
       band.extend(Saveable)
 
-      form.save.must_equal false
+      assert_equal form.save, false
     end
   end
 end
@@ -182,5 +181,5 @@ class FormCompositionCollectionTest < MiniTest::Spec
   let(:form)   { LibraryForm.new(library: library) }
   let(:library) { Library.new(2) }
 
-  it { form.save { |hash| hash.must_equal({library: {"books" => [{"id" => 1, "name" => "My book"}]}}) } }
+  it { form.save { |hash| assert_equal hash, { library: { "books" => [{ "id" => 1, "name" => "My book" }] } } } }
 end

data/test/{contract_new_api.rb → contract_test.rb}

@@ -46,32 +46,32 @@ class ContractTest < MiniTest::Spec
 
   # 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 %i[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

data/test/deserialize_test.rb

@@ -41,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,7 +62,7 @@ class DeserializeTest < MiniTest::Spec
       form = CompilationForm.new(Album.new)
       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
@@ -91,11 +91,11 @@ class ValidateWithBlockTest < MiniTest::Spec
       options_from:     :deserializer
     )
 
-    form.validate(json) { |params|
+    assert form.validate(json) { |params|
       deserializer.new(form).from_json(params)
-    }.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_new_api.rb → errors_test.rb}

@@ -37,7 +37,7 @@ class ErrorsTest < MiniTest::Spec
       # TODO: make band a required object.
 
       validation do
-        config.messages.load_paths << "test/fixtures/dry_new_api_error_messages.yml"
+        config.messages.load_paths << "test/fixtures/dry_error_messages.yml"
 
         params { required(:name).filled }
 
@@ -72,22 +72,22 @@ class ErrorsTest < MiniTest::Spec
 
   describe "#validate with invalid array property" do
     it do
-      form.validate(
+      refute 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)
+      )
+      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
 
@@ -102,13 +102,13 @@ class ErrorsTest < MiniTest::Spec
     end
 
     it do
-      form.errors.messages.must_equal(
+      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
@@ -117,60 +117,60 @@ class ErrorsTest < MiniTest::Spec
     # 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 { 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(
+      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"]
-      )
-      form.errors.size.must_equal(5)
+      }
+      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"}}, "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)
+      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"}}) }
 
-    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"}}) }
 
-    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" => {}}) }
 
-    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)
+      refute result
+      assert_equal form.errors.messages, "band.name": ["you're a bad person"]
+      assert_equal form.errors.size, 1
     end
   end
 
@@ -178,17 +178,17 @@ class ErrorsTest < MiniTest::Spec
     let(:album_title) { nil }
     it do
       result = form.validate("songs" => [{"title" => "Someday"}], "band" => {"name" => "Nickelback", "label" => {"name" => "Roadrunner Records"}})
-      result.must_equal false
-      form.errors.messages.must_equal(title: ["must be filled"], "band.name": ["you're a bad person"])
+      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")
-      form.errors.messages.must_equal(title: ["must be filled"], "band.name": ["you're a bad person"], 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")
-      form.errors.messages.must_equal(title: ["must be filled"], "band.name": ["you're a bad person"], policy: ["error_text"])
+      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")
-      form.errors.messages.must_equal(title: ["must be filled"], "band.name": ["you're a bad person"], policy: ["error_text", "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
 
@@ -202,14 +202,14 @@ class ErrorsTest < MiniTest::Spec
       )
     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 { 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
 
@@ -219,7 +219,7 @@ class ErrorsTest < MiniTest::Spec
     # 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