selenium_shots 0.0.0 → 0.0.1

data/README.rdoc

@@ -3,15 +3,52 @@
 http://www.seleniumshots.com
 Selenium Shots is an Integration Testing Service that transparently distributes your integration tests across multiple operating systems with different versions of all major browsers AND captures a screen shot. This eliminates the need to have multiple vm's on your computer or the need for multiple machines on your test to test your web application.  Running your tests remotely will dramatically speed up in-browser web testing and leave more time to  and create a slide show available to confirm visuals making it easy for you to improve your web application.
 
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+== Install
+
+=== Rails 3
+
+Add this to your Gemfile:
+
+  group :development do
+    gem 'selenium_shots'
+  end
+
+=== Rails 2
+
+To install add teh following to config/environment.rb:
+
+  config.gem 'selenium_shots'
+  
+== Configure
+
+In configure/selenium_shots.yml you will need to define the application
+* api_key
+* mode
+* default_browser_url
+* application_name
+* local_browser
+* browsers
+
+== Creating Tests
+
+
+   class MyTest < SeleniumShots
+  
+     @group = "MyTestGroup"
+  
+     selenium_shot "Should run my test and pass." do
+       @name = "My Test Name"
+       browser.open "/my_site"
+       browser.type "search[query]", "Cats"
+       browser.click "find"
+     end
+   end
+   
+== Selenium Setup
+Download the latest version of selenium grid from http://seleniumhq.org/download/
+
+===Using a Custom Selenium Server
+`ant launch-remote-control -DcustomRemoteControl=/path/to/your/customer/selenium-server.jar`
 
 == Copyright
 

data/bin/selenium_shots

@@ -11,6 +11,6 @@ command = args.shift.strip rescue 'help'
 if File.exists?('config/environment.rb')
   SeleniumShots::Command.run(command, args)
 else
-  puts "No rails app found!, you need stay inside on the root of one rails app"
+  puts "app rails not found!, you need stay inside on the root of one rails app"
 end
 

data/examples/google.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+
+class Google < SeleniumShots
+
+  @group = "Google"
+
+  selenium_shot "should search on google" do
+    @name = "Google search"
+    element = driver.find_element(:name, 'q')
+    element.send_keys "Hello WebDriver!"
+    element.submit
+  end
+end
+

data/lib/selenium_shots/cli/client.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-require 'rexml/document'
 require 'rest_client'
 require 'uri'
 require 'time'
@@ -8,16 +7,11 @@ class SeleniumShots::Client
 
 	attr_reader :host, :api_key
 
-	def initialize(api_key, host='seleniumshots.heroku.com')
+	def initialize(api_key, host='www.seleniumshots.com')
 		@api_key  = api_key
 		@host     = host
 	end
 
-  def list
-    #get list app from selenium_shots
-    []
-  end
-
 ############
 	def resource(uri)
 		RestClient::Resource.new("http://#{host}", api_key)[uri]
@@ -38,16 +32,5 @@ class SeleniumShots::Client
 	def delete(uri)
 		resource(uri).delete
 	end
