jouba 0.1.0 → 1.0.0

data/lib/jouba/cache.rb

@@ -0,0 +1,40 @@
+require 'forwardable'
+
+module Jouba
+  module Cache
+    class Null
+      def fetch(_)
+        yield
+      end
+
+      def refresh(_, _)
+        yield
+      end
+    end
+
+    class Memory
+      extend Forwardable
+
+      attr_reader :store
+
+      def_delegators :store, :set, :get, :persist
+
+      def initialize
+        @store = MemoryStore.new
+      end
+
+      def fetch(key)
+        get(key) || yield.tap { |value| store.set(key, value) }
+      end
+
+      def refresh(key, value)
+        store.set(key, value)
+        yield
+      end
+
+      def self.load(file_path)
+        @store = MemoryStore.load(file_path)
+      end
+    end
+  end
+end

data/lib/jouba/event.rb

@@ -1,13 +1,33 @@
 module Jouba
-  class Event < Hashie::Dash
-    include Hashie::Extensions::IndifferentAccess
+  class Event < Hashie::Trash
+    property :key,       required: true
+    property :name,      required: true
+    property :data,      required: true
+    property :uuid, default: ->(e) { e.send(:raw_uuid).to_s }
+    property :version, default: ->(e) { e.send(:raw_uuid).version }
+    property :timestamp, default: ->(e) { e.send(:raw_uuid).timestamp }
 
-    property :name, required: true
-    property :data, required: true
-    property :occured_at, default: -> { Time.now.utc }
+    def self.serialize(event)
+      event.to_h
+    end
+
+    def self.deserialize(serialized_event)
+      new(serialized_event)
+    end
+
+    def self.stream(key, params)
+      Jouba.Store.get(key, params).map { |event| Event.deserialize(event) }
+    end
+
+    def track
+      Jouba.Store.set(key, Event.serialize(self))
+    end
+    alias_method :save, :track
+
+    private
 
-    def self.build(event_name, data)
-      new(name: event_name, data: data)
+    def raw_uuid
+      @raw_uuid ||= self[:uuid].nil? ? UUID.new : UUID.new(self[:uuid])
     end
   end
 end

data/lib/jouba/key.rb

@@ -0,0 +1,11 @@
+module Jouba
+  class Key < Struct.new(:name, :id)
+    def self.serialize(name, id)
+      "#{name}.#{id}"
+    end
+
+    def self.deserialize(key)
+      new(*key.split('.')[(0..1)])
+    end
+  end
+end

data/lib/jouba/store.rb

@@ -0,0 +1,76 @@
+require 'yaml'
+require 'forwardable'
+
+module Jouba
+  class MemoryStore
+    attr_reader :db
+
+    def initialize
+      flush
+    end
+
+    def get(key, _ = {})
+      db[key].nil? ? nil : deserialize(db[key])
+    end
+
+    def set(key, value)
+      db[key] = serialize(value)
+    end
+
+    def delete(key)
+      db.delete(key)
+    end
+
+    def flush
+      @db = {}
+    end
+
+    def persist(file_path)
+      File.open(file_path, 'w') { |file| file.write @db.to_yaml }
+    end
+
+    def self.load(file_path)
+      new.tap { |store| store.instance_variable_set('@db', YAML.load_file(file_path)) }
+    end
+
+    protected
+
+    def deserialize(data)
+      YAML.load(data)
+    end
+
+    def serialize(data)
+      YAML.dump(data)
+    end
+  end
+
+  class EventStore < MemoryStore
+    class Collection
+      extend Forwardable
+      include Enumerable
+
+      attr_reader :collection
+      def_delegators :collection, :each
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def since(time)
+        Collection.new collection.select { |item| item.timestamp <= time }
+      end
+    end
+
+    def get(key, _ = {})
+      Collection.new db[key].map { |item| deserialize(item) }
+    end
+
+    def set(key, value)
+      db[key].push serialize(value)
+    end
+
+    def flush
+      @db = Hash.new { |h, k| h[k] = [] }
+    end
+  end
+end

