middleman-s3_sync 4.6.4 → 4.7.0

data/spec/indifferent_hash_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+describe Middleman::S3Sync::IndifferentHash do
+  let(:hash) { described_class.new }
+
+  describe 'string-indifferent key access' do
+    it 'allows setting and retrieving values using string keys' do
+      hash['foo'] = 'bar'
+      expect(hash['foo']).to eq('bar')
+    end
+
+    it 'retrieves string key values using symbol keys' do
+      hash['foo'] = 'bar'
+      expect(hash[:foo]).to eq('bar')
+    end
+
+    it 'normalizes string keys on retrieval' do
+      hash['foo'] = 'value1'
+      hash['foo'] = 'value2'
+      expect(hash['foo']).to eq('value2')
+      expect(hash.keys.count).to eq(1)
+    end
+  end
+
+  describe 'symbol-indifferent key access' do
+    it 'allows setting and retrieving values using symbol keys' do
+      hash[:foo] = 'bar'
+      expect(hash[:foo]).to eq('bar')
+    end
+
+    it 'retrieves symbol key values using string keys' do
+      hash[:foo] = 'bar'
+      expect(hash['foo']).to eq('bar')
+    end
+
+    it 'normalizes symbol keys to strings' do
+      hash[:foo] = 'value1'
+      hash['foo'] = 'value2'
+      expect(hash[:foo]).to eq('value2')
+      expect(hash.keys.count).to eq(1)
+    end
+
+    it 'stores keys as strings internally' do
+      hash[:foo] = 'bar'
+      expect(hash.keys).to eq(['foo'])
+    end
+  end
+
+  describe 'dot notation access' do
+    it 'allows accessing values using dot notation' do
+      hash[:foo] = 'bar'
+      expect(hash.foo).to eq('bar')
+    end
+
+    it 'allows setting values using dot notation' do
+      hash.foo = 'baz'
+      expect(hash[:foo]).to eq('baz')
+    end
+
+    it 'works with string keys' do
+      hash['foo'] = 'bar'
+      expect(hash.foo).to eq('bar')
+    end
+
+    it 'raises NoMethodError for non-existent keys' do
+      expect { hash.nonexistent_key }.to raise_error(NoMethodError)
+    end
+
+    it 'supports respond_to? for existing keys' do
+      hash[:foo] = 'bar'
+      expect(hash).to respond_to(:foo)
+      expect(hash).to respond_to(:foo=)
+    end
+
+    it 'returns false for respond_to? on non-existent keys' do
+      expect(hash).not_to respond_to(:nonexistent)
+    end
+  end
+
+  describe 'nested hashes with indifferent access' do
+    it 'handles nested hash values' do
+      hash[:outer] = { inner: 'value' }
+      expect(hash[:outer]).to eq({ inner: 'value' })
+    end
+
+    it 'allows nested IndifferentHash instances' do
+      inner = described_class.new
+      inner[:foo] = 'bar'
+      hash[:outer] = inner
+      
+      expect(hash[:outer][:foo]).to eq('bar')
+      expect(hash[:outer].foo).to eq('bar')
+    end
+
+    it 'supports multiple levels of nesting' do
+      inner = described_class.new
+      inner[:level2] = 'deep'
+      hash[:level1] = inner
+      
+      expect(hash['level1']['level2']).to eq('deep')
+      expect(hash[:level1][:level2]).to eq('deep')
+    end
+  end
+
+  describe 'Hash method compatibility' do
+    describe '#has_key?' do
+      it 'works with string keys' do
+        hash['foo'] = 'bar'
+        expect(hash.has_key?('foo')).to be true
+        expect(hash.has_key?(:foo)).to be true
+      end
+
+      it 'works with symbol keys' do
+        hash[:foo] = 'bar'
+        expect(hash.has_key?('foo')).to be true
+        expect(hash.has_key?(:foo)).to be true
+      end
+
+      it 'returns false for non-existent keys' do
+        expect(hash.has_key?('nonexistent')).to be false
+        expect(hash.has_key?(:nonexistent)).to be false
+      end
+    end
+
+    describe '#key?' do
+      it 'is aliased to has_key?' do
+        hash[:foo] = 'bar'
+        expect(hash.key?('foo')).to be true
+        expect(hash.key?(:foo)).to be true
+      end
+    end
+
+    describe '#include?' do
+      it 'is aliased to has_key?' do
+        hash[:foo] = 'bar'
+        expect(hash.include?('foo')).to be true
+        expect(hash.include?(:foo)).to be true
+      end
+    end
+
+    describe '#fetch' do
+      it 'fetches values with string keys' do
+        hash['foo'] = 'bar'
+        expect(hash.fetch('foo')).to eq('bar')
+        expect(hash.fetch(:foo)).to eq('bar')
+      end
+
+      it 'fetches values with symbol keys' do
+        hash[:foo] = 'bar'
+        expect(hash.fetch('foo')).to eq('bar')
+        expect(hash.fetch(:foo)).to eq('bar')
+      end
+
+      it 'returns default value for missing keys' do
+        expect(hash.fetch('missing', 'default')).to eq('default')
+        expect(hash.fetch(:missing, 'default')).to eq('default')
+      end
+
+      it 'calls block for missing keys' do
+        result = hash.fetch('missing') { |key| "Key #{key} not found" }
+        expect(result).to eq('Key missing not found')
+      end
+
+      it 'raises KeyError when key is missing without default' do
+        expect { hash.fetch('missing') }.to raise_error(KeyError)
+        expect { hash.fetch(:missing) }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe '.from_hash' do
+    it 'creates an IndifferentHash from a regular hash' do
+      regular_hash = { 'foo' => 'bar', 'baz' => 'qux' }
+      result = described_class.from_hash(regular_hash)
+      
+      expect(result).to be_a(described_class)
+      expect(result['foo']).to eq('bar')
+      expect(result[:foo]).to eq('bar')
+      expect(result['baz']).to eq('qux')
+      expect(result[:baz]).to eq('qux')
+    end
+
+    it 'handles hashes with symbol keys' do
+      regular_hash = { foo: 'bar', baz: 'qux' }
+      result = described_class.from_hash(regular_hash)
+      
+      expect(result[:foo]).to eq('bar')
+      expect(result['foo']).to eq('bar')
+    end
+
+    it 'handles empty hashes' do
+      result = described_class.from_hash({})
+      expect(result).to be_a(described_class)
+      expect(result).to be_empty
+    end
+
+    it 'handles mixed string and symbol keys' do
+      regular_hash = { 'string_key' => 'value1', :symbol_key => 'value2' }
+      result = described_class.from_hash(regular_hash)
+      
+      expect(result['string_key']).to eq('value1')
+      expect(result[:string_key]).to eq('value1')
+      expect(result['symbol_key']).to eq('value2')
+      expect(result[:symbol_key]).to eq('value2')
+    end
+  end
+
+  describe 'map gem API compatibility' do
+    # These tests ensure no breaking changes compared to the map gem
+    
+    it 'supports basic key-value storage' do
+      hash[:key] = 'value'
+      expect(hash[:key]).to eq('value')
+      expect(hash['key']).to eq('value')
+    end
+
+    it 'supports dot notation like map gem' do
+      hash.max_age = 3600
+      expect(hash.max_age).to eq(3600)
+      expect(hash[:max_age]).to eq(3600)
+    end
+
+    it 'supports fetch with default values' do
+      expect(hash.fetch(:missing, 'default')).to eq('default')
+    end
+
+    it 'supports has_key? checks' do
+      hash[:present] = 'value'
+      expect(hash.has_key?(:present)).to be true
+      expect(hash.has_key?('present')).to be true
+      expect(hash.has_key?(:absent)).to be false
+    end
+
+    it 'maintains Hash inheritance' do
+      expect(hash).to be_a(Hash)
+    end
+
+    it 'supports standard Hash operations' do
+      hash[:a] = 1
+      hash[:b] = 2
+      
+      expect(hash.keys.sort).to eq(['a', 'b'])
+      expect(hash.values.sort).to eq([1, 2])
+      expect(hash.size).to eq(2)
+    end
+
+    it 'supports iteration' do
+      hash[:a] = 1
+      hash[:b] = 2
+      
+      result = []
+      hash.each { |k, v| result << [k, v] }
+      expect(result).to contain_exactly(['a', 1], ['b', 2])
+    end
+
+    context 'usage in BrowserCachePolicy' do
+      it 'supports caching policy access patterns' do
+        # Mimics how BrowserCachePolicy uses the hash
+        hash[:max_age] = 3600
+        hash[:s_maxage] = 7200
+        hash[:public] = true
+        hash[:no_cache] = false
+        
+        expect(hash.has_key?(:max_age)).to be true
+        expect(hash.has_key?('s_maxage')).to be true
+        expect(hash.fetch(:public, false)).to be true
+        expect(hash.fetch(:private, false)).to be false
+        expect(hash.fetch('must_revalidate', false)).to be false
+      end
+
+      it 'supports mixed string and symbol key access like in caching_policy.rb' do
+        hash[:max_age] = 3600
+        expect(hash['max_age']).to eq(3600)
+        expect(hash.max_age).to eq(3600)
+      end
+    end
+  end
+end

