testingbot 0.0.9 → 0.1.0

data/examples/test_rspec1.rb

@@ -22,7 +22,7 @@ describe "People" do
     end
 
     before(:each) do
-      selenium_driver.start_new_browser_session
+      @selenium_driver.start_new_browser_session
     end
 
     append_after(:each) do 

data/examples/test_unit.rb

@@ -1,11 +1,7 @@
-require "rubygems"
-gem "selenium-client"
-require "selenium/client"
-gem 'test-unit'
+require 'rubygems'
 require 'test/unit'
-
-gem "testingbot"
-require "testingbot"
+require "selenium/client"
+require 'testingbot'
 
 class ExampleTest < TestingBot::TestCase
   attr_reader :browser
@@ -17,12 +13,10 @@ class ExampleTest < TestingBot::TestCase
         :browser => "firefox", 
         :platform => "WINDOWS",
         :version => "10",
-        :url => "http://testingbot.com", 
+        :url => "http://www.google.com", 
         :timeout_in_second => 60
       
-    browser.extra = "First test" # some custom data you can pass with your tests
-    
-    browser.start_new_browser_session(:captureNetworkTraffic => true)
+    browser.start_new_browser_session
   end
 
   def teardown
@@ -31,7 +25,6 @@ class ExampleTest < TestingBot::TestCase
 
   def test_page_search
     browser.open "/"
-#    assert_equal "Google", browser.title
-p browser.browser_network_traffic
+    assert_equal "Google", browser.title
   end
 end

data/lib/testingbot.rb

@@ -1,224 +1,5 @@
 require "testingbot/version"
 require "testingbot/config"
-
-# if selenium RC, add testingbot credentials to request
-if defined?(Selenium) && defined?(Selenium::Client) && defined?(Selenium::Client::Protocol)
-  module Selenium
-    module Client
-      module Protocol
-          # add custom parameters for testingbot.com
-          def http_request_for_testingbot(verb, args)
-            data = http_request_for_original(verb, args)
-            data << "&client_key=#{TestingBot.get_config[:client_key]}&client_secret=#{TestingBot.get_config[:client_secret]}"
-          end
-
-          begin
-           alias http_request_for_original http_request_for
-           alias http_request_for http_request_for_testingbot
-         rescue
-         end
-      end
-    end
-  end
-end
-
-if defined?(Selenium) && defined?(Selenium::Client) && defined?(Selenium::Client::Base)
-  module Selenium
-    module Client
-      module Base
-        DEFAULT_OPTIONS = {
-          :screenshot => true
-        }
-        
-        alias :close_current_browser_session_old :close_current_browser_session
-        alias :start_new_browser_session_old :start_new_browser_session
-        alias :initialize_old :initialize
-        
-        attr_accessor :options
-        attr_accessor :session_id_backup
-        attr_accessor :extra
-        attr_accessor :platform
-        attr_accessor :version
-        
-        def initialize(*args)
-          if args[0].kind_of?(Hash)
-            options = args[0]
-            @platform = options[:platform] || "WINDOWS"
-            @version  = options[:version]  if options[:version]
-          end
-          
-          @options = DEFAULT_OPTIONS
-          initialize_old(*args)
-          @host = "hub.testingbot.com" if @host.nil?
-          @port = 4444 if @port.nil?
-        end
-        
-        def close_current_browser_session
-          @session_id_backup = @session_id
-          close_current_browser_session_old
-        end
-        
-        def start_new_browser_session(options={})
-          options = @options.merge options
-          options[:platform] = @platform
-          options[:version] = @version unless @version.nil?
-          start_new_browser_session_old(options)
-        end
-        
-        def extra=(str)
-          @extra = str
-        end
-        
-        def options=(opts = {})
-          @options = @options.merge opts
-        end
-      end
-    end
-  end
-end
-
-# rspec 1
-begin
-  require 'spec'
-  require "selenium/rspec/spec_helper"
-    Spec::Runner.configure do |config|
-      config.prepend_after(:each) do
-        client_key = TestingBot.get_config[:client_key]
-        client_secret = TestingBot.get_config[:client_secret]
-        
-        if !client_key.nil?
-          
-          session_id = nil
-          
-          if !@selenium_driver.nil?
-            session_id = @selenium_driver.session_id_backup
-          elsif defined?(Capybara)
-            begin
-              session_id = page.driver.browser.instance_variable_get("@bridge").instance_variable_get("@session_id")
-            rescue Exception => e
-              p "Could not determine sessionID, can not send results to TestingBot.com #{e.message}"
-            end
-          end
-          
-          if !session_id.nil?
-            params = {
-              "session_id" => session_id,
-              "client_key" => client_key,
-              "client_secret" => client_secret,
-              "status_message" => @execution_error,
-              "success" => !actual_failure?,
-              "name" => description.to_s,
-              "kind" => 2,
-              "extra" => @selenium_driver.extra
-            }
-        
-            url = URI.parse('http://testingbot.com/hq')
-            http = Net::HTTP.new(url.host, url.port)
-            response = http.post(url.path, params.map { |k, v| "#{k.to_s}=#{v}" }.join("&"))
-          end
-        else
-            puts "Can't post test results to TestingBot since I could not a .testingbot file in your home-directory."
-        end
-      end
-    end
-rescue LoadError
-end
-
-# rspec 2
-begin
-  require 'rspec'
-  
-  ::RSpec.configuration.after :each do
-    
-    client_key = TestingBot.get_config[:client_key]
-    client_secret = TestingBot.get_config[:client_secret]
-    
-    if !client_key.nil?
-      test_name = ""
-      if example.metadata && example.metadata[:example_group]
-        if example.metadata[:example_group][:description_args]
-          test_name = example.metadata[:example_group][:description_args].join(" ")
-        end
-        
-        if example.metadata[:description_args]
-          test_name = test_name + " it " + example.metadata[:description_args].join(" ")
-        end
-      end
-      
-      status_message = ""
-      status_message = example.exception.to_s if !example.exception.nil?
-      
-      session_id = nil
-      
-      if !@selenium_driver.nil?
-        session_id = @selenium_driver.session_id_backup
-      elsif defined?(Capybara)
-        begin
-          session_id = page.driver.browser.instance_variable_get("@bridge").instance_variable_get("@session_id")
-        rescue Exception => e
-          p "Could not determine sessionID, can not send results to TestingBot.com #{e.message}"
-        end
-      end
-      
-      if !session_id.nil?
-        params = {
-          "session_id" => session_id,
-          "client_key" => client_key,
-          "client_secret" => client_secret,
-          "status_message" => status_message,
-          "success" => example.exception.nil?,
-          "name" => test_name,
-          "kind" => 2
-        }
-      
-        if @selenium_driver && @selenium_driver.extra
-          params["extra"] = @selenium_driver.extra
-        end
-    
-        url = URI.parse('http://testingbot.com/hq')
-        http = Net::HTTP.new(url.host, url.port)
-        response = http.post(url.path, params.map { |k, v| "#{k.to_s}=#{v}" }.join("&"))
-      end
-    else
-      puts "Can't post test results to TestingBot since I could not a .testingbot file in your home-directory."
-    end
-  end
-rescue LoadError
-end
-
-if defined?(Test::Unit::TestCase) && (Test::Unit::TestCase.respond_to?('run_teardown'))
-  module TestingBot
-    class TestingBot::TestCase < Test::Unit::TestCase
-      alias :run_teardown_old :run_teardown
-      alias :handle_exception_old :handle_exception
-      
-      attr_accessor :exception
-      
-      def run_teardown
-        client_key = TestingBot.get_config[:client_key]
-        client_secret = TestingBot.get_config[:client_secret]
-        
-        params = {
-          "session_id" => browser.session_id,
-          "client_key" => client_key,
-          "client_secret" => client_secret,
-          "status_message" => @exception,
-          "success" => passed?,
-          "name" => self.to_s,
-          "kind" => 2,
-          "extra" => browser.extra
-        }
-        
-        url = URI.parse('http://testingbot.com/hq')
-        http = Net::HTTP.new(url.host, url.port)
-        response = http.post(url.path, params.map { |k, v| "#{k.to_s}=#{v}" }.join("&"))
-        run_teardown_old
-      end
-      
-      def handle_exception(e)
-        @exception = e.to_s
-        handle_exception_old(e)
-      end
-    end
-  end
-end
+require "testingbot/selenium"
+require "testingbot/api"
+require "testingbot/hooks"

