spec/unit/assertion/base_spec.rb in assertion-0.1.0 vs spec/unit/assertion/base_spec.rb in assertion-0.2.0

@@ -3,18 +3,10 @@
 describe Assertion::Base do
 
   let(:klass) { Class.new(described_class) }
   before { allow(klass).to receive(:name) { "Test" } }
 
-  it "can declare attributes" do
-    expect(klass).to be_kind_of Assertion::Attributes
-  end
-
-  it "can translate states" do
-    expect(klass).to include Assertion::Messages
-  end
-
   describe ".new" do
 
     let(:klass) { Class.new(described_class) { attribute :foo, :bar } }
 
     context "with attributes" do
@@ -43,10 +35,86 @@
 
     end # context
 
   end # describe .new
 
+  describe ".attributes" do
+
+    subject { klass.attributes }
+    it { is_expected.to eql [] }
+
+  end # describe .attributes
+
+  describe ".attribute" do
+
+    shared_examples "defining attributes" do
+
+      it "registers attributes" do
+        expect { subject }.to change { klass.attributes }.to [:foo, :bar]
+      end
+
+      it "declares attributes" do
+        subject
+        assertion = klass.new(foo: :FOO, bar: :BAR, baz: :BAZ)
+        expect(assertion.attributes).to eql(foo: :FOO, bar: :BAR)
+        expect(assertion.foo).to eql :FOO
+        expect(assertion.bar).to eql :BAR
+      end
+
+    end # shared examples
+
+    shared_examples "raising NameError" do |with: nil|
+
+      it "fails" do
+        expect { subject }.to raise_error do |exception|
+          expect(exception).to be_kind_of NameError
+          expect(exception.message).to eql "#{klass}##{with} is already defined"
+        end
+      end
+
+    end # shared examples
+
+    context "with a single name" do
+
+      subject do
+        klass.attribute :foo
+        klass.attribute "bar"
+      end
+      it_behaves_like "defining attributes"
+
+    end # context
+
+    context "with a list of names" do
+
+      subject { klass.attribute :foo, :bar }
+      it_behaves_like "defining attributes"
+
+    end # context
+
+    context "with an array of names" do
+
+      subject { klass.attribute %w(foo bar) }
+      it_behaves_like "defining attributes"
+
+    end # context
+
+    context ":check" do
+
+      subject { klass.attribute :check }
+      it_behaves_like "raising NameError", with: :check
+
+    end # context
+
+    context ":call" do
+
+      subject { klass.attribute :call }
+      it_behaves_like "raising NameError", with: :call
+
+    end # context
+
+  end # describe .attribute
+
   describe ".not" do
 
     subject { klass.not }
 
     it "creates the iverter for the current class" do
@@ -56,33 +124,75 @@
 
   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 } }
+    context "with params" do
 
-    it "checks the assertion for given attributes" do
-      expect(subject).to eql state
-    end
+      subject { klass[params] }
 
+      it "checks the assertion for given attributes" do
+        allow(klass).to receive(:new).with(params) { assertion }
+        expect(subject).to eql state
+      end
+
+    end # context
+
+    context "without params" do
+
+      subject { klass[] }
+
+      it "checks the assertion" do
+        allow(klass).to receive(:new) { assertion }
+        expect(subject).to eql state
+      end
+
+    end # context
+
   end # describe .[]
 
+  describe ".translator" do
+
+    subject { klass.translator }
+
+    it { is_expected.to be_kind_of Assertion::Translator }
+
+    it "refers to the current class" do
+      expect(subject.assertion).to eql klass
+    end
+
+  end # describe .translator
+
   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(:state)      { double }
+    let(:attrs)      { { foo: :FOO, bar: :BAR } }
+    let(:klass)      { Class.new(described_class) { attribute :foo, :bar } }
+    let(:assertion)  { klass.new attrs }
+    let(:translator) { double call: nil }
+
+    it "calls a translator with state and attributes" do
+      allow(klass).to receive(:translator) { translator }
+      expect(translator).to receive(:call).with(state, attrs)
+      assertion.message(state)
+    end
+
+  end # describe #message
 
   describe "#call" do
 
     subject { assertion.call }