headless 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ecdab81182658752d292ec13079deae78ed26241
-  data.tar.gz: 2f61437e9fe159aa2160e45263f731e20a43ffb8
+  metadata.gz: 36a92b0fed73ea273bf7cc4201b545be19d539e2
+  data.tar.gz: 29feae5dcdb2be2fa1d5147e009910d4c7f7c044
 SHA512:
-  metadata.gz: ca8f638bd43c1ddbda26171974b2c4bd11e0508d5c973c5ce35553658e8e647df8bb9027fa62e31c00fde382bf8f87ebd352d762904e3bddefc653169b8b5731
-  data.tar.gz: af8d46f3c14dbc2d0f8bea5bdfc04e7b2e917f878ac208abcf91f30c3bbc5f66582540c488b8a89b97f76527f4da0e825e0a6d6e6af715160d78b3ad4d7283a2
+  metadata.gz: 0a2c40f5cad61642e952565e3ab9666f00a4fe40eaee09ec99eb2facfff76bc4a87976cd2ca42dea02cf5b185d7d4f4d2a812ec44eb9c5a43ed016f9cbef12f6
+  data.tar.gz: ce8ea2ace8823b3507bcef65da7194f57b0fbce038f2fe0eef4f7a7dfbb69e7de678e4172c4761736297eb4b7d05f1e3128c93c6ee95cd6d42e81a18050fe773

data/.travis.yml

@@ -1,7 +1,9 @@
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
-  - ree
+  - 2.0
+  - 2.2
+before_install:
+  - "sudo apt-get update"
+  - "sudo apt-get install -y firefox xvfb libav-tools"
 script: "rspec"

data/CHANGELOG

@@ -1,3 +1,14 @@
+## 2.0.0 (2015-04-23)
+
+* Rewritten Xvfb launch using Process.spawn and avoiding a shell
+* Do not manually remove X11 lock file when stopping Xvfb; this isn’t conventional. Should eliminate some errors with not being able to find Xvfb
+* More informative error messages
+* Detect situation when Xvfb can’t listen to any sockets and raise corresponding error.
+* If video recorder provider is libav, use avconv binary instead of ffmpeg
+* Fixes to video recorder launch options (from @gpavlidi, @abotalov, @ynagorny, @WeAreFarmGeek)
+* Customize launch timeout (from @ShockwaveNN)
+* Properly working integration tests
+
 ## 1.0.2 (2014-06-03)
 
 * pass options correctly to ffmpeg (from @abotalov)

data/README.md

@@ -1,12 +1,12 @@
 # Headless [![Travis CI status](https://secure.travis-ci.org/leonid-shevtsov/headless.png)](http://travis-ci.org/leonid-shevtsov/headless)
 