data/spec/resource_spec.rb

@@ -182,6 +182,212 @@ describe Middleman::S3Sync::Resource do
     end
   end
 
+  context 'content type detection' do
+    context 'when mm_resource provides content_type' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/file.html',
+          content_type: 'text/html'
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/file.html').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/file.html').and_return('content')
+      end
+
+      it 'uses the content_type from mm_resource' do
+        expect(resource.content_type).to eq 'text/html'
+      end
+    end
+
+    context 'when mm_resource is nil (orphan file)' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(nil, remote) }
+
+      let(:remote) { mock_s3_object('path/to/file.webp') }
+
+      before do
+        resource.full_s3_resource = remote
+        allow(File).to receive(:exist?).with('build/path/to/file.webp').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/file.webp').and_return('content')
+      end
+
+      it 'falls back to mime-types for known extensions' do
+        expect(resource.content_type).to eq 'image/webp'
+      end
+    end
+
+    context 'when mm_resource has nil content_type' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/image.svg',
+          content_type: nil
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/image.svg').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/image.svg').and_return('content')
+      end
+
+      it 'falls back to mime-types' do
+        expect(resource.content_type).to eq 'image/svg+xml'
+      end
+    end
+
+    context 'when content_types option is set' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/data.custom',
+          content_type: nil
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/data.custom').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/data.custom').and_return('content')
+        options.content_types = { 'path/to/data.custom' => 'application/x-custom' }
+      end
+
+      it 'uses content_types option by path' do
+        expect(resource.content_type).to eq 'application/x-custom'
+      end
+    end
+
+    context 'when content_types option uses local_path key' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/data.custom',
+          content_type: nil
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/data.custom').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/data.custom').and_return('content')
+        options.content_types = { 'build/path/to/data.custom' => 'application/x-custom-local' }
+      end
+
+      it 'uses content_types option by local_path' do
+        expect(resource.content_type).to eq 'application/x-custom-local'
+      end
+    end
+
+    context 'when extension is unknown' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/file.unknownext123',
+          content_type: nil
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/file.unknownext123').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/file.unknownext123').and_return('content')
+      end
+
+      it 'defaults to application/octet-stream' do
+        expect(resource.content_type).to eq 'application/octet-stream'
+      end
+    end
+  end
+
+  context 'a resource with explicit path (orphan file)' do
+    subject(:resource) { Middleman::S3Sync::Resource.new(nil, nil, path: 'orphan/file.webp') }
+
+    before do
+      allow(File).to receive(:exist?).with('build/orphan/file.webp').and_return(true)
+      allow(File).to receive(:exist?).with('build/orphan/file.webp.gz').and_return(false)
+      allow(File).to receive(:read).with('build/orphan/file.webp').and_return('content')
+      allow(File).to receive(:directory?).with('build/orphan/file.webp').and_return(false)
+      
+      # Mock the bucket to return NotFound for head request (file doesn't exist on S3)
+      mock_object = instance_double(Aws::S3::Object)
+      allow(mock_object).to receive(:head).and_raise(Aws::S3::Errors::NotFound.new(nil, 'Not Found'))
+      allow(bucket).to receive(:object).with('orphan/file.webp').and_return(mock_object)
+    end
+
+    its(:path) { is_expected.to eq 'orphan/file.webp' }
+    its(:local_path) { is_expected.to eq 'build/orphan/file.webp' }
+    its(:status) { is_expected.to eq :new }
+
+    it 'detects content type via mime-types' do
+      expect(resource.content_type).to eq 'image/webp'
+    end
+  end
+
+  context 'redirect preservation' do
+    context 'remote-only redirect (no local file)' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(nil, remote) }
+
+      let(:remote) do
+        double(
+          key: 'old-page.html',
+          metadata: {},
+          etag: '"abc123"',
+          content_encoding: nil,
+          cache_control: nil,
+          website_redirect_location: '/new-page.html'
+        )
+      end
+
+      before do
+        allow(File).to receive(:exist?).with('build/old-page.html').and_return(false)
+        resource.full_s3_resource = remote
+      end
+
+      it 'detects as a redirect' do
+        expect(resource.redirect?).to be true
+      end
+
+      its(:status) { is_expected.to eq :ignored }
+
+      it 'is not marked for deletion' do
+        expect(resource.to_delete?).to be false
+      end
+    end
+
+    context 'remote file without redirect (no local file)' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(nil, remote) }
+
+      let(:remote) do
+        double(
+          key: 'deleted-page.html',
+          metadata: {},
+          etag: '"abc123"',
+          content_encoding: nil,
+          cache_control: nil,
+          website_redirect_location: nil
+        )
+      end
+
+      before do
+        allow(File).to receive(:exist?).with('build/deleted-page.html').and_return(false)
+        resource.full_s3_resource = remote
+      end
+
+      it 'is not a redirect' do
+        expect(resource.redirect?).to be_falsey
+      end
+
+      its(:status) { is_expected.to eq :deleted }
+
+      it 'is marked for deletion' do
+        expect(resource.to_delete?).to be true
+      end
+    end
+  end
+
   context 'An ignored resource' do
     context "that is local" do