assertion 0.0.1

data/spec/integration/en.yml

@@ -0,0 +1,10 @@
+# Translations of messages for examples in the `./assertion_spec.rb`
+---
+en:
+  assertion:
+    is_adult:
+      right: "%{name} is an adult (age %{age})"
+      wrong: "%{name} is a child (age %{age})"
+    is_male:
+      right: "%{name} is a male"
+      wrong: "%{name} is a female"

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
+
+# Loads the code under test
+require "assertion"

data/spec/unit/assertion/base_spec.rb

@@ -0,0 +1,221 @@
+# encoding: utf-8
+
+describe Assertion::Base do
+
+  let(:klass) { Class.new(described_class) }
+  before { allow(klass).to receive(:name) { "Test" } }
+
+  describe ".attributes" do
+
+    subject(:attributes) { klass.attributes }
+
+    it { is_expected.to eql [] }
+
+  end # describe .attributes
+
+  describe ".attribute" do
+
+    subject(:attribute) { klass.attribute names }
+
+    context "with valid name" do
+
+      let(:names) { :foo }
+
+      it "defines the attribute" do
+        expect { subject }
+          .to change { klass.attributes }
+          .to [:foo]
+      end
+
+    end # context
+
+    context "with array of names" do
+
+      let(:names) { [:foo, "bar", "foo"] }
+
+      it "defines the attribute" do
+        expect { subject }
+          .to change { klass.attributes }
+          .to [:foo, :bar]
+      end
+
+    end # context
+
+    context "with a :check name" do
+
+      let(:names) { [:check] }
+
+      it "fails" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of Assertion::NameError
+          expect(error.message).to include "check"
+        end
+      end
+
+    end # context
+
+    context "with a :call name" do
+
+      let(:names) { [:call] }
+
+      it "fails" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of Assertion::NameError
+          expect(error.message).to include "call"
+        end
+      end
+
+    end # context
+
+  end # describe .attribute
+
+  describe ".new" do
+
+    let(:klass) { Class.new(described_class) { attribute :foo, :bar } }
+
+    context "with attributes" do
+
+      subject { klass.new foo: :FOO, bar: :BAR, baz: :BAZ }
+
+      it "defines attributes" do
+        new_methods = subject.methods - described_class.instance_methods
+        expect(new_methods).to match_array [:foo, :bar]
+      end
+
+      it "initializes attributes" do
+        expect(subject.foo).to eql :FOO
+        expect(subject.bar).to eql :BAR
+      end
+
+      it { is_expected.to be_frozen }
+
+    end # context
+
+    context "without attributes" do
+
+      subject { klass.new }
+
+      it { is_expected.to be_frozen }
+
+    end # context
+
+  end # describe .new
+
+  describe ".not" do
+
+    subject { klass.not }
+
+    it "creates the iverter for the current class" do
+      expect(subject).to be_kind_of Assertion::Inverter
+      expect(subject.source).to eql klass
+    end
+
+  end # describe .not
+
+  describe ".[]" do
+
+    subject { klass[params] }
+
+    let(:params)    { { foo: :FOO }      }
+    let(:state)     { double             }
+    let(:assertion) { double call: state }
+
+    before { allow(klass).to receive(:new).with(params) { assertion } }
+
+    it "checks the assertion for given attributes" do
+      expect(subject).to eql state
+    end
+
+  end # describe .[]
+
+  describe "#attributes" do
+
+    let(:attrs)     { { foo: :FOO, bar: :BAR } }
+    let(:klass)     { Class.new(described_class) { attribute :foo, :bar } }
+    let(:assertion) { klass.new attrs }
+
+    subject { assertion.attributes     }
+    it      { is_expected.to eql attrs }
+
+  end # describe #attributes
+
+  describe "#message" do
+
+    let(:assertion) { klass.new }
+
+    context "for the truthy state" do
+
+      subject { assertion.message(true) }
+      it { is_expected.to eql "translation missing: en.assertion.test.right" }
+
+    end # context
+
+    context "for the falsey state" do
+
+      subject { assertion.message(false) }
+      it { is_expected.to eql "translation missing: en.assertion.test.wrong" }
+
+    end # context
+
+    context "by default" do
+
+      it "returns the message for the falsey state" do
+        expect(assertion.message).to eql assertion.message(false)
+      end
+
+    end # context
+
+  end # describe #message
+
+  describe "#check" do
+
+    subject { klass.new.check }
+
+    it "raises NotImplementedError" do
+      expect { subject }.to raise_error do |error|
+        expect(error).to be_kind_of Assertion::NotImplementedError
+        expect(error.message).to include("Test#check ")
+      end
+    end
+
+  end # describe #check
+
+  describe "#call" do
+
+    subject { assertion.call }
+
+    context "invalid assertion" do
+
+      let(:assertion) do
+        klass.__send__(:define_method, :check) { false }
+        klass.new
+      end
+
+      it "returns an invalid state" do
+        expect(subject).to be_kind_of Assertion::State
+        expect(subject).to be_invalid
+      end
+
+      it "adds a proper message to the state" do
+        expect(subject.messages).to contain_exactly assertion.message(false)
+      end
+
+    end # context
+
+    context "valid assertion" do
+
+      let(:assertion) do
+        klass.__send__(:define_method, :check) { true }
+        klass.new
+      end
+
+      it "returns a valid state" do
+        expect(subject).to be_kind_of Assertion::State
+        expect(subject).to be_valid
+      end
+
+    end # context
+
+  end # describe #call
+
+end # describe Assertion

