attestor 0.0.1

data/spec/tests/policy/not_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+# describe #valid_policy and #invalid_policy builders
+# also describes shared examples for all policies
+require "support/policies"
+
+describe Attestor::Policy::Not do
+
+  subject { described_class.new item }
+
+  describe ".new" do
+
+    let(:item) { valid_policy }
+
+    it_behaves_like "creating a node"
+    it_behaves_like "creating an immutable object"
+
+  end # context
+
+  describe "#validate" do
+
+    context "when a part is invalid" do
+
+      let(:item) { invalid_policy }
+
+      it_behaves_like "passing validation"
+
+    end # context
+
+    context "when a part is valid" do
+
+      let(:item) { valid_policy }
+
+      it_behaves_like "failing validation"
+
+    end # context
+
+  end # describe #validate
+
+end # describe Policy::Base::Not

data/spec/tests/policy/or_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+# describe #valid_policy and #invalid_policy builders
+# also describes shared examples for all policies
+require "support/policies"
+
+describe Attestor::Policy::Or do
+
+  subject { described_class.new items }
+
+  describe ".new" do
+
+    let(:items) { [valid_policy] }
+
+    it_behaves_like "creating a node"
+    it_behaves_like "creating an immutable object"
+
+  end # context
+
+  describe "#validate" do
+
+    context "when valid part exists" do
+
+      let(:items) { [valid_policy, valid_policy, invalid_policy] }
+
+      it_behaves_like "passing validation"
+
+    end # context
+
+    context "when all parts are invalid" do
+
+      let(:items) { 3.times.map { invalid_policy } }
+
+      it_behaves_like "failing validation"
+
+    end # context
+
+  end # describe #validate
+
+end # describe Policy::Base::Not

data/spec/tests/policy/xor_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+# describe #valid_policy and #invalid_policy builders
+# also describes shared examples for all policies
+require "support/policies"
+
+describe Attestor::Policy::Xor do
+
+  subject { described_class.new items }
+
+  describe ".new" do
+
+    let(:items) { [valid_policy] }
+
+    it_behaves_like "creating a node"
+    it_behaves_like "creating an immutable object"
+
+  end # context
+
+  describe "#validate" do
+
+    context "when both valid and invalid parts exist" do
+
+      let(:items) { [valid_policy, valid_policy, invalid_policy] }
+
+      it_behaves_like "passing validation"
+
+    end # context
+
+    context "when all parts are valid" do
+
+      let(:items) { 3.times.map { valid_policy } }
+
+      it_behaves_like "failing validation"
+
+    end # context
+
+    context "when all parts are invalid" do
+
+      let(:items) { 3.times.map { invalid_policy } }
+
+      it_behaves_like "failing validation"
+
+    end # context
+
+  end # describe #validate
+
+end # describe Policy::Base::Not

data/spec/tests/policy_spec.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+describe Attestor::Policy do
+
+  let(:factory)   { Attestor::Policy::Factory }
+  let(:validator) { Attestor::Validations }
+  let(:invalid)   { Attestor::InvalidError.new subject, [] }
+  let(:others)    { 2.times { double } }
+
+  let(:test_class) { Class.new.send(:include, described_class) }
+  before  { Test = test_class }
+  after   { Object.send :remove_const, :Test }
+  subject { test_class.new }
+
+  it "is a factory" do
+    expect(test_class).to be_kind_of factory
+  end
+
+  describe ".new" do
+
+    it "creates a validator" do
+      expect(subject).to be_kind_of validator
+    end
+
+  end # describe .new
+
+  describe "#valid?" do
+
+    context "when #validate method fails" do
+
+      before { allow(subject).to receive(:validate) { fail invalid } }
+
+      it "returns false" do
+        expect(subject.valid?).to eq false
+      end
+
+    end
+
+    context "when #validate method passes" do
+
+      before { allow(subject).to receive(:validate) { nil } }
+
+      it "returns true" do
+        expect(subject.valid?).to eq true
+      end
+
+    end
+
+  end # describe #valid?
+
+  describe "#invalid?" do
+
+    context "when #validate method fails" do
+
+      before { allow(subject).to receive(:validate) { fail invalid } }
+
+      it "returns true" do
+        expect(subject.invalid?).to eq true
+      end
+
+    end
+
+    context "when #validate method passes" do
+
+      before { allow(subject).to receive(:validate) { nil } }
+
+      it "returns false" do
+        expect(subject.invalid?).to eq false
+      end
+
+    end
+
+  end # describe #invalid?
+
+  describe "#and" do
+
+    it "calls .and class factory method with self" do
+      expect(test_class).to receive(:and).with(subject, *others)
+      subject.and(*others)
+    end
+
+  end # describe #and
+
+  describe "#or" do
+
+    it "calls .or class factory method with self" do
+      expect(test_class).to receive(:or).with(subject, *others)
+      subject.or(*others)
+    end
+
+  end # describe #or
+
+  describe "#xor" do
+
+    it "calls .xor class factory method with self" do
+      expect(test_class).to receive(:xor).with(subject, *others)
+      subject.xor(*others)
+    end
+
+  end # describe #xor
+
+  describe "#not" do
+
+    it "calls .not class factory method with self" do
+      expect(test_class).to receive(:not).with(subject)
+      subject.not
+    end
+
+  end # describe #not
+
+end # describe Attestor::Policy

