rcqrs 0.1.0

data/spec/command_executor_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Rcqrs::CommandExecutor do
+  
+  let(:subject){Rcqrs::CommandExecutor}
+  
+  it "reads the eventstore from the configuration" do
+    Rcqrs::Configuration.eventstore = "eventstore"
+    subject.eventbus.instance_eval{|bus| bus.instance_variable_get(:@eventstore).should == "eventstore"}
+  end
+  
+end

data/spec/command_handler_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Rcqrs::CommandSource do
+  
+  before do
+    @commandSource = TestCommandSource.new
+  end
+  
+  it "should find the appropiate command handler and call it" do
+    @commandSource.execute TestCommand.new("Parameter")
+    TestCommandHandler.was_called_with.should == "Parameter"
+  end
+  
+  it "should raise NameError when commandhandler not found" do
+    expect {@commandSource.execute NonExistingCommand.new("Param")}.to raise_error(Rcqrs::CommandHandlerNotFoundError)
+  end
+  
+  it "should raise an Exception if the CommandHandler does not inherit from BaseCommandHandler" do
+    expect {@commandSource.execute DoesNotInheritFromBase.new("Param")}.to raise_error(Rcqrs::CommandHandlerDoesNotInheritFromBaseError)
+  end
+  
+  it "should provide the CommandHandler a repository" do
+    @commandSource.execute TestCommand.new "param"
+    TestCommandHandler.repository.should_not == nil
+  end
+  
+  it "should execute the command handler in a transaction for the eventstore" do
+    @commandSource.execute TestCommand.new "param"
+    TestEventBus.transaction_executed.should == true    
+  end
+  
+end
+
+class DoesNotInheritFromBase
+  
+end
+
+class DoesNotInheritFromBaseHandler 
+  
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Rcqrs::Configuration do
+  let(:subject) {Rcqrs::Configuration}
+  
+  it "allows to configure a eventstore" do
+    subject.configure do |config|
+      subject.eventstore = "eventstore"
+    end
+    subject.eventstore.should == "eventstore"
+  end
+    
+end

data/spec/convention_command_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+
+describe Rcqrs::ConventionCommandHandler do
+  
+  let(:comand_source) {TestCommandSource.new}
+  
+  it "should execute the method on the aggregate defined by the command name" do
+      comand_source.execute(DummyNamespace::TestConventionCommand.new(parameter:"parameter"))
+      DummyNamespace::ConventionAggregate.called.should == true
+  end
+  
+end
+
+module DummyNamespace
+
+  class ConventionAggregate < Rcqrs::AggregateRootBase
+  
+    def test_convention
+      @@called = true
+    end
+    
+    def self.called
+      @@called
+    end
+  end
+  
+  class TestConventionCommand < Rcqrs::ConventionCommand
+      aggregate DummyNamespace::ConventionAggregate
+      attr_reader :parameter
+  end
+  
+end

data/spec/denormalizer_spec.rb

