policy 1.2.0 → 2.0.0

data/spec/tests/lib/policy/cli/attribute_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require "policy/cli"
+
+describe Policy::CLI::Attribute do
+
+  subject { described_class.new "FooBar{bar/baz}" }
+
+  describe "#name" do
+
+    context "when the name is present in the source" do
+
+      it "returns a name for a method" do
+        expect(subject.name).to eq "foo_bar"
+      end
+
+    end # context
+
+    context "when the name is absent in the source" do
+
+      subject { described_class.new "{bar/baz}" }
+
+      it "returns @todo" do
+        expect(subject.name).to eq "@todo"
+      end
+
+    end # context
+
+  end # describe #name
+
+  describe "#type" do
+
+    context "when the type is present in the source" do
+
+      it "returns a name for a constant" do
+        expect(subject.type).to eq "Bar::Baz"
+      end
+
+    end # context
+
+    context "when the type is absent in the source" do
+
+      subject { described_class.new "FooBar" }
+
+      it "returns @todo" do
+        expect(subject.type).to eq "@todo"
+      end
+
+    end # context
+
+  end # describe #type
+  
+end # describe Policy::CLI::Attribute

data/spec/tests/{policy → lib/policy}/cli_spec.rb

@@ -50,28 +50,6 @@ describe Policy::CLI, :sandbox, :capture do
 
     end # context
 
-    context "foo -a bar baz" do
-
-      let(:options) { %w(foo -a bar baz) }
-      before { subject }
-
-      it_behaves_like "adding a policy", folder: "policies"
-      it_behaves_like "adding a spec", folder: "policies"
-      it_behaves_like "adding locales", %w(en ru), folder: "policies"
-
-      it "adds attributes to the policy" do
-        content = read_in_sandbox "app/policies/foo.rb"
-        expect(content).to include "class Foo < Hexx::Policy.new(:bar, :baz)"
-      end
-
-      it "checks attributes" do
-        content = read_in_sandbox "spec/tests/policies/foo_spec.rb"
-        expect(content).to include "let(:bar) {"
-        expect(content).to include "let(:baz) {"
-      end
-
-    end # context
-
     context "foo -n bar/baz" do
 
       let(:options) { %w(foo -n bar/baz) }
@@ -101,6 +79,29 @@ describe Policy::CLI, :sandbox, :capture do
 
     end # context
 
+    context "foo -a bar baz" do
+
+      let(:options) { %w(foo -a bar baz) }
+      before { subject }
+
+      it_behaves_like "adding a policy", folder: "policies"
+      it_behaves_like "adding a spec", folder: "policies"
+      it_behaves_like "adding locales", %w(en ru), folder: "policies"
+
+      it "adds attributes to the policy" do
+        content = read_in_sandbox "app/policies/foo.rb"
+        expect(content).to include "attr_reader :bar"
+        expect(content).to include "attr_reader :baz"
+      end
+
+      it "checks attributes" do
+        content = read_in_sandbox "spec/tests/policies/foo_spec.rb"
+        expect(content).to include "let(:bar) {"
+        expect(content).to include "let(:baz) {"
+      end
+
+    end # context
+
     context "foo -n bar baz" do
 
       let(:options) { %w(foo -n bar baz) }
@@ -112,9 +113,9 @@ describe Policy::CLI, :sandbox, :capture do
 
     end # context
 
-    context "foo -l ua jp" do
+    context "foo -l UA jP" do
 
-      let(:options) { %w(foo -l ua jp) }
+      let(:options) { %w(foo -l UA jP) }
       before { subject }
 
       it_behaves_like "adding a policy", folder: "policies"

data/spec/tests/lib/policy/follower/name_error_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+describe Policy::Follower::NameError do
+
+  let(:follower) { double :follower }
+  let(:name)     { "foo"            }
+  subject        { described_class.new follower, name }
+
+  describe ".new" do
+
+    it "creates the RuntimeError" do
+      expect(subject).to be_kind_of ::RuntimeError
+    end
+
+  end # describe .new
+
+  describe "#follower" do
+
+    it "is initialized" do
+      expect(subject.follower).to eq follower
+    end
+
+  end # describe #follower
+
+  describe "#name" do
+
+    it "is initialized" do
+      expect(subject.name).to eq name.to_sym
+    end
+
+  end # describe #follower
+
+  describe "#message" do
+
+    it "returns a correct string" do
+      expect(subject.message)
+        .to eq "#{ follower.inspect } hasn't registered the policy \"foo\""
+    end
+
+  end # describe #message
+
+  describe "#inspect" do
+
+    it "returns a correct string" do
+      expect(subject.inspect)
+        .to eq "#<#{ described_class.name }: #{ subject.message }>"
+    end
+
+  end # describe #inspect
+
+end # describe Policy::Follower::NameError

