mini_magick 3.8.1 → 4.0.0

data/spec/lib/mini_magick/image_spec.rb

@@ -1,499 +1,460 @@
-require 'spec_helper'
-require 'pathname'
-require 'tempfile'
-
-MiniMagick.processor = :mogrify
-
-describe MiniMagick::Image do
-  context 'when ImageMagick and GraphicsMagick are both unavailable' do
-    before do
-      MiniMagick::Utilities.expects(:which).at_least_once.returns(nil)
-      MiniMagick.instance_variable_set(:@processor, nil)
-      @old_path = ENV['PATH']
-      ENV['PATH'] = ''
-    end
+require "spec_helper"
+require "pathname"
+require "tempfile"
+require "fileutils"
+require "stringio"
+
+["ImageMagick", "GraphicsMagick"].each do |cli|
+  RSpec.context "With #{cli}", cli: cli.downcase.to_sym do
+    describe MiniMagick::Image do
+      subject { described_class.open(image_path) }
+
+      describe ".read" do
+        it "reads image from String" do
+          string = File.binread(image_path)
+          image = described_class.read(string)
+          expect(image).to be_valid
+        end
 
-    after do
-      ENV['PATH'] = @old_path
-    end
+        it "reads image from StringIO" do
+          stringio = StringIO.new(File.binread(image_path))
+          image = described_class.read(stringio)
+          expect(image).to be_valid
+        end
 
-    it "raises an exception with 'No such file' in the message" do
-      begin
-        described_class.open(SIMPLE_IMAGE_PATH)
-      rescue => e
-        expect(e.message).to match(/(No such file|not found)/)
+        it "reads image from tempfile" do
+          tempfile = Tempfile.open('magick')
+          FileUtils.cp image_path, tempfile.path
+          image = described_class.read(tempfile)
+          expect(image).to be_valid
+        end
       end
-    end
-  end
 
-  describe 'ported from testunit', :ported => true do
-    it 'reads image from blob' do
-      File.open(SIMPLE_IMAGE_PATH, 'rb') do |f|
-        image = described_class.read(f.read)
-        expect(image).to be_valid
-        image.destroy!
-      end
-    end
+      describe ".import_pixels" do
+        let(:dimensions) { [325, 200] }
+        let(:depth)      { 16 } # 16 bits (2 bytes) per pixel
+        let(:map)        { 'gray' }
+        let(:pixels)     { Array.new(dimensions.inject(:*)) { |i| i } }
+        let(:blob)       { pixels.pack('S*') } # unsigned short, native byte order
 
-    it 'reads image from tempfile', :if => !MiniMagick::Utilities.windows? do
-      tempfile = Tempfile.new('magick')
+        it "can import pixels with default format" do
+          image = described_class.import_pixels(blob, *dimensions, depth, map)
 
-      File.open(SIMPLE_IMAGE_PATH, 'rb') do |f|
-        tempfile.write(f.read)
-        tempfile.rewind
-      end
-
-      image = described_class.read(tempfile)
-      expect(image).to be_valid
-      image.destroy!
-    end
+          expect(image).to be_valid
+          expect(image.type).to eq 'PNG'
+          expect(image.dimensions).to eq dimensions
+        end
 
-    # from https://github.com/minimagick/minimagick/issues/163
-    it 'annotates image with whitespace' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
+        it "can import pixels with custom format" do
+          image = described_class.import_pixels(blob, *dimensions, depth, map, 'jpeg')
 
-      expect {
-        message = 'a b'
+          expect(image).to be_valid
+          expect(image.type).to eq 'JPEG'
+          expect(image.dimensions).to eq dimensions
+        end
+      end
 
-        image.combine_options do |c|
-          c.gravity 'SouthWest'
-          c.fill 'white'
-          c.stroke 'black'
-          c.strokewidth '2'
-          c.pointsize '48'
-          c.interline_spacing '-9'
-          c.annotate '0', message
+      describe ".open" do
+        it "makes a copy of the image" do
+          image = described_class.open(image_path)
+          expect(image.path).not_to eq image_path
+          expect(image).to be_valid
         end
-      }.to_not raise_error
-    end
 
-    it 'opens image' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      expect(image).to be_valid
-      image.destroy!
-    end
+        it "accepts a Pathname" do
+          image = described_class.open(Pathname(image_path))
+          expect(image).to be_valid
+        end
 
