hikki 0.0.1

data/spec/hikki/repository_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+
+module Hikki
+  describe Repository do
+    subject(:repository) { Repository.new(writers, readers) }
+    let(:writers) { [writer] }
+    let(:readers) { [reader] }
+    let(:writer) { double :writer, save: data, index: true, remove: true, remove_all: true }
+    let(:another_writer) { double :writer, save: data, index: true, remove: true, remove_all: true }
+    let(:reader) { double :reader }
+    let(:collection) { 'collection' }
+    let(:data) { { id: '1' } }
+
+    describe '.new' do
+      context 'with no readers specified' do
+        subject(:repository) { Repository.new(writers) }
+
+        it 'defaults to the first writer for reading' do
+          expect(repository.readers.first).to eq repository.writers.first
+        end
+      end
+
+      context 'with no writers specified' do
+        subject(:repository) { Repository.new }
+
+        it 'defaults to the memory adapter for writing' do
+          expect(repository.writers.first.class).to eq Hikki::Adapters::MemoryAdapter
+        end
+
+        it 'defaults to the first writer for reading' do
+          expect(repository.readers.first).to eq repository.writers.first
+        end
+      end
+    end
+
+    describe '#save' do
+      it 'calls save on the writer' do
+        repository.save(collection, data)
+        expect(writer).to have_received(:save).with(collection, data)
+      end
+
+      it 'returns the data' do
+        expect(repository.save(collection, data)).to eq data
+      end
+
+      context 'with a second writer' do
+        before { repository.writers << another_writer }
+
+        it 'calls save on both of the writers' do
+          repository.save(collection, data)
+          expect(writer).to have_received(:save).with(collection, data)
+          expect(another_writer).to have_received(:save).with(collection, data)
+        end
+      end
+    end
+
+    describe '#index' do
+      it 'calls index on the writer' do
+        repository.index(collection, :field)
+        expect(writer).to have_received(:index).with(collection, :field)
+      end
+
+      context 'with a second writer' do
+        before { repository.writers << another_writer }
+
+        it 'calls index on both of the writers' do
+          repository.index(collection, :field)
+          expect(writer).to have_received(:index).with(collection, :field)
+          expect(another_writer).to have_received(:index).with(collection, :field)
+        end
+      end
+    end
+
+    describe '#remove' do
+      it 'calls index on the writer' do
+        repository.remove(collection, '1')
+        expect(writer).to have_received(:remove).with(collection, '1')
+      end
+
+      context 'with a second writer' do
+        before { repository.writers << another_writer }
+
+        it 'calls index on both of the writers' do
+          repository.remove(collection, '1')
+          expect(writer).to have_received(:remove).with(collection, '1')
+          expect(another_writer).to have_received(:remove).with(collection, '1')
+        end
+      end
+    end
+
+    describe '#remove_all' do
+      it 'calls remove_all on the writer' do
+        repository.remove_all(collection)
+        expect(writer).to have_received(:remove_all).with(collection)
+      end
+
+      context 'with a second writer' do
+        before { repository.writers << another_writer }
+
+        it 'calls remove_all on both of the writers' do
+          repository.remove_all(collection)
+          expect(writer).to have_received(:remove_all).with(collection)
+          expect(another_writer).to have_received(:remove_all).with(collection)
+        end
+      end
+    end
+
+    describe '#find' do
+      context 'when the adapter returns a result' do
+        before { reader.stub(:find).with(collection, '1').and_return(data) }
+
+        it 'returns the result' do
+          expect(repository.find(collection, '1')).to eq data
+        end
+      end
+
+      context 'when the adapter does not return a result' do
+        before { reader.stub(:find).with(collection, '1').and_return({}) }
+
+        it 'returns {}' do
+          expect(repository.find(collection, '1')).to eq Hash.new
+        end
+      end
+
+      context 'with 2 readers' do
+        let(:another_reader) { double :reader }
+        before { repository.readers << another_reader }
+
+        context 'and the record is found in the first' do
+          before do
+            reader.stub(:find).with(collection, '1').and_return(data)
+            another_reader.stub(:find).with(collection, '1').and_return({})
+          end
+
+          it 'returns the result from the first reader' do
+            expect(repository.find(collection, '1')).to eq data
+          end
+        end
+
+        context 'and the record is found only in the second' do
+          before do
+            reader.stub(:find).with(collection, '1').and_return({})
+            another_reader.stub(:find).with(collection, '1').and_return(data)
+          end
+
+          it 'returns the result from the second reader' do
+            expect(repository.find(collection, '1')).to eq data
+          end
+        end
+      end
+    end
+
+    describe '#all' do
+      context 'when the adapter returns the results' do
+        before { reader.stub(:all).with(collection, {}).and_return([data]) }
+
+        it 'returns the results' do
+          expect(repository.all(collection)).to eq [data]
+        end
+      end
+
+      context 'when the adapter does not return a result' do
+        before { reader.stub(:all).with(collection, {}).and_return([]) }
+
+        it 'returns {}' do
+          expect(repository.all(collection)).to eq []
+        end
+      end
+
+      context 'with 2 readers' do
+        let(:another_reader) { double :reader }
+        before { repository.readers << another_reader }
+
+        context 'and the record is found in the first' do
+          before do
+            reader.stub(:all).with(collection, {}).and_return([data])
+            another_reader.stub(:all).with(collection, {}).and_return([])
+          end
+
+          it 'returns the result from the first reader' do
+            expect(repository.all(collection)).to eq [data]
+          end
+        end
+
+        context 'and the record is found only in the second' do
+          before do
+            reader.stub(:all).with(collection, {}).and_return([])
+            another_reader.stub(:all).with(collection, {}).and_return([data])
+          end
+
+          it 'returns the result from the second reader' do
+            expect(repository.all(collection)).to eq [data]
+          end
+        end
+      end
+
+      context 'with options' do
+        before { reader.stub(:all).with(collection, {limit: 10}).and_return([data]) }
+
+        it 'returns the results' do
+          expect(repository.all(collection, limit: 10)).to eq [data]
+        end
+      end
+    end
+
+    describe '#find_by' do
+      context 'when the adapter returns the results' do
+        before { reader.stub(:find_by).with(collection, :field, 'abc', {}).and_return([data]) }
+
+        it 'returns the results' do
+          expect(repository.find_by(collection, :field, 'abc')).to eq [data]
+        end
+      end
+
+      context 'when the adapter does not return a result' do
+        before { reader.stub(:find_by).with(collection, :field, 'abc', {}).and_return([]) }
+
+        it 'returns {}' do
+          expect(repository.find_by(collection, :field, 'abc')).to eq []
+        end
+      end
+
+      context 'with 2 readers' do
+        let(:another_reader) { double :reader }
+        before { repository.readers << another_reader }
+
+        context 'and the record is found in the first' do
+          before do
+            reader.stub(:find_by).with(collection, :field, 'abc', {}).and_return([data])
+            another_reader.stub(:find_by).with(collection, :field, 'abc', {}).and_return([])
+          end
+
+          it 'returns the result from the first reader' do
+            expect(repository.find_by(collection, :field, 'abc')).to eq [data]
+          end
+        end
+
+        context 'and the record is found only in the second' do
+          before do
+            reader.stub(:find_by).with(collection, :field, 'abc', {}).and_return([])
+            another_reader.stub(:find_by).with(collection, :field, 'abc', {}).and_return([data])
+          end
+
+          it 'returns the result from the second reader' do
+            expect(repository.find_by(collection, :field, 'abc')).to eq [data]
+          end
+        end
+      end
+
+      context 'with options' do
+        before { reader.stub(:find_by).with(collection, :field, 'abc', {limit: 10}).and_return([data]) }
+
+        it 'returns the results' do
+          expect(repository.find_by(collection, :field, 'abc', limit: 10)).to eq [data]
+        end
+      end
+    end
+
+  end
+end

