headless 2.3.1 → 3.0.0

data/lib/headless.rb

@@ -1,5 +1,5 @@
-require 'headless/cli_util'
-require 'headless/video/video_recorder'
+require "headless/cli_util"
+require "headless/video/video_recorder"
 
 # A class incapsulating the creation and usage of a headless X server
 #
@@ -40,10 +40,9 @@ require 'headless/video/video_recorder'
 # TODO test that reuse actually works with an existing xvfb session
 #++
 class Headless
-
   DEFAULT_DISPLAY_NUMBER = 99
   MAX_DISPLAY_NUMBER = 10_000
-  DEFAULT_DISPLAY_DIMENSIONS = '1280x1024x24'
+  DEFAULT_DISPLAY_DIMENSIONS = "1280x1024x24"
   DEFAULT_XVFB_LAUNCH_TIMEOUT = 10
 
   class Exception < RuntimeError
@@ -73,9 +72,10 @@ class Headless
   #   (default true unless reuse is true and a server is already running)
   # * +xvfb_launch_timeout+ - how long should we wait for Xvfb to open a
   #   display, before assuming that it is frozen (in seconds, default is 10)
-  # * +video+ - options to be passed to the ffmpeg video recorder. See Headless::VideoRecorder#initialize for documentation
+  # * +video+ - options to be passed to the ffmpeg video recorder.
+  #   See Headless::VideoRecorder#initialize for documentation
   def initialize(options = {})
-    CliUtil.ensure_application_exists!('Xvfb', 'Xvfb not found on your system')
+    CliUtil.ensure_application_exists!("Xvfb", "Xvfb not found on your system")
 
     @display = options.fetch(:display, DEFAULT_DISPLAY_NUMBER).to_i
     @xvfb_launch_timeout = options.fetch(:xvfb_launch_timeout, DEFAULT_XVFB_LAUNCH_TIMEOUT).to_i
@@ -83,8 +83,14 @@ class Headless
     @reuse_display = options.fetch(:reuse, true)
     @dimensions = options.fetch(:dimensions, DEFAULT_DISPLAY_DIMENSIONS)
     @video_capture_options = options.fetch(:video, {})
+    @extensions = options.fetch(:extensions, [])
+    @extensions = [@extensions] unless @extensions.is_a? Array
 
-    already_running = xvfb_running? rescue false
+    already_running = begin
+      xvfb_running?
+    rescue
+      false
+    end
     @destroy_at_exit = options.fetch(:destroy_at_exit, !(@reuse_display && already_running))
 
     @pid = nil # the pid of the running Xvfb process
@@ -95,14 +101,14 @@ class Headless
 
   # Switches to the headless server
   def start
-    @old_display = ENV['DISPLAY']
-    ENV['DISPLAY'] = ":#{display}"
+    @old_display = ENV["DISPLAY"]
+    ENV["DISPLAY"] = ":#{display}"
     hook_at_exit
   end
 
   # Switches back from the headless server
   def stop
-    ENV['DISPLAY'] = @old_display
+    ENV["DISPLAY"] = @old_display
   end
 
   # Switches back from the headless server and terminates the headless session
@@ -137,37 +143,42 @@ class Headless
   #     # perform operations in headless mode
   #   end
   # See #new for options
-  def self.run(options={}, &block)
+  def self.run(options = {}, &block)
     headless = Headless.new(options)
     headless.start
     yield headless
   ensure
-    headless && headless.destroy
+    headless&.destroy
   end
-  class <<self; alias_method :ly, :run; end
+  class << self; alias_method :ly, :run; end
 
   def video
     @video_recorder ||= VideoRecorder.new(display, dimensions, @video_capture_options)
   end
 
-  def take_screenshot(file_path, options={})
+  def take_screenshot(file_path, options = {})
     using = options.fetch(:using, :imagemagick)
     case using
     when :imagemagick
-      CliUtil.ensure_application_exists!('import', "imagemagick is not found on your system. Please install it using sudo apt-get install imagemagick")
-      system "#{CliUtil.path_to('import')} -display localhost:#{display} -window root #{file_path}"
+      CliUtil.ensure_application_exists!("import",
+        "imagemagick is not found on your system. " \
+        "Please install it using sudo apt-get install imagemagick")
+      system "#{CliUtil.path_to("import")} -display :#{display} -window root #{file_path}"
     when :xwd