-    it 'reads image from buffer' do
-      buffer = StringIO.new File.open(SIMPLE_IMAGE_PATH, 'rb') { |f| f.read }
-      image = described_class.read(buffer)
-      expect(image).to be_valid
-      image.destroy!
-    end
+        it "loads a remote image" do
+          begin
+            image = described_class.open(image_url)
+            expect(image).to be_valid
+          rescue SocketError
+          end
+        end
 
-    describe '.create' do
-      subject(:create) do
-        described_class.create do |f|
-          # Had to replace the old File.read with the following to work across all platforms
-          f.write(File.open(SIMPLE_IMAGE_PATH, 'rb') { |fi| fi.read })
+        it "validates the image" do
+          expect { described_class.open(image_path(:not)) }
+            .to raise_error(MiniMagick::Invalid)
         end
       end
 
-      it 'creates an image' do
-        expect {
-          image = create
-          image.destroy!
-        }.to_not raise_error
-      end
+      describe ".create" do
+        def create(path = image_path)
+          described_class.create do |f|
+            f.write(File.binread(path))
+          end
+        end
 
-      describe 'validation' do
-        before do
-          @old_validate = MiniMagick.validate_on_create
-          MiniMagick.validate_on_create = validate
+        it "creates an image" do
+          image = create
+          expect(File.exists?(image.path)).to eq true
         end
 
-        context 'MiniMagick.validate_on_create = true' do
-          let(:validate) { true }
+        it "validates the image if validation is set" do
+          allow(MiniMagick).to receive(:validate_on_create).and_return(true)
+          expect { create(image_path(:not)) }
+            .to raise_error(MiniMagick::Invalid)
+        end
 
-          it 'validates image' do
-            described_class.any_instance.expects(:valid?).returns(true)
-            create
-          end
+        it "doesn't validate image if validation is disabled" do
+          allow(MiniMagick).to receive(:validate_on_create).and_return(false)
+          expect { create(image_path(:not)) }
+            .not_to raise_error
         end
+      end
 
-        context 'MiniMagick.validate_on_create = false' do
-          let(:validate) { false }
+      describe "#initialize" do
+        it "initializes a new image" do
+          image = described_class.new(image_path)
+          expect(image).to be_valid
+        end
 
-          it 'skips validation' do
-            described_class.any_instance.expects(:valid?).never
-            create
+        it "accepts a block which it passes on to #combine_options" do
+          image = described_class.new(subject.path) do |b|
+            b.resize "100x100!"
           end
+          expect(image.dimensions).to eq [100, 100]
         end
-
-        after { MiniMagick.validate_on_create = @old_validate }
       end
-    end
 
-    it 'loads a new image' do
-      expect {
-        image = described_class.new(SIMPLE_IMAGE_PATH)
-        image.destroy!
-      }.to_not raise_error
-    end
+      describe "equivalence" do
+        subject(:image) { described_class.new(image_path) }
+        let(:same_image) { described_class.new(image_path) }
+        let(:other_image) { described_class.new(image_path(:exif)) }
 
-    it 'loads remote image' do
-      image = described_class.open('http://upload.wikimedia.org/wikipedia/en/b/bc/Wiki.png')
-      expect(image).to be_valid
-      image.destroy!
-    end
+        it "is #== and #eql? to itself" do
+          expect(image).to eq(image)
+          expect(image).to eql(image)
+        end
 
-    it 'loads remote image with complex url' do
-      image = described_class.open(
-        'http://a0.twimg.com/a/1296609216/images/fronts/logo_withbird_home.png?extra=foo&plus=bar'
-      )
-      expect(image).to be_valid
-      image.destroy!
-    end
+        it "is #== and #eql? to an instance of the same image" do
+          expect(image).to eq(same_image)
+          expect(image).to eql(same_image)
+        end
 
-    it 'reformats an image with a given extension' do
-      expect {
-        image = described_class.open(CAP_EXT_PATH)
-        image.format 'jpg'
-      }.to_not raise_error
-    end
+        it "is not #== nor #eql? to an instance of a different image" do
+          expect(image).not_to eq(other_image)
+          expect(image).not_to eql(other_image)
+        end
 
