rrrmatey 0.1.0

data/spec/rrrmatey/retryable_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+class Conn
+    def get(id)
+        { :id => id }
+    end
+end
+
+class ConnPool
+    def initialize(opts = {})
+        @conn = Conn.new()
+        @errors = opts[:errors] || -1
+    end
+
+    def with(&block)
+        if @errors > 0
+            @errors -= 1
+            raise "errors remaining: #{@errors}"
+        else
+            block.call(@conn)
+        end
+    end
+end
+
+describe RRRMatey::Retryable do
+    describe '#initialize' do
+        let(:conn) { Conn.new() }
+        let(:conn_pool) { ConnPool.new() }
+        let(:default) { RRRMatey::Retryable.new(conn) }
+        let(:default_pool) { RRRMatey::Retryable.new(conn_pool) }
+        let(:optioned) { RRRMatey::Retryable.new(conn_pool,
+                                                 :retries => 5,
+                                                 :retry_delay => 0.01) }
+
+        it 'has sane defaults for conn_pool' do
+            expect(default_pool.instance_variable_get(:@retries)).to eq(3)
+            expect(default_pool.instance_variable_get(:@retry_delay)).to eq(0.1)
+            expect(default_pool.instance_variable_get(:@conn)).to eq(conn_pool)
+            expect(default_pool.instance_variable_get(:@conn_respond_to_with)).to be(true)
+        end
+
+        it 'has sane defaults for conn' do
+            expect(default.instance_variable_get(:@retries)).to eq(3)
+            expect(default.instance_variable_get(:@retry_delay)).to eq(0.1)
+            expect(default.instance_variable_get(:@conn)).to eq(conn)
+            expect(default.instance_variable_get(:@conn_respond_to_with)).to be(false)
+        end
+
+        it 'accepts options' do
+            expect(optioned.instance_variable_get(:@retries)).to eq(5)
+            expect(optioned.instance_variable_get(:@retry_delay)).to eq(0.01)
+            expect(optioned.instance_variable_get(:@conn)).to eq(conn_pool)
+            expect(optioned.instance_variable_get(:@conn_respond_to_with)).to be(true)
+        end
+    end
+
+    describe '#with' do
+        let(:conn) { Conn.new() }
+        let(:conn_pool) { ConnPool.new() }
+        let(:flappy_conn) { ConnPool.new(:errors => 2) }
+        let(:failing_conn) { ConnPool.new(:errors => 10) }
+        let(:optioned) { RRRMatey::Retryable.new(conn,
+                                                 :retries => 5,
+                                                 :retry_delay => 0.01) }
+        let(:optioned_pool) { RRRMatey::Retryable.new(conn_pool,
+                                                      :retries => 5,
+                                                      :retry_delay => 0.01) }
+        let(:flappy_optioned_pool) { RRRMatey::Retryable.new(flappy_conn,
+                                                             :retries => 5,
+                                                             :retry_delay => 0.01) }
+        let(:failing_optioned_pool) { RRRMatey::Retryable.new(failing_conn,
+                                                              :retries => 5,
+                                                              :retry_delay => 0.01) }
+
+        it 'yields nil if !block.given?' do
+            expect(optioned.with()).to be(nil)
+        end
+
+        it 'yields block response on no error for conn' do
+            expect(optioned.with { |c| c.get(3) }).to eq({:id => 3})
+        end
+
+        it 'yields block response on no error for conn_pool' do
+            expect(optioned_pool.with { |c| c.get(3) }).to eq({:id => 3})
+        end
+
+        it 'yields block response for flappy pool' do
+            expect(flappy_optioned_pool.with { |c| c.get(3) }).to eq({:id => 3})
+        end
+
+        it 'raises for failing pool' do
+            expect{failing_optioned_pool.with { |c| c.get(3) }}.to raise_error(RuntimeError)
+        end
+   end
+end

