vtools 0.0.1

data/spec/thumbnailer_spec.rb

@@ -0,0 +1,178 @@
+require "spec_helper"
+require "thumbnailer"
+
+describe VTools::Thumbnailer do
+
+  let(:video)  { double (nil) }
+
+  # hooks
+  before do
+    @thumbnailer = VTools::Thumbnailer.new video
+  end
+
+  # specs
+  context "#run" do
+
+    before do
+      @output_file = nil
+      @options = {}
+    end
+
+    def prepare_thumbnailer error_strings = []
+      # prepare output lines
+      index = 0
+      # output iterator (raise error once per item)
+      Open3.stub!(:popen3).and_return do |*args, block|
+        (io = StringIO.new(error_strings[index].to_s)).rewind
+        block.yield(nil, io, nil)
+        index += 1
+      end
+
+      @options.stub(:to_s) { "test.options" }
+
+      video.stub(:thumbs_options) { @options }
+      video.stub(:name) { "video.name" }
+      video.stub(:path) { "video/path" }
+      @converter.instance_variable_set( :@video, video )
+
+      VTools::CONFIG[:thumb_binary] = "tested.thumbnailer"
+      @output_file = "/#{video.name}_"
+
+      VTools.should_receive(:fix_encoding).exactly(@options[:thumb_count].to_i).times.and_return {|str| str}
+      VTools::Handler.should_receive(:exec).with(:before_thumb, video, @options)
+      @thumbnailer.should_receive(:generate_path)
+    end
+
+    it "creates thumbnails without postfix" do
+
+      @options = {:thumb_count => 3, :thumb_start_point => 0}
+      prepare_thumbnailer
+
+      thumbs_array = [
+        {:path => "#{@output_file}0.jpg", :offset => 0},
+        {:path => "#{@output_file}1.jpg", :offset => 1},
+        {:path => "#{@output_file}2.jpg", :offset => 2},
+      ]
+
+      thumbs_array.each do |index|
+        VTools::Handler.should_receive(:exec).with(:in_thumb, video, index)
+      end
+
+      @thumbnailer.should_receive(:set_point).exactly(3).times.and_return { |sec| sec }
+      @thumbnailer.should_receive(:time_offset).exactly(3).times.and_return { |sec| (sec.is_a?(Hash) ? sec[:thumb_start_point] : sec) }
+      VTools::Handler.should_receive(:exec).with(:thumb_success, video, thumbs_array)
+
+      @thumbnailer.run.should == thumbs_array
+    end
+
+    it "creates thumb with postfix and offset" do
+      
+      @options = {:thumb_count => 1, :thumb_start_point => 3, :postfix => "test.postfix"}
+      prepare_thumbnailer
+
+      thumbs_array = [ {:path => "#{@output_file}test.postfix.jpg", :offset => 3} ]
+
+      VTools::Handler.should_receive(:exec).with(:in_thumb, video, thumbs_array[0])
+
+      @thumbnailer.should_receive(:set_point).once.and_return { |sec| sec }
+      @thumbnailer.should_receive(:time_offset).once.and_return { |sec| sec[:thumb_start_point] }
+      VTools::Handler.should_receive(:exec).with(:thumb_success, video, thumbs_array)
+
+      @thumbnailer.run.should == thumbs_array
+    end
+
+    it "creates thumbs via options[:t]" do
+      @options = {:t => 12, :thumb_count => 1}
+      prepare_thumbnailer
+
+      thumbs_array = [ {:path => "#{@output_file}12.jpg", :offset => 12} ]
+
+      VTools::Handler.stub(:exec)
+      @thumbnailer.should_not_receive(:set_point)
+      @thumbnailer.should_receive(:time_offset).with(12).once.and_return { |sec| sec }
+
+      @thumbnailer.run.should == thumbs_array
+    end
+
+    it "creates 2 of 3 thumbs" do
+      @options = {:thumb_count => 3, :thumb_start_point => 0}
+      prepare_thumbnailer ["thumbnailer error"]
+
+      thumbs_array = [
+        {:path => "#{@output_file}1.jpg", :offset => 1},
+        {:path => "#{@output_file}2.jpg", :offset => 2},
+      ]
+
+      VTools::Handler.should_receive(:exec).with(:thumb_error, video, " Errors: thumbnailer error (/video.name_0.jpg). ")
+      thumbs_array.each do |index|
+        VTools::Handler.should_receive(:exec).with(:in_thumb, video, index)
+      end
+
+      @thumbnailer.should_receive(:set_point).exactly(3).times.and_return { |sec| sec }
+      @thumbnailer.should_receive(:time_offset).exactly(2).times.and_return { |sec| (sec.is_a?(Hash) ? sec[:thumb_start_point] : sec) }
+
+      @thumbnailer.run.should == thumbs_array
+    end
+
+    it "completely fails on thumb creation" do
+      @options = {:thumb_count => 2, :thumb_start_point => 0}
+      prepare_thumbnailer ["thumbnailer error", "thumbnailer error 2"]
+
+
+      VTools::Handler.should_receive(:exec).with(
+        :thumb_error, video,
+        " Errors: thumbnailer error (/video.name_0.jpg);thumbnailer error 2 (/video.name_1.jpg). "
+      )
+
+      @thumbnailer.should_not_receive(:time_offset)
+      @thumbnailer.should_receive(:set_point).exactly(2).times.and_return { |sec| sec }
+
+      expect { @thumbnailer.run }.to raise_error VTools::ProcessError, /Thumbnailer error:/
+    end
+  end
+
+  context "#set_point" do
+
+    context "generates percent point from hash" do
+      it "indicated in percent" do
+        config = {:thumb_start_point => "12.2%"}
+        @thumbnailer.method(:set_point).call(config).should == 12
+      end
+
+      it "indicated in seconds" do
+        config = { :thumb_start_point => 122 }
+        @thumbnailer.should_receive(:time_offset).with("122")
+
+        @thumbnailer.method(:set_point).call(config)
+      end
+    end
+
+    it "generates percent point from integer" do
+      @thumbnailer.instance_variable_set(:@total, 3) # total count
+      @thumbnailer.method(:set_point).call(1).should == 33 # first pic
+      @thumbnailer.method(:set_point).call(2).should == 66
+      @thumbnailer.method(:set_point).call(3).should == 100 # last pic
+    end
+
+    it "returns default" do
+      @thumbnailer.method(:set_point).call("invalid").should == 0
+    end
+  end
+
+  context "#time_offset" do
+
+    let(:video) {v = double nil; v.stub(:duration){120.3}; v}
+
+    before { @thumbnailer.instance_variable_set(:@video, video) }
+
+    it "calculates offset from valid shift value" do
+      @thumbnailer.method(:time_offset).call(10).should == "00:00:10"
+      @thumbnailer.method(:time_offset).call(23.2).should == "00:00:23"
+    end
+
+    it "shift value is invalid returns video duration" do
+      @thumbnailer.method(:time_offset).call(123).should == "00:02:00"
+      @thumbnailer.method(:time_offset).call(130).should == "00:02:00"
+    end
+  end
+end

