Implement some specs

Author: mattapayne

lib/freshdesk_api_v2/base.rb

@@ -4,43 +4,43 @@ def initialize(http)
       @http = http
     end
 
-    def list(options = {})
-      per_page = value_from_options(options, :per_page) || Utils::MAX_PAGE_SIZE
+    def list(pagination_options = {})
+      per_page = pagination_options[:per_page] || Utils::MAX_PAGE_SIZE
       raise PaginationException, "Max per page is #{Utils::MAX_PAGE_SIZE}" if per_page.to_i > Utils::MAX_PAGE_SIZE
-      first_page, last_page = extract_pagination(options)
-      validate_pagination!(first_page, last_page)
-      http_list(first_page, last_page, per_page)
+      first_page, last_page = extract_list_pagination(pagination_options)
+      validate_list_pagination!(first_page, last_page)
+      paginated_get(first_page, last_page, per_page)
     end
 
     # TODO - Note that queries that by email or things that have special characters to not work yet in
     # Freshdesk
-    def search(query, options = {})
+    def search(query, pagination_options = {})
       raise SearchException, 'You must provide a query' if query.nil?
       raise SearchException, 'You must provide a query of type FreshdeskApiV2::SearchArgs' unless query.is_a?(FreshdeskApiV2::SearchArgs)
       raise SearchException, 'You must provide a query' unless query.valid?
-      first_page, last_page = extract_pagination(options)
-      validate_pagination!(first_page, last_page)
-      http_search(query.to_query, first_page, last_page)
+      first_page, last_page = extract_search_pagination(pagination_options)
+      validate_search_pagination!(first_page, last_page)
+      paginated_search(query.to_query, first_page, last_page)
     end
 
     def show(id)
-      http_show(id)
+      get(id)
     end
 
     def create(attributes)
       validate_create_attributes!(attributes)
       attributes = prepare_attributes!(attributes)
-      http_create(attributes)
+      post(attributes)
     end
 
     def update(id, attributes)
       validate_update_attributes!(attributes)
       attributes = prepare_attributes!(attributes)
-      http_update(id, attributes)
+      put(id, attributes)
     end
 
     def destroy(id)
-      http_destroy(id)
+      delete(id)
     end
 
     protected
@@ -59,11 +59,19 @@ def validate_update_attributes!(attributes)
         raise UpdateException, 'Please provide attributes' if attributes.nil? || attributes.count == 0
       end
 
-      def validate_pagination!(first_page, last_page)
+      def validate_list_pagination!(first_page, last_page)
         raise PaginationException, 'first_page must be a number greater than 0' if first_page.to_i <= 0
         raise PaginationException, 'last_page must be a number greater than or equal to first_page' if last_page.to_i < first_page.to_i
       end
 
+      def validate_search_pagination!(first_page, last_page)
+        raise PaginationException, 'first_page must be a number greater than 0' if first_page.to_i <= 0
+        unless last_page.nil?
+          raise PaginationException, "last_page cannot exceed #{Utils::MAX_SEARCH_PAGES}" if last_page.to_i > Utils::MAX_SEARCH_PAGES
+          raise PaginationException, 'last_page must be a number greater than or equal to first_page' if last_page.to_i < first_page.to_i
+        end
+      end
+
       def prepare_attributes!(attributes)
         clean = attributes.reject { |key, value | !allowed_attributes.include?(key) || value.nil? }
         custom_fields = clean['custom_fields']
@@ -76,47 +84,47 @@ def prepare_attributes!(attributes)
 
     private
 
-      def http_show(id)
+      def get(id)
         response = @http.get("#{api_url}/#{id}")
         JSON.parse(response.body)
       end
 
-      def http_create(attributes)
+      def post(attributes)
         response = @http.post("#{api_url}", attributes)
         JSON.parse(response.body)
       end
 
-      def http_destroy(id)
+      def delete(id)
         response = @http.delete("#{api_url}/#{id}")
         response.status
       end
 
-      def http_update(id, attributes)
+      def put(id, attributes)
         response = @http.put("#{api_url}/#{id}", attributes)
         JSON.parse(response.body)
       end
 
-      def http_list(first_page, last_page, per_page)
+      def paginated_get(first_page, last_page, per_page)
         url = "#{api_url}?page=#{first_page}&per_page=#{per_page}"
-        @http.paginate(url, last_page)
+        @http.paginated_get(url, last_page)
       end
 
       # For example, see: https://developers.freshdesk.com/api/#filter_contacts
-      def http_search(query, first_page, last_page)
+      def paginated_search(query, first_page, last_page)
         url = "#{base_api_url}/search/#{endpoint}?page=#{first_page}&query=#{query}"