data/spec/rrrmatey/string_model/connection_methods_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+class ConnectionModel
+    extend RRRMatey::StringModel::ConnectionMethods
+
+    class ConnPool
+        def initialize(conn)
+            @conn = conn
+        end
+
+        def with(&block)
+            block.call(@conn)
+        end
+    end
+
+    class Conn
+    end
+end
+
+describe RRRMatey::StringModel::ConnectionMethods do
+    context 'with riak and cache_proxy setup' do
+        let(:conn) {  ConnectionModel::ConnPool.new(ConnectionModel::Conn.new()) }
+        let(:model_klass) {
+            m = ConnectionModel
+            m.riak = conn
+            m.cache_proxy = conn
+            m
+        }
+
+        describe '#cache_proxy' do
+            it 'yields values from self' do
+                expect(model_klass.cache_proxy).to eq(conn)
+            end
+        end
+
+        describe '#riak' do
+            it 'yields values from self' do
+                expect(model_klass.riak).to eq(conn)
+            end
+        end
+    end
+
+    context 'with or without riak and cache_proxy setup' do
+        let(:model_klass) {
+            m = ConnectionModel
+            m.riak = nil
+            m.cache_proxy = nil
+            m
+        }
+        let(:string_model_klass) { RRRMatey::StringModel }
+
+        describe '#cache_proxy' do
+            it 'yields values from StringModel' do
+                expect(model_klass.cache_proxy).to eq(string_model_klass.cache_proxy)
+            end
+        end
+
+        describe '#riak' do
+            it 'yields values from StringModel' do
+                expect(model_klass.riak).to eq(string_model_klass.riak)
+            end
+        end
+    end
+end

data/spec/rrrmatey/string_model/consumer_adapter_methods_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+class SomeModel
+    extend RRRMatey::StringModel::ConsumerAdapterMethods
+
+    attr_accessor :id, :name, :content_type
+
+    def self.object_from_hash(h, id, content_type)
+        sm = SomeModel.new()
+        sm.id = id
+        sm.content_type = content_type
+        sm.name = h[:name] || name
+        sm
+    end
+end
+
+describe RRRMatey::StringModel::ConsumerAdapterMethods do
+    describe '#from_params' do
+        let(:model_klass) { SomeModel }
+        let(:params) { { :id => 'di', :name => 'eman' } }
+        let(:model_params_id_content_type) { SomeModel.from_params(params, 'dis', :xml) }
+        let(:model_params_id) { SomeModel.from_params(params, 'dis') }
+        let(:model_params) { SomeModel.from_params(params) }
+
+        it 'yields a model from params hash, id, and content-type' do
+            expect(model_params_id_content_type.name).to eq(params[:name])
+            expect(model_params_id_content_type.id).to eq('dis')
+            expect(model_params_id_content_type.content_type).to eq(:xml)
+        end
+
+        it 'yields a model from params hash and id' do
+            expect(model_params_id.name).to eq(params[:name])
+            expect(model_params_id.id).to eq('dis')
+            expect(model_params_id.content_type).to eq(:json)
+        end
+
+        it 'yields a model from params hash' do
+            expect(model_params.name).to eq(params[:name])
+            expect(model_params.id).to eq(params[:id])
+            expect(model_params.content_type).to eq(:json)
+        end
+    end
+end

data/spec/rrrmatey/string_model/delete_methods_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe RRRMatey::StringModel::DeleteMethods do
+    context 'with or without cache_proxy setup' do
+        describe '#delete' do
+            let(:model) { StringModelKlass.new() }
+
+            it 'yields 0 if cache_proxy is not setup' do
+                model.id = 'di'
+                expect(model.delete()).to eq(0)
+            end
+        end
+    end
+
+    context 'with cache_proxy setup' do
+        describe '#delete' do
+            let(:model_klass) { StringModelKlass }
+            let(:model) {
+                m = model_klass.new()
+                m.class.cache_proxy = StringModelKlass::ConnPool.new(StringModelKlass::Conn.new)
+                m.class.cache_proxy.with { |c| c.set(model_klass.namespaced_key('di'), 'exists') }
+                m
+            }
+
+            it 'yields 0 if value was not in the store' do
+                model.id = 'dne'
+                expect(model.delete()).to eq(0)
+            end
+
+            it 'yields 1 if the value was in the store' do
+                model.id = 'di'
+                expect(model.delete()).to eq(1)
+            end
+        end
+    end
+end