data/spec/unit/assertion/exceptions/invalid_error_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+describe Assertion::InvalidError do
+
+  subject(:error) { described_class.new messages }
+  let(:messages)  { %w(foo bar) }
+
+  describe ".new" do
+
+    it { is_expected.to be_kind_of ::RuntimeError }
+
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#message" do
+
+    subject { error.message }
+
+    it "returns a proper message" do
+      expect(subject).to include "#{messages.inspect}"
+    end
+
+  end # describe #message
+
+  describe "#messages" do
+
+    subject { error.messages }
+
+    it { is_expected.to eql messages }
+
+    it { is_expected.to be_frozen }
+
+    it "doesn't freeze the source messages" do
+      expect(messages).not_to be_frozen
+    end
+
+  end # describe #message
+
+end # describe Assertion::InvalidError

data/spec/unit/assertion/exceptions/name_error_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+describe Assertion::NameError do
+
+  subject(:error) { described_class.new :foo, :bar }
+
+  describe ".new" do
+
+    it { is_expected.to be_kind_of ::NameError }
+
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#message" do
+
+    subject(:message) { error.message }
+
+    it "returns a proper message" do
+      expect(subject)
+        .to include "Wrong name(s) for attribute(s): foo, bar"
+    end
+
+  end # describe #message
+
+end # describe Assertion::NameError

data/spec/unit/assertion/exceptions/not_implemented_error_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+describe Assertion::NotImplementedError do
+
+  subject(:error) { described_class.new klass, :foo }
+  let(:klass)     { double name: :Test }
+
+  describe ".new" do
+
+    it { is_expected.to be_kind_of ::NotImplementedError }
+
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#message" do
+
+    subject(:message) { error.message }
+
+    it "returns a proper message" do
+      expect(subject).to include "Test#foo method not implemented"
+    end
+
+  end # describe #message
+
+end # describe Assertion::NotImplementedError

data/spec/unit/assertion/inversion_spec.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+describe Assertion::Inversion do
+
+  before { Adult = Assertion.about(:age) { age >= 18 } }
+
+  let(:assertion)            { Adult.new age: 21              }
+  subject(:inversion)        { described_class.new(assertion) }
+  subject(:double_inversion) { described_class.new(inversion) }
+
+  describe ".new" do
+
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#assertion" do
+
+    subject { inversion.assertion }
+
+    it { is_expected.to eql assertion }
+
+  end # describe #assertion
+
+  describe "#check" do
+
+    subject { instance.check }
+
+    it "is opposite to the assertion#check" do
+      expect(inversion.check).to eql !assertion.check
+    end
+
+    it "works for double inversion" do
+      expect(double_inversion.check).to eql assertion.check
+    end
+
+  end # describe #check
+
+  describe "#message" do
+
+    context "for the truthy state" do
+
+      it "is equal to wrong assertion" do
+        expect(inversion.message(true)).to eql assertion.message(false)
+      end
+
+      it "works for double inversion" do
+        expect(double_inversion.message(true)).to eql assertion.message(true)
+      end
+
+    end # context
+
+    context "for the falsey state" do
+
+      it "is equal to right assertion" do
+        expect(inversion.message(false)).to eql assertion.message(true)
+      end
+
+      it "works for double inversion" do
+        expect(double_inversion.message(false)).to eql assertion.message(false)
+      end
+
+    end # context
+
+    context "by default" do
+
+      it "returns the message for the falsey state" do
+        expect(inversion.message).to eql inversion.message(false)
+      end
+
+    end # context
+
+  end # describe #message
+
+  describe "#call" do
+
+    let(:state) { assertion.call }
+    subject     { inversion.call }
+
+    it "creates the state opposite to the assertion's" do
+      expect(subject.valid?).to eql state.invalid?
+      expect(subject.messages).to contain_exactly assertion.message(true)
+    end
+
+  end # describe #call
+
+  after { Object.send :remove_const, :Adult }
+
+end # describe Assertion::Inversion

data/spec/unit/assertion/inverter_spec.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+describe Assertion::Inverter do
+
+  let(:source) do
+    Man = Assertion.about(:age, :gender) { age.to_i >= 18 && gender == :male }
+  end
+
+  subject(:inverter) { described_class.new source }
+
+  describe ".new" do
+
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe ".source" do
+
+    subject { inverter.source           }
+    it      { is_expected.to eql source }
+
+  end # describe .source
+
+  describe "#new" do
+
+    let(:assertion) { inversion.assertion }
+
+    context "with attributes" do
+
+      subject(:inversion) { inverter.new age: 17, gender: :male }
+
+      it "returns an inversion" do
+        expect(inversion).to be_kind_of Assertion::Inversion
+        expect(assertion.attributes).to eql(age: 17, gender: :male)
+      end
+
+    end # context
+
+    context "without attributes" do
+
+      subject(:inversion) { inverter.new }
+
+      it "returns an inversion" do
+        expect(inversion).to be_kind_of Assertion::Inversion
+        expect(assertion.attributes).to eql(age: nil, gender: nil)
+      end
+
+    end # context
+
+  end # describe #new
+
+  describe "#[]" do
+
+    context "with attributes" do
+
+      subject(:state) { inverter[age: 18, gender: :male] }
+
+      it "provides the state for inversion" do
+        expect(state).to be_kind_of Assertion::State
+        expect(state).to be_invalid
+      end
+
+    end # context
+
+    context "without attributes" do
+
+      subject(:state) { inverter[] }
+
+      it "provides the state for inversion" do
+        expect(state).to be_kind_of Assertion::State
+        expect(state).to be_valid
+      end
+
+    end # context
+
+  end # describe #[]
+
+  after { Object.send :remove_const, :Man }
+
+end # describe Assertion::Inverter