sbf-dm-validations 1.3.0.beta

data/spec/integration/length_validator/equality_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+shared_examples 'entity with wrong destination MAC address length' do
+  it 'has error message with range bounds' do
+    expect(@model.errors.on(:destination_mac)).to eq ['Destination mac must be 6 characters long']
+  end
+end
+
+describe 'DataMapper::Validations::Fixtures::EthernetFrame' do
+  before :all do
+    DataMapper::Validations::Fixtures::EthernetFrame.auto_migrate!
+
+    @model = DataMapper::Validations::Fixtures::EthernetFrame.valid_instance
+    @model.link_support_fragmentation = false
+  end
+
+  it_behaves_like 'valid model'
+
+  describe "with destination MAC 3 'bits' long" do
+    before :all do
+      @model.destination_mac = "123"
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+    it_behaves_like 'entity with wrong destination MAC address length'
+  end
+
+  describe "with destination MAC 8 'bits' long" do
+    before :all do
+      @model.destination_mac = "123abce8"
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+    it_behaves_like 'entity with wrong destination MAC address length'
+  end
+
+  # arguable but reasonable for 80% of cases
+  # to treat nil as a 0 lengh value
+  # reported in
+  # http://datamapper.lighthouseapp.com/projects/20609/tickets/646
+  describe "that has no destination MAC address" do
+    before :all do
+      @model.destination_mac = nil
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+    it_behaves_like 'entity with wrong destination MAC address length'
+  end
+
+  describe "with a 6 'bits' destination MAC address" do
+    before :all do
+      @model.destination_mac = "a1b2c3"
+      @model.valid?
+    end
+
+    it_behaves_like 'valid model'
+  end
+
+  describe "with multibyte characters" do
+    before :all do
+      begin
+        # force normal encoding in this block
+        original, $KCODE = $KCODE, 'N' if RUBY_VERSION <= '1.8.6'
+
+        # example from: http://intertwingly.net/stories/2004/04/14/i18n.html
+        @model = DataMapper::Validations::Fixtures::Multibyte.new(
+          :name => 'Iñtërnâtiônàlizætiøn'
+        )
+        expect(@model).to be_valid
+      ensure
+        $KCODE = original if RUBY_VERSION <= '1.8.6'
+      end
+    end
+
+    it_behaves_like 'valid model'
+  end
+end

data/spec/integration/length_validator/error_message_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'DataMapper::Validations::Fixtures::Jabberwock' do
+  before :all do
+    DataMapper::Validations::Fixtures::Jabberwock.auto_migrate!
+
+    @model = DataMapper::Validations::Fixtures::Jabberwock.new
+  end
+
+  describe "without snickersnack" do
+    before :all do
+      @model.snickersnack = nil
+    end
+
+    it_behaves_like 'invalid model'
+
+    it "has custom error message" do
+      expect(@model.errors.on(:snickersnack)).to eq [ 'worble warble' ]
+    end
+  end
+end

data/spec/integration/length_validator/maximum_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+shared_examples 'barcode with invalid code length' do
+  it 'has a meaningful error message with length restrictions mentioned' do
+    expect(@model.errors.on(:code)).to eq ['Code must be at most 10 characters long']
+  end
+end
+
+describe 'DataMapper::Validations::Fixtures::Barcode' do
+  before :all do
+    DataMapper::Validations::Fixtures::Barcode.auto_migrate!
+
+    @model = DataMapper::Validations::Fixtures::Barcode.valid_instance
+  end
+
+  it_behaves_like 'valid model'
+
+  describe "with a 17 characters long code" do
+    before :all do
+      @model.code = "18283849284728124"
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+    it_behaves_like 'barcode with invalid code length'
+  end
+
+  describe "with a 7 characters long code" do
+    before :all do
+      @model.code = "8372786"
+      @model.valid?
+    end
+
+    it_behaves_like 'valid model'
+  end
+
+  describe "with an 11 characters long code" do
+    before :all do
+      @model.code = "83727868754"
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+    it_behaves_like 'barcode with invalid code length'
+  end
+end

