reform 2.3.0.rc1 → 2.3.0.rc2

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

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class FormCompositionInheritanceTest < MiniTest::Spec
   module SizePrice
@@ -26,10 +26,9 @@ class FormCompositionInheritanceTest < MiniTest::Spec
     property :size,   inherit: true, on: :measurement
   end
 
-
-  let (:measurement) { Measurement.new(:l) }
-  let (:tshirt)      { Tshirt.new(2, :m) }
-  let (:form)        { OutfitForm.new(tshirt: tshirt, measurement: measurement) }
+  let(:measurement) { Measurement.new(:l) }
+  let(:tshirt)      { Tshirt.new(2, :m) }
+  let(:form)        { OutfitForm.new(tshirt: tshirt, measurement: measurement) }
 
   Tshirt = Struct.new(:price, :size)
   Measurement = Struct.new(:size)
@@ -46,28 +45,28 @@ class FormCompositionTest < MiniTest::Spec
   class RequestForm < TestForm
     include Composition
 
-    property  :name,          :on =>  :requester
-    property  :requester_id,  :on => :requester, :from => :id
-    properties :title, :id, :on => :song
+    property  :name,          on: :requester
+    property  :requester_id,  on: :requester, from: :id
+    properties :title, :id, on: :song
     # property  :channel # FIXME: what about the "main model"?
-    property :channel, :virtual => true, :on => :song
-    property :requester,      :on => :requester
-    property :captcha,        :on => :song, :virtual => true
+    property :channel, virtual: true, on: :song
+    property :requester,      on: :requester
+    property :captcha,        on: :song, virtual: true
 
     validation do
       required(:name).filled
       required(:title).filled
     end
 
-    property :band,           :on => :song do
+    property :band,           on: :song do
       property :title
     end
   end
 
-  let (:form)       { RequestForm.new(:song => song, :requester => requester) }
-  let (:song)       { Song.new(1, "Rio", band) }
-  let (:requester)  { Requester.new(2, "Duran Duran", "MCP") }
-  let (:band)       { Band.new("Duran^2") }
+  let(:form)       { RequestForm.new(song: song, requester: requester) }
+  let(:song)       { Song.new(1, "Rio", band) }
+  let(:requester)  { Requester.new(2, "Duran Duran", "MCP") }
+  let(:band)       { Band.new("Duran^2") }
 
   # delegation form -> composition works
   it { form.id.must_equal 1 }
@@ -85,7 +84,6 @@ class FormCompositionTest < MiniTest::Spec
   it { form.model[:requester].must_equal requester }
   it { form.model[:song].must_equal 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
@@ -101,7 +99,7 @@ class FormCompositionTest < MiniTest::Spec
         hash[:title]  = form.title
       end
 
-      hash.must_equal({:name=>"Duran Duran", :title=>"Rio"})
+      hash.must_equal({name: "Duran Duran", title: "Rio"})
     end
 
     it "provides nested symbolized hash as second block argument" do
@@ -114,9 +112,9 @@ class FormCompositionTest < MiniTest::Spec
       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"}
-        }
+                        song: {"title" => "Greyhound", "id" => 1, "channel" => "JJJ", "captcha" => "wonderful", "band" => {"title" => "Duran^2"}},
+                        requester: {"name" => "Frenzal Rhomb", "id" => 2, "requester" => "MCP"}
+                      }
       )
     end
 
@@ -162,12 +160,11 @@ class FormCompositionTest < MiniTest::Spec
   end
 end
 
-
 class FormCompositionCollectionTest < MiniTest::Spec
   Book = Struct.new(:id, :name)
   Library = Struct.new(:id) do
     def books
-      [Book.new(1,"My book")]
+      [Book.new(1, "My book")]
     end
   end
 
@@ -180,8 +177,8 @@ class FormCompositionCollectionTest < MiniTest::Spec
     end
   end
 
-  let (:form)   { LibraryForm.new(library: library) }
-  let (:library) { Library.new(2) }
+  let(:form)   { LibraryForm.new(library: library) }
+  let(:library) { Library.new(2) }
 
-  it { form.save do |hash| hash.must_equal({:library=>{"books"=>[{"id"=>1, "name"=>"My book"}]}}) end }
+  it { form.save { |hash| hash.must_equal({library: {"books" => [{"id" => 1, "name" => "My book"}]}}) } }
 end

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_new_api.rb

