rainforest_ruby_runtime 0.0.2 → 0.1.0

data/lib/rainforest_ruby_runtime/dsl.rb

@@ -1,5 +1,8 @@
 module RainforestRubyRuntime
   class DSL
+    include RSpec::Matchers
+    include Capybara::DSL
+
     def initialize(callback: )
       @callback = callback
     end
@@ -8,14 +11,25 @@ module RainforestRubyRuntime
       RainforestRubyRuntime::Test.new(id: id, title: title, callback: @callback, &block)
     end
 
+    def step(options, &block)
+      RainforestRubyRuntime::Step.new(options.merge(callback: @callback), &block).tap(&:run)
+    end
+
     def define_variable_scope(name, &block)
       scope = Variables::Scope.new(name, &block)
-      Variables.scope_registery.register(scope)
+      Variables.scope_registry.register(scope)
     end
 
     def run_code(code)
       eval(code)
     end
+
+    def method_missing(name, *args, &block)
+      if Variables.scope_registry.has_variable?(name)
+        Variables.scope_registry[name]
+      else
+        super
+      end
+    end
   end
 end
-

data/lib/rainforest_ruby_runtime/runner.rb

@@ -1,12 +1,15 @@
 module RainforestRubyRuntime
   class Runner
     attr_reader :config_options, :logger
+    attr_accessor :browser
 
     FAILURE_EXCEPTIONS = [
       RSpec::Expectations::ExpectationNotMetError,
       Capybara::ElementNotFound,
     ].freeze
 
+    BROWSERS = %w(chrome firefox ie edge safari).freeze
+
     def initialize(options = {})
       @config_options = options.dup.freeze
       @step_variables = options[:step_variables]
@@ -14,64 +17,55 @@ module RainforestRubyRuntime
       @logger = options.fetch(:logger) { Logger.new(StringIO.new) }
     end
 
-    def run(code)
-      logger.debug "Running code:\n#{code}\nDriver: #{driver}"
-      Capybara.default_driver = :"#{driver}"
+    def run(codes)
+      logger.debug "Running code:\n#{codes.join('\n')}\nDriver: #{driver_type}"
+      Capybara.default_driver = :"#{driver_type}"
       Capybara.default_max_wait_time = wait_time
 
-      apply_config!
-      setup_scope_registery!
+      setup_scope_registry!
 
       dsl = RainforestRubyRuntime::DSL.new(callback: @callback)
 
-      test = dsl.run_code(code)
-      if Test === test
-        test.run
+      tests = codes.map { |code| dsl.run_code(code) }
+      if tests.all? { |test| test.is_a?(Test) }
+        describe = driver_klass.new(config_options).to_rspec(tests)
+        run_rspec(describe)
       else
-        raise WrongReturnValueError, test
+        raise WrongReturnValueError, tests.reject { |test| test.is_a?(Test) }
       end
-      test
+      tests
     ensure
       terminate_session!
     end
 
-    def extract_results(code, fake_session_id: nil)
-      stdout = stderr = nil
-      payload = nil
-      begin
-        stdout, stderr = capture_output2 do
-          run(code)
+    def run_rspec(describe)
+      if ENV['RUNTIME_ENV'] == 'test' && ENV['SHOW_OUTPUT'] != 'true'
+        # if we're in tests, don't mix output from here with tests output
+        # and don't include this describe block in the test count
+        describe.run
+        RSpec.world.example_groups.pop
+      else
+        RSpec.configure do |config|
+          config.color = true
+          config.formatter = :documentation
+        end
+        RSpec.configuration.reporter.report(RSpec.world.example_count([describe])) do |reporter|
+          describe.run(reporter)
         end
-      rescue *FAILURE_EXCEPTIONS => e
-        payload = exception_to_payload e, status: 'failed'
-      rescue StandardError => e
-        payload = exception_to_payload e, status: 'error'
-      rescue SyntaxError, Exception => e
-        payload = exception_to_payload e, status: 'fatal_error'
       end
-
-      payload ||= { status: 'passed' }
-
-      sid = fake_session_id || session_id
-
-      payload = payload.merge({
-        stdout: stdout,
-        stderr: stderr,
-        session_id: sid,
-        driver: driver,
-      })
-
-
-      logger.debug("Payload")
-      logger.debug(payload.inspect)
-
-      payload
     end
 