data/spec/integration/customer_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'jouba/aggregate'
+
+describe 'Aggregate' do
+  class Customer < Hashie::Dash
+    include Jouba::Aggregate.new(prefix: :on)
+    property :uuid
+    property :name
+
+    def self.create(attributes)
+      Customer.new(uuid: SecureRandom.uuid).tap do |customer|
+        customer.create(attributes.merge(uuid: customer.uuid))
+      end
+    end
+
+    def create(attributes)
+      emit(:created, attributes)
+    end
+
+    private
+
+    def on_created(attributes)
+      update_attributes!(attributes)
+    end
+  end
+
+  let(:name) { 'foo' }
+
+  describe 'create new customer' do
+    subject { Customer.create(name: name) }
+
+    it 'creates a customer' do
+      expect(subject).to be_a Customer
+      expect(subject.name).to eq name
+    end
+
+    it 'increased the stream stack' do
+      expect(Customer.stream(subject.uuid).size).to eq 1
+    end
+
+    it 'it findable' do
+      expect(Customer.find(subject.uuid)).to eq subject
+    end
+
+    describe 'with cache' do
+      before do
+        Jouba.config.Cache = Jouba::Cache::Memory.new
+      end
+
+      after do
+        Jouba.config.Cache = Jouba::Cache::Null.new
+      end
+
+      context 'when there is something in the cache' do
+        before { Customer.create(name: name) }
+        after { 10.times { Customer.find(subject.uuid) } }
+
+        it 'dont uses the cache' do
+          expect(Customer).not_to receive(:replay)
+        end
+      end
+
+      context 'when there is nothing in the cache' do
+        let(:customer) { Customer.create(name: name) }
+        let(:key) { Customer.key_from_uuid(customer.uuid) }
+        let(:uuid) { customer.uuid }
+
+        before do
+          expect(Jouba.Cache.get(key)).not_to eq nil
+          Jouba.Cache.store.flush
+          expect(Jouba.Cache.get(key)).to eq nil
+        end
+
+        after { 10.times { Customer.find(uuid) } }
+
+        it 'uses the cache once' do
+          expect { |b| Jouba.Cache.fetch(key, &b) }.to yield_control.exactly(1)
+          expect(Jouba.Cache).to receive(:fetch).exactly(10)
+        end
+      end
+    end
+  end
+end

data/spec/lib/jouba/aggregate_spec.rb

@@ -1,74 +1,115 @@
-require 'ostruct'
 require 'spec_helper'
+require 'jouba/aggregate'
 
 describe Jouba::Aggregate do
-  let(:aggregate_class) { Class.new { include Jouba::Aggregate } }
+  let(:uuid) { '123' }
+  let(:attributes) { { name: 'bar' }  }
+  let(:name) { :created }
+  let(:event) { Jouba::Event.new(key: target.to_key, name: name, data: attributes) }
+  let(:listener) { double(:listener) }
 
-  subject { aggregate_class }
+  let(:target_class) do
+    Class.new(OpenStruct) do
+      include Jouba::Aggregate.new(prefix: :on)
+      include Wisper::Publisher
 
-  describe '.find(id)' do
-    let(:id) { 2 }
+      def create(attributes)
+        emit(:created, attributes)
+      end
+    end
+  end
+  let(:target) { target_class.new(uuid: uuid) }
+
+  describe '.initialize' do
+    it 'has instance methods of an aggreate' do
+      described_class::InstanceMethods.public_instance_methods.each do |meth|
+        expect(target_class.new).to respond_to(meth)
+      end
+    end
 
-    it 'query the store' do
-      expect(Jouba).to receive(:find).with(aggregate_class, id)
-      subject.find(id)
+    it 'has class methods of an aggreate' do
+      described_class::ClassMethods.public_instance_methods.each do |meth|
+        expect(target_class).to respond_to(meth)
+      end
     end
   end
 