data/spec/integration/length_validator/minimum_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+shared_examples 'entity with a name shorter than 2 characters' do
+  it 'has a meaningful error message with length restrictions mentioned' do
+    expect(@model.errors.on(:name)).to eq ['Name must be at least 2 characters long']
+  end
+end
+
+describe 'DataMapper::Validations::Fixtures::Mittelschnauzer' do
+  before :all do
+    DataMapper::Validations::Fixtures::Mittelschnauzer.auto_migrate!
+
+    @model = DataMapper::Validations::Fixtures::Mittelschnauzer.valid_instance
+  end
+
+  it_behaves_like 'valid model'
+
+  describe 'with a 13 characters long name' do
+    it_behaves_like 'valid model'
+  end
+
+  describe "with a single character name" do
+    before :all do
+      @model.name = "R"
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it_behaves_like 'entity with a name shorter than 2 characters'
+  end
+
+  describe "with blank name" do
+    before :all do
+      @model.name = ""
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it_behaves_like 'entity with a name shorter than 2 characters'
+  end
+
+  describe "persisted, with a single character owner" do
+    before :all do
+      @model.save
+      @model.owner = 'a'
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+  end
+end

data/spec/integration/length_validator/range_spec.rb

@@ -0,0 +1,87 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'DataMapper::Validations::Fixtures::EthernetFrame' do
+  before :all do
+    DataMapper::Validations::Fixtures::EthernetFrame.auto_migrate!
+
+    @model = DataMapper::Validations::Fixtures::EthernetFrame.valid_instance
+    @model.link_support_fragmentation = false
+  end
+
+  it_behaves_like 'valid model'
+
+  describe "with payload that is 7 'bits' long (too short)" do
+    before :all do
+      @model.payload = "1234567"
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it "has error message with range bounds" do
+      expect(@model.errors.on(:payload)).to eq [ 'Payload must be between 46 and 1500 characters long' ]
+    end
+  end
+
+
+  describe "with a one character long payload (too short)" do
+    before :all do
+      @model.payload = 'a'
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it "has error message with range bounds" do
+      expect(@model.errors.on(:payload)).to eq [ 'Payload must be between 46 and 1500 characters long' ]
+    end
+  end
+
+
+  describe "with a 1600 'bits' long payload (needs fragmentation)" do
+    before :all do
+      @model.payload = 'a'
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it "has error message with range bounds" do
+      expect(@model.errors.on(:payload)).to eq [ 'Payload must be between 46 and 1500 characters long' ]
+    end
+  end
+
+
+  # arguable but reasonable for 80% of cases
+  # to treat nil as a 0 lengh value
+  # reported in
+  # http://datamapper.lighthouseapp.com/projects/20609/tickets/646
+  describe "that has no payload" do
+    before :all do
+      @model.payload = nil
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it "has error message with range bounds" do
+      expect(@model.errors.on(:payload)).to eq [ 'Payload must be between 46 and 1500 characters long' ]
+    end
+  end
+
+
+
+  describe "with a 50 characters long payload" do
+    before :all do
+      @model.payload = 'Imagine yourself a beautiful bag full of bits here'
+      @model.valid?
+    end
+
+    it_behaves_like 'valid model'
+
+    it "has blank error message" do
+      expect(@model.errors.on(:payload)).to be_nil
+    end
+  end
+end

data/spec/integration/length_validator/spec_helper.rb

@@ -0,0 +1,7 @@
+# put validator specific fixture models and helpers here
+#
+# make sure you check out spec/fixtures to see fixture models
+# already written
+#
+# DataMapper developers feels strongly against foobars in the spec
+# suite

data/spec/integration/method_validator/method_validator_spec.rb

