rescue_groups 0.0.1

data/spec/lib/response_spec.rb

@@ -0,0 +1,99 @@
+require_relative '../spec_helper'
+require_relative '../../lib/response'
+
+module RescueGroups
+  describe Response do
+    subject { described_class.new(raw_response) }
+
+    describe 'instance variables' do
+      let(:raw_response) do
+        Class.new(Object) do
+          attr_reader :code
+          def parsed_response; {}; end
+        end.new
+      end
+
+      it 'has a parsed body' do
+        expect(subject.instance_variables).to include(:@parsed_body)
+      end
+
+      it 'has an http status code' do
+        expect(subject.instance_variables).to include(:@http_status_code)
+      end
+    end
+
+    describe '#success?' do
+      context 'a successful response' do
+        let(:raw_response) do
+          Class.new(Object) do
+            attr_reader :code
+            def parsed_response
+              {
+                'status' => "ok",
+                'data' => []
+              }
+            end
+          end.new
+        end
+
+        specify do
+          expect(subject).to be_success
+        end
+      end
+
+      context 'an errorful response' do
+        let(:raw_response) do
+          Class.new(Object) do
+            attr_reader :code
+            def parsed_response
+              JSON.parse(File.read("#{ File.dirname(__FILE__) }/../fixtures/error.json"))
+            end
+          end.new
+        end
+
+        specify do
+          expect(subject).to_not be_success
+        end
+      end
+    end
+
+    describe '#error' do
+      context 'errorful response' do
+        let(:raw_response) do
+          Class.new(Object) do
+            attr_reader :code
+            def parsed_response
+              JSON.parse(File.read("#{ File.dirname(__FILE__) }/../fixtures/error.json"))
+            end
+          end.new
+        end
+
+        it 'returns the error message' do
+          expect(subject.error).to_not be_nil
+        end
+
+        it 'does not return warning messages' do
+          expect(subject.error).to_not match(/You provided an invalid result sort field/)
+        end
+      end
+
+      context 'successful response' do
+        let(:raw_response) do
+          Class.new(Object) do
+            attr_reader :code
+            def parsed_response
+              {
+                'status' => 'ok',
+                'data' => {}
+              }
+            end
+          end.new
+        end
+
+        it 'returns nil ' do
+          expect(subject.error).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/models/animal_spec.rb