data/spec/tests/lib/policy/follower/policies_spec.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+
+describe Policy::Follower::Policies do
+
+  let(:follower) { double :follower             }
+  subject        { described_class.new follower }
+
+  describe ".new" do
+
+    it "creates the collection" do
+      expect(subject).to be_kind_of Enumerable
+    end
+
+  end # describe .new
+
+  describe "#follower" do
+
+    it "is initialized" do
+      expect(subject.follower).to eq follower
+    end
+
+  end # describe #follower
+
+  describe "#add" do
+
+    it "registers the item" do
+      expect { subject.add "foo" }
+        .to change { subject.map { |item| item } }
+        .from([]).to([:foo])
+    end
+
+    it "registers the item once" do
+      ["foo", :foo, "foo"].each(&subject.method(:add))
+
+      expect(subject.map { |item| item }).to eq [:foo]
+    end
+
+    it "returns itself" do
+      expect(subject.add "foo").to eq subject
+    end
+
+  end # describe #add
+
+  describe "#include?" do
+
+    context "registered name" do
+
+      before { subject.add "foo" }
+
+      it "returns true" do
+        expect(subject.include? :foo).to eq true
+      end
+
+    end # context
+
+    context "unregistered name" do
+
+      it "fails" do
+        expect { subject.include? :foo }
+          .to raise_error Policy::Follower::NameError
+      end
+
+      it "preserves name and follower in the exception" do
+        begin
+          subject.include? :foo
+        rescue => err
+          expect(err.name).to eq :foo
+          expect(err.follower).to eq subject.follower
+        end
+      end
+
+    end # context
+
+  end # describe #include?
+
+  describe "#subset" do
+
+    subject { described_class.new follower }
+    before  { %i(foo bar baz).each(&subject.method(:add)) }
+
+    let(:subset) { subject.subset(names) }
+
+    context "without names" do
+
+      it "returns itself" do
+        expect(subject.subset []).to eq subject
+      end
+
+    end # context
+
+    context "with registered names" do
+
+      let(:names) { %i(baz foo) }
+
+      it "creates a collection" do
+        expect(subset).to be_kind_of described_class
+      end
+
+      it "preserves a follower" do
+        expect(subset.follower).to eq subject.follower
+      end
+
+      it "leaves selected names only" do
+        expect(subset.map { |item| item }).to eq names
+      end
+
+    end # context
+
+    context "with repetitive names" do
+
+      let(:names) { ["baz", :baz, "baz"] }
+
+      it "leaves uniq names only" do
+        expect(subset.map { |item| item }).to eq [:baz]
+      end
+
+    end # context
+
+    context "with non-registered names" do
+
+      let(:names) { %i(baz foo cad) }
+
+      it "fails" do
+        expect { subset }.to raise_error Policy::Follower::NameError
+      end
+
+      it "adds follower and name to the error" do
+        begin
+          subset
+        rescue => err
+          expect(err.name).to eq :cad
+          expect(err.follower).to eq subject.follower
+        end
+      end
+
+    end # context
+
+  end # describe #subset
+
+  describe "#each" do
+
+    it "retuns enumerator" do
+      expect(subject.each).to be_kind_of Enumerator
+    end
+
+    it "iterates through names" do
+      names   = %i(foo bar baz)
+      subject = described_class.new follower
+      names.each(&subject.method(:add))
+
+      expect(subject.map { |item| item }).to eq names
+    end
+
+  end # describe #each
+
+end # describe Policy::Follower::Policies

data/spec/tests/lib/policy/follower/violation_error_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+describe Policy::Follower::ViolationError do
+
+  let(:errors)   { double :errors   }
+  let(:follower) { double :follower }
+  let(:policy)   { double :policy, errors: errors }
+  subject        { described_class.new follower, policy }
+
+  describe ".new" do
+
+    it "creates the RuntimeError" do
+      expect(subject).to be_kind_of ::RuntimeError
+    end
+
+  end # describe .new
+
+  describe "#follower" do
+
+    it "is initialized" do
+      expect(subject.follower).to eq follower
+    end
+
+  end # describe #follower
+
+  describe "#policy" do
+
+    it "is initialized" do
+      expect(subject.policy).to eq policy
+    end
+
+  end # describe #policy
+
+  describe "#errors" do
+
+    it "is initialized" do
+      expect(subject.errors).to eq errors
+    end
+
+  end # describe #errors
+
+  describe "#message" do
+
+    it "returns a correct string" do
+      expect(subject.message)
+        .to eq "#{ follower.inspect } violates the policy #{ policy }"
+    end
+
+  end # describe #message
+
+  describe "#inspect" do
+
+    it "returns a correct string" do
+      expect(subject.inspect)
+        .to eq "#<#{ described_class.name }: #{ subject.message }>"
+    end
+
+  end # describe #inspect
+
+end # describe Policy::Follower::NameError

