shrimple 0.8.0

data/spec/shrimple/process_monitor_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+
+# the other Shrimple specs exercise this class pretty well
+# it would take a lot of mocking and stubbing to do it here too.
+
+
+describe Shrimple::ProcessMonitor do
+  it "will add a process" do
+    processes = Shrimple::ProcessMonitor.new(1)
+    # this should not raise an exception
+    # not using expect(...).not_to raise_exception since that eats all raised expections.
+    processes._add(Object.new)
+  end
+
+  it "won't launch too many processes" do
+    processes = Shrimple::ProcessMonitor.new(0)
+    expect { processes._add(Object.new) }.to raise_exception(Shrimple::TooManyProcessesError)
+  end
+
+  it "can disable the process counter" do
+    processes = Shrimple::ProcessMonitor.new(-1)
+    processes._add(Object.new)
+  end
+
+  it "counts and kills multiple processes" do
+    expect(Shrimple.processes.count).to eq 0
+    process = Shrimple::Process.new(['sleep', '20'], StringIO.new, StringIO.new, StringIO.new)
+    process = Shrimple::Process.new(['sleep', '20'], StringIO.new, StringIO.new, StringIO.new)
+    process = Shrimple::Process.new(['sleep', '20'], StringIO.new, StringIO.new, StringIO.new)
+    process = Shrimple::Process.new(['sleep', '20'], StringIO.new, StringIO.new, StringIO.new)
+    expect(Shrimple.processes.count).to eq 4
+    Shrimple.processes.first.kill
+    expect(Shrimple.processes.count).to eq 3
+    # can't use Array#each since calling delete in the block causes it to screw up
+    Shrimple.processes.kill_all
+    expect(Shrimple.processes.count).to eq 0
+  end
+
+  it "waits for multiple processes" do
+    expect(Shrimple.processes.count).to eq 0
+    # these sleep durations might be too small, depends on machine load and scheduling.
+    # if you're seeing threads finishing in the wrong order, try increasing them 10X.
+    process1 = Shrimple::Process.new(['sleep', '.3'], StringIO.new, StringIO.new, StringIO.new)
+    process2 = Shrimple::Process.new(['sleep', '.1'], StringIO.new, StringIO.new, StringIO.new)
+    process3 = Shrimple::Process.new(['sleep', '.2'], StringIO.new, StringIO.new, StringIO.new)
+    expect(Shrimple.processes.count).to eq 3
+
+    child = Shrimple.processes.wait_next
+    expect(child).to eq process2
+    expect(child.finished?).to eq true
+    expect(child.success?).to eq true
+    expect(Shrimple.processes.count).to eq 2
+
+    child = Shrimple.processes.wait_next
+    expect(child).to eq process3
+    expect(Shrimple.processes.count).to eq 1
+
+    child = Shrimple.processes.wait_next
+    expect(child).to eq process1
+    expect(Shrimple.processes.count).to eq 0
+  end
+
+  it "handles waiting for zero processes" do
+    expect {
+      child = Shrimple.processes.wait_next
+    }.to raise_exception(ThreadsWait::ErrNoWaitingThread)
+  end
+end