data/spec/tests/validations/collection_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+describe Attestor::Validations::Collection do
+
+  let(:item_class) { Attestor::Validations::Item }
+
+  describe ".new" do
+
+    it "creates a collection" do
+      expect(subject).to be_kind_of Enumerable
+    end
+
+    it "creates an immutable object" do
+      expect(subject).to be_frozen
+    end
+
+  end # .new
+
+  describe "#each" do
+
+    it "returns an enumerator" do
+      expect(subject.each).to be_kind_of Enumerator
+    end
+
+    it "iterates trough the unique item names" do
+      items   = %w(foo bar foo).map(&item_class.method(:new))
+      subject = described_class.new items
+
+      expect(subject.to_a).to match_array %i(foo bar)
+    end
+
+  end # describe #each
+
+  describe "#add" do
+
+    context "without options" do
+
+      let(:result) { subject.add("foo") }
+
+      it "returns the collection" do
+        expect(result).to be_kind_of described_class
+      end
+
+      it "adds item to the collection" do
+        item = result.first
+        expect(item).to eq :foo
+      end
+
+      it "preserves existing items" do
+        expect(result.add(:bar).to_a).to contain_exactly :foo, :bar
+      end
+
+    end # context
+
+    context "with options" do
+
+      let(:result) { subject.add "foo", only: [:foo] }
+
+      it "adds item to the collection" do
+        expect(result.to_a).to eq [:foo]
+        expect(result.set(:foo).to_a).to eq [:foo]
+        expect(result.set(:all).to_a).to eq []
+      end
+
+    end # context
+
+    context "existing item" do
+
+      subject { described_class.new.add "foo" }
+
+      it "returns itself" do
+        expect(subject.add "foo").to eq subject
+      end
+
+    end # context
+
+  end # describe #add
+
+  describe "#context" do
+
+    subject do
+      described_class.new
+        .add("foo", only:   %w(cad cam))
+        .add("bar", except: %w(cad))
+        .add("baz", except: %w(cam))
+    end
+
+    it "returns a collection" do
+      expect(subject.set "all").to be_kind_of described_class
+    end
+
+    it "returns a set of items used in given context" do
+      expect(subject.set("cad").to_a).to contain_exactly :foo, :baz
+      expect(subject.set("cam").to_a).to contain_exactly :foo, :bar
+      expect(subject.set("all").to_a).to contain_exactly :bar, :baz
+    end
+
+  end # describe #context
+
+end # describe Attestor::Collection