-        @http.search_paginate(url, last_page)
+        @http.paginated_search(url, last_page)
       end
 
-      def extract_pagination(options)
-        first_page = value_from_options(options, :first_page)
-        last_page = value_from_options(options, :last_page)
-        first_page ||= Utils::DEFAULT_PAGE
-        last_page ||= Utils::INTEGER_MAX
+      def extract_list_pagination(options)
+        first_page = options[:first_page] || Utils::DEFAULT_PAGE
+        last_page = options[:last_page] || Utils::INTEGER_MAX
         [first_page, last_page]
       end
 
-      def value_from_options(options, key)
-        options[key.to_s] || options[key.to_sym]
+      def extract_search_pagination(options)
+        first_page = options[:first_page] || Utils::DEFAULT_PAGE
+        last_page = options[:last_page]
+        [first_page, last_page]
       end
 
       def base_api_url

lib/freshdesk_api_v2/companies.rb

@@ -1,15 +1,15 @@
 module FreshdeskApiV2
   class Companies < Base
-    ALLOWED_ATTRIBUTES = %w[
-      custom_fields
-      description
-      domains
-      name
-      note
-      health_score
-      account_tier
-      renewal_date
-      industry
+    ALLOWED_ATTRIBUTES = [
+      :custom_fields,
+      :description,
+      :domains,
+      :name,
+      :note,
+      :health_score,
+      :account_tier,
+      :renewal_date,
+      :industry
     ].freeze
 
     protected

lib/freshdesk_api_v2/http.rb

@@ -7,7 +7,7 @@ def initialize(configuration)
 
     # Freshdesk's search API uses a different pagination mechanism than their
     # regular pagination mechanism, so this implementation needs to be different.
-    def search_paginate(url, last_page, collection = [])
+    def paginate_search(url, last_page, collection = [])
       current_page = 1
       page_count, items = do_search(url)
       collection += items
@@ -27,7 +27,7 @@ def search_paginate(url, last_page, collection = [])
 
     # This is Freshdesk's normal pagination. It always returns a link to the next
     # page in a header called 'link' with a rel of 'next'
-    def paginate(url, last_page, collection = [])
+    def paginated_get(url, last_page, collection = [])
       response = get(url)
       links = @link_parser.parse(response)
       collection += JSON.parse(response.body)

spec/freshdesk_api_v2/base_spec.rb

@@ -1,3 +1,204 @@
+require 'byebug'
 RSpec.describe FreshdeskApiV2::Companies do
-  #Nothing to test here
+  before do
+    @mock_http = double('Mock HTTP', domain: 'test')
+  end
+
+  subject { FreshdeskApiV2::Companies.new(@mock_http) }
+
+  def company_attributes(overrides = {})
+    {
+      custom_fields: { name: 1 },
+      description: 'A company',
+      domains: ['test.company.com'],
+      name: 'A Company',
+      note: '',
+      health_score: 'A',
+      account_tier: 'Silver',
+      renewal_date: '2019-01-01',
+      industry: 'Stuff'
+    }.merge(overrides)
+  end
+
+  context 'list' do
+    let(:companies) { [company_attributes(id: 1, name: 'Company 1'), company_attributes(id: 1, name: 'Company 2')] }
+
+    before do
+      allow(@mock_http).to receive(:paginated_get).and_return(companies)
+    end
+
+    it 'returns a list of companies' do
+      expect(subject.list).to be_instance_of(Array)
+    end
+
+    it 'raises an exception when last_page is less than first_page' do
+      expect do
+        subject.list(first_page: 2, last_page: 1)
+      end.to raise_error(FreshdeskApiV2::PaginationException)
+    end
+
+    it "raises an exception when per_page is greater than #{FreshdeskApiV2::Utils::MAX_PAGE_SIZE}" do
+      expect do
+        subject.list(first_page: 1, per_page: 101)
+      end.to raise_error(FreshdeskApiV2::PaginationException)
+    end
+  end
+
+  context 'search' do
+    let(:query) do
+      q = FreshdeskApiV2::SearchArgs.new
+      q.add('name', 'Bob')
+      q
+    end
+
+    let(:companies) { [company_attributes(id: 1, name: 'Company 1'), company_attributes(id: 1, name: 'Company 2')] }
+
+    before do
+      allow(@mock_http).to receive(:paginated_search).and_return(companies)
+    end
+
+    it 'returns a list of companies matching the query' do
+      expect(subject.search(query)).to be_instance_of(Array)
+    end
+
+    it 'raises an exception when a query is not given' do
+      expect do
+        subject.search(nil)
+      end.to raise_error(FreshdeskApiV2::SearchException)
+    end
+
+    it 'raises an exception when the query given is invalid' do
+      q = FreshdeskApiV2::SearchArgs.new
+      expect do
+        subject.search(q)
+      end.to raise_error(FreshdeskApiV2::SearchException)
+    end
+
+    it 'raises an exception when last_page is less than first_page' do
+      expect do
+        subject.search(query, first_page: 2, last_page: 1)
+      end.to raise_error(FreshdeskApiV2::PaginationException)
+    end
+
+    it "raises an exception when last_page is greater than #{FreshdeskApiV2::Utils::MAX_SEARCH_PAGES}" do
+      expect do
+        subject.search(query, first_page: 1, last_page: 11)
+      end.to raise_error(FreshdeskApiV2::PaginationException)
+    end
+  end
+
+  context 'show' do
+    let(:response) { double('Mock HTTP Response', body: company_attributes.to_json) }
+
+    before do
+      allow(@mock_http).to receive(:get).and_return(response)
+    end
+
+    it 'returns the company' do
+      expect(subject.show(1)).not_to be_nil
+    end
+  end
+
+  context 'destroy' do
+    let(:response) { double('Mock HTTP Response', status: 204) }
+
+    before do
+      allow(@mock_http).to receive(:delete).and_return(response)
+    end
+
+    it 'deletes the company' do
+      expect(@mock_http).to receive(:delete).and_return(response)
+      subject.destroy(1)
+    end
+
+    it 'returns a status code of 204' do
+      expect(subject.destroy(1)).to eq(204)
+    end
+  end
+
+  context 'create' do
+    let(:endpoint) { 'https://test.freshdesk.com/api/v2/companies' }
+    let(:response) { double('Mock HTTP Response', body: company_attributes.to_json) }
+
+    before do
+      allow(@mock_http).to receive(:post).and_return(response)
+    end
+
+    it 'creates the company' do
+      expect(@mock_http).to receive(:post).with(endpoint, company_attributes).and_return(response)
+      subject.create(company_attributes)
+    end
+
+    it 'returns the company' do
+      response = subject.create(company_attributes)
+      expect(response).not_to be_nil
+    end
+
+    it 'filters out non-whitelisted properties' do
+      expect(@mock_http).to receive(:post).with(endpoint, company_attributes)
+      subject.create(company_attributes(monkey: 'Yes'))
+    end
+
+    it 'filters out nil properties' do
+      altered_attributes = company_attributes.dup
+      altered_attributes.delete(:description)
+      expect(@mock_http).to receive(:post).with(endpoint, altered_attributes)
+      subject.create(company_attributes(description: nil))
+    end
+
+    it 'raises an exception when no attributes are given' do
+      expect do
+        subject.create(nil)
+      end.to raise_error(FreshdeskApiV2::CreationException)
+    end
+
+    it 'raises an exception when empty attributes are given' do
+      expect do
+        subject.create({})
+      end.to raise_error(FreshdeskApiV2::CreationException)
+    end
+  end
+
+  context 'update' do
+    let(:endpoint) { 'https://test.freshdesk.com/api/v2/companies/1' }
+    let(:response) { double('Mock HTTP Response', body: company_attributes(id: 1).to_json) }
+
+    before do
+      allow(@mock_http).to receive(:put).and_return(response)
+    end
+
+    it 'updates the company' do
+      expect(@mock_http).to receive(:put).with(endpoint, company_attributes).and_return(response)
+      subject.update(1, company_attributes)
+    end
+
+    it 'returns the company' do
+      response = subject.update(1, company_attributes)
+      expect(response).not_to be_nil
+    end
+
+    it 'filters out non-whitelisted properties' do
+      expect(@mock_http).to receive(:put).with(endpoint, company_attributes)
+      subject.update(1, company_attributes(monkey: 'Yes'))
+    end
+
+    it 'filters out nil properties' do
+      altered_attributes = company_attributes.dup
+      altered_attributes.delete(:description)
+      expect(@mock_http).to receive(:put).with(endpoint, altered_attributes)
+      subject.update(1, company_attributes(description: nil))
+    end
+
+    it 'raises an exception when no attributes are given' do
+      expect do
+        subject.update(1, nil)
+      end.to raise_error(FreshdeskApiV2::UpdateException)
+    end
+
+    it 'raises an exception when empty attributes are given' do
+      expect do
+        subject.update(1, {})
+      end.to raise_error(FreshdeskApiV2::UpdateException)
+    end
+  end
 end