rescue_groups 0.0.1

data/spec/lib/relationable_spec.rb

@@ -0,0 +1,113 @@
+require_relative '../spec_helper'
+require_relative '../../lib/relationable'
+
+module RescueGroups
+  class OtherClass;end
+
+  class YetAnotherClass
+    def self.where(anything); [] end
+  end
+
+  class IncludedClass
+    include Relationable
+    belongs_to :other_class
+    has_many :yet_another_classes
+
+    def initialize(other_class:, yet_another_classes:)
+      self.other_class         = other_class
+      self.yet_another_classes = yet_another_classes
+    end
+  end
+
+  describe 'Relationable' do
+    subject { IncludedClass.new(other_class: other_class, yet_another_classes: yet_another_classes) }
+    let(:other_class)         { nil }
+    let(:yet_another_classes) { nil }
+
+    describe '#belongs_to' do
+      it 'makes a setter method' do
+        expect(subject).to respond_to(:other_class=)
+      end
+
+      it 'makes a getter method' do
+        expect(subject).to respond_to(:other_class)
+      end
+
+      it 'makes a setter relationship_id method' do
+        expect(subject).to respond_to(:other_class_id=)
+      end
+
+      it 'makes a getter relationship_id method' do
+        expect(subject).to respond_to(:other_class_id)
+      end
+
+      context 'relationship model exists' do
+        let(:other_class) { OtherClass.new }
+        it 'returns a model of the specified class' do
+          expect(subject.other_class).to be_a(OtherClass)
+        end
+      end
+
+      context 'relationship model is nil' do
+        it 'returns nil' do
+          expect(subject.other_class).to be_nil
+        end
+      end
+
+      context 'relationship_id is set model is not present' do
+        let(:other_class_id) { 1 }
+        it 'fetches the model' do
+          subject.other_class_id = other_class_id
+          expect(OtherClass).to receive(:find).with(other_class_id)
+          subject.other_class
+        end
+      end
+    end
+
+    describe '#has_many' do
+      it 'makes a setter method' do
+        expect(subject).to respond_to(:yet_another_classes=)
+      end
+
+      it 'makes a getter method' do
+        expect(subject).to respond_to(:yet_another_classes)
+      end
+
+      context 'relationship models exist' do
+        let(:yet_another_class)   { YetAnotherClass.new }
+        let(:yet_another_classes) { [yet_another_class] }
+
+        context 'one model exists' do
+          it 'returns an array of size 1' do
+            expect(subject.yet_another_classes.length).to eq(1)
+          end
+
+          it 'the model in the relationship is of the specified class' do
+            subject.yet_another_classes.each do |yac|
+              expect(yac).to be_a(YetAnotherClass)
+            end
+          end
+        end
+
+        context 'more than one model exists' do
+          let(:yet_another_classes) { [YetAnotherClass.new, YetAnotherClass.new] }
+          it 'returns an array the size of the relationship' do
+            expect(subject.yet_another_classes.length).to eq(2)
+          end
+
+          it 'all models in the relationship are of the specified class' do
+            subject.yet_another_classes.each do |yac|
+              expect(yac).to be_a(YetAnotherClass)
+            end
+          end
+        end
+      end
+
+      context 'relationship model does not exist' do
+        it 'returns an empty array' do
+          expect(subject.yet_another_classes).to eq([])
+        end
+      end
+    end
+  end
+end

data/spec/lib/remote_client_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../spec_helper'
+require_relative '../../lib/remote_client'
+
+module RescueGroups
+  describe RemoteClient do
+    describe '#post_and_respond' do
+      before do
+        allow(Response).to receive(:new)
+      end
+
+      it 'calls the class post method' do
+        expect(described_class).to receive(:post)
+        subject.post_and_respond({})
+      end
+
+      context 'with no api key' do
+        before do
+          allow(RescueGroups.config).to receive(:apikey) { nil }
+        end
+
+        it 'raises an error' do
+          expect { subject.post_and_respond({}) }.to raise_error('No RescueGroups API Key set')
+        end
+      end
+    end
+  end
+end

data/spec/lib/requests/find_spec.rb