-      CliUtil.ensure_application_exists!('xwd', "xwd is not found on your system. Please install it using sudo apt-get install X11-apps")
-      system "#{CliUtil.path_to('xwd')} -display localhost:#{display} -silent -root -out #{file_path}"
+      CliUtil.ensure_application_exists!("xwd",
+        "xwd is not found on your system. " \
+        "Please install it using sudo apt-get install X11-apps")
+      system "#{CliUtil.path_to("xwd")} -display localhost:#{display} -silent -root -out #{file_path}"
     when :graphicsmagick, :gm
-      CliUtil.ensure_application_exists!('gm', "graphicsmagick is not found on your system. Please install it.")
-      system "#{CliUtil.path_to('gm')} import -display localhost:#{display} -window root #{file_path}"
+      CliUtil.ensure_application_exists!("gm", "graphicsmagick is not found on your system. " \
+      "Please install it.")
+      system "#{CliUtil.path_to("gm")} import -display localhost:#{display} -window root #{file_path}"
     else
-      raise Headless::Exception.new('Unknown :using option value')
+      raise Headless::Exception.new("Unknown :using option value")
     end
   end
 
-private
+  private
 
   def attach_xvfb
     possible_display_set = @autopick_display ? @display..MAX_DISPLAY_NUMBER : Array(@display)
@@ -187,26 +198,30 @@ private
   def launch_xvfb
     out_pipe, in_pipe = IO.pipe
     @pid = Process.spawn(
-      CliUtil.path_to("Xvfb"), ":#{display}", "-screen", "0", dimensions, "-ac",
-      err: in_pipe)
+      CliUtil.path_to("Xvfb"), ":#{display}", "-screen", "0", dimensions, "-ac", *extensions,
+      err: in_pipe
+    )
     raise Headless::Exception.new("Xvfb did not launch - something's wrong") unless @pid
+
     # According to docs, you should either wait or detach on spawned procs:
     Process.detach @pid
-    return ensure_xvfb_launched(out_pipe)
-    ensure
-      in_pipe.close
+    ensure_xvfb_launched(out_pipe)
+  ensure
+    in_pipe.close
   end
 
   def ensure_xvfb_launched(out_pipe)
     start_time = Time.now
     errors = ""
-    begin
+    loop do
       begin
         errors += out_pipe.read_nonblock(10000)
-        if errors.include? "Cannot establish any listening sockets"
-          raise Headless::Exception.new("Display socket is taken but lock file is missing - check the Headless troubleshooting guide")
-        end
-        if errors.include? "Server is already active for display #{display}"
+        if errors.include? "directory /tmp/.X11-unix will not be created."
+          raise Headless::Exception, "/tmp/.X11-unix is missing - check the Headless troubleshooting guide"
+        elsif errors.include? "Cannot establish any listening sockets"
+          raise Headless::Exception,
+            "Display socket is taken but lock file is missing - check the Headless troubleshooting guide"
+        elsif errors.include? "Server is already active for display #{display}"
           # This can happen if there is a race to grab the lock file.
           # Not an exception, just return false to let pick_available_display choose another:
           return false
@@ -215,13 +230,16 @@ private
         # will retry next cycle
       end
       sleep 0.01 # to avoid cpu hogging
-      raise Headless::Exception.new("Xvfb launched but did not complete initialization") if (Time.now-start_time)>=@xvfb_launch_timeout
-    # Continue looping until Xvfb has written its pidfile:
-    end while !xvfb_running?
+      if (Time.now - start_time) >= @xvfb_launch_timeout
+        raise Headless::Exception.new("Xvfb launched but did not complete initialization")
+      end
+      # Continue looping until Xvfb has written its pidfile:
+      break if xvfb_running?
+    end
 
     # If for any reason the pid file doesn't match ours, we lost the race to
     # get the file lock:
-    return @pid == read_xvfb_pid
+    @pid == read_xvfb_pid
   end
 
   def xvfb_mine?
@@ -252,4 +270,8 @@ private
       end
     end
   end
+
+  def extensions
+    @extensions.map { |ext| "+" + ext.to_s }
+  end
 end

data/spec/headless_spec.rb

@@ -1,28 +1,44 @@
-require 'headless'
+require "headless"
 
 describe Headless do
   before do
-    ENV['DISPLAY'] = ":31337"
+    ENV["DISPLAY"] = ":31337"
     stub_environment
   end
 
