sbf-dm-validations 1.3.0.beta

data/spec/public/resource_spec.rb

@@ -0,0 +1,113 @@
+require_relative '../spec_helper'
+
+describe 'DataMapper::Resource' do
+  before :all do
+    DataMapper::Validations::Fixtures::Barcode.destroy!
+
+    @resource = DataMapper::Validations::Fixtures::Barcode.new
+  end
+
+  describe '#update' do
+    describe 'when provided valid attributes' do
+      before :all do
+        @response = @resource.update(:code => 'a' * 10)
+      end
+
+      it 'returns true' do
+        expect(@response).to be(true)
+      end
+    end
+
+    describe 'when provided invalid attributes' do
+      before :all do
+        @response = @resource.update(:code => 'a' * 11)
+      end
+
+      it 'returns false' do
+        expect(@response).to be(false)
+      end
+
+      it 'sets errors' do
+        expect(@resource.errors.to_a).to eq [ [ 'Code must be at most 10 characters long' ] ]
+      end
+    end
+
+    describe 'when provided invalid attributes and a context' do
+      before :all do
+        DataMapper::Validations::Fixtures::Organisation.destroy!
+        DataMapper::Validations::Fixtures::Department.destroy!
+        DataMapper::Validations::Fixtures::User.destroy!
+
+        organization = DataMapper::Validations::Fixtures::Organisation.create(:name => 'Org 101', :domain => '101')
+        dept         = DataMapper::Validations::Fixtures::Department.create(:name => 'accounting')
+
+        attributes = {
+          :organisation => organization,
+          :user_name    => 'guy',
+          :department   => dept,
+        }
+
+        # create a record that will be a dupe when User#update is executed below
+        expect(DataMapper::Validations::Fixtures::User.create(attributes)).to be_saved
+
+        @resource = DataMapper::Validations::Fixtures::User.create(attributes.merge(:user_name => 'other'))
+
+        @response = @resource.update(attributes, :signing_up_for_department_account)
+      end
+
+      it 'returns false' do
+        expect(@response).to be(false)
+      end
+
+      it 'sets errors' do
+        expect(@resource.errors.to_a).to eq [ [ 'User name is already taken' ] ]
+      end
+    end
+  end
+
+  describe '#save' do
+    before :all do
+      @resource.code = 'a' * 10
+      @resource.save
+    end
+
+    describe 'on a new, non-dirty resource' do
+      it 'calls valid? once' do
+        blank = DataMapper::Validations::Fixtures::Barcode.new
+        blank.save
+        expect(blank.valid_hook_call_count).to eq 1
+      end
+    end
+
+    describe 'on a new, dirty resource' do
+      it 'calls valid? once' do
+        expect(@resource.valid_hook_call_count).to eq 1
+      end
+    end
+
+    describe 'on a saved, non-dirty resource' do
+      before :all do
+        # reload the resource
+        @resource = @resource.model.get(*@resource.key)
+        @resource.save
+      end
+
+      it 'does not call valid?' do
+        expect(@resource.valid_hook_call_count.to_i).to eq 0
+      end
+    end
+
+    describe 'on a saved, dirty resource' do
+      before :all do
+        # reload the resource
+        @resource = @resource.model.get(*@resource.key)
+        @resource.code = 'b' * 10
+        @resource.save
+      end
+
+      it 'calls valid? once' do
+        expect(@resource.valid_hook_call_count).to eq 1
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'dm-core/spec/setup'
+require 'dm-core/spec/lib/adapter_helpers'
+
+require 'dm-validations'
+require 'dm-types'
+require 'dm-migrations'
+
+class Hash
+  def except(*keys)
+    hash = dup
+    keys.each { |key| hash.delete(key) }
+    hash
+  end
+end
+
+Dir["#{File.realpath(File.dirname(__FILE__))}/fixtures/**/*.rb"].sort.each { |file| require file }
+Dir["#{File.realpath(File.dirname(__FILE__))}/integration/shared/**/*.rb"].sort.each { |file| require file }
+
+DataMapper::Spec.setup
+DataMapper.finalize
+
+RSpec.configure do |config|
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+
+  config.before :suite do
+    DataMapper.finalize.auto_migrate!
+  end
+end

