reform 2.2.4 → 2.3.3

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"
+    _(form.password).must_equal "123"
 
     form.sync
-    cred.password.must_equal "123" # password written.
+    _(cred.password).must_equal "123" # password written.
 
     hash = {}
     form.save do |nested|
       hash = nested
     end
 
-    hash.must_equal("password"=> "123")
+    _(hash).must_equal("password" => "123")
   }
-end
+end

data/test/reform_new_api.rb

@@ -0,0 +1,204 @@
+require "test_helper"
+
+class ReformTest < Minitest::Spec
+  let(:comp) { OpenStruct.new(name: "Duran Duran", title: "Rio") }
+
+  let(:form) { SongForm.new(comp) }
+
+  class SongForm < TestForm
+    property :name
+    property :title
+
+    validation do
+      params { required(:name).filled }
+    end
+  end
+
+  describe "(new) form with empty models" do
+    let(:comp) { OpenStruct.new }
+
+    it "returns empty fields" do
+      assert_nil form.title
+      _(form.name).must_be_nil
+    end
+
+    describe "and submitted values" do
+      it "returns filled-out fields" do
+        form.validate("name" => "Duran Duran")
+
+        assert_nil form.title
+        _(form.name).must_equal "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"
+    end
+  end
+
+  describe "#validate" do
+    let(:comp) { OpenStruct.new }
+
+    it "ignores unmapped fields in input" do
+      form.validate("name" => "Duran Duran", :genre => "80s")
+      assert_raises NoMethodError do
+        form.genre
+      end
+    end
+
+    it "returns true when valid" do
+      _(form.validate("name" => "Duran Duran")).must_equal true
+    end
+
+    it "exposes input via property accessors" do
+      form.validate("name" => "Duran Duran")
+
+      _(form.name).must_equal "Duran Duran"
+    end
+
+    it "doesn't change model properties" do
+      form.validate("name" => "Duran Duran")
+
+      assert_nil comp.name # don't touch model, yet.
+    end
+
+    # TODO: test errors. test valid.
+    describe "invalid input" do
+      class ValidatingForm < TestForm
+        property :name
+        property :title
+
+        validation do
+          params do
+            required(:name).filled
+            required(:title).filled
+          end
+        end
+      end
+      let(:form) { ValidatingForm.new(comp) }
+
+      it "returns false when invalid" do
+        _(form.validate({})).must_equal false
+      end
+
+      it "populates errors" do
+        form.validate({})
+        _(form.errors.messages).must_equal(name: ["must be filled"], title: ["must be filled"])
+      end
+    end
+  end
+
+  describe "#save" do
+    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"
+      assert_nil comp.title
+    end
+
+    describe "#save with block" do
+      it do
+        hash = {}
+
+        form.save do |map|
+          hash = map
+        end
+
+        _(hash).must_equal("name" => "Diesel Boy", "title" => nil)
+      end
+    end
+  end
+
+  describe "#model" do
+    it { _(form.model).must_equal comp }
+  end
+
+  describe "inheritance" do
+    class HitForm < SongForm
+      property :position
+      validation do
+        params { required(:position).filled }
+      end
+    end
+
+    let(:form) { HitForm.new(OpenStruct.new()) }
+    it do
+      form.validate("title" => "The Body")
+      _(form.title).must_equal "The Body"
+      assert_nil form.position
+      _(form.errors.messages).must_equal(name: ["must be filled"], position: ["must be filled"])
+    end
+  end
+end
+
+class OverridingAccessorsTest < BaseTest
+  class SongForm < TestForm
+    property :title
+
+    def title=(v) # used in #validate.
+      super v * 2
+    end
+
+    def title # used in #sync.
+      super.downcase
+    end
+  end
+
+  let(:song) { Song.new("Pray") }
+  subject { SongForm.new(song) }
+
+  # override reader for presentation.
+  it { _(subject.title).must_equal "pray" }
+
+  describe "#save" do
+    before { subject.validate("title" => "Hey Little World") }
+
+    # reader always used
+    it { _(subject.title).must_equal "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"
+      end
+    end
+
+    # no reader or writer used when saving/syncing.
+    it do
+      song.extend(Saveable)
+      subject.save
+      _(song.title).must_equal "Hey Little WorldHey Little World"
+    end
+  end
+end
+
+class MethodInFormTest < MiniTest::Spec
+  class AlbumForm < TestForm
+    property :title
+
+    def title
+      "The Suffer And The Witness"
+    end
+
+    property :hit do
+      property :title
+
+      def title
+        "Drones"
+      end
+    end
+  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" }
+end

data/test/{reform_test.rb → reform_old_api.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
+      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
+      _(form.name).must_be_nil
     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
+        _(form.name).must_equal "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"
+      _(form.name).must_equal  "Duran Duran"
+      _(form.title).must_equal "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,56 @@ class ReformTest < Minitest::Spec
     end
 
     it "returns true when valid" do
-      form.validate("name" => "Duran Duran").must_equal true
+      _(form.validate("name" => "Duran Duran")).must_equal true
     end
 
     it "exposes input via property accessors" do
       form.validate("name" => "Duran Duran")
 
-      form.name.must_equal "Duran Duran"
+      _(form.name).must_equal "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
+          required(:name).filled
+          required(:title).filled
         end
       end
-      let (:form) { ValidatingForm.new(comp) }
+      let(:form) { ValidatingForm.new(comp) }
 
       it "returns false when invalid" do
-        form.validate({}).must_equal false
+        _(form.validate({})).must_equal false
       end
 
       it "populates errors" do
         form.validate({})
-        form.errors.messages.must_equal({:name=>["is missing"], :title=>["is missing"]})
+        _(form.errors.messages).must_equal({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
+      _(comp.name).must_equal "Diesel Boy"
+      assert_nil comp.title
     end
 
     describe "#save with block" do
@@ -126,42 +110,39 @@ class ReformTest < Minitest::Spec
           hash = map
         end
 
-        hash.must_equal({"name"=>"Diesel Boy"})
+        _(hash).must_equal({"name" => "Diesel Boy", "title" => nil})
       end
     end
   end
 
-
   describe "#model" do
-    it { form.model.must_equal comp }
+    it { _(form.model).must_equal comp }
   end
 
-
   describe "inheritance" do
     class HitForm < SongForm
       property :position
       validation do
-        key(:position).required
+        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.title).must_equal "The Body"
+      assert_nil form.position
+      _(form.errors.messages).must_equal({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 +150,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 { _(subject.title).must_equal "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 { _(subject.title).must_equal "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"
+        _(hash["title"]).must_equal "Hey Little WorldHey Little World"
       end
     end
 
@@ -193,14 +173,13 @@ class OverridingAccessorsTest < BaseTest
     it do
       song.extend(Saveable)
       subject.save
-      song.title.must_equal "Hey Little WorldHey Little World"
+      _(song.title).must_equal "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 +196,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 { _(subject.title).must_equal "The Suffer And The Witness" }
+  it { _(subject.hit.title).must_equal "Drones" }
 end