policy 1.0.1

data/spec/features/follower_spec.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+# The integration test for policy follower
+describe Policy::Follower do
+
+  before do
+
+    Transaction = Class.new Struct.new(:sum)
+
+    module Policies
+
+      class Consistency < Policy.new(:debet, :credit)
+
+        validates :debet, :credit, presence: true
+        validates :sum, numericality: { equal_to: 0 }, allow_nil: true
+
+        private
+
+        def sum
+          debet && credit && (credit.sum + debet.sum)
+        end
+
+      end # class Consistency
+
+    end # module Policy
+
+    # The follower class to be tested
+    class Transfer < Struct.new(:withdrawal, :enrollment)
+      include Policy::Follower
+
+      use_policies Policies do
+        follow_policy :Consistency, :withdrawal, :enrollment, as: :consistency
+      end
+
+    end # class Transfer
+
+  end # before
+
+  let(:withdrawal) { Transaction.new(-100) }
+  subject { Transfer.new withdrawal, enrollment }
+
+  describe "#follow_policies!" do
+
+    context "when policy is met" do
+
+      let(:enrollment) { Transaction.new(100) }
+
+      it "passes if the policy is met" do
+        expect { subject.follow_policies! }.not_to raise_error
+      end
+
+    end # context
+
+    context "when policy is broken" do
+
+      let(:enrollment) { Transaction.new(200) }
+
+      it "fails if the policy is broken" do
+        expect { subject.follow_policies! }.to raise_error
+      end
+
+    end # context
+
+  end # describe #follow_policies!
+
+  describe "#follow_policies?" do
+
+    context "when policy is met" do
+
+      let(:enrollment) { Transaction.new(100) }
+
+      it "returns true if the policy is met" do
+        expect(subject).to be_follow_policies
+      end
+
+    end # context
+
+    context "when policy is broken" do
+
+      let(:enrollment) { Transaction.new(200) }
+
+      it "returns false if the policy is broken" do
+        expect(subject).not_to be_follow_policies
+      end
+
+    end # context
+
+  end # describe #follow_policies!
+
+  after do
+    %i(Transaction Transfer Policies)
+      .each { |const| Object.__send__(:remove_const, const) }
+  end
+
+end # describe Policy::Follower

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+# Loads the RSpec test suit.
+require "hexx-suit"
+
+# Loads runtime metrics in the current scope
+Hexx::Suit.load_metrics_for(self)
+
+# Loads the code of the module.
+require "policy"

data/spec/tests/policy/follower/followed_policies_spec.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+require "ostruct"
+
+describe Policy::Follower::FollowedPolicies do
+
+  it "is a hash" do
+    expect(subject).to be_kind_of Hash
+  end
+
+  describe "#add" do
+
+    let(:policy) { double :policy, name: :foo }
+
+    it "registers a policy" do
+      expect { subject.add policy }.to change { subject }.to(foo: policy)
+    end
+
+  end # describe #add
+
+  describe "#apply_to" do
+
+    let(:follower) { double }
+
+    before do
+      %i(first second third).each do |item|
+        subject.add double(name: item, apply_to: nil)
+      end
+    end
+
+    shared_examples "applying policies" do |applied_policies = nil|
+
+      before { applied_policies ||= subject.keys }
+      let(:skipped_policies) { subject.keys - applied_policies }
+
+      it "[applies policies]" do
+        policies = applied_policies.map(&subject.method(:[]))
+
+        policies.each do |policy|
+          expect(policy).to receive(:apply_to).with(follower).ordered
+        end
+      end
+
+      it "[skips policies]" do
+        policies = skipped_policies.map(&subject.method(:[]))
+
+        policies.each do |policy|
+          expect(policy).not_to receive(:apply_to)
+        end
+      end
+
+    end # shared examples
+
+    context "by default" do
+
+      after { subject.apply_to follower }
+
+      it_behaves_like "applying policies"
+
+    end # context
+
+    context "with a list of names" do
+
+      after { subject.apply_to follower, :third, :first }
+
+      it_behaves_like "applying policies", %i(third first)
+
+    end # context
+
+    context "with a repetitive names" do
+
+      after { subject.apply_to follower, :third, :third, :third }
+
+      it_behaves_like "applying policies", %i(third third third)
+
+    end # context
+
+    context "with an array of names" do
+
+      after { subject.apply_to follower, %w(third first forth) }
+
+      it_behaves_like "applying policies", %i(third first)
+
+    end # context
+
+  end # describe #apply_to
+
+end # describe Policy::Follower::FollowedPolicies