-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.
+Headless is *the* Ruby interface for Xvfb. It allows you to create a headless 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 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)
+Documentation is available at [rubydoc.info](http://www.rubydoc.info/gems/headless)
 
 [Changelog](https://github.com/leonid-shevtsov/headless/blob/master/CHANGELOG)
 
@@ -120,19 +120,58 @@ After do |scenario|
 end
 ```
 
+### Video options
+
+When initiating Headless you may pass a hash with video options.
+
+```ruby
+headless = Headless.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
+* :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: [] 
+
 ## 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.
+Call `headless.take_screenshot` to take a screenshot. It needs two arguments:
 
-## Contributors
+- file_path - path where the image should be stored
+- options - options, that can be:
+    :using - :imagemagick or :xwd, :imagemagick is default, if :imagemagick is used, image format is determined by file_path extension
 
-* [Igor Afonov](http://iafonov.github.com) - video and screenshot capturing functionality.
+Screenshots can be taken by either using `import` (part of `imagemagick` library) or `xwd` utility.
 
----
+`import` captures a screenshot and saves it in the format of the specified file. It is convenient but not too fast as 
+it has to do the encoding synchronously.
 
-© 2011 Leonid Shevtsov, released under the MIT license
+`xwd` will capture a screenshot very fast and store it in its own format, which can then be converted to one 
+of other picture formats using, for example, netpbm utilities - `xwdtopnm <xwd_file> | pnmtopng > capture.png`.
 
+To install the necessary libraries on ubuntu:
 
+`import` - run `sudo apt-get install imagemagick`
+`xwd` - run `sudo apt-get install X11-apps` and if you are going to use netpbm utilities for image conversion - `sudo apt-get install netpbm`
+ 
+## 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
 
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/leonid-shevtsov/headless/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+If video is not recording, and there are no visible exceptions, try passing the following option to Headless to figure out the reason: `Headless.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.
+
+
+##[Contributors](https://github.com/leonid-shevtsov/headless/graphs/contributors)
+
+---
 
+&copy; 2011-2015 Leonid Shevtsov, released under the MIT license

data/headless.gemspec

@@ -3,7 +3,7 @@ spec = Gem::Specification.new do |s|
   s.email = 'leonid@shevtsov.me'
 
   s.name = 'headless'
-  s.version = '1.0.2'
+  s.version = '2.0.0'
   s.summary = 'Ruby headless display interface'
 
   s.description = <<-EOF
@@ -15,5 +15,6 @@ spec = Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency "rspec", "~> 2.6"
+  s.add_development_dependency "rspec", "~> 3"
+  s.add_development_dependency "selenium-webdriver"
 end

data/lib/headless.rb

@@ -44,8 +44,7 @@ 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
+  DEFAULT_XVFB_LAUNCH_TIMEOUT = 10
 
   class Exception < RuntimeError
   end
@@ -55,19 +54,30 @@ class Headless
 
   # The display dimensions
   attr_reader :dimensions
+  attr_reader :xvfb_launch_timeout
 
-  # Creates a new headless server, but does NOT switch to it immediately. Call #start for that
+  # 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?
+  # * +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?
+  # * +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
   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)
@@ -93,7 +103,13 @@ class Headless
   # Switches back from the headless server and terminates the headless session
   def destroy
     stop
-    CliUtil.kill_process(pid_filename)
+    CliUtil.kill_process(pid_filename, preserve_pid_file: true)
+  end
+
+  # Same as destroy, but waits for Xvfb process to terminate
+  def destroy_sync
+    stop
+    CliUtil.kill_process(pid_filename, preserve_pid_file: true, wait: true)
   end
 
   # Block syntax:
@@ -115,10 +131,17 @@ class Headless
     @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}"
+  def take_screenshot(file_path, options={})
+    using = options.fetch(:using, :imagemagick)
+    if using == :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}"
+    elsif using == :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}"
+    else
+      raise Headless::Exception.new('Unknown :using option value')
+    end
   end
 
 private
@@ -142,18 +165,30 @@ private
   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
+    out_pipe, in_pipe = IO.pipe
+    pid = Process.spawn(
+      CliUtil.path_to("Xvfb"), ":#{display}", "-screen", "0", dimensions, "-ac",
+      err: in_pipe)
+    in_pipe.close
+    raise Headless::Exception.new("Xvfb did not launch - something's wrong") unless pid
+    ensure_xvfb_is_running(out_pipe)
     return true
   end
 
-  def ensure_xvfb_is_running
+  def ensure_xvfb_is_running(out_pipe)
     start_time = Time.now
+    errors = ""
     begin
+      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
+      rescue IO::WaitReadable
+        # will retry next cycle
+      end
       sleep 0.01 # to avoid cpu hogging
-      raise Headless::Exception.new("Xvfb is frozen") if (Time.now-start_time)>=XVFB_LAUNCH_TIMEOUT
+      raise Headless::Exception.new("Xvfb launched but did not complete initialization") if (Time.now-start_time)>=@xvfb_launch_timeout
     end while !xvfb_running?
   end
 
@@ -180,4 +215,3 @@ private
     end
   end
 end
-

data/lib/headless/cli_util.rb

@@ -53,11 +53,13 @@ class Headless
           # Process.wait tried to wait on a dead process
         end
       end
-      
-      begin
-        FileUtils.rm pid_filename
-      rescue Errno::ENOENT
-        # pid file already removed
+
+      unless options[:preserve_pid_file]
+        begin
+          FileUtils.rm pid_filename
+        rescue Errno::ENOENT
+          # pid file already removed
+        end
       end
     end
   end

data/lib/headless/video/video_recorder.rb

@@ -5,8 +5,6 @@ class Headless
     attr_accessor :pid_file_path, :tmp_file_path, :log_file_path
 
     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)/]
 
@@ -15,6 +13,10 @@ class Headless
       @log_file_path = options.fetch(:log_file_path, "/dev/null")
       @codec = options.fetch(:codec, "qtrle")
       @frame_rate = options.fetch(:frame_rate, 30)
+      @provider = options.fetch(:provider, :libav)  # or :ffmpeg
+      @extra = Array(options.fetch(:extra, []))
+
+      CliUtil.ensure_application_exists!(provider_binary, "#{provider_binary} not found on your system. Install it or change video recorder provider")
     end
 
     def capture_running?
@@ -22,7 +24,8 @@ class Headless
     end
 
     def start_capture
-      CliUtil.fork_process("#{CliUtil.path_to('ffmpeg')} -y -r #{@frame_rate} -g 600 -s #{@dimensions} -f x11grab -i :#{@display} -vcodec #{@codec} #{@tmp_file_path}", @pid_file_path, @log_file_path)
+      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
@@ -49,5 +52,32 @@ class Headless
         # that's ok if the file doesn't exist
       end
     end
+
+    private
+
+    def provider_binary
+      @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),
+        "-y",
+        "-r #{@frame_rate}",
+        "-s #{dimensions}",
+        "-f x11grab",
+        "-i :#{@display}",
+        group_of_pic_size_option,
+        "-vcodec #{@codec}"
+      ].compact + @extra + [@tmp_file_path]).join(' ')
+    end
   end
 end

data/spec/headless_spec.rb

@@ -6,170 +6,201 @@ describe Headless do
     stub_environment
   end
 
-  context "instantiation" do
-    context "when Xvfb is not installed" do
-      before do
-        Headless::CliUtil.stub(:application_exists?).and_return(false)
-      end
+  describe 'launch options' do
+    before do
+      allow_any_instance_of(Headless).to receive(:ensure_xvfb_is_running).and_return(true)
+    end
 
-      it "raises an error" do
-        lambda { Headless.new }.should raise_error(Headless::Exception)
-      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
     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)
+    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")
+    end
+  end
 
-        headless = Headless.new
-      end
+  context 'with stubbed launch_xvfb' do
+    before do
+      allow_any_instance_of(Headless).to receive(:launch_xvfb).and_return(true)
+    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)
+    context "instantiation" do
+      context "when Xvfb is not installed" do
+        before do
+          allow(Headless::CliUtil).to receive(:application_exists?).and_return(false)
+        end
 
-        headless = Headless.new(:dimensions => "1024x768x16")
+        it "raises an error" do
+          expect { Headless.new }.to raise_error(Headless::Exception)
+        end
       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 "when Xvfb is already running" 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/.X100-lock').and_return(nil)
+        end
 
-      context "and display reuse is allowed" do
-        let(:options) { {:reuse => true} }
+        context "and display reuse is allowed" do
+          let(:options) { {:reuse => true} }
 
-        it "should reuse the existing Xvfb" do
-          Headless.new(options).display.should == 99
+          it "should reuse the existing Xvfb" do
+            expect(Headless.new(options).display).to eq 99
+          end
         end
-      end
 
-      context "and display reuse is not allowed" do
-        let(:options) { {:reuse => false} }
+        context "and display reuse is not allowed" do
+          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} }
+
+            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} }
+
+              it "should pick the next available display number" do
+                expect(Headless.new(options).display).to eq 100
+              end
+            end
+          end
+        end
+      end
 
-        it "should pick the next available display number" do
-          Headless.new(options).display.should == 100
+      context 'when Xvfb is started, but by another user' do
+        before do
+          allow(Headless::CliUtil).to receive(:read_pid).with('/tmp/.X99-lock') { raise Errno::EPERM }
+          allow(Headless::CliUtil).to receive(:read_pid).with('/tmp/.X100-lock').and_return(nil)
         end
 
-        context "and display number is explicitly set" do
-          let(:options) { {:reuse => false, :display => 99} }
+        context "and display autopicking is not allowed" do
+          let(:options) { {:autopick => false} }
 
-          it "should fail with an exception" do
-            lambda { Headless.new(options) }.should raise_error(Headless::Exception)
+          it "should fail with and exception" do
+            expect { Headless.new(options) }.to raise_error(Headless::Exception)
           end
+        end
 
-          context "and autopicking is allowed" do
-            let(:options) { {:reuse => false, :display => 99, :autopick => true} }
+        context "and display autopicking is allowed" do
+          let(:options) { {:autopick => true} }
 
-            it "should pick the next available display number" do
-              Headless.new(options).display.should == 100
-            end
+          it "should pick the next display number" do
+            expect(Headless.new(options).display).to eq 100
           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)
+    context "lifecycle" do
+      let(:headless) { Headless.new }
+      describe "#start" do
+        it "switches to the headless server" do
+          expect(ENV['DISPLAY']).to eq ":31337"
+          headless.start
+          expect(ENV['DISPLAY']).to eq ":99"
+        end
       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)
+      describe "#stop" do
+        it "switches back from the headless server" do
+          expect(ENV['DISPLAY']).to eq ":31337"
+          headless.start
+          expect(ENV['DISPLAY']).to eq ":99"
+          headless.stop
+          expect(ENV['DISPLAY']).to eq ":31337"
         end
       end
 
-      context "and display autopicking is allowed" do
-        let(:options) { {:autopick => true} }
+      describe "#destroy" do
+        before do
+          allow(Headless::CliUtil).to receive(:read_pid).and_return(4444)
+        end
+
+        it "switches back from the headless server and terminates the headless session" do
+          expect(Process).to receive(:kill).with('TERM', 4444)
 
-        it "should pick the next display number" do
-          Headless.new(options).display.should == 100
+          expect(ENV['DISPLAY']).to eq ":31337"
+          headless.start
+          expect(ENV['DISPLAY']).to eq ":99"
+          headless.destroy
+          expect(ENV['DISPLAY']).to eq ":31337"
         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
+    context "#video" do
+      let(:headless) { Headless.new }
 
-    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"
+      it "returns video recorder" do
+        expect(headless.video).to be_a_kind_of(Headless::VideoRecorder)
       end
-    end
 
-    describe "#destroy" do
-      before do
-        Headless::CliUtil.stub(:read_pid).and_return(4444)
+      it "returns the same instance" do
+        recorder = headless.video
+        expect(headless.video).to eq recorder
       end
+    end
 
-      it "switches back from the headless server and terminates the headless session" do
-        Process.should_receive(:kill).with('TERM', 4444)
+    context "#take_screenshot" do
+      let(:headless) { Headless.new }
 
-        ENV['DISPLAY'].should == ":31337"
-        headless.start
-        ENV['DISPLAY'].should == ":99"
-        headless.destroy
-        ENV['DISPLAY'].should == ":31337"
+      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)
       end
-    end
-  end
 
-  context "#video" do
-    let(:headless) { Headless.new }
+      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)
 
-    it "returns video recorder" do
-      headless.video.should be_a_kind_of(Headless::VideoRecorder)
-    end
+        expect { headless.take_screenshot('a.png') }.to raise_error(Headless::Exception)
+      end
 
-    it "returns the same instance" do
-      recorder = headless.video
-      headless.video.should be_eql(recorder)
-    end
-  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)
 
-  context "#take_screenshot" do
-    let(:headless) { Headless.new }
+        expect { headless.take_screenshot('a.png', :using => :imagemagick) }.to raise_error(Headless::Exception)
+      end
 
-    it "raises an error if imagemagick is not installed" do
-      Headless::CliUtil.stub(:application_exists?).and_return(false)
+      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)
 
-      lambda { headless.take_screenshot }.should raise_error(Headless::Exception)
-    end
+        expect { headless.take_screenshot('a.png', :using => :xwd) }.to raise_error(Headless::Exception)
+      end
 
-    it "issues command to take screenshot" do
-      headless = Headless.new
+      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")
+        headless.take_screenshot("/tmp/image.png")
+      end
 
-      Headless.any_instance.should_receive(:system)
+      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)
+      end
 
-      headless.take_screenshot("/tmp/image.png")
+      it "issues command to take screenshot, with using: :xwd" do
+        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)
+      end
     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).and_return("/usr/bin/Xvfb")
-
-    # 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)
+    allow(Headless::CliUtil).to receive(:application_exists?).and_return(true)
+    allow(Headless::CliUtil).to receive(:read_pid).and_return(nil)
+    allow(Headless::CliUtil).to receive(:path_to).and_return("/usr/bin/Xvfb")
   end
 end

data/spec/integration_spec.rb

@@ -0,0 +1,44 @@
+require 'headless'
+require 'selenium-webdriver'
+
+describe 'Integration test' do
+  let!(:headless) { Headless.new }
+  before { headless.start }
+
+  after { headless.destroy_sync }
+
+  it 'should use xvfb' do
+    work_with_browser
+  end
+
+  it 'should record screenshots' do
+    headless.take_screenshot("test.jpg")
+    expect(File.exist?("test.jpg")).to eq true
+  end
+
+  # Unfortunately the libav version that ships with Ubuntu 12.04 has
+  # buggy X11 capture.
+  it 'should record video with ffmpeg', pending: ENV['TRAVIS'] 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
+    expect {
+      FileUtils.mv("/tmp/.X#{headless.display}-lock", "/tmp/headless-test-tmp")
+      Headless.new(display: headless.display, reuse: false)
+    }.to raise_error(Headless::Exception, /troubleshooting guide/)
+    FileUtils.mv("/tmp/headless-test-tmp", "/tmp/.X#{headless.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

@@ -7,30 +7,39 @@ describe Headless::VideoRecorder do
 
   describe "instantiation" do
     before do
-      Headless::CliUtil.stub(:application_exists?).and_return(false)
+      allow(Headless::CliUtil).to receive(: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)
+      expect { Headless::VideoRecorder.new(99, "1024x768x32") }.to raise_error(Headless::Exception)
     end
   end
 
   describe "#capture" do
+    before do
+      allow(Headless::CliUtil).to receive(:path_to).and_return('ffmpeg')
+    end
+
     it "starts ffmpeg" do
-      Headless::CliUtil.stub(:path_to).and_return('ffmpeg')
-      Headless::CliUtil.should_receive(:fork_process).with(/ffmpeg -y -r 30 -g 600 -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 -g 600 -vcodec qtrle [^ ]+$/, "/tmp/.headless_ffmpeg_99.pid", '/dev/null')
 
       recorder = Headless::VideoRecorder.new(99, "1024x768x32")
       recorder.start_capture
     end
 
     it "starts ffmpeg with specified codec" do
-      Headless::CliUtil.stub(:path_to).and_return('ffmpeg')
-      Headless::CliUtil.should_receive(:fork_process).with(/ffmpeg -y -r 30 -g 600 -s 1024x768 -f x11grab -i :99 -vcodec libvpx/, "/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 -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')
+
+      recorder = Headless::VideoRecorder.new(99, "1024x768x32", {:provider => :ffmpeg})
+      recorder.start_capture
+    end
   end
 
   context "stopping video recording" do
@@ -46,9 +55,9 @@ describe Headless::VideoRecorder do
 
     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(Headless::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
@@ -56,8 +65,8 @@ describe Headless::VideoRecorder do
 
     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)
+        expect(Headless::CliUtil).to receive(:kill_process).with(pidfile, :wait => true)
+        expect(FileUtils).to receive(:rm).with(tmpfile)
 
         subject.stop_and_discard
       end
@@ -67,7 +76,7 @@ describe Headless::VideoRecorder do
 private
 
   def stub_environment
-    Headless::CliUtil.stub(:application_exists?).and_return(true)
-    Headless::CliUtil.stub(:fork_process).and_return(true)
+    allow(Headless::CliUtil).to receive(:application_exists?).and_return(true)
+    allow(Headless::CliUtil).to receive(:fork_process).and_return(true)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: headless
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Leonid Shevtsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-03 00:00:00.000000000 Z
+date: 2015-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -30,14 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        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: |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.
 email: leonid@shevtsov.me
@@ -57,6 +71,7 @@ files:
 - lib/headless/cli_util.rb
 - lib/headless/video/video_recorder.rb
 - spec/headless_spec.rb
+- spec/integration_spec.rb
 - spec/video_recorder_spec.rb
 homepage: http://leonid.shevtsov.me/en/headless
 licenses: []
@@ -78,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Xvfb
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby headless display interface