middleman-s3_sync 4.0.3 → 4.6.0

data/spec/cloudfront_spec.rb

@@ -0,0 +1,391 @@
+require 'spec_helper'
+require 'middleman/s3_sync/cloudfront'
+
+describe Middleman::S3Sync::CloudFront do
+  let(:options) do
+    double(
+      cloudfront_invalidate: true,
+      cloudfront_distribution_id: 'E1234567890123',
+      cloudfront_invalidate_all: false,
+      cloudfront_invalidation_batch_size: 1000,
+      cloudfront_wait: false,
+      aws_access_key_id: 'test_key',
+      aws_secret_access_key: 'test_secret',
+      aws_session_token: nil,
+      dry_run: false,
+      verbose: false
+    )
+  end
+
+  let(:invalidation_response) do
+    double(
+      invalidation: double(id: 'I1234567890123')
+    )
+  end
+
+  before do
+    allow(described_class).to receive(:say_status)
+  end
+
+  describe '.invalidate' do
+    context 'when CloudFront invalidation is disabled' do
+      let(:options) do
+        double(cloudfront_invalidate: false)
+      end
+
+      it 'returns early without doing anything' do
+        expect(Aws::CloudFront::Client).not_to receive(:new)
+        result = described_class.invalidate(['/path1', '/path2'], options)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when no distribution ID is provided' do
+      let(:options) do
+        double(
+          cloudfront_invalidate: true,
+          cloudfront_distribution_id: nil
+        )
+      end
+
+      it 'skips invalidation and shows warning' do
+        expect(described_class).to receive(:say_status).with(
+          match(/CloudFront invalidation skipped.*no distribution ID/)
+        )
+        expect(Aws::CloudFront::Client).not_to receive(:new)
+        result = described_class.invalidate(['/path1', '/path2'], options)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when dry run is enabled' do
+      let(:options) do
+        double(
+          cloudfront_invalidate: true,
+          cloudfront_distribution_id: 'E1234567890123',
+          cloudfront_invalidate_all: false,
+          dry_run: true,
+          verbose: true
+        )
+      end
+
+      it 'shows what would be invalidated without making API calls' do
+        expect(described_class).to receive(:say_status).with(
+          'Invalidating CloudFront distribution E1234567890123'
+        )
+        expect(described_class).to receive(:say_status).with(
+          match(/DRY RUN.*Would invalidate 2 paths/)
+        )
+        expect(described_class).to receive(:say_status).with('  /path1')
+        expect(described_class).to receive(:say_status).with('  /path2')
+        expect(Aws::CloudFront::Client).not_to receive(:new)
+
+        result = described_class.invalidate(['/path1', '/path2'], options)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when invalidating all paths' do
+      let(:options) do
+        double(
+          cloudfront_invalidate: true,
+          cloudfront_distribution_id: 'E1234567890123',
+          cloudfront_invalidate_all: true,
+          cloudfront_invalidation_batch_size: 1000,
+          cloudfront_wait: false,
+          aws_access_key_id: 'test_key',
+          aws_secret_access_key: 'test_secret',
+          aws_session_token: nil,
+          dry_run: false,
+          verbose: false
+        )
+      end
+
+      it 'invalidates all paths with /*' do
+        client = double('cloudfront_client')
+        allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+        expect(client).to receive(:create_invalidation).with({
+          distribution_id: 'E1234567890123',
+          invalidation_batch: {
+            paths: {
+              quantity: 1,
+              items: ['/*']
+            },
+            caller_reference: match(/middleman-s3_sync-\d+-[a-f0-9]{8}/)
+          }
+        }).and_return(invalidation_response)
+
+        result = described_class.invalidate(['/path1', '/path2'], options)
+        expect(result).to eq(['I1234567890123'])
+      end
+    end
+
+    context 'when invalidating specific paths' do
+      it 'creates invalidation for the provided paths' do
+        client = double('cloudfront_client')
+        allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+        expect(client).to receive(:create_invalidation).with({
+          distribution_id: 'E1234567890123',
+          invalidation_batch: {
+            paths: {
+              quantity: 2,
+              items: ['/path1', '/path2']
+            },
+            caller_reference: match(/middleman-s3_sync-\d+-[a-f0-9]{8}/)
+          }
+        }).and_return(invalidation_response)
+
+        result = described_class.invalidate(['/path1', '/path2'], options)
+        expect(result).to eq(['I1234567890123'])
+      end
+
+      it 'normalizes paths to start with /' do
+        client = double('cloudfront_client')
+        allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+        expect(client).to receive(:create_invalidation).with({
+          distribution_id: 'E1234567890123',
+          invalidation_batch: {
+            paths: {
+              quantity: 2,
+              items: ['/path1', '/path2']
+            },
+            caller_reference: match(/middleman-s3_sync-\d+-[a-f0-9]{8}/)
+          }
+        }).and_return(invalidation_response)
+
+        result = described_class.invalidate(['path1', '/path2'], options)
+        expect(result).to eq(['I1234567890123'])
+      end
+
+      it 'removes duplicate paths' do
+        client = double('cloudfront_client')
+        allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+        expect(client).to receive(:create_invalidation).with({
+          distribution_id: 'E1234567890123',
+          invalidation_batch: {
+            paths: {
+              quantity: 2,
+              items: ['/path1', '/path2']
+            },
+            caller_reference: match(/middleman-s3_sync-\d+-[a-f0-9]{8}/)
+          }
+        }).and_return(invalidation_response)
+
+        result = described_class.invalidate(['/path1', 'path1', '/path2'], options)
+        expect(result).to eq(['I1234567890123'])
+      end
+
+      it 'removes double slashes from paths' do
+        client = double('cloudfront_client')
+        allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+        expect(client).to receive(:create_invalidation).with({
+          distribution_id: 'E1234567890123',
+          invalidation_batch: {
+            paths: {
+              quantity: 1,
+              items: ['/path/to/file.html']
+            },
+            caller_reference: match(/middleman-s3_sync-\d+-[a-f0-9]{8}/)
+          }
+        }).and_return(invalidation_response)
+
+        result = described_class.invalidate(['//path//to//file.html'], options)
+        expect(result).to eq(['I1234567890123'])
+      end
+    end
+
+    context 'with large batch sizes' do
+      let(:options) do
+        double(
+          cloudfront_invalidate: true,
+          cloudfront_distribution_id: 'E1234567890123',
+          cloudfront_invalidate_all: false,
+          cloudfront_invalidation_batch_size: 2,
+          cloudfront_wait: false,
+          aws_access_key_id: 'test_key',
+          aws_secret_access_key: 'test_secret',
+          aws_session_token: nil,
+          dry_run: false,
+          verbose: false
+        )
+      end
+
+      it 'splits paths into multiple batches' do
+        client = double('cloudfront_client')
+        allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+        paths = ['/path1', '/path2', '/path3', '/path4']
+        
+        expect(client).to receive(:create_invalidation).twice.and_return(invalidation_response)
+        expect(described_class).to receive(:sleep).with(1)
+
+        result = described_class.invalidate(paths, options)
+        expect(result).to eq(['I1234567890123', 'I1234567890123'])
+      end
+    end
+
+    context 'when CloudFront API returns an error' do
+      let(:error) { Aws::CloudFront::Errors::ServiceError.new(nil, 'Distribution not found') }
+
+      it 'handles API errors gracefully' do
+        client = double('cloudfront_client')
+        allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+        expect(client).to receive(:create_invalidation).and_raise(error)
+        expect(described_class).to receive(:say_status).with(
+          match(/Failed to create CloudFront invalidation.*Distribution not found/)
+        )
+
+        expect {
+          described_class.invalidate(['/path1'], options)
+        }.to raise_error(Aws::CloudFront::Errors::ServiceError)
+      end
+
+      context 'when verbose mode is enabled' do
+        let(:options) do
+          double(
+            cloudfront_invalidate: true,
+            cloudfront_distribution_id: 'E1234567890123',
+            cloudfront_invalidate_all: false,
+            cloudfront_invalidation_batch_size: 1000,
+            cloudfront_wait: false,
+            aws_access_key_id: 'test_key',
+            aws_secret_access_key: 'test_secret',
+            aws_session_token: nil,
+            dry_run: false,
+            verbose: true
+          )
+        end
+
+        it 'does not re-raise errors in verbose mode' do
+          client = double('cloudfront_client')
+          allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+          expect(client).to receive(:create_invalidation).and_raise(error)
+          expect(described_class).to receive(:say_status).with(
+            match(/Failed to create CloudFront invalidation/)
+          )
+
+          expect {
+            described_class.invalidate(['/path1'], options)
+          }.not_to raise_error
+        end
+      end
+    end
+
+    context 'with empty paths and invalidate_all false' do
+      it 'returns early without making API calls' do
+        expect(Aws::CloudFront::Client).not_to receive(:new)
+        result = described_class.invalidate([], options)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when cloudfront_wait is enabled' do
+      let(:options) do
+        double(
+          cloudfront_invalidate: true,
+          cloudfront_distribution_id: 'E1234567890123',
+          cloudfront_invalidate_all: false,
+          cloudfront_invalidation_batch_size: 1000,
+          cloudfront_wait: true,
+          aws_access_key_id: 'test_key',
+          aws_secret_access_key: 'test_secret',
+          aws_session_token: nil,
+          dry_run: false,
+          verbose: false
+        )
+      end
+
+      it 'waits for invalidation to complete' do
+        client = double('cloudfront_client')
+        allow(Aws::CloudFront::Client).to receive(:new).and_return(client)
+        expect(client).to receive(:create_invalidation).and_return(invalidation_response)
+        expect(client).to receive(:wait_until).with(:invalidation_completed, 
+          distribution_id: 'E1234567890123',
+          id: 'I1234567890123'
+        )
+        expect(described_class).to receive(:say_status).with(
+          'Waiting for CloudFront invalidation(s) to complete...'
+        )
+        expect(described_class).to receive(:say_status).with(
+          'CloudFront invalidation(s) completed successfully'
+        )
+
+        result = described_class.invalidate(['/path1'], options)
+        expect(result).to eq(['I1234567890123'])
+      end
+    end
+  end
+
+  describe 'CloudFront client configuration' do
+    it 'creates client with correct credentials' do
+      client = double('cloudfront_client')
+      expect(Aws::CloudFront::Client).to receive(:new).with({
+        region: 'us-east-1',
+        access_key_id: 'test_key',
+        secret_access_key: 'test_secret'
+      }).and_return(client)
+
+      expect(client).to receive(:create_invalidation).and_return(invalidation_response)
+
+      described_class.invalidate(['/test'], options)
+    end
+
+    context 'with session token' do
+      let(:options) do
+        double(
+          cloudfront_invalidate: true,
+          cloudfront_distribution_id: 'E1234567890123',
+          cloudfront_invalidate_all: false,
+          cloudfront_invalidation_batch_size: 1000,
+          cloudfront_wait: false,
+          aws_access_key_id: 'test_key',
+          aws_secret_access_key: 'test_secret',
+          aws_session_token: 'test_token',
+          dry_run: false,
+          verbose: false
+        )
+      end
+
+      it 'includes session token in client configuration' do
+        client = double('cloudfront_client')
+        expect(Aws::CloudFront::Client).to receive(:new).with({
+          region: 'us-east-1',
+          access_key_id: 'test_key',
+          secret_access_key: 'test_secret',
+          session_token: 'test_token'
+        }).and_return(client)
+
+        expect(client).to receive(:create_invalidation).and_return(invalidation_response)
+
+        described_class.invalidate(['/test'], options)
+      end
+    end
+
+    context 'without explicit credentials' do
+      let(:options) do
+        double(
+          cloudfront_invalidate: true,
+          cloudfront_distribution_id: 'E1234567890123',
+          cloudfront_invalidate_all: false,
+          cloudfront_invalidation_batch_size: 1000,
+          cloudfront_wait: false,
+          aws_access_key_id: nil,
+          aws_secret_access_key: nil,
+          aws_session_token: nil,
+          dry_run: false,
+          verbose: false
+        )
+      end
+
+      it 'creates client without explicit credentials (uses default chain)' do
+        client = double('cloudfront_client')
+        expect(Aws::CloudFront::Client).to receive(:new).with({
+          region: 'us-east-1'
+        }).and_return(client)
+
+        expect(client).to receive(:create_invalidation).and_return(invalidation_response)
+
+        described_class.invalidate(['/test'], options)
+      end
+    end
+  end
+end

