assertion 0.2.0 → 0.2.1

data/spec/unit/assertion/dsl/attribute_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+describe Assertion::DSL::Attribute do
+
+  let(:klass) do
+    Class.new do
+      extend Assertion::DSL::Attribute
+      attr_reader :foo
+    end
+  end
+
+  describe ".extended" do
+
+    it "defines the #object" do
+      expect(klass.new).to respond_to :object
+    end
+
+  end # describe .extended
+
+  describe "#attribute" do
+
+    before { klass.send(:define_method, :object) { :object } }
+
+    shared_examples "aliasing #object" do |with: nil|
+
+      before { klass.attribute with }
+      let(:instance) { klass.new }
+      subject { instance.send with }
+
+      it { is_expected.to eql instance.object }
+
+    end # shared examples
+
+    shared_examples "complaining about wrong name" do |with: nil|
+
+      subject { klass.attribute with }
+
+      it "fails" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of NameError
+          expect(error.message).to eql "#{klass}##{with} is already defined"
+        end
+      end
+
+    end # shared examples
+
+    it_behaves_like "aliasing #object", with: "bar"
+    it_behaves_like "complaining about wrong name", with: "foo"
+    it_behaves_like "complaining about wrong name", with: "state"
+
+  end # describe #attribute
+
+end # describe Assertion::DSL::Attribute

data/spec/unit/assertion/dsl/attributes_spec.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require "ostruct"
+
+describe Assertion::DSL::Attributes do
+
+  let(:klass) do
+    Class.new do
+      extend Assertion::DSL::Attributes
+      attr_reader :baz
+    end
+  end
+
+  describe ".extended" do
+
+    subject { klass.new.attributes }
+
+    it "defines hash of #attributes" do
+      expect(subject).to eql({})
+    end
+
+  end # describe .extended
+
+  describe "#attributes" do
+
+    subject { klass.attributes }
+
+    it { is_expected.to eql [] }
+
+  end # describe .attributes
+
+  describe "#attribute" do
+
+    before do
+      klass.send(:define_method, :attributes) { { foo: :FOO, bar: :BAR } }
+    end
+
+    shared_examples "defining attributes" do
+
+      let(:instance) { klass.new }
+
+      it "registers attributes" do
+        expect(klass.attributes).to eql [:foo, :bar]
+      end
+
+      it "declares attributes" do
+        expect(instance.foo).to eql :FOO
+        expect(instance.bar).to eql :BAR
+      end
+
+    end # shared examples
+
+    shared_examples "complaining about wrong name" do
+
+      subject { klass.attribute name }
+
+      it "fails" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of NameError
+          expect(error.message).to eql "#{klass}##{name} is already defined"
+        end
+      end
+
+    end # shared examples
+
+    it_behaves_like "defining attributes" do
+      before { klass.attribute :foo }
+      before { klass.attribute :bar }
+    end
+
+    it_behaves_like "defining attributes" do
+      before { klass.attribute :foo, :bar }
+    end
+
+    it_behaves_like "defining attributes" do
+      before { klass.attribute %w(foo bar) }
+    end
+
+    it_behaves_like "complaining about wrong name" do
+      let(:name) { "baz" }
+    end
+
+    it_behaves_like "complaining about wrong name" do
+      let(:name) { "check" }
+    end
+
+  end # describe .attribute
+
+end # describe Assertion::DSL::Attributes

