jouba 0.1.0 → 1.0.0

data/spec/lib/jouba/key_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Jouba::Key do
+  let(:name) { 'Customer' }
+  let(:id) { '1' }
+  let(:key) { 'Customer.1' }
+
+  describe '.serialize(name, id)' do
+    subject { described_class.serialize(name, id) }
+
+    it 'serialize a name and id' do
+      expect(subject).to eq key
+    end
+  end
+
+  describe '.deserialize(key)' do
+    subject { described_class.deserialize(key) }
+
+    it 'deserialize a key into name an id' do
+      expect(subject.name).to eq name
+      expect(subject.id).to eq id
+    end
+
+    context 'when there is more information in the key' do
+      let(:key) { 'Customer.1.meta.info' }
+      it 'parse the key properly' do
+        expect(subject.name).to eq name
+        expect(subject.id).to eq id
+      end
+    end
+  end
+end

data/spec/lib/jouba_spec.rb

@@ -1,213 +1,67 @@
 require 'spec_helper'
 
 describe Jouba do
+  [:Key, :Event, :Cache, :Store].each do |meth|
+    after { Jouba.send(meth) }
+    it "delegates #{meth} to config" do
+      expect(described_class.config).to receive(meth)
+    end
+  end
   describe '.config' do
     subject { described_class.config }
 
     it { should be_a Hashie::Mash }
 
-    it 'has a stores reader' do
-      expect(subject.stores).to be_a Hashie::Mash
-    end
-
-    context 'when we try to access an unknown key' do
-      let(:unkwown_key) { :foo }
-
-      it 'fails' do
-        expect { subject[unkwown_key] }.to raise_error
-      end
-    end
-  end
-
-  describe '.adapters_map' do
-    subject { described_class.adapters_map }
-    let(:existing_adapter) { :sql }
-    let(:unknown_adapter) { :foo }
-
-    before do
-      Jouba.register_adapter(existing_adapter, Class)
-    end
-
-    after do
-      Jouba.adapters_map.delete(existing_adapter)
-    end
-
-    it 'fail when we try to access an unknown adapter' do
-      expect { subject[existing_adapter] }.not_to raise_error
-      expect { subject[unknown_adapter] }.to raise_error
-    end
-  end
-
-  describe 'register_adapter(key, class)' do
-    let(:key) { :adapter }
-    let(:adapter_class) { double(:adapter_class) }
+    context 'by default' do
+      subject { described_class.config[key] }
 
-    before do
-      expect { Jouba.adapters_map[key] }.to raise_error
-      Jouba.register_adapter(key, Class)
-    end
-
-    after do
-      Jouba.adapters_map.delete(key)
-    end
-
-    it 'assign the class to the key in the adapters_map' do
-      expect { Jouba.adapters_map[key] }.not_to raise_error
-    end
-  end
-
-  describe 'register_store(name)' do
-    let(:store_name) { :foo }
-    let(:adapter_name) { :sql }
-    let(:adapter_class) { double(:adapter_class) }
-    let(:adapter_instance) { double(:adapter_instance) }
-    let(:config_h) { double(:config_h) }
-
-    before do
-      Jouba.register_adapter(adapter_name, adapter_class)
-      expect { Jouba.stores[store_name] }.to raise_error
-
-      expect(described_class.config.stores).to receive(:[]).with(store_name).and_return(config_h)
-      config_h.stub(:adapter).and_return(adapter_name)
-      expect(adapter_class).to receive(:new).with(config_h).and_return(adapter_instance)
-      Jouba.register_store(store_name) do |c|
-        c.adapter = adapter_name
+      context 'when key is event' do
+        let(:key) { 'Event' }
+        it { expect(subject).to eq Jouba::Event }
       end