-  describe 'launch options' do
+  describe "launch options" do
     before do
       allow_any_instance_of(Headless).to receive(:ensure_xvfb_launched).and_return(true)
     end
 
     it "starts Xvfb" do
-      expect(Process).to receive(:spawn).with(*(%w(/usr/bin/Xvfb :99 -screen 0 1280x1024x24 -ac)+[hash_including(:err)])).and_return(123)
-      headless = Headless.new
+      expect(Process).to receive(:spawn).with(*(%w[/usr/bin/Xvfb :99 -screen 0 1280x1024x24
+        -ac] + [hash_including(:err)])).and_return(123)
+      Headless.new
     end
 
     it "allows setting screen dimensions" do
-      expect(Process).to receive(:spawn).with(*(%w(/usr/bin/Xvfb :99 -screen 0 1024x768x16 -ac)+[hash_including(:err)])).and_return(123)
-      headless = Headless.new(:dimensions => "1024x768x16")
+      expect(Process).to receive(:spawn).with(*(%w[/usr/bin/Xvfb :99 -screen 0 1024x768x16
+        -ac] + [hash_including(:err)])).and_return(123)
+      Headless.new(dimensions: "1024x768x16")
+    end
+
+    it "allows to enable extensions", focus: true do
+      expect(Process).to receive(:spawn).with(*(%w[/usr/bin/Xvfb :99 -screen 0 1280x1024x24 -ac
+        +iglx] + [hash_including(:err)])).and_return(123)
+      Headless.new(extensions: [:iglx])
+
+      expect(Process).to receive(:spawn).with(*(%w[/usr/bin/Xvfb :99 -screen 0 1280x1024x24 -ac
+        +iglx] + [hash_including(:err)])).and_return(123)
+      Headless.new(extensions: "iglx")
+
+      expect(Process).to receive(:spawn).with(*(%w[/usr/bin/Xvfb :99 -screen 0 1280x1024x24 -ac +iglx
+        +dummy] + [hash_including(:err)])).and_return(123)
+      Headless.new(extensions: ["iglx", :dummy])
     end
   end
 
-  context 'with stubbed launch_xvfb' do
+  context "with stubbed launch_xvfb" do
     before do
       allow_any_instance_of(Headless).to receive(:launch_xvfb).and_return(true)
     end
@@ -40,15 +56,15 @@ describe Headless do
 
       context "when Xvfb is already running and was started by this user" do
         before do
-          allow(Headless::CliUtil).to receive(:read_pid).with('/tmp/.X99-lock').and_return(31337)
+          allow(Headless::CliUtil).to receive(:read_pid).with("/tmp/.X99-lock").and_return(31337)
           allow(Headless::CliUtil).to receive(:process_running?).with(31337).and_return(true)
           allow(Headless::CliUtil).to receive(:process_mine?).with(31337).and_return(true)
 
-          allow(Headless::CliUtil).to receive(:read_pid).with('/tmp/.X100-lock').and_return(nil)
+          allow(Headless::CliUtil).to receive(:read_pid).with("/tmp/.X100-lock").and_return(nil)
         end
 
         context "and display reuse is allowed" do
-          let(:options) { {:reuse => true} }
+          let(:options) { {reuse: true} }
 
           it "should reuse the existing Xvfb" do
             expect(Headless.new(options).display).to eq 99
@@ -60,21 +76,21 @@ describe Headless do
         end
 
         context "and display reuse is not allowed" do
-          let(:options) { {:reuse => false} }
+          let(:options) { {reuse: false} }
 
           it "should pick the next available display number" do
             expect(Headless.new(options).display).to eq 100
           end
 
           context "and display number is explicitly set" do
-            let(:options) { {:reuse => false, :display => 99} }
+            let(:options) { {reuse: false, display: 99} }
 
             it "should fail with an exception" do
               expect { Headless.new(options) }.to raise_error(Headless::Exception)
             end
 
             context "and autopicking is allowed" do
-              let(:options) { {:reuse => false, :display => 99, :autopick => true} }
+              let(:options) { {reuse: false, display: 99, autopick: true} }
 
               it "should pick the next available display number" do
                 expect(Headless.new(options).display).to eq 100
@@ -84,17 +100,17 @@ describe Headless do
         end
       end
 
-      context 'when Xvfb is started, but by another user' do
+      context "when Xvfb is started, but by another user" do
         before do