data/spec/unit/assertion/dsl/builder_spec.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+describe Assertion::DSL::Builder do
+
+  let(:klass) { Class.new { extend Assertion::DSL::Builder } }
+  let(:john)  { { age: 17, gender: :male } }
+  let(:jack)  { { age: 18, gender: :male } }
+
+  describe "#about" do
+
+    context "with attributes and a block" do
+
+      subject do
+        IsMan = klass.about(:age, :gender) { age >= 18 && gender == :male }
+      end
+
+      it "builds the assertion class" do
+        expect(subject.superclass).to eql Assertion::Base
+      end
+
+      it "implements the #check method" do
+        expect(subject[john]).to be_invalid
+        expect(subject[jack]).to be_valid
+      end
+
+    end # context
+
+    context "without attributes" do
+
+      subject do
+        IsMan = klass.about { true }
+      end
+
+      it "builds the assertion class" do
+        expect(subject.superclass).to eql Assertion::Base
+      end
+
+      it "implements the #check method" do
+        expect(subject[john]).to be_valid
+        expect(subject[jack]).to be_valid
+      end
+
+    end # context
+
+    context "without a block" do
+
+      subject do
+        IsMan = klass.about(:age, :gender)
+      end
+
+      it "builds the assertion class" do
+        expect(subject.superclass).to eql Assertion::Base
+      end
+
+      it "doesn't implement the #check method" do
+        expect { subject.new(jack).check }.to raise_error NoMethodError
+      end
+
+    end # context
+
+    after { Object.send :remove_const, :IsMan }
+
+  end # describe .about
+
+  describe "#guards" do
+
+    before { IsAdult = klass.about(:age) { age.to_i >= 18 } }
+
+    context "with an attribute and a block" do
+
+      subject { klass.guards(:user) { IsAdult[user] } }
+
+      it "builds the guard class" do
+        expect(subject.superclass).to eql Assertion::Guard
+      end
+
+      it "defines an alias for the object" do
+        expect(subject.new(jack).user).to eql jack
+      end
+
+      it "implements the #state" do
+        expect { subject.new(jack).state }.not_to raise_error
+      end
+
+    end # context
+
+    context "without an attribute" do
+
+      subject { klass.guards { IsAdult[object] } }
+
+      it "builds the guard class" do
+        expect(subject.superclass).to eql Assertion::Guard
+      end
+
+      it "implements the #state of #object" do
+        expect { subject.new(jack).state }.not_to raise_error
+      end
+
+    end # context
+
+    context "without a block" do
+
+      subject { klass.guards(:user) }
+
+      it "builds the guard class" do
+        expect(subject.superclass).to eql Assertion::Guard
+      end
+
+      it "defines an alias for the object" do
+        expect(subject.new(jack).user).to eql jack
+      end
+
+      it "doesn't implement the #state" do
+        expect { subject.new(jack).state }.to raise_error NoMethodError
+      end
+
+    end # context
+
+    after { Object.send :remove_const, :IsAdult   }
+
+  end # describe .guards
+
+end # describe Assertion::DSL::Builder

data/spec/unit/assertion/dsl/caller_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require "ostruct"
+
+describe Assertion::DSL::Caller do
+
+  let(:klass) do
+    Class.new(OpenStruct) do
+      extend Assertion::DSL::Caller
+      alias_method :call, :inspect
+    end
+  end
+
+  describe "#[]" do
+
+    it "works" do
+      args = { foo: :FOO, baz: :BAZ }
+      expect(klass[args]).to eql klass.new(args).call
+    end
+
+  end # describe #[]
+
+end # describe Assertion::DSL::Caller

data/spec/unit/assertion/dsl/inversion_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+describe Assertion::DSL::Inversion do
+
+  let(:klass) { Class.new { extend Assertion::DSL::Inversion } }
+
+  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
+
+end # describe Assertion::DSL::Inversion

data/spec/unit/assertion/guard_spec.rb

@@ -17,64 +17,25 @@ describe Assertion::Guard do
   let(:invalid) { OpenStruct.new(name: "Ian", age: 10) }
   let(:guard)   { AdultOnly.new valid }
 
-  describe ".attribute" do
-
-    shared_examples "adding #object alias" do |name|
-
-      subject { AdultOnly.attribute name }
-
-      it "adds alias for the #object" do
-        subject
-        expect(guard.send name).to eql guard.object
-      end
-
-    end # shared examples
-
-    shared_examples "raising NameError" do |with: nil|
-
-      before  { Test = Class.new(described_class) } # #state not implemented yet
-      after   { Object.send :remove_const, :Test  }
-      subject { Test.attribute with               }
-
-      it "fails" do
-        expect { subject }.to raise_error do |error|
-          expect(error).to be_kind_of NameError
-          expect(error.message).to eql "Test##{with} is already defined"
-        end
-      end
-
-    end # shared examples
-
-    it_behaves_like "adding #object alias", :foo
-    it_behaves_like "raising NameError", with: "state"
-    it_behaves_like "raising NameError", with: "call"
+  it "implements DSL::Caller" do
+    expect(AdultOnly).to be_kind_of Assertion::DSL::Caller
+  end
 
-  end # describe .attribute
+  it "implements DSL::Attribute" do
+    expect(AdultOnly).to be_kind_of Assertion::DSL::Attribute
+  end
 
   describe ".new" do
 
     subject { guard }
 
-    it { is_expected.to be_frozen }
-
-  end # describe .new
-
-  describe ".[]" do
-
-    it "returns the result of the call" do
-      expect(AdultOnly[valid]).to eql valid
-      expect { AdultOnly[invalid] }.to raise_error Assertion::InvalidError
+    it "initializes the object" do
+      expect(guard.object).to eql valid
     end
 