data/spec/tests/policy/follower/followed_policy_spec.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+require "ostruct"
+
+describe Policy::Follower::FollowedPolicy do
+
+  before { module Namespace; class Policy < ::Policy.new(:foo, :bar); end; end }
+  after  { Object.send :remove_const, :Namespace                               }
+
+  let(:namespace)    { Namespace       }
+  let(:policy_class) { Namespace::Policy }
+
+  describe ".new" do
+
+    shared_examples "refusing wrong number of attributes" do |*list|
+
+      subject { described_class.new nil, policy_class, :policy, *list }
+
+      it "raises ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+
+      it "sets a proper message for the exception" do
+        begin
+          subject
+        rescue => err
+          expect(err.message).to eq(
+            "#{ policy_class } requires 2 attribute(s)." \
+            " #{ list } cannot be assigned."
+          )
+        end
+      end
+
+    end # shared examples
+
+    it_behaves_like "refusing wrong number of attributes", :foo
+    it_behaves_like "refusing wrong number of attributes", :foo, :bar, :baz
+
+  end # describe .new
+
+  describe "#name" do
+
+    context "when name is set to nil" do
+
+      subject { described_class.new nil, policy_class, nil, :foo, :bar }
+
+      it "assigns uuid" do
+        expect(subject.name.to_s).to match(/^\h{8}-(\h{4}-){3}\h{12}$/)
+      end
+
+      it "is a symbol" do
+        expect(subject.name).to be_kind_of Symbol
+      end
+
+    end # context
+
+    context "when name is set explicitly" do
+
+      subject { described_class.new nil, policy_class, "policy", :foo, :bar }
+
+      it "returns the symbolized name" do
+        expect(subject.name).to eq :policy
+      end
+
+    end # context
+
+  end # describe #name
+
+  describe "#policy" do
+
+    let(:policy_name) { :Policy }
+
+    shared_examples "policy object class" do
+
+      it "returns the constant" do
+        expect(subject.policy).to eq policy_class
+      end
+
+    end # context
+
+    it_behaves_like "policy object class" do
+      subject { described_class.new :foo, policy_class, :foo, :bar, :baz }
+    end
+
+    it_behaves_like "policy object class" do
+      subject { described_class.new namespace, policy_name, :foo, :bar, :baz }
+    end
+
+  end # describe #policy
+
+  describe "#attributes" do
+
+    let(:attributes) { %i(foo bar) }
+    subject { described_class.new nil, policy_class, :foo, *attributes }
+
+    it "is set by the initializer" do
+      expect(subject.attributes).to eq attributes
+    end
+
+  end # describe #attributes
+
+  describe "#apply_to" do
+
+    let(:attributes) { { foo: :bar, bar: :baz }   }
+    let(:follower)   { OpenStruct.new(attributes) }
+
+    subject do
+      described_class.new nil, policy_class, nil, *attributes.keys
+    end
+
+    it "calls policy_class validation with follower attributes" do
+      expect(policy_class).to receive(:apply).with(*attributes.values)
+      subject.apply_to(follower)
+    end
+
+  end # describe #apply_to
+
+end # describe Policy::Follower::Policy

data/spec/tests/policy/follower/names_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+describe Policy::Follower::Names do
+
+  describe ".from" do
+
+    shared_examples "normalizing from" do |*source|
+
+      subject { described_class.from(*source) }
+      it      { is_expected.to eq %i(foo bar baz foo) }
+
+    end # shared examples
+
+    it_behaves_like "normalizing from", %w(foo bar baz foo)
+    it_behaves_like "normalizing from", *%w(foo bar baz foo)
+
+  end # describe .from
+
+end # describe Policy::Follower::Names

data/spec/tests/policy/follower_spec.rb

