vtools 0.0.1

data/spec/config_spec.rb

@@ -0,0 +1,142 @@
+require "spec_helper"
+require "config"
+
+describe VTools::CONFIG do
+  context "VTools::CONFIG" do
+
+    before :all do
+      @config = VTools::CONFIG.dup
+      @config[:video_set] = VTools::CONFIG[:video_set].dup
+      @config[:thumb_set] = VTools::CONFIG[:thumb_set].dup
+    end
+
+    before :each do
+      VTools::CONFIG.replace @config.dup
+      VTools::CONFIG[:video_set] = @config[:video_set].dup
+      VTools::CONFIG[:thumb_set] = @config[:thumb_set].dup
+    end
+
+    # specs
+    context "#load!" do
+
+      it "executes configs without merge" do
+        VTools::CONFIG[:config_file] = false
+
+        VTools.should_not_receive(:keys_to_sym)
+        VTools::CONFIG.should_not_receive(:append!)
+
+        expect { VTools::CONFIG.load! }.to_not raise_error
+      end
+
+      it "merges configs sucessfully" do
+        VTools::CONFIG[:config_file] = 'exsitent/file'
+        YAML.stub!(:load_file).and_return { {} } # stub file access method
+
+        VTools.should_receive(:keys_to_sym)
+        VTools::CONFIG.should_receive(:append!)
+
+        expect { VTools::CONFIG.load! }.to_not raise_error
+      end
+
+      it "breaks executing due to invalid yaml" do
+        VTools::CONFIG[:config_file] = 'nonexsitent/file'
+        expect { VTools::CONFIG.load! }.to raise_error VTools::ConfigError, /Invalid config data /
+      end
+    end
+
+    context "#append!" do
+
+      # common validator behavior
+      def validate_data config_hash
+
+        VTools::CONFIG.append! config_hash
+
+        # validate data
+        VTools::CONFIG.each do |name, content|
+          if config_hash.include? name
+            content.should == config_hash[name]
+          else # the rest data should remain untouched
+            content.should == @config[name]
+          end
+        end
+      end
+
+      it "merges permitted data directly" do
+        data = {
+          :ffmpeg_binary  => 'binary-ffmpeg',
+          :thumb_binary   => 'binary-ffmpeg',
+
+          :max_jobs       => 'jobs',
+          :harvester_timer=> 'timer',
+          :temp_dir       => 'temp',
+
+          :video_storage  => 'videos',
+          :thumb_storage  => 'thumbs',
+        }
+
+        validate_data data
+      end
+
+      it "merges permitted data as array" do
+        data = { :library  => ['data-lib'], }
+
+        validate_data data
+      end
+
+      it "merges permitted data as hash" do
+        data = {
+          :video_set    => {:test => [1, 2, 3]},
+          :thumb_set    => {:test => [1, 2, 3]},
+        }
+
+        VTools::CONFIG.append! data
+
+        # validate data
+        VTools::CONFIG.each do |name, content|
+          if data.include?(name)
+            content.should include(data[name])
+            content[:test].should == data[name][:test]
+          else # the rest data should remain
+            content.should == @config[name]
+          end
+        end
+      end
+
+      it "skips denied data" do
+        invalid_data = {
+          :video_set   => {:test => 3},
+          :thumb_set   => :test,
+          :library  => 'data-lib',
+        }
+
+        # save original values
+        VTools::CONFIG.append! invalid_data
+
+        # invalid data should not be placed & the rest data should remain the same
+        VTools::CONFIG.each { |key| VTools::CONFIG[key].should == @config[key] }
+      end
+
+      it "merges permitted & skips denied data (complex)" do
+
+        mixed_data = {
+          :video_set   => {
+            :invalid  => 3,
+            :valid    => [1,2,3],
+          },
+          :thumb_set => {
+            :valid    => [1,2,3],
+          },
+          :library  => 'invalid',
+        }
+        VTools::CONFIG.append! mixed_data
+
+        VTools::CONFIG[:thumb_set].should include :valid
+        VTools::CONFIG[:thumb_set][:valid].should == mixed_data[:thumb_set][:valid]
+
+        VTools::CONFIG[:video_set].should_not include :valid
+        VTools::CONFIG[:video_set].should_not include :invalid
+        VTools::CONFIG[:library].should_not include 'invalid'
+      end
+    end
+  end
+end

data/spec/convert_options_spec.rb

