event_sourcing 0.0.2

data/spec/unit/aggregate/actor_spec.rb

@@ -0,0 +1,59 @@
+require "unit_helper"
+require "event_sourcing/aggregate/actor"
+
+describe EventSourcing::Aggregate::Actor do
+  context "for()" do
+    let(:aggregate) { double("Aggregate class", new: true) }
+
+    subject do
+      EventSourcing::Aggregate::Actor.for(aggregate)
+    end
+
+    it "returns an actor" do
+      expect(subject < Concurrent::Actor::RestartingContext).to be_truthy
+    end
+  end
+
+  context "instance" do
+    subject { actor }
+    let(:aggregate_class) { double("Aggregate class", new: aggregate_instance, instance_methods: [:publish])}
+    let(:aggregate_instance) { double("Aggregate instance", publish: :published)}
+    let(:event_stream) { instance_double("EventSourcing::Event::Stream") }
+    let(:event_bus)    { instance_double("EventSourcing::Event::Bus::Reference") }
+    let(:actor) { EventSourcing::Aggregate::Actor.for(aggregate_class).new(event_bus, event_stream) }
+
+    before do
+      allow(aggregate_instance).to receive(:_apply).with(:published)
+      allow(event_bus).to receive(:publish)
+      allow(event_stream).to receive(:append)
+    end
+    
+    context "when receiving supported messages" do
+      after do
+        subject.on_message([:publish, :some_arg])
+      end
+
+      it "stores the events using the stream" do
+        expect(event_stream).to receive(:append).with(:published)
+      end
+
+      it "delegates on aggregate and publishes events" do
+        expect(event_bus).to receive(:publish).with(:published)
+      end
+
+      it "gets events applied" do
+        expect(aggregate_instance).to receive(:_apply).with(:published)
+      end   
+    end
+
+    context "when receiving unsupported messages" do
+      after do
+        subject.on_message([:fake])
+      end
+
+      it "does nothing" do
+        expect(event_bus).not_to receive(:publish)
+      end
+    end
+  end
+end

data/spec/unit/aggregate/manager/cache_spec.rb

@@ -0,0 +1,26 @@
+require "unit_helper"
+require "event_sourcing/aggregate/manager/cache"
+
+describe EventSourcing::Aggregate::Manager::Cache do
+  subject { EventSourcing::Aggregate::Manager::Cache.new(event_bus) }
+
+  let(:aggregate) { Class.new }
+  let(:actor)     { double("Actor")}
+  let(:instance)  { double("Aggregate instance") }
+  let(:event_bus) { instance_double("EventSourcing::Event::Bus::Reference") }
+  let(:event_stream) { double("Event stream") }
+
+  before do
+    allow(event_bus).to receive(:get_stream).with("some-id").and_return(event_stream)
+    aggregate.const_set("Actor", actor)
+    allow(actor).to receive(:spawn!).once.with(name: "some-id", args: [event_bus, event_stream], supervise: true).and_return(instance)
+  end
+
+  it "returns instances" do
+    expect(subject.instance_of(aggregate, "some-id")).to eq(instance)
+  end
+  
+  it "memoizes instances" do
+    expect(subject.instance_of(aggregate, "some-id")).to eq(subject.instance_of(aggregate, "some-id"))
+  end
+end

data/spec/unit/aggregate/manager/reference_spec.rb

@@ -0,0 +1,14 @@
+require "unit_helper"
+require "event_sourcing/aggregate/manager/reference"
+
+describe EventSourcing::Aggregate::Manager::Reference do
+  context "instance_of" do
+    let(:aggregate) { double("Aggregate") }
+    let(:wrapper)  { EventSourcing::Aggregate::Wrapper.new(subject, aggregate, "some-id") }
+    subject { EventSourcing::Aggregate::Manager::Reference.new(instance_double("Concurrent::Actor::Core", is_a?: true)) }
+
+    it "returns a wrapper" do
+      expect(subject.instance_of(aggregate, "some-id")).to eq(wrapper)
+    end
+  end
+end

data/spec/unit/aggregate/manager_spec.rb