-  describe '.build_from_events(uuid, events)' do
-    let(:aggregate) { aggregate_class.new }
-    let(:uuid) { '123' }
-    let(:events) { [double(:event)] }
+  describe '#emit(name, *args)' do
+    after { target.create(attributes) }
 
-    it 'build the aggregate by applying the events' do
-      expect(aggregate_class).to receive(:new).and_return(aggregate)
-      expect(aggregate).to receive(:[]=).with(:uuid, uuid)
-      expect(aggregate).to receive(:apply_events).with(events)
-      aggregate_class.build_from_events(uuid, events)
+    before do
+      expect(Jouba.Event).to receive(:new)
+        .with(key: target.to_key, name: name, data: [attributes]).and_return(event)
+      expect(target).to receive(:"on_#{name}").with(*attributes)
     end
 
-    context 'when after_initialize_blocks is not empty' do
-      let(:observer) { double(:observer) }
+    it 'apply the event' do
+      expect(target).to receive(:apply_event).with(event).and_call_original
+    end
 
-      before do
-        aggregate_class.after_initialize do |aggregate|
-          aggregate.subscribe(observer)
-        end
-      end
+    it 'refresh the cache' do
+      expect(Jouba.Cache).to receive(:refresh).with(target.to_key, target)
+        .and_yield.and_call_original
+    end
 
-      it 'apply the blocks once initialized' do
-        expect(aggregate_class).to receive(:new).and_return(aggregate)
-        expect(aggregate).to receive(:apply_events).with(events)
-        expect(aggregate).to receive(:[]=).with(:uuid, uuid)
-        expect(aggregate).to receive(:subscribe).with(observer)
-        aggregate_class.build_from_events(uuid, events)
-      end
+    it 'publish an event' do
+      target.subscribe(listener, prefix: :on)
+      expect(listener).to receive(:"on_#{name}").with(attributes)
     end
+  end
 
+  describe '#to_key' do
+    let(:uuid) { 123 }
+    it 'delegates to the class method' do
+      expect(target_class).to receive(:key_from_uuid).with(target.uuid)
+      target.to_key
+    end
   end
 
-  describe '.after_initialize(&block)' do
+  describe '#replay(event)' do
+    after { target.replay(event) }
+    it 'calls the callback_method with the right params' do
+      expect(target).to receive(:"on_#{name}").with(*attributes)
+    end
   end
 
-  describe '#uuid' do
-    let(:uuids) { (1..3).map { aggregate_class.new.uuid } }
+  describe '.replay(events)' do
+    let(:events) { [event, event] }
+
+    after { target_class.replay(events) }
+    before { expect(target_class).to receive(:new).and_return(target) }
 
-    it 'return a different uuid for each instance' do
-      expect(uuids.uniq.size).to eq 3
+    it 'create a new instance of the aggregate and apply all the events' do
+      expect(target).to receive(:replay).with(event).exactly(2).times
     end
   end
 
-  describe '#commit(aggregate, event)' do
-    let(:aggregate) { aggregate_class.new }
-    let(:data) { { value: 10, meta: OpenStruct.new(foo: 'bar') } }
-    let(:event_name) { 'add_credit' }
-    let(:event) { Jouba::Event.new(name: event_name, data: data) }
-
-    it 'append the event to the store' do
-      expect(Jouba.stores[:events]).to receive(:append_events).with(aggregate, event)
-      expect(Jouba::Event).to receive(:build).with(event_name, data).and_return(event)
-      expect(aggregate).to receive(event_name).with(data)
-      aggregate.commit(event_name, data)
+  describe '.find(uuid)' do
+    let(:key) { target_class.key_from_uuid(uuid) }
+    let(:stream) { [] }
+    after { target_class.find(uuid) }
+
+    it 'goes through the cache' do
+      expect(target_class).to receive(:stream).with(uuid).and_return(stream)
+      expect(target_class).to receive(:replay).with(stream)
+      expect(Jouba.Cache).to receive(:fetch).with(key).and_yield.and_call_original
+    end
+  end
+
+  describe '.stream(uuid)' do
+    let(:key) { target_class.key_from_uuid(uuid) }
+    let(:params) { {} }
+    after { target_class.stream(uuid, params) }
+    it 'returns the stream from the EventStore' do
+      expect(Jouba.Event).to receive(:stream).with(key, params)
+    end
+  end
+
+  describe '.key_from_uuid(uuid)' do
+    after { target_class.key_from_uuid(uuid) }
+
+    it 'delegates to the configured key structure' do
+      expect(Jouba.Key).to receive(:serialize).with(target_class.name, uuid)
     end
   end
 end

