headless-muse 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f3ef46e8f92d17bf336aae8bab33f7e138dd4619
+  data.tar.gz: 36029054c983b680a1996121ae0256a52c5f034a
+SHA512:
+  metadata.gz: a4e524a612efbeab185f98efa58ba2c7490a391bc02bdee9a327b8760d62837ed76f575c4756c20aa3442978b17d0305bf0a261c8eb7e7391652c5e3b1006917
+  data.tar.gz: 0df9462f894b68182517fe89552b22fc5ce09f1143d44233efa46e9fd5dece0d559e049bb4311e752fb69757608871db0e0a922f1b4006cc087566d4b7b12254

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+env:
+  - FFMPEG_VERSION=default
+  - FFMPEG_VERSION=2.3
+before_install: ./.travis/setup.sh
+script: "rspec"
+

data/.travis/setup.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+case "$FFMPEG_VERSION" in
+    2.3)
+        sudo add-apt-repository ppa:archivematica/externals -y
+        sudo apt-get update -q
+        sudo apt-get install ffmpeg
+        ;;
+
+    1.2)
+        stop
+        ;;
+    *)
+        sudo apt-get update -q
+        sudo apt-get install ffmpeg
+esac

data/CHANGELOG

@@ -0,0 +1,33 @@
+## 1.0.2 (2014-06-03)
+
+* pass options correctly to ffmpeg (from @abotalov)
+* only destroy headless if it was created (from @evandrodp)
+
+## 1.0.1 (2013-02-20)
+
+* when starting, wait for Xvfb to launch (fixed issue #33)
+
+## 1.0.0 (2013-01-28)
+
+* bugfix release
+* version number compliant to the [semantic versioning system](http://semver.org)
+
+## 0.3.1 (2012-03-29)
+
+* added autopicking of display number, if the requested one is already taken
+* fixed plenty of bugs thanks to @recursive, @gshakhn, @masatomo and @mabotelh
+
+## 0.2.2 (2011-09-01)
+
+* improve detection of ffmpeg process (from https://github.com/alanshields/headless)
+
+## 0.2.1 (2011-08-26)
+
+* added ability to capture screenshots (from https://github.com/iafonov/headless)
+* added ability to capture video (from https://github.com/iafonov/headless)
+* fixed issue with stray pidfile
+
+## 0.1.0 (2010-08-15)
+
+* introduced options
+* make it possible to change virtual screen dimensions and pixel depth

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) 2010 Leonid Shevtsov
+
+ 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,141 @@
+# Headless
+[![Build Status](https://travis-ci.org/pgeraghty/headless.svg?branch=master)](https://travis-ci.org/pgeraghty/headless)
+[![Coverage Status](https://img.shields.io/coveralls/pgeraghty/headless.svg)](https://coveralls.io/r/pgeraghty/headless?branch=master)
+
+# This fork
+
+This fork is the source of the [headless-muse gem]().
+
+## Notes by original author (Leonid Shevtsov)
+
+Headless is *the* Ruby interface for Xvfb. It allows you to create a headless display straight from Ruby code, hiding some low-level action.
+It can also capture images and video from the virtual framebuffer.
+
+I created it so I can run Selenium tests in Cucumber without any shell scripting. Even more, you can go headless only when you run tests against Selenium.
+Other possible uses include pdf generation with `wkhtmltopdf`, or screenshotting.
+
+Documentation is available at [rdoc.info](http://rdoc.info/projects/leonid-shevtsov/headless)
+
+[Changelog](https://github.com/leonid-shevtsov/headless/blob/master/CHANGELOG)
+
+**Note: Headless will NOT hide most applications on OS X. [Here is a detailed explanation](https://github.com/leonid-shevtsov/headless/issues/31#issuecomment-8933108)**
+
+## Installation
+
+On Debian/Ubuntu:
+
+```sh
+sudo apt-get install xvfb
+gem install headless
+```
+
+## Usage
+
+Block mode:
+
+```ruby
+require 'rubygems'
+require 'headless'
+require 'selenium-webdriver'
+
+Headless.ly do
+  driver = Selenium::WebDriver.for :firefox
+  driver.navigate.to 'http://google.com'
+  puts driver.title 
+end
+```
+
+Object mode:
+
+```ruby
+require 'rubygems'
+require 'headless'
+require 'selenium-webdriver'
+
+headless = Headless.new
+headless.start
+
+driver = Selenium::WebDriver.for :firefox
+driver.navigate.to 'http://google.com'
+puts driver.title
+
+headless.destroy
+```
+
+## Cucumber
+
+Running cucumber headless 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 'headless'
+
+  headless = Headless.new
+  headless.start
+end
+```
+
+## Running tests in parallel
+
+If you have multiple threads running acceptance tests in parallel, you want to spawn Headless before forking, and then reuse that instance with `destroy_at_exit: false`.
+You can even spawn a Headless 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_headless.rb
+Headless.new(display: 100, destroy_at_exit: false).start
+
+# test_suite_that_could_be_ran_multiple_times.rb
+Headless.new(display: 100, reuse: true, destroy_at_exit: false).start
+
+# reap_headless.rb 
+headless = Headless.new(display: 100, reuse: true)
+headless.destroy
+```
+ 
+
+## Cucumber with wkhtmltopdf
+
+_Note: this is true for other programs which may use headless at the same time as cucumber is running_
+
+When wkhtmltopdf is using Headless, and cucumber is invoking a block of code which uses a headless 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
+headless = Headless.new(:display => '100')
+headless.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 'headless'
+
+headless = Headless.new
+headless.start
+
+Before do
+  headless.video.start_capture
+end
+
+After do |scenario|
+  if scenario.failed?
+    headless.video.stop_and_save("/tmp/#{BUILD_ID}/#{scenario.name.split.join("_")}.mov")
+  else
+    headless.video.stop_and_discard
+  end
+end
+```
+
+## Taking screenshots
+
+Images are captured using `import` utility which is part of `imagemagick` library. You can install it on Ubuntu via `sudo apt-get install imagemagick`. You can call `headless.take_screenshot` at any time. You have to supply full path to target file. File format is determined by supplied file extension.
+
+## Contributors
+
+* [Igor Afonov](http://iafonov.github.com) - video and screenshot capturing functionality.
+
+---
+
+© 2011 Leonid Shevtsov, released under the MIT license

data/Rakefile

@@ -0,0 +1,10 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec

data/headless.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.authors = ['Leonid Shevtsov', 'Igor Afonov', 'Paul Geraghty']
+  s.email = 'muse@appsthatcould.be'
+
+  s.name = 'headless-muse'
+  s.version = '1.1.0'
+  s.summary = 'Ruby headless display interface'
+
+  s.description = <<-EOF
+    Headless is a Ruby interface for Xvfb. It allows you to create a headless display straight from Ruby code, hiding some low-level action.
+    It can also capture video and audio via ffmpeg and take screenshots.
+  EOF
+  s.requirements = 'Xvfb'
+  s.homepage = 'https://github.com/pgeraghty/headless'
+s.license = 'MIT'
+  s.files         = `git ls-files`.split("\n")
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 2.6'
+  s.add_development_dependency('coveralls', '> 0') unless RUBY_VERSION == '1.8.7'
+end

data/lib/headless.rb

@@ -0,0 +1,183 @@
+require 'headless/cli_util'
+require 'headless/video/video_recorder'
+
+# A class incapsulating the creation and usage of a headless X server
+#
+# == Prerequisites
+#
+# * X Window System
+# * Xvfb[http://en.wikipedia.org/wiki/Xvfb]
+#
+# == Usage
+#
+# Block mode:
+#
+#   require 'rubygems'
+#   require 'headless'
+#   require 'selenium-webdriver'
+#
+#   Headless.ly do
+#     driver = Selenium::WebDriver.for :firefox
+#     driver.navigate.to 'http://google.com'
+#     puts driver.title
+#   end
+#
+# Object mode:
+#
+#   require 'rubygems'
+#   require 'headless'
+#   require 'selenium-webdriver'
+#
+#   headless = Headless.new
+#   headless.start
+#
+#   driver = Selenium::WebDriver.for :firefox
+#   driver.navigate.to 'http://google.com'
+#   puts driver.title
+#
+#   headless.destroy
+#--
+# 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'
+  # How long should we wait for Xvfb to open a display, before assuming that it is frozen (in seconds)
+  XVFB_LAUNCH_TIMEOUT = 10
+
+  class Exception < RuntimeError
+  end
+
+  # The display number
+  attr_reader :display
+
+  # The display dimensions
+  attr_reader :dimensions
+
+  # Creates a new headless 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 is display number isn't explicitly set) - if Headless 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+ (default true) - if a display is started but not stopped, should it be destroyed when the script finishes?
+  def initialize(options = {})
+    CliUtil.ensure_application_exists!('Xvfb', 'Xvfb not found on your system')
+
+    @display = options.fetch(:display, DEFAULT_DISPLAY_NUMBER).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, {})
+    @destroy_at_exit = options.fetch(:destroy_at_exit, true)
+
+    # FIXME Xvfb launch should not happen inside the constructor
+    attach_xvfb
+  end
+
+  # Switches to the headless server
+  def start
+    @old_display = ENV['DISPLAY']
+    ENV['DISPLAY'] = ":#{display}"
+    hook_at_exit
+  end
+
+  # Switches back from the headless server
+  def stop
+    ENV['DISPLAY'] = @old_display
+  end
+
+  # Switches back from the headless server and terminates the headless session
+  def destroy
+    stop
+    CliUtil.kill_process(pid_filename)
+  end
+
+  # Block syntax:
+  #
+  #   Headless.run do
+  #     # perform operations in headless mode
+  #   end
+  # See #new for options
+  def self.run(options={}, &block)
+    headless = Headless.new(options)
+    headless.start
+    yield headless
+  ensure
+    headless && headless.destroy
+  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)
+    CliUtil.ensure_application_exists!('import', "imagemagick 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}"
+  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
+      begin
+        return true if xvfb_running? && can_reuse
+        return true if !xvfb_running? && launch_xvfb
+      rescue Errno::EPERM # display not accessible
+        next
+      end
+    end
+    raise Headless::Exception.new("Could not find an available display")
+  end
+
+  def launch_xvfb
+    #TODO error reporting
+    result = system "#{CliUtil.path_to("Xvfb")} :#{display} -screen 0 #{dimensions} -ac >/dev/null 2>&1 &"
+    raise Headless::Exception.new("Xvfb did not launch - something's wrong") unless result
+    ensure_xvfb_is_running
+    return true
+  end
+
+  def ensure_xvfb_is_running
+    start_time = Time.now
+    begin
+      sleep 0.01 # to avoid cpu hogging
+      raise Headless::Exception.new("Xvfb is frozen") if (Time.now-start_time)>=XVFB_LAUNCH_TIMEOUT
+    end while !xvfb_running?
+  end
+
+  def xvfb_running?
+    !!read_xvfb_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/headless/cli_util.rb

@@ -0,0 +1,64 @@
+class Headless
+  class CliUtil
+    def self.application_exists?(app)
+      `which #{app}`.strip != ""
+    end
+
+    def self.ensure_application_exists!(app, error_message)
+      if !self.application_exists?(app)
+        raise Headless::Exception.new(error_message)
+      end
+    end
+
+    def self.path_to(app)
+      `which #{app}`.strip
+    end
+
+    def self.read_pid(pid_filename)
+      pid = (File.read(pid_filename) rescue "").strip.to_i
+      pid = nil if pid.zero?
+
+      if pid
+        begin
+          Process.kill(0, pid)
+          pid
+        rescue Errno::ESRCH
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+    def self.fork_process(command, pid_filename, log_filename='/dev/null')
+      pid = fork do
+        STDERR.reopen(log_filename)
+        exec command
+        exit! 127 # safeguard in case exec fails
+      end
+
+      File.open pid_filename, 'w' do |f|
+        f.puts pid
+      end
+    end
+
+    def self.kill_process(pid_filename, options={})
+      if pid = self.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
+      
+      begin
+        FileUtils.rm pid_filename
+      rescue Errno::ENOENT
+        # pid file already removed
+      end
+    end
+  end
+end

data/lib/headless/video/video_recorder.rb

@@ -0,0 +1,82 @@
+require 'tempfile'
+
+class Headless
+  class VideoRecorder
+    attr_accessor :pid_file_path, :tmp_file_path, :log_file_path, :bin_file_path, :bin_version, :capture_with
+
+    def initialize(display, dimensions, options = {})
+      CliUtil.ensure_application_exists!('ffmpeg', 'Ffmpeg not found on your system. Install it with sudo apt-get install ffmpeg')
+
+      @display = display
+      @dimensions = dimensions[/.+(?=x)/]
+
+      @bin_file_path = options.fetch(:bin_file_path, CliUtil.path_to('ffmpeg'))
+      # divine version - tested on:
+      # ffmpeg version 2.3.1
+      # ffmpeg version 0.10.9-7:0.10.9-1~quantal1
+      # ffmpeg 0.8.10-6:0.8.10-0ubuntu0.12.10.1
+      @bin_version   = options.fetch(:bin_version, guess_ffmpeg_version!)
+      @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, 'qtrle')
+      @frame_rate = options.fetch(:frame_rate, 30).to_i
+      @nomouse = options.fetch(:nomouse, false)
+      @audio = options.fetch(:audio, false)
+    end
+
+    def guess_ffmpeg_version!
+      (Gem::Version.new(`#{@bin_file_path} -version`[/(?:ffmpeg )(?:version )?((?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+))/, 1])) unless @bin_file_path.empty? rescue Gem::Version.new('0')
+    end
+
+    def capture_running?
+      !!CliUtil.read_pid(@pid_file_path)
+    end
+
+    def capture_with
+      # TODO adjust switches based on @bin_version e.g. if @bin_version < Gem::Version.new('1')
+      [
+          @bin_file_path,
+          'y',                        # ignore already-existing file
+          ('f alsa -ac 2 -i hw:0,1' if @audio),
+          "r #{@frame_rate}",
+          "s #{@dimensions}",
+          'f x11grab',
+          ('draw_mouse 0' if @nomouse),
+          "i :#{@display}",
+          "vcodec #{@codec}",
+          ("g #{@frame_rate.to_i*20}" if @bin_version && @bin_version < Gem::Version.new('1'))
+      ].compact*' -'
+    end
+
+    def start_capture
+      CliUtil.fork_process("#{capture_with} #{@tmp_file_path}", @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.mv(@tmp_file_path, path)
+            true
+        rescue Errno::EINVAL
+          false
+        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
+  end
+end

data/spec/cli_util_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Headless::CliUtil do
+  before do
+    subject.class.stub(:path_to).and_return('ffmpeg')
+  end
+
+  describe 'application_exists?' do
+    before { subject.class.stub(:`).and_return('/usr/bin/ffmpeg') }
+
+    it 'calls which to find the process' do
+      subject.class.should_receive(:`).with('which ffmpeg').and_return('/usr/bin/ffmpeg')
+      subject.class.application_exists?('ffmpeg').should eq(true)
+    end
+  end
+
+  describe 'fork_process' do
+    before { subject.class.stub(:application_exists?).and_return(true) }
+
+    it 'forks' do
+      recorder = Headless::VideoRecorder.new(99, '1024x768x32')
+
+      subject.class.should_receive(:fork).and_yield do |block|
+        block.stub(:exec).and_return(123)
+        block.stub(:exit!)
+        STDERR.should_receive(:reopen).with('/dev/null')
+        block.should_receive(:exec).with("#{recorder.capture_with} #{recorder.tmp_file_path}")
+      end
+      recorder.start_capture
+    end
+
+    it 'creates PID file' do
+      recorder = Headless::VideoRecorder.new(99, '1024x768x32')
+      subject.class.stub(:fork).and_return(123)
+
+      file = double('file')
+      File.should_receive(:open).with('/tmp/.headless_ffmpeg_99.pid', 'w').and_yield(file)
+      file.should_receive(:puts).with(123)
+
+      recorder.start_capture
+    end
+  end
+
+  describe 'read_pid' do
+    before do
+      Process.stub(:kill)
+      File.stub(:read).and_return('999999999999')
+    end
+
+    it 'reads PID file' do
+      File.should_receive(:read).with('/tmp/.headless_ffmpeg_99.pid').and_return('')
+      subject.class.read_pid('/tmp/.headless_ffmpeg_99.pid').should eq(nil)
+    end
+
+    it 'sends signal to process' do
+      Process.should_receive(:kill).with(0, 999999999999)
+      subject.class.read_pid('/tmp/.headless_ffmpeg_99.pid').should eq(999999999999)
+    end
+
+    it 'returns nil after a rescued error when process does not exist' do
+      Process.stub(:kill).and_raise(Errno::ESRCH)
+      subject.class.read_pid('/tmp/.headless_ffmpeg_99.pid').should eq(nil)
+    end
+  end
+end

data/spec/headless_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe Headless do
+  before do
+    ENV['DISPLAY'] = ":31337"
+    stub_environment
+  end
+
+  after do
+    `killall Xvfb`
+    # RSpec::Mocks.proxy_for(Headless::CliUtil).reset
+    # RSpec::Mocks.proxy_for(Headless).reset
+    #
+    # ObjectSpace.each_object(Headless) { |h| RSpec::Mocks.proxy_for(h).reset; h.destroy }
+  end
+
+  context "instantiation" do
+    context "when Xvfb is not installed" do
+      before do
+        Headless::CliUtil.stub(:application_exists?).and_return(false)
+      end
+
+      it "raises an error" do
+        lambda { Headless.new }.should raise_error(Headless::Exception)
+      end
+    end
+
+    context "when Xvfb is not started yet" do
+      it "starts Xvfb" do
+        Headless.any_instance.should_receive(:system).with("/usr/bin/Xvfb :99 -screen 0 1280x1024x24 -ac >/dev/null 2>&1 &").and_return(true)
+
+        headless = Headless.new
+      end
+
+      it "allows setting screen dimensions" do
+        Headless.any_instance.should_receive(:system).with("/usr/bin/Xvfb :99 -screen 0 1024x768x16 -ac >/dev/null 2>&1 &").and_return(true)
+
+        headless = Headless.new(:dimensions => "1024x768x16")
+      end
+    end
+
+    context "when Xvfb is already running" do
+      before do
+        Headless::CliUtil.stub(:read_pid).with('/tmp/.X99-lock').and_return(31337)
+        Headless::CliUtil.stub(: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
+          Headless.new(options).display.should == 99
+        end
+      end
+
+      context "and display reuse is not allowed" do
+        let(:options) { {:reuse => false} }
+
+        it "should pick the next available display number" do
+          Headless.new(options).display.should == 100
+        end
+
+        context "and display number is explicitly set" do
+          let(:options) { {:reuse => false, :display => 99} }
+
+          it "should fail with an exception" do
+            lambda { Headless.new(options) }.should raise_error(Headless::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
+              Headless.new(options).display.should == 100
+            end
+          end
+        end
+      end
+    end
+
+    context 'when Xvfb is started, but by another user' do
+      before do
+        Headless::CliUtil.stub(:read_pid).with('/tmp/.X99-lock') { raise Errno::EPERM }
+        Headless::CliUtil.stub(:read_pid).with('/tmp/.X100-lock').and_return(nil)
+      end
+
+      context "and display autopicking is not allowed" do
+        let(:options) { {:autopick => false} }
+
+        it "should fail with and exception" do
+          lambda { Headless.new(options) }.should raise_error(Headless::Exception)
+        end
+      end
+
+      context "and display autopicking is allowed" do
+        let(:options) { {:autopick => true} }
+
+        it "should pick the next display number" do
+          Headless.new(options).display.should == 100
+        end
+      end
+    end
+  end
+
+  context "lifecycle" do
+    let(:headless) { Headless.new }
+    describe "#start" do
+      it "switches to the headless server" do
+        ENV['DISPLAY'].should == ":31337"
+        headless.start
+        ENV['DISPLAY'].should == ":99"
+      end
+    end
+
+    describe "#stop" do
+      it "switches back from the headless server" do
+        ENV['DISPLAY'].should == ":31337"
+        headless.start
+        ENV['DISPLAY'].should == ":99"
+        headless.stop
+        ENV['DISPLAY'].should == ":31337"
+      end
+    end
+
+    describe "#destroy" do
+      before do
+        Headless::CliUtil.stub(:read_pid).and_return(4444)
+      end
+
+      it "switches back from the headless server and terminates the headless session" do
+        Process.should_receive(:kill).with('TERM', 4444)
+
+        ENV['DISPLAY'].should == ":31337"
+        headless.start
+        ENV['DISPLAY'].should == ":99"
+        headless.destroy
+        ENV['DISPLAY'].should == ":31337"
+      end
+    end
+  end
+
+  context "#video" do
+    let(:headless) { Headless.new }
+
+    it "returns video recorder" do
+      headless.video.should be_a_kind_of(Headless::VideoRecorder)
+    end
+
+    it "returns the same instance" do
+      recorder = headless.video
+      headless.video.should be_eql(recorder)
+    end
+  end
+
+  context "#take_screenshot" do
+    let(:headless) { Headless.new }
+
+    it "raises an error if imagemagick is not installed" do
+      Headless::CliUtil.stub(:application_exists?).and_return(false)
+
+      expect { headless.take_screenshot }.to raise_error
+    end
+
+    it "issues command to take screenshot" do
+      headless = Headless.new
+
+      Headless.any_instance.should_receive(:system)
+
+      headless.take_screenshot("/tmp/image.png")
+    end
+  end
+
+  context '#ensure_xvfb_is_running' do
+    let(:headless) { Headless.new }
+    before { headless.stub(:ensure_xvfb_is_running).and_call_original }
+
+
+    it 'store the start times and compares' do
+      headless.stub(:xvfb_running?).and_return(true)
+      Time.should_receive(:now).twice.and_call_original
+      headless.ensure_xvfb_is_running
+    end
+
+    it 'pauses briefly' do
+      headless.stub(:xvfb_running?).and_return(true)
+      headless.should_receive(:sleep).with(0.01)
+      headless.ensure_xvfb_is_running
+    end
+
+    it 'times out' do
+      headless.stub(:xvfb_running?).and_return(false)
+      times = [Time.now + 20, Time.now]
+      Time.stub(:now) do
+        times.pop
+      end
+      expect { headless.ensure_xvfb_is_running }.to raise_error(Headless::Exception)
+    end
+  end
+
+  context 'run' do
+    it 'instantiates, starts, yields and is destroyed' do
+      Headless.any_instance.should_receive(:start)
+      Headless.any_instance.should_receive(:destroy)
+      expect { |b| Headless.run({}, &b) }.to yield_with_args(Headless)
+    end
+  end
+
+private
+  def stub_environment
+    Headless::CliUtil.stub(:application_exists?).and_return(true)
+    Headless::CliUtil.stub(:read_pid).and_return(nil)
+    Headless::CliUtil.stub(:path_to)
+    Headless::CliUtil.stub(:path_to).with('Xvfb').and_return('/usr/bin/Xvfb')
+    Headless::CliUtil.stub(:path_to).with('ffmpeg').and_return('/usr/bin/ffmpeg')
+
+    # TODO this is wrong. But, as long as Xvfb is started inside the constructor (which is also wrong), I don't see another option to make tests pass
+    Headless.any_instance.stub(:ensure_xvfb_is_running).and_return(true)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+# Coveralls requires Ruby 1.9.2
+unless RUBY_VERSION == '1.8.7'
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+require 'headless'

data/spec/video_recorder_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Headless::VideoRecorder do
+  before do
+    stub_environment
+  end
+
+  describe "instantiation" do
+    before do
+      Headless::CliUtil.stub(:application_exists?).and_return(false)
+    end
+
+    it "throws an error if ffmpeg is not installed" do
+        lambda { Headless::VideoRecorder.new(99, "1024x768x32") }.should raise_error(Headless::Exception)
+    end
+  end
+
+  describe "#capture" do
+    it "starts ffmpeg" do
+      Headless::CliUtil.stub(:path_to).and_return('ffmpeg')
+      recorder = Headless::VideoRecorder.new(99, "1024x768x32")
+
+      Headless::CliUtil.should_receive(:fork_process).with(/#{recorder.capture_with}/, '/tmp/.headless_ffmpeg_99.pid', '/dev/null')
+      recorder.start_capture
+    end
+
+    it "starts ffmpeg with specified codec" do
+      Headless::CliUtil.stub(:path_to).and_return('ffmpeg')
+      recorder = Headless::VideoRecorder.new(99, "1024x768x32", {:codec => 'libvpx'})
+      Headless::CliUtil.should_receive(:fork_process).with(/#{recorder.capture_with}/, '/tmp/.headless_ffmpeg_99.pid', '/dev/null')
+      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 = 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
+        Headless::CliUtil.should_receive(:kill_process).with(pidfile, :wait => true)
+        File.should_receive(:exists?).with(tmpfile).and_return(true)
+        FileUtils.should_receive(:mv).with(tmpfile, filename)
+
+        expect(subject.stop_and_save(filename)).to eq(true)
+      end
+
+      it 'returns false after a rescued error when attempting to move file' do
+        FileUtils.stub(:mv).and_raise(Errno::EINVAL)
+        File.should_receive(:exists?).and_return(true)
+
+        expect(subject.stop_and_save(tmpfile)).to eq(false)
+      end
+
+      it 'returns nil when target file does not exist' do
+        File.stub(:exists?).and_return(false)
+
+        expect(subject.stop_and_save(tmpfile)).to eq(nil)
+      end
+    end
+
+    describe "using #stop_and_discard" do
+      it "stops video recording and deletes temporary file" do
+        Headless::CliUtil.should_receive(:kill_process).with(pidfile, :wait => true)
+        FileUtils.should_receive(:rm).with(tmpfile)
+
+        subject.stop_and_discard
+      end
+    end
+
+    describe '#capture_running?' do
+      it 'returns false unless the PID file exists' do
+        Headless::CliUtil.should_receive(:read_pid).with(pidfile)
+
+        expect(subject.capture_running?).to eq(false)
+      end
+    end
+  end
+
+private
+
+  def stub_environment
+    Headless::CliUtil.stub(:application_exists?).and_return(true)
+    Headless::CliUtil.stub(:fork_process).and_return(true)
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: headless-muse
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Leonid Shevtsov
+- Igor Afonov
+- Paul Geraghty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-17 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: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: |2
+      Headless is a Ruby interface for Xvfb. It allows you to create a headless display straight from Ruby code, hiding some low-level action.
+      It can also capture video and audio via ffmpeg and take screenshots.
+email: muse@appsthatcould.be
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- ".travis/setup.sh"
+- CHANGELOG
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- headless.gemspec
+- lib/headless.rb
+- lib/headless/cli_util.rb
+- lib/headless/video/video_recorder.rb
+- spec/cli_util_spec.rb
+- spec/headless_spec.rb
+- spec/spec_helper.rb
+- spec/video_recorder_spec.rb
+homepage: https://github.com/pgeraghty/headless
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby headless display interface
+test_files: []