@@ -0,0 +1,284 @@
+require "spec_helper"
+require "convert_options"
+
+describe VTools::ConvertOptions do
+
+  # hooks
+  before :all do
+    @options_base = VTools::ConvertOptions.new({})
+  end
+
+  before :each do
+    @options = @options_base.dup
+  end
+
+  # specs
+  context "#[]=" do
+
+    it "places width & height" do
+      # place initial value
+      @options.merge!({:s => "720x360"})
+
+      # set new values
+      @options[:width] = 1024
+      @options[:height] = 768
+
+      @options[:width].should == 1024
+      @options[:height].should == 768
+      @options[:s].should be nil
+      @options[:resolution].should be nil
+    end
+
+    it "places s" do
+      @options[:s]                  = "720x360"
+
+      @options[:s].should           == "720x360"
+      @options[:resolution].should  == "720x360"
+      @options[:width].should       be 720
+      @options[:height].should      be 360
+    end
+
+    it "places resolution" do
+      # place initial value
+      @options.merge!({:s => "720x360"})
+
+      # set new values
+      @options[:resolution] = "1024x768"
+
+      @options[:s].should == "1024x768"
+      @options[:resolution].should == "1024x768"
+    end
+
+    it "places duration" do
+      # forward
+      @options[:t] = 25
+      @options[:t].should == 25
+      @options[:duration].should == 25
+
+      # reverse
+      @options[:duration] = 45
+      @options[:t].should == 45
+      @options[:duration].should == 45
+    end
+
+    it "places other" do
+      @options[:a] = 123
+      @options[:a].should == 123
+    end
+  end
+
+
+  context "#to_s" do
+
+    # skps ignored values
+    it "reates valid string representation" do
+
+      # still empty
+      @options.to_s.should == ""
+
+      # skips disallowed keywords
+      @options.merge!({
+        :width              => 1024,
+        :height             => 768,
+        :resolution         => "600x400",
+        :extension          => '.flv',
+        :preserve_aspect    => false,
+        :duration           => 123,
+        :postfix            => "video",
+        :s                  => "640x480",
+      })
+      @options.to_s.should == "-s 640x480"
+
+      # validate with aspect
+      @options[:aspect] = 1.2
+      @options.to_s.should == "-s 640x480 -aspect 1.2"
+    end
+  end
+
+  context "#perform" do
+
+    it "receives recalculate" do
+      @options.should_receive(:recalculate).once.and_return{ |str| str.split("x").map(&:to_i) }
+
+      values = {
+        :duration => 123,
+        :resolution => "600x360",
+        :preserve_aspect => true,
+      }
+
+      @options.method(:perform).call values
+
+      values.delete(:preserve_aspect)
+      @options.method(:perform).call values
+    end
+
+    it "converts data valid" do
+      @options.should_not_receive(:recalculate)
+
+      values = {
+        :duration => 123,
+        :resolution => "640x480",
+        :width => 600,
+        :height => 400,
+        :aspect => 1.3,
+      }
+
+      # major priority
+      @options.method(:perform).call values
+      values[:t].should == 123
+      values[:s].should == "640x480"
+
+      # middle priority
+      values.delete(:resolution)
+      @options.method(:perform).call values
+      values[:s].should == "600x400"
+
+      # minor priority
+      values[:s] = "1024x768"
+      values.delete(:preserve_aspect)
+      values.delete(:width)
+      values.delete(:height)
+      @options.method(:perform).call values
+      values[:s].should == "1024x768"
+    end
+
+    it "deletes invalid dimmensions definition" do
+      @options.should_not_receive(:recalculate)
+
+      values = { :width => 600 }
+      @options[:s] = "600x400"
+      @options.method(:perform).call values
+      values[:s].should be nil
+
+      values = { :height => 600 }
+      @options[:s] = "600x400"
+      @options.method(:perform).call values
+      values[:s].should be nil
+    end
+  end  
+
+  context "#parse!" do
+
+    # set predefined data
+    VTools::CONFIG[:video_set][:x264_180p] = [
+      'libx264', 'libfaac', '240x180', '96k', '64k',
+      22050, 2, 'mp4', '_180', 'normal'
+    ]
+
+    let :conf_hash do
+      { :s => "240x180", :vcodec => "libx264", :acodec => "libfaac",
+        :vb => "96k", :ab => "64k", :ar => 22050, :ac => 2,
+        :extension => "mp4", :postfix => "_180", :vpre => "normal" }
+    end
+
+    def make_stubs
+      @options.stub(:keys_to_sym).and_return{ |hsh| hsh }
+      @options.stub(:perform).and_return{ |hsh| hsh }
+    end
+
+    it "parses custom hash" do
+      make_stubs
+
+      @options.method(:parse!).call({:s => "640x480"}).should == {:s => "640x480"}
+      @options.delete(:s)
+      @options.method(:parse!).call({:width => 640, :height => 480}).should == {:width => 640, :height => 480}
+    end
+
+    it "parses predefined set" do
+      make_stubs
+
+      @options.method(:parse!).call("x264_180p").should include conf_hash
+    end
+
+    it "parses complex set" do
+      make_stubs
+
+      complex = conf_hash.dup
+      complex[:s] = "1024x768"
+
+      @options.method(:parse!).call({:set => "x264_180p", :s => "1024x768"}).should include complex
+    end
+
+    it "raises error" do
+      make_stubs
+
+      expect {@options.method(:parse!).call(123) }.to raise_error VTools::ConfigError
+      expect {@options.method(:parse!).call("nonexistent") }.to raise_error VTools::ConfigError
+    end
+  end  
+
+  context "#recalculate" do
+
+    it "no rescale" do
+      @options[:aspect] = nil
+      width, height = @options.method(:recalculate).call "1024x768"
+      width.should == 1024
+      height.should == 768
+    end
+
+    it "rescale by aspect > 1 (wide video)" do
+      @options[:aspect] = 6.to_f / 5.to_f # original video aspect is 6:5
+      { # set max expected video dimm => rescale
+        "1024x768" => [922, 768], # we create 4:3
+        "1024x576" => [692, 576], # we create 16:9
+      }.each do |accept, result|
+        width, height = @options.method(:recalculate).call accept
+        width.should == result[0]
+        height.should == result[1]
+      end
+
+      @options[:aspect] = 17.to_f / 8.to_f # original video aspect is 17:8
+      { # set max expected video dimm => rescale_result
+        "1024x768"  => [1024, 482], # we create 4:3
+        "600x436"   => [600, 282], # we create 11:8
+      }.each do |accept, result|
+        width, height = @options.method(:recalculate).call accept
+        width.should == result[0]
+        height.should == result[1]
+      end
+    end
+
+    it "rescale by aspect < 1 (tall video)" do
+      @options[:aspect] = 5.to_f / 6.to_f # original video aspect is 5:6
+      { # set max expected video dimm => rescale
+        "1024x768" => [640, 768], # we create 4:3
+        "1024x576" => [480, 576], # we create 16:9
+      }.each do |accept, result|
+        width, height = @options.method(:recalculate).call accept
+        width.should == result[0]
+        height.should == result[1]
+      end
+
+      @options[:aspect] = 8.to_f / 17.to_f # original video aspect is 8:17
+      { # set max expected video dimm => rescale_result
+        "1024x768"  => [362, 768], # we create 4:3
+        "600x436"   => [206, 436], # we create 11:8
+      }.each do |accept, result|
+        width, height = @options.method(:recalculate).call accept
+        width.should == result[0]
+        height.should == result[1]
+      end
+    end
+
+    it "rescale by aspect = 1 (square video)" do
+      @options[:aspect] = 1.to_f / 1.to_f # original video aspect is 1:1
+      { # set max expected video dimm => rescale
+        "1024x768" => [768, 768], # we create 4:3
+        "1024x576" => [576, 576], # we create 16:9
+      }.each do |accept, result|
+        width, height = @options.method(:recalculate).call accept
+        width.should == result[0]
+        height.should == result[1]
+      end
+    end
+  end  
+
+  context "#initialize" do
+    it "valid calls methods" do
+      config = { :width => 1024, :height => 768 }
+
+      VTools::ConvertOptions.any_instance.should_receive(:parse!).with(config)
+      options = VTools::ConvertOptions.new config
+    end
+  end
+end