@@ -0,0 +1,97 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/requests/find'
+
+module RescueGroups
+  module Requests
+    describe Find do
+      class TestFields
+        FIELDS = {}
+        def self.all; end
+      end
+
+      test_model = Struct.new("TestModel")
+      test_client = Struct.new("TestClient")
+
+      describe '#initalize' do
+        subject { described_class.new(ids, anything, anything) }
+
+        let(:ids) { [1] }
+
+        it 'sets @ids to the passed in value' do
+          expect(subject.instance_variable_get(:@ids)).to eq(ids)
+        end
+
+        context 'a single id is given' do
+          let(:ids) { 42 }
+
+          it 'sets them correctly' do
+            expect(subject.instance_variable_get(:@ids)).to eq([ids])
+          end
+        end
+
+        context 'multiple ids are given' do
+          let(:ids) { [120, 203, 399] }
+
+          it 'sets them correctly' do
+            expect(subject.instance_variable_get(:@ids)).to eq(ids)
+          end
+
+          context 'with duplicates' do
+            let(:ids) { [101, 101, 120, 399, 120, 203, 399] }
+
+            it 'removes the duplicates' do
+              expect(subject.instance_variable_get(:@ids)).to eq(ids.uniq)
+            end
+          end
+        end
+
+        context 'something other than an integer or an array is given' do
+          let(:ids) { Object.new }
+
+          it 'raises error' do
+            expect { subject }.to raise_error(/Only initialize a Requests::Find/)
+          end
+        end
+      end
+
+      describe '#request' do
+        before do
+          allow(test_model).to receive(:object_type)
+          allow(test_model).to receive(:object_fields) { TestFields }
+        end
+
+        subject { described_class.new(1, test_model, test_client) }
+
+        it 'composes the request given the passed in objects' do
+          expect(subject.instance_variable_get(:@client)).to receive(:post_and_respond)
+          expect(subject).to receive(:as_json)
+          subject.request
+        end
+
+        context 'client is improper object' do
+          it 'raises error' do
+            expect { subject.request }.to raise_error(InvalidClient, /Invalid client/)
+          end
+        end
+      end
+
+      describe '#as_json' do
+        before do
+          allow(test_model).to receive(:object_type)
+          allow(test_model).to receive(:object_fields) { TestFields }
+        end
+
+        subject { described_class.new(1, test_model, anything) }
+
+        it 'has the correct keys' do
+          json_result = subject.as_json
+
+          expect(json_result).to have_key(:objectAction)
+          expect(json_result).to have_key(:objectType)
+          expect(json_result).to have_key(:fields)
+          expect(json_result).to have_key(:values)
+        end
+      end
+    end
+  end
+end

data/spec/lib/requests/where_spec.rb

