sbf-dm-validations 1.3.0.beta

data/spec/fixtures/page.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validation
+    module Fixtures
+
+      # see http://datamapper.lighthouseapp.com/projects/20609/tickets/671
+      class Page
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,   Serial, :key      => true
+        property :body, Text,   :required => true
+
+        #
+        # Validations
+        #
+
+        # duplicates inferred validation for body (caused by
+        # :required => true)
+        validates_presence_of :body
+      end
+    end # Fixtures
+  end # Validations
+end # DataMapper

data/spec/fixtures/phone_number.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validation
+    module Fixtures
+      class PhoneNumber
+        #
+        # Behaviors
+        #
+
+        include ::DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,             Serial
+        property :type_of_number, String, :auto_validation => false
+
+        #
+        # Validations
+        #
+
+        validates_within :type_of_number, :set => %w(home work cell), :message => "Should be one of: home, cell or work"
+      end # PhoneNumber
+    end # Fixtures
+  end # Validations
+end # DataMapper

data/spec/fixtures/pirogue.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validation
+    module Fixtures
+      class Pirogue
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,       Serial
+        property :salesman, String, :default => 'Layfayette'
+
+        #
+        # Validations
+        #
+
+        validates_absence_of :salesman, :on => :sale
+      end
+    end
+  end
+end

