data-com-api 0.0.1 → 0.1.0

data/spec/integration/client_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'faker'
+require 'data-com-api/responses/search_contact'
+require 'data-com-api/responses/search_company'
+require 'data-com-api/responses/company_contact_count'
+require 'data-com-api/responses/contacts'
+require 'data-com-api/client'
+require 'data-com-api/company_contact_count/department'
+require 'data-com-api/company_contact_count/level'
+require 'data-com-api/contact'
+
+describe DataComApi::Client do
+
+  subject(:client) { FactoryGirl.build(:client) }
+
+  describe "#search_contact" do
+
+    it "has records when searched with no params" do
+      DataComApiStubRequests.stub_search_contact(
+        total_hits: 10
+      )
+
+      expect(client.search_contact.size).to be > 0
+    end
+
+    context "when searching by firstname" do
+      before do
+        DataComApiStubRequests.stub_search_few_contacts(
+          total_hits: 1,
+          query: {
+            firstname: 'Dummy'
+          },
+          records: FactoryGirl.build_list(:data_com_contact, 1,
+            firstname: 'Dummy'
+          )
+        )
+
+        DataComApiStubRequests.stub_search_few_contacts(
+          total_hits: 0,
+          query: {
+            firstname: 'DoesntExist'
+          }
+        )
+      end
+
+      it "with firstname Dummy it has records with Dummy as firstname" do
+        expect(
+          client.search_contact(firstname: 'Dummy').all.first.first_name
+        ).to eq('Dummy')
+      end
+
+      it "with firstname DoesntExist it doesn't find records" do
+        expect(client.search_contact(firstname: 'DoesntExist').all.first).to be_nil
+      end
+
+    end
+
+  end
+
+  describe "#company_contact_count" do
+    before do
+      DataComApiStubRequests.stub_company_contact_count(
+        company_id,
+        total_count: contacts_count
+      )
+    end
+
+    let!(:company_id)     {  1 }
+    let!(:contacts_count) { 10 }
+
+    it { expect(client.company_contact_count(company_id).size).to eq contacts_count }
+    it { expect(client.company_contact_count(company_id).url).not_to be_blank }
+
+    it "has some levels" do
+      expect(client.company_contact_count(company_id).levels).not_to be_empty
+    end
+
+    it "has some departments" do
+      expect(client.company_contact_count(company_id).departments).not_to be_empty
+    end
+
+    it "doesn't have nil levels" do
+      client.company_contact_count(company_id).levels.each do |level|
+        expect(level).to be_an_instance_of DataComApi::CompanyContactCount::Level
+      end
+    end
+
+    it "doesn't have nil departments" do
+      client.company_contact_count(company_id).departments.each do |department|
+        expect(department).to be_an_instance_of DataComApi::CompanyContactCount::Department
+      end
+    end
+
+  end
+
+  describe "#contact" do
+    before do
+      DataComApiStubRequests.stub_contacts(
+        contact_ids,
+        username:           username,
+        password:           password,
+        purchase_flag:      purchase_flag,
+        total_hits:         total_hits,
+        used_points:        used_points,
+        purchased_contacts: purchased_contacts,
+        point_balance:      point_balance
+      )
+    end
+
+    let!(:contact_ids)        { [1, 2]                    }
+    let!(:username)           { Faker::Internet.user_name }
+    let!(:password)           { Faker::Internet.password  }
+    let!(:purchase_flag)      { false                     }
+    let!(:total_hits)         { 1                         }
+    let!(:used_points)        { 2000                      }
+    let!(:purchased_contacts) { 1                         }
+    let!(:point_balance)      { 4818                      }
+
+    it "has used some points" do
+      expect(
+        client.contacts(contact_ids, username, password, purchase_flag).used_points
+      ).to be > 0
+    end
+
+    it "has found some records" do
+      expect(
+        client.contacts(contact_ids, username, password, purchase_flag).size
+      ).to eq total_hits
+    end
+
+    it "has purchased some contacts" do
+      expect(
+        client.contacts(contact_ids, username, password, purchase_flag).purchased_contacts
+      ).to eq purchased_contacts
+    end
+
+    it "reports new point balance" do
+      expect(
+        client.contacts(contact_ids, username, password, purchase_flag).point_balance
+      ).to eq point_balance
+    end
+
+    it "has some contacts" do
+      expect(
+        client.contacts(
+          contact_ids,
+          username,
+          password,
+          purchase_flag
+        ).contacts
+      ).not_to be_empty
+    end
+
+    it "doesn't have nil contacts" do
+      client.contacts(
+        contact_ids,
+        username,
+        password,
+        purchase_flag
+      ).contacts.each do |contact|
+        expect(contact).to be_an_instance_of DataComApi::Contact
+      end
+    end
+
+  end
+
+end