@@ -0,0 +1,107 @@
+describe Rcqrs::Denormalizer do
+  
+  before do
+      @denormalizer = Object.new
+      @denormalizer.extend Rcqrs::Denormalizer    
+  end
+  
+  describe "mapping of hashes" do
+    
+    before do
+      @target = mockup    
+    end
+    
+    it "should allow to map hash values named by symbols to corresponding attributes of target" do
+      @denormalizer.map({name: "thename", age: 21}).to(@target)
+      @target.message(:name=).with("thename").should_be_received
+      @target.message(:age=).with(21).should_be_received
+    end
+    
+    it "should allow to map hash values named by strings to corresponding attributes of the target" do
+      @denormalizer.map({"name" => "thename", "age" => 21}).to(@target)
+      @target.message(:name=).with("thename").should_be_received
+      @target.message(:age=).with(21).should_be_received    
+    end
+    
+    it "should allow to reduce the mapped values to specified keys" do
+      @denormalizer.map({"name" => "thename", "age" => 21}).only([:name]).to(@target)
+      @target.message(:name=).with("thename").should_be_received
+      @target.message(:age=).with(21).times(0).should_be_received          
+    end
+    
+    it "should allow to map values to another hash" do
+      hash_target = Hash.new
+      @denormalizer.map({name: "thename", age: 21}).to(hash_target)
+      hash_target.should == {name: "thename", age: 21}
+    end
+        
+  end
+  
+  
+  describe "with an object as source" do
+
+    before do
+      class Source; attr_accessor :name, :age; end
+      @source = Source.new
+      @target = mockup
+    end
+    
+    it "should allow to map attributes specified by name to an target object" do
+      @source.name = "Bernd"
+      @source.age = 534
+      @denormalizer.map([:name,:age]).from(@source).to(@target)
+      @target.message(:name=).with("Bernd").should_be_received
+      @target.message(:age=).with(534).should_be_received
+    end
+    
+    it "should only map those attributes that are specified" do
+      @source.name = "Bernd"
+      @denormalizer.map([:name]).from(@source).to(@target)
+      @target.message(:name=).with("Bernd").should_be_received
+      @target.message(:age=).never.should_be_received      
+    end
+    
+    it "should allow to map to a hash" do
+      target_hash = Hash.new
+      @source.name = "Bernd"
+      @source.age = 534
+      @denormalizer.map([:name,:age]).from(@source).to(target_hash)
+      target_hash.should == {name: "Bernd", age: 534}
+    end
+    
+  end
+  
+  
+  context "database access" do
+    
+    class DummyReadmodelDatabase     
+      def save(modelname,data)       
+      end
+    end
+    
+    before do
+      @read_model_db = stub(DummyReadmodelDatabase)
+      Rcqrs::Configuration.readmodel_database = @read_model_db
+    end
+    
+    it "redirect all methodcalls to the readmodel_db if the Denormalizer doesnt define it" do
+      @read_model_db.stub!(:save)
+      @denormalizer.save(:model_name,:params)
+      @read_model_db.should have_received(:save).with(:model_name,:params)      
+    end
+    
+    it "if a modelname is specified it is added to the parameterlist of the methodcall" do
+      @denormalizer.model = :model_name
+      @read_model_db.stub!(:save)
+      @denormalizer.save(:params)
+      @read_model_db.should have_received(:save).with(:model_name, :params)      
+    end
+    
+    it "if the readmodel_db doesnt define it normal method missing should raise" do
+      expect{@denormalizer.update(:model_name, "id",{attr:"val"})}.to raise_error
+    end
+    
+  end
+  
+  
+end

