rescue_groups 0.0.1

data/spec/models/picture_spec.rb

@@ -0,0 +1,87 @@
+require_relative '../spec_helper'
+require_relative '../../models/picture'
+
+module RescueGroups
+  describe Picture do
+    describe '#initialize' do
+      context 'given a list of rescue groups attributes' do
+        let(:attributes) do
+          {}.tap do |attrs|
+            PictureField::FIELDS.keys.sample(5).each do |key|
+              attrs[key] = anything
+            end
+          end
+        end
+
+        it 'maps the attributes' do
+          picture = described_class.new(attributes)
+
+          attributes.keys.each do |attr_name|
+            mapped_key = PictureField::FIELDS[attr_name]
+            expect(picture.send(mapped_key)).to_not be_nil
+          end
+        end
+
+        context 'unknown attributes are present' do
+          it 'does not map them' do
+            picture = described_class.new(attributes.merge(foo: :bar))
+
+            attributes.keys.each do |attr_name|
+              mapped_key = PictureField::FIELDS[attr_name]
+              expect(picture.send(mapped_key)).to_not be_nil
+            end
+
+            expect(picture.instance_variable_get(:@foo)).to be_nil
+          end
+        end
+      end
+
+      context 'given a list of random attributes' do
+        let(:attributes) {{ foo: :bar, baz: :qux }}
+
+        it 'does not make any instance variables' do
+          expect(described_class.new(attributes).instance_variables).to be_empty
+        end
+      end
+    end
+
+    describe '#url' do
+      context 'secure' do
+        it 'calls the secure attribute' do
+          expect(subject).to receive(:url_full)
+          subject.url(secure: true)
+        end
+      end
+
+      context 'default behaviour' do
+        it 'calls the default attribute' do
+          expect(subject).to receive(:insecure_url_full)
+          subject.url
+        end
+      end
+    end
+
+    describe '#url_thumb' do
+      context 'secure' do
+        it 'calls the secure attribute' do
+          expect(subject).to receive(:url_thumbnail)
+          subject.url_thumb(secure: true)
+        end
+      end
+
+      context 'default behaviour' do
+        it 'calls the default attribute' do
+          expect(subject).to receive(:insecure_url_thumb)
+          subject.url_thumb
+        end
+      end
+    end
+
+    describe '#animal' do
+      it { expect(subject).to respond_to(:animal) }
+      it { expect(subject).to respond_to(:animal=) }
+      it { expect(subject).to respond_to(:animal_id) }
+      it { expect(subject).to respond_to(:animal_id=) }
+    end
+  end
+end

data/spec/search/animal_search_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../support/searchable_spec'
+require_relative '../../search/animal_search'
+
+module RescueGroups
+  describe AnimalSearch do
+    it_behaves_like 'a searchable'
+  end
+end

data/spec/search/event_search_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../support/searchable_spec'
+require_relative '../../search/event_search'
+
+module RescueGroups
+  describe EventSearch do
+    it_behaves_like 'a searchable'
+  end
+end

data/spec/search/filter_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../../search/filter'
+
+module RescueGroups
+  describe Filter do
+    subject { described_class.new(name, operation, criteria) }
+    let(:name)      { 'some attribute' }
+    let(:operation) { described_class::OPERATIONS.keys.sample }
+    let(:criteria)  { 'the correct thing' }
+
+    describe '#initialize' do
+      it 'sets instance variables' do
+        expect(subject.instance_variables).to include(:@name)
+        expect(subject.name).to_not be_nil
+        expect(subject.instance_variables).to include(:@operation)
+        expect(subject.operation).to_not be_nil
+        expect(subject.instance_variables).to include(:@criteria)
+        expect(subject.criteria).to_not be_nil
+      end
+
+      context 'with an uknown operation' do
+        let(:operation) { :banana }
+        it 'raises an exception about an unknown operator' do
+          expect { subject }.to raise_error(described_class::InvalidFilter)
+        end
+      end
+    end
+
+    describe '#as_json' do
+      context 'with valid attributes' do
+        it 'returns a hash with all pertinent keys' do
+          result = subject.as_json
+          expect(result).to have_key(:fieldName)
+          expect(result).to have_key(:operation)
+          expect(result).to have_key(:criteria)
+        end
+      end
+    end
+  end
+end