@@ -0,0 +1,220 @@
+# encoding: utf-8
+
+describe Policy::Follower do
+
+  before { Test = Class.new.__send__(:include, described_class) }
+  after  { Object.send :remove_const, :Test         }
+
+  let(:test_class)  { Test }
+  subject { test_class.new }
+
+  it "includes Policy::Validations" do
+    expect(test_class).to include Policy::Validations
+  end
+
+  describe ".followed_policies" do
+
+    let(:followed_policies) { Policy::Follower::FollowedPolicies }
+
+    it "returns the AppiedPolicies object" do
+      expect(test_class.followed_policies).to be_kind_of followed_policies
+    end
+
+  end # describe .followed_policies
+
+  describe ".follow_policy" do
+
+    let(:followed_policy) { Policy::Follower::FollowedPolicy }
+
+    let(:policy)       { double name: :foo }
+    let(:policy_class) { double }
+    let(:name)         { double }
+    let(:attributes)   { [double, double] }
+
+    before { allow(followed_policy).to receive(:new) { policy } }
+
+    context "by default" do
+
+      after { test_class.follow_policy policy_class, *attributes }
+
+      it "creates new followed policy" do
+        expect(followed_policy)
+          .to receive(:new)
+          .with(test_class, policy_class, nil, *attributes)
+      end
+
+      it "adds new policy to .followed_policies" do
+        expect(test_class.followed_policies).to receive(:add).with(policy)
+      end
+
+    end # context
+
+    context "as: name" do
+
+      after { test_class.follow_policy(policy_class, *attributes, as: name) }
+
+      it "creates named followed policy" do
+        expect(followed_policy)
+          .to receive(:new)
+          .with(test_class, policy_class, name, *attributes)
+      end
+
+    end # context
+
+    context "inside #use_policies" do
+
+      let(:namespace) { double }
+
+      subject do
+        test_class.use_policies namespace do
+          follow_policy :foo, as: :bar
+        end
+      end
+
+      it "sends the namespace to followed policy" do
+        expect(followed_policy)
+          .to receive(:new).with(namespace, :foo, :bar)
+        subject
+      end
+
+      it "doesn't change default namespace" do
+        subject
+        expect(followed_policy)
+          .to receive(:new).with(test_class, :foo, :bar)
+        test_class.follow_policy :foo, as: :bar
+      end
+
+    end # context
+
+  end # describe .follow_policy
+
+  describe "#follow_policies!" do
+
+    context "without names" do
+
+      after { subject.follow_policies! }
+
+      it "applies .followed_policies to itself" do
+        expect(test_class.followed_policies)
+          .to receive(:apply_to).with(subject)
+      end
+
+    end # context
+
+    context "with names" do
+
+      let(:names) { %i(foo bar baz) }
+      after { subject.follow_policies!(*names) }
+
+      it "applies .followed_policies to itself with names" do
+        expect(test_class.followed_policies)
+          .to receive(:apply_to).with(subject, *names)
+      end
+
+    end # context
+
+    context "when a ViolationError is raised" do
+
+      let(:error)    { Policy::ViolationError.allocate }
+      let(:messages) { %w(foo bar baz) }
+
+      before do
+        allow(error).to receive(:messages) { messages }
+        allow(test_class.followed_policies).to receive(:apply_to) { fail error }
+      end
+
+      it "populates messages with errors" do
+        expect { subject.follow_policies! rescue nil }
+          .to change { subject.__send__(:errors).messages }
+          .to(base: messages)
+      end
+
+      it "re-raises the exception" do
+        expect { subject.follow_policies! }.to raise_error(error)
+      end
+
+    end # context
+
+  end # describe #follow_policies!
+
+  describe "#follow_policies?" do
+
+    before { allow(subject).to receive(:follow_policies!) }
+
+    it "calls #follow_policies! without names" do
+      expect(subject).to receive(:follow_policies!)
+      subject.follow_policies?
+    end
+
+    it "calls #follow_policies! with names" do
+      names = %i(foo bar baz)
+
+      expect(subject).to receive(:follow_policies!).with(*names)
+      subject.follow_policies?(*names)
+    end
+
+    context "wheh #follow_policies! doesn't raise an error" do
+
+      before { allow(subject).to receive(:follow_policies!) { nil } }
+
+      it "returns true" do
+        expect(subject.follow_policies?).to eq true
+      end
+
+    end # context
+
+    context "wheh #folow_policies! raises ViolationError" do
+
+      let(:error) { Policy::ViolationError.allocate }
+      before { allow(subject).to receive(:follow_policies!) { fail error } }
+
+      it "returns false" do
+        expect(subject.follow_policies?).to eq false
+      end
+
+    end # context
+
+    context "wheh #follow_policies! raises RuntimeError" do
+
+      let(:error) { StandardError.allocate }
+      before { allow(subject).to receive(:follow_policies!) { fail error } }
+
+      it "fails" do
+        expect { subject.follow_policies? }.to raise_error(error)
+      end
+
+    end # context
+
+  end # describe #follow_policies?
+
+  describe "#follow_policy!" do
+
+    before { allow(subject).to receive(:follow_policies!) }
+
+    it "is an alias for #follow_policies!" do
+      expect(subject).to receive(:follow_policies!).with :foo
+      subject.follow_policy! :foo
+    end
+
+    it "requires an argument" do
+      expect(subject.method(:follow_policy!).arity).to eq 1
+    end
+
+  end # describe #follow_policy!
+
+  describe "#follow_policy?" do
+
+    before { allow(subject).to receive(:follow_policies?) }
+
+    it "is an alias for #follow_policies?" do
+      expect(subject).to receive(:follow_policies?).with :foo
+      subject.follow_policy? :foo
+    end
+
+    it "requires an argument" do
+      expect(subject.method(:follow_policy?).arity).to eq 1
+    end
+
+  end # describe #follow_policy?
+
+end # describe Policy::Follower