-    def driver
+    def driver_type
       ENV.fetch("CAPYBARA_DRIVER") { "selenium" }
     end
 
+    def driver_klass
+      {
+        'selenium' => Drivers::Selenium,
+        'sauce' => Drivers::Sauce,
+      }.fetch(driver_type)
+    end
+
     def current_browser
       current_driver.browser
     end
@@ -93,17 +87,6 @@ module RainforestRubyRuntime
       })
     end
 
-    def apply_config!
-      config = {
-        "selenium" => Drivers::Selenium,
-        "sauce" => Drivers::Sauce,
-        "testingbot" => Drivers::TestingBot,
-        "browser_stack" => Drivers::BrowserStack,
-      }.fetch(driver)
-
-      config.new(config_options).call
-    end
-
     def current_driver
       Capybara.current_session.driver
     end
@@ -115,12 +98,12 @@ module RainforestRubyRuntime
       elsif current_driver.respond_to?(:quit)
         current_driver.quit
       else
-        logger.warn "Cannot terminate session. Driver #{driver}" and return
+        logger.warn "Cannot terminate session. Driver #{driver_type}" and return
       end
       logger.debug "Session successfuly terminated"
     rescue Selenium::WebDriver::Error::WebDriverError => e
       # Ignore
-      logger.warn "Exception while terminating session. Driver #{driver}. Class: #{e.class}"
+      logger.warn "Exception while terminating session. Driver #{driver_type}. Class: #{e.class}"
       logger.warn "#{e.message}\n#{e.backtrace.join("\n")}"
     end
 
@@ -128,23 +111,12 @@ module RainforestRubyRuntime
       ENV.fetch("CAPYBARA_WAIT_TIME", 20).to_i
     end
 
-    def capture_output2
-      previous_stdout, $stdout = $stdout, StringIO.new
-      previous_stderr, $stderr = $stderr, StringIO.new
-      yield
-      [$stdout.string, $stderr.string]
-    ensure
-      # Restore the previous value of stdout (typically equal to STDERR).
-      $stdout = previous_stdout
-      $stderr = previous_stderr
-    end
-
-    def setup_scope_registery!
+    def setup_scope_registry!
       # TODO this should not be set globally, but passed in the DSL
       if @step_variables.nil?
-        Variables.scope_registery = Variables::Registery.new
+        Variables.scope_registry = Variables::Registry.new
       else
-        Variables.scope_registery = Variables::StaticVariableRegistery.new(@step_variables)
+        Variables.scope_registry = Variables::StaticVariableRegistry.new(@step_variables)
       end
     end
   end

data/lib/rainforest_ruby_runtime/test.rb

@@ -10,28 +10,11 @@ module RainforestRubyRuntime
       @callback = callback
     end
 
-    def step(options, &block)
-      step = Step.new(options.merge(callback: @callback), &block)
-      @steps << step
-      step.run
-      step
-    end
-
     def run
-      extend RSpec::Matchers
-      extend Capybara::DSL
       @callback.before_test(self)
-      instance_eval &@block
+      @block.call
       @callback.after_test(self)
     end
-
-    def method_missing(name, *args, &block)
-      if Variables.scope_registery.has_variable?(name)
-        Variables.scope_registery[name]
-      else
-        super
-      end
-    end
   end
 
   class Step

data/lib/rainforest_ruby_runtime/variables/{registery.rb → registry.rb}

@@ -1,6 +1,6 @@
 module RainforestRubyRuntime
   module Variables
-    class Registery
+    class Registry
       def initialize(variables = {})
         @variables = {}
       end
@@ -22,7 +22,7 @@ module RainforestRubyRuntime
       attr_reader :variables
     end
 
-    class StaticVariableRegistery
+    class StaticVariableRegistry
       def initialize(variables)
         @variables = variables.inject({}) do |variables, (name, var_and_values)|
           scope = Scope.new(name)
@@ -47,12 +47,12 @@ module RainforestRubyRuntime
       end
     end
 