@@ -0,0 +1,131 @@
+require_relative '../spec_helper'
+require_relative '../../models/animal'
+require_relative '../support/model_spec'
+
+module RescueGroups
+  describe Animal do
+    known_attributes = { animalID: 12, animalDeclawed: true, animalName: :snuffles }
+    it_behaves_like 'a model', known_attributes
+
+    describe '#initialize' do
+      context 'picture are present' do
+
+        it 'extracts them' do
+          expect_any_instance_of(described_class).to receive(:extract_pictures)
+          described_class.find(TEST_ANIMAL_ID)
+        end
+
+        it 'is actual pictures' do
+          animal = described_class.find(TEST_ANIMAL_ID)
+          expect(animal.pictures).to_not be_empty
+          expect(animal.pictures.all? { |p| p.is_a?(Picture) }).to eq(true)
+        end
+      end
+    end
+
+    describe '.find' do
+      context 'animal is found' do
+        it 'does not raise error' do
+          expect do
+            described_class.find(TEST_ANIMAL_ID)
+          end.to_not raise_error
+        end
+
+        it 'finds and fills the animal' do
+          animal = described_class.find(TEST_ANIMAL_ID)
+          expect(animal.id.to_i).to eq(TEST_ANIMAL_ID)
+        end
+      end
+
+      context 'animal is not found' do
+        it 'raises an error' do
+          expect do
+            described_class.find(NOT_FOUND_ANIMAL_ID)
+          end.to raise_error("Unable to find #{ described_class } with id: #{ NOT_FOUND_ANIMAL_ID }")
+        end
+      end
+    end
+
+    describe '.where' do
+      context 'when only id is present' do
+        let(:id) { 1 }
+
+        it 'calls find instead' do
+          expect(described_class).to receive(:find).with(id)
+          described_class.where(id: id)
+        end
+      end
+
+      context 'with other conditions' do
+        let(:conditions) { { breed: TEST_ANIMAL_BREED } }
+
+        it 'adds conditions to search' do
+          expect_any_instance_of(AnimalSearch)
+            .to receive(:add_filter)
+            .with(:animalBreed, :equal, TEST_ANIMAL_BREED).and_call_original
+
+          described_class.where(conditions)
+        end
+
+        context 'when animals are found' do
+          it 'does not error' do
+            expect do
+              described_class.where(breed: TEST_ANIMAL_BREED)
+            end.to_not raise_error
+          end
+
+          it 'sets the breed correctly' do
+            animals = described_class.where(breed: TEST_ANIMAL_BREED)
+
+            expect(animals).to_not eq([])
+
+            animals.each do |animal|
+              expect(animal.breed).to_not be_nil
+            end
+          end
+        end
+
+        context 'when animals are not found' do
+          it 'does not error' do
+            expect do
+              described_class.where(breed: NOT_FOUND_ANIMAL_BREED)
+            end.to_not raise_error
+          end
+
+          it 'returns an empty array' do
+            animals = described_class.where(breed: NOT_FOUND_ANIMAL_BREED)
+            expect(animals).to eq([])
+          end
+        end
+      end
+    end
+
+    describe 'organization' do
+      it 'defines #organization' do
+        expect(subject).to respond_to(:organization)
+      end
+
+      it 'defines #organization=' do
+        expect(subject).to respond_to(:organization=)
+      end
+    end
+
+    describe '!#extract_pictures' do
+      let(:picture_attribute) { described_class.object_fields::FIELDS[:pictures] }
+      let(:pictures) { [{ test: :picture }, { foo: :bar }, { baz: :qux }] }
+
+      it 'intializes a new picture class per picture' do
+        pictures.each do |picture|
+          expect(RescueGroups::Picture).to receive(:new).with(picture).and_call_original
+        end
+
+        described_class.new(picture_attribute => pictures)
+      end
+
+      it 'turns the @pictures for the model into pictures' do
+        model = described_class.new(picture_attribute => pictures)
+        expect(model.pictures.all? { |p| p.is_a?(RescueGroups::Picture) }).to eq(true)
+      end
+    end
+  end
+end

data/spec/models/event_spec.rb

@@ -0,0 +1,105 @@
+require_relative '../spec_helper'
+require_relative '../support/model_spec'
+require_relative '../../models/event'
+
+module RescueGroups
+  describe Event do
+    known_attributes = begin
+      { eventID: 12, eventName: 'Great Event!', eventDescription: 'This is the great event.' }
+    end
+    it_behaves_like 'a model', known_attributes
+
+    describe '.find' do
+      context 'event is found' do
+        it 'does not raise error' do
+          expect do
+            described_class.find(TEST_EVENT_ID)
+          end.to_not raise_error
+        end
+
+        it 'finds and fills the event' do
+          event = described_class.find(TEST_EVENT_ID)
+          expect(event.id.to_i).to eq(TEST_EVENT_ID)
+        end
+      end
+
+      context 'event is not found' do
+        it 'raises an error' do
+          expect do
+            described_class.find(NOT_FOUND_EVENT_ID)
+          end.to raise_error("Unable to find #{ described_class } with id: #{ NOT_FOUND_EVENT_ID }")
+        end
+      end
+    end
+
+    describe '.where' do
+      context 'when only id is present' do
+        let(:id) { 1 }
+
+        it 'calls find instead' do
+          expect(described_class).to receive(:find).with(id)
+          described_class.where(id: id)
+        end
+      end
+
+      context 'with other conditions' do
+        let(:conditions) { { name: TEST_EVENT_NAME } }
+
+        it 'adds conditions to search' do
+          expect_any_instance_of(EventSearch)
+            .to receive(:add_filter)
+            .with(:eventName, :equal, TEST_EVENT_NAME)
+
+          allow_any_instance_of(RemoteClient)
+            .to receive_message_chain(:post_and_respond, :success?) { true }
+
+          allow_any_instance_of(RemoteClient)
+            .to receive_message_chain(:post_and_respond, :[]) { {} }
+
+          described_class.where(conditions)
+        end
+
+        context 'when events are found' do
+          it 'does not error' do
+            expect do
+              described_class.where(name: TEST_EVENT_NAME)
+            end.to_not raise_error
+          end
+
+          it 'sets the name correctly' do
+            events = described_class.where(name: TEST_EVENT_NAME)
+
+            expect(events).to_not eq([])
+
+            events.each do |event|
+              expect(event.name).to_not be_nil
+            end
+          end
+        end
+
+        context 'when events are not found' do
+          it 'does not error' do
+            expect do
+              described_class.where(name: NOT_FOUND_EVENT_NAME)
+            end.to_not raise_error
+          end
+
+          it 'returns an empty array' do
+            events = described_class.where(name: NOT_FOUND_EVENT_NAME)
+            expect(events).to eq([])
+          end
+        end
+      end
+    end
+
+    describe 'organization' do
+      it 'should define #organization' do
+        expect(subject).to respond_to(:organization)
+      end
+
+      it 'should define #organization=' do
+        expect(subject).to respond_to(:organization=)
+      end
+    end
+  end
+end