-    end
-
-    after do
-      Jouba.stores.delete(store_name)
-      Jouba.adapters_map.delete(adapter_name)
-    end
-
-    subject { described_class.stores[store_name] }
-
-    it 'sets the store in the Jouba.stores' do
-      expect(subject).to eq adapter_instance
-    end
-  end
-
-  describe '.stores' do
-    subject { described_class.stores }
-    let(:existing_store) { :existing }
-    let(:unknown_store) { :foo }
 
-    before do
-      Jouba.register_store(existing_store) do |config|
-        config.adapter = :random # Check spec_helper
+      context 'when key is key' do
+        let(:key) { 'Key' }
+        it { expect(subject).to eq Jouba::Key }
       end
-    end
-
-    after do
-      Jouba.stores.delete(existing_store)
-    end
-
-    it 'fail when we try to access an unknown adapter' do
-      expect { subject[existing_store] }.not_to raise_error
-      expect { subject[unknown_store] }.to raise_error
-    end
-
-    it 'returns the same instance' do
-      expect(subject[existing_store].object_id).to eq Jouba.stores[existing_store].object_id
-    end
-  end
-
-  describe '.commit(aggregate, event)' do
-    let(:aggregate) { double(:aggregate) }
-    let(:event) { double(:event) }
 
-    it 'commit the event to the store' do
-      expect(described_class.stores[:events]).to receive(:append_events).with(aggregate, event).and_return(true)
-      expect { |b| described_class.commit(aggregate, event, &b) }.to yield_with_no_args
-    end
-
-    context 'when store hasnt been able to append the events' do
-      before do
-        expect(described_class.stores[:events]).to receive(:append_events).with(aggregate, event).and_return(false)
+      context 'when key is cache' do
+        let(:key) { 'Cache' }
+        it { expect(subject).to be_a Jouba::Cache::Null }
       end
 
-      it 'doesnt yield' do
-        expect { |b| described_class.commit(aggregate, event, &b) }.not_to yield_with_no_args
+      context 'when key is key' do
+        let(:key) { 'Store' }
+        it { expect(subject).to be_a Jouba::EventStore }
       end
     end
   end
 
-  describe '.find(aggreate_class, aggregate_id)' do
-    let(:aggregate_id) { 'id' }
-    let(:aggregate_class) { 'aggregate_class' }
-    let(:aggregate) { double(:aggregate) }
-
-    it 'retrieve an aggregate from the store' do
-      expect(described_class.stores[:events]).to receive(:find)
-        .with(aggregate_class, aggregate_id).and_return(aggregate)
-      expect(described_class.find(aggregate_class, aggregate_id)).to eq aggregate
-    end
-  end
-
-  describe '.alias_store(alias_name, target)' do
-    let(:alias_name) { :alias_name }
-    let(:target) { :target }
-
-    before do
-      Jouba.register_store(target) do |config|
-        config.adapter = :random # Check spec_helper
-      end
-    end
-
-    after do
-      Jouba.stores.delete(target)
-      Jouba.stores.delete(alias_name)
+  describe '.emit(key, name, data)' do
+    let(:key) { 'key' }
+    let(:name) { 'name' }
+    let(:data) { double(:data) }
+    let(:event_payload) do
+      { key: key, name: name, data: data }
     end
+    let(:event) { Jouba::Event.new(event_payload) }
 
-    it 'alias the two stores' do
-      expect { Jouba.stores[alias_name] }.to raise_error
-      Jouba.alias_store(alias_name, target)
-      expect { Jouba.stores[alias_name] }.not_to raise_error
-      expect(Jouba.stores[alias_name].object_id).to eq Jouba.stores[target].object_id
+    after { described_class.emit(key, name, data) }
 
+    it 'tracks a new event' do
+      expect(Jouba.Event).to receive(:new).with(event_payload).and_return(event)
+      expect(event).to receive(:track)
     end
   end
 
-  describe '.locked?(key)' do
+  describe '.stream(key, params)' do
     let(:key) { 'key' }
-    it 'asks the lock store if a key is locked' do
-      expect(Jouba.stores[:lock]).to receive(:locked?).with(key)
-      described_class.locked?(key)
-    end
-  end
+    let(:params) { { foo: 'bar' } }
 
