hubspot-api-client 19.0.0 → 20.0.0.pre.beta.1

data/spec/discovery/marketing/events/{participant_state_api_spec.rb → retrieve_participant_state_api_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe 'Hubspot::Discovery::Marketing::Events::ParticipantStateApi' do
-  subject(:api) { Hubspot::Client.new(access_token: 'test').marketing.events.participant_state_api }
+describe 'Hubspot::Discovery::Marketing::Events::RetrieveParticipantStateApi' do
+  subject(:RetrieveParticipantStateApi) { Hubspot::Client.new(access_token: 'test').marketing.events.retrieve_participant_state_api }
   
   it { is_expected.to respond_to(:get_participations_breakdown_by_contact_id) }
   it { is_expected.to respond_to(:get_participations_breakdown_by_external_event_id) }

data/spec/helpers/requests/http_auth_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'hubspot/helpers/requests/http_auth'
+
+RSpec.describe Hubspot::Helpers::Auth do
+    let(:config_with_api_key) { { api_key: 'api_key_value' } }
+    let(:config_with_access_token) { { access_token: 'token_value' } }
+    let(:config_empty) { {} }
+
+  describe '.get_auth_types' do
+    it 'returns an array of supported auth types' do
+      expect(described_class.get_auth_types).to eq([:access_token, :api_key])
+    end
+  end
+
+  describe '.has_auth_value?' do
+    it 'returns true if the key has a value' do
+      expect(described_class.has_auth_value?(config_with_api_key, :api_key)).to be true
+      expect(described_class.has_auth_value?(config_with_access_token, :access_token)).to be true
+    end
+
+    it 'returns false if the key has no value or is nil' do
+      expect(described_class.has_auth_value?(config_empty, :access_token)).to be false
+      expect(described_class.has_auth_value?(config_empty, :api_key)).to be false
+    end
+  end
+
+  describe '.choose_auth' do
+    context 'when auth_type is specified in options' do
+      it 'returns the specified auth type' do
+        options = { auth_type: :api_key }
+        result = described_class.choose_auth(config_with_access_token, options)
+        expect(result).to eq({ auth_type: :api_key })
+      end
+    end
+
+    context 'when auth_type is not specified in options' do
+      it 'chooses the first valid auth type from the config' do
+        options = {}
+        result = described_class.choose_auth(config_with_access_token, options)
+        expect(result).to eq({ auth_type: :access_token })
+      end
+    end
+
+    context 'when no valid auth type is found in config' do
+      it 'raises an error' do
+        options = {}
+        expect { described_class.choose_auth(config_empty, options) }.to raise_error("Unsupported auth_type: ")
+      end
+    end
+
+    context 'when auth_type is invalid' do
+      it 'raises an error for unsupported auth types' do
+        options = { auth_type: :unsupported_type }
+        expect { described_class.choose_auth(config_with_access_token, options) }.to raise_error("Unsupported auth_type: unsupported_type")
+      end
+    end
+  end
+end

data/spec/helpers/requests/http_request_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'hubspot/helpers/requests/http_request_builder'
+
+RSpec.describe Hubspot::Helpers::Request do
+  let(:config_with_access_token) { { access_token: 'token_value', "base_url" => "https://api.hubapi.com" } }
+  let(:config_with_api_key) { { api_key: 'api_key_value', "base_url" => "https://api.hubapi.com" } }
+  let(:default_options) { { path: '/test', method: 'GET' } }
+  let(:post_options) { { path: '/test', method: 'POST', body: { key: 'value' } } }
+
+  describe '#initialize' do
+    it 'sets default headers and URL' do
+      request = described_class.new(config_with_access_token, default_options)
+      expect(request.url).to eq('https://api.hubapi.com/test')
+      expect(request.headers['Content-Type']).to eq('application/json')
+    end
+  end
+
+  describe '#apply_auth' do
+    it 'applies access_token authorization' do
+      request = described_class.new(config_with_access_token, default_options)
+      expect(request.headers['Authorization']).to eq('Bearer token_value')
+    end
+
+    it 'applies API key authorization' do
+      request = described_class.new(config_with_api_key, default_options.merge(auth_type: :api_key, auth_value: 'api_key_value'))
+      expect(request.url).to include('hapikey=api_key_value')
+    end
+  end
+
+  describe '#generate_url' do
+    it 'generates a valid URL with a query string' do
+      options = default_options.merge(qs: { param1: 'value1', param2: 'value2' })
+      request = described_class.new(config_with_access_token, options)
+      expect(request.url).to eq('https://api.hubapi.com/test?param1=value1&param2=value2')
+    end
+  end
+
+  describe '#set_body' do
+    it 'sets JSON body for POST requests' do
+      request = described_class.new(config_with_access_token, post_options)
+      expect(request.body).to eq('{"key":"value"}')
+    end
+
+    it 'does not set body for GET requests' do
+      request = described_class.new(config_with_access_token, default_options)
+      expect(request.body).to be_nil
+    end
+  end
+
+  describe '#send' do
+    let(:response) { instance_double('Net::HTTPResponse', code: '200', body: '{"message":"success"}') }
+
+    it 'sends a GET request successfully' do
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_return(response)
+      request = described_class.new(config_with_access_token, default_options)
+      result = request.send
+      expect(result.body).to eq('{"message":"success"}')
+    end
+
+    it 'raises an error for unsupported HTTP methods' do
+      options = default_options.merge(method: 'INVALID')
+      expect { described_class.new(config_with_access_token, options).send }.to raise_error('Unsupported HTTP method: INVALID')
+    end
+
+    it 'raises an error for HTTP exceptions' do
+        allow_any_instance_of(Net::HTTP).to receive(:request).and_raise(StandardError.new('network error'))
+        request = described_class.new(config_with_access_token, default_options)
+        expect { request.send }.to raise_error(StandardError, 'network error')
+      end      
+  end
+end

data/spec/helpers/signature_spec.rb

@@ -7,10 +7,10 @@ TEST_DATA = {
   :request_body=> "{'example_field':'example_value'}",
   :url=> "https://www.example.com/webhook_uri",
   :http_method=> "POST",
-  :timestamp=> 15000000,
+  :timestamp=> 1_700_000_300_000,
   :v1_hash=> "69fc6631a867edd4f9e9e627fc5c1148e3fbdd8b21837b6d2b8901c1fa57f750",
   :v2_hash=> "4fe4e3a7d3cf09db53be39d0a58130e2aaba074ec123a9e355b876a689a1c383",
-  :v3_hash=> "HPW73RUtKmcYoEDADG0s6MmGFWUzWJKAW07r8RDgcQw=",
+  :v3_hash=> "RnbPH7+UMKVkbV32P8bz450N4M56aPmcru1+D3kSDtw=",
 }
 
 
@@ -77,12 +77,12 @@ describe "Hubspot::Helpers::Signature.is_valid" do
     expect(result).to be true
   end
   it "should return true for v3 signature version" do
-    test_timestamp = DateTime.now.strftime("%s")
+    test_timestamp_microseconds = (Time.now.to_f * 1000).to_i
     test_signature = signature.get_signature(
       client_secret: TEST_DATA[:client_secret],
       request_body: TEST_DATA[:request_body],
       http_uri: TEST_DATA[:http_uri],
-      timestamp: test_timestamp,
+      timestamp: test_timestamp_microseconds,
       signature_version: "v3"
     )
 
@@ -91,7 +91,7 @@ describe "Hubspot::Helpers::Signature.is_valid" do
       client_secret: TEST_DATA[:client_secret],
       request_body: TEST_DATA[:request_body],
       http_uri: TEST_DATA[:http_uri],
-      timestamp: test_timestamp,
+      timestamp: test_timestamp_microseconds,
       signature_version: "v3"
     )
     expect(result).to be true
@@ -105,6 +105,16 @@ describe "Hubspot::Helpers::Signature.is_valid" do
       signature_version: "v3"
     ) }.to raise_error(Hubspot::InvalidSignatureTimestampError)
   end
+  it "should raise exception if :signature_version=>v3 and :timestamp=>expired" do
+    expect {  signature.is_valid(
+      signature: TEST_DATA[:v3_hash],
+      client_secret: TEST_DATA[:client_secret],
+      request_body: TEST_DATA[:request_body],
+      http_uri: TEST_DATA[:http_uri],
+      timestamp: 1_700_000_000_000,
+      signature_version: "v3"
+    ) }.to raise_error(Hubspot::InvalidSignatureTimestampError)
+  end
   it "should raise exception if :signature_version=>v3 and :timestamp=>wrong_timestamp" do
     expect {  signature.is_valid(
       signature: TEST_DATA[:v3_hash],