-    def self.scope_registery
-      @scope_registery ||= Registery.new
+    def self.scope_registry
+      @scope_registry ||= Registry.new
     end
 
-    def self.scope_registery=(registery)
-      @scope_registery = registery
+    def self.scope_registry=(registry)
+      @scope_registry = registry
     end
   end
 end

data/lib/rainforest_ruby_runtime/variables/scope.rb

@@ -5,7 +5,7 @@ module RainforestRubyRuntime
 
       def initialize(*, &block)
         super
-        @registry = Registery.new
+        @registry = Registry.new
         instance_eval &block if block_given?
       end
 

data/lib/rainforest_ruby_runtime/version.rb

@@ -1,3 +1,3 @@
 module RainforestRubyRuntime
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/rainforest_ruby_runtime.gemspec

@@ -13,19 +13,30 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://www.rainforestqa.com/"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f =~ %r(^vendor/sauce/) }
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake"
+  spec.post_install_message = <<-EOS
+  Thanks for installing!
+  If you plan to run scripts against Sauce Labs, please run
+  `rainforest_test --prepare-sauce`
+  and set the SAUCE_USERNAME, SAUCE_ACCESS_KEY, and CAPYBARA_DRIVER
+  environment variables.
+  EOS
+
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "rspec_junit_formatter"
   spec.add_dependency "sauce", "~> 3.7"
   spec.add_dependency "sauce-connect", "~> 3.6"
-  spec.add_dependency "rspec-expectations", "~> 3.0"
+  spec.add_dependency "rspec", "3.5.0"
   spec.add_dependency "capybara", "~> 2.7.1"
   spec.add_dependency "selenium-client", "~> 1.2.0"
   spec.add_dependency "selenium-webdriver", "~> 3.3"
   spec.add_dependency "net-http-persistent", "~> 3.0"
-  spec.add_dependency "testingbot", "~> 0.1.7"
+  spec.add_dependency "bundler", "~> 1.16"
+  spec.add_dependency "rake", "~> 12.3"
 end

data/sample_tests/empty.rb

@@ -1,2 +1,2 @@
-test(id: 1, title: "") do
+test(id: 1, title: "empty") do
 end

data/spec/rainforest_test_spec.rb

