Strengthen feed request specs

Author: gildesmarais

spec/html2rss/web/app_integration_spec.rb

@@ -11,9 +11,12 @@
   include Rack::Test::Methods
 
   let(:app) { described_class.freeze.app }
+  let(:secret_key) { ENV.fetch('HTML2RSS_SECRET_KEY') }
 
   let(:feed_url) { 'https://example.com/articles' }
-  let(:feed_token) { "valid-feed-token-#{SecureRandom.hex(4)}" }
+  let(:feed_token) do
+    Html2rss::Web::Auth.generate_feed_token(account[:username], feed_url, strategy: 'faraday')
+  end
   let(:encoded_feed_token) { CGI.escape(feed_token) }
 
   let(:account) do
@@ -55,18 +58,6 @@
     allow(Html2rss::Web::LocalConfig).to receive(:yaml).and_return(accounts_config)
     stub_const('Html2rss::FeedChannel', Class.new { attr_reader :ttl })
     stub_const('Html2rss::Feed', Class.new { attr_reader :channel })
-    token_payload = instance_double(
-      Html2rss::Web::FeedToken,
-      url: feed_url,
-      username: account[:username],
-      strategy: 'faraday'
-    )
-    allow(Html2rss::Web::FeedToken).to receive_messages(
-      decode: token_payload,
-      validate_and_decode: token_payload
-    )
-    allow(Html2rss::Web::AccountManager).to receive(:get_account_by_username).and_return(account)
-    allow(Html2rss::Web::UrlValidator).to receive(:url_allowed?).and_return(true)
     allow(Html2rss::Web::AutoSource).to receive(:enabled?).and_return(true)
     allow(Html2rss::Web::Feeds::Service).to receive(:call).and_return(feed_result)
     allow(Html2rss::Web::Feeds::RssRenderer).to receive(:call).and_return('<rss version="2.0"></rss>')
@@ -76,8 +67,6 @@
 
   describe 'GET /api/v1/feeds/:token' do # rubocop:disable RSpec/MultipleMemoizedHelpers
     it 'returns unauthorized for invalid tokens' do
-      allow(Html2rss::Web::FeedToken).to receive(:decode).and_return(nil)
-
       get '/api/v1/feeds/invalid-token', {}, { 'HTTP_ACCEPT' => 'application/xml' }
 
       expect(last_response.status).to eq(401)
@@ -172,8 +161,6 @@
     end
 
     it 'returns JSON Feed-shaped errors for invalid json feed tokens' do