data/spec/hikki_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Hikki do
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'hikki'

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: hikki
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- alexpeachey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A light weight persistence system.
+email:
+- alex.peachey@originate.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- adapters/hikki-memcache/.rspec
+- adapters/hikki-memcache/.travis.yml
+- adapters/hikki-memcache/Gemfile
+- adapters/hikki-memcache/LICENSE.txt
+- adapters/hikki-memcache/README.md
+- adapters/hikki-memcache/Rakefile
+- adapters/hikki-memcache/hikki-memcache.gemspec
+- adapters/hikki-memcache/lib/hikki/adapters/memcache_adapter.rb
+- adapters/hikki-memcache/lib/hikki/adapters/memcache_collection.rb
+- adapters/hikki-memcache/spec/hikki/adapters/memcache_adapter_integration_spec.rb
+- adapters/hikki-memcache/spec/hikki/adapters/memcache_adapter_spec.rb
+- adapters/hikki-memcache/spec/spec_helper.rb
+- adapters/hikki-mongo/.rspec
+- adapters/hikki-mongo/.travis.yml
+- adapters/hikki-mongo/Gemfile
+- adapters/hikki-mongo/LICENSE.txt
+- adapters/hikki-mongo/README.md
+- adapters/hikki-mongo/Rakefile
+- adapters/hikki-mongo/hikki-mongo.gemspec
+- adapters/hikki-mongo/lib/hikki/adapters/mongo_adapter.rb
+- adapters/hikki-mongo/lib/hikki/adapters/mongo_collection.rb
+- adapters/hikki-mongo/spec/hikki/adapters/mongo_adapter_integration_spec.rb
+- adapters/hikki-mongo/spec/hikki/adapters/mongo_adapter_spec.rb
+- adapters/hikki-mongo/spec/spec_helper.rb
+- adapters/hikki-redis/.rspec
+- adapters/hikki-redis/.travis.yml
+- adapters/hikki-redis/Gemfile
+- adapters/hikki-redis/LICENSE.txt
+- adapters/hikki-redis/README.md
+- adapters/hikki-redis/Rakefile
+- adapters/hikki-redis/hikki-redis.gemspec
+- adapters/hikki-redis/lib/hikki/adapters/redis_adapter.rb
+- adapters/hikki-redis/lib/hikki/adapters/redis_collection.rb
+- adapters/hikki-redis/spec/hikki/adapters/redis_adapter_integration_spec.rb
+- adapters/hikki-redis/spec/hikki/adapters/redis_adapter_spec.rb
+- adapters/hikki-redis/spec/spec_helper.rb
+- all_specs
+- hikki.gemspec
+- lib/hikki.rb
+- lib/hikki/adapters/adapter.rb
+- lib/hikki/adapters/memory_adapter.rb
+- lib/hikki/adapters/memory_collection.rb
+- lib/hikki/collection.rb
+- lib/hikki/repository.rb
+- lib/hikki/version.rb
+- spec/hikki/adapters/memory_adapter_spec.rb
+- spec/hikki/repository_spec.rb
+- spec/hikki_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: A light weight persistence system.
+test_files:
+- spec/hikki/adapters/memory_adapter_spec.rb
+- spec/hikki/repository_spec.rb
+- spec/hikki_spec.rb
+- spec/spec_helper.rb