data/spec/tests/lib/policy/follower_spec.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+
+describe Policy::Follower do
+
+  let(:test_class) { Class.new.send(:include, described_class) }
+  subject          { test_class.new }
+
+  describe ".policies" do
+
+    it "is a collection of policies" do
+      expect(test_class.policies).to be_kind_of Policy::Follower::Policies
+    end
+
+    it "refers to itself" do
+      expect(test_class.policies.follower).to eq test_class
+    end
+
+  end # describe .policies
+
+  describe ".follows_policy" do
+
+    it "adds a name to the collection of policies" do
+      expect(test_class.policies).to receive(:add).with("foo")
+      test_class.follows_policy "foo"
+    end
+
+    it "returns the name of the method" do
+      expect(test_class.follows_policy "foo").to eq :follows_policy
+    end
+
+  end # describe .follows_policy
+
+  describe ".follows_policies" do
+
+    it "adds all names to the collection of policies" do
+      expect(test_class.policies).to receive(:add).with("foo").ordered
+      expect(test_class.policies).to receive(:add).with("bar").ordered
+      test_class.follows_policies "foo", "bar"
+    end
+
+    it "returns the name of the method" do
+      expect(test_class.follows_policies "foo").to eq :follows_policies
+    end
+
+  end # describe .follows_policies
+
+  describe "#follow_policies?" do
+
+    before { test_class.follows_policies :one, :two }
+
+    context "with valid policies" do
+
+      let(:one) { double valid?: true }
+      before    { allow(subject).to receive(:one) { one } }
+
+      it "returns true" do
+        expect(subject.follow_policies? :one).to eq true
+      end
+
+    end # context
+
+    context "with invalid policy's name" do
+
+      let(:one) { double valid?: false, errors: [] }
+      before    { allow(subject).to receive(:one) { one } }
+
+      it "raises ViolationError" do
+        expect { subject.follow_policies? :one }
+          .to raise_error Policy::Follower::ViolationError
+      end
+
+      it "stores both the follower and policy in the exception" do
+        begin
+          subject.follow_policies? :one
+        rescue => exception
+          expect(exception.follower).to eq subject
+          expect(exception.policy).to eq one
+        end
+      end
+
+    end # context
+
+    context "with undefined name" do
+
+      it "raises NoMethodError" do
+        expect { subject.follow_policies? :one }
+          .to raise_error NoMethodError
+      end
+
+    end # context
+
+    context "with unregistered name" do
+
+      it "raises NameError" do
+        expect { subject.follow_policies? :three }
+          .to raise_error Policy::Follower::NameError
+      end
+
+      it "stores both the follower class and name in the exception" do
+        begin
+          subject.follow_policies? :three
+        rescue => exception
+          expect(exception.follower).to eq test_class
+          expect(exception.name).to eq :three
+        end
+      end
+
+    end # context
+
+    context "with a list of names" do
+
+      let(:one) { double valid?: true }
+      let(:two) { double valid?: true }
+
+      before    { allow(subject).to receive(:one) { one } }
+      before    { allow(subject).to receive(:two) { two } }
+
+      it "checks listed policies in given order" do
+        expect(two).to receive(:valid?).ordered
+        expect(one).to receive(:valid?).ordered
+        subject.follow_policies? :two, :one
+      end
+
+    end # context
+
+    context "without names" do
+
+      let(:one) { double valid?: true }
+      let(:two) { double valid?: true }
+
+      before    { allow(subject).to receive(:one) { one } }
+      before    { allow(subject).to receive(:two) { two } }
+
+      it "checks listed policies in predefined order" do
+        expect(one).to receive(:valid?).ordered
+        expect(two).to receive(:valid?).ordered
+        subject.follow_policies? []
+      end
+
+    end # context
+
+  end # describe #follow_policies?
+
+  describe "#follow_policy?" do
+
+    it "is an alias for #follow_policies?" do
+      expect(subject).to receive(:follow_policies?).with "foo"
+      subject.follow_policy? "foo"
+    end
+
+  end # describe #follow_policy?
+
+end # describe Policy::Follower