data/spec/shrimple/process_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+# run this to ensure there are no deadlock / process synchronization problems:
+#    while rspec spec/shrimple_process_spec.rb ; do echo -n ; done
+
+describe Shrimple::Process do
+  let(:chin)  { StringIO.new('small instring') }
+  let(:chout) { StringIO.new }
+  let(:cherr) { StringIO.new }
+
+  it "has a working drain method" do
+    bigin = StringIO.new('x' * 1024 * 1024) # at least 1 MB of data to test drain loop
+    process = Shrimple::Process.new('cat', bigin, chout, cherr)
+    process.stop
+    expect(chout.string).to eq bigin.string
+    expect(process.finished?).to eq true
+  end
+
+  it "waits until a sleeping command is finished" do
+    # pile a bunch of checks into this test so we only have to sleep once
+    expect(Shrimple.processes.count).to eq 0
+    claimed = nil
+
+    elapsed = time do
+      # echo -n doesn't work here because of platform variations
+      # and for some reason jruby requires the explicit subshell; mri launches it automatically
+      process = Shrimple::Process.new('/bin/sh -c "sleep 0.1 && printf done."', chin, chout, cherr)
+      expect(Shrimple.processes.count).to eq 1
+      process.stop
+      expect(process.start_time).not_to eq nil
+      expect(process.stop_time).not_to eq nil
+      claimed = process.stop_time - process.start_time
+      expect(chout.string).to eq 'done.'
+      expect(process.finished?).to eq true
+      expect(process.success?).to eq true
+    end
+
+    # ensure process elapsed time is in the ballpark
+    expect(elapsed).to be >= 0.1
+    expect(claimed).to be >= 0.1
+    expect(claimed).to be <= elapsed
+
+    expect(Shrimple.processes.count).to eq 0
+    expect(chout.closed_read?).to eq true
+    expect(cherr.closed_read?).to eq true
+  end
+
+  it "has a working kill method" do
+    elapsed = time do
+      process = Shrimple::Process.new(['sleep', '0.5'], chin, chout, cherr)
+
+      expect(process.finished?).to eq false
+      expect(process.killed?).to eq false
+      expect(process.success?).to eq false
+      expect(process.timed_out?).to eq false
+
+      process.kill
+
+      expect(process.finished?).to eq true
+      expect(process.killed?).to eq true
+      expect(process.success?).to eq false
+      expect(process.timed_out?).to eq false
+    end
+
+    expect(elapsed).to be < 0.5
+    expect(chout.closed_read?).to eq true
+    expect(cherr.closed_read?).to eq true
+  end
+
+  it "handles invalid commands" do
+    expect {
+      expect(Shrimple.processes.count).to eq 0
+      process = Shrimple::Process.new(['ThisCmdDoes.Not.Exist.'], chin, chout, cherr)
+      raise "we shouldn't get here"
+    }.to raise_error(/[Nn]o such file/)
+    expect(Shrimple.processes.count).to eq 0
+  end
+
+  it "has a working timeout" do
+    elapsed = time do
+      process = Shrimple::Process.new(['sleep', '10'], chin, chout, cherr, 0)
+    end
+    expect(elapsed).to be < 0.5
+  end
+end

