informator 0.1.0 → 1.0.0

data/spec/unit/informator/reporter_spec.rb

@@ -1,75 +0,0 @@
-# encoding: utf-8
-
-describe Informator::Reporter do
-
-  subject(:reporter) { described_class.new }
-
-  describe ".new" do
-
-    it { is_expected.to be_frozen }
-
-  end # describe .new
-
-  describe "#events" do
-
-    subject { reporter.events }
-    it { is_expected.to eql [] }
-
-  end # describe #events
-
-  describe "#remember" do
-
-    subject { reporter.remember(*options) }
-
-    let(:options) { [:foo, "bar", baz: :qux] }
-    let(:event)   { Informator::Event.new(*options) }
-
-    it "builds the event and adds it to #events" do
-      expect { subject }.to change { reporter.events }.by [event]
-    end
-
-    it { is_expected.to eql reporter }
-
-  end # describe #remember
-
-  describe "#notify" do
-
-    subject { reporter.notify(subscribers) }
-
-    let(:subscribers) { 2.times.map { double notify: nil } }
-    let!(:events) do
-      %i(foo bar).each(&reporter.method(:remember))
-      reporter.events.dup
-    end
-
-    it "notifies every subscriber on all #events" do
-      events.each do |event|
-        subscribers.each do |subscriber|
-          expect(subscriber).to receive(:notify).with(event).ordered
-        end
-      end
-
-      subject
-    end
-
-    it "clears #events" do
-      expect { subject }.to change { reporter.events }.to []
-    end
-
-    context "when error occured while publishing" do
-
-      before { allow(subscribers.first).to receive(:notify) { fail } }
-
-      it "removes tried #events" do
-        expect { subject rescue nil }
-          .to change { reporter.events }
-          .to [events.last]
-      end
-
-    end # context
-
-    it { is_expected.to eql events }
-
-  end # describe #notify
-
-end # describe Informator::Reporter

data/spec/unit/informator_spec.rb

@@ -1,153 +0,0 @@
-# encoding: utf-8
-
-describe Informator do
-
-  subject(:informator) { klass.new }
-
-  let(:klass)    { Class.new { include Informator } }
-  let(:callback) { :on_received }
-  let(:listener) do
-    double(
-      callback => nil,
-      foo: nil,
-      bar: nil,
-      receive: nil,
-      freeze: nil
-    )
-  end
-
-  before { informator.subscribe listener, callback }
-
-  describe "#subscribe" do
-
-    it "subscribes listeners one-by-one" do
-      informator.subscribe(listener, :foo).subscribe(listener, :bar)
-
-      expect(listener).to receive(callback).ordered
-      expect(listener).to receive(:foo).ordered
-      expect(listener).to receive(:bar).ordered
-      informator.publish :info
-    end
-
-    it "doesn't duplicate listener's callbacks" do
-      informator.subscribe(listener, callback)
-
-      expect(listener).to receive(callback).once
-      informator.publish :info
-    end
-
-    it "subscribes listener with :receive callback by default" do
-      informator.subscribe(listener)
-
-      expect(listener).to receive(:receive)
-      informator.publish :info
-    end
-
-  end # describe #subscribe
-
-  describe "#remember" do
-
-    it "keeps remembered events unpublished" do
-      expect(listener).not_to receive(callback)
-
-      informator.remember :info
-    end
-
-    it "remembers events until publishing" do
-      expect(listener).to receive(callback).once
-
-      informator.remember :info
-      informator.publish
-    end
-
-    it "returns itself to allow chaining" do
-      expect(informator.remember(:info).remember(:alert)).to eql informator
-    end
-
-  end # describe #remember
-
-  describe "#publish" do
-
-    it "publishes events" do
-      expect(listener).to receive(callback) do |event|
-        expect(event).to be_kind_of Informator::Event
-        expect(event.type).to eq :alert
-        expect(event.messages).to eql %w(foo)
-        expect(event.attributes).to eql(bar: :baz)
-      end
-
-      informator.publish :alert, "foo", bar: :baz
-    end
-
-    it "publishes all remembered events at once" do
-      expect(listener).to receive(callback).twice
-
-      informator.remember :info
-      informator.publish  :alert
-    end
-
-    it "can publish only remembered events without a new one" do
-      expect(listener).to receive(callback).once
-
-      informator.remember :info
-      informator.publish
-    end
-
-    it "returns events having been published" do
-      informator.remember :info
-      events = informator.publish :alert
-
-      expect(events).to be_kind_of Array
-      expect(events.map(&:class).uniq).to contain_exactly Informator::Event
-      expect(events.map(&:type)).to eql [:info, :alert]
-    end
-
-    it "forgets published events" do
-      informator.publish :info
-      expect(listener).not_to receive(callback)
-
-      informator.publish
-    end
-
-  end # describe #publish
-
-  describe "#publish!" do
-
-    it "publishes all remembered events at once" do
-      expect(listener).to receive(callback).twice
-
-      informator.remember :info
-      informator.publish!(:alert) rescue nil
-    end
-
-    it "can publish only remembered events without a new one" do
-      expect(listener).to receive(callback).once
-
-      informator.remember :info
-      informator.publish! rescue nil
-    end
-
-    it "forgets published events" do
-      informator.publish! :info rescue nil
-      expect(listener).not_to receive(callback)
-
-      informator.publish
-    end
-
-    it "throws :published" do
-      expect { informator.publish! }.to raise_error(ArgumentError)
-      expect { catch(:published) { informator.publish! } }.not_to raise_error
-    end
-
-    it "throws events having been published" do
-      informator.remember :info
-      events = catch(:published) { informator.publish! :alert }
-
-      expect(events).to be_kind_of Array
-      expect(events.map(&:class).uniq).to contain_exactly Informator::Event
-      expect(events.map(&:type)).to eql [:info, :alert]
-    end
-
-  end # describe #publish!
-
-end # describe Informator