data/spec/unit/contextual_validators/emptiness_spec.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'DataMapper::Validations::ContextualRuleSet' do
+  before :all do
+    @validators = DataMapper::Validations::ContextualRuleSet.new
+  end
+
+  describe "initially" do
+    it "is empty" do
+      expect(@validators).to be_empty
+    end
+  end
+
+
+  describe "after first reference to context" do
+    before :all do
+      @validators.context(:create)
+    end
+
+    it "initializes list of validators for referred context" do
+      expect(@validators.context(:create)).to be_empty
+    end
+  end
+
+
+  describe "after a context being added" do
+    before :all do
+      @validators.context(:default) << DataMapper::Validations::Rule::Presence.new(:toc, :when => [:publishing])
+    end
+
+    it "is no longer empty" do
+      expect(@validators).not_to be_empty
+    end
+  end
+
+
+  describe "when cleared" do
+    before :all do
+      @validators.context(:default) << DataMapper::Validations::Rule::Presence.new(:toc, :when => [:publishing])
+      expect(@validators).not_to be_empty
+      @validators.clear
+    end
+
+    it "becomes empty again" do
+      expect(@validators).to be_empty
+    end
+  end
+end

data/spec/unit/contextual_validators/execution_spec.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+require_relative '../../spec_helper'
+require_relative 'spec_helper'
+
+describe 'DataMapper::Validations::ContextualRuleSet' do
+  before :all do
+    @validators = DataMapper::Validations::ContextualRuleSet.new
+  end
+
+  describe "#execute(name, target)" do
+    before do
+      @validator_one = DataMapper::Validations::Rule::Presence.new(:name)
+      @validator_two = DataMapper::Validations::Rule::Within.new(:operating_system, :set => ["Mac OS X", "Linux", "FreeBSD", "Solaris"])
+
+      @validators.context(:default) << @validator_one << @validator_two
+    end
+
+
+    describe "when target satisfies all validators" do
+      before do
+        @target = DataMapper::Validations::Fixtures::PieceOfSoftware.new(:name => 'gcc', :operating_system => "Mac OS X")
+        expect(@validator_one.call(@target)).to be(true)
+        expect(@validator_two.call(@target)).to be(true)
+
+        @result = @validators.execute(:default, @target)
+      end
+
+      it "returns true" do
+        expect(@result).to be(true)
+      end
+    end
+
+
+    describe "when target does not satisfy all validators" do
+      before do
+        @target = DataMapper::Validations::Fixtures::PieceOfSoftware.new(:name => 'Skitch', :operating_system => "Haiku")
+        expect(@validator_one.call(@target)).to be(true)
+        expect(@validator_two.call(@target)).to be(false)
+
+        @result = @validators.execute(:default, @target)
+      end
+
+      it "returns false" do
+        expect(@result).to be(false)
+      end
+    end
+  end
+end

data/spec/unit/contextual_validators/spec_helper.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validation
+    module Fixtures
+
+      class PieceOfSoftware
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Validations
+
+        #
+        # Attributes
+        #
+
+        attr_accessor :name, :operating_system
+
+        #
+        # Validations
+        #
+
+        #
+        # API
+        #
+
+        def initialize(attributes = {})
+          attributes.each do |key, value|
+            self.send("#{key}=", value)
+          end
+        end
+      end
+
+    end # Fixtures
+  end # Validations
+end # DataMapper

data/spec/unit/generic_validator/equality_operator_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../../spec_helper'
+
+describe 'DataMapper::Validations::Rule' do
+  describe "when types and fields are equal" do
+    it "returns true" do
+      DataMapper::Validations::Rule::Presence.new(:name).
+        is_expected.to eq DataMapper::Validations::Rule::Presence.new(:name)
+    end
+  end
+
+
+  describe "when types differ" do
+    it "returns false" do
+      DataMapper::Validations::Rule::Presence.new(:name).
+        is_expected.not_to eq DataMapper::Validations::Rule::Uniqueness.new(:name)
+    end
+  end
+
+
+  describe "when property names differ" do
+    it "returns false" do
+      DataMapper::Validations::Rule::Presence.new(:first_name).
+        is_expected.not_to eq DataMapper::Validations::Rule::Presence.new(:last_name)
+    end
+  end
+end