-      allow(Html2rss::Web::FeedToken).to receive(:decode).and_return(nil)
-
       get '/api/v1/feeds/invalid-token.json'
 
       expect([last_response.status, last_response.headers['Content-Type'], json_feed_error]).to eq(
@@ -225,8 +212,6 @@ def stub_escaped_feed_token(raw_token:, encoded_token:)
     end
 
     context 'without authentication' do # rubocop:disable RSpec/MultipleMemoizedHelpers
-      before { allow(Html2rss::Web::Auth).to receive(:authenticate).and_return(nil) }
-
       it 'requires authentication' do
         post '/api/v1/feeds', request_payload.to_json, json_headers
 
@@ -237,19 +222,19 @@ def stub_escaped_feed_token(raw_token:, encoded_token:)
     end
 
     context 'with authenticated account' do # rubocop:disable RSpec/MultipleMemoizedHelpers
-      before { allow(Html2rss::Web::Auth).to receive(:authenticate).and_return(account) }
+      before do
+        allow(Html2rss::Web::Api::V1::FeedMetadata).to receive(:site_title_for).and_return('Example Feed')
+      end
 
       it 'returns bad request when JSON payload is invalid' do
-        post '/api/v1/feeds', '{ invalid', json_headers
+        post '/api/v1/feeds', '{ invalid', auth_headers
 
         expect(last_response.status).to eq(400)
         expect(last_response.content_type).to include('application/json')
         expect(json_body).to include('error' => include('message' => 'Invalid JSON payload'))
       end
 
       it 'returns bad request when URL is missing' do
-        allow(Html2rss::Web::Api::V1::FeedMetadata).to receive(:site_title_for).and_return('Example')
-
         post '/api/v1/feeds', request_payload.merge(url: '').to_json, auth_headers
 
         expect(last_response.status).to eq(400)

spec/html2rss/web/feeds/responder_spec.rb

@@ -1,68 +1,62 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'rack'
 require_relative '../../../../app'
 
 RSpec.describe Html2rss::Web::Feeds::Responder do
   let(:response) { Rack::Response.new }
-  let(:request) { instance_double(Struct.new(:response), response: response) }
-
-  def feed_request(representation)
-    Html2rss::Web::Feeds::Contracts::Request.new(
-      target_kind: :token,
-      representation: representation,
-      feed_name: nil,
-      token: 'token',
-      params: {}
+  let(:result) do
+    Html2rss::Web::Feeds::Contracts::RenderResult.new(
+      status: :ok,
+      payload: nil,
+      message: nil,
+      ttl_seconds: 600,
+      cache_key: 'feed_result:test',
+      error_message: nil
     )
   end
+  let(:static_config) do
+    {
+      channel: { url: 'https://example.com', ttl: 10 },
+      strategy: :faraday
+    }
+  end
 
-  def resolved_source
-    Html2rss::Web::Feeds::Contracts::ResolvedSource.new(
-      source_kind: :token,
-      cache_identity: 'token:abc',
-      generator_input: { strategy: :faraday, channel: { url: 'https://example.com' } },
-      ttl_seconds: 600
-    )
+  before do
+    allow(Html2rss::Web::LocalConfig).to receive(:find).with('example').and_return(static_config)
+    allow(Html2rss::Web::Observability).to receive(:emit)
   end
 
   context 'with a cacheable success result' do
     subject(:write_response) do
       described_class.call(
-        request: request,
-        target_kind: :token,
-        identifier: 'token'
-      )
-    end
-
-    let(:representation) { Html2rss::Web::FeedResponseFormat::RSS }
-
-    let(:result) do
-      Html2rss::Web::Feeds::Contracts::RenderResult.new(
-        status: :ok,
-        payload: nil,
-        message: nil,
-        ttl_seconds: 600,
-        cache_key: 'feed_result:test',
-        error_message: nil
+        request: request_for(path: '/example', accept: 'application/xml'),
+        target_kind: :static,
+        identifier: 'example'
       )
     end
 
     before do
-      allow(Html2rss::Web::Feeds::Request).to receive(:call).and_return(feed_request(representation))
-      allow(Html2rss::Web::Feeds::SourceResolver).to receive(:call).and_return(resolved_source)
       allow(Html2rss::Web::Feeds::Service).to receive(:call).and_return(result)
-      allow(Html2rss::Web::Observability).to receive(:emit)
       allow(Html2rss::Web::Feeds::RssRenderer).to receive(:call).with(result).and_return('<rss/>')
     end
 
     it 'writes the expected response tuple' do
       expect(response_tuple(write_response)).to eq([200, 'application/xml', '<rss/>'])
     end
 
-    it 'marks the response as cacheable', :aggregate_failures do
+    it 'resolves the source through the real request and source resolver path', :aggregate_failures do
       write_response
 
+      expect(Html2rss::Web::Feeds::Service).to have_received(:call).with(
+        have_attributes(
+          source_kind: :static,
+          cache_identity: a_string_starting_with('static:example:'),
+          generator_input: include(strategy: :faraday, channel: { url: 'https://example.com', ttl: 10 }),
+          ttl_seconds: 600
+        )
+      )
       expect(response['Cache-Control']).to include('max-age=600')
       expect(response['Cache-Control']).to include('public')
       expect(response['Vary']).to eq('Accept')
@@ -74,7 +68,7 @@ def resolved_source
       expect(Html2rss::Web::Observability).to have_received(:emit).with(
         event_name: 'feed.render',
         outcome: 'success',
-        details: include(strategy: :faraday, url: 'https://example.com'),
+        details: include(strategy: :faraday, url: 'https://example.com', feed_name: 'example'),
         level: :info
       )
     end
@@ -83,14 +77,12 @@ def resolved_source
   context 'with an error result' do
     subject(:write_response) do
       described_class.call(
-        request: request,
-        target_kind: :token,
-        identifier: 'token'
+        request: request_for(path: '/example.json', accept: 'application/feed+json'),
+        target_kind: :static,
+        identifier: 'example.json'
       )
     end
 
-    let(:representation) { Html2rss::Web::FeedResponseFormat::JSON_FEED }
-
     let(:result) do
       Html2rss::Web::Feeds::Contracts::RenderResult.new(
         status: :error,
@@ -103,10 +95,7 @@ def resolved_source
     end
 
     before do
-      allow(Html2rss::Web::Feeds::Request).to receive(:call).and_return(feed_request(representation))
-      allow(Html2rss::Web::Feeds::SourceResolver).to receive(:call).and_return(resolved_source)
       allow(Html2rss::Web::Feeds::Service).to receive(:call).and_return(result)
-      allow(Html2rss::Web::Observability).to receive(:emit)
       allow(Html2rss::Web::Feeds::JsonRenderer).to receive(:call).with(result).and_return('{"title":"Error"}')
     end
 
@@ -125,30 +114,14 @@ def resolved_source
   context 'when response rendering fails after feed generation succeeds' do
     subject(:write_response) do
       described_class.call(
-        request: request,
-        target_kind: :token,
-        identifier: 'token'
-      )
-    end
-
-    let(:representation) { Html2rss::Web::FeedResponseFormat::RSS }
-
-    let(:result) do
-      Html2rss::Web::Feeds::Contracts::RenderResult.new(
-        status: :ok,
-        payload: nil,
-        message: nil,
-        ttl_seconds: 600,
-        cache_key: 'feed_result:test',
-        error_message: nil
+        request: request_for(path: '/example', accept: 'application/xml'),
+        target_kind: :static,
+        identifier: 'example'
       )
     end
 
     before do
-      allow(Html2rss::Web::Feeds::Request).to receive(:call).and_return(feed_request(representation))
-      allow(Html2rss::Web::Feeds::SourceResolver).to receive(:call).and_return(resolved_source)
       allow(Html2rss::Web::Feeds::Service).to receive(:call).and_return(result)
-      allow(Html2rss::Web::Observability).to receive(:emit)
       allow(Html2rss::Web::Feeds::RssRenderer).to receive(:call).and_raise(StandardError, 'render failed')
     end
 
@@ -158,14 +131,27 @@ def resolved_source
       expect(Html2rss::Web::Observability).to have_received(:emit).once.with(
         event_name: 'feed.render',
         outcome: 'failure',
-        details: include(error_class: 'StandardError', error_message: 'render failed'),
+        details: include(error_class: 'StandardError', error_message: 'render failed', feed_name: 'example'),
         level: :warn
       )
     end
   end
 
   private
 
+  # @param path [String]
+  # @param accept [String]
+  # @return [Rack::Request]
+  def request_for(path:, accept:)
+    rack_response = response
+
+    Rack::Request.new(
+      Rack::MockRequest.env_for(path, 'HTTP_ACCEPT' => accept)
+    ).tap do |request|
+      request.define_singleton_method(:response) { rack_response }
+    end
+  end
+
   # @param body [String]
   # @return [Array<(Integer, String, String)>]
   def response_tuple(body)