# 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