entity_store 0.0.2

data/lib/entity_store.rb

@@ -0,0 +1,61 @@
+module EntityStore
+  require 'logger'
+  require 'entity_store/entity'
+  require 'entity_store/entity_value'
+  require 'entity_store/event'
+  require 'entity_store/store'
+  require 'entity_store/external_store'
+  require 'entity_store/event_data_object'
+  require 'entity_store/mongo_entity_store'
+  require 'entity_store/event_bus'
+  require 'entity_store/not_found'
+
+  class << self
+    def setup
+      yield self
+    end
+    
+    def connection_profile
+      @_connection_profile
+    end
+
+    def connection_profile=(value)
+      @_connection_profile = value
+    end
+
+    def external_connection_profile
+      @_external_connection_profile
+    end
+
+    def external_connection_profile=(value)
+      @_external_connection_profile = value
+    end
+    
+    def event_subscribers
+      @_event_subscribers ||=[]
+    end
+    
+    def log_level
+      @_log_level ||= Logger::INFO
+    end
+    
+    def log_level=(value)
+      @_log_level = value
+    end
+    
+    def logger
+      unless @_logger
+        @_logger = Logger.new(STDOUT)
+        @_logger.progname = "Entity_Store"
+        @_logger.level = log_level
+      end
+      @_logger
+    end
+    
+    def logger=(value)
+      @_logger = value
+    end
+  end
+
+
+end

data/lib/entity_store/entity.rb

@@ -0,0 +1,31 @@
+module EntityStore
+  module Entity
+    attr_accessor :id
+    attr_writer :version
+
+    def initialize(attr={})
+      attr.each_pair { |k,v| self.send("#{k}=", v) }
+    end
+    
+    def type
+      self.class.name
+    end
+  
+    def version
+      @version ||= 1
+    end
+  
+    def pending_events
+      @pending_events ||= []
+    end
+  
+    def record_event(event)
+      apply_event(event)
+      pending_events<<event
+    end
+  
+    def apply_event(event)
+      event.apply(self)
+    end
+  end
+end

data/lib/entity_store/entity_value.rb

@@ -0,0 +1,36 @@
+module EntityStore
+  module EntityValue
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    def initialize(attr={})
+      attr.each_pair { |k,v| self.send("#{k}=", v) if self.respond_to? "#{k}=" }
+    end
+
+    def attributes
+      Hash[*public_methods.select {|m| m =~ /\w\=$/}.collect do |m|
+        attribute_name = m.to_s.chop.to_sym
+        [attribute_name, send(attribute_name).respond_to?(:attributes) ? send(attribute_name).attributes : send(attribute_name)]
+      end.flatten]
+    end
+
+    def ==(other)
+      attributes.each_key do |attr|
+        return false unless other.respond_to?(attr) && send(attr) == other.send(attr)
+      end
+      return true
+    end
+
+    module ClassMethods
+      def entity_value_attribute(name, klass)
+        define_method(name) { instance_variable_get("@#{name}") }
+        define_method("#{name}=") do |value|
+          instance_variable_set("@#{name}", value.is_a?(Hash) ? klass.new(value) : value)
+        end
+      end
+    end
+  end
+end

data/lib/entity_store/event.rb

@@ -0,0 +1,56 @@
+module EntityStore
+  module Event
+    attr_accessor :entity_id
+    
+    def initialize(attrs={})
+      attrs.each_pair do |key, value|         
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+    
+    def receiver_name
+      elements = self.class.name.split('::')
+      elements[elements.count - 1].
+         gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+         gsub(/([a-z\d])([A-Z])/,'\1_\2').
+         tr("-", "_").
+         downcase
+    end
+    
+    def attributes
+      Hash[*public_methods.select {|m| m =~ /\w\=$/}.collect do |m|
+        attribute_name = m.to_s.chop.to_sym
+        [attribute_name, send(attribute_name).respond_to?(:attributes) ? send(attribute_name).attributes : send(attribute_name)]
+      end.flatten]
+    end
+    
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+      end
+    end
+    
+    module ClassMethods
+      def time_attribute(*names)
+        class_eval do
+          names.each do |name|
+            define_method "#{name}=" do |value|
+              require 'time'
+              instance_variable_set("@#{name}", value.kind_of?(String) ? Time.parse(value) : value)
+            end
+            define_method name do
+              instance_variable_get "@#{name}"
+            end
+          end
+        end
+      end
+      
+      def entity_value_attribute(name, klass)
+        define_method(name) { instance_variable_get("@#{name}") }
+        define_method("#{name}=") do |value|
+          instance_variable_set("@#{name}", value.is_a?(Hash) ? klass.new(value) : value)
+        end
+      end
+    end
+  end
+end