data/lib/testingbot/api.rb

@@ -0,0 +1,112 @@
+require 'json'
+module TestingBot
+
+  class Api
+
+    VERSION = 1
+    API_URL = "http://api.testingbot.com"
+
+    attr_reader :config
+
+    def initialize(opts = {})
+      @config = TestingBot::Config.new(opts)
+    end
+
+    def get_user_info
+      get("/user")
+    end
+
+    def update_user_info(params = {})
+      new_params = {}
+      params.keys.each do |key|
+        new_params["user[#{key}]"] = params[key]
+      end
+      response = put("/user", new_params)
+      response["success"]
+    end
+
+    def get_tests(offset = 0, count = 10)
+      get("/tests")
+    end
+
+    def get_single_test(test_id)
+      get("/tests/#{test_id}")
+    end
+
+    def update_test(test_id, params = {})
+      new_params = {}
+      params.keys.each do |key|
+        new_params["test[#{key}]"] = params[key]
+      end
+      response = put("/tests/#{test_id}", new_params)
+      response["success"]
+    end
+
+    def delete_test(test_id)
+      response = delete("/tests/#{test_id}")
+      response["success"]
+    end
+
+    private
+
+    def get(url)
+      uri = URI(API_URL + '/v' + VERSION.to_s + url)
+      req = Net::HTTP::Get.new(uri.request_uri)
+      req.basic_auth @config[:client_key], @config[:client_secret]
+      res = Net::HTTP.start(uri.hostname, uri.port) {|http|
+        http.request(req)
+      }
+
+      parsed = JSON.parse(res.body)
+
+      if !parsed["error"].nil? && !parsed["error"].empty?
+        raise parsed["error"]
+      end
+
+      parsed
+    end
+
+    def put(url, params = {})
+      uri = URI(API_URL + '/v' + VERSION.to_s + url)
+      req = Net::HTTP::Put.new(uri.request_uri)
+      req.basic_auth @config[:client_key], @config[:client_secret]
+      req.set_form_data(params)
+      res = Net::HTTP.start(uri.hostname, uri.port) {|http|
+        http.request(req)
+      }
+
+      parsed = JSON.parse(res.body)
+
+      if !parsed["error"].nil? && !parsed["error"].empty?
+        raise parsed["error"]
+      end
+
+      parsed
+    end
+
+    def delete(url, params = {})
+      uri = URI(API_URL + '/v' + VERSION.to_s + url)
+      req = Net::HTTP::Delete.new(uri.request_uri)
+      req.basic_auth @config[:client_key], @config[:client_secret]
+      req.set_form_data(params)
+      res = Net::HTTP.start(uri.hostname, uri.port) {|http|
+        http.request(req)
+      }
+
+      parsed = JSON.parse(res.body)
+
+      if !parsed["error"].nil? && !parsed["error"].empty?
+        raise parsed["error"]
+      end
+
+      parsed
+    end
+
+    def post(url, params = {})
+      url = URI.parse(API_URL + '/v' + VERSION + url)
+      http = Net::HTTP.new(url.host, url.port)
+      http.basic_auth @config[:client_key], @config[:client_secret]
+      response = http.post(url.path, params.map { |k, v| "#{k.to_s}=#{v}" }.join("&"))
+    end
+  end
+end