@@ -0,0 +1,32 @@
+require "unit_helper"
+require "event_sourcing/aggregate/manager"
+
+describe EventSourcing::Aggregate::Manager do
+  it "is a restarting actor" do
+    expect(EventSourcing::Aggregate::Manager.ancestors).to include(Concurrent::Actor::RestartingContext)
+  end
+
+  context "on message of kind Aggregate::Message" do
+    let(:aggregate) { double("Aggregate") }
+    let(:instance)  { double("Aggregate instance") }
+    let(:cache_class) { class_double("EventSourcing::Aggregate::Manager::Cache").as_stubbed_const }
+    let(:cache_instance) { instance_double("EventSourcing::Aggregate::Manager::Cache") }
+    let(:manager) { EventSourcing::Aggregate::Manager.new(event_bus) }
+    let(:event_bus) { double("EventSourcing::Event::Bus::Reference") }
+    let(:wrapped_message) { EventSourcing::Aggregate::Message.new(aggregate, "some-id", actual_message) }
+    let(:actual_message) { :publish }
+
+    before do
+      allow(cache_class).to receive(:new).with(event_bus).once.and_return(cache_instance)
+      allow(cache_instance).to receive(:instance_of).with(aggregate, "some-id").and_return(instance)
+    end
+
+    after do
+      manager.on_message(wrapped_message)
+    end
+
+    it "redirects the message to the aggregate actor" do
+      expect(instance).to receive(:tell).with(actual_message)
+    end
+  end
+end

data/spec/unit/aggregate/wrapper_spec.rb

@@ -0,0 +1,22 @@
+require "unit_helper"
+require "event_sourcing/aggregate/wrapper"
+
+describe EventSourcing::Aggregate::Wrapper do
+  let(:manager) { instance_double("EventSourcing::Aggregate::Manager::Reference") }
+  let(:wrapper) { EventSourcing::Aggregate::Wrapper.new(manager, aggregate, "some-id") }
+  let(:aggregate) do
+    Class.new do
+      def publish
+        :stuff
+      end
+    end
+  end
+
+  context "when is sent a message using tell" do
+    after { wrapper.publish }
+
+    it "routes it through the manager" do
+      expect(manager).to receive(:tell).with(EventSourcing::Aggregate::Message.new(aggregate, "some-id", [:publish]))
+    end
+  end
+end

data/spec/unit/aggregate_spec.rb

@@ -0,0 +1,75 @@
+require "unit_helper"
+require "event_sourcing/aggregate"
+
+describe EventSourcing::Aggregate do
+  context "once included" do
+
+    let(:actor_class)     { class_double("EventSourcing::Aggregate::Actor") }
+    let(:aggregate_class) { Class.new }
+    let(:aggregate_actor) { double("Aggregate actor") }
+
+    before do
+      stub_const("EventSourcing::Aggregate::Actor", actor_class)
+      allow(actor_class).to receive(:for).with(aggregate_class).and_return(aggregate_actor)
+    end
+    
+    subject do
+      aggregate_class.class_eval do
+        include EventSourcing::Aggregate
+      end
+    end
+
+    it "defines an actor" do
+      expect(subject::Actor).to eq(aggregate_actor)
+    end
+  end
+
+  context "when it has defined handlers" do
+
+
+    let(:event) { instance_double("EventSourcing::Event", to_s: "SomethingHappened") }
+
+    let(:aggregate_class) do
+      Class.new do
+        include EventSourcing::Aggregate
+
+        def do_something
+          :did_something unless @something_happened
+        end
+
+        handle "SomethingHappened" do |e|
+          @something_happened = true
+        end
+      end
+    end
+
+    let(:clean_aggregate) { aggregate_class.new() }
+    let(:aggregate_with_events) { aggregate_class.new([event]) }
+
+    it "can be initialized without an event stream" do
+      expect(clean_aggregate.do_something).to eq(:did_something)
+    end
+
+    it "can be initialized with an event stream" do
+      expect(aggregate_with_events.do_something).to be_nil
+    end
+
+    it "can have events applied to it" do
+      clean_aggregate._apply(event)
+      expect(clean_aggregate.do_something).to be_nil
+    end
+
+
+    context "with unsupported events" do
+      let(:unsupported_event) { instance_double("EventSourcing::Event", to_s: "WrongEvent") }
+
+      it "fails when initialized with unsupported events" do
+        expect { aggregate_class.new([unsupported_event])}.to raise_error(RuntimeError, "unsupported event WrongEvent")
+      end
+
+      it "fails when unsupported events are applied" do
+        expect { aggregate_class.new._apply(unsupported_event) }.to raise_error(RuntimeError, "unsupported event WrongEvent")
+      end
+    end
+  end
+end

