test: update the tests

Author: DNR500

spec/requests/api/subscriptions_spec.rb

@@ -26,6 +26,14 @@
         message: 'Subscription provider is currently unavailable.'
       )
     end
+    let(:submitter_result_rejected) do
+      Subscriptions::PardotFormHandlerSubmitter::Result.new(
+        success?: false,
+        status: :bad_gateway,
+        error_code: 'subscription_provider_rejected',
+        message: 'Subscription provider rejected the request.'
+      )
+    end
     let(:submitter) { instance_double(Subscriptions::PardotFormHandlerSubmitter) }
 
     before do
@@ -89,5 +97,18 @@
         'message' => 'Subscription provider is currently unavailable.'
       )
     end
+
+    it 'returns provider rejection shape when provider rejects request' do
+      allow(submitter).to receive(:call).and_return(submitter_result_rejected)
+
+      post(path, params: payload, as: :json)
+
+      expect(response).to have_http_status(:bad_gateway)
+      expect(response.parsed_body).to include(
+        'ok' => false,
+        'error_code' => 'subscription_provider_rejected',
+        'message' => 'Subscription provider rejected the request.'
+      )
+    end
   end
 end

spec/services/subscriptions/pardot_form_handler_submitter_spec.rb

@@ -3,56 +3,99 @@
 require 'rails_helper'
 
 RSpec.describe Subscriptions::PardotFormHandlerSubmitter do
-  let(:endpoint_url) { 'https://example.com/form-handler' }
-  let(:service) { described_class.new(endpoint_url: endpoint_url) }
-  let(:payload) { { 'email' => 'teacher@example.com', 'privacy_policy' => true } }
+  let(:endpoint_url) { 'https://example.test/form-handler' }
+  let(:submitter) { described_class.new(endpoint_url:) }
+  let(:connection) { instance_double(Faraday::Connection) }
+
+  let(:payload) do
+    {
+      'email' => 'teacher@example.com',
+      'test_opt_in' => true,
+      'privacy_policy' => true
+    }
+  end
+
+  let(:headers) { {} }
+  let(:response_body) { '' }
+  let(:response_status) { 200 }
+  let(:response) { instance_double(Faraday::Response, status: response_status, body: response_body, headers:) }
+
+  before do
+    allow(submitter).to receive(:faraday).and_return(connection)
+    allow(connection).to receive(:post).and_return(response)
+    allow(Sentry).to receive(:capture_exception)
+  end
 
   describe '#call' do
-    let(:connection) { instance_double(Faraday::Connection) }
-    let(:response) { instance_double(Faraday::Response, status: status, headers: headers, success?: success) }
-    let(:headers) { {} }
-    let(:status) { 200 }
-    let(:success) { true }
-
-    before do
-      allow(Faraday).to receive(:new).and_return(connection)
-      allow(connection).to receive(:post).and_return(response)
-    end
+    it 'returns success when status 200 and body contains success marker' do
+      allow(response).to receive(:body).and_return('Cannot find success page to redirect to.')
 
-    it 'returns success for a 200 response' do
-      result = service.call(form_payload: payload)
+      result = submitter.call(form_payload: payload)
 
       expect(result.success?).to be(true)
     end
 
-    it 'returns success for a 302 success redirect location' do
-      allow(response).to receive_messages(status: 302, success?: false, headers: { 'location' => '/subscriptions/success' })
+    it 'returns rejected when body contains error marker even with status 200' do
+      allow(response).to receive(:body).and_return('Cannot find error page to redirect to.')
 
-      result = service.call(form_payload: payload)
+      result = submitter.call(form_payload: payload)
 
-      expect(result.success?).to be(true)
+      expect(result.success?).to be(false)
+      expect(result.status).to eq(:bad_gateway)
+      expect(result.error_code).to eq('subscription_provider_rejected')
+    end
+
+    it 'returns rejected when status is not 200' do
+      allow(response).to receive(:status).and_return(302)
+
+      result = submitter.call(form_payload: payload)
+
+      expect(result.success?).to be(false)
+      expect(result.status).to eq(:bad_gateway)
+      expect(result.error_code).to eq('subscription_provider_rejected')
     end
 
-    it 'returns rejected for a 302 error redirect location' do
-      allow(response).to receive_messages(status: 302, success?: false, headers: { 'location' => '/subscriptions/error' })
+    it 'returns ambiguous when status is 200 and body has no markers' do
+      allow(response).to receive(:body).and_return('ok')
 
-      result = service.call(form_payload: payload)
+      result = submitter.call(form_payload: payload)
 
-      aggregate_failures do
-        expect(result.success?).to be(false)
-        expect(result.error_code).to eq('subscription_provider_rejected')
-      end
+      expect(result.success?).to be(false)
+      expect(result.status).to eq(:bad_gateway)
+      expect(result.error_code).to eq('subscription_provider_ambiguous')
     end
 
-    it 'returns ambiguous for an unknown 302 redirect location' do
-      allow(response).to receive_messages(status: 302, success?: false, headers: { 'location' => '/subscriptions/unknown' })
+    it 'returns unavailable on Faraday::Error' do
+      allow(connection).to receive(:post).and_raise(Faraday::Error, 'connection failed')
+
+      result = submitter.call(form_payload: payload)
+
+      expect(result.success?).to be(false)
+      expect(result.status).to eq(:service_unavailable)
+      expect(result.error_code).to eq('subscription_provider_unavailable')
+      expect(Sentry).to have_received(:capture_exception)
+    end
+
+    it 'returns not configured when endpoint_url is blank' do
+      blank_submitter = described_class.new(endpoint_url: '')
+
+      result = blank_submitter.call(form_payload: payload)
+
+      expect(result.success?).to be(false)
+      expect(result.status).to eq(:service_unavailable)
+      expect(result.error_code).to eq('subscription_provider_not_configured')
+    end
 
-      result = service.call(form_payload: payload)
+    it 'posts payload mapped to email and Tester only' do
+      submitter.call(form_payload: payload)
 
-      aggregate_failures do
-        expect(result.success?).to be(false)
-        expect(result.error_code).to eq('subscription_provider_ambiguous')
-      end
+      expect(connection).to have_received(:post).with(
+        endpoint_url,
+        {
+          'email' => 'teacher@example.com',
+          'Tester' => true
+        }
+      )
     end
   end
 end