reform 2.2.4 → 2.6.2

data/test/readable_test.rb

@@ -1,30 +1,30 @@
-require 'test_helper'
+require "test_helper"
 
 class ReadableTest < MiniTest::Spec
   Credentials = Struct.new(:password)
 
-  class PasswordForm < Reform::Form
+  class PasswordForm < TestForm
     property :password, readable: false
   end
 
-  let (:cred) { Credentials.new }
-  let (:form) { PasswordForm.new(cred) }
+  let(:cred) { Credentials.new }
+  let(:form) { PasswordForm.new(cred) }
 
   it {
-    form.password.must_equal nil # password not read.
+    assert_nil form.password # password not read.
 
     form.validate("password" => "123")
 
-    form.password.must_equal "123"
+    assert_equal form.password, "123"
 
     form.sync
-    cred.password.must_equal "123" # password written.
+    assert_equal cred.password, "123" # password written.
 
     hash = {}
     form.save do |nested|
       hash = nested
     end
 
-    hash.must_equal("password"=> "123")
+    assert_equal hash, "password" => "123"
   }
-end
+end

data/test/reform_test.rb

@@ -1,47 +1,46 @@
-require 'test_helper'
+require "test_helper"
 
-# TODO: this test should be removed.
 class ReformTest < Minitest::Spec
-  let (:comp) { OpenStruct.new(:name => "Duran Duran", :title => "Rio") }
+  let(:comp) { OpenStruct.new(name: "Duran Duran", title: "Rio") }
 
-  let (:form) { SongForm.new(comp) }
+  let(:form) { SongForm.new(comp) }
 
-  class SongForm < Reform::Form
+  class SongForm < TestForm
     property :name
     property :title
 
     validation do
-      key(:name).required
+      params { required(:name).filled }
     end
   end
 
   describe "(new) form with empty models" do
-    let (:comp) { OpenStruct.new }
+    let(:comp) { OpenStruct.new }
 
     it "returns empty fields" do
-      form.title.must_equal nil
-      form.name.must_equal  nil
+      assert_nil form.title
+      assert_nil form.name
     end
 
     describe "and submitted values" do
       it "returns filled-out fields" do
         form.validate("name" => "Duran Duran")
 
-        form.title.must_equal nil
-        form.name.must_equal  "Duran Duran"
+        assert_nil form.title
+        assert_equal form.name, "Duran Duran"
       end
     end
   end
 
   describe "(edit) form with existing models" do
     it "returns filled-out fields" do
-      form.name.must_equal  "Duran Duran"
-      form.title.must_equal "Rio"
+      assert_equal form.name,  "Duran Duran"
+      assert_equal form.title, "Rio"
     end
   end
 
   describe "#validate" do
-    let (:comp) { OpenStruct.new }
+    let(:comp) { OpenStruct.new }
 
     it "ignores unmapped fields in input" do
       form.validate("name" => "Duran Duran", :genre => "80s")
@@ -51,71 +50,58 @@ class ReformTest < Minitest::Spec
     end
 
     it "returns true when valid" do
-      form.validate("name" => "Duran Duran").must_equal true
+      assert_equal form.validate("name" => "Duran Duran"), true
     end
 
     it "exposes input via property accessors" do
       form.validate("name" => "Duran Duran")
 
-      form.name.must_equal "Duran Duran"
+      assert_equal form.name, "Duran Duran"
     end
 
     it "doesn't change model properties" do
       form.validate("name" => "Duran Duran")
 
-      comp.name.must_equal nil # don't touch model, yet.
+      assert_nil comp.name # don't touch model, yet.
     end
 
     # TODO: test errors. test valid.
     describe "invalid input" do
-      class ValidatingForm < Reform::Form
+      class ValidatingForm < TestForm
         property :name
         property :title
 
         validation do
-          key(:name).required
-          key(:title).required
+          params do
+            required(:name).filled
+            required(:title).filled
+          end
         end
       end
-      let (:form) { ValidatingForm.new(comp) }
+      let(:form) { ValidatingForm.new(comp) }
 
       it "returns false when invalid" do
-        form.validate({}).must_equal false
+        assert_equal form.validate({}), false
       end
 
       it "populates errors" do
         form.validate({})
