reform 2.3.3 → 2.5.0

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

data/test/feature_test.rb

@@ -45,8 +45,8 @@ class FeatureInheritanceTest < BaseTest
   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) }

data/test/fixtures/dry_error_messages.yml

@@ -1,94 +1,104 @@
 en:
-  errors:
-    array?: "must be an array"
+  dry_validation:
+    errors:
+      array?: "must be an array"
 
-    empty?: "must be empty"
+      empty?: "must be empty"
 
-    excludes?: "must not include %{value}"
+      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}"
+      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}"
+      eql?: "must be equal to %{left}"
 
-    not_eql?: "must not be equal to %{left}"
+      not_eql?: "must not be equal to %{left}"
 
-    filled?: "must be filled"
+      filled?: "must be filled"
 
-    format?: "is in invalid format"
+      format?: "is in invalid format"
 
-    number?: "must be a number"
+      number?: "must be a number"
 
-    odd?: "must be odd"
+      odd?: "must be odd"
 
-    even?: "must be even"
+      even?: "must be even"
 
-    gt?: "must be greater than %{num}"
+      gt?: "must be greater than %{num}"
 
-    gteq?: "must be greater than or equal to %{num}"
+      gteq?: "must be greater than or equal to %{num}"
 
-    hash?: "must be a hash"
+      hash?: "must be a hash"
 
-    included_in?:
-      arg:
-        default: "must be one of: %{list}"
-        range: "must be one of: %{list_left} - %{list_right}"
+      included_in?:
+        arg:
+          default: "must be one of: %{list}"
+          range: "must be one of: %{list_left} - %{list_right}"
 
-    includes?: "must include %{value}"
+      includes?: "must include %{value}"
 
-    bool?: "must be boolean"
+      bool?: "must be boolean"
 
-    true?: "must be true"
+      true?: "must be true"
 
-    false?: "must be false"
+      false?: "must be false"
 
-    int?: "must be an integer"
+      int?: "must be an integer"
 
-    float?: "must be a float"
+      float?: "must be a float"
 
-    decimal?: "must be a decimal"
+      decimal?: "must be a decimal"
 
-    date?: "must be a date"
+      date?: "must be a date"
 
-    date_time?: "must be a date time"
+      date_time?: "must be a date time"
 
-    time?: "must be a time"
+      time?: "must be a time"
 
-    key?: "is missing"
+      key?: "is missing"
 
-    attr?: "is missing"
+      attr?: "is missing"
 
-    lt?: "must be less than %{num}"
+      lt?: "must be less than %{num}"
 
-    lteq?: "must be less than or equal to %{num}"
+      lteq?: "must be less than or equal to %{num}"
 
-    max_size?: "size cannot be greater than %{num}"
+      max_size?: "size cannot be greater than %{num}"
 
-    min_size?: "size cannot be less than %{num}"
+      min_size?: "size cannot be less than %{num}"
 
-    none?: "cannot be defined"
+      none?: "cannot be defined"
 
-    str?: "must be a string"
+      str?: "must be a string"
 
-    type?: "must be %{type}"
+      type?: "must be %{type}"
 
-    size?:
-      arg:
-        default: "size must be %{size}"
-        range: "size must be within %{size_left} - %{size_right}"
+      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}"
+        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"
+
+      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:
-  errors:
+  dry_validation:
+    errors:
       filled?: "muss abgefüllt sein"