data/spec/integration/webmock_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'data-com-api/query_parameters'
+
+describe WebMock do
+  let!(:dummy_url) { 'http://dummyurl.com' }
+
+  before do
+    # Be careful, when stubbing, all values must be strings
+    stub_request(
+      :get,
+      dummy_url
+    ).with(
+      query: hash_including(DataComApi::QueryParameters.stringify_hash_values({
+        param1: 5,
+        param2: 'random1'
+      }))
+    ).to_return(
+      body: 'body 1'
+    )
+  end
+
+  it "receive a request when mocked with query param" do
+    expect(
+      HTTParty.get(dummy_url, {
+        query: {
+          param1: 5,
+          param2: 'random1',
+          param3: 'random3'
+        }
+      }).body
+    ).to eq 'body 1'
+  end
+
+end

data/spec/models/client_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+require 'data-com-api/contact'
+require 'data-com-api/responses/base'
+require 'data-com-api/responses/search_contact'
+require 'data-com-api/api_uri'
+require 'data-com-api/client'
+
+describe DataComApi::Client do
+
+  subject(:client) do
+    clt           = FactoryGirl.build(:client)
+    clt.page_size = 2
+
+    clt
+  end
+
+  it "has a valid factory" do
+    expect{client}.not_to raise_error
+  end
+
+  context "env #{ described_class::ENV_NAME_TOKEN } empty" do
+    before do
+      @env_data_com_token                  = ENV[described_class::ENV_NAME_TOKEN]
+      ENV[described_class::ENV_NAME_TOKEN] = nil
+    end
+
+    after do
+      ENV[described_class::ENV_NAME_TOKEN] = @env_data_com_token
+    end
+
+    it ".new raises error when both no token passed and no env DATA_COM_TOKEN set" do
+      expect{described_class.new}.to raise_error DataComApi::TokenFailError
+    end
+
+  end
+
+  describe "#page_size=" do
+
+    it "accepts values between 1 and 100" do
+      expect{client.page_size = Random.rand(100) + 1}.not_to raise_error
+    end
+
+    it "doesn't accept values > 100" do
+      expect{client.page_size = 101}.to raise_error DataComApi::ParamError
+    end
+
+    it "doesn't accept values < 1" do
+      expect{client.page_size = 0}.to raise_error DataComApi::ParamError
+    end
+
+  end
+
+  describe "#search_contact" do
+
+    it "is an instance of SearchContact" do
+      DataComApiStubRequests.stub_search_contact(
+        page_size:  client.page_size,
+        total_hits: 6
+      )
+
+      expect(client.search_contact).to be_an_instance_of DataComApi::Responses::SearchContact
+    end
+
+    it "calls search_contact_raw_json on client" do
+      DataComApiStubRequests.stub_search_contact(
+        page_size:  client.page_size,
+        total_hits: 6
+      )
+      expect(client).to receive(:search_contact_raw_json).once.and_call_original
+
+      client.search_contact.size
+    end
+
+    describe "#all" do
+      [0, 2, 4, 10, 11, 15].each do |total_contacts_count|
+        context "with #{ total_contacts_count } total_hits" do
+          before do
+            DataComApiStubRequests.stub_search_contact(
+              page_size:  client.page_size,
+              total_hits: total_contacts_count
+            )
+          end
+
+          it "is an array containing only Contact records" do
+            search_contact = client.search_contact
+
+            search_contact.all.each do |contact|
+              expect(contact).to be_an_instance_of DataComApi::Contact
+            end
+          end
+
+          it "is an array containing all records possible for request" do
+            expect(client.search_contact.all.size).to eq total_contacts_count
+          end
+
+        end
+      end
+
+      it "doesn't have more records than max_size" do
+        max_offset       = 10
+        client.page_size = 2
+        max_size         = max_offset + client.page_size
+        client.stub(:max_offset).and_return(max_offset)
+
+        DataComApiStubRequests.stub_search_contact(
+          page_size:  client.page_size,
+          total_hits: 25
+        )
+
+        expect(client.search_contact.all.size).to eq max_size
+      end
+
+      it "doesn't have more records than max_size when page size is odd" do
+        max_offset        = 10
+        client.page_size  = 3
+        max_size          = max_offset - (max_offset % client.page_size)
+        max_size         += client.page_size
+        client.stub(:max_offset).and_return(max_offset)
+
+        DataComApiStubRequests.stub_search_contact(
+          page_size:  client.page_size,
+          total_hits: 25
+        )
+
+        expect(client.search_contact.all.size).to eq max_size
+      end
+
+      it "doesn't have records when total_hits is 0" do
+        DataComApiStubRequests.stub_search_contact(
+          page_size:  client.page_size,
+          total_hits: 0
+        )
+
+        expect(client.search_contact.all.size).to eq 0
+      end
+    end
+
+    describe "#each" do
+      before do
+        DataComApiStubRequests.stub_search_contact(
+          page_size:  client.page_size,
+          total_hits: total_contacts_count
+        )
+      end
+
+      let!(:total_contacts_count) { 10 }
+
+      it "is an array containing only Contact records" do
+        search_contact = client.search_contact
+
+        search_contact.all.each do |contact|
+          expect(contact).to be_an_instance_of DataComApi::Contact
+        end
+      end
+
+      it "is an array containing all records possible for request" do
+        expect(client.search_contact.all.size).to eq total_contacts_count
+      end
+
+    end
+
+  end
+
+end