data/spec/unit/generic_validator/optional_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../../spec_helper'
+
+describe 'DataMapper::Validations::Rule::Generic', '#optional?' do
+  def validator(opts = {})
+    DataMapper::Validations::Rule::Length.new(:name, opts)
+  end
+
+  describe 'allowing blank' do
+    subject do
+      validator(
+        :allow_blank => true
+      )
+    end
+
+    it { expect(subject.optional?("" )).to be }
+    it { expect(subject.optional?(nil)).to be }
+  end
+
+  describe 'allowing nil' do
+    subject do
+      validator(
+        :allow_nil => true
+      )
+    end
+
+    it { expect(subject.optional?("" )).not_to be }
+    it { expect(subject.optional?(nil)).to be }
+  end
+
+  describe 'allowing blank, but now allowing nil' do
+    subject do
+      validator(
+        :allow_blank => true,
+        :allow_nil   => false
+      )
+    end
+
+    it { expect(subject.optional?("" )).to be }
+    it { expect(subject.optional?(nil)).not_to be }
+  end
+
+  describe 'allowing nil, but now allowing blank' do
+    subject do
+      validator(
+        :allow_blank => false,
+        :allow_nil   => true
+      )
+    end
+
+    it { expect(subject.optional?("" )).not_to be }
+    it { expect(subject.optional?(nil)).to be }
+  end
+
+end

data/spec/unit/validators/within_validator_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../../spec_helper'
+
+describe 'DataMapper::Validations::Rule::Within' do
+  it 'allows Sets to be passed to the :set option' do
+    types = Set.new(%w(home mobile business))
+
+    @model = Class.new do
+      include DataMapper::Resource
+
+      def self.name
+        'WithinValidatorClass'
+      end
+
+      property :id,   DataMapper::Property::Serial
+      property :name, String, :auto_validation => false
+    end.new
+
+    validator = DataMapper::Validations::Rule::Within.new(:name, :set => types)
+    validator.call(@model)
+
+    expect(@model.errors).not_to be_empty
+  end
+end

data/spec/unit/violation_set/adding_spec.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+require_relative '../../spec_helper'
+
+describe 'DataMapper::Validations::ViolationSet' do
+  before :all do
+    @model = DataMapper::Validations::ViolationSet.new(Object.new)
+  end
+
+  describe "after first error being added" do
+    before :all do
+      @model.add(:property, "can't be valid, no way")
+    end
+
+    it "is no longer empty" do
+      expect(@model).not_to be_empty
+    end
+
+    it "adds error message to list of errors for given property name" do
+      expect(@model.on(:property)).to eq ["can't be valid, no way"]
+    end
+  end
+
+
+  describe "after second error being added" do
+    before :all do
+      @model.add(:property, "can't be valid, no way")
+      @model.add(:property, "something else is wrong")
+    end
+
+    it "is no longer empty" do
+      expect(@model).not_to be_empty
+    end
+
+    it "appends error message to list of errors for given property name" do
+      expect(@model.on(:property)).to eq ["can't be valid, no way", "something else is wrong"]
+    end
+  end
+
+
+  describe "when duplicate error being added" do
+    before :all do
+      @model.add(:property, "can't be valid, no way")
+      @model.add(:property, "can't be valid, no way")
+    end
+
+    it "is no longer empty" do
+      expect(@model).not_to be_empty
+    end
+
+    it "DOES NOT allow duplication" do
+      expect(@model.on(:property)).to eq ["can't be valid, no way"]
+    end
+  end
+end

data/spec/unit/violation_set/emptiness_spec.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+require_relative '../../spec_helper'
+
+describe 'DataMapper::Validations::ViolationSet' do
+  before :all do
+    @model = DataMapper::Validations::ViolationSet.new(Object.new)
+  end
+
+  describe "initially" do
+    it "is empty" do
+      expect(@model).to be_empty
+    end
+  end
+
+  # Not sure if this is worth having at all,
+  # just keeping old spec suite bits in place
+  # if they make no harm — MK
+  describe "after enquiry" do
+    before :all do
+      @model.on(:property)
+    end
+
+    it "is still empty" do
+      expect(@model).to be_empty
+    end
+  end
+
+
+  describe "after errors being added" do
+    before :all do
+      @model.add(:property, "can't be valid, no way")
+    end
+
+    it "is no longer empty" do
+      expect(@model).not_to be_empty
+    end
+  end
+end