data/spec/fixtures/programming_language.rb

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validation
+    module Fixtures
+      # If you think that this particular fixture class
+      # and assumptions made below are full of bullshit
+      # and author is a moron, you are 100% right. I am,
+      # but it's me who rewrites poor dm-validations
+      # spec suite this time, so unless someone smart
+      # steps up to do it, we have to roll on with
+      # this crappy example of method validation. — MK
+      class ProgrammingLanguage
+        #
+        # Behaviors
+        #
+
+        include ::DataMapper::Validations
+
+        #
+        # Attributes
+        #
+
+        attr_accessor :name, :allows_system_calls, :allows_manual_memory_management, :allows_optional_parentheses,
+          :allows_operator_overload, :approved_by_linus, :compiler_excels_at_utilizing_cpu_cache,
+          :is_very_high_level, :does_not_require_explicit_return_keyword, :standard_library_support_parallel_programming_out_of_the_box
+
+        #
+        # Validations
+        #
+
+        validates_with_method :ensure_appropriate_for_system_programming,  :when => [:doing_system_programming, :hacking_on_the_kernel, :implementing_a_game_engine]
+        validates_with_method :ensure_appropriate_for_dsls,                :when => [:implementing_a_dsl]
+        validates_with_method :ensure_appropriate_for_cpu_intensive_tasks, :when => [:implementing_a_game_engine_core]
+        validates_with_method :ensure_approved_by_linus_himself,           :when => [:hacking_on_the_kernel], :violation_type => :unapproved_by_linus
+
+        #
+        # API
+        #
+
+        def initialize(args = {})
+          args.each do |key, value|
+            self.send("#{key}=", value)
+          end
+        end
+
+        def ensure_appropriate_for_system_programming
+          if allows_manual_memory_management && allows_system_calls
+            true
+          else
+            [false, "try something that is closer to the metal"]
+          end
+        end
+
+        def ensure_appropriate_for_dsls
+           if allows_optional_parentheses && allows_operator_overload && is_very_high_level && does_not_require_explicit_return_keyword
+            true
+          else
+            [false, "may not be so good for domain specific languages"]
+          end
+        end
+
+        def ensure_appropriate_for_cpu_intensive_tasks
+          if compiler_excels_at_utilizing_cpu_cache && allows_manual_memory_management
+            true
+          else
+            [false, "may not be so good for CPU intensive tasks"]
+          end
+        end
+
+        def ensure_approved_by_linus_himself
+          if name.downcase == "c++"
+            [false, "Quite frankly, even if the choice of C were to do *nothing*
+              but keep the C++ programmers out, that in itself would be
+              a huge reason to use C."]
+          else
+            true
+          end
+        end
+      end # ProgrammingLanguage
+    end # Fixtures
+  end # Validations
+end # DataMapper

data/spec/fixtures/reservation.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validation
+    module Fixtures
+      class Reservation
+        #
+        # Behaviors
+        #
+
+        include ::DataMapper::Resource
+
+        #
+        # Attributes
+        #
+
+        attr_accessor :person_name_confirmation, :seats_confirmation
+
+        #
+        # Properties
+        #
+
+        property :id,              Serial
+        property :person_name,     String,  :auto_validation => false
+        property :number_of_seats, Integer, :auto_validation => false
+
+        #
+        # Validations
+        #
+
+        validates_confirmation_of :person_name,     :allow_nil => false, :allow_blank => false
+        validates_confirmation_of :number_of_seats, :confirm => :seats_confirmation, :message => Proc.new { |resource, property|
+          '%s requires confirmation for %s' % [DataMapper::Inflector.demodulize(resource.model.name), property.name]
+        }
+      end # Reservation
+    end # Fixtures
+  end # Validations
+end # DataMapper

data/spec/fixtures/scm_operation.rb

@@ -0,0 +1,56 @@
+#
+# SCMs
+#
+# This example may look stupid (I am sure it is),
+# but it is way better than foobars and easier to read/add cases
+# compared to gardening examples because every software engineer has idea
+# about SCMs and not every software engineer does gardening often.
+#
+
+class ScmOperation
+  include DataMapper::Resource
+
+  #
+  # Property
+  #
+
+  property :id,                 Serial
+
+  # operation name
+  property :name,               String,  :auto_validation => false
+
+  property :committer_name,     String,  :auto_validation => false, :default => "Just another Ruby hacker"
+  property :author_name,        String,  :auto_validation => false, :default => "Just another Ruby hacker"
+  property :network_connection, Boolean, :auto_validation => false
+  property :message,            Text,    :auto_validation => false
+  property :clean_working_copy, Boolean, :auto_validation => false
+
+  #
+  # Validations
+  #
+
+  validates_presence_of :name
+end
+
+class SubversionOperation < ScmOperation
+  #
+  # Validations
+  #
+
+  validates_presence_of :network_connection, :when => [:committing, :log_viewing]
+end
+
+class GitOperation < ScmOperation
+  #
+  # Validations
+  #
+
+  validates_presence_of :author_name, :committer_name, :when => :committing
+
+  validates_presence_of :message,            :when => :committing
+  validates_presence_of :network_connection, :when => [:pushing, :pulling], :message => {
+    :pushing => "though git is advanced, it cannot push without network connectivity",
+    :pulling => "you must have network connectivity to pull from others"
+  }
+  validates_presence_of :clean_working_copy, :when => :pulling
+end

data/spec/fixtures/sms_message.rb

@@ -0,0 +1,22 @@
+module DataMapper
+  module Validation
+    module Fixtures
+
+      class SmsMessage
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,   Serial
+        property :body, Text, :length => (1..500)
+      end
+
+    end
+  end
+end

data/spec/fixtures/udp_packet.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validation
+    module Fixtures
+
+      class UDPPacket
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,          Serial
+
+        property :source_port,      Integer, :auto_validation => false
+        property :destination_port, Integer, :auto_validation => false
+
+        property :length,           Integer, :auto_validation => false
+        property :checksum,         String,  :auto_validation => false
+        # consider that there are multiple algorithms
+        # available to the app, and it is allowed
+        # to be chosed
+        #
+        # yes, to some degree, this is a made up
+        # property ;)
+        property :checksum_algorithm, String, :auto_validation => false
+        property :data,               Text,   :auto_validation => false
+
+        #
+        # Volatile attributes
+        #
+
+        attr_accessor :underlying_ip_version
+
+        #
+        # Validations
+        #
+
+        validates_presence_of :checksum_algorithm, :checksum, :if => Proc.new { |packet| packet.underlying_ip_version == 6 }, :message => "Checksum is mandatory when used with IPv6"
+      end
+
+    end # Fixtures
+  end # Validations
+end # DataMapper

data/spec/integration/absent_field_validator/absent_field_validator_spec.rb

@@ -0,0 +1,90 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'DataMapper::Validations::Fixtures::Kayak' do
+  before :all do
+    DataMapper::Validations::Fixtures::Kayak.auto_migrate!
+
+    @kayak = DataMapper::Validations::Fixtures::Kayak.new
+    expect(@kayak).to be_valid_for_sale
+  end
+
+  describe "with salesman being non blank" do
+    before :all do
+      @kayak.salesman = 'Joe'
+    end
+
+    it "is invalid" do
+      expect(@kayak).not_to be_valid_for_sale
+    end
+
+    it "has meaningful error message" do
+      expect(@kayak.errors.on(:salesman)).to eq [ 'Salesman must be absent' ]
+    end
+  end
+
+
+  describe "with salesman being nil" do
+    before :all do
+      @kayak.salesman = nil
+    end
+
+    it "is valid" do
+      expect(@kayak).to be_valid_for_sale
+    end
+
+    it "has no error messages" do
+      expect(@kayak.errors.on(:salesman)).to be_nil
+    end
+  end
+
+
+  describe "with salesman being an empty string" do
+    before :all do
+      @kayak.salesman = ''
+    end
+
+    it "is valid" do
+      expect(@kayak).to be_valid_for_sale
+    end
+
+    it "has no error messages" do
+      expect(@kayak.errors.on(:salesman)).to be_nil
+    end
+  end
+
+
+  describe "with salesman being a string of white spaces" do
+    before :all do
+      @kayak.salesman = '    '
+    end
+
+    it "is valid" do
+      expect(@kayak).to be_valid_for_sale
+    end
+
+    it "has no error messages" do
+      expect(@kayak.errors.on(:salesman)).to be_nil
+    end
+  end
+end
+
+
+describe 'DataMapper::Validations::Fixtures::Pirogue' do
+  before :all do
+    DataMapper::Validations::Fixtures::Pirogue.auto_migrate!
+
+    @kayak = DataMapper::Validations::Fixtures::Pirogue.new
+    expect(@kayak).not_to be_valid_for_sale
+  end
+
+  describe "by default" do
+    it "is invalid" do
+      expect(@kayak).not_to be_valid_for_sale
+    end
+
+    it "has meaningful error message" do
+      expect(@kayak.errors.on(:salesman)).to eq [ 'Salesman must be absent' ]
+    end
+  end
+end

data/spec/integration/absent_field_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/acceptance_validator/acceptance_validator_spec.rb

@@ -0,0 +1,196 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'DataMapper::Validations::Fixtures::BetaTesterAccount' do
+  before :all do
+    DataMapper::Validations::Fixtures::BetaTesterAccount.auto_migrate!
+  end
+
+  before do
+    @model = DataMapper::Validations::Fixtures::BetaTesterAccount.new(:user_agreement    => true,
+                                                                   :newsletter_signup => nil,
+                                                                   :privacy_agreement => "accept")
+    expect(@model).to be_valid
+  end
+
+  describe "with a missing newsletter signup field" do
+    before do
+      @model.newsletter_signup = nil
+    end
+
+    it "is perfectly valid" do
+      expect(@model).to be_valid
+    end
+  end
+
+  describe "with a blank newsletter signup field" do
+    before do
+      @model.newsletter_signup = ""
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with a blank user agreement field" do
+    before do
+      @model.user_agreement = ""
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with a nil user agreement field" do
+    before do
+      @model.user_agreement = nil
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with user agreement field having value of 1 (as integer)" do
+    before do
+      @model.user_agreement = 1
+    end
+
+    it "is valid" do
+      expect(@model).to be_valid
+    end
+  end
+
+  describe "with user agreement field having value of 1 (as a string)" do
+    before do
+      @model.user_agreement = "1"
+    end
+
+    it "is valid" do
+      expect(@model).to be_valid
+    end
+  end
+
+  describe "with user agreement field having value of 'true' (as a string)" do
+    before do
+      @model.user_agreement = 'true'
+    end
+
+    it "is valid" do
+      expect(@model).to be_valid
+    end
+  end
+
+  describe "with user agreement field having value of true (TrueClass instance)" do
+    before do
+      @model.user_agreement = true
+    end
+
+    it "is valid" do
+      expect(@model).to be_valid
+    end
+  end
+
+  describe "with user agreement field having value of 't' (The Lisp Way)" do
+    before do
+      @model.user_agreement = 't'
+    end
+
+    it "is valid" do
+      expect(@model).to be_valid
+    end
+  end
+
+  describe "with user agreement field having value of 'f'" do
+    before do
+      @model.user_agreement = 'f'
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with user agreement field having value of false" do
+    before do
+      @model.user_agreement = false
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with privacy agreement field having value of 1" do
+    before do
+      @model.privacy_agreement = 1
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with privacy agreement field having value of true" do
+    before do
+      @model.privacy_agreement = true
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with privacy agreement field having value of '1'" do
+    before do
+      @model.privacy_agreement = '1'
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with privacy agreement field having value of 't'" do
+    before do
+      @model.privacy_agreement = 't'
+    end
+
+    it "is NOT valid" do
+      expect(@model).not_to be_valid
+    end
+  end
+
+  describe "with privacy agreement field having value of 'accept'" do
+    before do
+      @model.privacy_agreement = 'accept'
+    end
+
+    it "is valid" do
+      expect(@model).to be_valid
+    end
+  end
+
+  describe "with privacy agreement field having value of 'agreed'" do
+    before do
+      @model.privacy_agreement = 'agreed'
+    end
+
+    it "is valid" do
+      expect(@model).to be_valid
+    end
+  end
+
+  describe "with privacy agreement field having value of 'ah, greed'" do
+    before do
+      @model.privacy_agreement = 'ah, greed'
+    end
+
+    it "is NOT valid" do
+      # greed is invalid? can't be
+      expect(@model).not_to be_valid
+    end
+  end
+end

data/spec/integration/acceptance_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/automatic_validation/custom_messages_for_inferred_validation_spec.rb

@@ -0,0 +1,57 @@
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'Inferred validations' do
+  it "allow overriding a single error message" do
+    custom_boat = Class.new do
+      include DataMapper::Resource
+
+      def self.name
+        'Boat'
+      end
+
+      property :id,   DataMapper::Property::Serial
+      property :name, String, :required => true, :message => "This boat must have name"
+    end
+    boat = custom_boat.new
+    expect(boat).not_to be_valid
+    expect(boat.errors.on(:name)).to eq [ 'This boat must have name' ]
+  end
+
+  it "has correct error messages" do
+    custom_boat = Class.new do
+      include DataMapper::Resource
+
+      def self.name
+        'Boat'
+      end
+
+      property :id,   DataMapper::Property::Serial
+      property :name, String, :required => true, :length => 5..20, :format => /^[a-z]+$/,
+               :messages => {
+                 :presence => "This boat must have name",
+                 :length => "Name must have at least 4 and at most 20 chars",
+                 :format => "Please use only small letters"
+               }
+    end
+
+    boat = custom_boat.new
+    expect(boat).not_to be_valid
+    expect(boat.errors.on(:name)).to eq [ 'This boat must have name' ]
+
+    boat.name = "%%"
+    expect(boat).not_to be_valid
+    expect(boat.errors.on(:name)).to eq [
+      'Name must have at least 4 and at most 20 chars',
+      'Please use only small letters',
+    ]
+
+    boat.name = "%%asd"
+    expect(boat).not_to be_valid
+    expect(boat.errors.on(:name)).to eq [ 'Please use only small letters' ]
+
+    boat.name = "superboat"
+    expect(boat).to be_valid
+    expect(boat.errors.on(:name)).to be_nil
+  end
+end