-  end # describe .[]
-
-  describe "#object" do
-
-    subject { guard.object }
-
-    it { is_expected.to eql valid }
+    it { is_expected.to be_frozen }
 
-  end # describe #object
+  end # describe .new
 
   describe "#call" do
 

data/spec/unit/assertion/inverter_spec.rb

@@ -8,6 +8,10 @@ describe Assertion::Inverter do
 
   subject(:inverter) { described_class.new source }
 
+  it "implements DSL::Caller" do
+    expect(inverter).to be_kind_of Assertion::DSL::Caller
+  end
+
   describe ".new" do
 
     it { is_expected.to be_frozen }
@@ -49,32 +53,6 @@ describe Assertion::Inverter do
 
   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, :IsMan }
 
 end # describe Assertion::Inverter

data/spec/unit/assertion/translator_spec.rb

@@ -50,7 +50,9 @@ describe Assertion::Translator do
     end # shared examples
 
     it_behaves_like "translating", true,  to: "truthy"
+    it_behaves_like "translating", "ok",  to: "truthy"
     it_behaves_like "translating", false, to: "falsey"
+    it_behaves_like "translating", nil,   to: "falsey"
 
   end # describe #call
 

data/spec/unit/assertion_spec.rb

@@ -2,121 +2,8 @@
 
 describe Assertion do
 
-  let(:john) { { age: 17, gender: :male } }
-  let(:jack) { { age: 18, gender: :male } }
-
-  describe ".about" do
-
-    context "with attributes and a block" do
-
-      subject do
-        IsMan = Assertion.about(:age, :gender) { age >= 18 && gender == :male }
-      end
-
-      it "builds the assertion class" do
-        expect(subject.superclass).to eql Assertion::Base
-      end
-
-      it "implements the #check method" do
-        expect(subject[john]).to be_invalid
-        expect(subject[jack]).to be_valid
-      end
-
-    end # context
-
-    context "without attributes" do
-
-      subject do
-        IsMan = Assertion.about { true }
-      end
-
-      it "builds the assertion class" do
-        expect(subject.superclass).to eql Assertion::Base
-      end
-
-      it "implements the #check method" do
-        expect(subject[john]).to be_valid
-        expect(subject[jack]).to be_valid
-      end
-
-    end # context
-
-    context "without a block" do
-
-      subject do
-        IsMan = Assertion.about(:age, :gender)
-      end
-
-      it "builds the assertion class" do
-        expect(subject.superclass).to eql Assertion::Base
-      end
-
-      it "doesn't implement the #check method" do
-        expect { subject.new(jack).check }.to raise_error NoMethodError
-      end
-
-    end # context
-
-    after { Object.send :remove_const, :IsMan }
-
-  end # describe .about
-
-  describe ".guards" do
-
-    before { IsAdult = Assertion.about(:age) { age.to_i >= 18 } }
-
-    context "with an attribute and a block" do
-
-      subject { Assertion.guards(:user) { IsAdult[user] } }
-
-      it "builds the guard class" do
-        expect(subject.superclass).to eql Assertion::Guard
-      end
-
-      it "defines an alias for the object" do
-        expect(subject.new(jack).user).to eql jack
-      end
-
-      it "implements the #state" do
-        expect { subject.new(jack).state }.not_to raise_error
-      end
-
-    end # context
-
-    context "without an attribute" do
-
-      subject { Assertion.guards { IsAdult[object] } }
-
-      it "builds the guard class" do
-        expect(subject.superclass).to eql Assertion::Guard
-      end
-
-      it "implements the #state of #object" do
-        expect { subject.new(jack).state }.not_to raise_error
-      end
-
-    end # context
-
-    context "without a block" do
-
-      subject { Assertion.guards(:user) }
-
-      it "builds the guard class" do
-        expect(subject.superclass).to eql Assertion::Guard
-      end
-
-      it "defines an alias for the object" do
-        expect(subject.new(jack).user).to eql jack
-      end
-
-      it "doesn't implement the #state" do
-        expect { subject.new(jack).state }.to raise_error NoMethodError
-      end
-
-    end # context
-
-    after { Object.send :remove_const, :IsAdult   }
-
-  end # describe .guards
+  it "extends DSL::Builder" do
+    expect(described_class).to be_kind_of Assertion::DSL::Builder
+  end
 
 end # describe Assertion