-    describe '#write' do
-      it 'reformats a PSD with a given a extension and all layers' do
-        expect {
-          image = described_class.open(PSD_IMAGE_PATH)
-          image.format('jpg', nil)
-        }.to_not raise_error
-      end
+        it "generates the same hash code for an instance of the same image" do
+          expect(image.hash).to eq(same_image.hash)
+        end
 
-      it 'opens and writes an image' do
-        output_path = 'output.gif'
-        begin
-          image = described_class.new(SIMPLE_IMAGE_PATH)
-          image.write output_path
-          expect(File.exist?(output_path)).to be(true)
-        ensure
-          File.delete output_path
+        it "generates different same hash codes for a different image" do
+          expect(image.hash).not_to eq(other_image.hash)
         end
-        image.destroy!
       end
 
-      it 'opens and writes an image with space in its filename' do
-        output_path = 'test output.gif'
-        begin
-          image = described_class.new(SIMPLE_IMAGE_PATH)
-          image.write output_path
+      describe "#format" do
+        subject { described_class.open(image_path(:jpg)) }
 
-          expect(File.exist?(output_path)).to be(true)
-        ensure
-          File.delete output_path
+        it "changes the format of the photo" do
+          expect { subject.format("png") }
+            .to change { subject.type }
         end
-        image.destroy!
-      end
 
-      it 'writes an image with stream' do
-        stream = StringIO.new
-        image = described_class.open(SIMPLE_IMAGE_PATH)
-        image.write("#{Dir.tmpdir}/foo.gif")
-        image.write(stream)
-        expect(described_class.read(stream.string)).to be_valid
-        image.destroy!
-      end
+        it "reformats an image with a given extension" do
+          expect { subject.format('png') }
+            .to change { File.extname(subject.path) }.to ".png"
+        end
 
-      describe 'validation' do
-        let(:image) { described_class.new(SIMPLE_IMAGE_PATH) }
-        let(:output_path) { 'output.gif' }
+        it "creates the file with new extension" do
+          subject.format('png')
+          expect(File.exist?(subject.path)).to eq true
+        end
 
-        before do
-          @old_validate = MiniMagick.validate_on_write
-          MiniMagick.validate_on_write = validate
+        it "accepts a block of additional commands" do
+          expect {
+            subject.format("png") do |b|
+              b.resize("100x100!")
+            end
+          }.to change { subject.dimensions }.to [100, 100]
         end
 
-        subject(:write) { image.write output_path }
+        it "works without an extension" do
+          subject = described_class.open(image_path(:without_extension))
+          expect { subject.format("png") }
+            .to change { File.extname(subject.path) }.from("").to(".png")
+        end
 
-        context 'MiniMagick.validate_on_write = true' do
-          let(:validate) { true }
+        it "deletes the previous tempfile" do
+          old_path = subject.path.dup
+          subject.format('png')
+          expect(File.exist?(old_path)).to eq false
+        end
 
-          it 'runs post-validation' do
-            image.expects(:run_command).with('identify', output_path)
-            write
-          end
+        it "doesn't delete itself when formatted to the same format" do
+          subject.format(subject.type.downcase)
+          expect(File.exists?(subject.path)).to eq true
         end
 
-        context 'MiniMagick.validate_on_write = false' do
-          let(:validate) { false }
+        it "reformats multi-image formats to multiple images" do
+          subject = described_class.open(image_path(:animation))
+          subject.format('jpg', nil)
+          expect(Dir[subject.path.sub('.', '*.')]).not_to be_empty
+        end
 
-          it 'runs post-validation' do
-            image.expects(:run_command).never
-            write
-          end
+        it "reformats multi-image formats to a single image" do
+          subject = described_class.open(image_path(:animation))
+          subject.format('jpg')
+          expect(subject).to be_valid
         end
 
-        after do
-          image.destroy!
-          File.delete output_path
-          MiniMagick.validate_on_write = @old_validate
+        it "returns self" do
+          expect(subject.format('png')).to eq subject
         end
       end
-    end
 
