xvfb 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70a2f74969d87e28871f89a642241fa48c5e456c
+  data.tar.gz: 75cf5fc301aab83dc0c77c1a36f8f1d1e1535593
+SHA512:
+  metadata.gz: 532ccfc8b2d560a473066af407549210a147b3f176bd8effdeb2f516db101b605d1338082cfa2e3f53b964547753dfdd41f02328bfb247e1a2ae1908b16003a9
+  data.tar.gz: 40999436585f058196e1442eb0b6d066ab0425bfe6a70d76bf4ec898b829f6e20151c837ea84e37470948d6ddbd78e027722bacfb166ac3ab624b69abcf49a7e

data/.gitignore

@@ -0,0 +1,3 @@
+.bundle
+Gemfile.lock
+pkg/*

data/.travis.yml

@@ -0,0 +1,19 @@
+sudo: required
+dist: trusty
+language: ruby
+cache: bundler
+matrix:
+  include:
+    - rvm: 1.9.3
+    - rvm: 2.0.0-p648
+    - rvm: 2.1.10
+    - rvm: 2.2.5
+    - rvm: 2.3.1
+    # see https://github.com/travis-ci/travis-ci/issues/6471
+    - rvm: jruby-9.1.2.0
+      env: JRUBY_OPTS=""
+before_install:
+  - "sudo apt-get update"
+  - "sudo apt-get install -y firefox xvfb libav-tools"
+
+script: "bundle exec rspec"

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ci_util.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+ Copyright (c) 2017 Piotr Krajewski
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,137 @@
+# Xvfb
+
+Xvfb is *the* Ruby interface for Xvfb. It allows you to create a xvfb display straight from Ruby code, hiding the low-level action.
+It can also capture images and video from the virtual framebuffer. For example, you can record screenshots and screencasts of your failing integration specs.
+
+I created it so I can run Selenium tests in Cucumber without any shell scripting. Even more, you can go xvfb only when you run tests against Selenium.
+Other possible uses include pdf generation with `wkhtmltopdf`, or screenshotting.
+
+Documentation is available at [rubydoc.info](http://www.rubydoc.info/gems/xvfb)
+
+[Changelog](https://github.com/mits87/Xvfb/blob/master/CHANGELOG)
+
+## Installation
+
+On Debian/Ubuntu:
+
+```sh
+sudo apt-get install xvfb
+gem install xvfb
+```
+
+## Usage
+
+```ruby
+require 'rubygems'
+require 'xvfb'
+require 'selenium-webdriver'
+
+xvfb = Xvfb.new
+xvfb.start
+
+driver = Selenium::WebDriver.for :firefox
+driver.navigate.to 'http://google.com'
+puts driver.title
+
+xvfb.destroy
+```
+
+## Cucumber
+
+Running cucumber xvfb is now as simple as adding a before and after hook in `features/support/env.rb`:
+
+```ruby
+# change the condition to fit your setup
+if Capybara.current_driver == :selenium
+  require 'xvfb'
+
+  xvfb = Xvfb.new
+  xvfb.start
+end
+```
+
+## Running tests in parallel
+
+If you have multiple threads running acceptance tests in parallel, you want to spawn Xvfb before forking, and then reuse that instance with `destroy_at_exit: false`.
+You can even spawn a Xvfb instance in one ruby script, and then reuse the same instance in other scripts by specifying the same display number and `reuse: true`.
+
+```ruby
+# spawn_xvfb.rb
+Xvfb.new(display: 100, destroy_at_exit: false).start
+
+# test_suite_that_could_be_ran_multiple_times.rb
+Xvfb.new(display: 100, reuse: true, destroy_at_exit: false).start
+
+# reap_xvfb.rb 
+xvfb = Xvfb.new(display: 100, reuse: true)
+xvfb.destroy
+
+# kill_xvfb_without_waiting.rb 
+xvfb = Xvfb.new
+xvfb.destroy_without_sync
+```
+
+There's also a different approach that creates a new virtual display for every parallel test process - see [this implementation](https://gist.github.com/rosskevin/5937888) by @rosskevin.
+
+## Cucumber with wkhtmltopdf
+
+_Note: this is true for other programs which may use xvfb at the same time as cucumber is running_
+
+When wkhtmltopdf is using Xvfb, and cucumber is invoking a block of code which uses a xvfb session, make sure to override the default display of cucumber to retain browser focus. Assuming wkhtmltopdf is using the default display of 99, make sure to set the display to a value != 99 in `features/support/env.rb` file. This may be the cause of `Connection refused - connect(2) (Errno::ECONNREFUSED)`.
+
+```ruby
+xvfb = Xvfb.new(:display => '100')
+xvfb.start
+```
+
+## Capturing video
+
+Video is captured using `ffmpeg`. You can install it on Debian/Ubuntu via `sudo apt-get install ffmpeg` or on OS X via `brew install ffmpeg`. You can capture video continuously or capture scenarios separately. Here is typical use case:
+
+```ruby
+require 'xvfb'
+
+xvfb = Xvfb.new
+xvfb.start
+
+Before do
+  xvfb.video.start_capture
+end
+
+After do |scenario|
+  if scenario.failed?
+    xvfb.video.stop_and_save("/tmp/#{BUILD_ID}/#{scenario.name.split.join("_")}.mov")
+  else
+    xvfb.video.stop_and_discard
+  end
+end
+```
+
+### Video options
+
+When initiating Xvfb you may pass a hash with video options.
+
+```ruby
+xvfb = Xvfb.new(:video => { :frame_rate => 12, :codec => 'libx264' })
+```
+
+Available options:
+
+* :codec - codec to be used by ffmpeg
+* :frame_rate      - frame rate of video capture
+* :provider        - ffmpeg provider - either :libav (default) or :ffmpeg
+* :provider_binary_path - Explicit path to avconv or ffmpeg.  Only required when the binary cannot be discovered on the system $PATH.
+* :pid_file_path   - path to ffmpeg pid file, default: "/tmp/.headless_ffmpeg_#{@display}.pid"
+* :tmp_file_path   - path to tmp video file,  default: "/tmp/.headless_ffmpeg_#{@display}.mov"
+* :log_file_path   - ffmpeg log file,         default: "/dev/null"
+* :extra           - array of extra ffmpeg options, default: [] 
+
+## Troubleshooting
+
+### Display socket is taken but lock file is missing
+
+This means that there is an X server that is taking up the chosen display number, but its lock file is missing. This is an exceptional situation. Please stop the server process manually (`pkill Xvfb`) and open an issue.
+
+### Video not recording
+
+If video is not recording, and there are no visible exceptions, try passing the following option to Xvfb to figure out the reason: `Xvfb.new(video: {log_file_path: STDERR})`. In particular, there are some issues with the version of avconv packaged with Ubuntu 12.04 - an outdated release, but still in use on Travis.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/xvfb.rb

@@ -0,0 +1,210 @@
+require 'xvfb/cli_util'
+require 'xvfb/video/video_recorder'
+
+# A class incapsulating the creation and usage of a xvfb X server
+#
+# == Prerequisites
+#
+# * X Window System
+# * Xvfb[http://en.wikipedia.org/wiki/Xvfb]
+#
+# == Usage
+#
+#   require 'rubygems'
+#   require 'xvfb'
+#   require 'selenium-webdriver'
+#
+#   xvfb = Xvfb.new
+#   xvfb.start
+#
+#   driver = Selenium::WebDriver.for :firefox
+#   driver.navigate.to 'http://google.com'
+#   puts driver.title
+#
+#   xvfb.destroy
+#--
+# TODO test that reuse actually works with an existing xvfb session
+#++
+class Xvfb
+
+  DEFAULT_DISPLAY_NUMBER = 99
+  MAX_DISPLAY_NUMBER = 10_000
+  DEFAULT_DISPLAY_DIMENSIONS = '1280x1024x24'
+  DEFAULT_XVFB_LAUNCH_TIMEOUT = 10
+
+  class Exception < RuntimeError
+  end
+
+  # The display number
+  attr_reader :display
+
+  # The display dimensions
+  attr_reader :dimensions
+  attr_reader :xvfb_launch_timeout
+
+  # Creates a new xvfb server, but does NOT switch to it immediately.
+  # Call #start for that
+  #
+  # List of available options:
+  # * +display+ (default 99) - what display number to listen to;
+  # * +reuse+ (default true) - if given display server already exists,
+  #   should we use it or try another?
+  # * +autopick+ (default true if display number isn't explicitly set) - if
+  #   Xvfb should automatically pick a display, or fail if the given one is
+  #   not available.
+  # * +dimensions+ (default 1280x1024x24) - display dimensions and depth. Not
+  #   all combinations are possible, refer to +man Xvfb+.
+  # * +destroy_at_exit+  - if a display is started but not stopped, should it
+  #   be destroyed when the script finishes?
+  #   (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 Xvfb::VideoRecorder#initialize for
+  # * +browser+ - options to be passed to the browser chromium. See Xvfb::Browser#initialize for documentation
+  def initialize(options = {})
+    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
+    @autopick_display = options.fetch(:autopick, !options.key?(:display))
+    @reuse_display = options.fetch(:reuse, true)
+    @dimensions = options.fetch(:dimensions, DEFAULT_DISPLAY_DIMENSIONS)
+    @video_capture_options = options.fetch(:video, {})
+
+    already_running = xvfb_running? rescue false
+    @destroy_at_exit = options.fetch(:destroy_at_exit, !(@reuse_display && already_running))
+
+    @pid = nil # the pid of the running Xvfb process
+
+    # FIXME Xvfb launch should not happen inside the constructor
+    attach_xvfb
+  end
+
+  # Switches to the xvfb server
+  def start
+    @old_display = ENV['DISPLAY']
+    ENV['DISPLAY'] = ":#{display}"
+    hook_at_exit
+  end
+
+  # Switches back from the xvfb server
+  def stop
+    ENV['DISPLAY'] = @old_display
+  end
+
+  # Switches back from the xvfb server and terminates the xvfb session
+  # while waiting for Xvfb process to terminate.
+  def destroy
+    stop
+    CliUtil.kill_process(pid_filename, preserve_pid_file: true, wait: true)
+  end
+
+  # Deprecated.
+  # Same as destroy.
+  # Kept for backward compatibility in June 2015.
+  def destroy_sync
+    destroy
+  end
+
+  # Same as the old destroy function -- doesn't wait for Xvfb to die.
+  # Can cause zombies: http://stackoverflow.com/a/31003621/1651458
+  def destroy_without_sync
+    stop
+    CliUtil.kill_process(pid_filename, preserve_pid_file: true)
+  end
+
+  # Whether the xvfb display will be destroyed when the script finishes.
+  def destroy_at_exit?
+    @destroy_at_exit
+  end
+
+  def video
+    @video_recorder ||= VideoRecorder.new(display, dimensions, @video_capture_options)
+  end
+
+private
+
+  def attach_xvfb
+    possible_display_set = @autopick_display ? @display..MAX_DISPLAY_NUMBER : Array(@display)
+    pick_available_display(possible_display_set, @reuse_display)
+  end
+
+  def pick_available_display(display_set, can_reuse)
+    display_set.each do |display_number|
+      @display = display_number
+
+      return true if xvfb_running? && can_reuse && (xvfb_mine? || !@autopick_display)
+      return true if !xvfb_running? && launch_xvfb
+    end
+    raise Xvfb::Exception.new("Could not find an available display")
+  end
+
+  def launch_xvfb
+    out_pipe, in_pipe = IO.pipe
+    @pid = Process.spawn(
+      CliUtil.path_to("Xvfb"), ":#{display}", "-screen", "0", dimensions, "-ac",
+      err: in_pipe)
+    raise Xvfb::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
+  end
+
+  def ensure_xvfb_launched(out_pipe)
+    start_time = Time.now
+    errors = ""
+    begin
+      begin
+        errors += out_pipe.read_nonblock(10000)
+        if errors.include? "Cannot establish any listening sockets"
+          raise Xvfb::Exception.new("Display socket is taken but lock file is missing - check the Xvfb troubleshooting guide")
+        end
+        if 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
+        end
+      rescue IO::WaitReadable
+        # will retry next cycle
+      end
+      sleep 0.01 # to avoid cpu hogging
+      raise Xvfb::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 for any reason the pid file doesn't match ours, we lost the race to
+    # get the file lock:
+    return @pid == read_xvfb_pid
+  end
+
+  def xvfb_mine?
+    CliUtil.process_mine?(read_xvfb_pid)
+  end
+
+  # Check whether an Xvfb process is running on @display.
+  # NOTE: This might be a process started by someone else!
+  def xvfb_running?
+    (pid = read_xvfb_pid) && CliUtil.process_running?(pid)
+  end
+
+  def pid_filename
+    "/tmp/.X#{display}-lock"
+  end
+
+  def read_xvfb_pid
+    CliUtil.read_pid(pid_filename)
+  end
+
+  def hook_at_exit
+    unless @at_exit_hook_installed
+      @at_exit_hook_installed = true
+      at_exit do
+        exit_status = $!.status if $!.is_a?(SystemExit)
+        destroy if destroy_at_exit?
+        exit exit_status if exit_status
+      end
+    end
+  end
+end

data/lib/xvfb/cli_util.rb

@@ -0,0 +1,70 @@
+class Xvfb
+  class CliUtil
+    def self.application_exists?(app)
+      !!path_to(app)
+    end
+
+    def self.ensure_application_exists!(app, error_message)
+      if !self.application_exists?(app)
+        raise Xvfb::Exception.new(error_message)
+      end
+    end
+
+    # Credit: http://stackoverflow.com/a/5471032/6678
+    def self.path_to(app)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each { |ext|
+          exe = File.join(path, "#{app}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        }
+      end
+      return nil
+    end
+
+    def self.process_mine?(pid)
+      Process.kill(0, pid) && true
+    rescue Errno::EPERM, Errno::ESRCH
+      false
+    end
+
+    def self.process_running?(pid)
+      Process.getpgid(pid) && true
+    rescue Errno::ESRCH
+      false
+    end
+
+    def self.read_pid(pid_filename)
+      pid = (File.read(pid_filename) rescue "").strip
+      pid.empty? ? nil : pid.to_i
+    end
+
+    def self.fork_process(command, pid_filename, log_filename='/dev/null')
+      pid = Process.spawn(command, err: log_filename)
+      File.open pid_filename, 'w' do |f|
+        f.puts pid
+      end
+    end
+
+    def self.kill_process(pid_filename, options={})
+      if pid = read_pid(pid_filename)
+        begin
+          Process.kill 'TERM', pid
+          Process.wait pid if options[:wait]
+        rescue Errno::ESRCH
+          # no such process; assume it's already killed
+        rescue Errno::ECHILD
+          # Process.wait tried to wait on a dead process
+        end
+      end
+
+      unless options[:preserve_pid_file]
+        begin
+          FileUtils.rm pid_filename
+        rescue Errno::ENOENT
+          # pid file already removed
+        end
+      end
+    end
+  end
+end

data/lib/xvfb/video/video_recorder.rb

@@ -0,0 +1,106 @@
+require 'tempfile'
+
+class Xvfb
+  class VideoRecorder
+    attr_accessor :pid_file_path, :tmp_file_path, :log_file_path, :provider_binary_path
+
+    # Construct a new Video Recorder instance. Typically done from inside Xvfb, but can be also created manually,
+    # and even used separately from Xvfb' Xvfb features.
+    # * display - display number to capture
+    # * dimensions - dimensions of the captured video
+    # * options - available options:
+    #   * provider - either :ffmpeg or :libav; default is :ffmpeg - switch if your system is provisioned with FFMpeg
+    #   * provider_binary_path - override path to ffmpeg / libav binary
+    #   * pid_file_path - override path to PID file, default is placed in /tmp
+    #   * tmp_file_path - override path to temp file, default is placed in /tmp
+    #   * log_file_path - set log file path, default is /dev/null
+    #   * codec - change ffmpeg codec, default is qtrle
+    #   * frame_rate - change frame rate, default is 30
+    #   * devices - array of device options - see https://www.ffmpeg.org/ffmpeg-devices.html
+    #   * extra - array of extra options to append to the FFMpeg command line
+    def initialize(display, dimensions, options = {})
+      @display = display
+      @dimensions = dimensions[/.+(?=x)/]
+
+      @pid_file_path = options.fetch :pid_file_path, "/tmp/.headless_ffmpeg_#{@display}.pid"
+      @tmp_file_path = options.fetch :tmp_file_path, "/tmp/.headless_ffmpeg_#{@display}.mov"
+      @log_file_path = options.fetch :log_file_path, "/dev/null"
+      @codec         = options.fetch :codec, "libx264"
+      @frame_rate    = options.fetch :frame_rate, 12
+      @provider      = options.fetch :provider, :ffmpeg  # or :libav
+
+      # If no provider_binary_path was specified, then
+      # make a guess based upon the provider.
+      @provider_binary_path = options.fetch(:provider_binary_path, guess_the_provider_binary_path)
+
+      @extra   = Array(options.fetch :extra,   [])
+      @devices = Array(options.fetch :devices, [])
+
+      CliUtil.ensure_application_exists! provider_binary_path, "#{provider_binary_path} not found on your system. Install it or change video recorder provider"
+    end
+
+    def capture_running?
+      CliUtil.read_pid @pid_file_path
+    end
+
+    def start_capture
+      CliUtil.fork_process command_line_for_capture, @pid_file_path, @log_file_path
+      at_exit do
+        exit_status = $!.status if $!.is_a?(SystemExit)
+        stop_and_discard
+        exit exit_status if exit_status
+      end
+    end
+
+    def stop_and_save(path)
+      CliUtil.kill_process @pid_file_path, wait: true
+      if File.exists? @tmp_file_path
+        begin
+          FileUtils.mkdir_p File.dirname(path)
+          FileUtils.mv @tmp_file_path, path
+        rescue
+          nil
+        end
+      end
+    end
+
+    def stop_and_discard
+      CliUtil.kill_process @pid_file_path, wait: true
+      begin
+        FileUtils.rm @tmp_file_path
+      rescue Errno::ENOENT
+        # that's ok if the file doesn't exist
+      end
+    end
+
+    private
+
+    def guess_the_provider_binary_path
+      @provider== :libav ? 'avconv' : 'ffmpeg'
+    end
+
+    def command_line_for_capture
+      if @provider == :libav
+        group_of_pic_size_option = '-g 600'
+        dimensions = @dimensions
+      else
+        group_of_pic_size_option = nil
+        dimensions = @dimensions.match(/^(\d+x\d+)/)[0]
+      end
+
+      [
+         CliUtil.path_to(provider_binary_path),
+         "-y",
+         "-r #{@frame_rate}",
+         "-s #{dimensions}",
+         "-f x11grab",
+         "-i :#{@display}",
+         @devices,
+         group_of_pic_size_option,
+         "-vcodec #{@codec}",
+         @extra,
+         @tmp_file_path
+      ].flatten.compact.join(' ')
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,37 @@
+require 'xvfb'
+require 'selenium-webdriver'
+
+describe 'Integration test' do
+  let!(:xvfb) { xvfb.new }
+  before { xvfb.start }
+
+  after { xvfb.destroy_sync }
+
+  it 'should use xvfb' do
+    work_with_browser
+  end
+
+  it 'should record video with ffmpeg' do
+    xvfb.video.start_capture
+    work_with_browser
+    xvfb.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
+    expect {
+      FileUtils.mv("/tmp/.X#{xvfb.display}-lock", "/tmp/xvfb-test-tmp")
+      xvfb.new(display: xvfb.display, reuse: false)
+    }.to raise_error(Xvfb::Exception, /troubleshooting guide/)
+    FileUtils.mv("/tmp/xvfb-test-tmp", "/tmp/.X#{xvfb.display}-lock")
+  end
+
+  private
+
+  def work_with_browser
+    driver = Selenium::WebDriver.for :firefox
+    driver.navigate.to 'http://google.com'
+    expect(driver.title).to match(/Google/)
+    driver.close
+  end
+end

data/spec/video_recorder_spec.rb

@@ -0,0 +1,115 @@
+require 'xvfb'
+require 'tempfile'
+
+describe Xvfb::VideoRecorder do
+  before do
+    stub_environment
+  end
+
+  describe "instantiation" do
+
+    it "throws an error if provider_binary_path is not installed" do
+      allow(Xvfb::CliUtil).to receive(:application_exists?).and_return(false)
+      expect { Xvfb::VideoRecorder.new(99, "1024x768x32") }.to raise_error(Xvfb::Exception)
+    end
+
+    it "allows provider_binary_path to be specified" do
+      Tempfile.open('some_provider') do |f|
+        v = Xvfb::VideoRecorder.new(99, "1024x768x32", provider: :libav, provider_binary_path: f.path)
+        expect(v.provider_binary_path).to eq(f.path)
+      end
+    end
+
+    it "allows provider_binary_path to be specified" do
+      Tempfile.open('some_provider') do |f|
+        v = Xvfb::VideoRecorder.new(99, "1024x768x32", provider: :libav, provider_binary_path: f.path)
+        expect(v.provider_binary_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 = Xvfb::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 = Xvfb::VideoRecorder.new(99, "1024x768x32", provider: :libav)
+        expect(v.provider_binary_path).to eq("avconv")
+      end
+
+    end
+  end
+
+  describe "#capture" do
+    before do
+      allow(Xvfb::CliUtil).to receive(:path_to).and_return('ffmpeg')
+    end
+
+    it "starts ffmpeg" do
+      expect(Xvfb::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')
+
+      recorder = Xvfb::VideoRecorder.new(99, "1024x768x32")
+      recorder.start_capture
+    end
+
+    it "starts ffmpeg with specified codec" do
+      expect(Xvfb::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 = Xvfb::VideoRecorder.new(99, "1024x768x32", {:codec => 'libvpx'})
+      recorder.start_capture
+    end
+
+    it "starts ffmpeg from libav provider with correct parameters" do
+      expect(Xvfb::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')
+
+      recorder = Xvfb::VideoRecorder.new(99, "1024x768x32", {:provider => :libav})
+      recorder.start_capture
+    end
+
+    it "starts ffmpeg with specified extra device options" do
+      expect(Xvfb::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')
+
+      recorder = Xvfb::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' }
+
+    subject do
+      recorder = Xvfb::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(Xvfb::CliUtil).to receive(:kill_process).with(pidfile, :wait => true)
+        expect(File).to receive(:exists?).with(tmpfile).and_return(true)
+        expect(FileUtils).to receive(:mv).with(tmpfile, filename)
+
+        subject.stop_and_save(filename)
+      end
+    end
+
+    describe "using #stop_and_discard" do
+      it "stops video recording and deletes temporary file" do
+        expect(Xvfb::CliUtil).to receive(:kill_process).with(pidfile, :wait => true)
+        expect(FileUtils).to receive(:rm).with(tmpfile)
+
+        subject.stop_and_discard
+      end
+    end
+  end
+
+  private
+
+  def stub_environment
+    allow(Xvfb::CliUtil).to receive(:application_exists?).and_return(true)
+    allow(Xvfb::CliUtil).to receive(:fork_process).and_return(true)
+  end
+end

data/spec/xvfb_spec.rb

@@ -0,0 +1,172 @@
+require 'xvfb'
+
+describe Xvfb do
+  before do
+    ENV['DISPLAY'] = ":31337"
+    stub_environment
+  end
+
+  describe 'launch options' do
+    before do
+      allow_any_instance_of(Xvfb).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)
+      xvfb = Xvfb.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)
+      xvfb = Xvfb.new(:dimensions => "1024x768x16")
+    end
+  end
+
+  context 'with stubbed launch_xvfb' do
+    before do
+      allow_any_instance_of(Xvfb).to receive(:launch_xvfb).and_return(true)
+    end
+
+    context "instantiation" do
+      context "when Xvfb is not installed" do
+        before do
+          allow(Xvfb::CliUtil).to receive(:application_exists?).and_return(false)
+        end
+
+        it "raises an error" do
+          expect { Xvfb.new }.to raise_error(Xvfb::Exception)
+        end
+      end
+
+      context "when Xvfb is already running and was started by this user" do
+        before do
+          allow(Xvfb::CliUtil).to receive(:read_pid).with('/tmp/.X99-lock').and_return(31337)
+          allow(Xvfb::CliUtil).to receive(:process_running?).with(31337).and_return(true)
+          allow(Xvfb::CliUtil).to receive(:process_mine?).with(31337).and_return(true)
+
+          allow(Xvfb::CliUtil).to receive(:read_pid).with('/tmp/.X100-lock').and_return(nil)
+        end
+
+        context "and display reuse is allowed" do
+          let(:options) { {:reuse => true} }
+
+          it "should reuse the existing Xvfb" do
+            expect(Xvfb.new(options).display).to eq 99
+          end
+
+          it "should not be destroyed at exit by default" do
+            expect(Xvfb.new(options).destroy_at_exit?).to eq false
+          end
+        end
+
+        context "and display reuse is not allowed" do
+          let(:options) { {:reuse => false} }
+
+          it "should pick the next available display number" do
+            expect(Xvfb.new(options).display).to eq 100
+          end
+
+          context "and display number is explicitly set" do
+            let(:options) { {:reuse => false, :display => 99} }
+
+            it "should fail with an exception" do
+              expect { Xvfb.new(options) }.to raise_error(Xvfb::Exception)
+            end
+
+            context "and autopicking is allowed" do
+              let(:options) { {:reuse => false, :display => 99, :autopick => true} }
+
+              it "should pick the next available display number" do
+                expect(Xvfb.new(options).display).to eq 100
+              end
+            end
+          end
+        end
+      end
+
+      context 'when Xvfb is started, but by another user' do
+        before do
+          allow(Xvfb::CliUtil).to receive(:read_pid).with('/tmp/.X99-lock').and_return(31337)
+          allow(Xvfb::CliUtil).to receive(:process_running?).with(31337).and_return(true)
+          allow(Xvfb::CliUtil).to receive(:process_mine?).with(31337).and_return(false)
+
+          allow(Xvfb::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} }
+
+          it "should reuse the display" do
+            expect(Xvfb.new(options).display).to eq 99
+          end
+        end
+
+        context "and display autopicking is allowed" do
+          let(:options) { {:autopick => true} }
+
+          it "should pick the next display number" do
+            expect(Xvfb.new(options).display).to eq 100
+          end
+        end
+      end
+    end
+
+    context "lifecycle" do
+      let(:xvfb) { Xvfb.new }
+      describe "#start" do
+        it "switches to the xvfb server" do
+          expect(ENV['DISPLAY']).to eq ":31337"
+          xvfb.start
+          expect(ENV['DISPLAY']).to eq ":99"
+        end
+      end
+
+      describe "#stop" do
+        it "switches back from the xvfb server" do
+          expect(ENV['DISPLAY']).to eq ":31337"
+          xvfb.start
+          expect(ENV['DISPLAY']).to eq ":99"
+          xvfb.stop
+          expect(ENV['DISPLAY']).to eq ":31337"
+        end
+      end
+
+      describe "#destroy" do
+        before do
+          allow(Xvfb::CliUtil).to receive(:read_pid).and_return(4444)
+        end
+
+        it "switches back from the xvfb server and terminates the xvfb session" do
+          expect(Process).to receive(:kill).with('TERM', 4444)
+
+          expect(ENV['DISPLAY']).to eq ":31337"
+          xvfb.start
+          expect(ENV['DISPLAY']).to eq ":99"
+          xvfb.destroy
+          expect(ENV['DISPLAY']).to eq ":31337"
+        end
+      end
+    end
+
+    context "#video" do
+      let(:xvfb) { Xvfb.new }
+
+      it "returns video recorder" do
+        expect(xvfb.video).to be_a_kind_of(Xvfb::VideoRecorder)
+      end
+
+      it "returns the same instance" do
+        recorder = xvfb.video
+        expect(xvfb.video).to eq recorder
+      end
+    end
+  end
+
+private
+
+  def stub_environment
+    allow(Xvfb::CliUtil).to receive(:application_exists?).and_return(true)
+    allow(Xvfb::CliUtil).to receive(:read_pid).and_return(nil)
+    allow(Xvfb::CliUtil).to receive(:path_to).and_return("/usr/bin/Xvfb")
+  end
+end

data/xvfb.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.author = 'Piotr Krajewski'
+  s.email  = 'mits87@gmail.com'
+
+  s.name    = 'xvfb'
+  s.version = '1.0.4'
+  s.summary = 'Ruby interface for Xvfb'
+  s.license = 'MIT'
+
+  s.description = <<-EOF
+    Ruby interface for Xvfb. It allows you to create a headless display straight from Ruby code, hiding some low-level action.
+  EOF
+  s.requirements = 'Xvfb'
+  s.homepage = 'https://github.com/mits87/Xvfb'
+
+  s.files = `git ls-files`.split("\n")
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 3'
+  s.add_development_dependency 'selenium-webdriver'
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: xvfb
+version: !ruby/object:Gem::Version
+  version: 1.0.4
+platform: ruby
+authors:
+- Piotr Krajewski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "    Ruby interface for Xvfb. It allows you to create a headless display
+  straight from Ruby code, hiding some low-level action.\n"
+email: mits87@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/xvfb.rb
+- lib/xvfb/cli_util.rb
+- lib/xvfb/video/video_recorder.rb
+- spec/integration_spec.rb
+- spec/video_recorder_spec.rb
+- spec/xvfb_spec.rb
+- xvfb.gemspec
+homepage: https://github.com/mits87/Xvfb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Xvfb
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Ruby interface for Xvfb
+test_files: []