data/spec/resource_spec.rb

@@ -8,13 +8,39 @@ describe Middleman::S3Sync::Resource do
 
   let(:mm_resource) {
     double(
-      destination_path: 'path/to/resource.html'
+      destination_path: 'path/to/resource.html',
+      content_type: 'text/html'
     )
   }
+
+  let(:s3_client) { instance_double(Aws::S3::Client) }
+  let(:s3_resource) { instance_double(Aws::S3::Resource) }
+  let(:bucket) { instance_double(Aws::S3::Bucket) }
+  let(:s3_object) { instance_double(Aws::S3::Object) }
+
   before do
     Middleman::S3Sync.s3_sync_options = options
+
     options.build_dir = "build"
     options.prefer_gzip = false
+    options.bucket = "test-bucket"
+    options.acl = "public-read"
+
+    allow(Aws::S3::Client).to receive(:new).and_return(s3_client)
+    allow(Aws::S3::Resource).to receive(:new).and_return(s3_resource)
+    allow(s3_resource).to receive(:bucket).and_return(bucket)
+    allow(bucket).to receive(:exists?).and_return(true)
+    allow(bucket).to receive(:object) do |path|
+      # Ensure path has no leading slash
+      path = path.sub(/^\//, '') if path.is_a?(String)
+      s3_object
+    end
+    allow(s3_object).to receive(:head).and_return(nil)
+    allow(s3_object).to receive(:put).and_return(true)
+    allow(s3_object).to receive(:delete).and_return(true)
+
+    # Allow Middleman::S3Sync to use our mocked bucket
+    allow(Middleman::S3Sync).to receive(:bucket).and_return(bucket)
   end
 
   context "a new resource" do
@@ -23,6 +49,7 @@ describe Middleman::S3Sync::Resource do
     context "without a prefix" do
       before do
         allow(File).to receive(:exist?).with('build/path/to/resource.html').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/resource.html').and_return('test content')
       end
 
       its(:status) { is_expected.to eq :new }
@@ -31,11 +58,11 @@ describe Middleman::S3Sync::Resource do
         expect(resource).not_to be_remote
       end
 
-      it "exits locally" do
+      it "exists locally" do
         expect(resource).to be_local
       end
 
-      its(:path) { is_expected.to eq 'path/to/resource.html'}
+      its(:path) { is_expected.to eq 'path/to/resource.html' }
       its(:local_path) { is_expected.to eq 'build/path/to/resource.html' }
       its(:remote_path) { is_expected.to eq 'path/to/resource.html' }
     end
@@ -43,6 +70,7 @@ describe Middleman::S3Sync::Resource do
     context "with a prefix set" do
       before do
         allow(File).to receive(:exist?).with('build/path/to/resource.html').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/resource.html').and_return('test content')
         options.prefix = "bob"
       end
 
@@ -62,6 +90,9 @@ describe Middleman::S3Sync::Resource do
     context "gzipped" do
       before do
         allow(File).to receive(:exist?).with('build/path/to/resource.html.gz').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/resource.html.gz').and_return('gzipped content')
+        allow(File).to receive(:exist?).with('build/path/to/resource.html').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/resource.html').and_return('test content')
         options.prefer_gzip = true
       end
 
@@ -82,12 +113,7 @@ describe Middleman::S3Sync::Resource do
   context "the file does not exist locally" do
     subject(:resource) { Middleman::S3Sync::Resource.new(nil, remote) }
 
-    let(:remote) {
-      double(
-        key: 'path/to/resource.html',
-        metadata: {}
-      )
-    }
+    let(:remote) { mock_s3_object('path/to/resource.html') }
 
     before do
       resource.full_s3_resource = remote
@@ -103,7 +129,7 @@ describe Middleman::S3Sync::Resource do
         expect(resource).to be_remote
       end
 
-      it "exits locally" do
+      it "does not exist locally" do
         expect(resource).not_to be_local
       end
 
@@ -115,8 +141,9 @@ describe Middleman::S3Sync::Resource do
     context "with a prefix set" do
       before do
         allow(File).to receive(:exist?).with('build/path/to/resource.html').and_return(false)
-        allow(remote).to receive(:key).and_return('bob/path/to/resource.html')
-        options.prefix = "bob"
+        remote = mock_s3_object('bob/path/to/resource.html')
+        resource.full_s3_resource = remote
+        options.prefix = "bob/"
       end
 
       its(:status) { is_expected.to eq :deleted }
@@ -145,7 +172,7 @@ describe Middleman::S3Sync::Resource do
         expect(resource).to be_remote
       end
 
-      it "exists locally" do
+      it "does not exist locally" do
         expect(resource).not_to be_local
       end
 
@@ -154,4 +181,42 @@ describe Middleman::S3Sync::Resource do
       its(:remote_path) { is_expected.to eq 'path/to/resource.html' }
     end
   end
+
+  context 'An ignored resource' do
+    context "that is local" do
+
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'ignored/path/to/resource.html',
+          content_type: 'text/html'
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/ignored/path/to/resource.html').and_return(true)
+        allow(File).to receive(:read).with('build/ignored/path/to/resource.html').and_return('test content')
+        options.ignore_paths = [/^ignored/]
+      end
+
+      its(:status) { is_expected.to eq :ignored }
+    end
+
+    context "that is remote" do
+
+      subject(:resource) { Middleman::S3Sync::Resource.new(nil, remote) }
+
+      let(:remote) { mock_s3_object('ignored/path/to/resource.html') }
+
+      before do
+        resource.full_s3_resource = remote
+        options.ignore_paths = [/^ignored/]
+      end
+
+      its(:status) { is_expected.to eq :ignored }
+    end
+
+  end
+
 end

data/spec/s3_sync_integration_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+require 'middleman/s3_sync'
+
+describe 'S3Sync CloudFront Integration' do
+  let(:app) { double('middleman_app') }
+  let(:s3_sync_options) do
+    double(
+      cloudfront_invalidate: true,
+      cloudfront_distribution_id: 'E1234567890123',
+      cloudfront_invalidate_all: false,
+      cloudfront_invalidation_batch_size: 1000,
+      aws_access_key_id: 'test_key',
+      aws_secret_access_key: 'test_secret',
+      aws_session_token: nil,
+      dry_run: false,
+      verbose: false,
+      delete: true,
+      bucket: 'test-bucket'
+    )
+  end
+
+  before do
+    allow(::Middleman::Application).to receive(:new).and_return(app)
+    allow(Middleman::S3Sync).to receive(:s3_sync_options).and_return(s3_sync_options)
+    allow(Middleman::S3Sync).to receive(:say_status)
+    allow(Middleman::S3Sync).to receive(:work_to_be_done?).and_return(true)
+    allow(Middleman::S3Sync).to receive(:update_bucket_versioning)
+    allow(Middleman::S3Sync).to receive(:update_bucket_website)
+    allow(Middleman::S3Sync).to receive(:ignore_resources)
+    allow(Middleman::S3Sync).to receive(:create_resources)
+    allow(Middleman::S3Sync).to receive(:update_resources)
+    allow(Middleman::S3Sync).to receive(:delete_resources)
+    allow(Middleman::S3Sync::CloudFront).to receive(:invalidate)
+  end
+
+  describe 'CloudFront invalidation integration' do
+    it 'calls CloudFront invalidation after sync operations' do
+      # Reset invalidation paths for this test
+      Middleman::S3Sync.instance_variable_set(:@invalidation_paths, [])
+      
+      expect(Middleman::S3Sync::CloudFront).to receive(:invalidate).with(
+        [], # Initially empty, gets populated during resource operations
+        s3_sync_options
+      )
+
+      Middleman::S3Sync.sync
+    end
+
+    it 'calls CloudFront invalidation with collected paths' do
+      # Mock the methods to inject paths during sync
+      allow(Middleman::S3Sync).to receive(:create_resources) do
+        Middleman::S3Sync.add_invalidation_path('/updated/file.html')
+      end
+      allow(Middleman::S3Sync).to receive(:update_resources) do
+        Middleman::S3Sync.add_invalidation_path('/new/file.css')
+      end
+
+      expect(Middleman::S3Sync::CloudFront).to receive(:invalidate) do |paths, options|
+        expect(paths).to include('/updated/file.html')
+        expect(paths).to include('/new/file.css')
+        expect(options).to eq(s3_sync_options)
+      end
+
+      Middleman::S3Sync.sync
+    end
+
+    context 'when cloudfront_invalidate_all is true' do
+      let(:s3_sync_options) do
+        double(
+          cloudfront_invalidate: true,
+          cloudfront_distribution_id: 'E1234567890123',
+          cloudfront_invalidate_all: true,
+          bucket: 'test-bucket'
+        )
+      end
+
+      it 'still calls CloudFront invalidation even when no work is needed' do
+        allow(Middleman::S3Sync).to receive(:work_to_be_done?).and_return(false)
+        
+        expect(Middleman::S3Sync::CloudFront).to receive(:invalidate).with(
+          [], s3_sync_options
+        )
+
+        Middleman::S3Sync.sync
+      end
+    end
+
+    context 'when CloudFront invalidation is disabled' do
+      let(:s3_sync_options) do
+        double(
+          cloudfront_invalidate: false,
+          bucket: 'test-bucket'
+        )
+      end
+
+      it 'does not call CloudFront invalidation' do
+        expect(Middleman::S3Sync::CloudFront).not_to receive(:invalidate)
+
+        Middleman::S3Sync.sync
+      end
+    end
+  end
+
+  describe 'path tracking during resource operations' do
+    before do
+      # Reset invalidation paths before each path tracking test
+      Middleman::S3Sync.instance_variable_set(:@invalidation_paths, [])
+    end
+
+    it 'adds paths to invalidation list when resources are processed' do
+      # Test the add_invalidation_path method directly
+      Middleman::S3Sync.add_invalidation_path('test/file.html')
+      Middleman::S3Sync.add_invalidation_path('images/photo.jpg')
+      
+      expect(Middleman::S3Sync.invalidation_paths).to include('/test/file.html')
+      expect(Middleman::S3Sync.invalidation_paths).to include('/images/photo.jpg')
+    end
+
+    it 'normalizes paths when adding to invalidation list' do
+      Middleman::S3Sync.add_invalidation_path('no-leading-slash.html')
+      
+      expect(Middleman::S3Sync.invalidation_paths).to include('/no-leading-slash.html')
+    end
+
+    it 'does not add duplicate paths' do
+      Middleman::S3Sync.add_invalidation_path('/same/path.html')
+      Middleman::S3Sync.add_invalidation_path('/same/path.html')
+      
+      expect(Middleman::S3Sync.invalidation_paths.count('/same/path.html')).to eq(1)
+    end
+  end
+end