data/spec/rrrmatey/string_model/field_definition_methods_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+class SomeFieldyModel
+    extend RRRMatey::StringModel::FieldDefinitionMethods
+
+    field :name, :type => :string
+    field :hornery, :type => :boolean
+    field :created, :type => :date
+    field :bounties, :type => :integer
+    field :ales, :type => :long
+    field :chins, :type => :double
+    field :corks, :type => :float
+end
+
+describe RRRMatey::StringModel::FieldDefinitionMethods do
+    let(:model_klass) { SomeFieldyModel }
+    let(:model) { SomeFieldyModel.new }
+
+    describe '#fields' do
+        it 'yields fields defined on the model' do
+            expect(model_klass.fields).to eq([:name_s, :hornery_b, :created_ti, :bounties_i, :ales_l, :chins_d, :corks_f])
+        end
+
+        it 'creates accessors for defined fields' do
+            expect(model.respond_to?(:name)).to be(true)
+            expect(model.respond_to?(:name=)).to be(true)
+        end
+
+        it 'allows fields to be defined programmatically' do
+            model_klass.fields(:name, :birth)
+            expect(model_klass.fields).to eq([:name, :birth])
+        end
+
+        it 'specializes initialize, mapping all opts set to field set ops' do
+            expect(model_klass.new(:name => 'eman').name).to eq('eman')
+        end
+    end
+
+    describe '#consumer_fields' do
+        it 'yields consumer fields' do
+            model_klass.fields(:name_s, :hornery_b, :created_ti, :bounties_i, :ales_l, :chins_d, :corks_f)
+            expect(model_klass.consumer_fields).to eq([:name, :hornery, :created, :bounties, :ales, :chins, :corks])
+        end
+    end
+
+    describe '#append_type' do
+        it 'raises for unsupported type' do
+            expect{model_klass.send(:append_type, :some_field, :some_unknown_type)}.to raise_error(RRRMatey::UnsupportedTypeError)
+        end
+    end
+end

data/spec/rrrmatey/string_model/find_methods_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+class FindModel
+    extend RRRMatey::StringModel::FindMethods
+
+    @@cache_proxy = nil
+    
+    def self.cache_proxy
+        @@cache_proxy
+    end
+    
+    def self.cache_proxy=(v)
+        @@cache_proxy = v
+    end
+
+    def self.item_name()
+        'find_model'
+    end
+
+    def self.namespace
+        'find_models'
+    end
+
+    def self.namespaced_key(id)
+        "#{namespace}:#{id}"
+    end
+
+    attr_accessor :id, :content_type
+    attr_accessor :name
+    attr_accessor :field_dne_d
+
+    def self.fields
+        [ :name_s, :field_dne_d ]
+    end
+
+    def self.consumer_fields
+        [ :name ]
+    end
+
+    class ConnPool
+        def initialize(conn)
+            @conn = conn
+        end
+
+        def with(&block)
+            block.call(@conn)
+        end
+    end
+
+    class Conn
+        attr_accessor :result
+
+        def get(id)
+            @result
+        end
+    end
+end
+
+describe RRRMatey::StringModel::FindMethods do
+    context 'with or without cache_proxy setup' do
+        let(:model_klass) { FindModel }
+
+        describe '#get' do
+            it 'returns nil if cache_proxy is not set' do
+                expect(model_klass.get('di')).to be(nil)
+            end
+
+            it 'returns nil if id is blank' do
+                expect(model_klass.get(nil)).to be(nil)
+            end
+        end
+    end
+
+    context 'with cache_proxy setup' do
+        let(:cache_proxy) { FindModel::Conn.new() }
+        let(:model_klass) {
+            m = FindModel
+            m.cache_proxy = FindModel::ConnPool.new(cache_proxy)
+            m
+        }
+
+        context 'with no value at key' do
+            let(:model) { model_klass.get('di') }
+
+            describe '#get' do
+                it 'returns object with id and content-type set' do
+                    expect(model.id).to eq('di')
+                    expect(model.content_type).to eq('application/json')
+                end
+            end
+        end
+
+        context 'with json value at key' do
+            let(:result) { '{"find_model":{"id":"di","name":"eman","field_dne_d":2.718}}' }
+            let(:model) {
+                m = model_klass
+                cache_proxy.result = result
+                m.get('di')
+            }
+
+            describe '#get' do
+                it 'returns object with fields set' do
+                    expect(model.id).to eq('di')
+                    expect(model.content_type).to eq('application/json')
+                    expect(model.name).to eq('eman')
+                end
+            end
+        end
+
+        context 'with xml value at key' do
+            let(:result) { '<root><find_model><id>di</id><name>eman</name><field_dne_d>2.718</field_dne_d></find_model></root>' }
+            let(:model) {
+                m = model_klass
+                cache_proxy.result = result
+                m.get('di')
+            }
+
+            describe '#get' do
+                it 'returns object with fields set' do
+                    expect(model.id).to eq('di')
+                    expect(model.content_type).to eq('application/xml')
+                    expect(model.name).to eq('eman')
+                end
+            end
+        end
+
+        context 'with string value at key' do
+            let(:result) { <<EOF
+id:di
+name:eman
+field_dne_d:2.718
+EOF
+            }
+            let(:model_klass_s) {
+                m = model_klass
+                cache_proxy.result = result
+                m
+            }
+
+            describe '#get' do
+                it 'raises UnparseableContentError' do
+                    expect{model_klass_s.get('di')}.to raise_error(RRRMatey::UnparseableContentError)
+                end
+            end
+        end
+    end
+end