data/spec/tests/policy/interface_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+describe Policy::Interface do
+
+  before { Test = Class.new.send :include, described_class }
+  after  { Object.send :remove_const, :Test         }
+
+  let(:test_class)  { Test }
+  subject { test_class.new }
+
+  it "includes Policy::Validations" do
+    expect(test_class).to include Policy::Validations
+  end
+
+  describe "#apply" do
+
+    context "when #valid? returns true" do
+
+      before { allow(subject).to receive(:valid?).and_return true }
+
+      it "doesn't raise error" do
+        expect { subject.apply }.not_to raise_error
+      end
+    end
+
+    context "when #valid? returns false" do
+
+      before { allow(subject).to receive(:valid?).and_return false }
+
+      it "raises ViolationError" do
+        expect { subject.apply }.to raise_error(Policy::ViolationError)
+      end
+
+      it "adds the policy to Exception" do
+        expect(Policy::ViolationError).to receive(:new).with(subject).once
+        subject.apply rescue nil
+      end
+    end
+
+  end # describe #apply
+
+  describe "#messages" do
+
+    context "when #errors are present" do
+
+      let(:messages) { %w(foo bar) }
+      let(:errors)   { double :errors, messages: { foo: messages } }
+
+      it "extracts a plain array of error messages" do
+        allow(subject).to receive(:errors) { errors }
+        expect(subject.messages).to eq messages
+      end
+
+    end # context
+
+    context "when #errors are absent" do
+
+      it "returns an empty array" do
+        expect(subject.messages).to eq []
+      end
+
+    end # context
+
+  end # describe #messages
+
+  describe ".apply" do
+
+    let(:attributes) { %i(foo bar) }
+    let(:follower)   { double apply: nil }
+
+    it "creates a policy object with the attributes" do
+      expect(test_class).to receive(:new).with(attributes) { follower }
+      test_class.apply attributes
+    end
+
+    it "validates the policy object" do
+      expect(test_class).to receive_message_chain :new, :apply
+      test_class.apply attributes
+    end
+
+  end # describe .apply
+
+end # describe Policy::Inteface

data/spec/tests/policy/validations_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+describe Policy::Validations do
+
+  let(:validations) { ActiveModel::Validations }
+  let(:methods)     { validations.public_instance_methods }
+  let(:test_class)  { Class.new.send :include, described_class }
+
+  it "includes ActiveModel::Validatons" do
+    expect(test_class).to include validations
+  end
+
+end