-    it 'tells when an image is invalid' do
-      image = described_class.new(NOT_AN_IMAGE_PATH)
-      expect(image).not_to be_valid
-      image.destroy!
-    end
-
-    it "raises error when opening a file that isn't an image" do
-      expect {
-        image = described_class.open(NOT_AN_IMAGE_PATH)
-        image.destroy
-      }.to raise_error(MiniMagick::Invalid)
-    end
+      describe "#write" do
+        it "writes the image" do
+          output_path = random_path("test output")
+          subject.write(output_path)
+          expect(described_class.new(output_path)).to be_valid
+        end
 
-    it "raises error when imagemagick raised an error during processing" do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      image.rotate "invalid_value"
-      expect { image.run_queue }.to raise_error(MiniMagick::Error)
-    end
+        it "writes an image with stream" do
+          output_stream = StringIO.new
+          subject.write(output_stream)
+          expect(described_class.read(output_stream.string)).to be_valid
+        end
 
-    it 'inspects image meta info' do
-      image = described_class.new(SIMPLE_IMAGE_PATH)
-      expect(image[:width]).to be(150)
-      expect(image[:height]).to be(55)
-      expect(image[:dimensions]).to match_array [150, 55]
-      expect(image[:colorspace]).to be_an_instance_of(String)
-      expect(image[:format]).to match(/^gif$/i)
-      image.destroy!
-    end
+        it "writes layers" do
+          output_path = random_path(["", ".#{subject.type.downcase}"])
+          subject = described_class.new(image_path(:gif))
+          subject.frames.first.write(output_path)
+          expect(described_class.new(output_path)).to be_valid
+        end
 
-    it 'supports string keys for dimension attributes' do
-      image = described_class.new(SIMPLE_IMAGE_PATH)
-      expect(image["width"]).to be(150)
-      expect(image["height"]).to be(55)
-      expect(image["dimensions"]).to match_array [150, 55]
-      image.destroy!
-    end
+        it "accepts a Pathname" do
+          output_path = Pathname(random_path)
+          subject.write(output_path)
+          expect(described_class.new(output_path.to_s)).to be_valid
+        end
+      end
 
-    it 'inspects an erroneus image meta info' do
-      image = described_class.new(ERRONEOUS_IMAGE_PATH)
-      expect(image[:width]).to be(10)
-      expect(image[:height]).to be(10)
-      expect(image[:dimensions]).to match_array [10, 10]
-      expect(image[:format]).to eq 'JPEG'
-      image.destroy!
-    end
+      describe "#valid?" do
+        it "returns true when image is valid" do
+          image = described_class.new(image_path)
+          expect(image).to be_valid
+        end
 
-    it 'inspects meta info from tiff images' do
-      image = described_class.new(TIFF_IMAGE_PATH)
-      expect(image[:format].to_s.downcase).to eq 'tiff'
-      expect(image[:width]).to be(50)
-      expect(image[:height]).to be(41)
-      image.destroy!
-    end
+        it "returns false when image is not valid" do
+          image = described_class.new(image_path(:not))
+          expect(image).not_to be_valid
+        end
+      end
 
-    it 'inspects a gif with jpg format correctly' do
-      image = described_class.new(GIF_WITH_JPG_EXT)
-      expect(image[:format].to_s.downcase).to eq 'gif'
-      image.destroy!
-    end
+      describe "#[]" do
+        it "inspects image meta info" do
+          expect(subject[:width]).to be_a(Fixnum)
+          expect(subject[:height]).to be_a(Fixnum)
+          expect(subject[:dimensions]).to all(be_a(Fixnum))
+          expect(subject[:colorspace]).to be_a(String)
+          expect(subject[:format]).to match(/[A-Z]/)
+          expect(subject[:signature]).to match(/[[:alnum:]]{64}/)
+        end
 
-    it 'resizes an image correctly' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      image.resize '20x30!'
+        it "supports string keys" do
+          expect(subject["width"]).to be_a(Fixnum)
+          expect(subject["height"]).to be_a(Fixnum)
+          expect(subject["dimensions"]).to all(be_a(Fixnum))
+          expect(subject["colorspace"]).to be_a(String)
+          expect(subject["format"]).to match(/[A-Z]/)
+          expect(subject['signature']).to match(/[[:alnum:]]{64}/)
+        end
 
-      expect(image[:width]).to be(20)
-      expect(image[:height]).to be(30)
-      expect(image[:format]).to match(/^gif$/i)
-      image.destroy!
-    end
+        it "reads exif" do
+          subject = described_class.new(image_path(:exif))
+          gps_latitude = subject.exif["GPSLatitude"].split(/\s*,\s*/)
+          gps_longitude = subject.exif["GPSLongitude"].split(/\s*,\s*/)
 