data/spec/rrrmatey/string_model/index_methods_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+class IndexModel
+    extend RRRMatey::StringModel::IndexMethods
+
+    class ConnPool
+        def initialize(conn)
+            @conn = conn
+        end
+
+        def with(&block)
+            block.call(@conn)
+        end
+    end
+
+    class Conn
+        @@search_index_name =
+            @@search_index_term =
+            @@search_start =
+            @@search_rows =
+            @@search_sort = nil
+
+        def search_index_name
+            @@search_index_name
+        end
+
+        def search_index_term
+            @@search_index_term
+        end
+
+        def search_start
+            @@search_start
+        end
+
+        def search_rows
+            @@search_rows
+        end
+
+        def search_sort
+            @@search_sort
+        end
+
+        def self.mock_results(limit)
+            item_name_prefix = "#{IndexModel.item_name}."
+            {
+                'num_found' => 3,
+                'docs' => [
+                    {
+                        '_yz_rk' => 'di1',
+                        "#{item_name_prefix}name" => 'eman1'
+                    },
+                    {
+                        '_yz_rk' => 'di2',
+                        "#{item_name_prefix}name" => 'eman2'
+                    },
+                    nil,
+                    {
+                        '_yz_rk' => 'di3',
+                        "#{item_name_prefix}name" => 'eman3'
+                    }
+                ]
+            }
+        end
+
+        def search(index_name, index_term, opts = {})
+            @@search_index_name = index_name
+            @@search_index_term = index_term
+            @@search_start = opts[:start]
+            @@search_rows = opts[:rows]
+            @@search_sort = opts[:sort]
+
+            self.class.mock_results(@@search_rows)
+        end
+    end
+
+    def self.namespace()
+        'index_models'
+    end
+
+    def self.item_name()
+        'index_model'
+    end
+
+    def self.riak()
+        @riak
+    end
+
+    def self.riak=(v)
+        @riak = v
+    end
+
+    def self.object_from_hash(h, id, content_type)
+    end
+end
+
+describe RRRMatey::StringModel::IndexMethods do
+    context 'with or without riak setup' do
+        context 'index_name set' do
+            let(:model_klass) {
+                IndexModel.index_name = 'something_else'
+                IndexModel
+            }
+
+            describe '#index_name' do
+                it 'yields values from self' do
+                    expect(model_klass.index_name).to eq('something_else')
+                end
+            end
+        end
+
+        context 'index_name not set' do
+            let(:model_klass) {
+                IndexModel.index_name = nil
+                IndexModel
+            }
+            let(:offset) { 4 }
+            let(:limit) { 20 }
+            let(:empty_discrete_result) {
+                RRRMatey::DiscreteResult.new(:length => 0,
+                                             :offset => offset,
+                                             :discrete_length => limit,
+                                             :results => [])
+            }
+
+            describe '#index_name' do
+                it 'yields values from StringModel' do
+                    expect(model_klass.index_name).to eq('index_models')
+                end
+            end
+
+            describe '#list' do
+                let(:list_result) { model_klass.list(offset, limit) }
+
+                it 'yields an empty DiscreteResult' do
+                    expect(list_result.length).to eq(empty_discrete_result.length)
+                    expect(list_result.offset).to eq(empty_discrete_result.offset)
+                    expect(list_result.discrete_length).to eq(empty_discrete_result.discrete_length)
+                    expect(list_result.results).to eq(empty_discrete_result.results)
+                end
+            end
+
+            describe '#list_by' do
+                let(:list_by_result) { model_klass.list_by(offset, limit, :name => 'ema*') }
+
+                it 'yields an empty DiscreteResult' do
+
+                end
+            end
+        end
+    end
+
+    context 'with riak setup' do
+        let(:riak) { IndexModel::Conn.new() }
+        let(:riak_pool) { 
+            IndexModel::ConnPool.new(riak)
+        }
+        let(:model_klass) {
+            IndexModel.index_name = nil
+            IndexModel.riak = riak_pool
+            IndexModel
+        }
+        let(:offset) { 4 }
+        let(:limit) { 20 }
+        let(:results) { IndexModel::Conn.mock_results(limit) }
+        let(:result_docs) { results['docs'].select { |it| !it.nil? } }
+        let(:discrete_result) {
+            RRRMatey::DiscreteResult.new(:length => results.length,
+                                         :offset => offset,
+                                         :discrete_length => limit,
+                                         :results => results)
+        }
+
+        describe '#list' do
+            let(:list_result) { model_klass.list(offset, limit) }
+
+            it 'yields a hydrated DiscreteResult' do
+                expect(list_result.length).to eq(result_docs.length)
+            end
+
+            it 'passes the index_name to riak search' do
+                expect(riak.search_index_name).to eq(model_klass.index_name)
+            end
+
+            it 'passes the open index_term to riak search' do
+                expect(riak.search_index_term).to eq('*:*')
+            end
+
+            it 'passes the offset to riak search' do
+                expect(riak.search_start).to eq(offset)
+            end
+
+            it 'passes the limit to riak search' do
+                expect(riak.search_rows).to eq(limit)
+            end
+
+            it 'passes riak key ascending sort to riak search' do
+                expect(riak.search_sort).to eq('_yz_rk asc')
+            end
+        end
+
+        describe '#list_by' do
+            let(:list_result) { model_klass.list_by(offset, limit, :name => 'ema*',
+                                                    :birth => Date.today) }
+            let(:birth_date) { Date.today.to_s }
+
+            it 'yields a hydrated DiscreteResult' do
+                expect(list_result.length).to eq(result_docs.length)
+            end
+
+            it 'passes the index_name to riak search' do
+                expect(riak.search_index_name).to eq(model_klass.index_name)
+            end
+
+            it 'passes the specified index_term to riak search' do
+                expect(riak.search_index_term).to eq("index_model.name:ema* OR index_model.birth:#{birth_date}")
+            end
+
+            it 'passes the offset to riak search' do
+                expect(riak.search_start).to eq(offset)
+            end
+
+            it 'passes the limit to riak search' do
+                expect(riak.search_rows).to eq(limit)
+            end
+
+            it 'passes riak key ascending sort to riak search' do
+                expect(riak.search_sort).to eq('_yz_rk asc')
+            end
+        end
+    end
+end