data/spec/thumbs_options_spec.rb

@@ -0,0 +1,159 @@
+require "spec_helper"
+require "thumbs_options"
+
+describe VTools::ThumbsOptions do
+
+  # hooks
+  before :all do
+    @options_base = VTools::ThumbsOptions.new({})
+  end
+
+  before :each do
+    @options = @options_base.dup
+  end
+
+  # specs
+  context "#[]=" do
+
+    it "places quality" do
+      # place initial value
+      @options.merge!({:q => 10})
+
+      # set new values
+      @options[:q] = 5
+      @options[:q].should == 5
+      @options[:quality].should == 5
+      # set new values
+      @options[:quality] = 7
+      @options[:q].should == 7
+      @options[:quality].should == 7
+    end
+
+    it "places width" do
+      # place initial value
+      @options.merge!({:width => 256})
+
+      # set new values
+      @options[:s] = 128
+      @options[:s].should == 128
+      @options[:width].should == 128
+
+      @options[:width] = 360
+      @options[:s].should == 360
+      @options[:width].should == 360
+    end
+
+    it "places time" do
+      # :time, :t
+      # place initial value
+      @options.merge!({:t => 150})
+
+      # set new values
+      @options[:t] = 45
+      @options[:t].should == 45
+      @options[:time].should == 45
+
+      @options[:time] = 89
+      @options[:t].should == 89
+      @options[:time].should == 89
+    end
+
+    it "places other" do
+      @options[:a] = 123
+      @options[:a].should == 123
+    end
+  end
+
+  context "#to_s" do
+
+    # [:thumb_count, :thumb_start_point, :quality, :width, :time, :postfix]
+    # skps ignored values
+    it "reates valid string representation" do
+
+      # still empty
+      @options.to_s.should == ""
+
+      # skips disallowed keywords
+      @options.merge! :thumb_count        => 10,
+                      :thumb_start_point  => 25,
+                      :quality            => 5,
+                      :width              => 600,
+                      :time               => 123,
+                      :postfix            => "thumb",
+                      :s                  => 640
+
+      @options.to_s.should == "-s 640"
+    end
+  end
+
+  context "#perform" do
+
+    it "converts valid data" do
+      values = { :quality => 5, :width => 600, :time => 123 }
+      @options.method(:perform).call values
+      
+      values[:q].should == values[:quality]
+      values[:s].should == values[:width]
+      values[:t].should == values[:t]
+    end
+  end
+
+  context "#parse!" do
+
+    # set predefined data
+    VTools::CONFIG[:thumb_set][:w600] = [600, 8, 5, 0]
+
+    let :conf_hash do
+      { :s => 600, :q => 8, :thumb_count => 5, :thumb_start_point => 0 }
+    end
+
+    def make_stubs
+      @options.stub(:perform).and_return{ |hsh| hsh }
+    end
+
+    it "raises error on invlaid data" do
+      expect { @options.method(:parse!).call "123" }.to raise_error VTools::ConfigError
+      expect { @options.method(:parse!).call [] }.to raise_error VTools::ConfigError
+    end
+
+    it "accepts hash" do
+      make_stubs
+
+      @options.method(:parse!).call(:s => 600).should == { :s => 600,
+        :thumb_count=>0, :thumb_start_point=>0 }
+
+      @options.delete(:s)
+      @options.method(:parse!).call( :width => 600, :thumb_count=>2,
+        :thumb_start_point=>3 ).should == { :width => 600, :thumb_count=>2,
+        :thumb_start_point=>3 }
+    end
+
+    it "accepts string (predefined set)"do
+      make_stubs
+
+      @options.method(:parse!).call("w600").should include conf_hash
+    end
+
+    it "accepts mixed data" do
+      make_stubs
+      complex = conf_hash.dup
+      complex[:s] = 1024
+
+      @options.method(:parse!).call({:set => "w600", :s => 1024}).should include complex
+    end
+  end
+
+  context "#initialize" do
+
+    it "valid calls methods" do
+      config = { :width => 1024, :t => 7 }
+
+      VTools::ThumbsOptions.any_instance.should_receive(:parse!).with(config)
+
+      options = VTools::ThumbsOptions.new config
+
+      options[:thumb_count].should == 0
+      options[:thumb_start_point].should == 0
+    end
+  end
+end