-    it 'resizes an image with minimum dimensions' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      original_width, original_height = image[:width], image[:height]
-      image.resize "#{original_width + 10}x#{original_height + 10}>"
+          expect(subject["EXIF:ColorSpace"]).to eq "1"
+          expect(gps_latitude.size).to eq 3
+          expect(gps_longitude.size).to eq 3
+        end
 
-      expect(image[:width]).to be original_width
-      expect(image[:height]).to be original_height
-      image.destroy!
-    end
+        it "passes unknown values directly to -format" do
+          expect(subject["%w %h"].split.map(&:to_i)).to eq [subject[:width], subject[:height]]
+        end
+      end
 
-    it 'combines options to create an image with resize and blur' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      image.combine_options do |c|
-        c.resize '20x30!'
-        c.blur '50'
+      it "has attributes" do
+        expect(subject.type).to match(/^[A-Z]+$/)
+        expect(subject.mime_type).to match(/^image\/[a-z]+$/)
+        expect(subject.width).to be_a(Fixnum).and be_nonzero
+        expect(subject.height).to be_a(Fixnum).and be_nonzero
+        expect(subject.dimensions).to all(be_a(Fixnum))
+        expect(subject.size).to be_a(Fixnum).and be_nonzero
+        expect(subject.colorspace).to be_a(String)
+        expect(subject.resolution).to all(be_a(Fixnum))
+        expect(subject.signature).to match(/[[:alnum:]]{64}/)
       end
 
-      expect(image[:width]).to be(20)
-      expect(image[:height]).to be(30)
-      expect(image[:format]).to match(/\Agif\z/i)
-      image.destroy!
-    end
+      describe "#exif" do
+        subject { described_class.new(image_path(:exif)) }
 
-    it "combines options to create an image even with minuses symbols on it's name it" do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      background = '#000000'
-      expect {
-        image.combine_options do |c|
-          c.draw "image Over 0,0 10,10 '#{MINUS_IMAGE_PATH}'"
-          c.thumbnail '300x500>'
-          c.background background
-        end
-      }.to_not raise_error
-      image.destroy!
-    end
+        it "returns a hash of EXIF data" do
+          expect(subject.exif["DateTimeOriginal"]).to be_a(String)
+        end
 
-    it 'inspects the EXIF of an image' do
-      image = described_class.open(EXIF_IMAGE_PATH)
-      expect(image['exif:ExifVersion']).to eq '0220'
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      expect(image['EXIF:ExifVersion']).to be_empty
-      image.destroy!
-    end
+        it "decodes the ExifVersion" do
+          expect(subject.exif["ExifVersion"]).to eq("0221")
+        end
+      end
 
-    it 'inspects the original at of an image' do
-      image = described_class.open(EXIF_IMAGE_PATH)
-      expect(image[:original_at]).to eq Time.local('2005', '2', '23', '23', '17', '24')
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      expect(image[:original_at]).to be_nil
-      image.destroy!
-    end
+      describe "#resolution" do
+        it "accepts units", skip_cli: :graphicsmagick do
+          expect(subject.resolution("PixelsPerCentimeter"))
+            .not_to eq subject.resolution("PixelsPerInch")
+        end
+      end
 
-    it 'has the same path for tempfile and image' do
-      image = described_class.open(TIFF_IMAGE_PATH)
-      expect(image.instance_eval('@tempfile.path')).to eq image.path
-      image.destroy!
-    end
+      describe "#mime_type" do
+        it "returns the correct mime type" do
+          jpg = described_class.new(image_path(:jpg))
+          expect(jpg.mime_type).to eq 'image/jpeg'
+        end
+      end
 
-    it 'has the tempfile at path after format' do
-      image = described_class.open(TIFF_IMAGE_PATH)
-      image.format('png')
-      expect(File.exist?(image.path)).to be(true)
-      image.destroy!
-    end
+      describe "#layers" do
+        it "returns a list of images" do
+          expect(subject.layers).to all(be_a(MiniMagick::Image))
+          expect(subject.layers.first).to be_valid
+        end
 