data/spec/eventbus_spec.rb

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+describe Rcqrs::Eventbus do
+  
+  before do
+    @id = UUID.generate
+    @mockEventStore = mockup
+    @bus = Rcqrs::Eventbus.new @mockEventStore
+    @eventHandler = mockup
+    @bus.register(EventbusTestevent, @eventHandler)
+    @anotherHandler = mockup
+    @bus.register(EventbusTestevent, @anotherHandler)
+    @testevent = EventbusTestevent.new "Hello happened"
+  end
+  
+  it "publishes Events to multiple Eventhandlers" do
+    @bus.publish @id, @testevent
+    @bus.commit   
+    @eventHandler.message(:handle).times(1).with(@id, @testevent).should_be_received
+    @anotherHandler.message(:handle).times(1).with(@id, @testevent).should_be_received
+  end
+  
+  it "flushes the events after commiting" do
+    @bus.publish @id, @testevent
+    @bus.commit
+    @bus.commit    
+    @eventHandler.message(:handle).times(1).with(@id, @testevent).should_be_received
+    @anotherHandler.message(:handle).times(1).with(@id, @testevent).should_be_received
+  end
+  
+  it "stores the current time as publish time when commiting in the event" do
+    @bus.publish @id, @testevent
+    @bus.commit
+    @testevent.published_at.should be_kind_of Time    
+  end
+  
+  it "shouldnt be able to change the publish time after a commit" do
+    @bus.publish @id, @testevent
+    @bus.commit
+    expect{@testevent.store_publish_time}.to raise_error "Event has allready a publish date"
+  end
+  
+  it "ignores double registrations of eventhandlers" do
+    @bus.register(EventbusTestevent, @eventHandler)
+    @bus.publish @id, @testevent
+    @bus.commit   
+    @eventHandler.message(:handle).times(1).with(@id, @testevent).should_be_received
+  end
+  
+  it "should only publish events to a eventhandler that is interested in events of that type" do
+    yetAnotherHandler = mockup
+    @bus.register(EventbusOtherEvent, yetAnotherHandler)
+    @bus.publish @id, @testevent
+    @bus.commit
+    yetAnotherHandler.message(:handle).times(0).should_be_received
+  end
+  
+  it "events are only published after a commit" do
+    @bus.publish @id, @testevent    
+    @eventHandler.message(:handle).times(0).should_be_received
+    @anotherHandler.message(:handle).times(0).should_be_received
+  end
+  
+  it "should save the events in a eventstore during commit" do
+    @bus.publish @id, @testevent
+    @bus.commit
+    @mockEventStore.message(:store).once.with([Rcqrs::PublishedEvent.new(@id, @testevent)]).should_be_received
+  end
+  
+  it "should reject events not inherited from base event" do
+    expect{ @bus.publish(@id, "no event") }.to raise_error Rcqrs::NotAnEventException
+  end
+  
+  it "should allow to load previous events" do
+    eventstore = Object.new
+    def eventstore.load_events aggregate_id; "events"; end
+    bus = Rcqrs::Eventbus.new eventstore
+    bus.load_events(@id).should == "events"
+  end
+  
+end 
+
+describe "Eventbus without eventhandler" do
+  
+  it "should not throw an error and just save the events" do
+    mockEventStore = mockup
+    bus = Rcqrs::Eventbus.new mockEventStore
+    id = UUID.generate
+    testevent = EventbusTestevent.new "Hello happened"
+    bus.publish id, testevent
+    bus.commit
+    mockEventStore.message(:store).once.with([Rcqrs::PublishedEvent.new(id, testevent)]).should_be_received    
+  end
+  
+end
+
+class EventbusTestevent < Rcqrs::BaseEvent
+  attr_accessor :data
+  
+  def initialize data
+    @data = data
+  end
+end
+
+class EventbusOtherEvent < Rcqrs::BaseEvent
+  def initialize
+    
+  end
+end

data/spec/eventhandler_spec.rb

@@ -0,0 +1,74 @@
+describe Rcqrs::EventHandler do
+  
+  before do 
+    @handler = DummyEventhandler
+    @event = TestEventModule::TestEvent.new
+  end
+  
+  it "should find the appropriate eventhandler method by the eventname" do
+    @handler.handle("aggregate_id",@event)
+    @handler.test_event_handled.should == true 
+  end
+  
+  it "should allow to handle multiple events" do
+    class AnotherTestEvent < Rcqrs::BaseEvent; end
+    @handler.handle("another_id",AnotherTestEvent.new);
+    @handler.another_test_event_handled.should == true
+  end
+  
+  it "should allow to get the names of all handled events" do
+    class ReadingHandledEventsTestHandler
+      include Rcqrs::EventHandler
+      def self.handle_test_event; end
+    end
+    ReadingHandledEventsTestHandler.handled_events.should == ["TestEvent"]
+  end
+  
+  it "should allow to define a eventhandler via a class macro" do
+    @handler.handle("id",TestEventModule::ClassMacroEvent.new)
+    @handler.class_macro_event_handled.should == true
+  end
+  
+  it "should automaticly register the eventhandler in the eventconfiguration" do
+    bus = DummyEventBus.new
+    Rcqrs::EventConfigurationBase.register_all_at bus
+    bus.config.should == {TestEventModule::ClassMacroEvent => DummyEventhandler}
+  end
+      
+end
+
+class DummyEventBus
+  
+  attr_reader :config
+  
+  def initialize
+    @config = Hash.new
+  end
+  
+  def register eventtype,eventhandler
+    @config[eventtype] = eventhandler
+  end
+end 
+
+class DummyEventhandler
+  include Rcqrs::EventHandler
+  
+  namespace TestEventModule
+  
+  class << self
+    attr_reader :test_event_handled, :another_test_event_handled, :class_macro_event_handled    
+  end
+  
+  def self.handle_test_event aggregate_id, event
+    @test_event_handled = true
+  end
+  
+  def self.handle_another_test_event aggregate_id, event
+    @another_test_event_handled = true
+  end
+  
+  handler :class_macro_event do |aggregate_id, event|
+    @class_macro_event_handled = true
+  end
+  
+end