data/spec/unit/application/actor/reference_spec.rb

@@ -0,0 +1,25 @@
+require "unit_helper"
+require "event_sourcing/application/actor/reference"
+
+describe EventSourcing::Application::Actor::Reference do
+  subject { EventSourcing::Application::Actor::Reference.new(instance_double("Concurrent::Actor::Core", is_a?: true)) }
+  context "terminate!" do
+    after { subject.terminate! }
+
+    it "tells the actor to terminate" do
+      expect(subject).to receive(:tell).with(:terminate!)
+    end
+  end
+
+  context "execute_command" do
+    let(:command)     { double("Command") }
+    let(:command_bus) { double("Command bus") }
+    
+    after  { subject.execute_command(command) }
+    before { allow(subject).to receive(:ask!).with(:get_command_bus).once.and_return(command_bus) }
+
+    it "delegates on the command bus" do
+      expect(command_bus).to receive(:tell).with(command)
+    end
+  end
+end

data/spec/unit/application/actor_spec.rb

@@ -0,0 +1,36 @@
+require "unit_helper"
+require "event_sourcing/application/actor"
+
+describe EventSourcing::Application::Actor do
+  subject { EventSourcing::Application::Actor.new(event_store) }
+
+  let(:event_store)     { instance_double("EventSourcing::Event::Store::Memory") }
+  let(:command_bus)     { class_double("EventSourcing::Command::Bus").as_stubbed_const(transfer_nested_constants: true) }
+  let(:command_bus_ref) { double("EventSourcing::Command::Bus::Reference") }
+  let(:event_bus)       { class_double("EventSourcing::Event::Bus").as_stubbed_const(transfer_nested_constants: true) }
+  let(:event_bus_ref)   { double("EventSourcing::Event::Bus::Reference") }
+  let(:aggregate_manager)       { class_double("EventSourcing::Aggregate::Manager").as_stubbed_const(transfer_nested_constants: true) }
+  let(:aggregate_manager_ref)   { instance_double("EventSourcing::Aggregate::Manager::Reference") }
+
+  before do
+    allow(command_bus).to receive(:spawn!).with(name: :command_bus, supervise: true, args: [aggregate_manager_ref]).and_return(command_bus_ref)
+    allow(event_bus).to receive(:spawn!).with(name: :event_bus, supervise: true, args: [event_store]).and_return(event_bus_ref)
+    allow(aggregate_manager).to receive(:spawn!).with(name: :aggregate_manager, supervise: true, args: [event_bus_ref]).and_return(aggregate_manager_ref)
+  end
+
+  it "uses Actor::Reference internally" do
+    expect(EventSourcing::Application::Actor.new(event_store).default_reference_class).to eq(EventSourcing::Application::Actor::Reference)
+  end
+
+  it "supervises and returns a command bus" do
+    expect(subject.on_message(:get_command_bus)).to eq(command_bus_ref)
+  end
+
+  it "supervises and returns an event bus" do
+    expect(subject.on_message(:get_event_bus)).to eq(event_bus_ref)
+  end
+
+  it "supervises and returns an event bus" do
+    expect(subject.on_message(:get_aggregate_manager)).to eq(aggregate_manager_ref)
+  end  
+end

data/spec/unit/application_spec.rb

@@ -0,0 +1,41 @@
+require "unit_helper"
+require "event_sourcing/application"
+
+describe EventSourcing::Application do
+  let(:sample_app) { EventSourcing::Application.new(:sample_app) }
+
+  it "can be inspected" do
+    expect(sample_app.inspect).to eq("EventSourcing::Application(sample_app)")
+  end
+
+  context "while running" do
+    subject { running_app }
+
+    let(:running_app) { sample_app.run!(event_store: event_store) }
+    let(:event_store) { instance_double("EventSourcing::Event::Store::Memory") }
+    #FIXME Remove to_str. It's only needed for specs to pass under jruby
+    let(:actor_class) { class_double("EventSourcing::Application::Actor", to_str: "EventSourcing::Application::Actor").as_stubbed_const(transfer_nested_constants: true) }
+    let(:actor_reference) { instance_double("EventSourcing::Application::Actor::Reference") }
+
+    before do
+      allow(actor_class).to receive(:spawn!).with(name: :sample_app, args: [event_store]).and_return(actor_reference)
+    end
+
+    context "shutdown" do
+      after { subject.shutdown }
+
+      it "terminates the application actor" do
+        expect(actor_reference).to receive(:terminate!)
+      end
+    end
+
+    context "execute command" do
+      let(:command) { double("Command") }
+      after { subject.execute_command(command)}
+
+      it "delegates on the application actor" do
+        expect(actor_reference).to receive(:execute_command).with(command)
+      end
+    end
+  end
+end