data/spec/tests/validations/item_spec.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+
+describe Attestor::Validations::Item do
+
+  subject { described_class.new "foo" }
+
+  describe ".new" do
+
+    it "is immutable" do
+      expect(subject).to be_frozen
+    end
+
+    it "accepts item option :except" do
+      expect { described_class.new "foo", except: :bar }.not_to raise_error
+    end
+
+    it "accepts array option :except" do
+      expect { described_class.new "foo", except: %w(bar) }.not_to raise_error
+    end
+
+    it "ignores repetitive :except items" do
+      expect(described_class.new "foo", except: %i(bar bar))
+        .to eq(described_class.new "foo", except: %i(bar))
+    end
+
+    it "accepts item option :only" do
+      expect { described_class.new "foo", only: :bar }.not_to raise_error
+    end
+
+    it "accepts array option :only" do
+      expect { described_class.new "foo", only: %w(bar) }.not_to raise_error
+    end
+
+    it "ignores repetitive :only items" do
+      expect(described_class.new "foo", only: %i(bar bar))
+        .to eq(described_class.new "foo", only: %i(bar))
+    end
+
+  end # describe .new
+
+  describe ".name" do
+
+    it "is initialized as a symbol" do
+      expect(subject.name).to eq :foo
+    end
+
+  end # describe .name
+
+  describe "#==" do
+
+    subject { described_class.new :foo, except: [:foo], only: %i(bar) }
+
+    context "item with the same name and options" do
+
+      let(:other) { described_class.new :foo, except: %i(foo), only: %i(bar) }
+
+      it "returns true" do
+        expect(subject == other).to eq true
+        expect(subject).to eq other
+      end
+
+    end # context
+
+    context "item with another name" do
+
+      let(:other) { described_class.new :baz, except: %i(foo), only: %i(bar) }
+
+      it "returns false" do
+        expect(subject == other).to eq false
+        expect(subject).not_to eq other
+      end
+
+    end # context
+
+    context "item with another blacklist" do
+
+      let(:other) { described_class.new :foo, except: %i(baz), only: %i(bar) }
+
+      it "returns false" do
+        expect(subject == other).to eq false
+        expect(subject).not_to eq other
+      end
+
+    end # context
+
+    context "item with another whitelist" do
+
+      let(:other) { described_class.new :foo, except: %i(foo), only: %i(baz) }
+
+      it "returns false" do
+        expect(subject == other).to eq false
+        expect(subject).not_to eq other
+      end
+
+    end # context
+
+    context "not an item" do
+
+      let(:other) { "baz" }
+
+      it "returns false" do
+        expect(subject == other).to eq false
+        expect(subject).not_to eq other
+      end
+
+    end # context
+
+  end # describe #==
+
+  describe "#used_in_context?" do
+
+    context "not restricted" do
+
+      it { is_expected.to be_used_in_context :bar }
+      it { is_expected.to be_used_in_context "baz" }
+
+    end # context
+
+    context "blacklisted" do
+
+      subject { described_class.new "foo", except: %w(foo bar) }
+
+      it { is_expected.not_to be_used_in_context "foo" }
+      it { is_expected.not_to be_used_in_context :bar }
+      it { is_expected.to be_used_in_context "baz" }
+
+    end # context
+
+    context "whitelisted" do
+
+      subject { described_class.new "foo", only: %w(foo bar) }
+
+      it { is_expected.to be_used_in_context "foo" }
+      it { is_expected.to be_used_in_context :bar }
+      it { is_expected.not_to be_used_in_context "baz" }
+
+    end # context
+
+    context "white- and blacklisted" do
+
+      subject do
+        described_class.new "foo", only: %w(foo bar), except: %w(bar baz)
+      end
+
+      it { is_expected.to be_used_in_context "foo" }
+      it { is_expected.not_to be_used_in_context :bar }
+      it { is_expected.not_to be_used_in_context "baz" }
+
+    end
+
+  end # describe #name
+
+end # describe Attestor::Validation

