shoot 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e10dbd0bfc3ff30229957a90d50477a671c0aab
-  data.tar.gz: e619ce09449a34dbceffa72e9fc41ce013897bae
+  metadata.gz: 152d35943f02692f5c763b5928e6dcfcf0c51e29
+  data.tar.gz: 51152e373355366c011881fbb8b6aecca33444a8
 SHA512:
-  metadata.gz: a4f0d7327b131b72f4d7322cc8adeb8aa3836c152cdce5137aa08bfafdeca6b66532b5769629ff930a2e20b0c6df6729c464a156e5e5be7ad76481f29274b99c
-  data.tar.gz: 0feca96a4fa38dbb160d0717cc7ae4ad2bd717faefa8a511aa6d998058cda866540ec27c7264f53d5461c0f785fc4b94fea98fcb7a9c450fb94436c0921bac53
+  metadata.gz: 8ae30e0c7ba313cab8298b866d9ffa0750c0e16a26242d8eebb5bf77efff96db56b27ab5c1c9d81d110f1ea92c8de0ca9df132a0221573c5c3c50106273e1a7d
+  data.tar.gz: 9edf0ae57d9cea0a13df09202a63f6fe9c4e08aa4b0e5ebbe079d143a2578a2115834b0259d4e69c4ed9d1d93fdbb7761c3f95eb6df14f09cfa103baa235f54b

data/Changelog.md

@@ -1,3 +1,11 @@
+# 2.1.0
+
+- Adds Ngrok and NgrokPow class to make forwarding much easier;
+- Adds a list of _ad hoc_ emulators BrowserStack provides for iPhones/iPads that is not on the API; 😢
+- Writes a backtrace files in the appropriate folder if the thing explodes (both external and internal issues);
+- Updates the Changelog to contain this.
+
+
 # 2.0.0
 
 - Adds interactive mode (`shoot -i`);

data/README.md

@@ -145,6 +145,38 @@ You got the idea.
 	shoot update                          # Update browser list (WARNING: will override active browsers)
 	shoot version, --version, -v          # Shoot version
 
