discourse_image_optim 0.24.4

data/spec/image_optim/cache_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'fspath'
+require 'image_optim/cache'
+require 'image_optim/path'
+
+describe ImageOptim::Cache do
+  before do
+    stub_const('Cache', ImageOptim::Cache)
+    stub_const('CachePath', ImageOptim::CachePath)
+  end
+
+  let(:tmp_file){ double('/somewhere/tmp/foo/bar', :rename => 0) }
+
+  let(:cache_dir) do
+    dir = '/somewhere/cache'
+    allow(FileUtils).to receive(:mkpath).with(Regexp.new(Regexp.escape(dir)))
+    allow(FileUtils).to receive(:touch)
+    allow(FSPath).to receive(:temp_file_path) do
+      tmp_file
+    end
+    FSPath.new(dir)
+  end
+
+  let(:original) do
+    original = double('/somewhere/original', :image_format => :ext)
+    allow(Digest::SHA1).to receive(:file).with(original) do
+      Digest::SHA1.new << 'some content!'
+    end
+    original
+  end
+
+  let(:optimized) do
+    double('/somewhere/optimized', :format => :ext, :basename => 'optimized')
+  end
+
+  let(:cached) do
+    cached = cache_dir / digest
+    allow(Digest::SHA1).to receive(:file).with(cached) do
+      Digest::SHA1.new << 'some optimized content!'
+    end
+    CachePath.convert(cached)
+  end
+
+  context 'when cache is disabled (default)' do
+    let(:image_optim) do
+      double(:image_optim, :cache_dir => nil, :cache_worker_digests => false)
+    end
+    let(:cache){ Cache.new(image_optim, double) }
+
+    describe :fetch do
+      it 'always return block' do
+        expect(cache.fetch(original){ optimized }).to be optimized
+      end
+    end
+
+    describe :fetch do
+      it 'does not write to disk' do
+        expect(FileUtils).not_to receive(:mv)
+        expect(FileUtils).not_to receive(:touch)
+        expect(cache.fetch(original){ optimized })
+      end
+    end
+  end
+
+  shared_examples 'an enabled cache' do
+    context 'when cached file does not exist' do
+      describe :fetch do
+        it 'writes to cache when file is optimizable' do
+          cached_s = cached.to_s
+          expect(FileTest).to receive(:file?).with(cached_s).and_return(false)
+          expect(FileTest).not_to receive(:size?).with(cached_s)
+          expect(FileUtils).to receive(:mv).with(optimized, tmp_file)
+          expect(tmp_file).to receive(:rename).with(cached)
+
+          allow(File).to receive(:umask).and_return(0o024)
+          expect(tmp_file).to receive(:chmod).with(0o642)
+
+          expect(cache.fetch(original){ optimized }).to eq(cached)
+        end
+
+        it 'writes an empty file to cache when file is already optimized' do
+          cached_s = cached.to_s
+          expect(FileTest).to receive(:file?).with(cached_s).and_return(false)
+          expect(FileTest).not_to receive(:size?).with(cached_s)
+          expect(FileUtils).not_to receive(:mv)
+          expect(FileUtils).to receive(:touch).with(cached)
+
+          expect(cache.fetch(original){ nil }).to eq(nil)
+        end
+      end
+    end
+
+    context 'when cached file exists (options and/or workers match)' do
+      describe(:fetch) do
+        it 'returns cached file' do
+          cached_s = cached.to_s
+          allow(FileTest).to receive(:file?).with(cached_s).and_return(true)
+          allow(FileTest).to receive(:size?).with(cached_s).and_return(1234)
+          expect(FileUtils).not_to receive(:mv)
+          expect(File).not_to receive(:rename)
+
+          expect(cache.fetch(original){}).to eq(cached)
+        end
+
+        it 'returns nil when file is already optimized' do
+          cached_s = cached.to_s
+          allow(FileTest).to receive(:file?).with(cached_s).and_return(true)
+          allow(FileTest).to receive(:size?).with(cached_s).and_return(nil)
+          expect(FileUtils).not_to receive(:mv)
+          expect(File).not_to receive(:rename)
+
+          expect(cache.fetch(original){ nil }).to eq(nil)
+        end
+      end
+    end
+  end
+
+  context 'when cache is enabled (without worker digests)' do
+    let(:image_optim) do
+      double(:image_optim,
+             :cache_dir => cache_dir, :cache_worker_digests => false)
+    end
+    let(:cache) do
+      cache = Cache.new(image_optim, {})
+      allow(cache).
+        to receive(:options_by_format).
+        with(original.image_format).
+        and_return('some options!')
+      allow(cache).
+        to receive(:bins_by_format).
+        with(original.image_format).
+        and_return('some bins!')
+      cache
+    end
+    let(:digest){ cache.send(:digest, original, original.image_format) }
+
+    it_behaves_like 'an enabled cache'
+  end
+
+  context 'when cache is enabled (with worker digests)' do
+    let(:image_optim) do
+      double(:image_optim,
+             :cache_dir => cache_dir,
+             :cache_worker_digests => true)
+    end
+    let(:cache) do
+      cache = Cache.new(image_optim, {})
+      allow(cache).
+        to receive(:options_by_format).
+        with(original.image_format).
+        and_return('some options!')
+      allow(cache).
+        to receive(:bins_by_format).
+        with(original.image_format).
+        and_return('some bins!')
+      cache
+    end
+    let(:digest){ cache.send(:digest, original, original.image_format) }
+
+    it_behaves_like 'an enabled cache'
+  end
+end