-    it "hasn't previous tempfile at path after format" do
-      image = described_class.open(TIFF_IMAGE_PATH)
-      before = image.path.dup
-      image.format('png')
-      expect(File.exist?(before)).to be(false)
-      image.destroy!
-    end
+        it "returns multiple images for GIFs, PDFs and PSDs" do
+          gif = described_class.new(image_path(:gif))
+          psd = described_class.new(image_path(:psd))
 
-    it 'changes the format of image with special characters', :if => !MiniMagick::Utilities.windows? do
-      tempfile = Tempfile.new('magick with special! "chars\'')
+          expect(gif.frames.count).to be > 1
+          expect(psd.layers.count).to be > 1 unless MiniMagick.graphicsmagick?
+        end
+
+        it "returns one image for other formats" do
+          jpg = described_class.new(image_path(:jpg))
 
-      File.open(SIMPLE_IMAGE_PATH, 'rb') do |file|
-        tempfile.write(file.read)
-        tempfile.rewind
+          expect(jpg.layers.count).to eq 1
+        end
       end
 
-      image = described_class.new(tempfile.path)
-      image.format('png')
-      expect(File.exist?(image.path)).to be(true)
-      image.destroy!
+      describe "missing methods" do
+        context "for a known method" do
+          it "is executed by #method_missing" do
+            expect { subject.resize '20x30!' }
+              .to change { subject.dimensions }.to [20, 30]
+          end
 
-      File.delete(image.path)
-      tempfile.unlink
-    end
+          it "returns self" do
+            expect(subject.resize('20x30!')).to eq subject
+          end
 
-    it 'raises exception when calling wrong method' do
-      image = described_class.open(TIFF_IMAGE_PATH)
-      expect { image.to_blog }.to raise_error(NoMethodError)
-      image.to_blob
-      image.destroy!
-    end
+          it "can be responed to" do
+            expect(subject.respond_to?(:resize)).to eq true
+          end
+        end
+
+        context "for an unknown method" do
+          it "fails with a NoMethodError" do
+            expect { subject.foo }
+              .to raise_error(NoMethodError, /MiniMagick::Image/)
+          end
 
-    it 'can create a composite of two images' do
-      image = described_class.open(EXIF_IMAGE_PATH)
-      result = image.composite(described_class.open(TIFF_IMAGE_PATH)) do |c|
-        c.gravity 'center'
+          it "cannot be responded to" do
+            expect(subject.respond_to?(:foo)).to eq false
+          end
+        end
       end
-      expect(File.exist?(result.path)).to be(true)
-    end
 
-    # https://github.com/minimagick/minimagick/issues/212
-    it 'can create a composite of two images with mask' do
-      image = described_class.open(EXIF_IMAGE_PATH)
-      result = image.composite(described_class.open(TIFF_IMAGE_PATH), 'jpg', described_class.open(PNG_PATH)) do |c|
-        c.gravity 'center'
+      describe "#combine_options" do
+        it "chains multiple options and executes them in one command" do
+          expect {
+            subject.combine_options { |c| c.resize '20x30!' }
+          }.to change { subject.dimensions }.to [20, 30]
+        end
+
+        it "doesn't allow calling of #format" do
+          expect { subject.combine_options { |c| c.format("png") } }
+            .to raise_error(NoMethodError)
+        end
+
+        it "returns self" do
+          expect(subject.combine_options {}).to eq subject
+        end
       end
-      expect(File.exist?(result.path)).to be(true)
-    end
 
-    # https://github.com/minimagick/minimagick/issues/8
-    it 'has issue 8 fixed' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      expect {
-        image.combine_options do |c|
-          c.sample '50%'
-          c.rotate '-90>'
+      describe "#composite" do
+        let(:other_image) { described_class.open(image_path) }
+        let(:mask) { described_class.open(image_path) }
+
+        it "creates a composite of two images" do
+          image = subject.composite(other_image)
+          expect(image).to be_valid
         end
-      }.to_not raise_error
-      image.destroy!
-    end
 
-    # https://github.com/minimagick/minimagick/issues/8
-    it 'has issue 15 fixed' do
-      expect {
-        image = described_class.open(Pathname.new(SIMPLE_IMAGE_PATH))
-        output = Pathname.new('test.gif')
-        image.write(output)
-      }.to_not raise_error
-      FileUtils.rm('test.gif')
-    end
+        it "creates a composite of two images with mask" do
+          image = subject.composite(other_image, 'jpg', mask)
+          expect(image).to be_valid
+        end
 