data/spec/tests/validations/message_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+describe Attestor::Validations::Message do
+
+  let(:test_class) { Class.new }
+  before { TestModule = Module.new }
+  before { TestModule::TestObject = test_class }
+  after  { Object.send :remove_const, :TestModule }
+
+  let(:scope) { test_class.new }
+
+  shared_examples "building frozen string" do
+
+    it { is_expected.to be_kind_of String }
+    it { is_expected.to be_frozen }
+
+  end # shared examples
+
+  describe ".new" do
+
+    context "with a symbol argument" do
+
+      subject { described_class.new :invalid, scope, foo: "bar" }
+
+      it_behaves_like "building frozen string"
+
+      it "translates the symbol in given scope" do
+        expect(I18n).to receive(:t) do |text, options|
+          expect(text).to eq :invalid
+          expect(options[:scope])
+            .to eq %w(attestor errors test_module/test_object)
+          expect(options[:default]).to eq "#{ scope } is invalid (invalid)"
+          expect(options[:foo]).to eq "bar"
+          ""
+        end
+        subject
+      end
+
+      it "returns the translation" do
+        expect(subject).to eq "#{ scope } is invalid (invalid)"
+      end
+
+    end # context
+
+    context "with a non-symbolic argument" do
+
+      subject { described_class.new 1, scope }
+
+      it_behaves_like "building frozen string"
+
+      it "creates a stringified argument" do
+        expect(subject).to eq "1"
+      end
+
+    end # context
+
+    context "without options" do
+
+      subject { described_class.new :invalid, scope }
+
+      it_behaves_like "building frozen string"
+
+      it "returns the translation" do
+        expect(subject).to eq "#{ scope } is invalid (invalid)"
+      end
+
+    end # context
+
+  end # describe .new
+
+end # Attestor::Validations::Invalid

data/spec/tests/validations_spec.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+describe Attestor::Validations do
+
+  let(:collection_class) { Attestor::Validations::Collection }
+  let(:item_class)       { Attestor::Validations::Item }
+  let(:message_class)    { Attestor::Validations::Message }
+  let(:invalid_error)    { Attestor::InvalidError }
+  let(:test_class)       { Class.new.send(:include, described_class) }
+
+  before { Test = test_class }
+  after  { Object.send :remove_const, :Test }
+
+  subject { test_class.new }
+
+  describe ".validations" do
+
+    it "returns a Collection" do
+      expect(test_class.validations).to be_kind_of collection_class
+    end
+
+    it "is empty by default" do
+      expect(test_class.validations.to_a).to be_empty
+    end
+
+  end # describe .validations
+
+  describe ".validate" do
+
+    context "without options" do
+
+      before { test_class.validate :foo }
+
+      it "adds the item to the collection" do
+        expect(test_class.validations.to_a).to eq [:foo]
+      end
+
+    end # context
+
+    context "with options" do
+
+      before { test_class.validate :foo, only: %w(bar baz), except: "bar" }
+
+      it "uses options" do
+        expect(test_class.validations.to_a).to eq [:foo]
+        expect(test_class.validations.set(:baz).to_a).to eq [:foo]
+        expect(test_class.validations.set(:bar).to_a).to eq []
+      end
+
+    end # context
+
+  end # describe .validate
+
+  describe "#validate" do
+
+    before do
+      test_class.validate :foo
+      test_class.validate :bar, only: :all
+      test_class.validate :baz, only: :foo
+      %i(foo bar baz).each { |method| allow(subject).to receive(method) }
+    end
+
+    context "without an argument" do
+
+      it "calls validations for :all context" do
+        expect(subject).to receive(:foo)
+        expect(subject).to receive(:bar)
+        expect(subject).not_to receive(:baz)
+        subject.validate
+      end
+
+    end # context
+
+    context ":foo" do
+
+      it "calls validations for :foo context" do
+        expect(subject).to receive(:foo)
+        expect(subject).to receive(:baz)
+        expect(subject).not_to receive(:bar)
+        subject.validate :foo
+      end
+
+    end # context
+
+  end # describe #validate
+
+  describe "#invalid" do
+
+    shared_examples "raising an error" do |name, options = {}|
+
+      let(:message) { message_class.new(name, subject, options) }
+
+      it "raises an InvalidError" do
+        expect { invalid }.to raise_error invalid_error
+      end
+
+      it "assings itself to the exception" do
+        begin
+          invalid
+        rescue => error
+          expect(error.object).to eq subject
+          expect(error.messages).to contain_exactly message
+        end
+      end
+
+    end # shared examples
+
+    context "without options" do
+
+      let(:invalid) { subject.invalid :foo }
+
+      it_behaves_like "raising an error", :foo
+
+    end
+
+    context "with options" do
+
+      let(:invalid) { subject.invalid :foo, bar: :baz }
+
+      it_behaves_like "raising an error", :foo, bar: :baz
+
+    end
+
+  end # invalid
+
+end # describe Attestor::Validations