@@ -0,0 +1,89 @@
+require 'open3'
+require_relative './spec_helper'
+
+module RainforestRubyRuntime
+  describe 'rainforest_test', show_output: true do
+    subject do
+      if browsers
+        Open3.capture2e("ruby bin/rainforest_test #{browsers} sample_tests/empty.rb")
+      else
+        Open3.capture2e('ruby bin/rainforest_test sample_tests/empty.rb')
+      end
+    end
+
+    context 'with no browsers' do
+      let(:browsers) { nil }
+
+      it 'defaults to chrome' do
+        output, status = subject
+
+        expect(status).to be_success
+        expect(output).to match(/chrome/)
+      end
+    end
+
+    context 'with a browser' do
+      context 'from the whitelist' do
+        let(:browser) { Runner::BROWSERS.sample }
+        let(:browsers) { "--browsers #{browser}" }
+
+        it 'passes it to Runner' do
+          output, status = subject
+
+          expect(status).to be_success
+          expect(output).to match(browser)
+        end
+      end
+
+      context 'that is unknown' do
+        let(:browsers) { "--browsers opera" }
+
+        it 'exits with status 1' do
+          output, status = subject
+
+          expect(status).to_not be_success
+          expect(output).to match(/invalid option: #{browsers}/)
+        end
+      end
+    end
+
+    context 'with multiple browsers' do
+      context 'from the whitelist' do
+        let(:browser_values) { Runner::BROWSERS.sample(2) }
+        let(:browsers) { "--browsers #{browser_values.join(',')}" }
+
+        it 'passes them to Runner' do
+          output, status = subject
+
+          expect(status).to be_success
+          browser_values.each { |b| expect(output).to match(b) }
+        end
+      end
+
+      context 'that is unknown' do
+        let(:browsers) { "--browsers #{Runner::BROWSERS.sample},opera" }
+
+        it 'exits with status 1' do
+          output, status = subject
+
+          expect(status).to_not be_success
+          expect(output).to match(/invalid option: --browsers opera/)
+        end
+      end
+    end
+
+    context 'with multiple files' do
+      subject do
+        Open3.capture2e('ruby bin/rainforest_test sample_tests/empty.rb sample_tests/simple.rb')
+      end
+
+      it 'should work' do
+        output, status = subject
+
+        expect(status).to be_success
+        expect(output).to match(/\[1\] empty/)
+        expect(output).to match(/\[1\] My Sample Test/)
+      end
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,132 @@
+require_relative './spec_helper'
+
+module RainforestRubyRuntime
+  describe Runner do
+    let(:codes) { [read_sample('empty')] }
+
+    subject { Runner.new(browsers: %i(chrome)) }
+
+    before do
+      allow(subject).to receive(:driver).and_return('selenium')
+    end
+
+    describe "#session_id" do
+      before { allow(subject).to receive(:current_driver) { OpenStruct.new(browser: OpenStruct.new(session_id: 'session')) } }
+
+      it "returns a session id" do
+        expect(subject.session_id).to eq('session')
+      end
+    end
+
+    describe "#run" do
+      describe "with a limited browser set" do
+        before do
+          allow(subject).to receive(:driver_type).and_return('sauce')
+          expect_any_instance_of(Drivers::Sauce).to receive(:to_rspec) do |driver|
+            driver.send(:apply_config)
+            double(run: nil)
+          end
+        end
+
+        it "applies the correct configuration" do
+          subject.run(codes)
+          expect(Sauce.get_config.browsers).to eq([['Windows 7', 'Chrome', 'latest']])
+        end
+      end
+
+      describe "for a rainforest test" do
+        let(:codes) { [read_sample('simple')] }
+
+        it "runs the content of the step" do
+          tests = subject.run(codes)
+          expect(tests).to all be_instance_of(Test)
+          expect($simple_test_was).to eq(:run)
+        end
+      end
+
+      describe "for another type of test" do
+        it "raises an exception" do
+          expect { subject.run(['']) }.to raise_error(WrongReturnValueError)
+        end
+      end
+
+      describe "with custom step variables" do
+        let(:codes) { [read_sample('step_variables')] }
+
+        it "makes the variable accessible in the test" do
+          subject.run(codes)
+          expect($step_variable_1_was).to_not be_nil
+          expect($step_variable_2_was).to match(/time is: .*/)
+          expect($step_variable_3_was).to eq('1')
+        end
+      end
+    end
+
+    describe "callbacks" do
+      let(:callback) do
+        Class.new do
+          attr_reader :before_steps, :before_tests, :after_steps, :after_tests
+
+          def initialize
+            @before_steps = []
+            @after_steps = []
+            @after_tests = []
+            @before_tests = []
+          end
+
+          def before_step(step)
+            @before_steps << step
+          end
+
+          def after_step(step)
+            @after_steps << step
+          end
+
+          def after_test(test)
+            @after_tests << test
+          end
+
+          def before_test(test)
+            @before_tests << test
+          end
+        end.new
+      end
+
+      let(:codes) { [read_sample('two_steps')] }
+
+      subject { Runner.new(browsers: %i(chrome), callback: callback) }
+
+      it "calls the right method on the callback object" do
+        subject.run(codes)
+        expect(callback.before_tests.size).to eq(1)
+        expect(callback.after_tests.size).to eq(1)
+        expect(callback.before_steps.size).to eq(2)
+        expect(callback.after_steps.size).to eq(2)
+
+        expect(callback.before_steps.map(&:id)).to eq([1, 2])
+        expect(callback.after_steps.map(&:id)).to eq([1, 2])
+
+        expect(callback.before_steps.map(&:action)).to eq(["action 1", "action 2"])
+      end
+
+      describe "a partially define callback object" do
+        let(:callback) do
+          Class.new do
+          end.new
+        end
+
+        it "should not raise a method missing exception" do
+          subject.run(codes)
+        end
+      end
+    end
+
+    def read_sample(name)
+      File.read(File.expand_path("../sample_tests/#{name}.rb", __dir__))
+    end
+
+    def format_step(code)
+      read_sample("one_step").gsub("#REPLACE", code)
+    end
+  end
+end