data/spec/unit/violation_set/enumerable_spec.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+require_relative '../../spec_helper'
+
+describe 'DataMapper::Validations::ViolationSet' do
+  before :all do
+    @model = DataMapper::Validations::ViolationSet.new(Object.new)
+    @model.add(:ip_address, "must have valid format")
+    @model.add(:full_name, "can't be blank")
+  end
+
+  describe "#each" do
+    it "iterates over properties and yields error message arrays" do
+      params = []
+      @model.each do |param|
+        params << param
+      end
+
+      expect(params).to eq [ [ 'must have valid format' ], [ "can't be blank" ] ]
+    end
+  end
+
+
+  describe "#map" do
+    before :all do
+      @model.add(:ip_address, "must belong to a local subnet")
+    end
+    it "maps error message arrays using provided block" do
+      projection = @model.map { |ary| ary }
+      expect(projection).to eq [ [ 'must have valid format', 'must belong to a local subnet' ], [ "can't be blank" ] ]
+    end
+  end
+end

data/spec/unit/violation_set/reading_spec.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+require_relative '../../spec_helper'
+
+shared_examples 'a validation error reader' do
+  context 'and that property has no associated errors' do
+    it 'returns an empty array' do
+      expect(@errors[@property]).to eq []
+    end
+  end
+  context 'and that property has associated error(s)' do
+    it 'returns a non empty array' do
+      @errors.add(@property.to_sym, 'invalid')
+      expect(@errors[@property]).not_to be_empty
+    end
+  end
+end
+
+describe 'DataMapper::Validations::ViolationSet' do
+  describe '[]' do
+    describe 'when passing the argument as a String' do
+      before(:each) do
+        @errors   = DataMapper::Validations::ViolationSet.new(Object.new)
+        @property = 'name'
+      end
+      it_behaves_like 'a validation error reader'
+    end
+    describe 'when passing the argument as a Symbol' do
+      before(:each) do
+        @errors   = DataMapper::Validations::ViolationSet.new(Object.new)
+        @property = :name
+      end
+      it_behaves_like 'a validation error reader'
+    end
+  end
+end

data/spec/unit/violation_set/respond_to_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../../spec_helper'
+
+describe 'DataMapper::Validations::ViolationSet#respond_to?' do
+
+  subject { DataMapper::Validations::ViolationSet.new(Object.new) }
+
+  it 'looks for the method in self' do
+    expect(subject).to respond_to(:full_messages)
+  end
+
+  it 'delegates lookup to the underlying errors hash' do
+    expect(subject).to respond_to(:size)
+  end
+
+end

data/tasks/spec.rake

@@ -0,0 +1,21 @@
+require 'rspec/core/rake_task'
+
+begin
+  task(:default).clear
+  task(:spec).clear
+
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+
+    require 'simplecov'
+    SimpleCov.start do
+      minimum_coverage 100
+    end
+  end
+rescue LoadError
+  task :spec do
+    abort 'rspec is not available. In order to run spec, you must: gem install rspec'
+  end
+end
+
+task default: :spec

data/tasks/yard.rake

@@ -0,0 +1,9 @@
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end

data/tasks/yardstick.rake

@@ -0,0 +1,19 @@
+begin
+  require 'pathname'
+  require 'yardstick/rake/measurement'
+  require 'yardstick/rake/verify'
+
+  # yardstick_measure task
+  Yardstick::Rake::Measurement.new
+
+  # verify_measurements task
+  Yardstick::Rake::Verify.new do |verify|
+    verify.threshold = 100
+  end
+rescue LoadError
+  %w[ yardstick_measure verify_measurements ].each do |name|
+    task name.to_s do
+      abort "Yardstick is not available. In order to run #{name}, you must: gem install yardstick"
+    end
+  end
+end