data/spec/search/organization_search_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../support/searchable_spec'
+require_relative '../../search/organization_search'
+
+module RescueGroups
+  describe OrganizationSearch do
+    it_behaves_like 'a searchable'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,340 @@
+require_relative '../rescue_groups'
+
+RescueGroups.configuration do |config|
+  config.apikey = 'test_api_key'
+end
+
+require 'pry'
+require 'webmock/rspec'
+require_relative './fixtures/test_constants'
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+class TestResponse
+  attr_reader :http_status_code, :parsed_body
+
+  def initialize(code, body)
+    @http_status_code = http_status_code
+    @parsed_body      = body
+  end
+
+  def [](attribute)
+    parsed_body[attribute]
+  end
+
+  def success?
+    @parsed_body['status'] != 'error'
+  end
+
+  def error
+    'It did not work'
+  end
+end
+
+RSpec.configure do |config|
+  fixtures_dir = "#{ File.dirname(__FILE__) }/fixtures/"
+  post_url     = 'https://api.rescuegroups.org/http/json'
+  headers      = { 'Content-Type' => 'application/json' }
+  SUCCESS      = 200
+  NOT_FOUND    = 404
+
+  config.before(:each) do
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicView,
+          objectType: :orgs,
+          fields: RescueGroups::OrganizationField.all,
+          values: [{ orgID: TEST_ORG_ID }],
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: File.read("#{ fixtures_dir }/organization/find.json"),
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicView,
+          objectType: :orgs,
+          fields: RescueGroups::OrganizationField.all,
+          values: [{ orgID: NOT_FOUND_ORG_ID }],
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: NOT_FOUND,
+        body: '{}',
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicSearch,
+          objectType: :orgs,
+          search: {
+            resultStart: 0,
+            resultLimit: 100,
+            resultSort: nil,
+            resultOrder: :asc,
+            calcFoundRows: 'Yes',
+            filters: [{
+              fieldName: :orgName,
+              operation: :equal,
+              criteria: TEST_ORG_NAME
+            }],
+            fields: RescueGroups::OrganizationField.all,
+          },
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: File.read("#{ fixtures_dir }/organization/where.json"),
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicSearch,
+          objectType: :orgs,
+          search: {
+            resultStart: 0,
+            resultLimit: 100,
+            resultSort: nil,
+            resultOrder: :asc,
+            calcFoundRows: 'Yes',
+            filters: [{
+              fieldName: :orgName,
+              operation: :equal,
+              criteria: NOT_FOUND_ORG_NAME
+            }],
+            fields: RescueGroups::OrganizationField.all,
+          },
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: '{ "data": {} }',
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicSearch,
+          objectType: :animals,
+          search: {
+            resultStart: 0,
+            resultLimit: 100,
+            resultSort: nil,
+            resultOrder: :asc,
+            calcFoundRows: 'Yes',
+            filters: [{
+              fieldName: :animalBreed,
+              operation: :equal,
+              criteria: TEST_ANIMAL_BREED
+            }],
+            fields: RescueGroups::AnimalField.all,
+          },
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: File.read("#{ fixtures_dir }/animal/where.json"),
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicSearch,
+          objectType: :animals,
+          search: {
+            resultStart: 0,
+            resultLimit: 100,
+            resultSort: nil,
+            resultOrder: :asc,
+            calcFoundRows: 'Yes',
+            filters: [{
+              fieldName: :animalOrgID,
+              operation: :equal,
+              criteria: TEST_ORG_ID
+            }],
+            fields: RescueGroups::AnimalField.all,
+          },
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: File.read("#{ fixtures_dir }/animal/where.json"),
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicSearch,
+          objectType: :animals,
+          search: {
+            resultStart: 0,
+            resultLimit: 100,
+            resultSort: nil,
+            resultOrder: :asc,
+            calcFoundRows: 'Yes',
+            filters: [{
+              fieldName: :animalBreed,
+              operation: :equal,
+              criteria: NOT_FOUND_ANIMAL_BREED
+            }],
+            fields: RescueGroups::AnimalField.all,
+          },
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: '{ "data": {} }',
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicView,
+          objectType: :animals,
+          fields: RescueGroups::AnimalField.all,
+          values: [{ animalID: TEST_ANIMAL_ID }],
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: File.read("#{ fixtures_dir }/animal/find.json"),
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicView,
+          objectType: :animals,
+          fields: RescueGroups::AnimalField.all,
+          values: [{ animalID: NOT_FOUND_ANIMAL_ID }],
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: NOT_FOUND,
+        body: '{}',
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicView,
+          objectType: :events,
+          fields: RescueGroups::EventField.all,
+          values: [{ eventID: TEST_EVENT_ID }],
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: File.read("#{ fixtures_dir }/event/find.json"),
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicView,
+          objectType: :events,
+          fields: RescueGroups::EventField.all,
+          values: [{ eventID: NOT_FOUND_EVENT_ID }],
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: NOT_FOUND,
+        body: '{}',
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicSearch,
+          objectType: :events,
+          search: {
+            resultStart: 0,
+            resultLimit: 100,
+            resultSort: nil,
+            resultOrder: :asc,
+            calcFoundRows: 'Yes',
+            filters: [{
+              fieldName: :eventName,
+              operation: :equal,
+              criteria: TEST_EVENT_NAME
+            }],
+            fields: RescueGroups::EventField.all,
+          },
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: File.read("#{ fixtures_dir }/event/where.json"),
+        headers: headers)
+
+    stub_request(
+      :post,
+      post_url)
+      .with(
+        body: JSON({
+          objectAction: :publicSearch,
+          objectType: :events,
+          search: {
+            resultStart: 0,
+            resultLimit: 100,
+            resultSort: nil,
+            resultOrder: :asc,
+            calcFoundRows: 'Yes',
+            filters: [{
+              fieldName: :eventName,
+              operation: :equal,
+              criteria: NOT_FOUND_EVENT_NAME
+            }],
+            fields: RescueGroups::EventField.all,
+          },
+          apikey: 'test_api_key'
+        }),
+        headers: headers)
+      .to_return(
+        status: SUCCESS,
+        body: '{ "data": {} }',
+        headers: headers)
+  end
+end