-          allow(Headless::CliUtil).to receive(:read_pid).with('/tmp/.X99-lock').and_return(31337)
+          allow(Headless::CliUtil).to receive(:read_pid).with("/tmp/.X99-lock").and_return(31337)
           allow(Headless::CliUtil).to receive(:process_running?).with(31337).and_return(true)
           allow(Headless::CliUtil).to receive(:process_mine?).with(31337).and_return(false)
 
-          allow(Headless::CliUtil).to receive(:read_pid).with('/tmp/.X100-lock').and_return(nil)
+          allow(Headless::CliUtil).to receive(:read_pid).with("/tmp/.X100-lock").and_return(nil)
         end
 
         context "and display autopicking is not allowed" do
-          let(:options) { {:autopick => false} }
+          let(:options) { {autopick: false} }
 
           it "should reuse the display" do
             expect(Headless.new(options).display).to eq 99
@@ -102,7 +118,7 @@ describe Headless do
         end
 
         context "and display autopicking is allowed" do
-          let(:options) { {:autopick => true} }
+          let(:options) { {autopick: true} }
 
           it "should pick the next display number" do
             expect(Headless.new(options).display).to eq 100
@@ -115,19 +131,19 @@ describe Headless do
       let(:headless) { Headless.new }
       describe "#start" do
         it "switches to the headless server" do
-          expect(ENV['DISPLAY']).to eq ":31337"
+          expect(ENV["DISPLAY"]).to eq ":31337"
           headless.start
-          expect(ENV['DISPLAY']).to eq ":99"
+          expect(ENV["DISPLAY"]).to eq ":99"
         end
       end
 
       describe "#stop" do
         it "switches back from the headless server" do
-          expect(ENV['DISPLAY']).to eq ":31337"
+          expect(ENV["DISPLAY"]).to eq ":31337"
           headless.start
-          expect(ENV['DISPLAY']).to eq ":99"
+          expect(ENV["DISPLAY"]).to eq ":99"
           headless.stop
-          expect(ENV['DISPLAY']).to eq ":31337"
+          expect(ENV["DISPLAY"]).to eq ":31337"
         end
       end
 
@@ -137,13 +153,13 @@ describe Headless do
         end
 
         it "switches back from the headless server and terminates the headless session" do
-          expect(Process).to receive(:kill).with('TERM', 4444)
+          expect(Process).to receive(:kill).with("TERM", 4444)
 
-          expect(ENV['DISPLAY']).to eq ":31337"
+          expect(ENV["DISPLAY"]).to eq ":31337"
           headless.start
-          expect(ENV['DISPLAY']).to eq ":99"
+          expect(ENV["DISPLAY"]).to eq ":99"
           headless.destroy
-          expect(ENV['DISPLAY']).to eq ":31337"
+          expect(ENV["DISPLAY"]).to eq ":31337"
         end
       end
     end
@@ -165,72 +181,72 @@ describe Headless do
       let(:headless) { Headless.new }
 
       it "raises an error if unknown value for option :using is used" do
-        expect { headless.take_screenshot('a.png', :using => :teleportation) }.to raise_error(Headless::Exception)
+        expect { headless.take_screenshot("a.png", using: :teleportation) }.to raise_error(Headless::Exception)
       end
 
       it "raises an error if imagemagick is not installed, with default options" do
-        allow(Headless::CliUtil).to receive(:application_exists?).with('import').and_return(false)
+        allow(Headless::CliUtil).to receive(:application_exists?).with("import").and_return(false)
 
-        expect { headless.take_screenshot('a.png') }.to raise_error(Headless::Exception)
+        expect { headless.take_screenshot("a.png") }.to raise_error(Headless::Exception)
       end
 
       it "raises an error if imagemagick is not installed, with using: :imagemagick" do
-        allow(Headless::CliUtil).to receive(:application_exists?).with('import').and_return(false)
+        allow(Headless::CliUtil).to receive(:application_exists?).with("import").and_return(false)
 
-        expect { headless.take_screenshot('a.png', :using => :imagemagick) }.to raise_error(Headless::Exception)
+        expect { headless.take_screenshot("a.png", using: :imagemagick) }.to raise_error(Headless::Exception)
       end
 
       it "raises an error if xwd is not installed, with using: :xwd" do
-        allow(Headless::CliUtil).to receive(:application_exists?).with('xwd').and_return(false)
+        allow(Headless::CliUtil).to receive(:application_exists?).with("xwd").and_return(false)
 