data/spec/repository_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Rcqrs::Repository, "when Aggregates are loaded" do
+  
+  before do
+    @aggregate_id = UUID.generate
+    @mockEventStore = mock("EventStore")
+    @events = [TestEventModule::TestEvent.new,TestEventModule::TestEvent.new]
+    @mockEventStore.should_receive(:load_events).with(@aggregate_id).and_return(@events)
+    @repo = Rcqrs::Repository.new @mockEventStore    
+  end
+  
+  it "should return an instance of the given Aggregate-Type to load" do
+    loaded_aggregate = @repo.load TestAggregateModule::TestAggregate, @aggregate_id
+    loaded_aggregate.should be_an_instance_of TestAggregateModule::TestAggregate
+  end
+  
+  it "the returned aggregate should be initialized with stored events" do
+    loaded_aggregate = @repo.load TestAggregateModule::TestAggregate, @aggregate_id
+    loaded_aggregate.handledEvents[0].should == @events[0]
+    loaded_aggregate.handledEvents[1].should == @events[1]    
+  end
+  
+  it "should only load the events for the aggregateroot with the given id" do
+    otherEvents = [TestEventModule::TestEvent.new]
+    @mockEventStore.stub!(:load_events).and_return(otherEvents)
+    loaded_aggregate = @repo.load TestAggregateModule::TestAggregate, @aggregate_id
+    loaded_aggregate.handledEvents.size.should == 2
+  end
+  
+end
+
+
+describe Rcqrs::Repository, "when Aggregateroots are saved" do
+  
+  before do
+    @aggregate_id = UUID.generate
+    @testaggregate = TestAggregateModule::TestAggregate.new @aggregate_id
+    @mockEventStore = mock("Eventbus")
+    @repo = Rcqrs::Repository.new @mockEventStore    
+  end
+  
+  it "should save all the pending events of the aggregateroot" do
+    @mockEventStore.should_receive(:publish).with(@aggregate_id, an_instance_of(TestEventModule::TestEvent))
+    @testaggregate.doSomething
+    @repo.save @testaggregate
+  end
+  
+end
+
+describe Rcqrs::Repository do
+  
+    before do
+      @aggregate_id = UUID.generate
+      @testaggregate = TestAggregateModule::TestAggregate.new @aggregate_id
+      @mockEventStore = mock("Eventbus")
+      @repo = Rcqrs::Repository.new @mockEventStore    
+    end
+  
+    it "should allow to fire domainevents directly" do
+      repoTestEvent = RepoTestEvent.new
+      @mockEventStore.should_receive(:publish).with(@aggregate_id,repoTestEvent)
+      @repo.fire(@aggregate_id, repoTestEvent)
+    end
+    
+    it "should reject events not inherited from base event" do
+      expect{ @repo.fire(@aggregate_id,"no Event") }.to raise_error(Rcqrs::NotAnEventException)
+    end
+    
+end
+
+class RepoTestEvent < Rcqrs::BaseEvent
+  
+end
+