policy 1.2.0 → 2.0.0

data/lib/policy/violation_error.rb

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-module Policy
-
-  # An exception to be risen by {Policy::Interface#apply}
-  class ViolationError < RuntimeError
-    include Adamantium
-
-    # @!attribute [r] policy
-    # The violated policy object
-    #
-    # @return [Policy::Follower]
-    attr_reader :policy
-
-    # @!attribute [r] messages
-    # The list of messages from the broken policy
-    #
-    # @return [Array<String>]
-    attr_reader :messages
-
-    # @!scope class
-    # @!method new(policy)
-    # Constructs an exception
-    #
-    # @param [Policy::Follower] policy
-    #   the violated policy object
-    #
-    # @return [Policy::ViolationError]
-    def initialize(policy)
-      @policy   = policy.dup
-      @messages = @policy.messages
-    end
-
-    # The human-readable description for the exception
-    #
-    # @return [String]
-    def inspect
-      "#<#{ self }: #{ message }>"
-    end
-
-    # The human-readable exception message
-    #
-    # @return [String]
-    def message
-      "#{ policy } violated: #{ messages }"
-    end
-
-    memoize :policy, :messages
-
-  end # module Follower
-
-end # module Policy

data/spec/features/follower_spec.rb

@@ -1,95 +0,0 @@
-# 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/tests/policy/follower/followed_policies_spec.rb

@@ -1,87 +0,0 @@
-# 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

@@ -1,117 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,220 +0,0 @@
-# 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