-        expect { headless.take_screenshot('a.png', :using => :xwd) }.to raise_error(Headless::Exception)
+        expect { headless.take_screenshot("a.png", using: :xwd) }.to raise_error(Headless::Exception)
       end
 
       it "raises an error if gm is not installed with using: :graphicsmagick" do
-        allow(Headless::CliUtil).to receive(:application_exists?).with('gm').and_return(false)
+        allow(Headless::CliUtil).to receive(:application_exists?).with("gm").and_return(false)
 
-        expect { headless.take_screenshot('a.png', :using => :graphicsmagick) }.to raise_error(Headless::Exception)
+        expect { headless.take_screenshot("a.png", using: :graphicsmagick) }.to raise_error(Headless::Exception)
       end
 
       it "raises an error if gm is not installed with using: :gm" do
-        allow(Headless::CliUtil).to receive(:application_exists?).with('gm').and_return(false)
+        allow(Headless::CliUtil).to receive(:application_exists?).with("gm").and_return(false)
 
-        expect { headless.take_screenshot('a.png', :using => :gm) }.to raise_error(Headless::Exception)
+        expect { headless.take_screenshot("a.png", using: :gm) }.to raise_error(Headless::Exception)
       end
 
       it "issues command to take screenshot, with default options" do
-        allow(Headless::CliUtil).to receive(:path_to).with('import').and_return('path/import')
-        expect(headless).to receive(:system).with("path/import -display localhost:99 -window root /tmp/image.png")
+        allow(Headless::CliUtil).to receive(:path_to).with("import").and_return("path/import")
+        expect(headless).to receive(:system).with("path/import -display :99 -window root /tmp/image.png")
         headless.take_screenshot("/tmp/image.png")
       end
 
       it "issues command to take screenshot, with using: :imagemagick" do
-        allow(Headless::CliUtil).to receive(:path_to).with('import').and_return('path/import')
-        expect(headless).to receive(:system).with("path/import -display localhost:99 -window root /tmp/image.png")
-        headless.take_screenshot("/tmp/image.png", :using => :imagemagick)
+        allow(Headless::CliUtil).to receive(:path_to).with("import").and_return("path/import")
+        expect(headless).to receive(:system).with("path/import -display :99 -window root /tmp/image.png")
+        headless.take_screenshot("/tmp/image.png", using: :imagemagick)
       end
 
       it "issues command to take screenshot, with using: :xwd" do
-        allow(Headless::CliUtil).to receive(:path_to).with('xwd').and_return('path/xwd')
+        allow(Headless::CliUtil).to receive(:path_to).with("xwd").and_return("path/xwd")
         expect(headless).to receive(:system).with("path/xwd -display localhost:99 -silent -root -out /tmp/image.png")
-        headless.take_screenshot("/tmp/image.png", :using => :xwd)
+        headless.take_screenshot("/tmp/image.png", using: :xwd)
       end
 
       it "issues command to take screenshot, with using: :graphicsmagick" do
-        allow(Headless::CliUtil).to receive(:path_to).with('gm').and_return('path/gm')
+        allow(Headless::CliUtil).to receive(:path_to).with("gm").and_return("path/gm")
         expect(headless).to receive(:system).with("path/gm import -display localhost:99 -window root /tmp/image.png")
-        headless.take_screenshot("/tmp/image.png", :using => :graphicsmagick)
+        headless.take_screenshot("/tmp/image.png", using: :graphicsmagick)
       end
 
       it "issues command to take screenshot, with using: :gm" do
-        allow(Headless::CliUtil).to receive(:path_to).with('gm').and_return('path/gm')
+        allow(Headless::CliUtil).to receive(:path_to).with("gm").and_return("path/gm")
         expect(headless).to receive(:system).with("path/gm import -display localhost:99 -window root /tmp/image.png")
-        headless.take_screenshot("/tmp/image.png", :using => :gm)
+        headless.take_screenshot("/tmp/image.png", using: :gm)
       end
     end
   end
 
-private
+  private
 
   def stub_environment
     allow(Headless::CliUtil).to receive(:application_exists?).and_return(true)

data/spec/integration_spec.rb

@@ -1,29 +1,29 @@
-require 'headless'
-require 'selenium-webdriver'
+require "headless"
+require "selenium-webdriver"
 