data/spec/video_spec.rb

@@ -0,0 +1,274 @@
+require "spec_helper"
+require "video"
+
+describe VTools::Video do
+
+  # hooks
+  before do
+    VTools::CONFIG[:temp_dir] = ""
+    VTools::CONFIG[:PWD] = ""
+    VTools::Converter.stub!(:new) { nil }
+    VTools::Thumbnailer.stub!(:new) { nil }
+
+    @video = VTools::Video.new __FILE__
+  end
+
+  # specs
+  context "#to_json" do
+
+    # wtf with this rspec ?!
+    it "collects valid json" do
+
+      Open3.stub!(:popen3).and_return [nil, nil, StringIO.new("")]
+      @video.get_info
+
+      ignore = [:@convert_options, :@thumbs_options, :@converter, :@thumbnailer, :@uncertain_duration]
+      collect = {:path => nil, :name => nil, :duration => nil, :start => nil, :bitrate => nil, :video_stream => nil, :audio_stream => nil}
+
+      @video.instance_variables.inject({}) do |data, var|
+        data[ var[1..-1] ] = instance_variable_get(var) unless ignore.include? var.to_sym
+        data
+      end.should include collect
+    end
+  end
+
+  context "#create_thumbs" do
+
+    it "executes thumbnailer" do
+      thumb = double(nil)
+      @video.stub(:calculated_aspect_ratio).and_return { 1.2 }
+      @video.instance_variable_set(:@thumbnailer, thumb)
+
+      setup = { :thumb => "options" }
+      VTools::ThumbsOptions.should_receive(:new).with(setup.merge(:aspect => 1.2))
+      thumb.should_receive(:run)
+
+      @video.create_thumbs setup
+    end
+  end
+
+  context "#convert" do
+
+    it "executes converter" do
+      convert = double(nil)
+      @video.instance_variable_set(:@converter, convert)
+
+      setup = { :convert => "options" }
+      VTools::ConvertOptions.should_receive(:new).with(setup)
+      convert.should_receive(:run)
+
+      @video.convert setup
+    end
+  end
+
+  context "#get_info" do
+
+    let(:path) { "#{File.realpath(File.dirname(__FILE__))}/fixtures/outputs/" }
+
+    def stub_io
+      output_stub = StringIO.new(File.read(path))
+      Open3.stub!(:popen3).and_return([ nil, nil, output_stub ] )
+      @video.get_info
+    end
+
+    context "parses data valid" do
+
+      it "iso-8859-1" do
+        path << "file_with_iso-8859-1.txt"
+        stub_io
+
+        @video.should be_valid
+
+        @video.duration.should == 1482.6
+        @video.start.should == 0.0
+        @video.bitrate.should == 546
+
+        @video.video_bitrate.should == 480
+        @video.colorspace.should == "yuv420p"
+        @video.resolution.should == "1000x600"
+        @video.frame_rate.should == 25
+
+        @video.audio_sample_rate.should == 44100
+        @video.audio_bitrate.should == 64
+        @video.audio_channels.should == 1
+        @video.audio_codec.should == "aac"
+      end
+
+      it "non supported audio" do
+        path << "file_with_non_supported_audio.txt"
+        stub_io
+
+        @video.should_not be_valid
+      end
+
+      it "no audio" do
+        path << "file_with_no_audio.txt"
+        stub_io
+
+        @video.should be_valid
+      end
+
+      it "surround audio" do
+        path << "file_with_surround_sound.txt"
+        stub_io
+
+        @video.should be_valid
+        @video.audio_channels.should == 6
+      end
+
+      it "start value" do
+        path << "file_with_start_value.txt"
+        stub_io
+
+        @video.should be_valid
+        @video.start.should == 13.038000
+      end
+    end
+  end
+
+  context "#uncertain_duration?" do
+
+    it "returns uncertain_duration statement" do
+      @video.uncertain_duration?.should be
+
+      @video.instance_variable_set(:@uncertain_duration, false)
+
+      @video.uncertain_duration?.should_not be
+    end
+  end
+
+  context "#width" do
+
+    it "returns valid width" do
+      @video.stub(:resolution) { "1024x768" }
+
+      @video.width.should == 1024
+
+      @video.stub(:resolution) { "" }
+      @video.width.should == 0
+
+      @video.stub(:resolution) { nil }
+      expect { @video.width.should be nil }.to_not raise_error
+    end
+  end
+
+  context "#height" do
+
+    it "returns valid height" do
+      @video.stub(:resolution) { "1024x768" }
+
+      @video.height.should == 768
+
+      @video.stub(:resolution) { "" }
+      @video.height.should == 0
+
+      @video.stub(:resolution) { nil }
+      expect { @video.height.should be nil }.to_not raise_error
+    end
+  end
+
+  context "#calculated_aspect_ratio" do
+
+    it "returns dar statement" do
+      @video.stub(:dar) { "16:9" }
+      @video.calculated_aspect_ratio.should == (16.0/9.0)
+    end
+
+    it "returns width / height statement" do
+      @video.stub(:width) { 1024 }
+      @video.stub(:height) { 768 }
+
+      @video.calculated_aspect_ratio.should == (4.0/3.0)
+
+      @video.stub(:height) { nil }
+      @video.stub(:width) { "qwe" }
+
+      @video.calculated_aspect_ratio.should be nil
+
+      @video.stub(:height) { "asd" }
+
+      @video.calculated_aspect_ratio.should be nil
+    end
+  end
+
+  context "#size" do
+
+    it "responds with size" do
+      File.should_receive(:size).with( @video.instance_variable_get(:@path) )
+      @video.size
+    end
+  end
+
+  context "#audio_channels" do
+
+    it "returns valid channels count" do
+
+      @video.audio_channels.should_not be
+
+      @video.instance_variable_set(:@audio_channels, "5.1")
+      @video.audio_channels.should == 6
+
+      @video.instance_variable_set(:@audio_channels, "stereo")
+      @video.audio_channels.should == 2
+
+      @video.instance_variable_set(:@audio_channels, "mono")
+      @video.audio_channels.should == 1
+
+      @video.instance_variable_set(:@audio_channels, "3 channels")
+      @video.audio_channels.should == 3
+    end
+  end
+
+  context "#frame_rate" do
+
+    it "returns valid frame rate" do
+      @video.instance_variable_set(:@video_stream, "h264, yuv420p, 720x304, PAR 1:1 DAR 45:19, 23.98 tbr, 25fps, 1k tbn, 47.95 tbc")
+      @video.frame_rate.should == 25.0
+
+      @video.instance_variable_set(:@video_stream, "h264, yuv420p, 720x304, PAR 1:1 DAR 45:19, 23.98 tbr, 1k tbn, 47.95 tbc")
+      @video.frame_rate.should_not be
+    end
+  end
+
+  context "#set_path" do
+
+    it "sets valid path" do
+      VTools::CONFIG[:temp_dir] = ""
+      VTools::CONFIG[:PWD] = "pwd/dir"
+
+      @video.method(:set_path).call("test/path/").should == "pwd/dir/test/path/"
+
+      VTools::CONFIG[:temp_dir] = "temp/dir"
+      @video.method(:set_path).call("test/path/").should == "temp/dir/test/path/"
+
+      @video.method(:set_path).call("/test/path/").should == "/test/path/"
+
+      @video.method(:set_path).call("C://test/path/").should == "C://test/path/"
+    end
+  end
+
+  context "#initialize" do
+
+    it "crates instance valid" do
+      VTools::CONFIG[:PWD] = "/root"
+      File.stub!(:exists?) { true }
+      VTools::Converter.stub!(:new) { nil }
+      VTools::Thumbnailer.stub!(:new) { nil }
+
+      video = VTools::Video.new "test/path"
+
+      video.instance_variable_get(:@invalid).should be
+      video.instance_variable_get(:@uncertain_duration).should be
+      video.instance_variable_get(:@convert_options).should == {}
+      video.instance_variable_get(:@thumbs_options).should == {}
+
+      video.instance_variable_get(:@path).should == "/root/test/path"
+      video.instance_variable_get(:@name).should == "path"
+    end
+
+    it "raises error on nonexistent file" do
+      File.stub!(:exists?) { raise "test.error" }
+      expect { VTools::Video.new "nonextitent/path" }.to raise_error
+    end
+  end
+end