knight 0.0.1 → 0.0.2

data/spec/unit/knight/rule/exact_length/matches_predicate_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::ExactLength, '#matches?' do
+  subject { rule.matches?(value) }
+
+  let(:rule) { described_class.new(:foo, 3) }
+  let(:value) { 'abc' }
+
+  it { should be_true }
+
+  %w(ab abcdef).each do |value|
+    context "with value: #{value.inspect}" do
+      let(:value) { value }
+      it { should be_false }
+    end
+  end
+end

data/spec/unit/knight/rule/exact_length/to_hash_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::ExactLength, '#to_hash' do
+  subject { object.to_hash }
+
+  let(:object) { described_class.new(:foo, 3) }
+
+  it { should be_frozen }
+  it { should eql({ attribute: :foo, length: 3 }) }
+end

data/spec/unit/knight/rule/format/class_methods/new_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::Format, '.new' do
+  let(:attribute) { :foo }
+  let(:regexp)    { /abc/ }
+  let(:options)   { { message: 'message' } }
+
+  context 'with options' do
+    subject { described_class.new(attribute, regexp, options) }
+
+    it { should be_instance_of(described_class) }
+    its(:attribute_name) { should eql(attribute) }
+    its(:regexp) { should eql(regexp) }
+    its(:options) { should eql(options) }
+  end
+
+  context 'with no options' do
+    subject { described_class.new(attribute, regexp) }
+
+    it { should be_instance_of(described_class) }
+    its(:options) { should be_empty }
+    its(:message) { should eql('%{attribute} has an invalid format') }
+  end
+end

data/spec/unit/knight/rule/format/matches_predicate_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::Format, '#matches?' do
+  subject { rule.matches?(value) }
+
+  let(:rule) { described_class.new(:foo, /abc/) }
+
+  %w(
+    abcxxx
+    xxxabc
+    xxxabcxxx
+  ).each do |value|
+    context "with value: #{value.inspect}" do
+      let(:value) { value }
+      it { should be_true }
+    end
+  end
+
+  %w(
+    bcxxx
+    xxxac
+    xxxabxxx
+  ).each do |value|
+    context "with value: #{value.inspect}" do
+      let(:value) { value }
+      it { should be_false }
+    end
+  end
+end

data/spec/unit/knight/rule/format/to_hash_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::Format, '#to_hash' do
+  subject { object.to_hash }
+
+  let(:object) { described_class.new(:foo, /abc/) }
+
+  it { should be_frozen }
+  it { should eql({ attribute: :foo, format: /abc/ }) }
+end

data/spec/unit/knight/rule/inclusion/class_methods/new_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::Inclusion, '.new' do
+  subject { described_class.new(attribute, within) }
+
+  let(:attribute) { :foo }
+  let(:within)    { 3..5 }
+  let(:options)   { { message: 'message' } }
+
+  context 'with options' do
+    subject { described_class.new(attribute, within, options) }
+
+    it { should be_instance_of(described_class) }
+    its(:attribute_name) { should eql(attribute) }
+    its(:within) { should eql(within) }
+    its(:options) { should eql(options) }
+  end
+
+  context 'with no options' do
+    subject { described_class.new(attribute, within) }
+
+    it { should be_instance_of(described_class) }
+    its(:options) { should be_empty }
+    its(:message) { should eql('%{attribute} is not included in the list') }
+  end
+end

data/spec/unit/knight/rule/inclusion/matches_predicate_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::Inclusion, '#matches?' do
+  subject { rule.matches?(value) }
+
+  let(:rule) { described_class.new(:foo, within) }
+
+  context 'Array' do
+    let(:within) { [1, 2, 3] }
+
+    describe 'matched' do
+      let(:value) { 5 }
+      it { should be_false }
+    end
+
+    describe 'not matched' do
+      let(:value) { 3 }
+      it { should be_true }
+    end
+  end
+
+  context 'Range' do
+    let(:within) { 1..3 }
+
+    describe 'matched' do
+      let(:value) { 5 }
+      it { should be_false }
+    end
+
+    describe 'not matched' do
+      let(:value) { 2 }
+      it { should be_true }
+    end
+  end
+
+  context 'cover? vs include?' do
+    let(:within) { double('within') }
+    let(:value) { 5 }
+
+    it 'send cover?' do
+      within.stub(:kind_of?).and_return(true)
+      within.should_receive(:cover?).with(value).and_return(false)
+      should be_false
+    end
+  end
+end

data/spec/unit/knight/rule/inclusion/to_hash_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::Inclusion, '#to_hash' do
+  subject { object.to_hash }
+
+  let(:object) { described_class.new(:foo, [2, 4]) }
+
+  it { should be_frozen }
+  it { should eql({ attribute: :foo, within: [2, 4] }) }
+end

data/spec/unit/knight/rule/maximum_length/class_methods/new_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::MaximumLength, '.new' do
+
+  let(:attribute) { :foo }
+  let(:maximum)   { 3 }
+  let(:options)   { { message: 'message' } }
+
+  context 'with options' do
+    subject { described_class.new(attribute, maximum, options) }
+
+    it { should be_instance_of(described_class) }
+    its(:attribute_name) { should eql(attribute) }
+    its(:maximum) { should eql(maximum) }
+    its(:options) { should eql(options) }
+  end
+
+  context 'with no options' do
+    subject { described_class.new(attribute, maximum) }
+
+    it { should be_instance_of(described_class) }
+    its(:options) { should be_empty }
+    its(:message) { should eql('%{attribute} is too long') }
+  end
+end