-  describe '.with_lock(key)' do
-    let(:key) { 'key' }
-
-    context 'when the key is not locked' do
-      before do
-        expect(Jouba.stores[:lock]).to receive(:lock!).with(key)
-        expect(Jouba.stores[:lock]).to receive(:unlock!).with(key)
-        expect(Jouba).to receive(:locked?).with(key).and_return(false)
-      end
+    after { described_class.stream(key, params) }
 
-      it 'yield with lock' do
-        expect { |b| described_class.with_lock(key, &b) }.to yield_with_no_args
-      end
-
-      context 'when yield fails' do
-        let(:exception) { StandardError.new }
-
-        it 'make sure to release the lock' do
-          expect { described_class.with_lock(key) { fail(exception) } }.to raise_error
-        end
-      end
-    end
-
-    context 'when the key is locked' do
-      before do
-        expect(Jouba).to receive(:locked?).with(key).and_return(true)
-        expect(Jouba.stores[:lock]).not_to receive(:unlock!).with(key)
-      end
-
-      it 'fails with a LockException' do
-        expect { |b| described_class.with_lock(key, &b) }.to raise_error(Jouba::LockException)
-      end
+    it 'returns the stream of events' do
+      expect(Jouba.Event).to receive(:stream).with(key, params)
     end
   end
 end

data/spec/spec_helper.rb

@@ -22,12 +22,5 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.treat_symbols_as_metadata_keys_with_true_values = true
 
-  Jouba.register_adapter(:random, Struct.new('RandomAdapter', :config))
-
-  Jouba.register_store(:events) do |store_config|
-    store_config.adapter = :random
-  end
-  Jouba.alias_store(:lock, :events)
-
   config.order = 'random'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jouba
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - gregory
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-02 00:00:00.000000000 Z
+date: 2015-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -16,28 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: 3.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: 3.4.0
 - !ruby/object:Gem::Dependency
   name: wisper
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: locality-uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -143,7 +157,7 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
+- README.md
 files:
 - ".document"
 - ".rspec"
@@ -151,18 +165,22 @@ files:
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - jouba.gemspec
 - lib/jouba.rb
 - lib/jouba/aggregate.rb
+- lib/jouba/cache.rb
 - lib/jouba/event.rb
-- lib/jouba/exceptions.rb
-- lib/jouba/stores.rb
+- lib/jouba/key.rb
+- lib/jouba/store.rb
 - lib/jouba/version.rb
+- spec/integration/customer_spec.rb
 - spec/lib/jouba/aggregate_spec.rb
+- spec/lib/jouba/cache_spec.rb
 - spec/lib/jouba/event_spec.rb
+- spec/lib/jouba/key_spec.rb
 - spec/lib/jouba_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/gregory/jouba

data/README.rdoc

@@ -1,19 +0,0 @@
-= jouba
-
-Description goes here.
-
-== Contributing to jouba
- 
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
-* Fork the project.
-* Start a feature/bugfix branch.
-* Commit and push until you are happy with your contribution.
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
-
-== Copyright
-
-Copyright (c) 2014 gregory. See LICENSE.txt for
-further details.
-

data/lib/jouba/exceptions.rb

@@ -1,3 +0,0 @@
-module Jouba
-  class LockException < StandardError; end
-end

data/lib/jouba/stores.rb

@@ -1,27 +0,0 @@
-module Jouba
-  module Stores
-    def self.append_events(_, _)
-      fail NotImplementedError
-    end
-
-    def self.find(_)
-      fail NotImplementedError
-    end
-
-    def self.count
-      fail NotImplementedError
-    end
-
-    def self.locked?(_)
-      fail NotImplementedError
-    end
-
-    def self.lock!(_)
-      fail NotImplementedError
-    end
-
-    def self.unlock!(_)
-      fail NotImplementedError
-    end
-  end
-end