data/spec/models/query_parameters_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'data-com-api/query_parameters'
+
+describe DataComApi::QueryParameters do
+
+  subject(:query_parameters) { FactoryGirl.build(:query_parameters) }
+
+  it "has a valid factory" do
+    expect{query_parameters}.not_to raise_error
+  end
+
+  describe "#updated_since" do
+
+    it "returns time object" do
+      current_time = Time.now.utc.in_time_zone(DataComApi::Client::TIME_ZONE)
+      query_parameters.updated_since = current_time.to_s
+
+      expect(query_parameters.updatedSince).to be_an_instance_of ActiveSupport::TimeWithZone
+    end
+
+    it "returns same time as the one assigned" do
+      current_time = Time.now.utc.in_time_zone(DataComApi::Client::TIME_ZONE)
+      query_parameters.updated_since = current_time.to_s
+
+      # XXX: Be careful, comparison between the two ActiveSupport::TimeWithZone
+      #      fails for unknown reasons to me, even if to_i and to_s are equal.
+      #      Comparison through strings seems ok by the way because the class
+      #      will just output data directly to the API, so string based
+      expect(query_parameters.updatedSince.to_s).to eq(current_time.to_s)
+    end
+
+  end
+
+  it "has only string values when converted to_hash" do
+    query_parameters.pageSize = 5
+
+    expect(
+      query_parameters.to_hash['pageSize']
+    ).to eq query_parameters.pageSize.to_s
+  end
+
+end

data/spec/models/search_base_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'data-com-api/client'
+require 'data-com-api/contact'
+require 'data-com-api/responses/base'
+require 'data-com-api/responses/search_base'
+require 'data-com-api/responses/search_contact'
+
+describe DataComApi::Responses::SearchBase do
+
+  let!(:client) { FactoryGirl.build(:client) }
+  subject(:search_base_response) do
+    FactoryGirl.build(:responses_search_contact, client: client)
+  end
+
+  # Params: options, which are params passed to the request which will be
+  #         converted into query params for url
+  describe "#perform_request" do
+
+    it { expect(search_base_response).to respond_to :perform_request }
+    it { expect{search_base_response.send(:perform_request)}.to raise_error ArgumentError }
+
+    it "has correct totalHits value when size called" do
+      total_size = 42
+      client.stub(:search_contact_raw_json).and_return({ 'totalHits' => total_size })
+
+      expect(search_base_response.size).to be total_size
+    end
+
+  end
+
+  # Params: request, which is the requested data in json format
+  describe "#transform_request" do
+
+    it { expect(search_base_response).to respond_to :transform_request }
+    it { expect{search_base_response.send(:transform_request)}.to raise_error ArgumentError }
+
+    it "is called when we try to access page data" do
+      client.stub(:search_contact_raw_json).and_return(
+        FactoryGirl.build(:data_com_search_contact_response, totalHits: 10)
+      )    
+      expect(search_base_response).to receive(:transform_request).and_call_original
+
+      search_base_response.all
+    end
+
+    it "has correct types for all records after transformation" do
+      client.stub(:search_contact_raw_json).and_return(
+        FactoryGirl.build(:data_com_search_contact_response, totalHits: 10)
+      )
+
+      search_base_response.each do |contact|
+        expect(contact).to be_an_instance_of DataComApi::Contact
+      end
+    end
+
+  end
+
+  describe "#size" do
+  
+    it "has 32 records for 32 records" do
+      client.page_size = 3
+      client.stub(:search_contact_raw_json).and_return(
+        FactoryGirl.build(:data_com_search_contact_response, totalHits: 32)
+      )
+
+      expect(client.search_contact.size).to be 32
+    end
+  
+    it "has 0 records for 0 records" do
+      client.page_size = 1
+      client.stub(:search_contact_raw_json).and_return(
+        FactoryGirl.build(:data_com_search_contact_response, totalHits: 0)
+      )
+
+      expect(client.search_contact.size).to be 0
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,8 +1,28 @@
-require 'factories'
+require 'pry'
+require 'pathname'
+require 'webmock/rspec'
+require 'factory_girl'
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+factories_path = Pathname.new(File.expand_path('..', __FILE__))
+factories_path = factories_path.join('factories', '**', '*.rb')
+Dir[factories_path].each { |f| require f }
+
+support_path = Pathname.new(File.expand_path('..', __FILE__))
+support_path = support_path.join('support', '**', '*.rb')
+Dir[support_path].each { |f| require f }
 
 RSpec.configure do |config|
+  # Fix for faker deprecation message
+  I18n.enforce_available_locales                         = true
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered                = true
-  config.filter_run :focus
   config.order                                           = 'random'
+  config.filter_run           :focus
+  config.filter_run_excluding broken: true
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 end