+### Using ngrok
+
+In order to access your local development environment on BrowserStack you need to forward it somehow to the external work (a.k.a. the internet). BrowserStack has it's own forwarded, but ngrok is better. If you wanna use it:
+
+1. Install it from [https://ngrok.com/download](https://ngrok.com/download)
+
+2. Enable subdomains by registering.
+
+3. Use the `Shoot::Ngrok` class in your test, like this:
+
+``` ruby
+  def my_test
+    my_server = Shoot::Ngrok(12345)
+    visit my_server.url
+  end
+```
+
+Where `12345` is the port of your local server. The default is `3000`, since I believe you're probably using Rails.
+
+#### What if I'm using pow?
+
+If you're using pow, skip step 3 above and do it like this instead:
+
+``` ruby
+  def my_test
+    my_server = Shoot::NgrokPow(:my_server_folder)
+    visit my_server.url
+  end
+```
+
+NgrokPow will create another symlink of your server folder with a unique name and forward it correctly to ngrok. This symlink will be properly removed at the end of the execution of shoot.
+
 ## Contributing
 
 1. Fork it ( https://github.com/joaomilho/shoot/fork )

data/lib/shoot/browser.rb

@@ -0,0 +1,119 @@
+require 'json'
+
+class Hash
+  def symbolize_keys
+    self.keys.each do |key|
+      self[key.to_sym] = self.delete(key)
+    end
+    self
+  end
+end
+
+
+module Shoot
+  class Browser
+    BROWSERS_PATH = '.screenshots/.browsers.json'
+    EMULATORS_UNAVAILABLE_ON_THE_API = ["iPad 3rd", "iPad 3rd (6.0)", "iPad Mini", "iPad 4th", "iPhone 4S", "iPhone 4S (6.0)", "iPhone 5", "iPhone 5S"].map do |device|
+      {
+        browser: "iPhone",
+        os: "MAC",
+        device: device,
+        emulator: true
+      }
+    end
+
+    def self.all
+      @@all ||= fetch_json.map { |browser| Browser.new(browser.symbolize_keys) }
+    end
+
+    def self.activate(ids)
+      update(select_by_ids(ids), :activate)
+    end
+
+    def self.deactivate(ids)
+      update(select_by_ids(ids), :deactivate)
+    end
+
+    def self.deactivate_all
+      update(active, :deactivate)
+    end
+
+    def self.active
+      all.select(&:active)
+    end
+
+    def self.update_json
+      File.write(BROWSERS_PATH, JSON.dump(fetch_and_prepare))
+    end
+
+    def self.filter(filter)
+      all.select { |browser| browser.inspect =~ /#{filter}/i }
+    end
+
+    def self.select_by_ids(ids)
+      ids = ids.map(&:to_i)
+      all.select { |browser| ids.include?(browser.id) }
+    end
+
+    def self.save
+      File.write(BROWSERS_PATH, JSON.pretty_generate(all.map(&:to_h)))
+    end
+
+    attr_reader :id, :os, :os_version, :browser, :device, :browser_version, :active, :emulator
+    def initialize(id:, os:, browser:, device:, os_version: nil, browser_version: nil, active: false, emulator: false)
+      @id = id
+      @os = os
+      @os_version = os_version
+      @browser = browser
+      @device = device
+      @browser_version = browser_version
+      @active = active
+      @emulator = emulator
+    end
+
+    def activate
+      @active = true
+    end
+
+    def deactivate
+      @active = false
+    end
+
+    def to_h
+      {
+        id: id,
+        os: os,
+        os_version: os_version,
+        browser: browser,
+        device: device,
+        browser_version: browser_version,
+        active: active,
+        emulator: emulator
+      }
+    end
+
+    private
+
+    def self.update(browsers, action)
+      browsers.map(&action)
+      save
+      browsers
+    end
+
+    def self.fetch_json
+      update_json unless File.exist?(BROWSERS_PATH)
+      JSON.parse(File.read(BROWSERS_PATH))
+    end
+
+    def self.fetch_and_prepare
+      require 'rest_client'
+      json = JSON.parse(RestClient.get("https://#{ENV['BROWSERSTACK_USER']}:#{ENV['BROWSERSTACK_KEY']}@www.browserstack.com/automate/browsers.json"))
+      json += EMULATORS_UNAVAILABLE_ON_THE_API
+      json.each_with_index do |browser, index|
+        browser['id'] = index
+      end
+      json
+    end
+
+  end
+end

data/lib/shoot/cli.rb

@@ -1,12 +1,13 @@
 require 'thor'
-require 'json'
+require 'benchmark'
 require 'highline/import'
 
 module Shoot
   class CLI < Thor
+    include UI
+
     require 'fileutils'
     FileUtils::mkdir_p '.screenshots'
-    BROWSERS_PATH = '.screenshots/.browsers.json'
     map %w[--version -v] => :version
     map %w[--interactive -i] => :interactive
 
@@ -15,29 +16,28 @@ module Shoot
       puts Shoot::VERSION
     end
 
+    INTERACTIVE_COMMANDS = {
+      active:         ->(_)     { active },
+      activate:       ->(params){ activate(*params.split(" ")) },
+      deactivate:     ->(params){ deactivate(*params.split(" ")) },
+      deactivate_all: ->(_)     { deactivate_all },
+      list:           ->(params){ list(params) },
+      open:           ->(_)     { open },
+      test:           ->(params){ test(params) },
+      scenario:       ->(params){ scenario(params) },
+      update:         ->(_)     { update },
+      exit:           ->(_)     { @exit = true }
+    }
+
     desc 'interactive, --interactive, -i', 'Interactive mode'
     def interactive
       @exit = false
-
-      available_commands = {
-        active:         ->(_)     { active },
-        activate:       ->(params){ activate(*params.split(" ")) },
-        deactivate:     ->(params){ deactivate(*params.split(" ")) },
-        deactivate_all: ->(_)     { deactivate_all },
-        list:           ->(params){ list(params) },
-        open:           ->(_)     { open },
-        test:           ->(params){ test(params) },
-        scenario:       ->(params){ scenario(params) },
-        update:         ->(_)     { update },
-        exit:           ->(_)     { @exit = true }
-      }
-
       while ! @exit
         choose do |menu|
           menu.layout = :menu_only
           menu.shell  = true
 
-          available_commands.each do |command_name, command_action|
+          INTERACTIVE_COMMANDS.each do |command_name, command_action|
             menu.choice(command_name, desc(command_name)){|_, details| command_action.call(details) }
           end
         end
@@ -46,27 +46,27 @@ module Shoot
 
     desc 'open', 'Opens all screenshots taken'
     def open
-      open_all_screenshots
+      `open #{Dir.glob(".screenshots/**/*.png").join(" ")}`
     end
 
     desc 'list [FILTER]', 'List all platforms. Optionally passing a filter'
     def list(filter = nil)
-      table json.select { |p| p.inspect =~ /#{filter}/i }
+      table filter ? Browser.filter(filter) : Browser.all
     end
 
     desc 'active', 'List active platforms.'
     def active
-      table _active
+      table Browser.active
     end
 
     desc 'scenario PATH', 'Runs the given scenario or all files in a directory on all active platforms'
     def scenario(path)
-      files = File.directory?(path) ? Dir.glob("#{path}/*.rb") : [path]
+      scenarios = File.directory?(path) ? Dir.glob("#{path}/*.rb") : [path]
 
       elapsed_time do
-        _active.each do |config|
-          files.each do |file|
-            run file, config
+        Browser.active.each do |browser|
+          scenarios.each do |scenario|
+            run scenario, browser
           end
         end
         print set_color("\nAll tests finished", :blue)
@@ -75,44 +75,40 @@ module Shoot
 
     desc 'test PATH', 'Runs the given scenario or all files in a directory on a local phantomjs'
     def test(path)
-      files = File.directory?(path) ? Dir.glob("#{path}/*.rb") : [path]
+      scenarios = File.directory?(path) ? Dir.glob("#{path}/*.rb") : [path]
       elapsed_time do
-        files.each{|file| run file, nil }
+        scenarios.each{|scenario| run scenario }
         print set_color("\nAll tests finished", :blue)
       end
     end
 
     desc 'activate IDs', 'Activate platforms, based on IDs'
     def activate(*ids)
-      _activate(ids)
+      return puts "No ids provided, e.g. 'activate 123'" if ids.empty?
+      table Browser.activate(ids)
     end
 
     desc 'deactivate IDs', 'Deactivate platforms, based on IDs'
     def deactivate(*ids)
-      _deactivate(ids)
+      return puts "No ids provided, e.g. 'deactivate 123'" if ids.empty?
+      table Browser.deactivate(ids)
     end
 
     desc 'deactivate_all', 'Deactivate all the platforms'
     def deactivate_all
-      _active.each do |child|
-        child['active'] = false
-      end
-      save_json
+      Browser.deactivate_all
     end
 
     desc 'update', 'Update browser list (WARNING: will override active browsers)'
     def update
-      update_json
+      Browser.update_json
       list
     end
 
     no_commands do
-      def elapsed_time
-        require 'benchmark'
 
-        elapsed_time = Benchmark.measure do
-          yield
-        end
+      def elapsed_time
+        elapsed_time = Benchmark.measure { yield }
         print set_color "  (#{elapsed_time.real.to_i}s)\n", :blue
       end
 
@@ -120,99 +116,23 @@ module Shoot
         CLI.commands[command.to_s].description rescue nil
       end
 
-      def _activate(ids)
-        return puts "No ids provided, e.g. 'activate 123'" if ids.empty?
-        ids.map!(&:to_i)
-        ids.each { |id| json[id]['active'] = true }
-        save_json
-        table json.select{|item| ids.include?(item['id']) }
-      end
-
-      def _deactivate(ids)
-        return puts "No ids provided, e.g. 'deactivate 123'" if ids.empty?
-        ids.map!(&:to_i)
-        ids.each { |id| json[id]['active'] = false }
-        save_json
-        table json.select{|item| ids.include?(item['id']) }
-      end
-
-      def open_all_screenshots
-        `open #{Dir.glob(".screenshots/**/*.png").join(" ")}`
-      end
-
-      def run(file, config = nil)
-        klass = get_const_from_file(file)
-        instance = klass.new(config)
-        puts set_color instance.platform_name, :white, :bold
-        klass.instance_methods(false).each do |method|
-          print set_color "  ➥ #{klass}##{method} ... ", :white, :bold
+      def run(scenario, browser = nil)
+        runner = ScenarioRunner.new(scenario, browser)
+        puts set_color runner.platform_name, :white, :bold
+        runner.each_method do |method|
+          print set_color "  ➥ #{runner.klass}##{method} ... ", :white, :bold
           error = nil
 
           elapsed_time do
-            ok, error = instance.run(method)
+            ok, error = runner.run(method)
 
             print ok ? set_color("OK", :green) : set_color("FAILED", :red)
           end
           puts set_color "    ⚠ #{error}", :red if error
         end
-        instance.ok
-      end
-
-      def require_file(file)
-        require Dir.pwd + '/' + file
-      end
 
-      def constantize_file_name(file)
-        klass_name = File.basename(file, '.rb').split('_').map(&:capitalize).join
-        Kernel.const_get(klass_name)
       end
 
-      def get_const_from_file(file)
-        require_file(file)
-        constantize_file_name(file)
-      end
-
-      def table(browsers)
-        table = browsers.map do |p|
-          to_row(p)
-        end.unshift(['ID', 'OS #', 'Browser #', 'Device'])
-        print_table table, truncate: true
-      end
-
-      def to_row(p)
-        [
-          set_color(p['id'].to_s, p['active'] ? :green : :red),
-          "#{p['os']} #{p['os_version']}",
-          "#{p['browser']} #{p['browser_version']}",
-          p['device']
-        ]
-      end
-
-      def update_json
-        File.write(BROWSERS_PATH, JSON.dump(fetch_json_and_prepare))
-      end
-
-      def json
-        update_json unless File.exist?(BROWSERS_PATH)
-        @json ||= JSON.parse(File.read(BROWSERS_PATH))
-      end
-
-      def _active
-        @active ||= json.select { |p| p['active'] }
-      end
-
-      def save_json
-        File.write(BROWSERS_PATH, JSON.pretty_generate(json))
-      end
-
-      def fetch_json_and_prepare
-        require 'rest_client'
-        JSON.parse(RestClient.get("https://#{ENV['BROWSERSTACK_USER']}:#{ENV['BROWSERSTACK_KEY']}@www.browserstack.com/automate/browsers.json")).tap do |json|
-          json.each_with_index do |browser, index|
-            browser['id'] = index
-          end
-        end
-      end
     end
   end
 end

data/lib/shoot/ngrok.rb

@@ -0,0 +1,23 @@
+require 'childprocess'
+require 'forwardable'
+require 'securerandom'
+
+module Shoot
+  class Ngrok
+    extend Forwardable
+    def_delegators :@process, :start, :stop, :exited?
+
+    def initialize(port = 3000)
+      @process = ChildProcess.build("ngrok", "-log=stdout", "-subdomain=#{subdomain}", port.to_s)
+      start
+    end
+
+    def subdomain
+      @subdomain ||= "shoot-#{Time.now.to_i}-#{SecureRandom.random_number(10**8)}"
+    end
+
+    def url
+      @url ||= "http://#{subdomain}.ngrok.com"
+    end
+  end
+end

data/lib/shoot/ngrok_pow.rb

@@ -0,0 +1,13 @@
+module Shoot
+  class NgrokPow < Ngrok
+    def initialize(server)
+      `ln -s ~/.pow/#{server} ~/.pow/#{subdomain}`
+      @process = ChildProcess.build("ngrok", "-log=stdout", "-subdomain=#{subdomain}", "#{subdomain}.dev:80")
+      start
+
+      at_exit do
+        `rm ~/.pow/#{subdomain}`
+      end
+    end
+  end
+end

data/lib/shoot/scenario.rb

@@ -43,51 +43,60 @@ class Shoot::Scenario
   def run(method)
     @current_method = method
     send(method)
-    #Kernel.sleep(1) # Just in case
     shoot(:finish)
     [true, nil]
   rescue => e
-    #puts "FAILED #{method}: #{e.inspect}"
+    File.write("#{directory}/backtrace.txt", e.backtrace.join("\n"))
     shoot(:failed)
     [false, e]
   end
 
-  def ok
+  def quit
     page.driver.quit
   end
 
   def platform_name
-    @platform_name ||= if @platform['device']
-                         @platform['device']
+    @platform_name ||= if @platform.device
+                         @platform.device
                        else
-                         name_items = %w(browser browser_version os os_version)
-                         @platform.values_at(*name_items).join(' ')
+                         [
+                           @platform.browser,
+                           @platform.browser_version,
+                           @platform.os,
+                           @platform.os_version
+                         ].join(' ')
                        end
   end
 
   private
 
-  def shoot(label)
-    directory = ".screenshots/#{platform_name.to_s.gsub(" ", "_")}/#{self.class.name}/#{@current_method}"
-    unless Dir.exist?(directory)
-      require 'fileutils'
-      FileUtils::mkdir_p directory
+  def directory
+    ".screenshots/#{platform_name.to_s.gsub(" ", "_")}/#{self.class.name}/#{@current_method}".tap do |dir|
+      unless Dir.exist?(dir)
+        require 'fileutils'
+        FileUtils::mkdir_p dir
+      end
     end
+  end
 
+  def shoot(label)
     save_screenshot("#{directory}/#{label}.png")
+  rescue => e
+    File.write("#{directory}/#{label}.error.txt", %(#{e.inspect}\n\n#{e.backtrace.join("\n")}))
   end
 
   def config_capabilities # rubocop:disable AbcSize
     @capabilities = Selenium::WebDriver::Remote::Capabilities.new
-    @capabilities[:browser] = @platform['browser']
-    @capabilities[:browser_version] = @platform['browser_version']
-    @capabilities[:os] = @platform['os']
-    @capabilities[:os_version] = @platform['os_version']
+    @capabilities[:browser] = @platform.browser
+    @capabilities[:browser_version] = @platform.browser_version
+    @capabilities[:os] = @platform.os
+    @capabilities[:os_version] = @platform.os_version
     @capabilities['browserstack.debug'] = 'true'
-    @capabilities[:name] = "Digital Goods - #{@platform}"
-    @capabilities[:browserName] = @platform['browser']
-    @capabilities[:platform] = @platform['os']
-    @capabilities[:device] = @platform['device'] if @platform['device']
+    @capabilities[:name] = "Digital Goods - #{@platform.to_h}"
+    @capabilities[:browserName] = @platform.browser
+    @capabilities[:platform] = @platform.os
+    @capabilities[:device] = @platform.device if @platform.device
+    @capabilities[:emulator] = @platform.emulator
   end
 
 end

data/lib/shoot/scenario_runner.rb

@@ -0,0 +1,40 @@
+module Shoot
+  class ScenarioRunner
+    attr_reader :klass
+    def initialize(scenario, browser = nil)
+      @klass = get_const_from_file(scenario)
+      @instance = @klass.new(browser)
+    end
+
+    def platform_name
+      @instance.platform_name
+    end
+
+    def each_method
+      @klass.instance_methods(false).each do |method|
+        yield(method)
+      end
+      @instance.quit
+    end
+
+    def run(method)
+      @instance.run(method)
+    end
+
+    private
+
+    def require_file(file)
+      require Dir.pwd + '/' + file
+    end
+
+    def constantize_file_name(file)
+      klass_name = File.basename(file, '.rb').split('_').map(&:capitalize).join
+      Kernel.const_get(klass_name)
+    end
+
+    def get_const_from_file(file)
+      require_file(file)
+      constantize_file_name(file)
+    end
+  end
+end

data/lib/shoot/ui.rb

@@ -0,0 +1,24 @@
+module Shoot
+  module UI
+    TABLE_HEADER = ['ID', 'OS #', 'Browser #', 'Device', 'Emulator']
+
+    def table(browsers)
+      table = browsers.map do |browser|
+        to_row(browser)
+      end.unshift(TABLE_HEADER)
+      print_table table, truncate: true
+    end
+
+    private
+
+    def to_row(browser)
+      [
+        set_color(browser.id.to_s, browser.active ? :green : :red),
+        "#{browser.os} #{browser.os_version}",
+        "#{browser.browser} #{browser.browser_version}",
+        browser.device,
+        browser.emulator ? 'Yes' : set_color('No', :black)
+      ]
+    end
+  end
+end

data/lib/shoot/version.rb

@@ -1,3 +1,3 @@
 module Shoot
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 end

data/lib/shoot.rb

@@ -1,5 +1,10 @@
 module Shoot
-  autoload :CLI, "shoot/cli"
-  autoload :Scenario, "shoot/scenario"
-  autoload :VERSION, "shoot/version"
+  autoload :Browser,        "shoot/browser"
+  autoload :CLI,            "shoot/cli"
+  autoload :Ngrok,          "shoot/ngrok"
+  autoload :NgrokPow,       "shoot/ngrok_pow"
+  autoload :Scenario,       "shoot/scenario"
+  autoload :ScenarioRunner, "shoot/scenario_runner"
+  autoload :UI,             "shoot/ui"
+  autoload :VERSION,        "shoot/version"
 end

data/shoot.gemspec

@@ -28,4 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rest-client", "~> 1.7"
   spec.add_dependency "poltergeist", "~> 1.6"
   spec.add_dependency "highline", "~> 1.7"
+  spec.add_dependency "childprocess", "~> 0.5"
 end

data/spec/cli_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../lib/shoot/cli'
+require_relative '../lib/shoot'
 
 describe 'Shoot::CLI' do
   subject(:cli) do
@@ -7,18 +7,18 @@ describe 'Shoot::CLI' do
 
   let(:mock_json) do
     [
-      {os: "Foo", os_version: "Foo 1", browser: "Foo browser", device: nil, browser_version: "6.0", id: 0, 'active' => false},
-      {os: "Bar", os_version: "Bar 2", browser: "Bar browser", device: nil, browser_version: "7.0", id: 1, 'active' => true}
+      {id: 0, os: "Foo", os_version: "Foo 1", browser: "Foo browser", device: nil, browser_version: "6.0", active: false, emulator: false},
+      {id: 1, os: "Bar", os_version: "Bar 2", browser: "Bar browser", device: nil, browser_version: "7.0", active: true, emulator: false}
     ]
   end
 
   before do
-    allow(cli).to receive(:json).and_return(mock_json)
+    allow(Shoot::Browser).to receive(:fetch_json).and_return(mock_json)
+    allow(cli).to receive(:table) {|arg| arg.map(&:to_h) }
   end
 
   describe 'list' do
     before do
-      allow(cli).to receive(:table) {|arg| arg }
     end
 
     context 'list all' do
@@ -36,10 +36,6 @@ describe 'Shoot::CLI' do
   end
 
   describe 'active' do
-    before do
-      allow(cli).to receive(:table) {|arg| arg }
-    end
-
     it 'displays the active browsers' do
       expect(cli.active).to eq([mock_json[1]])
     end
@@ -48,42 +44,44 @@ describe 'Shoot::CLI' do
   describe 'activate' do
     before do
       allow(cli).to receive(:table) {|arg| arg }
-      allow(cli).to receive(:save_json)
+      allow(Shoot::Browser).to receive(:save)
     end
 
     it 'activates the browser' do
-      expect{ cli.activate(0) }.to change{ mock_json[0]['active'] }.from(false).to(true)
-      expect(cli).to have_received(:save_json)
+      expect{ cli.activate(0) }.to change{ Shoot::Browser.all[0].active }.from(false).to(true)
+      expect(Shoot::Browser).to have_received(:save)
     end
   end
 
   describe 'deactivate' do
     before do
       allow(cli).to receive(:table) {|arg| arg }
-      allow(cli).to receive(:save_json)
+      allow(Shoot::Browser).to receive(:save)
     end
 
     it 'deactivates the browser' do
-      expect{ cli.deactivate(1) }.to change{ mock_json[1]['active'] }.from(true).to(false)
-      expect(cli).to have_received(:save_json)
+      Shoot::Browser.all[1].activate
+      expect{ cli.deactivate(1) }.to change{ Shoot::Browser.all[1].active }.from(true).to(false)
+      expect(Shoot::Browser).to have_received(:save)
     end
   end
 
   describe 'deactivate_all' do
     before do
       allow(cli).to receive(:table) {|arg| arg }
-      allow(cli).to receive(:save_json)
+      allow(Shoot::Browser).to receive(:save)
     end
 
     it 'deactivates the browser' do
-      expect{ cli.deactivate_all }.to change{ mock_json[1]['active'] }.from(true).to(false)
-      expect(cli).to have_received(:save_json)
+      Shoot::Browser.all[1].activate
+      expect{ cli.deactivate_all }.to change{ Shoot::Browser.all[1].active }.from(true).to(false)
+      expect(Shoot::Browser).to have_received(:save)
     end
   end
 
   describe 'scenario' do
     before do
-      allow(cli).to receive(:_active).and_return(["foo"])
+      allow(Shoot::Browser).to receive(:active).and_return(["foo"])
       allow(cli).to receive(:run)
     end
 
@@ -102,7 +100,7 @@ describe 'Shoot::CLI' do
 
       it 'runs scenario' do
         cli.test('foo.rb')
-        expect(cli).to have_received(:run).with("foo.rb", nil)
+        expect(cli).to have_received(:run).with("foo.rb")
       end
     end
 
@@ -115,8 +113,8 @@ describe 'Shoot::CLI' do
 
       it 'runs scenario' do
         cli.test('foo')
-        expect(cli).to have_received(:run).with("foo/bar.rb", nil)
-        expect(cli).to have_received(:run).with("foo/baz.rb", nil)
+        expect(cli).to have_received(:run).with("foo/bar.rb")
+        expect(cli).to have_received(:run).with("foo/baz.rb")
       end
     end
   end
@@ -129,9 +127,9 @@ describe 'Shoot::CLI' do
       end
       allow_any_instance_of(Foo).to receive(:run).and_return([true, ""])
       allow_any_instance_of(Foo).to receive(:platform_name)
-      expect_any_instance_of(Foo).to receive(:ok)
+      expect_any_instance_of(Foo).to receive(:quit)
 
-      allow(cli).to receive(:get_const_from_file).with("foo.rb").and_return(Foo)
+      allow_any_instance_of(Shoot::ScenarioRunner).to receive(:get_const_from_file).with("foo.rb").and_return(Foo)
     end
 
     it 'runs scenario' do

data/spec/scenario_spec.rb

@@ -8,14 +8,13 @@ describe 'Shoot::Scenario' do
       allow(Capybara).to receive(:register_driver).with("browser 5.0 os 22.0")
       allow(Capybara).to receive(:current_driver=).with("browser 5.0 os 22.0")
       allow(FileUtils).to receive(:mkdir_p)
-      allow(Kernel).to receive(:sleep)
 
-      @scenario = Shoot::Scenario.new({
+      @scenario = Shoot::Scenario.new(OpenStruct.new({
         'browser' => 'browser',
         'browser_version' => '5.0',
         'os' => 'os',
         'os_version' => '22.0'
-      })
+      }))
 
       allow(@scenario).to receive(:foo)
       allow(@scenario).to receive(:save_screenshot)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shoot
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Juan Lulkin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-25 00:00:00.000000000 Z
+date: 2015-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 description: A helper to take shots on BrowserStack. Run the shoot binary for more
   info.
 email:
@@ -154,8 +168,13 @@ files:
 - Rakefile
 - bin/shoot
 - lib/shoot.rb
+- lib/shoot/browser.rb
 - lib/shoot/cli.rb
+- lib/shoot/ngrok.rb
+- lib/shoot/ngrok_pow.rb
 - lib/shoot/scenario.rb
+- lib/shoot/scenario_runner.rb
+- lib/shoot/ui.rb
 - lib/shoot/version.rb
 - shoot.gemspec
 - spec/cli_spec.rb