openstreetmap-image_optim 0.21.0.1

data/spec/image_optim/bin_resolver/comparable_condition_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'image_optim/bin_resolver/comparable_condition'
+
+describe ImageOptim::BinResolver::ComparableCondition do
+  is = ImageOptim::BinResolver::ComparableCondition.is
+
+  it 'builds conditions' do
+    expect(is.between?(10, 20).method).to eq(:between?)
+    expect(is.between?(10, 20).args).to eq([10, 20])
+
+    expect((is >= 15).method).to eq(:>=)
+    expect((is >= 15).args).to eq([15])
+
+    expect((is < 30).method).to eq(:<)
+    expect((is < 30).args).to eq([30])
+  end
+
+  it 'stringifies conditions' do
+    expect(is.between?(10, 20).to_s).to eq('10..20')
+    expect((is >= 15).to_s).to eq('>= 15')
+    expect((is < 30).to_s).to eq('< 30')
+  end
+
+  it 'matches conditions' do
+    expect(is.between?(10, 20)).not_to match 9
+    expect(is.between?(10, 20)).to match 15
+    expect(is.between?(10, 20)).not_to match 21
+
+    expect(is >= 15).not_to match 14
+    expect(is >= 15).to match 15
+    expect(is >= 15).to match 16
+
+    expect(is < 30).to match 29
+    expect(is < 30).not_to match 30
+    expect(is < 30).not_to match 31
+  end
+end

data/spec/image_optim/bin_resolver/simple_version_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'image_optim/bin_resolver/simple_version'
+
+describe ImageOptim::BinResolver::SimpleVersion do
+  helpers = Module.new do
+    def v(str)
+      ImageOptim::BinResolver::SimpleVersion.new(str)
+    end
+  end
+  include helpers
+  extend helpers
+
+  describe 'compares version 1.17' do
+    subject{ v '1.17' }
+
+    it{ is_expected.to be > '0' }
+    it{ is_expected.to be > '0.1' }
+    it{ is_expected.to be > '0.9' }
+    it{ is_expected.to be > '1.9' }
+    it{ is_expected.to be < '1.17.1' }
+    it{ is_expected.to be < '1.99' }
+    it{ is_expected.to be < '2.1' }
+  end
+
+  describe 'normalization' do
+    %w[
+      1
+      01
+      1.0
+      1.00
+      1.0.0
+      1.0.0.0
+    ].each do |variation|
+      it "normalizes #{variation}" do
+        expect(v variation).to eq(1)
+      end
+    end
+  end
+
+  describe 'conversion' do
+    it 'converts Integer' do
+      expect(v 117).to eq('117')
+    end
+
+    it 'converts Float' do
+      expect(v 1.17).to eq('1.17')
+    end
+
+    it 'converts String' do
+      expect(v '1.17').to eq('1.17')
+    end
+
+    it 'converts self' do
+      expect(v(v 1.17)).to eq('1.17')
+    end
+  end
+end