data/spec/unit/command/bus_spec.rb

@@ -0,0 +1,15 @@
+require "unit_helper"
+require "event_sourcing/command/bus"
+
+describe EventSourcing::Command::Bus do
+  let(:aggregate_manager) { instance_double("EventSourcing::Aggregate::Manager::Reference") }
+  let(:command) { double("EventSourcing::Command") }
+
+  subject { EventSourcing::Command::Bus.new(aggregate_manager) }
+
+  after { subject.on_message(command) }
+
+  it "executes commands" do
+    expect(command).to receive(:execute).with(aggregate_manager)
+  end
+end

data/spec/unit/command_spec.rb

@@ -0,0 +1,38 @@
+require "unit_helper"
+require "event_sourcing/command"
+
+describe EventSourcing::Command do
+  it "expects a block" do
+    expect { EventSourcing::Command.define }.to raise_error("Commands require an execution block")
+  end
+
+  it "can't be directly instantiated" do
+    expect { EventSourcing::Command.new }.to raise_error(NoMethodError)
+  end
+
+  context "instance" do
+    subject { EventSourcing::Command.define {} }
+
+    it "is a EventSourcing::Command" do
+      expect(subject.new).to be_a(EventSourcing::Command)
+    end
+  end
+
+  context "with required parameters" do
+    subject { EventSourcing::Command.define(:title) {} }
+
+    it "can't be instantiated if those are not provided" do
+      expect { subject.new }.to raise_error(ArgumentError, "missing keyword: title")
+    end
+  end
+
+  context "execute" do
+    let(:dependency) { double("Dependency", value: 42)}
+    let(:command)    { EventSourcing::Command.define(:prop) { |dep| "returning #{dep.value} and #{prop}"} }
+    subject { command.new(prop: "own_stuff") }    
+
+    it "runs the passed block under the current command context" do
+      expect(subject.execute(dependency)).to eq("returning 42 and own_stuff")
+    end
+  end
+end

data/spec/unit/event/bus/reference_spec.rb

@@ -0,0 +1,48 @@
+require "unit_helper"
+require "event_sourcing/event/bus/reference"
+
+describe EventSourcing::Event::Bus::Reference do
+  let(:bus_ref) { actor_reference(EventSourcing::Event::Bus::Reference) }
+  let(:stream) { instance_double("EventSourcing::Event::Stream") }
+
+  context "get_stream" do
+    let(:store) { instance_double("EventSourcing::Event::Store::Memory") }
+
+    before do
+      allow(bus_ref).to receive(:ask!).once.with(:get_event_store).and_return(store)
+      allow(store).to receive(:get_stream).with("some-id").and_return(stream)
+    end
+
+    it "returns a stream from the event store" do
+      expect(bus_ref.get_stream("some-id")).to eq(stream)
+    end
+
+    it "memoizes the store" do
+      expect(bus_ref.get_stream("some-id")).to eq(bus_ref.get_stream("some-id"))
+    end
+  end
+
+  context "publish" do
+    after { bus_ref.publish(event) }
+
+    before do
+      allow(bus_ref).to receive(:ask!).with(:get_event_publisher).and_return(publisher)
+    end
+
+    let(:event) { instance_double("EventSourcing::Event") }
+    let(:publisher) { double("Publisher ref") }
+
+    it "delegates on the memoized bus publisher" do
+      expect(publisher).to receive(:publish).with(event)
+    end
+
+    context "multiple times" do
+      after { bus_ref.publish(:event) }
+      before { allow(publisher).to receive(:publish) }
+
+      it "memoizes the publisher reference" do
+        expect(bus_ref).to receive(:ask!).once.with(:get_event_publisher).and_return(publisher)
+      end
+    end
+  end
+end