@@ -0,0 +1,243 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+shared_examples 'a good fit for DSLs' do
+  it 'is a good fit for DSLs' do
+    expect(@model).to be_valid_for_implementing_a_dsl
+  end
+
+  it 'is totally fine for DSLs' do
+    expect(@model.ensure_appropriate_for_dsls).to be(true)
+  end
+end
+
+shared_examples 'a poor candidate for DSLs' do
+  it 'is a poor candidate for DSLs' do
+    expect(@model).not_to be_valid_for_implementing_a_dsl
+  end
+
+  it 'is unappropriate for DSLs' do
+    expect(@model.ensure_appropriate_for_dsls.first).to be(false)
+  end
+
+  it 'has a (more or less) meaningful error message' do
+    expect(@model.errors.on(:ensure_appropriate_for_dsls)).to eq ['may not be so good for domain specific languages']
+  end
+
+  it 'has a violation type' do
+    expect(@model.errors[:ensure_appropriate_for_dsls].map(&:type)).to eq [:unsatisfied_condition]
+  end
+end
+
+shared_examples 'a good fit for game engine core' do
+  it 'is a good fit for game engine core' do
+    expect(@model).to be_valid_for_implementing_a_game_engine_core
+  end
+
+  it 'is appropriate for system programming' do
+    expect(@model.ensure_appropriate_for_system_programming).to be(true)
+  end
+end
+
+shared_examples 'a poor candidate for game engine core' do
+  it 'is a poor candidate for game engine core' do
+    expect(@model).not_to be_valid_for_implementing_a_game_engine_core
+  end
+end
+
+shared_examples 'a good fit for kernel hacking' do
+  it 'is a good fit for kernel hacking' do
+    expect(@model).to be_valid_for_hacking_on_the_kernel
+  end
+
+  it 'is appropriate for system programming' do
+    expect(@model.ensure_appropriate_for_system_programming).to be(true)
+  end
+end
+
+shared_examples 'a poor candidate for kernel hacking' do
+  it 'is not a good fit for kernel hacking' do
+    expect(@model).not_to be_valid_for_hacking_on_the_kernel
+  end
+end
+
+#
+# Note that ProgrammingLanguage is not a DM resource,
+# it is a plain old Ruby object (PORO), or simply put,
+# just a 'regular' Ruby class with a bunch of accessors.
+#
+# And yes, assumptions below are full of bullshit and
+# author is a moron, and your favourite programming
+# language is good for EVARYTHIN'!
+#
+#Please see spec_helper.rb next to this file
+#
+
+describe 'C' do
+  before :all do
+    @model = ::DataMapper::Validations::Fixtures::ProgrammingLanguage.new(:name                                     => 'C',
+                                                                       :allows_system_calls                      => true,
+                                                                       :allows_manual_memory_management          => true,
+                                                                       :approved_by_linus                        => true,
+                                                                       :compiler_excels_at_utilizing_cpu_cache   => true,
+                                                                       :is_very_high_level                       => false,
+                                                                       :does_not_require_explicit_return_keyword => false,
+                                                                       :allows_operator_overload                 => false,
+                                                                       :allows_optional_parentheses              => false
+                                                                       )
+  end
+
+  it_behaves_like 'a good fit for kernel hacking'
+
+  it_behaves_like 'a good fit for game engine core'
+
+  it_behaves_like 'a poor candidate for DSLs'
+end
+
+
+
+describe 'C++' do
+  before :all do
+    @model = ::DataMapper::Validations::Fixtures::ProgrammingLanguage.new(:name                                     => 'C++',
+                                                                       :allows_system_calls                      => true,
+                                                                       :allows_manual_memory_management          => true,
+                                                                       :approved_by_linus                        => false,
+                                                                       :compiler_excels_at_utilizing_cpu_cache   => true,
+                                                                       :is_very_high_level                       => false,
+                                                                       :does_not_require_explicit_return_keyword => false,
+                                                                       :allows_operator_overload                 => true,
+                                                                       :allows_optional_parentheses              => false
+                                                                       )
+  end
+
+  it_behaves_like 'a poor candidate for kernel hacking'
+
+  it_behaves_like 'a good fit for game engine core'
+
+  it_behaves_like 'a poor candidate for DSLs'
+
+  it 'is not approved by Linus' do
+    @model.valid?(:hacking_on_the_kernel)
+    expect(@model.errors.on(:ensure_approved_by_linus_himself)).not_to be_empty
+    expect(@model.errors[:ensure_approved_by_linus_himself].map(&:type)).to eq [:unapproved_by_linus]
+  end
+end
+
+
+describe 'Ruby' do
+  before :all do
+    @model = ::DataMapper::Validations::Fixtures::ProgrammingLanguage.new(:name                                     => 'Ruby',
+                                                                       # well, C extensions do not really count
+                                                                       :allows_system_calls                      => false,
+                                                                       :allows_manual_memory_management          => false,
+                                                                       :approved_by_linus                        => false,
+                                                                       :compiler_excels_at_utilizing_cpu_cache   => false,
+                                                                       :is_very_high_level                       => true,
+                                                                       :does_not_require_explicit_return_keyword => true,
+                                                                       :allows_operator_overload                 => true,
+                                                                       :allows_optional_parentheses              => true
+                                                                       )
+  end
+
+  it_behaves_like 'a good fit for DSLs'
+
+  it_behaves_like 'a poor candidate for kernel hacking'
+
+  it_behaves_like 'a poor candidate for game engine core'
+
+  it 'has a (more or less) meaningful error message' do
+    @model.valid?(:doing_system_programming)
+    expect(@model.errors.on(:ensure_appropriate_for_system_programming)).to eq [ 'try something that is closer to the metal' ]
+  end
+end
+
+
+describe 'Scala' do
+  before :all do
+    @model = ::DataMapper::Validations::Fixtures::ProgrammingLanguage.new(:name                                     => 'Scala',
+                                                                       :allows_system_calls                      => false,
+                                                                       :allows_manual_memory_management          => false,
+                                                                       :approved_by_linus                        => false,
+                                                                       :compiler_excels_at_utilizing_cpu_cache   => false,
+                                                                       :is_very_high_level                       => true,
+                                                                       :does_not_require_explicit_return_keyword => true,
+                                                                       :allows_operator_overload                 => true,
+                                                                       :allows_optional_parentheses              => true
+                                                                       )
+  end
+
+  it_behaves_like 'a good fit for DSLs'
+
+  it_behaves_like 'a poor candidate for kernel hacking'
+
+  it_behaves_like 'a poor candidate for game engine core'
+
+  it 'has a (more or less) meaningful error message' do
+    @model.valid?(:doing_system_programming)
+    expect(@model.errors.on(:ensure_appropriate_for_system_programming)).to eq [ 'try something that is closer to the metal' ]
+  end
+end
+
+
+
+describe 'Haskell' do
+  before :all do
+    @model = ::DataMapper::Validations::Fixtures::ProgrammingLanguage.new(
+      :name                                     => 'Haskell',
+      :allows_system_calls                      => false,
+      :allows_manual_memory_management          => false,
+      :approved_by_linus                        => false,
+      :compiler_excels_at_utilizing_cpu_cache   => true,
+      :is_very_high_level                       => true,
+      :does_not_require_explicit_return_keyword => true,
+      # operators are not different from any other function
+      :allows_operator_overload                 => true,
+      # or, allows explicit parentheses? who cares, we
+      # are just trying to come up with a relatively
+      # non-stupid spec example
+      :allows_optional_parentheses              => true
+    )
+  end
+
+  it_behaves_like 'a good fit for DSLs'
+
+  it_behaves_like 'a poor candidate for kernel hacking'
+
+  it_behaves_like 'a poor candidate for game engine core'
+
+  it 'has a (more or less) meaningful error message' do
+    @model.valid?(:doing_system_programming)
+    expect(@model.errors.on(:ensure_appropriate_for_system_programming)).to eq [ 'try something that is closer to the metal' ]
+  end
+end
+
+
+describe 'DataMapper::Validations::Fixtures::Event' do
+  before :all do
+    DataMapper::Validations::Fixtures::Event.auto_migrate!
+
+    @model = DataMapper::Validations::Fixtures::Event.new(:name => 'Fools day 2009')
+  end
+
+  describe 'with start time before end time' do
+    before :all do
+      @model.starts_at = DateTime.new(2009, 4, 1, 00, 00, 01)
+      @model.ends_at   = DateTime.new(2009, 4, 1, 23, 59, 59)
+    end
+
+    it_behaves_like 'valid model'
+  end
+
+  describe 'with start time after end time' do
+    before :all do
+      @model.starts_at = DateTime.new(2009, 4, 1, 23, 59, 59)
+      @model.ends_at   = DateTime.new(2009, 4, 1, 00, 00, 01)
+    end
+
+    it_behaves_like 'invalid model'
+
+    it 'uses custom error message for property starts_at' do
+      expect(@model.errors.on(:starts_at)).to eq [ 'Start time cannot be after end time' ]
+    end
+  end
+end