data/spec/image_optim/bin_resolver_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+require 'image_optim/bin_resolver'
+require 'image_optim/cmd'
+
+describe ImageOptim::BinResolver do
+  def with_env(key, value)
+    saved, ENV[key] = ENV[key], value
+    yield
+  ensure
+    ENV[key] = saved
+  end
+
+  before do
+    stub_const('BinResolver', ImageOptim::BinResolver)
+    stub_const('Bin', BinResolver::Bin)
+    stub_const('SimpleVersion', BinResolver::SimpleVersion)
+    stub_const('Cmd', ImageOptim::Cmd)
+  end
+
+  let(:image_optim){ double(:image_optim, :verbose => false, :pack => false) }
+  let(:resolver){ BinResolver.new(image_optim) }
+
+  describe :full_path do
+    def full_path(name)
+      resolver.instance_eval{ full_path(name) }
+    end
+
+    def command_v(name)
+      path = Cmd.capture("sh -c 'command -v #{name}' 2> /dev/null").strip
+      path unless path.empty?
+    end
+
+    it 'finds binary in path' do
+      with_env 'PATH', 'bin' do
+        expect(full_path('image_optim')).
+          to eq(File.expand_path('bin/image_optim'))
+      end
+    end
+
+    it 'finds bin in vendor' do
+      with_env 'PATH', nil do
+        expect(full_path('jpegrescan')).
+          to eq(File.expand_path('vendor/jpegrescan'))
+      end
+    end
+
+    it 'finds bin in pack' do
+      allow(image_optim).to receive(:pack).and_return(true)
+      stub_const('ImageOptim::Pack', Class.new do
+        def self.path
+          'script'
+        end
+      end)
+
+      with_env 'PATH', nil do
+        expect(full_path('update_worker_options_in_readme')).
+          to eq(File.expand_path('script/update_worker_options_in_readme'))
+      end
+    end
+
+    it 'works with different path separator' do
+      stub_const('File::PATH_SEPARATOR', 'O_o')
+      with_env 'PATH', 'bin' do
+        expect(full_path('image_optim')).
+          to eq(File.expand_path('bin/image_optim'))
+      end
+    end
+
+    it 'returns nil on failure' do
+      with_env 'PATH', 'lib' do
+        expect(full_path('image_optim')).to be_nil
+      end
+    end
+
+    %w[ls sh which bash image_optim does_not_exist].each do |name|
+      it "returns same path as `command -v` for #{name}" do
+        expect(full_path(name)).to eq(command_v(name))
+      end
+    end
+  end
+
+  it 'combines path in order dir:pack:path:vendor' do
+    allow(image_optim).to receive(:pack).and_return(true)
+    stub_const('ImageOptim::Pack', Class.new do
+      def self.path
+        'pack_path'
+      end
+    end)
+    allow(resolver).to receive(:dir).and_return('temp_dir')
+
+    expect(resolver.env_path).to eq([
+      'temp_dir',
+      'pack_path',
+      ENV['PATH'],
+      BinResolver::VENDOR_PATH,
+    ].join(':'))
+  end
+
+  it 'resolves bin in path and returns instance of Bin' do
+    with_env 'LS_BIN', nil do
+      expect(FSPath).not_to receive(:temp_dir)
+      expect(resolver).to receive(:full_path).with(:ls).and_return('/bin/ls')
+      bin = double
+      expect(Bin).to receive(:new).with(:ls, '/bin/ls').and_return(bin)
+      expect(bin).to receive(:check!).once
+      expect(bin).to receive(:check_fail!).exactly(5).times
+
+      5.times do
+        expect(resolver.resolve!(:ls)).to eq(bin)
+      end
+      expect(resolver.env_path).to eq([
+        ENV['PATH'],
+        BinResolver::VENDOR_PATH,
+      ].join(':'))
+    end
+  end
+
+  it 'raises on failure to resolve bin' do
+    with_env 'LS_BIN', nil do
+      expect(FSPath).not_to receive(:temp_dir)
+      expect(resolver).to receive(:full_path).with(:ls).and_return(nil)
+      expect(Bin).not_to receive(:new)
+
+      5.times do
+        expect do
+          resolver.resolve!(:ls)
+        end.to raise_error BinResolver::BinNotFound
+      end
+      expect(resolver.env_path).to eq([
+        ENV['PATH'],
+        BinResolver::VENDOR_PATH,
+      ].join(':'))
+    end
+  end
+
+  it 'resolves bin specified in ENV' do
+    path = 'bin/image_optim'
+    with_env 'IMAGE_OPTIM_BIN', path do
+      tmpdir = double(:tmpdir, :to_str => 'tmpdir')
+      symlink = double(:symlink)
+
+      expect(FSPath).to receive(:temp_dir).
+        once.and_return(tmpdir)
+      expect(tmpdir).to receive(:/).
+        with(:image_optim).once.and_return(symlink)
+      expect(symlink).to receive(:make_symlink).
+        with(File.expand_path(path)).once
+
+      expect(resolver).not_to receive(:full_path)
+      bin = double
+      expect(Bin).to receive(:new).
+        with(:image_optim, File.expand_path(path)).and_return(bin)
+      expect(bin).to receive(:check!).once
+      expect(bin).to receive(:check_fail!).exactly(5).times
+
+      at_exit_blocks = []
+      expect(resolver).to receive(:at_exit).once do |&block|
+        at_exit_blocks.unshift(block)
+      end
+
+      5.times do
+        resolver.resolve!(:image_optim)
+      end
+      expect(resolver.env_path).to eq([
+        tmpdir,
+        ENV['PATH'],
+        BinResolver::VENDOR_PATH,
+      ].join(':'))
+
+      expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir)
+      at_exit_blocks.each(&:call)
+    end
+  end
+
+  {
+    'some/path/does/not/exist' => 'doesn\'t exist',
+    '.' => 'is not a file',
+    __FILE__ => 'is not executable',
+  }.each do |path, error_message|
+    it "raises when bin specified in ENV #{error_message}" do
+      with_env 'IMAGE_OPTIM_BIN', path do
+        expect(FSPath).not_to receive(:temp_dir)
+        expect(resolver).not_to receive(:at_exit)
+
+        5.times do
+          expect do
+            resolver.resolve!(:image_optim)
+          end.to raise_error RuntimeError, /#{Regexp.escape(error_message)}/
+        end
+        expect(resolver.env_path).to eq([
+          ENV['PATH'],
+          BinResolver::VENDOR_PATH,
+        ].join(':'))
+      end
+    end
+  end
+
+  it 'resolves bin only once, but checks every time' do
+    with_env 'LS_BIN', nil do
+      expect(resolver).to receive(:full_path).once.with(:ls) do
+        sleep 0.1
+        '/bin/ls'
+      end
+      bin = double
+      expect(Bin).to receive(:new).once.with(:ls, '/bin/ls').and_return(bin)
+
+      count = 0
+      mutex = Mutex.new
+      allow(bin).to receive(:check!).once
+      allow(bin).to receive(:check_fail!){ mutex.synchronize{ count += 1 } }
+
+      10.times.map do
+        Thread.new do
+          resolver.resolve!(:ls)
+        end
+      end.each(&:join)
+
+      expect(count).to eq(10)
+    end
+  end
+
+  describe 'checking version' do
+    before do
+      allow(resolver).to receive(:full_path){ |name| "/bin/#{name}" }
+    end
+
+    it 'raises every time if did not get bin version' do
+      with_env 'PNGCRUSH_BIN', nil do
+        bin = Bin.new(:pngcrush, '/bin/pngcrush')
+
+        expect(Bin).to receive(:new).and_return(bin)
+        allow(bin).to receive(:version).and_return(nil)
+
+        5.times do
+          expect do
+            resolver.resolve!(:pngcrush)
+          end.to raise_error Bin::UnknownVersion
+        end
+      end
+    end
+
+    it 'raises every time on detection of misbehaving version' do
+      with_env 'PNGCRUSH_BIN', nil do
+        bin = Bin.new(:pngcrush, '/bin/pngcrush')
+
+        expect(Bin).to receive(:new).and_return(bin)
+        allow(bin).to receive(:version).and_return(SimpleVersion.new('1.7.60'))
+
+        5.times do
+          expect do
+            resolver.resolve!(:pngcrush)
+          end.to raise_error Bin::BadVersion
+        end
+      end
+    end
+
+    it 'warns once on detection of problematic version' do
+      with_env 'ADVPNG_BIN', nil do
+        bin = Bin.new(:advpng, '/bin/advpng')
+
+        expect(Bin).to receive(:new).and_return(bin)
+        allow(bin).to receive(:version).and_return(SimpleVersion.new('1.15'))
+
+        expect(bin).to receive(:warn).once
+
+        5.times do
+          resolver.resolve!(:pngcrush)
+        end
+      end
+    end
+  end
+end

data/spec/image_optim/cmd_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'image_optim/cmd'
+
+describe ImageOptim::Cmd do
+  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
+      expect_int_exception do
+        Cmd.run('kill -s INT $$')
+      end
+    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
+      expect_int_exception do
+        Cmd.capture('kill -s INT $$')
+      end
+    end
+  end
+end

data/spec/image_optim/config_spec.rb

@@ -0,0 +1,217 @@
+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 :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
+
+        def image_formats
+          []
+        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 'config' 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 'class methods' do
+    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(:file?)
+
+        expect(IOConfig.read_options(path)).to eq({})
+      end
+
+      it 'returns empty hash if path is not a file' do
+        expect(IOConfig).not_to receive(:warn)
+        expect(File).to receive(:expand_path).
+          with(path).and_return(full_path)
+        expect(File).to receive(:file?).
+          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(:file?).
+          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(:file?).
+          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(:file?).
+          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
+end