data/spec/shrimple_long_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+require 'dimensions'
+
+# this file contains the time-consuming tests that shell out to phantomjs
+
+
+def pdf_valid?(io)
+  # quick & dirty check
+  case io
+    when File
+      io.read[0...4] == "%PDF"
+    when String
+      io[0...4] == "%PDF" || File.open(io).read[0...4] == "%PDF"
+  end
+end
+
+
+def prepare_file outfile
+  # TODO: there MUST be a better way of handling file output in rspec
+  # (can't mock file ops because the output is coming from phantomjs)
+  File.delete(outfile) if File.exists?(outfile)
+  return '/tmp/' + outfile
+end
+
+
+describe Shrimple do
+  it "echoes its arguments" do
+    s = Shrimple.new(renderer: 'spec/parse_and_print_stdin.js')
+    output = s.render
+    result = JSON.parse(output.stdout)
+    expect(result['renderer']).to eq 'spec/parse_and_print_stdin.js'
+    expect(result['processed']).to eq true   # added by the phantom script
+    expect(output.stderr).to eq ""
+  end
+
+
+  # well I give up.  can't find an item settable by --config that I can read in js.  :(
+  # https://github.com/ariya/phantomjs/issues/12265
+  #
+  # it "sets a command-line arg" do
+  #   s = Shrimple.new
+  #   s.config.loadImages = false
+  #   s.config.autoLoadImages = false
+  #   s.renderer = 'render_max_disk_cache.js'
+  #   s.render
+  # end
+
+
+  it "renders text to a string" do
+    callback_param = nil
+    s = Shrimple.new
+    s.onSuccess = Proc.new do |result|
+      # make sure this process isn't removed from the process table
+      # until after this callback returns.
+      sleep(0.2)
+      expect(Shrimple.processes.count).to eq 1
+      callback_param = result
+    end
+    s.onError = Proc.new { fail }
+    result = s.render_text("file://#{example_html}")
+    output = result.stdout   # TODO: get rid of this line
+    expect(output).to eq "Hello World!\n"
+    expect(callback_param).to eq result
+  end
+
+  it "renders text to a file" do
+    outfile = prepare_file('shrimple-test-output.txt')
+    s = Shrimple.new
+    s.render_text("file://#{example_html}", to: outfile)
+    output = File.read(outfile)
+    expect(output).to eq "Hello World!\n"
+    File.delete(outfile)
+  end
+
+  it "renders html to a string" do
+    s = Shrimple.new
+    result = s.render_html("file://#{example_html}")
+    output = result.stdout   # TODO: get rid of this line
+    expect(output).to include "<h1>Hello World!</h1>"
+  end
+
+  it "handles a missing file" do
+    # also ensures failures's stderr appears in the exception
+    callback_param = nil
+    s = Shrimple.new
+    s.onSuccess = Proc.new { fail }
+    s.onError = Proc.new { |result| callback_param = result }
+    expect {
+      s.render_text("file://this-does-not-exist")
+    }.to raise_exception(Shrimple::PhantomError, /Unable to load.*this-does-not-exist/)
+    expect(callback_param).to be_a Shrimple::Phantom
+  end
+
+  it "handles a missing file in background mode" do
+    callback_param = nil
+    s = Shrimple.new(background: true)
+    s.onSuccess = Proc.new { fail }
+    s.onError = Proc.new { |result| callback_param = result }
+    result = s.render_text("file://this-does-not-exist")
+    child = Shrimple.processes.wait_next
+
+    expect(child).to eq result
+    expect(result.success?).to eq false
+    expect(result.stderr).to match(/Unable to load.*this-does-not-exist/)
+    expect(callback_param).to eq result
+  end
+
+  it "handles phantomjs complaining about a missing render script" do
+    s = Shrimple.new(renderer: 'this-does-not-exist')
+    expect {
+      s.render_text("file://#{example_html}")
+    }.to raise_exception(Shrimple::PhantomError, /Can't open 'this-does-not-exist'/)
+  end
+
+  it "handles phantomjs complaining about a missing render script in background mode" do
+    s = Shrimple.new(renderer: 'this-does-not-exist', background: true)
+    result = s.render_text("file://#{example_html}")
+    child = Shrimple.processes.wait_next
+
+    expect(child).to eq result
+    expect(result.success?).to eq false
+    expect(result.stderr).to match(/Can't open 'this-does-not-exist'/)
+  end
+
+  # # it's hopeless: https://github.com/ariya/phantomjs/issues/10687
+  #
+  # it "handles a syntax error in a render script" do
+  #   s = Shrimple.new(renderer: 'spec/syntax_error.js')
+  #   expect {
+  #     s.render_text("file://#{example_html}")
+  #   }.to raise_exception(/Can't open 'this-does-not-exist'/)
+  # end
+
+  it "supports a debugging mode" do
+    # isn't there a better way of resetting global variables in rspec?
+    olderr = $stderr
+    begin
+      $stderr = StringIO.new
+      s = Shrimple.new(debug: true)
+      s.render_text("file://#{example_html}")
+
+      expect($stderr.string).to match /^COMMAND: \[.*phantomjs.*render.js"\]/
+      expect($stderr.string).to match /^STDIN: {.*"debug":true.*}/
+    ensure
+      $stderr = olderr
+    end
+  end
+
+  it "renders a pdf to a file" do
+    outfile = prepare_file('shrimple-test-output.pdf')
+    s = Shrimple.new(to: outfile)
+    s.render_pdf "file://#{example_html}"
+    expect(File.exists? outfile).to eq true
+    expect(pdf_valid?(File.new(outfile))).to eq true
+  end
+
+  it "renders a png to a file" do
+    outfile = prepare_file('shrimple-test-output.png')
+    s = Shrimple.new
+    p = s.render_png "file://#{example_html}", output: outfile
+
+    expect(File.exists? outfile).to eq true
+    dimensions = Dimensions.dimensions(outfile)
+    expect(dimensions[0]).to eq 400   # phantomjs default width
+    expect(dimensions[1]).to eq 300   # phantomjs default height
+
+    # when dimensions allows reading the filetype, add that check here
+    # https://github.com/cleanio/dimensions/commit/c61ad05c354feb1063bfbdc97c1ec5456c9ad43a
+  end
+
+  it "renders a png to a stream" do
+    s = Shrimple.new(page: {viewportSize: { width: 555, height: 555 }} )
+    s.page.zoomFactor = 0.75
+    output = s.render_png "file://#{example_html}"
+
+    # todo: would be great if we could attach Dimensions straight to the io object reading the results
+    # instead of needing to flush the result to a memory buffer and wrapping that in a new stringio
+    dimensions = Dimensions(StringIO.new(output.stdout))    
+    expect(dimensions.width).to eq 555
+    expect(dimensions.height).to eq 555
+  end
+
+  it "renders a jpeg to a file" do
+    outfile = prepare_file('shrimple-test-output.jpg')
+    s = Shrimple.new
+    s.page.viewportSize = { width: 320, height: 240 }
+    s.output = outfile
+    output = s.render_jpeg "file://#{example_html}"
+
+    expect(File.exists? outfile).to eq true
+    dimensions = Dimensions.dimensions(outfile)
+    expect(dimensions[0]).to eq 320
+    expect(dimensions[1]).to eq 240
+  end
+
+  it "renders a gif to memory" do
+    s = Shrimple.new
+    s.page.viewportSize = { width: 213, height: 214 }
+    output = s.render_gif "file://#{example_html}"
+
+    dimensions = Dimensions(StringIO.new(output.stdout))    
+    expect(dimensions.width).to eq 213
+    expect(dimensions.height).to eq 214
+  end
+end

data/spec/shrimple_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+# Mostly tests the Shrimple API.  Other specs test the internals.
+
+
+describe Shrimple do
+  # we send this in every request until Phantom fixes its bug, see default_config.rb
+  let(:custom_headers) { {"page" => {"customHeaders"=>{"Accept-Encoding"=>"identity"}}} }
+
+  it "automatically finds the executable and renderer" do
+    s = Shrimple.new
+    expect(File.executable? s.executable).to be true
+    expect(File.exists? s.renderer).to be true
+  end
+
+  it "can be told the executable and renderer" do
+    # these don't need to be real executables since they're never called
+    s = Shrimple.new(executable: '/bin/sh', renderer: example_html)
+    expect(s.executable).to eq '/bin/sh'
+    expect(s.renderer).to eq example_html
+  end
+
+  it "dies if specified executable can't be found" do
+    s = Shrimple.new(executable: '/bin/THIS_FILE_DOES.not.Exyst')
+    expect { s.render 'http://be.com' }.to raise_exception(/[Nn]o such file/)
+  end
+
+  it "dies if default executable can't be found" do
+    expect { Shrimple.new.render('http://be.com', executable: nil) }.to raise_exception(/PhantomJS not found/)
+  end
+
+  it "allows a bunch of different ways to set options" do
+    s = Shrimple.new(executable: '/bin/sh', renderer: example_html, render: {quality: 50})
+
+    s.executable = '/bin/cat'
+    s.page.paperSize.orientation = 'landscape'
+    s[:page][:settings][:userAgent] = 'webkitalike'
+    s.options.page.zoomFactor = 0.25
+
+    mock_phantom = Object.new
+    expect(mock_phantom).to receive(:wait).once
+
+    allow(Shrimple::Phantom).to receive(:new).once do |opts|
+      expect(opts.to_hash).to eq(Hashie::Mash.new({
+        input: 'infile',
+        output: 'outfile',
+        executable: '/bin/cat',
+        renderer: example_html,
+        render: { quality: 50 },
+        page: {
+          paperSize: { orientation: 'landscape' },
+          settings: { userAgent: 'webkitalike' },
+          zoomFactor: 0.25
+        }
+      }).merge(custom_headers).to_hash)
+      mock_phantom
+    end
+
+    s.render 'infile', to: 'outfile'
+  end
+
+  it "runs in the background" do
+    s = Shrimple.new(executable: '/bin/cat', renderer: 'tt.js', background: true)
+
+    mock_phantom = Object.new
+    expect(mock_phantom).not_to receive(:wait)
+    allow(Shrimple::Phantom).to receive(:new).once.and_return(mock_phantom)
+
+    p = s.render 'infile'
+  end
+
+  it "special-cases input as the first argument" do
+    s = Shrimple.new
+    s.merge!(executable: nil, renderer: nil)
+    # can either start with a value for input
+    expect(s.get_full_options("input", to: "output")).
+      to eq({'input' => 'input', 'output' => 'output'}.merge(custom_headers))
+    # or just use hashes all the way through
+    expect(s.get_full_options(input: "eenput", output: "ootput")).
+      to eq({'input' => 'eenput', 'output' => 'ootput'}.merge(custom_headers))
+  end
+
+  it "has options with indifferent access" do
+    s = Shrimple.new
+    s.merge!('executable' => nil, renderer: nil)
+    expect(s.get_full_options(executable: 'symbol', 'executable' => 'string')).to eq({'executable' => 'string'}.merge(custom_headers))
+    s.merge!(executable: 'symbol')
+    expect(s.get_full_options(executable: 'symbol')).to eq({'executable' => 'symbol'}.merge(custom_headers))
+    expect(Shrimple.compact!(s.to_hash)).to eq({'executable' => 'symbol'}.merge(custom_headers))
+  end
+
+  it "has a working compact" do
+    expect(Shrimple.compact!({
+      a: nil,
+      b: { c: nil },
+      d: { e: { f: "", g: 1 } },
+      h: false
+    })).to eq({
+      d: { e: { g: 1 }},
+      h: false
+    })
+
+    expect(Shrimple.compact!({})).to eq({})
+  end
+
+  it "has a working deep_dup" do
+    x = { a: 1, b: { c: 2, d: false, e:[1,2,3] }}
+    y = Shrimple.deep_dup(x)
+
+    x[:a] = 2
+    x[:b].delete(:e)
+    x[:b][:d] = true
+    x.delete(:b)
+
+    # y should be unchanged since we dup'd it
+    expect(x).to eq({a: 2})
+    expect(y).to eq({a: 1, b: { c: 2, d: false, e: [1, 2, 3] }})
+  end
+end