-    # https://github.com/minimagick/minimagick/issues/37
-    it 'respects the language set' do
-      original_lang = ENV['LANG']
-      ENV['LANG'] = 'fr_FR.UTF-8'
+        it "yields an optional block" do
+          expect { |b| subject.composite(other_image, &b) }
+            .to yield_with_args(an_instance_of(MiniMagick::Tool::Composite))
+        end
 
-      expect {
-        image = described_class.open(NOT_AN_IMAGE_PATH)
-        image.destroy
-      }.to raise_error(MiniMagick::Invalid)
+        it "makes the composited image with the provided extension" do
+          result = subject.composite(other_image, 'png')
+          expect(result.path).to end_with ".png"
 
-      ENV['LANG'] = original_lang
-    end
+          result = subject.composite(other_image)
+          expect(result.path).to end_with ".jpg"
+        end
+      end
 
-    it 'can import pixels with default format' do
-      columns = 325
-      rows    = 200
-      depth   = 16 # 16 bits (2 bytes) per pixel
-      map     = 'gray'
-      pixels  = Array.new(columns * rows) { |i| i }
-      blob    = pixels.pack('S*') # unsigned short, native byte order
-      image   = described_class.import_pixels(blob, columns, rows, depth, map)
-
-      expect(image).to be_valid
-      expect(image[:format].to_s.downcase).to eq 'png'
-      expect(image[:width]).to eq columns
-      expect(image[:height]).to eq rows
-      image.write("#{Dir.tmpdir}/imported_pixels_image.png")
-    end
+      describe "#collapse!" do
+        subject { described_class.open(image_path(:animation)) }
 
-    it 'can import pixels with custom format' do
-      columns = 325
-      rows    = 200
-      depth   = 16 # 16 bits (2 bytes) per pixel
-      map     = 'gray'
-      format  = 'jpeg'
-      pixels  = Array.new(columns * rows) { |i| i }
-      blob    = pixels.pack('S*') # unsigned short, native byte order
-      image   = described_class.import_pixels(blob, columns, rows, depth, map, format)
-
-      expect(image).to be_valid
-      expect(image[:format].to_s.downcase).to eq format
-      expect(image[:width]).to eq columns
-      expect(image[:height]).to eq rows
-      image.write("#{Dir.tmpdir}/imported_pixels_image." + format)
-    end
+        it "collapses the image to one frame" do
+          subject.collapse!
+          expect(subject.identify.lines.count).to eq 1
+        end
+
+        it "keeps the extension" do
+          expect { subject.collapse! }
+            .not_to change { subject.type }
+        end
+
+        it "clears the info" do
+          expect { subject.collapse! }
+            .to change { subject.size }
+        end
+
+        it "returns self" do
+          expect(subject.collapse!).to eq subject
+        end
+      end
 
-    it 'loads mimetype correctly' do
-      gif        = described_class.open(SIMPLE_IMAGE_PATH)
-      jpeg       = described_class.open(EXIF_IMAGE_PATH)
-      png        = described_class.open(PNG_PATH)
-      tiff       = described_class.open(TIFF_IMAGE_PATH)
-      hidden_gif = described_class.open(GIF_WITH_JPG_EXT)
-
-      expect(gif.mime_type).to eq 'image/gif'
-      expect(jpeg.mime_type).to eq 'image/jpeg'
-      expect(png.mime_type).to eq 'image/png'
-      expect(tiff.mime_type).to eq 'image/tiff'
-      expect(hidden_gif.mime_type).to eq 'image/gif'
+      describe "#identify" do
+        it "returns the output of identify" do
+          expect(subject.identify).to match(subject.type)
+        end
+
+        it "yields an optional block" do
+          output = subject.identify do |b|
+            b.verbose
+          end
+          expect(output).to match("Format:")
+        end
+      end
+
+      describe "#run_command" do
+        it "runs the given command" do
+          output = subject.run_command("identify", "-format", "%w", subject.path)
+          expect(output).to eq subject.width.to_s
+        end
+      end
     end
   end
 end