data/spec/converter_spec.rb

@@ -0,0 +1,167 @@
+require "spec_helper"
+require "converter"
+
+describe VTools::Converter do
+
+  # hooks
+  before do
+    @converter = VTools::Converter.new nil
+  end
+
+  let(:video) { double nil }
+
+  # specs
+  context "#run" do
+
+    let(:output_array)  { [] }
+    let(:ffmpeg_7) { {10.02 => "time=10.02", 15.34 => "time=15.34", 20.45 => "time=20.45"} }
+    let(:ffmpeg_8) { {10.02 => "time=00:00:10.02", 15.34 => "time=00:00:15.34", 20.45 => "time=00:00:20.45", 61.05 => "time=00:01:01.05"} }
+    let(:ffmpeg_no_time) { {0.0 => "broken pipe"} }
+
+    # hooks
+    before do
+      @output_file = nil
+      @options = {}
+    end
+
+
+    def prepare_converter values_set
+      # prepare output lines
+      output_array.push *values_set.values
+      # output iterator
+      (io = double(nil)).stub!(:each) { |*args, blk| output_array.each { |line| blk.yield(line) } }
+      Open3.stub!(:popen3).and_return{ |*args, block| block.yield(nil, nil, io) }
+
+      @options.should_receive(:to_s).and_return { "test.options" }
+
+      video.stub(:convert_options){ @options }
+      video.stub(:name) {"video/name"}
+      video.stub(:path) {"video/path"}
+      video.stub(:duration) { values_set.keys.last }
+
+      @converter.instance_variable_set(:@video, video)
+
+      VTools::CONFIG[:ffmpeg_binary] = "tested.ffmpeg"
+      @output_file = "/#{video.name}#{@options[:postfix]}.#{@options[:extension]}"
+      # "#{CONFIG[:ffmpeg_binary]} -y -i '#{@video.path}' #{@options} '#{@output_file}'"
+      exec_com = "tested.ffmpeg -y -i 'video/path' test.options '#{@output_file}'"
+
+      VTools::Handler.should_receive(:exec).with(:before_convert, video, exec_com)
+      VTools.should_receive(:fix_encoding).exactly(values_set.size).times
+      @converter.should_receive(:generate_path)
+    end
+
+    it "converts video for ffmpeg 0.7" do
+      prepare_converter ffmpeg_7
+
+      ffmpeg_7.each do |sec, time_str|
+        VTools::Handler.should_receive(:exec).with(:in_convert, video, sec/ffmpeg_7.keys.last)
+      end
+
+      VTools::Handler.should_receive(:exec).with(:convert_success, video, @output_file)
+      @converter.should_receive(:encoding_invalid?) { false }
+      @converter.should_receive(:encoded)
+
+      @converter.run
+    end
+
+    it "converts video for ffmpeg 0.8" do
+      prepare_converter ffmpeg_8
+
+      ffmpeg_8.each do |sec, time_str|
+        VTools::Handler.should_receive(:exec).with(:in_convert, video, sec/ffmpeg_8.keys.last)
+      end
+
+      VTools::Handler.should_receive(:exec).with(:convert_success, video, @output_file)
+      @converter.should_receive(:encoding_invalid?) { false }
+      @converter.should_receive(:encoded)
+
+      @converter.run
+    end
+    
+    context "fails encoding" do
+
+      it "--no time received" do
+        prepare_converter ffmpeg_no_time
+        expect { @converter.run }.to raise_error VTools::ProcessError, "broken pipe"
+      end
+
+      it "--result file is invalid" do
+        VTools::Handler.stub(:exec).and_return nil
+        prepare_converter ffmpeg_7
+        @converter.should_receive(:encoding_invalid?) { "test.fail" }
+        expect { @converter.run }.to raise_error VTools::ProcessError, "test.fail"
+      end
+    end
+  end
+
+  context "#encoding_invalid?" do
+
+    before do
+      VTools::CONFIG[:validate_duration] = nil
+    end
+
+    def prepare_converter
+      File.stub!(:exists?).and_return { true }
+      video.stub(:duration) { 200.2 } # set duration in sec
+      @converter.stub_chain(:encoded, :valid?).and_return { true }
+      @converter.instance_variable_set(:@video, video)
+    end
+
+    context "encoding is valid" do
+
+      it "no manual duration set" do
+        prepare_converter
+        @converter.instance_variable_set(:@options, {}) # no manual duration set
+        @converter.stub_chain(:encoded, :duration).and_return { 200.2 }
+        VTools::CONFIG[:validate_duration] = true
+
+        @converter.encoding_invalid?.should == false
+      end
+
+      it "duration set manually" do
+        prepare_converter
+        @converter.instance_variable_set(:@options, { :duration => 115.3 }) # manual duration set
+        @converter.stub_chain(:encoded, :duration).and_return { 115.3 }
+        VTools::CONFIG[:validate_duration] = true
+
+        @converter.encoding_invalid?.should == false
+      end
+
+      it "without duration test" do
+        prepare_converter
+        @converter.encoding_invalid?.should == false
+      end
+    end
+
+    context  "encoding is invalid" do
+
+      it "no encoded file" do
+        File.stub!(:exists?).and_return { false }
+        @converter.encoding_invalid?.should == "No output file created"
+      end
+
+      it "encoded media is invalid video instance" do
+        File.stub!(:exists?).and_return { true }
+        @converter.stub_chain(:encoded, :valid?).and_return { false }
+        @converter.encoding_invalid?.should == "Encoded file is invalid"
+      end
+
+      it "invalid duration auto" do
+        prepare_converter
+        VTools::CONFIG[:validate_duration] = true
+        @converter.instance_variable_set(:@options, { :duration => 115.3 }) # no manual duration set
+        @converter.stub_chain(:encoded, :duration).and_return { 220.2 } # original 220
+        @converter.encoding_invalid?.should =~ /Encoded file duration is invalid \(original\/specified:/
+      end
+
+      it "invalid duration manual" do
+        prepare_converter
+        VTools::CONFIG[:validate_duration] = true
+        @converter.instance_variable_set(:@options, {}) # no manual duration set
+        @converter.stub_chain(:encoded, :duration).and_return { 320.2 } # original 220
+        @converter.encoding_invalid?.should =~ /Encoded file duration is invalid \(original\/specified:/
+      end
+    end
+  end
+end