openstreetmap-image_optim 0.21.0.1

data/spec/image_optim/space_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'image_optim/space'
+
+describe ImageOptim::Space do
+  before do
+    stub_const('Space', ImageOptim::Space)
+  end
+
+  {
+    0           => '      ',
+    1           => '    1B',
+    10          => '   10B',
+    100         => '  100B',
+    1_000       => ' 1000B',
+    10_000      => '  9.8K',
+    100_000     => ' 97.7K',
+    1_000_000   => '976.6K',
+    10_000_000  => '  9.5M',
+    100_000_000 => ' 95.4M',
+  }.each do |size, space|
+    it "converts #{size} to #{space}" do
+      expect(Space.space(size)).to eq(space)
+    end
+  end
+end

data/spec/image_optim/worker_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+require 'image_optim/worker'
+require 'image_optim/bin_resolver'
+
+describe ImageOptim::Worker do
+  before do
+    stub_const('Worker', ImageOptim::Worker)
+    stub_const('BinResolver', ImageOptim::BinResolver)
+  end
+
+  describe :optimize do
+    it 'raises NotImplementedError' do
+      image_optim = ImageOptim.new
+      worker = Worker.new(image_optim, {})
+
+      expect do
+        worker.optimize(double, double)
+      end.to raise_error NotImplementedError
+    end
+  end
+
+  describe :create_all_by_format do
+    it 'passes arguments to create_all' do
+      image_optim = double
+      options_proc = proc{ true }
+
+      expect(Worker).to receive(:create_all) do |arg, &block|
+        expect(arg).to eq(image_optim)
+        expect(block).to eq(options_proc)
+        []
+      end
+
+      Worker.create_all_by_format(image_optim, &options_proc)
+    end
+
+    it 'create hash by format' do
+      workers = [
+        double(:image_formats => [:a]),
+        double(:image_formats => [:a, :b]),
+        double(:image_formats => [:b, :c]),
+      ]
+
+      expect(Worker).to receive(:create_all).and_return(workers)
+
+      worker_by_format = {
+        :a => [workers[0], workers[1]],
+        :b => [workers[1], workers[2]],
+        :c => [workers[2]],
+      }
+
+      expect(Worker.create_all_by_format(double)).to eq(worker_by_format)
+    end
+  end
+
+  describe :create_all do
+    def worker_double(override = {})
+      stubs = {:resolve_used_bins! => nil, :run_order => 0}.merge(override)
+      instance_double(Worker, stubs)
+    end
+
+    let(:image_optim){ double(:allow_lossy => false) }
+
+    it 'creates all workers for which options_proc returns true' do
+      workers = Array.new(3){ worker_double }
+      klasses = workers.map{ |worker| double(:init => worker) }
+      options_proc = proc do |klass|
+        klass == klasses[1] ? {:disable => true} : {}
+      end
+
+      allow(Worker).to receive(:klasses).and_return(klasses)
+
+      expect(Worker.create_all(image_optim, &options_proc)).
+        to eq([workers[0], workers[2]])
+    end
+
+    it 'handles workers initializing multiple instances' do
+      workers = [
+        worker_double,
+        [worker_double, worker_double, worker_double],
+        worker_double,
+      ]
+      klasses = workers.map{ |worker| double(:init => worker) }
+
+      allow(Worker).to receive(:klasses).and_return(klasses)
+
+      expect(Worker.create_all(image_optim){ {} }).
+        to eq(workers.flatten)
+    end
+
+    describe 'with missing workers' do
+      let(:workers) do
+        Array.new(3) do |i|
+          worker = worker_double
+          unless i == 1
+            allow(worker).to receive(:resolve_used_bins!).
+              and_raise(BinResolver::BinNotFound, "not found #{i}")
+          end
+          worker
+        end
+      end
+      let(:klasses){ workers.map{ |worker| double(:init => worker) } }
+
+      before do
+        allow(Worker).to receive(:klasses).and_return(klasses)
+      end
+
+      describe 'if skip_missing_workers is true' do
+        define :bin_not_found do |message|
+          match do |error|
+            error.is_a?(BinResolver::BinNotFound) && error.message == message
+          end
+        end
+
+        it 'shows warnings and returns resolved workers ' do
+          allow(image_optim).to receive(:skip_missing_workers).and_return(true)
+
+          expect(Worker).to receive(:warn).
+            once.with(bin_not_found('not found 0'))
+          expect(Worker).to receive(:warn).
+            once.with(bin_not_found('not found 2'))
+
+          expect(Worker.create_all(image_optim){ {} }).
+            to eq([workers[1]])
+        end
+      end
+
+      describe 'if skip_missing_workers is false' do
+        it 'fails with a joint exception' do
+          allow(image_optim).to receive(:skip_missing_workers).and_return(false)
+
+          expect do
+            Worker.create_all(image_optim){ {} }
+          end.to raise_error(BinResolver::Error, /not found 0\nnot found 2/)
+        end
+      end
+    end
+
+    it 'orders workers by run_order' do
+      image_optim = double(:allow_lossy => false)
+      run_orders = [10, -10, 0, 0, 0, 10, -10]
+      workers = run_orders.map do |run_order|
+        worker_double(:run_order => run_order)
+      end
+      klasses_list = workers.map{ |worker| double(:init => worker) }
+
+      [
+        klasses_list,
+        klasses_list.reverse,
+        klasses_list.shuffle,
+      ].each do |klasses|
+        allow(Worker).to receive(:klasses).and_return(klasses)
+
+        expected_order = klasses.map(&:init).sort_by.with_index do |worker, i|
+          [worker.run_order, i]
+        end
+
+        expect(Worker.create_all(image_optim){ {} }).to eq(expected_order)
+      end
+    end
+  end
+
+  describe :option do
+    it 'runs option block in context of worker' do
+      # don't add Abc to list of wokers
+      allow(ImageOptim::Worker).to receive(:inherited)
+
+      stub_const('Abc', Class.new(Worker) do
+        option(:test, 1, 'Test context') do |_v|
+          some_instance_method
+        end
+      end)
+
+      expect_any_instance_of(Abc).
+        to receive(:some_instance_method).and_return(20)
+      expect(Abc.new(ImageOptim.new).test).to eq(20)
+    end
+
+    it 'returns instance of OptionDefinition' do
+      # don't add Abc to list of wokers
+      allow(ImageOptim::Worker).to receive(:inherited)
+
+      definition = nil
+      Class.new(Worker) do
+        definition = option(:test, 1, 'Test'){ |v| v }
+      end
+
+      expect(definition).to be_an(ImageOptim::OptionDefinition)
+      expect(definition.name).to eq(:test)
+      expect(definition.default).to eq(1)
+    end
+  end
+end