-describe 'Integration test' do
+describe "Integration test" do
   let!(:headless) { Headless.new }
   before { headless.start }
 
   after { headless.destroy_sync }
 
-  it 'should use xvfb' do
+  it "should use xvfb" do
     work_with_browser
   end
 
-  it 'should record screenshots' do
+  it "should record screenshots" do
     headless.take_screenshot("test.jpg")
     expect(File.exist?("test.jpg")).to eq true
   end
 
-  it 'should record video with ffmpeg' do
+  it "should record video with ffmpeg" do
     headless.video.start_capture
     work_with_browser
     headless.video.stop_and_save("test.mov")
     expect(File.exist?("test.mov")).to eq true
   end
 
-  it 'should raise an error when trying to create the same display' do
+  it "should raise an error when trying to create the same display" do
     expect {
       FileUtils.mv("/tmp/.X#{headless.display}-lock", "/tmp/headless-test-tmp")
       Headless.new(display: headless.display, reuse: false)
@@ -35,7 +35,7 @@ describe 'Integration test' do
 
   def work_with_browser
     driver = Selenium::WebDriver.for :firefox
-    driver.navigate.to 'http://google.com'
+    driver.navigate.to "http://google.com"
     expect(driver.title).to match(/Google/)
     driver.close
   end

data/spec/video_recorder_spec.rb

@@ -1,6 +1,6 @@
-require 'headless'
+require "headless"
 
-require 'tempfile'
+require "tempfile"
 
 describe Headless::VideoRecorder do
   before do
@@ -8,89 +8,79 @@ describe Headless::VideoRecorder do
   end
 
   describe "instantiation" do
-
-    it "throws an error if provider_binary_path is not installed" do
+    it "throws an error if ffmpeg_path is not installed" do
       allow(Headless::CliUtil).to receive(:application_exists?).and_return(false)
       expect { Headless::VideoRecorder.new(99, "1024x768x32") }.to raise_error(Headless::Exception)
     end
 
-    it "allows provider_binary_path to be specified" do
-      Tempfile.open('some_provider') do |f|
-        v = Headless::VideoRecorder.new(99, "1024x768x32", provider: :ffmpeg, provider_binary_path: f.path)
-        expect(v.provider_binary_path).to eq(f.path)
+    it "allows ffmpeg_path to be specified" do
+      Tempfile.open("ffmpeg") do |f|
+        v = Headless::VideoRecorder.new(99, "1024x768x32", ffmpeg_path: f.path)
+        expect(v.ffmpeg_path).to eq(f.path)
       end
     end
 
-    it "allows provider_binary_path to be specified" do
-      Tempfile.open('some_provider') do |f|
-        v = Headless::VideoRecorder.new(99, "1024x768x32", provider: :ffmpeg, provider_binary_path: f.path)
-        expect(v.provider_binary_path).to eq(f.path)
+    it "supports provider_binary_path for backward compatibility" do
+      Tempfile.open("ffmpeg") do |f|
+        v = Headless::VideoRecorder.new(99, "1024x768x32", provider_binary_path: f.path)
+        expect(v.ffmpeg_path).to eq(f.path)
       end
     end
-
-    context "provider_binary_path not specified" do
-      it "assumes the provider binary is 'ffmpeg' if the provider is :ffmpeg" do
-        v = Headless::VideoRecorder.new(99, "1024x768x32", provider: :ffmpeg)
-        expect(v.provider_binary_path).to eq("ffmpeg")
-      end
-
-      it "assumes the provider binary is 'avconv' if the provider is :libav" do
-        v = Headless::VideoRecorder.new(99, "1024x768x32", provider: :libav)
-        expect(v.provider_binary_path).to eq("avconv")
-      end
-
-    end
   end
 
   describe "#capture" do
     before do
-      allow(Headless::CliUtil).to receive(:path_to).and_return('ffmpeg')
+      allow(Headless::CliUtil).to receive(:path_to).and_return("ffmpeg")
     end
 
     it "starts ffmpeg" do
-      expect(Headless::CliUtil).to receive(:fork_process).with(/^ffmpeg -y -r 30 -s 1024x768 -f x11grab -i :99 -g 600 -vcodec qtrle [^ ]+$/, "/tmp/.headless_ffmpeg_99.pid", '/dev/null')
+      expect(Headless::CliUtil).to receive(:fork_process).with(
+        /^ffmpeg -y -r 30 -s 1024x768 -f x11grab -i :99 -vcodec qtrle [^ ]+$/,
+        "/tmp/.headless_ffmpeg_99.pid",
+        File::NULL
+      )
 
       recorder = Headless::VideoRecorder.new(99, "1024x768x32")
       recorder.start_capture
     end
 
     it "starts ffmpeg with specified codec" do
-      expect(Headless::CliUtil).to receive(:fork_process).with(/^ffmpeg -y -r 30 -s 1024x768 -f x11grab -i :99 -g 600 -vcodec libvpx [^ ]+$/, "/tmp/.headless_ffmpeg_99.pid", '/dev/null')
-
-      recorder = Headless::VideoRecorder.new(99, "1024x768x32", {:codec => 'libvpx'})
-      recorder.start_capture
-    end
-
-    it "starts ffmpeg from ffmpeg provider with correct parameters" do
-      expect(Headless::CliUtil).to receive(:fork_process).with(/^ffmpeg -y -r 30 -s 1024x768 -f x11grab -i :99 -vcodec qtrle [^ ]+$/, "/tmp/.headless_ffmpeg_99.pid", '/dev/null')
+      expect(Headless::CliUtil).to receive(:fork_process).with(
+        /^ffmpeg -y -r 30 -s 1024x768 -f x11grab -i :99 -vcodec libvpx [^ ]+$/,
+        "/tmp/.headless_ffmpeg_99.pid",
+        File::NULL
+      )
 
-      recorder = Headless::VideoRecorder.new(99, "1024x768x32", {:provider => :ffmpeg})
+      recorder = Headless::VideoRecorder.new(99, "1024x768x32", {codec: "libvpx"})
       recorder.start_capture
     end
 
     it "starts ffmpeg with specified extra device options" do
-      expect(Headless::CliUtil).to receive(:fork_process).with(/^ffmpeg -y -r 30 -s 1024x768 -f x11grab -draw_mouse 0 -i :99 -g 600 -vcodec qtrle [^ ]+$/, "/tmp/.headless_ffmpeg_99.pid", '/dev/null')
+      expect(Headless::CliUtil).to receive(:fork_process).with(
+        /^ffmpeg -y -r 30 -s 1024x768 -f x11grab -i :99 -draw_mouse 0 -vcodec qtrle [^ ]+$/,
+        "/tmp/.headless_ffmpeg_99.pid", File::NULL
+      )
 
-      recorder = Headless::VideoRecorder.new(99, "1024x768x32", {:devices => ["-draw_mouse 0"]})
+      recorder = Headless::VideoRecorder.new(99, "1024x768x32", {devices: ["-draw_mouse 0"]})
       recorder.start_capture
     end
   end
 
   context "stopping video recording" do
-    let(:tmpfile) { '/tmp/ci.mov' }
-    let(:filename) { '/tmp/test.mov' }
-    let(:pidfile) { '/tmp/pid' }
+    let(:tmpfile) { "/tmp/ci.mov" }
+    let(:filename) { "/tmp/test.mov" }
+    let(:pidfile) { "/tmp/pid" }
 
     subject do
-      recorder = Headless::VideoRecorder.new(99, "1024x768x32", :pid_file_path => pidfile, :tmp_file_path => tmpfile)
+      recorder = Headless::VideoRecorder.new(99, "1024x768x32", pid_file_path: pidfile, tmp_file_path: tmpfile)
       recorder.start_capture
       recorder
     end
 
     describe "using #stop_and_save" do
       it "stops video recording and saves file" do
-        expect(Headless::CliUtil).to receive(:kill_process).with(pidfile, :wait => true)
-        expect(File).to receive(:exists?).with(tmpfile).and_return(true)
+        expect(Headless::CliUtil).to receive(:kill_process).with(pidfile, wait: true)
+        expect(File).to receive(:exist?).with(tmpfile).and_return(true)
         expect(FileUtils).to receive(:mv).with(tmpfile, filename)
 
         subject.stop_and_save(filename)
@@ -99,7 +89,7 @@ describe Headless::VideoRecorder do
 
     describe "using #stop_and_discard" do
       it "stops video recording and deletes temporary file" do
-        expect(Headless::CliUtil).to receive(:kill_process).with(pidfile, :wait => true)
+        expect(Headless::CliUtil).to receive(:kill_process).with(pidfile, wait: true)
         expect(FileUtils).to receive(:rm).with(tmpfile)
 
         subject.stop_and_discard