-
-	def xml(raw)   # :nodoc:
-		REXML::Document.new(raw)
-	end
-
-	def escape(value)  # :nodoc:
-		escaped = URI.escape(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-		escaped.gsub('.', '%2E') # not covered by the previous URI.escape
-	end
-
-
 end
 

data/lib/selenium_shots/cli/command.rb

@@ -1,50 +1,52 @@
 module SeleniumShots
-	module Command
-		class InvalidCommand < RuntimeError; end
-		class CommandFailed  < RuntimeError; end
+  module Command
+    class InvalidCommand < RuntimeError; end
+    class CommandFailed  < RuntimeError; end
 
-		class << self
-			def run(command, args)
-				run_internal(command, args)
-			rescue InvalidCommand
-				display "Unknown command. Run 'selenium_shots help' for usage information."
-			end
+    class << self
+      def run(command, args)
+        run_internal(command, args)
+      rescue InvalidCommand
+        display "Unknown command. Run 'selenium_shots help' for usage information."
+      rescue RestClient::Unauthorized
+        display "Authentication failure. For more information you can go to http://www.seleniumshots.com"
+      end
 
-			def run_internal(command, args)
-				namespace, command = parse(command)
-				require "#{namespace}"
-				klass = SeleniumShots::Command.const_get(namespace.capitalize).new(args)
-				raise InvalidCommand unless klass.respond_to?(command)
-				klass.send(command)
-			end
+      def run_internal(command, args)
+        namespace, command = parse(command)
+        require "#{namespace}"
+        klass = SeleniumShots::Command.const_get(namespace.capitalize).new(args)
+        raise InvalidCommand unless klass.respond_to?(command)
+        klass.send(command)
+      end
 
-			def display(msg)
-				puts(msg)
-			end
+      def display(msg)
+        puts(msg)
+      end
 
-			def parse(command)
-				parts = command.split(':')
-				case parts.size
-					when 1
-						if namespaces.include? command
-							return command, 'index'
-						else
-							return 'app', command
-						end
-					when 2
-						raise InvalidCommand unless namespaces.include? parts[0]
-						return parts
-					else
-						raise InvalidCommand
-				end
-			end
+      def parse(command)
+        parts = command.split(':')
+        case parts.size
+          when 1
+            if namespaces.include? command
+              return command, 'index'
+            else
+              return 'app', command
+            end
+          when 2
+            raise InvalidCommand unless namespaces.include? parts[0]
+            return parts
+          else
+            raise InvalidCommand
+        end
+      end
 
-			def namespaces
-				@@namespaces ||= Dir["#{File.dirname(__FILE__)}/commands/*"].map do |namespace|
-					namespace.gsub(/.*\//, '').gsub(/\.rb/, '')
-				end
-			end
-		end
-	end
+      def namespaces
+        @@namespaces ||= Dir["#{File.dirname(__FILE__)}/commands/*"].map do |namespace|
+          namespace.gsub(/.*\//, '').gsub(/\.rb/, '')
+        end
+      end
+    end
+  end
 end
 

data/lib/selenium_shots/cli/commands/app.rb

@@ -1,20 +1,16 @@
 module SeleniumShots::Command
-	class App < Base
+  class App < Base
     def create
-		  name    = args.shift.downcase.strip rescue nil
-      api_key ||= SeleniumShots::Command.run_internal('auth:api_key', args)
-      make_config_file(name, api_key)
-		  display "Created #{name}"
+      name = args.shift.downcase.strip rescue nil
+      if name
+        selenium_shots_api_key
+        if make_config_file(name, @api_key) == "y"
+          display "Created #{name}\nYou can configurate selenium shots on config/selenium_shots.yml"
+        end
+      else
+        display "You need specify a name for your app. Run 'selenium_shots help' for usage information"
+      end
     end
-
-    def list
-			list = selenium_shots.list
-			if list.size > 0
-				display list.join("\n")
-			else
-				display "You have no apps."
-			end
-		end
-	end
+  end
 end
 

data/lib/selenium_shots/cli/commands/auth.rb

@@ -1,127 +1,127 @@
 module SeleniumShots::Command
-	class Auth < Base
-		attr_accessor :api_key_hash
+  class Auth < Base
+    attr_accessor :api_key_hash
 
-		def client
-			@client ||= init_selenium_shots
-		end
+    def client
+      @client ||= init_selenium_shots
+    end
 
-		def init_selenium_shots
-			SeleniumShots::Client.new(api_key)
-		end
+    def init_selenium_shots
+      SeleniumShots::Client.new(api_key)
+    end
 
-		def api_key
+    def api_key
       get_api_key
-		end
+    end
 
     def get_api_key_from_host
-      RestClient.post 'http://seleniumshots.heroku.com/selenium_tests/get_api_key', :user_session => { :login => @api_key_hash[0],
-                                                                                    :password => @api_key_hash[1]}
-    end
-
-		def api_key_file
-			"#{home_directory}/.selenium_shots/api_key"
-		end
-
-		def get_api_key
-			return if @api_key_hash
-			unless @api_key_hash = read_api_key
-				@api_key_hash = ask_for_api_key
-				save_api_key
-			end
-			@api_key_hash
-		end
-
-		def read_api_key
-			if File.exists? api_key_file
-				return File.read(api_key_file).split("\n")
-			end
-		end
-
-		def echo_off
-			system "stty -echo"
-		end
-
-		def echo_on
-			system "stty echo"
-		end
-
-		def ask_for_api_key
-			puts "Enter your SeleniumShots Account"
-
-			print "Login: "
-			user = ask
-
-			print "Password: "
-			password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
-
-			[ user, password ]
-		end
-
-		def ask_for_password_on_windows
-			require "Win32API"
-			char = nil
-			password = ''
-
-			while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
-				break if char == 10 || char == 13 # received carriage return or newline
-				if char == 127 || char == 8 # backspace and delete
-					password.slice!(-1, 1)
-				else
-					password << char.chr
-				end
-			end
-			puts
-			return password
-		end
-
-		def ask_for_password
-			echo_off
-			password = ask
-			puts
-			echo_on
-			return password
-		end
-
-		def save_api_key
-			begin
+      RestClient.post 'http://www.seleniumshots.com/selenium_tests/get_api_key',  :user_session => { :email => @api_key_hash[0],
+                                                                                  :password => @api_key_hash[1]}
+    end
+
+    def api_key_file
+      "#{home_directory}/.selenium_shots/api_key"
+    end
+
+    def get_api_key
+      return if @api_key_hash
+      unless @api_key_hash = read_api_key
+        @api_key_hash = ask_for_api_key
+        save_api_key
+      end
+      @api_key_hash
+    end
+
+    def read_api_key
+      if File.exists? api_key_file
+        return File.read(api_key_file).split("\n")
+      end
+    end
+
+    def echo_off
+      system "stty -echo"
+    end
+
+    def echo_on
+      system "stty echo"
+    end
+
+    def ask_for_api_key
+      puts "Enter your SeleniumShots Account"
+
+      print "Email: "
+      user = ask
+
+      print "Password: "
+      password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+
+      [ user, password ]
+    end
+
+    def ask_for_password_on_windows
+      require "Win32API"
+      char = nil
+      password = ''
+
+      while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
+        break if char == 10 || char == 13 # received carriage return or newline
+        if char == 127 || char == 8 # backspace and delete
+          password.slice!(-1, 1)
+        else
+          password << char.chr
+        end
+      end
+      puts
+      return password
+    end
+
+    def ask_for_password
+      echo_off
+      password = ask
+      puts
+      echo_on
+      return password
+    end
+
+    def save_api_key
+      begin
         @api_key_hash = get_api_key_from_host
-				write_api_key
-			rescue RestClient::Unauthorized => e
-				delete_api_key
-				raise e unless retry_login?
-				display "\nAuthentication failed"
-				@api_key_hash = ask_for_api_key
-				@client = init_selenium_shots
-				retry
-			rescue Exception => e
-				delete_api_key
-				raise e
-			end
-		end
-
-		def retry_login?
-			@login_attempts ||= 0
-			@login_attempts += 1
-			@login_attempts < 3
-		end
-
-		def write_api_key
-			FileUtils.mkdir_p(File.dirname(api_key_file))
-			File.open(api_key_file, 'w') do |f|
-				f.puts self.api_key_hash
-			end
-			set_api_key_permissions
-		end
-
-		def set_api_key_permissions
-			FileUtils.chmod 0700, File.dirname(api_key_file)
-			FileUtils.chmod 0600, api_key_file
-		end
-
-		def delete_api_key
-			FileUtils.rm_f(api_key_file)
-		end
-	end
+        write_api_key
+      rescue RestClient::Unauthorized => e
+        delete_api_key
+        raise e unless retry_login?
+        display "\nAuthentication failed"
+        @api_key_hash = ask_for_api_key
+        @client = init_selenium_shots
+        retry
+      rescue Exception => e
+        delete_api_key
+        raise e
+      end
+    end
+
+    def retry_login?
+      @login_attempts ||= 0
+      @login_attempts += 1
+      @login_attempts < 3
+    end
+
+    def write_api_key
+      FileUtils.mkdir_p(File.dirname(api_key_file))
+      File.open(api_key_file, 'w') do |f|
+        f.puts self.api_key_hash
+      end
+      set_api_key_permissions
+    end
+
+    def set_api_key_permissions
+      FileUtils.chmod 0700, File.dirname(api_key_file)
+      FileUtils.chmod 0600, api_key_file
+    end
+
+    def delete_api_key
+      FileUtils.rm_f(api_key_file)
+    end
+  end
 end
 

data/lib/selenium_shots/cli/commands/base.rb

@@ -1,61 +1,75 @@
 require 'fileutils'
 
 module SeleniumShots::Command
-	class Base
-		attr_accessor :args
-		def initialize(args)
-			@args = args
-		end
+  class Base
+    attr_accessor :args
+    def initialize(args)
+      @args = args
+    end
 
-		def selenium_shots
-			@selenium_shots ||= SeleniumShots::Command.run_internal('auth:client', args)
-		end
+    def selenium_shots
+      @selenium_shots ||= SeleniumShots::Command.run_internal('auth:client', args)
+    end
 
-		def display(msg, newline=true)
-			newline ? puts(msg) : print(msg)
-		end
+    def selenium_shots_api_key
+      @api_key ||= SeleniumShots::Command.run_internal('auth:api_key', args)
+    end
 
-		def ask
-			gets.strip
-		end
+    def display(msg, newline=true)
+      newline ? puts(msg) : print(msg)
+    end
 
-		def shell(cmd)
-			`#{cmd}`
-		end
+    def ask
+      gets.strip
+    end
+
+    def shell(cmd)
+      `#{cmd}`
+    end
 
-		def home_directory
-			running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
-		end
+    def home_directory
+      running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+    end
 
-		def running_on_windows?
-			RUBY_PLATFORM =~ /mswin32/
-		end
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32/
+    end
 
     def config_file
       'config/selenium_shots.yml'
     end
 
+
+  def ask_for_config_file
+    if File.exists?(config_file)
+      print "The file config/selenium_shots.yml exists, do you want overwrite this? (y/n): "
+      ask
+    else
+      "y"
+    end
+  end
+
     def make_config_file(name, api_key)
- 			FileUtils.rm_f(config_file) if File.exists?(config_file)
-      config_file_hash = <<EOFILE
+      overwrite_or_create_file = ask_for_config_file
+      if overwrite_or_create_file == "y"
+        config_file_hash = <<EOFILE
 api_key: "#{api_key}"
-hub_url: 'url'
-hub_port: 'port'
-default_browser_url: 'default url'
+mode: "remote" # "local" for run test locally
+default_browser_url: "http://www.myapp.com"
 application_name: "#{name}"
+local_browser: "firefox"
 browsers:
     - IE8 on XP
+    - Firefox3.6 on XP
 EOFILE
-			File.open(config_file, 'w') do |f|
-				f.puts config_file_hash
-			end
-    end
-
-    def inside_rails_app?
-      File.exists?('config/environment.rb')
+      File.open(config_file, 'w') do |f|
+        f.puts config_file_hash
+      end
     end
+    overwrite_or_create_file
+  end
 
-	end
+  end
 
 end
 

data/lib/selenium_shots/cli/commands/help.rb

@@ -1,15 +1,16 @@
 module SeleniumShots::Command
-	class Help < Base
-		def index
-			display usage
-		end
+  class Help < Base
+    def index
+      display usage
+    end
 
-		def usage
-			usage = <<EOTXT
+    def usage
+      usage = <<EOTXT
 === General Commands
 
- help                         # show this usage
- create [name]                # create file config for your app
+ help                     # show this usage
+ create [name]            # create file config for your app
+
 === Example story:
 
  rails myapp
@@ -17,7 +18,7 @@ module SeleniumShots::Command
  (...make edits...)
  selenium_shots create example_one
 EOTXT
-		end
-	end
+    end
+  end
 end
 

data/lib/selenium_shots/cli/init.rb

@@ -1,9 +1,9 @@
 module SeleniumShots; end
 
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/commands')
 
-require "rubygems" #take this later
-require "base"
 require "client"
 require "command"
+require "base"
 

data/lib/selenium_shots/test_selenium_shots.rb

@@ -1,38 +1,72 @@
 require "test/unit"
 require "rubygems"
 require "selenium/client"
+require "selenium-webdriver"
 require 'active_support'
 require 'active_support/test_case'
 require 'ostruct'
 
-
 #load config
-SeleniumConfig = OpenStruct.new(YAML.load_file("#{RAILS_ROOT}/config/selenium_shots.yml"))
-#
-PICS_WINDOWS_PATH = "Z:"
-PICS_LINUX_PATH   = ''
-PICS_MACOS_PATH   = ''
+ASSET_ROOT = File.expand_path((defined?(Rails) && Rails.root.to_s.length > 0) ? Rails.root : ".") unless defined?(ASSET_ROOT)
+
+SeleniumConfig = OpenStruct.new(YAML.load_file(ASSET_ROOT + '/config/selenium_shots.yml'))
 #
+
 #activeresource models
 class SeleniumTest < ActiveResource::Base
-  self.site = "http://seleniumshots.heroku.com"
+  self.site = "http://seleniumshots.com"
   self.user = SeleniumConfig.api_key
 end
 
+class SeleniumShots < ActionController::IntegrationTest
 
-class ActiveSupport::TestCase
+  attr_reader :driver, :agent, :take_screenshot
+  cattr_accessor :expected_test_count
 
-  attr_reader :browser, :agent
+  if SeleniumConfig.mode == "remote"
+    PICS_WINDOWS_PATH = "Z:"
+    PICS_LINUX_PATH   = ''
+    PICS_MACOS_PATH   = ''
+    HOST = "staging.advisorshq.com"
+    PORT = "8888"
+  else
+    HOST = "127.0.0.1"
+    PORT = "4444"
+  end
 
-  def self.selenium_shot(description, &block)
-    #set vars
-    @description = description
+  def pid_file
+    "/tmp/selenium_shots.pid"
+  end
+
+  def local_browsers
+    ["firefox", "ie", "chrome"]
+  end
 
+  def selected_browsers
+    if SeleniumConfig.mode == "remote"
+      SeleniumConfig.browsers
+    else
+      if defined?(SeleniumConfig.local_browser)
+        [SeleniumConfig.local_browser]
+     else
+        [local_browsers.first]
+     end
+    end
+  end
+  
+  def self.core_test(description, take_screenshot = true, &block)
+    @@group = (@group || "Default")
     test_name = "test_#{description.gsub(/\s+/,'_')}".to_sym
     defined = instance_method(test_name) rescue false
     raise "#{test_name} is already defined in #{self}" if defined
     if block_given?
-      define_method(test_name, &block)
+      define_method(test_name) do
+        @description     = description
+        @take_screenshot = take_screenshot
+        run_in_all_browsers do
+          instance_eval &block
+        end
+      end
     else
       define_method(test_name) do
         flunk "No implementation provided for #{name}"
@@ -40,65 +74,107 @@ class ActiveSupport::TestCase
     end
   end
 
-  def select_browser(browser, url = nil)
-    @browser = Selenium::Client::Driver.new \
-        :host => SeleniumConfig.hub_url,
-        :port => SeleniumConfig.hub_port,
-        :browser => browser,
-        :url => url || SeleniumConfig.default_browser_url,
-        :timeout_in_second => 60,
-        :highlight_located_element => true
-    @browser.start_new_browser_session
+  def self.selenium_test(description, &block)
+    core_test(description, nil, &block)
   end
 
-  def hover_click(locator)
-    browser.mouse_over locator
-    browser.click locator
-    browser.focus locator
+  def self.selenium_shot(description, &block)
+    core_test(description, true, &block)
   end
 
-  def open_and_wait(url)
-    browser.open url
-    browser.wait_for_page_to_load "30000"
+  def run_in_all_browsers(&block)
+    @error = nil
+    browsers = (@selected_browser || selected_browsers)
+    browsers.each do |browser_spec|
+      begin
+        run_webdriver(browser_spec, block)
+      rescue  => error
+        @driver.quit if @driver
+        @error = error.message
+        if @error.match(/Failed to start new browser session/) && SeleniumConfig.mode == "local"
+          @tmp_browsers ||= local_browsers
+          @tmp_browsers.delete(browser_spec)
+          @selected_browser  = [@tmp_browsers.shift]
+          unless @selected_browser.empty?
+            puts "The browser #{browser_spec} is not available, selenium_shots going to try with #{@selected_browser} browser"
+            run_in_all_browsers(&block)
+          end
+        end
+      end
+    end
+    assert @error.nil?, "Expected zero failures or errors, but got #{@error}\n"
   end
+  
+  def run_webdriver(browser_spec, block)
+    
+    client = Selenium::WebDriver::Remote::Http::Default.new
+    client.timeout = 20 # seconds
+    
+    if SeleniumConfig.mode == "local"
+      if /(firefox)/i.match(browser_spec)
+        profile = Selenium::WebDriver::Firefox::Profile.new
+        profile.native_events = false
+        @driver = Selenium::WebDriver.for(:firefox, :profile => profile, :http_client => client)
+      elsif /(chrome)/i.match(browser_spec)
+        @driver = Selenium::WebDriver.for(:chrome, :http_client => client)
+      elsif /(ie)/i.match(browser_spec)
+        @driver = Selenium::WebDriver.for(:ie, :http_client => client)
+      end
+    else
+      caps = nil
+      if /(firefox)/i.match(browser_spec)
+        caps = WebDriver::Remote::Capabilities.firefox
+      elsif /(chrome)/i.match(browser_spec)
+        caps = WebDriver::Remote::Capabilities.chrome
+      elsif /(ie)/i.match(browser_spec)
+        caps = WebDriver::Remote::Capabilities.internet_explorer
+      elsif /(safari)/i.match(browser_spec)
+        caps = WebDriver::Remote::Capabilities.safari
+      elsif /(htmlunit)/i.match(browser_spec)
+        caps = WebDriver::Remote::Capabilities.htmlunit
+        caps.javascript_enabled = true
+      end
 
-  def run_test(&proc)
-    begin
-      proc.call
-      @error = nil
-    rescue => e
-      @error = e.message
+      @driver = Selenium::WebDriver.for(:remote, :desired_capabilities => caps, :http_client => client) if caps
     end
-  end
+    
+    @driver.manage.timeouts.implicit_wait = 2 #seconds
+    @driver.navigate.to SeleniumConfig.default_browser_url
 
-  def teardown
-    save_test ({:selenium_test_group_name => @group, :selenium_test_name => @name,
-                :description => @description})
-    browser.close_current_browser_session
+    begin
+      block.call
+    rescue  => error
+      @error = error.message
+      puts error.message
+      puts error.backtrace
+    ensure
+      save_test({:selenium_test_group_name => @@group, :selenium_test_name => @name,
+                :description => @description}) if SeleniumConfig.mode == "remote"
+      @driver.quit
+    end 
   end
 
   def capture_screenshot_on(src)
     browser.window_focus
     browser.window_maximize
     sleep(2)
-    if browser.browser_string.match(/XP/)
-      browser.capture_entire_page_screenshot("#{PICS_WINDOWS_PATH}\\#{src}", "background=#FFFFFF")
-    elsif browser.browser_string.match(/SnowLeopard/)
-      browser.capture_entire_page_screenshot("#{PICS_MACOS_PATH}/#{src}", "background=#FFFFFF")
-    elsif browser.browser_string.match(/Linux/)
-      browser.capture_entire_page_screenshot("#{PICS_LINUX_PATH}/#{src}", "background=#FFFFFF")
+    if @driver.browser.to_s.match(/XP/)
+      @driver.capture_entire_page_screenshot("#{PICS_WINDOWS_PATH}\\#{src}", "background=#FFFFFF")
+    elsif @driver.browser.to_s.match(/SnowLeopard/)
+      @driver.capture_entire_page_screenshot("#{PICS_MACOS_PATH}/#{src}", "background=#FFFFFF")
+    elsif @driver.browser.to_s.match(/Linux/)
+      @driver.capture_entire_page_screenshot("#{PICS_LINUX_PATH}/#{src}", "background=#FFFFFF")
     end
   end
 
   def save_test(params)
     src = "#{SeleniumConfig.application_name}_#{params[:selenium_test_group_name]}_#{params[:selenium_test_name]}_" +
-          "#{browser.browser_string.gsub(/\s+/,"_").downcase}.png"
+           "#{@driver.browser.to_s.gsub(/\s+/,"_").downcase}.png"
 
     capture_screenshot_on(src)
 
     SeleniumTest.create(:selenium_test_name => params[:selenium_test_name], :description => params[:description],
-      :url => browser.location, :error_message => @error, :is_error => !@error.nil?, :environment => browser.browser_string,
+      :url => @driver.current_url, :error_message => @error, :is_error => !@error.nil?, :environment => @driver.browser.to_s,
       :selenium_test_group_name => params[:selenium_test_group_name], :application_name => SeleniumConfig.application_name)
   end
 end
-

data/spec/base.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'spec'
+require 'fileutils'
+
+require File.dirname(__FILE__) + '/../lib/selenium_shots/cli/init'
+
+%w(app auth base server).each { |c| require c }
+
+def prepare_command(klass)
+	command = klass.new([])
+	command.stub!(:display)
+	command
+end
+

data/spec/commands/app_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../base'
+
+module SeleniumShots::Command
+  describe App do
+    before do
+      @cli  = prepare_command(App)
+      @auth = prepare_command(Auth)
+    end
+
+    it "creates with a name" do
+      @cli.stub!(:args).and_return([ 'myapp' ])
+      @cli.stub!(:selenium_shots_api_key).and_return("api_key")
+      @cli.should_receive(:make_config_file)
+      @cli.create
+    end
+
+    it "cant creates app without a name" do
+      @cli.stub!(:args).and_return([ nil ])
+      @cli.stub!(:selenium_shots_api_key)
+      @cli.should_not_receive(:make_config_file)
+      @cli.create
+    end
+
+  end
+end
+

data/spec/commands/auth_spec.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../base'
+
+module SeleniumShots::Command
+  describe Auth do
+    before do
+      @cli = prepare_command(Auth)
+    end
+
+    it "reads api key from the api keys file" do
+      sandbox = "/tmp/cli_spec_#{Process.pid}"
+      File.open(sandbox, "w") { |f| f.write "api_key" }
+      @cli.stub!(:api_key_file).and_return(sandbox)
+      @cli.read_api_key.should == %w(api_key)
+    end
+
+    it "takes the apikey from the file" do
+      @cli.stub!(:read_api_key).and_return(%w(api_key))
+      @cli.api_key.should == %w(api_key)
+    end
+
+    it "asks for api_key when the file doesn't exist" do
+      sandbox = "/tmp/cli_spec_#{Process.pid}"
+      FileUtils.rm_rf(sandbox)
+      @cli.stub!(:api_key_file).and_return(sandbox)
+      @cli.should_receive(:ask_for_api_key).and_return(['u', 'p'])
+      @cli.should_receive(:save_api_key)
+      @cli.get_api_key.should == [ 'u', 'p' ]
+    end
+
+    it "writes the api_key to a file" do
+      sandbox = "/tmp/cli_spec_#{Process.pid}"
+      FileUtils.rm_rf(sandbox)
+      @cli.stub!(:api_key_file).and_return(sandbox)
+      @cli.stub!(:api_key_hash).and_return(['api_key'])
+      @cli.should_receive(:set_api_key_permissions)
+      @cli.write_api_key
+      File.read(sandbox).should == "api_key\n"
+    end
+
+    it "sets ~/.selenium_shots/api_key to be readable only by the user" do
+      sandbox = "/tmp/cli_spec_#{Process.pid}"
+      FileUtils.rm_rf(sandbox)
+      FileUtils.mkdir_p(sandbox)
+      fname = "#{sandbox}/file"
+      system "touch #{fname}"
+      @cli.stub!(:api_key_file).and_return(fname)
+      @cli.set_api_key_permissions
+      File.stat(sandbox).mode.should == 040700
+      File.stat(fname).mode.should == 0100600
+    end
+
+    it "writes api_key when the account is ok" do
+      @cli.stub!(:api_key)
+      @cli.should_receive(:write_api_key)
+      @cli.should_receive(:get_api_key_from_host).and_return("api_key")
+      @cli.save_api_key
+    end
+
+    it "save_api_key deletes the api_key when the resquest api_key is unauthorized" do
+      @cli.stub!(:write_api_key)
+      @cli.stub!(:retry_login?).and_return(false)
+      @cli.should_receive(:get_api_key_from_host).and_raise(RestClient::Unauthorized)
+      @cli.should_receive(:delete_api_key)
+      lambda { @cli.save_api_key }.should raise_error(RestClient::Unauthorized)
+    end
+
+
+    it "asks for login again when not authorized, for three times" do
+      @cli.stub!(:read_api_key)
+      @cli.stub!(:write_api_key)
+      @cli.stub!(:delete_api_key)
+      @cli.should_receive(:get_api_key_from_host).exactly(3).times.and_raise(RestClient::Unauthorized)
+      @cli.should_receive(:ask_for_api_key).exactly(4).times
+      lambda { @cli.save_api_key }.should raise_error(RestClient::Unauthorized)
+    end
+
+    it "deletes the api_key file" do
+      FileUtils.should_receive(:rm_f).with(@cli.api_key_file)
+      @cli.delete_api_key
+    end
+  end
+end
+

data/spec/commands/base_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../base'
+
+module SeleniumShots::Command
+  describe Base do
+    before do
+      @args = [1, 2]
+      @base = Base.new(@args)
+      @base.stub!(:display)
+    end
+
+    it "initializes the selenium_shots client with the Auth command" do
+      SeleniumShots::Command.should_receive(:run_internal).with('auth:client', @args)
+      @base.selenium_shots
+    end
+
+    it "creates or overwrite the selenium_shots yml file" do
+      sandbox = "/tmp/cli_spec_selenium_shots"
+      @base.stub!(:config_file).and_return(sandbox)
+      @base.should_receive(:ask_for_config_file).and_return("y")
+      @base.make_config_file("myapp", "api_key")
+      File.exists?(sandbox) == true
+    end
+
+    it "not overwrite the selenium_shots yml file" do
+      sandbox = "/tmp/cli_spec_selenium_shots"
+      @base.stub!(:config_file).and_return(sandbox)
+      @base.should_receive(:ask_for_config_file).and_return("n")
+      @base.make_config_file("myapp", "api_key")
+      File.exists?(sandbox) == false
+    end
+
+    it "return the config file name" do
+      @base.config_file.should == 'config/selenium_shots.yml'
+    end
+
+  end
+end
+

data/spec/commands/server_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../base'
+
+module SeleniumShots::Command
+  describe Server do
+    before do
+      @cli = prepare_command(Server)
+    end
+
+    it "run local instance of selenium server" do
+      @cli.start
+      File.exists?("/tmp/selenium_shots.pid") == true
+    end
+
+    it "stop local instance of selenium server" do
+      @cli.stop
+      File.exists?("/tmp/selenium_shots.pid") == false
+    end
+
+
+  end
+end
+

metadata

@@ -5,17 +5,18 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 0
-  version: 0.0.0
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - Kyle J. Ginavan
 - Mauro Torres
+- Mike Hemesath
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-04-08 00:00:00 -05:00
+date: 2010-12-21 00:00:00 -06:00
 default_executable: selenium_shots
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,21 +32,21 @@ dependencies:
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rest-client
+  name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
         segments: 
-        - 0
-        - 8
-        - 2
-        version: 0.8.2
-  type: :runtime
+        - 1
+        - 1
+        - 12
+        version: 1.1.12
+  type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: launchy
+  name: selenium-webdriver
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
@@ -53,23 +54,23 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 3
-        - 2
-        version: 0.3.2
+        - 1
+        - 0
+        version: 0.1.0
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: selenium-client
+  name: rest-client
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
+        - 0
+        - 8
         - 2
-        - 18
-        version: 1.2.18
+        version: 0.8.2
   type: :runtime
   version_requirements: *id004
 description: Selenium Shots is an Integration Testing Service that transparently distributes your integration tests across multiple operating systems with different versions of all major browsers AND captures a screen shot
@@ -126,5 +127,11 @@ signing_key:
 specification_version: 3
 summary: Integration Tests made easy
 test_files: 
+- spec/base.rb
+- spec/commands/app_spec.rb
+- spec/commands/auth_spec.rb
+- spec/commands/base_spec.rb
+- spec/commands/server_spec.rb
 - test/helper.rb
 - test/test_selenium_shots.rb
+- examples/google.rb