data/spec/image_optim/cmd_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'image_optim/cmd'
+
+describe ImageOptim::Cmd do
+  include CapabilityCheckHelpers
+
+  before do
+    stub_const('Cmd', ImageOptim::Cmd)
+  end
+
+  def expect_int_exception(&block)
+    expect(&block).to raise_error(SignalException) do |error|
+      expect(error.message.to_s).to match(/INT|#{Signal.list['INT']}/)
+    end
+  end
+
+  describe '.run' do
+    it 'calls system and returns result' do
+      status = double
+      expect(Cmd).to receive(:system).with('cmd', 'arg').and_return(status)
+      allow(Cmd).to receive(:check_status!)
+      expect(Cmd.run('cmd', 'arg')).to eq(status)
+    end
+
+    it 'returns process success status' do
+      expect(Cmd.run('sh -c "exit 0"')).to eq(true)
+      expect($CHILD_STATUS.exitstatus).to eq(0)
+
+      expect(Cmd.run('sh -c "exit 1"')).to eq(false)
+      expect($CHILD_STATUS.exitstatus).to eq(1)
+
+      expect(Cmd.run('sh -c "exit 66"')).to eq(false)
+      expect($CHILD_STATUS.exitstatus).to eq(66)
+    end
+
+    it 'raises SignalException if process terminates after signal' do
+      skip 'signals are not supported' unless signals_supported?
+      expect_int_exception do
+        Cmd.run('kill -s INT $$')
+      end
+    end
+  end
+
+  describe '.run_with_timeout', :if => ImageOptim::Cmd.support_timeout? do
+    it 'spawns a process in a thread and returns status' do
+      expect(Cmd.run_with_timeout(20, 'sh -c "exit 0"')).to eq(true)
+
+      [1, 66].each do |status|
+        expect(Cmd.run_with_timeout(20, "sh -c \"exit #{status}\"")).
+          to eq(false)
+      end
+    end
+
+    it 'raises Timeout::Error if process timeout' do
+      expect{ Cmd.run_with_timeout(0.001, 'sleep 1') }.
+        to raise_error(Cmd::TimeoutExceeded)
+    end
+
+    it 'calls system if timeout is <= zero' do
+      expect(Cmd.run_with_timeout(0, 'sh -c "sleep 0.001; exit 0"')).to eq(true)
+
+      expect(Cmd.run_with_timeout(-1, 'sh -c "sleep 0.001; exit 1"')).
+        to eq(false)
+    end
+  end
+
+  describe '.capture' do
+    it 'calls ` and returns result' do
+      output = double
+      expect(Cmd).to receive(:`).with('cmd arg arg+').and_return(output)
+      allow(Cmd).to receive(:check_status!)
+      expect(Cmd.capture('cmd arg arg+')).to eq(output)
+    end
+
+    it 'returns output' do
+      expect(Cmd.capture('echo test')).to eq("test\n")
+      expect($CHILD_STATUS.exitstatus).to eq(0)
+
+      expect(Cmd.capture('printf more && sh -c "exit 1"')).to eq('more')
+      expect($CHILD_STATUS.exitstatus).to eq(1)
+
+      expect(Cmd.capture('sh -c "exit 66"')).to eq('')
+      expect($CHILD_STATUS.exitstatus).to eq(66)
+    end
+
+    it 'raises SignalException if process terminates after signal' do
+      skip 'signals are not supported' unless signals_supported?
+      expect_int_exception do
+        Cmd.capture('kill -s INT $$')
+      end
+    end
+  end
+end

data/spec/image_optim/config_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper'
+require 'image_optim/config'
+
+describe ImageOptim::Config do
+  before do
+    stub_const('IOConfig', ImageOptim::Config)
+  end
+
+  describe '#assert_no_unused_options!' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'does not raise when no unused options' do
+      config = IOConfig.new({})
+      config.assert_no_unused_options!
+    end
+
+    it 'raises when there are unused options' do
+      config = IOConfig.new(:unused => true)
+      expect do
+        config.assert_no_unused_options!
+      end.to raise_error(ImageOptim::ConfigurationError)
+    end
+  end
+
+  describe '#nice' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'is 10 by default' do
+      config = IOConfig.new({})
+      expect(config.nice).to eq(10)
+    end
+
+    it 'is 0 if disabled' do
+      config = IOConfig.new(:nice => false)
+      expect(config.nice).to eq(0)
+    end
+
+    it 'converts value to number' do
+      config = IOConfig.new(:nice => '13')
+      expect(config.nice).to eq(13)
+    end
+  end
+
+  describe '#threads' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'is processor_count by default' do
+      config = IOConfig.new({})
+      allow(config).to receive(:processor_count).and_return(13)
+      expect(config.threads).to eq(13)
+    end
+
+    it 'is 1 if disabled' do
+      config = IOConfig.new(:threads => false)
+      expect(config.threads).to eq(1)
+    end
+
+    it 'converts value to number' do
+      config = IOConfig.new(:threads => '616')
+      expect(config.threads).to eq(616)
+    end
+  end
+
+  describe '#cache_dir' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'is nil by default' do
+      config = IOConfig.new({})
+      expect(config.cache_dir).to be nil
+    end
+
+    it 'is nil if set to the empty string' do
+      config = IOConfig.new(:cache_dir => '')
+      expect(config.cache_dir).to be nil
+    end
+  end
+
+  describe '#cache_worker_digests' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'is false by default' do
+      config = IOConfig.new({})
+      expect(config.cache_worker_digests).to be false
+    end
+  end
+
+  describe '#timeout' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'is 0 by default' do
+      config = IOConfig.new({})
+      expect(config.timeout).to eq(0)
+    end
+
+    it 'converts value to number' do
+      config = IOConfig.new(:timeout => '15')
+      expect(config.timeout).to eq(15)
+    end
+  end
+
+  describe '#for_worker' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+      stub_const('Abc', Class.new do
+        def self.bin_sym
+          :abc
+        end
+      end)
+    end
+
+    it 'returns empty hash by default' do
+      config = IOConfig.new({})
+      expect(config.for_worker(Abc)).to eq({})
+    end
+
+    it 'returns passed hash' do
+      config = IOConfig.new(:abc => {:option => true})
+      expect(config.for_worker(Abc)).to eq(:option => true)
+    end
+
+    it 'returns {:disable => true} for false' do
+      config = IOConfig.new(:abc => false)
+      expect(config.for_worker(Abc)).to eq(:disable => true)
+    end
+
+    it 'raises on unknown option' do
+      config = IOConfig.new(:abc => 13)
+      expect do
+        config.for_worker(Abc)
+      end.to raise_error(ImageOptim::ConfigurationError)
+    end
+  end
+
+  describe '#initialize' do
+    it 'reads options from default locations' do
+      expect(IOConfig).to receive(:read_options).
+        with(IOConfig::GLOBAL_PATH).and_return(:a => 1, :b => 2, :c => 3)
+      expect(IOConfig).to receive(:read_options).
+        with(IOConfig::LOCAL_PATH).and_return(:a => 10, :b => 20)
+
+      config = IOConfig.new(:a => 100)
+      expect(config.get!(:a)).to eq(100)
+      expect(config.get!(:b)).to eq(20)
+      expect(config.get!(:c)).to eq(3)
+      config.assert_no_unused_options!
+    end
+
+    it 'does not read options with empty config_paths' do
+      expect(IOConfig).not_to receive(:read_options)
+
+      config = IOConfig.new(:config_paths => [])
+      config.assert_no_unused_options!
+    end
+
+    it 'reads options from specified paths' do
+      expect(IOConfig).to receive(:read_options).
+        with('/etc/image_optim.yml').and_return(:a => 1, :b => 2, :c => 3)
+      expect(IOConfig).to receive(:read_options).
+        with('config/image_optim.yml').and_return(:a => 10, :b => 20)
+
+      config = IOConfig.new(:a => 100, :config_paths => %w[
+        /etc/image_optim.yml
+        config/image_optim.yml
+      ])
+      expect(config.get!(:a)).to eq(100)
+      expect(config.get!(:b)).to eq(20)
+      expect(config.get!(:c)).to eq(3)
+      config.assert_no_unused_options!
+    end
+
+    it 'converts config_paths to array' do
+      expect(IOConfig).to receive(:read_options).
+        with('config/image_optim.yml').and_return({})
+
+      config = IOConfig.new(:config_paths => 'config/image_optim.yml')
+      config.assert_no_unused_options!
+    end
+  end
+
+  describe '.read_options' do
+    let(:path){ double(:path) }
+    let(:full_path){ double(:full_path) }
+
+    it 'warns if expand path fails' do
+      expect(IOConfig).to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_raise(ArgumentError)
+      expect(File).not_to receive(:size?)
+
+      expect(IOConfig.read_options(path)).to eq({})
+    end
+
+    it 'returns empty hash if path is not a file or is an empty file' do
+      expect(IOConfig).not_to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_return(full_path)
+      expect(File).to receive(:size?).
+        with(full_path).and_return(false)
+
+      expect(IOConfig.read_options(path)).to eq({})
+    end
+
+    it 'returns hash with deep symbolised keys from reader' do
+      stringified = {'config' => {'this' => true}}
+      symbolized = {:config => {:this => true}}
+
+      expect(IOConfig).not_to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_return(full_path)
+      expect(File).to receive(:size?).
+        with(full_path).and_return(true)
+      expect(YAML).to receive(:load_file).
+        with(full_path).and_return(stringified)
+
+      expect(IOConfig.read_options(path)).to eq(symbolized)
+    end
+
+    it 'warns and returns an empty hash if reader returns non hash' do
+      expect(IOConfig).to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_return(full_path)
+      expect(File).to receive(:size?).
+        with(full_path).and_return(true)
+      expect(YAML).to receive(:load_file).
+        with(full_path).and_return([:config])
+
+      expect(IOConfig.read_options(path)).to eq({})
+    end
+
+    it 'warns and returns an empty hash if reader raises exception' do
+      expect(IOConfig).to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_return(full_path)
+      expect(File).to receive(:size?).
+        with(full_path).and_return(true)
+      expect(YAML).to receive(:load_file).
+        with(full_path).and_raise
+
+      expect(IOConfig.read_options(path)).to eq({})
+    end
+  end
+end