data/spec/unit/knight/rule/maximum_length/matches_predicate_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::MaximumLength, '#matches?' do
+  subject { rule.matches?(value) }
+
+  let(:rule) { described_class.new(:foo, 3) }
+
+  %w(ab abc).each do |value|
+    context "with value: #{value.inspect}" do
+      let(:value) { value }
+      it { should be_true }
+    end
+  end
+
+  context 'longer' do
+    let(:value) { 'abcd' }
+    it { should be_false }
+  end
+end

data/spec/unit/knight/rule/maximum_length/to_hash_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::MaximumLength, '#to_hash' do
+  subject { object.to_hash }
+
+  let(:object) { described_class.new(:foo, 20) }
+
+  it { should be_frozen }
+  it { should eql({ attribute: :foo, maximum: 20 }) }
+end

data/spec/unit/knight/rule/minimum_length/class_methods/new_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::MinimumLength, '.new' do
+
+  let(:attribute) { :foo }
+  let(:minimum)   { 3 }
+  let(:options)   { { message: 'message' } }
+
+  context 'with options' do
+    subject { described_class.new(attribute, minimum, options) }
+
+    it { should be_instance_of(described_class) }
+    its(:attribute_name) { should eql(attribute) }
+    its(:minimum) { should eql(minimum) }
+    its(:options) { should eql(options) }
+  end
+
+  context 'with no options' do
+    subject { described_class.new(attribute, minimum) }
+
+    it { should be_instance_of(described_class) }
+    its(:options) { should be_empty }
+    its(:message) { should eql('%{attribute} is too short') }
+  end
+end

data/spec/unit/knight/rule/minimum_length/matches_predicate_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::MinimumLength, '#matches?' do
+  subject { rule.matches?(value) }
+
+  let(:rule) { described_class.new(:foo, 3) }
+
+  %w(abc abcd).each do |value|
+    context "with value: #{value.inspect}" do
+      let(:value) { value }
+      it { should be_true }
+    end
+  end
+
+  context 'shorter' do
+    let(:value) { 'ab' }
+    it { should be_false }
+  end
+end

data/spec/unit/knight/rule/minimum_length/to_hash_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::MinimumLength, '#to_hash' do
+  subject { object.to_hash }
+
+  let(:object) { described_class.new(:foo, 4) }
+
+  it { should be_frozen }
+  it { should eql({ attribute: :foo, minimum: 4 }) }
+end

data/spec/unit/knight/rule/presence/matches_predicate_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::Presence, '#matches?' do
+  subject { rule.matches?(value) }
+
+  let(:rule) { described_class.new(:foo) }
+
+  [
+    nil,
+    '',
+    {},
+    [],
+    Set.new,
+  ].each do |value|
+    context "with value: #{value.inspect}" do
+      let(:value) { value }
+      it { should be_false }
+    end
+  end
+
+  context 'when the value is a string' do
+    let(:value) { 'bar' }
+    it { should be_true }
+  end
+end

data/spec/unit/knight/rule/range_length/class_methods/new_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::RangeLength, '.new' do
+
+  let(:attribute) { :foo }
+  let(:range)     { 3..4 }
+  let(:options)   { { message: 'message' } }
+
+  context 'with options' do
+    subject { described_class.new(attribute, range, options) }
+
+    it { should be_instance_of(described_class) }
+    its(:attribute_name) { should eql(attribute) }
+    its(:range) { should eql(range) }
+    its(:options) { should eql(options) }
+  end
+
+  context 'with no options' do
+    subject { described_class.new(attribute, range) }
+
+    it { should be_instance_of(described_class) }
+    its(:options) { should be_empty }
+    its(:message) { should eql('%{attribute} has an invalid length') }
+  end
+end

data/spec/unit/knight/rule/range_length/matches_predicate_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::RangeLength, '#matches?' do
+  subject { rule.matches?(value) }
+
+  let(:rule) { described_class.new(:foo, 3..5) }
+  let(:value) { 'abc' }
+
+  it { should be_true }
+
+  %w(ab abcdef).each do |value|
+    context "with value: #{value.inspect}" do
+      let(:value) { value }
+      it { should be_false }
+    end
+  end
+end

data/spec/unit/knight/rule/range_length/to_hash_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::RangeLength, '#to_hash' do
+  subject { object.to_hash }
+
+  let(:object) { described_class.new(:foo, (4...6)) }
+
+  it { should be_frozen }
+  it { should eql({ attribute: :foo, minimum: 4, maximum: 5 }) }
+end

data/spec/unit/knight/rule/to_hash_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule, '#to_hash' do
+  subject { object.to_hash }
+
+  let(:described_class) { Class.new(Rule) }
+  let(:object) { described_class.new(:foo) }
+
+  it { should be_frozen }
+  it { should eql({ attribute: :foo }) }
+end

data/spec/unit/knight/validator/add_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Validator, '#add' do
+  subject { validator.rules(context) }
+
+  let(:validator) { described_class.new(rule1) }
+  let(:rule1) { Rule::ExactLength.new(:username, 10) }
+  let(:rule2) { Rule::Presence.new(:username) }
+
+  before do
+    validator.add(rule2, :register)
+    validator.add(rule2)
+    validator.add(nil)
+  end
+
+  context 'default_context' do
+    let(:context) { :default }
+    specify { expect(subject.size).to eql(2) }
+    specify { expect(subject).to eql(Set.new([rule1, rule2])) }
+  end
+
+  context 'register' do
+    let(:context) { :register }
+    specify { expect(subject.size).to eql(1) }
+    specify { expect(subject).to eql(Set.new([rule2])) }
+  end
+end