aequitas 0.0.1 → 0.0.2

data/spec_legacy/integration/length_validator/error_message_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'integration/length_validator/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_should_behave_like "invalid model"
-
-    it "has custom error message" do
-      @model.errors.on(:snickersnack).should == [ 'worble warble' ]
-    end
-  end
-end

data/spec_legacy/integration/length_validator/maximum_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'integration/length_validator/spec_helper'
-
-describe "barcode with invalid code length", :shared => true do
-  it "has a meaninful error message with length restrictions mentioned" do
-    @model.errors.on(:code).should == [ '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_should_behave_like "valid model"
-
-  describe "with a 17 characters long code" do
-    before :all do
-      @model.code = "18283849284728124"
-      @model.valid?
-    end
-
-    it_should_behave_like "invalid model"
-
-    it_should_behave_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_should_behave_like "valid model"
-  end
-
-  describe "with an 11 characters long code" do
-    before :all do
-      @model.code = "83727868754"
-      @model.valid?
-    end
-
-    it_should_behave_like "invalid model"
-
-    it_should_behave_like "barcode with invalid code length"
-  end
-end

data/spec_legacy/integration/length_validator/minimum_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'integration/length_validator/spec_helper'
-
-describe "entity with a name shorter than 2 characters", :shared => true do
-  it "has a meaninful error message with length restrictions mentioned" do
-    @model.errors.on(:name).should == [ '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_should_behave_like "valid model"
-
-  describe "with a 13 characters long name" do
-    it_should_behave_like "valid model"
-  end
-
-  describe "with a single character name" do
-    before :all do
-      @model.name = "R"
-      @model.valid?
-    end
-
-    it_should_behave_like "invalid model"
-
-    it_should_behave_like "entity with a name shorter than 2 characters"
-  end
-
-  describe "with blank name" do
-    before :all do
-      @model.name = ""
-      @model.valid?
-    end
-
-    it_should_behave_like "invalid model"
-
-    it_should_behave_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_should_behave_like "invalid model"
-  end
-end

data/spec_legacy/integration/length_validator/range_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'integration/length_validator/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_should_behave_like "valid model"
-
-  describe "with payload that is 7 'bits' long (too short)" do
-    before :all do
-      @model.payload = "1234567"
-      @model.valid?
-    end
-
-    it_should_behave_like "invalid model"
-
-    it "has error message with range bounds" do
-      @model.errors.on(:payload).should == [ '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_should_behave_like "invalid model"
-
-    it "has error message with range bounds" do
-      @model.errors.on(:payload).should == [ '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_should_behave_like "invalid model"
-
-    it "has error message with range bounds" do
-      @model.errors.on(:payload).should == [ '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_should_behave_like "invalid model"
-
-    it "has error message with range bounds" do
-      @model.errors.on(:payload).should == [ '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_should_behave_like "valid model"
-
-    it "has blank error message" do
-      @model.errors.on(:payload).should be_nil
-    end
-  end
-end

data/spec_legacy/integration/length_validator/spec_helper.rb

@@ -1,7 +0,0 @@
-# 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_legacy/integration/method_validator/method_validator_spec.rb

@@ -1,242 +0,0 @@
-require 'spec_helper'
-require 'integration/method_validator/spec_helper'
-
-describe "a good fit for DSLs", :shared => true do
-  it "is a good fit for DSLs" do
-    @model.should be_valid_for_implementing_a_dsl
-  end
-
-  it "is totally fine for DSLs" do
-    @model.ensure_appropriate_for_dsls.should be(true)
-  end
-end
-
-describe "a poor candidate for DSLs", :shared => true do
-  it "is a poor candidate for DSLs" do
-    @model.should_not be_valid_for_implementing_a_dsl
-  end
-
-  it "is unappropriate for DSLs" do
-    @model.ensure_appropriate_for_dsls.first.should be(false)
-  end
-
-  it "has a (more or less) meaningful error message" do
-    @model.errors.on(:ensure_appropriate_for_dsls).should == [ 'may not be so good for domain specific languages' ]
-  end
-end
-
-
-describe "a good fit for game engine core", :shared => true do
-  it "is a good fit for game engine core" do
-    @model.should be_valid_for_implementing_a_game_engine_core
-  end
-
-  it "is appropriate for system programming" do
-    @model.ensure_appropriate_for_system_programming.should be(true)
-  end
-end
-
-describe "a poor candidate for game engine core", :shared => true do
-  it "is a poor candidate for game engine core" do
-    @model.should_not be_valid_for_implementing_a_game_engine_core
-  end
-end
-
-
-
-describe "a good fit for kernel hacking", :shared => true do
-  it "is a good fit for kernel hacking" do
-    @model.should be_valid_for_hacking_on_the_kernel
-  end
-
-  it "is appropriate for system programming" do
-    @model.ensure_appropriate_for_system_programming.should be(true)
-  end
-end
-
-
-describe "a poor candidate for kernel hacking", :shared => true do
-  it "is not a good fit for kernel hacking" do
-    @model.should_not 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_should_behave_like "a good fit for kernel hacking"
-
-  it_should_behave_like "a good fit for game engine core"
-
-  it_should_behave_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_should_behave_like "a poor candidate for kernel hacking"
-
-  it_should_behave_like "a good fit for game engine core"
-
-  it_should_behave_like "a poor candidate for DSLs"
-
-  it "is not approved by Linus" do
-    @model.valid?(:hacking_on_the_kernel)
-    @model.errors.on(:ensure_approved_by_linus_himself).should_not be_empty
-  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_should_behave_like "a good fit for DSLs"
-
-  it_should_behave_like "a poor candidate for kernel hacking"
-
-  it_should_behave_like "a poor candidate for game engine core"
-
-  it "has a (more or less) meaningful error message" do
-    @model.valid?(:doing_system_programming)
-    @model.errors.on(:ensure_appropriate_for_system_programming).should == [ '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_should_behave_like "a good fit for DSLs"
-
-  it_should_behave_like "a poor candidate for kernel hacking"
-
-  it_should_behave_like "a poor candidate for game engine core"
-
-  it "has a (more or less) meaningful error message" do
-    @model.valid?(:doing_system_programming)
-    @model.errors.on(:ensure_appropriate_for_system_programming).should == [ '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_should_behave_like "a good fit for DSLs"
-
-  it_should_behave_like "a poor candidate for kernel hacking"
-
-  it_should_behave_like "a poor candidate for game engine core"
-
-  it "has a (more or less) meaningful error message" do
-    @model.valid?(:doing_system_programming)
-    @model.errors.on(:ensure_appropriate_for_system_programming).should == [ '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_should_behave_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_should_behave_like "invalid model"
-
-    it "uses custom error message for property starts_at" do
-      @model.errors.on(:starts_at).should == [ 'Start time cannot be after end time' ]
-    end
-  end
-end