data/lib/entity_store/event_bus.rb

@@ -0,0 +1,34 @@
+module EntityStore
+  class EventBus
+    class << self
+      def publish(entity_type, event)
+        publish_externally entity_type, event
+        
+        subscribers_to(event.receiver_name).each do |s|
+          begin
+            s.new.send(event.receiver_name, event)
+            EntityStore.logger.debug { "called #{s.name}##{event.receiver_name} with #{event.inspect}" }
+          rescue => e
+            EntityStore.logger.error { "#{e.message} when calling #{s.name}##{event.receiver_name} with #{event.inspect}" }
+          end
+        end
+      end
+
+      def subscribers_to(event_name)
+        subscribers.select { |s| s.instance_methods.include?(event_name.to_sym) }
+      end
+            
+      def subscribers
+        EntityStore.event_subscribers
+      end
+      
+      def publish_externally(entity_type, event)
+        external_store.add_event(entity_type, event)
+      end
+      
+      def external_store
+        @_external_store ||= ExternalStore.new
+      end
+    end
+  end
+end

data/lib/entity_store/event_data_object.rb

@@ -0,0 +1,25 @@
+module EntityStore
+  class EventDataObject
+    attr_reader :attrs
+    
+    def initialize(attrs={})
+      @attrs = attrs
+    end
+    
+    def id
+      attrs['_id']
+    end
+    
+    def entity_type
+      attrs['_entity_type']
+    end
+    
+    def type
+      attrs['_type']
+    end
+    
+    def [](key)
+      attrs[key]
+    end
+  end
+end

data/lib/entity_store/external_store.rb