data/spec/integration/method_validator/spec_helper.rb

@@ -0,0 +1,5 @@
+# make sure you check out spec/fixtures to see fixture models
+# already written
+#
+# DataMapper developers feels strongly against foobars in the spec
+# suite

data/spec/integration/numeric_validator/equality_with_float_type_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'DataMapper::Validations::Fixtures::BasketballCourt' do
+  before :all do
+    DataMapper::Validations::Fixtures::BasketballCourt.auto_migrate!
+  end
+
+  describe "with valid set of attributes" do
+    before :all do
+      @model = DataMapper::Validations::Fixtures::BasketballCourt.valid_instance
+      @model.valid?
+    end
+
+    it_behaves_like 'valid model'
+  end
+
+
+  describe "with rim height of 3.05" do
+    before :all do
+      @model = DataMapper::Validations::Fixtures::BasketballCourt.valid_instance(:rim_height => 3.05)
+      @model.valid?
+    end
+
+    it_behaves_like 'valid model'
+  end
+
+
+  describe "with rim height of 3.30" do
+    before :all do
+      @model = DataMapper::Validations::Fixtures::BasketballCourt.valid_instance(:rim_height => 3.30)
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it "has a meaningful error message" do
+      expect(@model.errors.on(:rim_height)).to eq [ 'Rim height must be equal to 3.05' ]
+    end
+  end
+
+
+  describe "with free throw line distance of 4.57" do
+    before :all do
+      @model = DataMapper::Validations::Fixtures::BasketballCourt.valid_instance(:free_throw_line_distance => 4.57)
+      @model.valid?
+    end
+
+    it_behaves_like 'valid model'
+  end
+
+
+  describe "with free throw line distance of 3.10" do
+    before :all do
+      @model = DataMapper::Validations::Fixtures::BasketballCourt.valid_instance(:free_throw_line_distance => 3.10)
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it "has a meaningful error message" do
+      expect(@model.errors.on(:free_throw_line_distance)).to eq [ 'Free throw line distance must be equal to 4.57' ]
+    end
+  end
+end

data/spec/integration/numeric_validator/equality_with_integer_type_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'DataMapper::Validations::Fixtures::LerneanHydra' do
+  before :all do
+    DataMapper::Validations::Fixtures::LerneanHydra.auto_migrate!
+  end
+
+  describe "with valid set of attributes" do
+    before :all do
+      @model = DataMapper::Validations::Fixtures::LerneanHydra.valid_instance
+      @model.valid?
+    end
+
+    it_behaves_like 'valid model'
+  end
+
+
+  describe "with 9 heads" do
+    before :all do
+      @model = DataMapper::Validations::Fixtures::LerneanHydra.valid_instance(:head_count => 9)
+      @model.valid?
+    end
+
+    it_behaves_like 'valid model'
+  end
+
+
+  describe "with only 3 heads" do
+    before :all do
+      @model = DataMapper::Validations::Fixtures::LerneanHydra.valid_instance(:head_count => 3)
+      @model.valid?
+    end
+
+    it_behaves_like 'invalid model'
+
+    it "has a meaningful error message" do
+      expect(@model.errors.on(:head_count)).to eq [ 'Lernean hydra is said to have exactly 9 heads' ]
+    end
+  end
+end