@@ -0,0 +1,77 @@
+require "test_helper"
+
+class ContractTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :duration, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class ArtistForm < TestForm
+    property :name
+  end
+
+  class AlbumForm < TestContract
+    property :name
+
+    properties :duration
+    properties :year, :style, readable: false
+
+    validation do
+      params { required(:name).filled }
+    end
+
+    collection :songs do
+      property :title
+      validation do
+        params { required(:title).filled }
+      end
+
+      property :composer do
+        property :name
+        validation do
+          params { required(:name).filled }
+        end
+      end
+    end
+
+    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(:form) { AlbumForm.new(album) }
+
+  # accept `property form: SongForm`.
+  it do
+    form.artist.must_be_instance_of ArtistForm
+  end
+
+  describe ".properties" do
+    it "defines a property when called with one argument" do
+      form.must_respond_to :duration
+    end
+
+    it "defines several properties when called with multiple arguments" do
+      form.must_respond_to :year
+      form.must_respond_to :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
+    end
+
+    it "returns the list of defined properties" do
+      returned_value = AlbumForm.properties(:hello, :world, virtual: true)
+      returned_value.must_equal %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\"}>" }
+  end
+end

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

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class ContractTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
@@ -36,13 +36,13 @@ 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
@@ -66,7 +66,7 @@ class ContractTest < MiniTest::Spec
 
     it "returns the list of defined properties" do
       returned_value = AlbumForm.properties(:hello, :world, virtual: true)
-      returned_value.must_equal [:hello, :world]
+      returned_value.must_equal %i[hello world]
     end
   end
 

data/test/default_test.rb

@@ -19,4 +19,4 @@ class DefaultTest < Minitest::Spec
     form.name.must_equal "Wrong"
     form.songs[0].title.must_equal "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
 
@@ -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"}})
     end
   end
 end
 
-
 class ValidateWithBlockTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
   Album = Struct.new(:title, :artist)
@@ -90,13 +87,13 @@ 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|
+    form.validate(json) { |params|
       deserializer.new(form).from_json(params)
-    end.must_equal true # with block must return result, too.
+    }.must_equal true # with block must return result, too.
 
     form.title.must_equal "Apocalypse Soon"
     form.artist.name.must_equal "Mute"

data/test/errors_new_api.rb

@@ -0,0 +1,225 @@
+require "test_helper"
+
+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
+        params { required(:title).filled }
+      end
+    end
+
+    collection :songs do
+      property :title
+      validation do
+        params { required(:title).filled }
+      end
+    end
+
+    property :band do # yepp, people do crazy stuff like that.
+      property :name
+      property :label do
+        property :name
+        validation do
+          params { required(:name).filled }
+        end
+      end
+      # TODO: make band a required object.
+
+      validation do
+        config.messages.load_paths << "test/fixtures/dry_new_api_error_messages.yml"
+
+        params { required(:name).filled }
+
+        rule(:name) { key.failure(:good_musical_taste?) if value == "Nickelback" }
+      end
+    end
+
+    validation do
+      params do
+        required(:title).filled
+        required(:artists).each(:str?)
+        required(:producer).hash do
+          required(:name).filled
+        end
+      end
+    end
+  end
+
+  let(:album_title) { "Blackhawks Over Los Angeles" }
+  let(:album) do
+    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) }
+
+  describe "#validate with invalid array property" do
+    it do
+      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)
+    end
+  end
+
+  describe "#errors without #validate" do
+    it do
+      form.errors.size.must_equal 0
+    end
+  end
+
+  describe "blank everywhere" do
+    before do
+      form.validate(
+        "hit" => {"title" => ""},
+        "title" => "",
+        "songs" => [{"title" => ""}, {"title" => ""}],
+        "producer" => {"name" => ""}
+      )
+    end
+
+    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"],
+        "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.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 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"],
+        "producer.name": ["must be filled"]
+      )
+      form.errors.size.must_equal(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)
+    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) }
+  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) }
+  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) }
+  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)
+    end
+  end
+
+  describe "#add" do
+    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"])
+      # 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"])
+      # 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"])
+      # 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"])
+    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 { @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 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)
+    end
+  end
+
+  describe "Errors#to_s" do
+    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\"]}"
+    }
+  end
+end