data/lib/testingbot/capybara.rb

@@ -0,0 +1,49 @@
+require 'capybara'
+require 'testingbot/config'
+require 'testingbot/tunnel'
+require 'testingbot/selenium'
+require 'capybara/dsl'
+
+@tunnel = nil
+
+module TestingBot
+  module Capybara
+
+    def self.start_tunnel
+      return @tunnel unless @tunnel.nil?
+
+      @tunnel = TestingBot::Tunnel.new(TestingBot.get_config[:tunnel_options] || {})
+      @tunnel.start
+    end
+
+    class CustomDriver < ::Capybara::Selenium::Driver
+        def browser
+          unless @browser
+            if TestingBot.get_config[:require_tunnel]
+              TestingBot::Capybara.start_tunnel
+            end
+
+            @browser = TestingBot::SeleniumWebdriver.new
+
+            main = Process.pid
+            at_exit do
+              if @browser
+                begin
+                  @browser.quit 
+                rescue
+                end
+              end
+              if TestingBot.get_config[:require_tunnel]
+                @tunnel.stop unless @tunnel.nil?
+              end
+            end
+          end
+          @browser
+        end
+    end
+  end
+end
+
+Capybara.register_driver :testingbot do |app|
+  TestingBot::Capybara::CustomDriver.new(app)
+end

data/lib/testingbot/config.rb

@@ -1,28 +1,50 @@
 module TestingBot
   @@config = nil
-  
   def self.get_config
     @@config = TestingBot::Config.new if @@config.nil?
     @@config
   end
+
+  def self.reset_config!
+    @@config = nil
+  end
+
+  def self.config
+    yield self.get_config
+  end
   
   class Config
     
     attr_reader :options
     
     def initialize(options = {})
-      @options = options
+      @options = default_options
       @options = @options.merge(load_config_file)
       @options = @options.merge(load_config_environment)
+      @options = @options.merge(options)
     end
     
     def [](key)
       @options[key]
     end
 
+    def add_options(options = {})
+      @options = @options.merge(options)
+    end
+
     def []=(key, value)
       @options[key] = value
     end
+
+    def options
+      @options
+    end
+
+    def require_tunnel(host = "127.0.0.1", port = 4445)
+      @options[:require_tunnel] = true
+      @options[:host] = host
+      @options[:port] = port
+    end
     
     def client_key
       @options[:client_key]
@@ -31,8 +53,38 @@ module TestingBot
     def client_secret
       @options[:client_secret]
     end
+
+    def desired_capabilities
+      # check if instance of Selenium::WebDriver::Remote::Capabilities
+      unless @options[:desired_capabilities].instance_of?(Hash) || @options[:desired_capabilities].instance_of?(Array)
+        return symbolize_keys @options[:desired_capabilities].as_json
+      end
+      @options[:desired_capabilities]
+    end
     
     private
+
+    def symbolize_keys(hash)
+      hash.inject({}) {|new_hash, key_value|
+        key, value = key_value
+        value = symbolize_keys(value) if value.is_a?(Hash)
+        new_hash[key.to_sym] = value
+        new_hash
+      }
+    end
+
+    def default_desired_capabilities
+      { :browserName => "firefox", :version => 9, :platform => "WINDOWS" }
+    end
+
+    def default_options
+      {
+        :host => "hub.testingbot.com",
+        :port => 4444,
+        :jenkins_output => true,
+        :desired_capabilities => default_desired_capabilities
+      }
+    end
     
     def load_config_file
       options = {}