@@ -0,0 +1,267 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/requests/where'
+
+module RescueGroups
+  module Requests
+    describe Where do
+      class TestFields
+        FIELDS = { some_test_field: 'SomeTestField' }
+        def self.all; end
+      end
+
+      class TestSearchEngine < Struct.new(:limit, :start, :sort, :order)
+        def add_filter(*args)
+        end
+      end
+
+      test_model = Struct.new('TestModel')
+      test_client = Struct.new('TestClient')
+
+      let(:conditions) { search_conditions }
+      let(:search_conditions) { {} }
+
+      subject { described_class.new(conditions, test_model, test_client, TestSearchEngine) }
+
+      describe '#initialize' do
+        it 'sets the conditions' do
+          expect(subject.instance_variable_get(:@conditions)).to eq(search_conditions)
+        end
+
+        context 'with search modifiers present' do
+          let(:limit) { 10 }
+          let(:start) { 30 }
+          let(:sort) { :breed }
+          let(:order) { :asc }
+          let(:conditions) { search_conditions.merge(limit: limit, start: start, sort: sort, order: order) }
+
+          it 'does not include the modifiers in the search conditions' do
+            expect(subject.instance_variable_get(:@conditions)).to eq(search_conditions)
+          end
+
+          context 'limit' do
+            it 'sets an instance variable for the modifier' do
+              expect(subject.instance_variable_get(:@limit)).to eq(limit)
+            end
+          end
+
+          context 'start' do
+            it 'sets an instance variable for the modifier' do
+              expect(subject.instance_variable_get(:@start)).to eq(start)
+            end
+          end
+
+          context 'sort' do
+            it 'sets an instance variable for the modifier' do
+              expect(subject.instance_variable_get(:@sort)).to eq(sort)
+            end
+          end
+
+          context 'order' do
+            it 'sets an instance variable for the modifier' do
+              expect(subject.instance_variable_get(:@order)).to eq(order)
+            end
+          end
+        end
+
+        it 'calls search_engine' do
+          expect_any_instance_of(described_class).to receive(:build_search_engine)
+          subject
+        end
+      end
+
+      describe '#request' do
+        let(:response) do
+          TestResponse.new(200,
+            { 'status' => 'ok', 'data' => {}, 'found_rows' => 0 })
+        end
+
+        before do
+          allow(test_model).to receive(:object_type)
+          allow(test_model).to receive(:object_fields) { TestFields }
+          allow_any_instance_of(TestSearchEngine).to receive(:as_json)
+        end
+
+        it 'composes the request given the passed in objects' do
+          expect(subject.instance_variable_get(:@client)).to receive(:post_and_respond) { response }
+          expect(subject).to receive(:as_json)
+          subject.request
+        end
+
+        context 'client is improper object' do
+          it 'raises error' do
+            expect { subject.request }.to raise_error(InvalidClient, /Invalid client.*Where/)
+          end
+        end
+      end
+
+      describe '#as_json' do
+        before do
+          allow(test_model).to receive(:object_type)
+          allow(test_model).to receive(:object_fields) { TestFields }
+          allow_any_instance_of(TestSearchEngine).to receive(:as_json)
+        end
+
+        it 'has the correct keys' do
+          json_result = subject.as_json
+
+          expect(json_result).to have_key(:objectAction)
+          expect(json_result).to have_key(:objectType)
+          expect(json_result).to have_key(:search)
+        end
+      end
+
+      describe '#can_request_more?' do
+        let(:response) { { 'data' => data, 'found_rows' => found_rows } }
+        let(:data) { {} }
+        let(:found_rows) { 0 }
+
+        before do
+          subject.instance_variable_set(:@results, response)
+        end
+
+        context 'response returns no results' do
+          it 'returns false' do
+            expect(subject.can_request_more?).to eq(false)
+          end
+        end
+
+        context 'response does not return a found_rows count' do
+          let(:found_rows) { nil }
+
+          it 'returns false' do
+            expect(subject.can_request_more?).to eq(false)
+          end
+        end
+
+        context 'response returns found_rows and results' do
+          let(:data) { { foo: anything, bar: anything } }
+
+          context 'returned rows is less than found_rows' do
+            let(:found_rows) { 3 }
+
+            it 'returns true' do
+              expect(subject.can_request_more?).to eq(true)
+            end
+          end
+
+          context 'returned rows is equal to found_rows' do
+            let(:found_rows) { 2 }
+
+            it 'returns false' do
+              expect(subject.can_request_more?).to eq(false)
+            end
+          end
+        end
+      end
+
+      describe '!#conditions_to_rescue_groups_key_value' do
+        before do
+          allow(test_model).to receive(:object_fields) { TestFields }
+          allow_any_instance_of(TestSearchEngine).to receive(:add_filter)
+        end
+
+        context 'all filters have mappings' do
+          let(:conditions) { { some_test_field: value } }
+          let(:value)      { 'foo' }
+
+          it 'yields to the block for all filters' do
+            expect do |b|
+              subject.send(:conditions_to_rescue_groups_key_value, &b)
+            end.to yield_with_args('SomeTestField', value)
+          end
+        end
+
+        context 'some filters have mappings, others do not' do
+          let(:conditions) { { some_test_field: value, another_test_field: anything } }
+          let(:value)      { 'foo' }
+
+          it 'yields to the block only for mapped filters' do
+            expect do |b|
+              subject.send(:conditions_to_rescue_groups_key_value, &b)
+            end.to yield_with_args('SomeTestField', value)
+          end
+        end
+
+        context 'no filters have mappings' do
+          let(:conditions) { { foo: :bar } }
+          it 'does not yield to the block' do
+            expect do |b|
+              subject.send(:conditions_to_rescue_groups_key_value, &b)
+            end.to_not yield_control
+          end
+        end
+
+        context 'no block is given' do
+          it 'raises an error' do
+            expect do
+              subject.send(:conditions_to_rescue_groups_key_value)
+            end.to raise_error(/Block not given/)
+          end
+        end
+      end
+
+      describe '!#build_search_engine' do
+        let(:instance_vars_to_set) { {} }
+
+        before do
+          instance_vars_to_set.each do |key, value|
+            subject.instance_variable_set(:"@#{ key }", value)
+          end
+        end
+
+        context 'modifiers exist in conditions' do
+          context 'multiple modifiers' do
+            let(:instance_vars_to_set) { { limit: 100, start: 100 } }
+
+            it 'initializes searh engine with all modifiers' do
+              expect(TestSearchEngine).to receive(:new).with(limit: 100, start: 100)
+              subject.send(:build_search_engine, TestSearchEngine)
+            end
+          end
+
+          context 'a single modifier' do
+            let(:instance_vars_to_set) { { limit: 10 } }
+
+            it 'initializes searh engine with the modifier' do
+              expect(TestSearchEngine).to receive(:new).with(limit: 10)
+              subject.send(:build_search_engine, TestSearchEngine)
+            end
+          end
+        end
+
+        context 'modifiers do not exist in the conditions' do
+          it 'initializes searh engine without any args' do
+            subject
+            expect(TestSearchEngine).to receive(:new).with({})
+            subject.send(:build_search_engine, TestSearchEngine)
+          end
+        end
+      end
+
+      describe '!#add_filters_to_search_engine' do
+        context 'conditions are not empty' do
+          let(:conditions) { { foo: :bar } }
+
+          before do
+            allow_any_instance_of(described_class)
+              .to receive(:conditions_to_rescue_groups_key_value).with(no_args).and_yield(:foo, :bar)
+          end
+
+          it 'calls add_filter per condition' do
+            subject
+            expect_any_instance_of(TestSearchEngine)
+              .to receive(:add_filter).with(:foo, :equal, :bar)
+            subject.send(:add_filters_to_search_engine, TestSearchEngine.new)
+          end
+        end
+
+        context 'conditions are empty' do
+          it 'does not call add_filter' do
+            expect_any_instance_of(TestSearchEngine).to_not receive(:add_filter)
+            subject.send(:add_filters_to_search_engine, TestSearchEngine.new)
+          end
+        end
+      end
+    end
+  end
+end