data/spec/lib/jouba/event_spec.rb

@@ -1,21 +1,85 @@
 require 'spec_helper'
 
 describe Jouba::Event do
-  let(:event_name) { 'event_name' }
-  let(:data) { [:foo, 1, 'bar', { foo: 'bar' }, [1, 2]] }
-  let(:occured_at) { double(:time) }
+  let(:key) { 'User.1' }
+  let(:name) { 'created' }
+  let(:data) { { fname: 'John', lname: 'Doe' } }
+  let(:uuid) { UUID.new }
+  let(:attributes) do
+    { key: key, name: name, data: data }
+  end
+
+  subject { described_class.new(attributes) }
 
-  describe '.build(event_name, data)' do
+  describe '.new(attributes)' do
     before do
-      Time.stub_chain(:now, :utc).and_return(occured_at)
+      allow(UUID).to receive(:new).at_least(:once).and_return(uuid)
     end
 
-    subject { described_class.build(event_name, data) }
-
-    it 'build an event' do
-      expect(subject.name).to eq event_name
+    it 'sets the attributes and sets defaults for the other values' do
+      expect(subject.uuid).to eq uuid.to_s
+      expect(subject.version).to eq uuid.version
+      expect(subject.timestamp).to eq uuid.timestamp
+      expect(subject.key).to eq key
+      expect(subject.name).to eq name
       expect(subject.data).to eq data
-      expect(subject.occured_at).to eq occured_at
+    end
+  end
+
+  describe '.serialize(event)' do
+    before do
+      allow(UUID).to receive(:new).at_least(:once).and_return(uuid)
+    end
+
+    let(:event) { described_class.new(attributes) }
+    let(:expected_serialized) do
+      {
+        key: key,
+        name: name,
+        data: data,
+        uuid: uuid.to_s,
+        version: uuid.version,
+        timestamp: uuid.timestamp
+      }
+    end
+
+    subject { described_class.serialize(event) }
+
+    it 'serializes into a hash' do
+      expect(subject).to eq expected_serialized
+    end
+  end
+
+  describe '.deserialize(serialized_event)' do
+    let(:event) { described_class.new(attributes) }
+    let(:serialized_event) { described_class.serialize(event) }
+    subject { described_class.deserialize(serialized_event) }
+
+    it 'rebuild an event based on the serialized version' do
+      expect(subject).to eq event
+    end
+  end
+
+  describe '.stream(key, params)' do
+    let(:stream) { [described_class.new(attributes), described_class.new(attributes)] }
+    let(:key) { 'key' }
+    let(:params) { { lname: 'foo' } }
+    let(:serialized_stream) { stream.map { |item| described_class.serialize(item) } }
+
+    before { expect(Jouba.Store).to receive(:get).with(key, params).and_return(serialized_stream) }
+
+    it 'returns a stream of events' do
+      expect(described_class.stream(key, params)).to eq stream
+    end
+  end
+
+  describe '#track' do
+    let(:event) { described_class.new(attributes) }
+    let(:serialized_event) { described_class.serialize(event) }
+    before { expect(Jouba.Store).to receive(:set).with(event.key, serialized_event) }
+
+    it 'persist an event in the store' do
+      event.track
     end
   end
 end