data/spec/models/organization_spec.rb

@@ -0,0 +1,112 @@
+require_relative '../spec_helper'
+require_relative '../support/model_spec'
+require_relative '../../models/organization'
+
+module RescueGroups
+  describe Organization do
+    known_attributes = { orgCountry: 'USA', orgName: 'That one dog house'}
+    it_behaves_like 'a model', known_attributes
+
+    describe '.find' do
+      context 'org is found' do
+        it 'does not raise error' do
+          expect do
+            described_class.find(TEST_ORG_ID)
+          end.to_not raise_error
+        end
+
+        it 'finds and fills the organization' do
+          org = described_class.find(TEST_ORG_ID)
+          expect(org.id.to_i).to eq(TEST_ORG_ID)
+        end
+      end
+
+      context 'org is not found' do
+        it 'raises an error' do
+          expect do
+            described_class.find(NOT_FOUND_ORG_ID)
+          end.to raise_error("Unable to find #{ described_class } with id: #{ NOT_FOUND_ORG_ID }")
+        end
+      end
+    end
+
+    describe '.where' do
+      context 'when only id is present' do
+        let(:id) { 1 }
+
+        it 'calls find instead' do
+          expect(described_class).to receive(:find).with(id)
+          described_class.where(id: id)
+        end
+      end
+
+      context 'with other conditions' do
+        let(:conditions) do
+          {
+            name: 'test name',
+            location_city: 'test city',
+          }
+        end
+
+        it 'adds conditions to search' do
+          expect_any_instance_of(OrganizationSearch)
+            .to receive(:add_filter)
+            .with(:orgName, :equal, 'test name')
+
+          expect_any_instance_of(OrganizationSearch)
+            .to receive(:add_filter)
+            .with(:orgCity, :equal, 'test city')
+
+          allow_any_instance_of(RemoteClient)
+            .to receive_message_chain(:post_and_respond, :success?) { true }
+
+          allow_any_instance_of(RemoteClient)
+            .to receive_message_chain(:post_and_respond, :[]) { {} }
+
+          described_class.where(conditions)
+        end
+
+        context 'when orgs are found' do
+          it 'does not error' do
+            expect do
+              described_class.where(name: TEST_ORG_NAME)
+            end.to_not raise_error
+          end
+
+          it 'sets the names correctly' do
+            orgs = described_class.where(name: TEST_ORG_NAME)
+
+            expect(orgs).to_not eq([])
+
+            orgs.each do |org|
+              expect(org.name).to_not be_nil
+            end
+          end
+        end
+
+        context 'when orgs are not found' do
+          it 'does not error' do
+            expect do
+              described_class.where(name: NOT_FOUND_ORG_NAME)
+            end.to_not raise_error
+          end
+
+          it 'returns an empty array' do
+            orgs = described_class.where(name: NOT_FOUND_ORG_NAME)
+            expect(orgs).to eq([])
+          end
+        end
+      end
+    end
+
+    describe '#animals' do
+      it 'defines #animals' do
+        expect(subject).to respond_to(:animals)
+      end
+
+      it 'defines #animals=' do
+        expect(subject).to respond_to(:animals=)
+      end
+    end
+  end
+end