-        form.errors.messages.must_equal({:name=>["is missing"], :title=>["is missing"]})
+        assert_equal form.errors.messages, name: ["must be filled"], title: ["must be filled"]
       end
     end
   end
 
-  # FIXME: add this test to reform-rails.
-  describe "#errors" do
-    before { form.validate({})}
-
-    it { form.errors.must_be_kind_of Reform::Contract::Errors }
-
-    it { form.errors.messages.must_equal({}) }
-
-    it do
-      form.validate({"name"=>""})
-      form.errors.messages.must_equal({:name=>["must be filled"]})
-    end
-  end
-
-
   describe "#save" do
-    let (:comp) { OpenStruct.new }
-    let (:form) { SongForm.new(comp) }
+    let(:comp) { OpenStruct.new }
+    let(:form) { SongForm.new(comp) }
 
     before { form.validate("name" => "Diesel Boy") }
 
     it "xxpushes data to models" do
       form.save
 
-      comp.name.must_equal "Diesel Boy"
-      comp.title.must_equal nil
+      assert_equal comp.name, "Diesel Boy"
+      assert_nil comp.title
     end
 
     describe "#save with block" do
@@ -126,42 +112,39 @@ class ReformTest < Minitest::Spec
           hash = map
         end
 
-        hash.must_equal({"name"=>"Diesel Boy"})
+        assert_equal hash, "name" => "Diesel Boy", "title" => nil
       end
     end
   end
 
-
   describe "#model" do
-    it { form.model.must_equal comp }
+    it { assert_equal form.model, comp }
   end
 
-
   describe "inheritance" do
     class HitForm < SongForm
       property :position
       validation do
-        key(:position).required
+        params { required(:position).filled }
       end
     end
 
-    let (:form) { HitForm.new(OpenStruct.new()) }
+    let(:form) { HitForm.new(OpenStruct.new()) }
     it do
-      form.validate({"title" => "The Body"})
-      form.title.must_equal "The Body"
-      form.position.must_equal nil
-      form.errors.messages.must_equal({:name=>["is missing"], :position=>["is missing"]})
+      form.validate("title" => "The Body")
+      assert_equal form.title, "The Body"
+      assert_nil form.position
+      assert_equal form.errors.messages, name: ["must be filled"], position: ["must be filled"]
     end
   end
 end
 
-
 class OverridingAccessorsTest < BaseTest
-  class SongForm < Reform::Form
+  class SongForm < TestForm
     property :title
 
     def title=(v) # used in #validate.
-      super v*2
+      super v * 2
     end
 
     def title # used in #sync.
@@ -169,23 +152,22 @@ class OverridingAccessorsTest < BaseTest
     end
   end
 
-  let (:song) { Song.new("Pray") }
+  let(:song) { Song.new("Pray") }
   subject { SongForm.new(song) }
 
   # override reader for presentation.
-  it { subject.title.must_equal "pray" }
-
+  it { assert_equal subject.title, "pray" }
 
   describe "#save" do
     before { subject.validate("title" => "Hey Little World") }
 
     # reader always used
-    it { subject.title.must_equal "hey little worldhey little world" }
+    it { assert_equal subject.title, "hey little worldhey little world" }
 
     # the reader is not used when saving/syncing.
     it do
       subject.save do |hash|
-        hash["title"].must_equal "Hey Little WorldHey Little World"
+        assert_equal hash["title"], "Hey Little WorldHey Little World"
       end
     end
 
@@ -193,14 +175,13 @@ class OverridingAccessorsTest < BaseTest
     it do
       song.extend(Saveable)
       subject.save
-      song.title.must_equal "Hey Little WorldHey Little World"
+      assert_equal song.title, "Hey Little WorldHey Little World"
     end
   end
 end
 
-
 class MethodInFormTest < MiniTest::Spec
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title
 
     def title
@@ -217,7 +198,7 @@ class MethodInFormTest < MiniTest::Spec
   end
 
   # methods can be used instead of created accessors.