data/spec/image_optim_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+require 'image_optim'
+require 'image_optim/cmd'
+require 'tempfile'
+require 'English'
+
+describe ImageOptim do
+  root_dir = ImageOptim::ImagePath.new(__FILE__).dirname.dirname
+  images_dir = root_dir / 'spec/images'
+  test_images = images_dir.glob('**/*.*').freeze
+
+  helpers = Module.new do
+    def temp_copy(image)
+      image.temp_path.tap{ |path| image.copy(path) }
+    end
+  end
+  include helpers
+  extend helpers
+
+  matcher :be_in_range do |expected|
+    match{ |actual| expected.include?(actual) }
+  end
+
+  before do
+    stub_const('Cmd', ImageOptim::Cmd)
+
+    allow(ImageOptim::Config).to receive(:global).and_return({})
+    allow(ImageOptim::Config).to receive(:local).and_return({})
+  end
+
+  disable_all_workers = Hash[ImageOptim::Worker.klasses.map do |klass|
+    [klass.bin_sym, false]
+  end]
+
+  ImageOptim::Worker.klasses.each do |worker_klass|
+    describe "#{worker_klass.bin_sym} worker" do
+      it 'optimizes at least one test image' do
+        options = disable_all_workers.dup
+        options.merge!(worker_klass.bin_sym => true)
+        options.merge!(:skip_missing_workers => false)
+
+        image_optim = ImageOptim.new(options)
+        if Array(worker_klass.init(image_optim)).empty?
+          image_optim = ImageOptim.new(options.merge(:allow_lossy => true))
+        end
+
+        expect(test_images.any? do |original|
+          image_optim.optimize_image(temp_copy(original))
+        end).to be true
+      end
+    end
+  end
+
+  describe :optimize_image do
+    define :have_same_data_as do |expected|
+      match{ |actual| actual.binread == expected.binread }
+    end
+
+    define :have_size do
+      match(&:size?)
+    end
+
+    describe 'optimizing images' do
+      rotated = images_dir / 'orient/original.jpg'
+      rotate_images = images_dir.glob('orient/?.jpg')
+
+      base_options = {:skip_missing_workers => false}
+      [
+        ['lossless', base_options, 0],
+        ['lossy', base_options.merge(:allow_lossy => true), 0.01],
+      ].each do |type, options, max_difference|
+        image_optim = ImageOptim.new(options)
+        describe type do
+          copies = test_images.map{ |image| temp_copy(image) }
+          pairs = image_optim.optimize_images(copies)
+          test_images.zip(*pairs.transpose).each do |original, copy, optimized|
+            it "optimizes #{original.relative_path_from(root_dir)}" do
+              expect(copy).to have_same_data_as(original)
+
+              expect(optimized).not_to be_nil
+              expect(optimized).to be_a(ImageOptim::ImagePath::Optimized)
+              expect(optimized).to have_size
+              expect(optimized).to be_smaller_than(original)
+              expect(optimized).not_to have_same_data_as(original)
+
+              compare_to = rotate_images.include?(original) ? rotated : original
+              expect(optimized).to be_similar_to(compare_to, max_difference)
+            end
+          end
+        end
+      end
+    end
+
+    it 'ignores text file' do
+      original = ImageOptim::ImagePath.new(__FILE__)
+      copy = temp_copy(original)
+
+      expect(Tempfile).not_to receive(:new)
+      optimized_image = ImageOptim.optimize_image(copy)
+      expect(optimized_image).to be_nil
+      expect(copy.read).to eq(original.read)
+    end
+
+    {
+      :png => "\211PNG\r\n\032\n",
+      :jpeg => "\377\330",
+    }.each do |type, data|
+      it "ingores broken #{type}" do
+        path = FSPath.temp_file_path
+        path.write(data)
+        expect(ImageOptim::ImageMeta).to receive(:warn)
+        expect(ImageOptim.optimize_image(path)).to be_nil
+      end
+    end
+  end
+
+  describe :optimize_image! do
+    it 'optimizes image and replaces original' do
+      original = double
+      optimized = double(:original_size => 12_345)
+      optimized_wrap = double
+      image_optim = ImageOptim.new
+
+      allow(ImageOptim::ImagePath).to receive(:convert).
+        with(original).and_return(original)
+
+      expect(image_optim).to receive(:optimize_image).
+        with(original).and_return(optimized)
+      expect(optimized).to receive(:replace).with(original)
+      expect(ImageOptim::ImagePath::Optimized).to receive(:new).
+        with(original, 12_345).and_return(optimized_wrap)
+
+      expect(image_optim.optimize_image!(original)).to eq(optimized_wrap)
+    end
+
+    it 'returns nil if optimization fails' do
+      original = double
+      image_optim = ImageOptim.new
+
+      allow(ImageOptim::ImagePath).to receive(:convert).
+        with(original).and_return(original)
+
+      expect(image_optim).to receive(:optimize_image).
+        with(original).and_return(nil)
+      expect(ImageOptim::ImagePath::Optimized).not_to receive(:new)
+
+      expect(image_optim.optimize_image!(original)).to eq(nil)
+    end
+  end
+
+  describe :optimize_image_data do
+    it 'create temp file, optimizes image and returns data' do
+      data = double
+      temp = double(:path => double)
+      optimized = double
+      optimized_data = double
+      image_optim = ImageOptim.new
+
+      allow(ImageOptim::ImageMeta).to receive(:for_data).
+        with(data).and_return(double(:format => 'xxx'))
+
+      expect(ImageOptim::ImagePath).to receive(:temp_file).and_yield(temp)
+      expect(temp).to receive(:binmode)
+      expect(temp).to receive(:write).with(data)
+      expect(temp).to receive(:close)
+      expect(image_optim).to receive(:optimize_image).
+        with(temp.path).and_return(optimized)
+      expect(optimized).to receive(:binread).and_return(optimized_data)
+
+      expect(image_optim.optimize_image_data(data)).to eq(optimized_data)
+    end
+
+    it 'returns nil if optimization fails' do
+      data = double
+      temp = double(:path => double)
+      image_optim = ImageOptim.new
+
+      allow(ImageOptim::ImageMeta).to receive(:for_data).
+        with(data).and_return(double(:format => 'xxx'))
+
+      expect(ImageOptim::ImagePath).to receive(:temp_file).and_yield(temp)
+      expect(temp).to receive(:binmode)
+      expect(temp).to receive(:write).with(data)
+      expect(temp).to receive(:close)
+      expect(image_optim).to receive(:optimize_image).
+        with(temp.path).and_return(nil)
+
+      expect(image_optim.optimize_image_data(data)).to eq(nil)
+    end
+
+    it 'returns nil if format can\'t be detected' do
+      data = double
+      image_optim = ImageOptim.new
+
+      allow(ImageOptim::ImageMeta).to receive(:for_data).
+        with(data).and_return(double(:format => nil))
+
+      expect(ImageOptim::ImagePath).not_to receive(:temp_file)
+      expect(image_optim).not_to receive(:optimize_image)
+
+      expect(image_optim.optimize_image_data(data)).to eq(nil)
+    end
+  end
+
+  describe 'optimize multiple' do
+    %w[
+      optimize_images
+      optimize_images!
+      optimize_images_data
+    ].each do |list_method|
+      describe list_method do
+        method = list_method.sub('images', 'image')
+        describe 'without block' do
+          it 'optimizes images and returns array of results' do
+            image_optim = ImageOptim.new
+            results = test_images.map do |src|
+              dst = double
+              expect(image_optim).to receive(method).with(src).and_return(dst)
+              [src, dst]
+            end
+            expect(image_optim.send(list_method, test_images)).to eq(results)
+          end
+        end
+
+        describe 'given block' do
+          it 'optimizes images, yields path and result for each and '\
+              'returns array of yield results' do
+            image_optim = ImageOptim.new
+            results = test_images.map do |src|
+              dst = double
+              expect(image_optim).to receive(method).with(src).and_return(dst)
+              [src, dst, :test]
+            end
+            expect(image_optim.send(list_method, test_images) do |src, dst|
+              [src, dst, :test]
+            end).to eq(results)
+          end
+        end
+      end
+    end
+  end
+end