@@ -0,0 +1,44 @@
+require 'mongo'
+require 'uri'
+
+module EntityStore
+  class ExternalStore
+    include Mongo
+    
+    def open_connection
+      @db ||= open_store
+    end
+    
+    def open_store
+      uri  = URI.parse(EntityStore.external_connection_profile)
+      Connection.from_uri(EntityStore.external_connection_profile).db(uri.path.gsub(/^\//, ''))
+    end
+    
+    def collection
+      @_collection ||= open_connection['events']
+    end
+    
+    def ensure_indexes
+      collection.ensure_index([['_type', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]])      
+    end
+    
+    def add_event(entity_type, event)
+      collection.insert({
+        '_entity_type' => entity_type, '_type' => event.class.name 
+        }.merge(event.attributes)
+      )
+    end
+    
+    def get_events(opts={})
+      query = {}
+      query['_id'] = { '$gt' => opts[:after] } if opts[:after]
+      query['_type'] = opts[:type] if opts[:type]
+      
+      options = {:sort => [['_id', -1]]}
+      options[:limit] = opts[:limit] || 100
+      
+      collection.find(query, options).collect { |e| EventDataObject.new(e)}
+    end
+    
+  end
+end

data/lib/entity_store/mongo_entity_store.rb

@@ -0,0 +1,86 @@
+require 'mongo'
+require 'uri'
+
+module EntityStore
+  class MongoEntityStore
+    include Mongo
+
+    def open_connection
+      @db ||= open_store
+    end
+
+    def open_store
+      uri  = URI.parse(EntityStore.connection_profile)
+      connection = Connection.from_uri(EntityStore.connection_profile, :connecttimeoutms => connect_timeout)
+      connection.db(uri.path.gsub(/^\//, ''))
+    end
+
+    def connect_timeout
+      ENV['ENTITY_STORE_CONNECT_TIMEOUT'] || '2000'
+    end
+
+    def entities
+      @entities_collection ||= open_connection['entities']
+    end
+
+    def events
+      @events_collection ||= open_connection['entity_events']
+    end
+
+    def ensure_indexes
+      events_collection.ensure_index([['entity_id', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]])
+    end
+
+    def add_entity(entity)
+      entities.insert('_type' => entity.class.name, 'version' => entity.version).to_s
+    end
+
+    def save_entity(entity)
+      entities.update({'_id' => BSON::ObjectId.from_string(entity.id)}, { '$set' => { 'version' => entity.version } })
+    end
+
+    def add_event(event)
+      events.insert({'_type' => event.class.name, '_entity_id' => BSON::ObjectId.from_string(event.entity_id) }.merge(event.attributes) ).to_s
+    end
+
+    def get_entity!(id)
+      get_entity(id, true)
+    end
+
+    def get_entity(id, raise_exception=false)
+      begin
+        if attrs = entities.find('_id' => BSON::ObjectId.from_string(id)).first
+          get_type_constant(attrs['_type']).new('id' => id, 'version' => attrs['version'])
+        else
+          if raise_exception
+            raise NotFound.new(id)
+          else
+            return nil
+          end
+        end
+      rescue BSON::InvalidObjectId
+        if raise_exception
+          raise NotFound.new(id)
+        else
+          return nil
+        end
+      end
+    end
+
+    def get_events(id)
+      events.find('_entity_id' => BSON::ObjectId.from_string(id)).collect do |attrs|
+        begin
+          get_type_constant(attrs['_type']).new(attrs)
+        rescue => e
+          logger = Logger.new(STDERR)
+          logger.error "Error loading type #{attrs['_type']}"
+          nil
+        end
+      end.select { |e| !e.nil? }
+    end
+
+    def get_type_constant(type_name)
+      type_name.split('::').inject(Object) {|obj, name| obj.const_get(name) }
+    end
+  end
+end

data/lib/entity_store/not_found.rb

@@ -0,0 +1,7 @@
+module EntityStore
+  class NotFound < StandardError
+    def initialise(id)
+      super("no item with id #{id} could be found")
+    end
+  end
+end

data/lib/entity_store/store.rb

@@ -0,0 +1,56 @@
+module EntityStore
+  class Store
+    def storage_client
+      @storage_client || MongoEntityStore.new
+    end
+    
+    def add(entity)      
+      entity.id = storage_client.add_entity(entity)  
+      add_events(entity)
+      return entity
+    rescue => e
+      EntityStore.logger.error { "Store#add error: #{e.inspect} - #{entity.inspect}" }
+      raise e
+    end
+    
+    def save(entity)
+      # need to look at concurrency if we start storing version on client
+      entity.version += 1
+      storage_client.save_entity(entity)
+      add_events(entity)
+      return entity
+    rescue => e
+      EntityStore.logger.error { "Store#save error: #{e.inspect} - #{entity.inspect}" }
+      raise e
+    end
+    
+    def add_events(entity)
+      entity.pending_events.each do |e|
+        e.entity_id = entity.id.to_s
+        storage_client.add_event(e)
+      end
+      entity.pending_events.each {|e| EventBus.publish(entity.type, e) }
+    end
+
+    def get!(id)
+      get(id, true)
+    end
+    
+    def get(id, raise_exception=false)
+      if entity = storage_client.get_entity(id, raise_exception)
+        storage_client.get_events(id).each { |e| e.apply(entity) }  
+      end    
+      return entity
+    end
+  
+    # Public : USE AT YOUR PERIL this clears the ENTIRE data store
+    # 
+    # Returns nothing
+    def clear_all
+      storage_client.entities.drop
+      storage_client.events.drop
+      @storage_client = nil
+    end
+  
+  end
+end

data/lib/entity_store/version.rb

@@ -0,0 +1,3 @@
+module EntityStore
+  VERSION = "0.0.2".freeze
+end

data/lib/tasks/entity_store.rake

@@ -0,0 +1,7 @@
+require "#{Rake.application.original_dir}/lib/entity_store"
+
+namespace :entity_store do
+  task :ensure_indexes do
+    EntityStore::MongoEntityStore.new.ensure_indexes
+  end
+end

data/spec/entity_store/entity_value_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+class NestedEntityValue
+  include EntityValue
+  attr_accessor :street, :town
+end
+
+class DummyEntityValue
+  include EntityValue
+  attr_accessor :name
+  entity_value_attribute :home, NestedEntityValue
+end
+
+describe EntityValue do
+  before(:each) do
+    @name = random_string
+    @home = random_string
+  end
+  describe "#initialize" do
+    before(:each) do
+      @value = DummyEntityValue.new(:name => @name, :home => @home)
+    end
+    it "sets the name" do
+      @value.name.should eq(@name)
+    end
+    it "sets the home" do
+      @value.home.should eq(@home)
+    end
+  end
+  
+  describe "#attributes" do
+    before(:each) do
+      @value = DummyEntityValue.new(:name => @name, :home => @home)
+    end
+    it "should return hash of attributes" do
+      @value.attributes.should eq({:name => @name, :home => @home})
+    end
+    context "nested attributes" do
+      before(:each) do
+        @street = random_string
+        @town = random_string
+        @value.home = NestedEntityValue.new(:street => @street, :town => @town)
+      end
+      it "should return a hash containing the nested attribute" do
+        @value.attributes.should eq({:name => @name, :home => {:street => @street, :town => @town}})
+      end
+    end
+    
+  end
+  
+  describe "#==" do
+    
+    subject { @this == @other }
+    
+    context "when values are equal" do
+      before(:each) do
+        @this = DummyEntityValue.new(:name => random_string)
+        @other = DummyEntityValue.new(:name => @this.name)
+      end
+      
+      it "should be true" do
+        subject.should be_true
+      end    
+    end
+
+    context "when values are not equal" do
+      before(:each) do
+        @this = DummyEntityValue.new(:name => random_string)
+        @other = DummyEntityValue.new(:name => random_string)
+      end
+      
+      it "should be false" do
+        subject.should be_false
+      end    
+    end
+  end
+end

data/spec/entity_store/event_bus_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+class DummyEvent
+  include Event
+  attr_accessor :name
+end
+
+class DummySubscriber
+  def dummy_event
+    
+  end
+end
+
+describe EventBus do
+  before(:each) do
+    @entity_type = random_string
+    @event = DummyEvent.new(:name => random_string)
+  end
+  describe ".publish" do
+    before(:each) do
+      @subscriber = mock("Subscriber", :dummy_event => true)
+      DummySubscriber.stub(:new) { @subscriber }
+      @subscriber_class2 = mock("SubscriberClass", :instance_methods => ['bilge'], :name => "SubscriberClass")
+      EventBus.stub(:subscribers).and_return([DummySubscriber, @subscriber_class2])
+      EventBus.stub(:publish_externally)
+    end
+    
+    subject { EventBus.publish(@entity_type, @event) }
+    
+    it "calls the receiver method on the subscriber" do
+      @subscriber.should_receive(:dummy_event).with(@event)
+      subject
+    end
+    it "should not create an instance of a class without the receiver method" do
+      @subscriber_class2.should_not_receive(:new)
+      subject
+    end
+    it "publishes event to the external event push" do
+      EventBus.should_receive(:publish_externally).with(@entity_type, @event)
+      subject
+    end
+  end
+  
+  describe ".publish_externally" do
+    before(:each) do
+      @external_store = mock(ExternalStore)
+      EventBus.stub(:external_store) { @external_store }
+    end
+    
+    subject { EventBus.publish_externally @entity_type, @event }
+    
+    it "should publish to the external store" do
+      @external_store.should_receive(:add_event).with(@entity_type, @event)
+      subject
+    end
+  end
+end

data/spec/entity_store/event_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+class DummyValue
+  include EntityValue
+  attr_accessor :town, :county
+
+end
+
+class DummyEvent
+  include Event
+  attr_accessor :name
+  time_attribute :updated_at, :sent_at
+  entity_value_attribute :address, DummyValue
+end
+
+describe Event do
+  before(:each) do
+    @id = random_integer
+    @name = random_string
+    @time = random_time
+    @town = random_string
+    @county = random_string
+  end
+  describe "#initialize" do
+    
+    subject { DummyEvent.new({:entity_id => @id, :name => @name, :updated_at => @time, :sent_at => nil, :address => {:town => @town, :county => @county}})}
+    
+    it "should set entity_id" do
+      subject.entity_id.should eq(@id)
+    end
+    it "should set name" do
+      subject.name.should eq(@name)
+    end
+    it "should set updated_at" do
+      subject.updated_at.should eq(@time)
+    end
+    it "should set town" do
+      subject.address.town.should eq(@town)
+    end
+    it "should set county" do
+      subject.address.county.should eq(@county)
+    end
+  end
+  
+  describe "#attributes" do
+    before(:each) do
+      @event = DummyEvent.new(:entity_id => @id, :name => @name, :updated_at => @time, :address => DummyValue.new(:town => @town, :county => @county))
+    end
+    
+    subject { @event.attributes }
+    
+    it "returns a hash of the attributes" do
+      subject.should eq({:entity_id => @id, :name => @name, :updated_at => @time, :sent_at => nil, :address => {:town => @town, :county => @county}})
+    end
+  end
+  
+  describe ".time_attribute" do
+    before(:each) do
+      @event = DummyEvent.new
+      @time = random_time
+    end
+    context "updated_at" do     
+      subject { @event.updated_at = @time.to_s }
+    
+      it "parses the time field when added as a string" do
+        subject
+        @event.updated_at.to_i.should eq(@time.to_i)
+      end
+    end
+    context "sent_at" do
+      subject { @event.updated_at = @time.to_s }
+    
+      it "parses the time field when added as a string" do
+        subject
+        @event.updated_at.to_i.should eq(@time.to_i)
+      end
+    end
+  end
+  
+  describe ".value_attribute" do
+    before(:each) do
+      @event = DummyEvent.new
+    end
+    context "assign a value" do
+      before(:each) do
+        @value = DummyValue.new(:town => random_string, :county => random_string)
+        @event.address = @value
+      end
+      it "assigns town" do
+        @event.address.town.should eq(@value.town)
+      end
+      it "assigns county" do
+        @event.address.county.should eq(@value.county)
+      end
+    end
+    context "assign a hash" do
+      before(:each) do
+        @hash = { 'town' => random_string, 'county' => random_string }
+        @event.address = @hash
+      end
+      it "assigns town" do
+        @event.address.town.should eq(@hash['town'])
+      end
+      it "assigns county" do
+        @event.address.county.should eq(@hash['county'])
+      end
+    end
+  end
+end

data/spec/entity_store/external_store_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+class DummyEvent
+  include Event
+  attr_accessor :name
+end
+
+class DummyEventTwo
+  include Event
+  attr_accessor :name
+end
+
+describe ExternalStore do
+  before(:each) do
+    EntityStore.external_connection_profile = "mongodb://localhost/external_entity_store_default"
+    ExternalStore.new.collection.drop
+    @store = ExternalStore.new
+  end
+  describe "#add_event" do
+    before(:each) do
+      @entity_type = random_string
+      @event = DummyEvent.new(:name => random_string, :entity_id => random_object_id)
+    end
+    
+    subject { @store.add_event(@entity_type, @event) }
+    
+    it "creates a record in the collection" do
+      subject
+      item = @store.collection.find_one
+      item['_entity_type'].should eq(@entity_type)
+      item['_type'].should eq(@event.class.name)
+      item['name'].should eq(@event.name)
+      item['entity_id'].should eq(@event.entity_id)
+    end
+  end
+  
+  describe "#get_events" do
+    before(:each) do
+      @entity_type = random_string
+      @events = [
+        DummyEvent.new(:name => random_string, :entity_id => random_object_id),
+        DummyEventTwo.new(:name => random_string, :entity_id => random_object_id),
+        DummyEvent.new(:name => random_string, :entity_id => random_object_id),
+        DummyEventTwo.new(:name => random_string, :entity_id => random_object_id),
+        DummyEvent.new(:name => random_string, :entity_id => random_object_id)
+      ]
+      
+      @events.each { |e| @store.add_event(@entity_type, e)}
+    end
+    
+    context "when no options" do
+
+      subject { @store.get_events }
+
+      it "returns all of the events" do
+        subject.count.should eq(@events.count)
+      end
+    end
+    
+    context "when options passed" do
+      subject { @store.get_events(@options) }
+      
+      context "when limit option passed" do
+        before(:each) do
+          @options = {:limit => 3}
+        end
+        
+        it "returns limited records records" do
+          subject.count.should eq(@options[:limit])
+        end
+      end
+      
+      context "when after index passed" do
+        before(:each) do
+          items = @store.get_events(:limit => 3)
+          @options = {:after => items[2].id}
+        end
+        
+        it "returns limited records records" do
+          subject.count.should eq(2)
+        end
+      end  
+      
+      context "when type passed" do
+        before(:each) do
+          @options = {:type => @events[2].class.name}
+        end
+        
+        it "returns type records records" do
+          subject.count.should eq(3)
+        end
+      end      
+          
+    end
+
+  end
+end

data/spec/entity_store/mongo_entity_store_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Level1
+  module Level2
+    class MyClass
+    end
+  end
+end
+
+describe MongoEntityStore do
+  before(:each) do
+    EntityStore.connection_profile = "mongodb://localhost/entity_store_default"
+    @store = MongoEntityStore.new
+  end
+  describe "#get_entity!" do
+    context "when invalid id format passed" do
+      
+      subject { @store.get_entity!(random_string) }
+      
+      it "should raise not found" do
+        expect { subject }.to raise_error(NotFound)
+      end
+    end
+    context "when valid id format passed but no object exists" do
+      before(:each) do
+        @store = MongoEntityStore.new
+      end
+      
+      subject { @store.get_entity!(random_object_id) }
+      
+      it "should raise not found" do
+        expect { subject }.to raise_error(NotFound)
+      end
+    end
+    
+  end
+  
+  describe "get_type_constant" do
+    
+    subject { @store.get_type_constant('Level1::Level2::MyClass') }
+    
+    it "should be an Level1::Level2::MyClass" do
+      subject.should eq(Level1::Level2::MyClass)
+    end
+  end
+end

data/spec/entity_store/store_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+class DummyEntity
+  include Entity
+  
+  attr_accessor :name
+  
+  def initialize(name)
+    @name = name
+  end
+end
+
+describe Store do
+  describe "#add" do
+    before(:each) do
+      @new_id = random_string
+      @entity = DummyEntity.new(random_string)
+      @storage_client = mock("StorageClient", :add_entity => @new_id)
+      @store = Store.new
+      @store.stub(:add_events)
+      @store.stub(:storage_client) { @storage_client }
+    end
+    
+    subject { @store.add(@entity) }
+    
+    it "adds the new entity to the store" do
+      @storage_client.should_receive(:add_entity).with(@entity)
+      subject
+    end
+    it "adds events" do
+      @store.should_receive(:add_events).with(@entity)
+      subject
+    end
+    it "returns a reference to the ride" do
+      subject.should eq(@entity)
+    end  
+  end
+
+  describe "#add_events" do
+    before(:each) do
+      @entity = DummyEntity.new(random_string)
+      @entity.id = random_string
+      @entity.pending_events << mock(Event, :entity_id= => true)
+      @entity.pending_events << mock(Event, :entity_id= => true)
+      @storage_client = mock("StorageClient", :add_event => true)
+      @store = Store.new
+      @store.stub(:storage_client) { @storage_client }
+      EventBus.stub(:publish)
+    end
+    
+    subject { @store.add_events(@entity) }
+    
+    it "adds each of the events" do
+      @entity.pending_events.each do |e|
+        @storage_client.should_receive(:add_event).with(e)
+      end
+      subject
+    end
+    it "should assign the new entity_id to each event" do
+      @entity.pending_events.each do |e|
+        e.should_receive(:entity_id=).with(@entity.id)
+      end
+      subject
+    end
+    it "publishes each event to the EventBus" do
+      @entity.pending_events.each do |e|
+        EventBus.should_receive(:publish).with(@entity.type, e)
+      end
+      subject
+    end
+    
+  end
+  
+  describe "#save" do
+    before(:each) do
+      @new_id = random_string
+      @entity = DummyEntity.new(random_string)
+      @storage_client = mock("StorageClient", :save_entity => true)
+      @store = Store.new
+      @store.stub(:add_events)
+      @store.stub(:storage_client) { @storage_client }
+    end
+    
+    subject { @store.save(@entity) }
+    
+    it "increments the entity version number" do
+      @entity.should_receive(:version=).with(@entity.version + 1)
+      subject
+    end
+    it "save the new entity to the store" do
+      @storage_client.should_receive(:save_entity).with(@entity)
+      subject
+    end
+    it "adds events" do
+      @store.should_receive(:add_events).with(@entity)
+      subject
+    end
+    it "returns a reference to the ride" do
+      subject.should eq(@entity)
+    end
+  end
+  
+  describe "#get" do
+    before(:each) do
+      @id = random_integer
+      @entity = DummyEntity.new(random_string)
+      DummyEntity.stub(:new).and_return(@ride)
+      @events = [mock("Event", :apply => true), mock("Event", :apply => true)]
+  
+      @storage_client = mock("StorageClient", :get_entity => @entity, :get_events => @events)
+      @store = Store.new
+      @store.stub(:storage_client) { @storage_client }
+    end
+    
+    subject { @store.get(@id) }
+    
+    it "should retrieve object from the storage client" do
+      @storage_client.should_receive(:get_entity).with(@id, false)
+      subject
+    end
+    it "should retrieve the events for the entity" do
+      @storage_client.should_receive(:get_events).with(@id)
+      subject
+    end
+    it "should apply each event" do
+      @events.each do |e|
+        e.should_receive(:apply).with(@entity)
+      end
+      subject
+    end
+    it "should return a ride" do
+      subject.should eq(@entity)
+    end
+  end
+end

data/spec/entity_store_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe EntityStore do
+  describe ".setup" do
+    before(:each) do
+      EntityStore.setup do |config|
+        config.log_level = Logger::WARN
+      end
+    end
+    it "has a log_level of WARN" do
+      EntityStore.log_level.should eq(Logger::WARN)
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'rake'
+require 'rspec'
+require "#{Rake.application.original_dir}/lib/entity_store"
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end
+
+include EntityStore
+
+def random_string
+  (0...24).map{ ('a'..'z').to_a[rand(26)] }.join
+end
+
+def random_integer
+  rand(9999)
+end
+
+def random_time
+  Time.now - random_integer
+end
+
+def random_object_id
+  BSON::ObjectId.from_time(random_time).to_s
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: entity_store
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Adam Bird
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: &70160207835100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70160207835100
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &70160207834240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70160207834240
+description: Event sourced entity store with a Mongo body
+email: adam.bird@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/entity_store/config.rb
+- lib/entity_store/entity.rb
+- lib/entity_store/entity_value.rb
+- lib/entity_store/event.rb
+- lib/entity_store/event_bus.rb
+- lib/entity_store/event_data_object.rb
+- lib/entity_store/external_store.rb
+- lib/entity_store/mongo_entity_store.rb
+- lib/entity_store/not_found.rb
+- lib/entity_store/store.rb
+- lib/entity_store/version.rb
+- lib/entity_store.rb
+- lib/tasks/entity_store.rake
+- spec/entity_store/entity_value_spec.rb
+- spec/entity_store/event_bus_spec.rb
+- spec/entity_store/event_spec.rb
+- spec/entity_store/external_store_spec.rb
+- spec/entity_store/mongo_entity_store_spec.rb
+- spec/entity_store/store_spec.rb
+- spec/entity_store_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/adambird/entity_store
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Event sourced entity store with a Mongo body
+test_files:
+- spec/entity_store/entity_value_spec.rb
+- spec/entity_store/event_bus_spec.rb
+- spec/entity_store/event_spec.rb
+- spec/entity_store/external_store_spec.rb
+- spec/entity_store/mongo_entity_store_spec.rb
+- spec/entity_store/store_spec.rb
+- spec/entity_store_spec.rb
+- spec/spec_helper.rb