-  subject { AlbumForm.new(OpenStruct.new(:hit => OpenStruct.new)) }
-  it { subject.title.must_equal "The Suffer And The Witness" }
-  it { subject.hit.title.must_equal "Drones" }
+  subject { AlbumForm.new(OpenStruct.new(hit: OpenStruct.new)) }
+  it { assert_equal subject.title, "The Suffer And The Witness" }
+  it { assert_equal subject.hit.title, "Drones" }
 end

data/test/save_test.rb

@@ -1,26 +1,26 @@
-require 'test_helper'
+require "test_helper"
 
 class SaveTest < BaseTest
   Song  = Struct.new(:title, :album, :composer)
   Album = Struct.new(:name, :songs, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name
     validation do
-      key(:name).required
+      params { required(:name).filled }
     end
 
     collection :songs do
       property :title
       validation do
-        key(:title).required
+        params { required(:title).filled }
       end
 
       property :composer do
         property :name
         validation do
-          key(:name).required
+          params { required(:name).filled }
         end
       end
     end
@@ -36,45 +36,57 @@ class SaveTest < BaseTest
     end
 
     def saved?
-      @saved
+      defined?(@saved) && @saved
     end
   end
 
+  let(:song)               { Song.new("Broken").extend(Saveable) }
+  # let(:song_with_composer) { Song.new("Resist Stance", nil, composer).extend(Saveable) }
+  let(:composer)           { Artist.new("Greg Graffin").extend(Saveable) }
+  let(:artist)             { Artist.new("Bad Religion").extend(Saveable).extend(Saveable) }
+  let(:album)              { Album.new("The Dissent Of Man", [song], artist).extend(Saveable) }
 
-  let (:song)               { Song.new("Broken").extend(Saveable) }
-  # let (:song_with_composer) { Song.new("Resist Stance", nil, composer).extend(Saveable) }
-  let (:composer)           { Artist.new("Greg Graffin").extend(Saveable) }
-  let (:artist)             { Artist.new("Bad Religion").extend(Saveable).extend(Saveable) }
-  let (:album)              { Album.new("The Dissent Of Man", [song], artist).extend(Saveable) }
-
-  let (:form) { AlbumForm.new(album) }
-
+  let(:form) { AlbumForm.new(album) }
 
   it do
     form.validate("songs" => [{"title" => "Fixed"}])
 
     form.save
 
-    album.saved?.must_equal true
-    album.songs[0].title.must_equal "Fixed"
-    album.songs[0].saved?.must_equal true
-    album.artist.saved?.must_equal nil
+    assert album.saved?
+    assert_equal album.songs[0].title, "Fixed"
+    assert album.songs[0].saved?
+    assert_nil album.artist.saved?
   end
-end
 
+  describe "#sync with block" do
+    it do
+      form = AlbumForm.new(Album.new("Greatest Hits"))
+
+      form.validate(name: nil) # nil-out the title.
+
+      nested_hash = nil
+      form.sync do |hash|
+        nested_hash = hash
+      end
+
+      assert_equal nested_hash, "name" => nil, "artist" => nil
+    end
+  end
+end
 
 # class SaveWithDynamicOptionsTest < MiniTest::Spec
 #   Song = Struct.new(:id, :title, :length) do
 #     include Saveable
 #   end
 
-#   class SongForm < Reform::Form
+#   class SongForm < TestForm
 #     property :title#, save: false
 #     property :length, virtual: true
 #   end
 
-#   let (:song) { Song.new }
-#   let (:form) { SongForm.new(song) }
+#   let(:song) { Song.new }
+#   let(:form) { SongForm.new(song) }
 
 #   # we have access to original input value and outside parameters.
 #   it "xxx" do
@@ -83,7 +95,7 @@ end
 #     form.save(length: lambda { |value, options| form.model.id = "#{value}: #{length_seconds}" })
 
 #     song.title.must_equal "A Poor Man's Memory"
-#     song.length.must_equal nil
+#     assert_nil song.length
 #     song.id.must_equal "10: 120"
 #   end
 # end

data/test/setup_test.rb

@@ -5,7 +5,7 @@ class SetupTest < MiniTest::Spec
   Album = Struct.new(:name, :songs, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :name
     collection :songs do
       property :title
@@ -20,29 +20,29 @@ class SetupTest < MiniTest::Spec
     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(: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") }
 
   describe "with nested objects" do
-    let (:album) { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
+    let(:album) { Album.new("The Dissent Of Man", [song, song_with_composer], artist) }
 
     it do
       form = AlbumForm.new(album)
 
-      form.name.must_equal "The Dissent Of Man"
-      form.songs[0].title.must_equal "Broken"
-      form.songs[0].composer.must_equal nil
-      form.songs[1].title.must_equal "Resist Stance"
-      form.songs[1].composer.name.must_equal "Greg Graffin"
-      form.artist.name.must_equal "Bad Religion"
+      assert_equal form.name, "The Dissent Of Man"
+      assert_equal form.songs[0].title, "Broken"
+      assert_nil form.songs[0].composer
+      assert_equal form.songs[1].title, "Resist Stance"
+      assert_equal form.songs[1].composer.name, "Greg Graffin"
+      assert_equal form.artist.name, "Bad Religion"
 
       # make sure all is wrapped in forms.
-      form.songs[0].must_be_kind_of Reform::Form
-      form.songs[1].must_be_kind_of Reform::Form
-      form.songs[1].composer.must_be_kind_of Reform::Form
-      form.artist.must_be_kind_of Reform::Form
+      assert form.songs[0].is_a? Reform::Form
+      assert form.songs[1].is_a? Reform::Form
+      assert form.songs[1].composer.is_a? Reform::Form
+      assert form.artist.is_a? Reform::Form
     end
   end
-end
+end

data/test/skip_if_test.rb

@@ -1,14 +1,16 @@
-require 'test_helper'
+require "test_helper"
 
 class SkipIfTest < BaseTest
+  let(:hit) { Song.new }
+  let(:album) { Album.new(nil, hit, [], nil) }
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title
 
-    property :hit, skip_if: lambda { |options| options[:fragment]["title"]=="" } do
+    property :hit, skip_if: ->(options) { options[:fragment]["title"] == "" } do
       property :title
       validation do
-        key(:title).required
+        params { required(:title).filled }
       end
     end
 
@@ -21,36 +23,32 @@ class SkipIfTest < BaseTest
     end
   end
 
-
-  let (:hit) { Song.new }
-  let (:album) { Album.new(nil, hit, [], nil) }
-
   # deserializes when present.
   it do
     form = AlbumForm.new(album)
-    form.validate("hit" => {"title" => "Altar Of Sacrifice"}).must_equal true
-    form.hit.title.must_equal "Altar Of Sacrifice"
+    assert form.validate("hit" => {"title" => "Altar Of Sacrifice"})
+    assert_equal form.hit.title, "Altar Of Sacrifice"
   end
 
   # skips deserialization when not present.
   it do
     form = AlbumForm.new(Album.new)
-    form.validate("hit" => {"title" => ""}).must_equal true
-    form.hit.must_equal nil # hit hasn't been deserialised.
+    assert form.validate("hit" => {"title" => ""})
+    assert_nil form.hit # hit hasn't been deserialised.
   end
 
   # skips deserialization when not present.
   it do
     form = AlbumForm.new(Album.new(nil, nil, []))
-    form.validate("songs" => [{"title" => "Waste Of Breath"}, {"title" => nil}]).must_equal true
-    form.songs.size.must_equal 1
-    form.songs[0].title.must_equal "Waste Of Breath"
+    assert form.validate("songs" => [{"title" => "Waste Of Breath"}, {"title" => nil}])
+    assert_equal form.songs.size, 1
+    assert_equal form.songs[0].title, "Waste Of Breath"
   end
 end
 
 class SkipIfAllBlankTest < BaseTest
   # skip_if: :all_blank"
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     collection :songs, skip_if: :all_blank, populate_if_empty: BaseTest::Song do
       property :title
       property :length
@@ -60,15 +58,28 @@ class SkipIfAllBlankTest < BaseTest
   # create only one object.
   it do
     form = AlbumForm.new(OpenStruct.new(songs: []))
-    form.validate("songs" => [{"title"=>"Apathy"}, {"title"=>"", "length" => ""}]).must_equal true
-    form.songs.size.must_equal 1
-    form.songs[0].title.must_equal "Apathy"
+    assert form.validate("songs" => [{"title" => "Apathy"}, {"title" => "", "length" => ""}])
+    assert_equal form.songs.size, 1
+    assert_equal form.songs[0].title, "Apathy"
   end
 
   it do
     form = AlbumForm.new(OpenStruct.new(songs: []))
-    form.validate("songs" => [{"title"=>"", "length" => ""}, {"title"=>"Apathy"}]).must_equal true
-    form.songs.size.must_equal 1
-    form.songs[0].title.must_equal "Apathy"
+    assert form.validate("songs" => [{"title" => "", "length" => ""}, {"title" => "Apathy"}])
+    assert_equal form.songs.size, 1
+    assert_equal form.songs[0].title, "Apathy"
+  end
+end
+
+class InvalidOptionsCombinationTest < BaseTest
+  it do
+    assert_raises(Reform::Form::InvalidOptionsCombinationError) do
+      class AlbumForm < TestForm
+        collection :songs, skip_if: :all_blank, populator: -> {} do
+          property :title
+          property :length
+        end
+      end
+    end
   end
 end

data/test/skip_setter_and_getter_test.rb

@@ -7,7 +7,7 @@ class SetupSkipSetterAndGetterTest < MiniTest::Spec
   Album = Struct.new(:title, :artist)
   Artist = Struct.new(:name)
 
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title
 
     def title
@@ -31,24 +31,23 @@ class SetupSkipSetterAndGetterTest < MiniTest::Spec
     end
   end
 
-  let (:artist) { Artist.new("Bad Religion") }
-
+  let(:artist) { Artist.new("Bad Religion") }
 
   it do
     album = Album.new("Greatest Hits", artist)
     form  = AlbumForm.new(album)
 
-    form.title.must_equal "GREATEST HITS"
-    form.artist.name.must_equal "bad religion"
+    assert_equal form.title, "GREATEST HITS"
+    assert_equal form.artist.name, "bad religion"
 
     form.validate("title" => "Resiststance", "artist" => {"name" => "Greg Graffin"})
 
-    form.title.must_equal "ECNATSTSISER" # first, setter called, then getter.
-    form.artist.name.must_equal "greg graffi"
+    assert_equal form.title, "ECNATSTSISER" # first, setter called, then getter.
+    assert_equal form.artist.name, "greg graffi"
 
     form.sync
 
-    album.title.must_equal "ecnatstsiseR" # setter called, but not getter.
-    album.artist.name.must_equal "Greg Graffi"
+    assert_equal album.title, "ecnatstsiseR" # setter called, but not getter.
+    assert_equal album.artist.name, "Greg Graffi"
   end
-end
+end

data/test/test_helper.rb

@@ -1,11 +1,26 @@
 require "reform"
-require 'minitest/autorun'
+require "minitest/autorun"
 require "representable/debug"
 require "declarative/testing"
 require "pp"
 
+require "reform/form/dry"
+
+# setup test classes so we can test without dry being included
+class TestForm < Reform::Form
+  feature Reform::Form::Dry
+end
+
+class TestContract < Reform::Contract
+  feature Reform::Form::Dry
+end
+
+module Types
+  include Dry.Types()
+end
+
 class BaseTest < MiniTest::Spec
-  class AlbumForm < Reform::Form
+  class AlbumForm < TestForm
     property :title
 
     property :hit do
@@ -17,17 +32,20 @@ class BaseTest < MiniTest::Spec
     end
   end
 
-  Song   = Struct.new(:title, :length)
+  Song   = Struct.new(:title, :length, :rating)
   Album  = Struct.new(:title, :hit, :songs, :band)
   Band   = Struct.new(:label)
   Label  = Struct.new(:name)
   Length = Struct.new(:minutes, :seconds)
 
-
-  let (:hit) { Song.new("Roxanne") }
+  let(:hit) { Song.new("Roxanne") }
 end
 
 MiniTest::Spec.class_eval do
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
   module Saveable
     def save
       @saved = true
@@ -38,12 +56,3 @@ MiniTest::Spec.class_eval do
     end
   end
 end
-
-require "reform/form/dry"
-Reform::Contract.class_eval do
-  feature Reform::Form::Dry
-end
-# FIXME!
-Reform::Form.class_eval do
-  feature Reform::Form::Dry
-end