browser_shooter 0.2.3 → 0.3.1

data/lib/browser_shooter/base.rb

@@ -0,0 +1,65 @@
+module BrowserShooter
+  class Base
+    attr_reader :opts
+
+    def initialize( opts )
+      @opts = opts
+    end
+
+    def run
+      BrowserShooter::Logger.verbose = opts[:verbose]
+      BrowserShooter::Logger.log( "Starting script running with version #{BrowserShooter::VERSION}..." )
+
+      config = BrowserShooter::Configurator.new( opts )
+      suites = config.suites
+
+      suites.each do |suite|
+        suite.tests.each do |test|
+          suite.browsers.each do |browser|
+            BrowserShooter::Base.run_test(
+              suite,
+              test,
+              browser,
+              config["output_path"]
+            )
+          end
+        end
+      end
+
+      BrowserShooter::Logger.log( "... script running ended." )
+      BrowserShooter::Logger.log( "Logs and Shots are in: #{config["output_path"]}", true )
+      BrowserShooter::Logger.log( "BYE!" )
+    end
+
+    def self.run_test( suite, test, browser, output_path )
+      BrowserShooter::Logger.log( "Executing #{suite.name} | #{test.name} | #{browser.name}", true )
+      output_path = "#{output_path}/#{suite.name}/#{test.name}/#{browser.name}"
+
+      driver = nil
+
+      begin
+        driver =
+          Selenium::WebDriver.for(
+            :remote,
+            :url => browser.url,
+            :desired_capabilities => browser.type.to_sym
+          )
+
+        logs =
+          BrowserShooter::Commander.script(
+            test.commands,
+            driver,
+            output_path
+          )
+
+        BrowserShooter::LogExporter.export(
+          logs,
+          "#{output_path}/logs"
+        )
+
+      ensure
+        driver.quit if driver
+      end
+    end
+  end
+end

data/lib/browser_shooter/commander.rb

@@ -1,141 +1,143 @@
-class BrowserShooter
-  module Commander
-    def self.execute( command, client, shots_path )
-      BrowserShooter::Logger.log "command: #{command}"
-
-      if( command.split[0].strip == "shot" )
-        sufix = command.split[1] ? command.split[1].strip : nil
-
-        BrowserShooter::Commander.shot(
-          client,
-          shots_path,
-          sufix
-        )
+module BrowserShooter::Commander
+
+  def self.script( commands, driver, output_path )
+    test_result =
+      commands.map do |command|
+        command_result =
+          BrowserShooter::Commander.wrapper_execute(
+            command.strip,
+            driver,
+            output_path
+          )
 
-      elsif( command.split[0].strip == "shot_system" )
-        sufix = command.split[1] ? command.split[1].strip : nil
+        BrowserShooter::Logger.command_result( command_result )
 
-        BrowserShooter::Commander.shot_system(
-          client,
-          shots_path,
-          sufix
-        )
+        command_result
+      end
 
-      elsif( command.split[0].strip == "pause" )
-        BrowserShooter::Commander.pause( command.split[1].strip.to_i )
+    BrowserShooter::Logger.test_result( test_result )
 
-      elsif( command.split[0].strip == "wait_for_element" )
-        params = command.match /wait_for_element "(.*)"\s?,\s?(\d*)/
+    test_result
+  end
 
-        BrowserShooter::Commander.wait_for_element(
-          client,
-          params[1],
-          params[2].to_i
-        )
+  def self.execute( command, driver, output_path )
+    BrowserShooter::Logger.log "command: #{command}"
 
-      elsif( command.split[0].strip == "type" )
-        params = command.match /type "(.*)"\s?,\s?"(.*)"/
+    if( command.split[0].strip == "shot" )
+      sufix = command.split[1] ? command.split[1].strip : nil
 
-        BrowserShooter::Commander.type(
-          client,
-          params[1],
-          params[2]
-        )
+      BrowserShooter::Commander.shot(
+        driver,
+        output_path,
+        sufix
+      )
 
-      elsif( command.split[0].strip == "click" )
-        params = command.match /click "(.*)"/
-        BrowserShooter::Commander.click(
-          client,
-          params[1]
-        )
+    elsif( command.split[0].strip == "pause" )
+      BrowserShooter::Commander.pause( command.split[1].strip.to_i )
 
-      else
-        eval "client.#{command}"
+    elsif( command.split[0].strip == "wait_for_element" )
+      params = command.match /wait_for_element "(.*)"\s?,\s?(\d*)/
 
-      end
-    end
+      BrowserShooter::Commander.wait_for_element(
+        driver,
+        params[1],
+        params[2].to_i
+      )
 
-    def self.wrapper_execute( command, client, shots_path )
-      result = {
-        :time     => Time.now.to_i,
-        :command  => command
-      }
-
-      begin
-        message =
-          BrowserShooter::Commander.execute(
-            command,
-            client,
-            shots_path
-          )
+    elsif( command.split[0].strip == "type" )
+      params = command.match /type "(.*)"\s?,\s?"(.*)"/
 
-        result.merge!(
-          :success => true,
-          :message => message
-        )
+      BrowserShooter::Commander.type(
+        driver,
+        params[1],
+        params[2]
+      )
 
-      rescue Exception => e
-        BrowserShooter::Logger.log "ERROR: #{e.message}"
+    elsif( command.split[0].strip == "click" )
+      params = command.match /click "(.*)"/
+      BrowserShooter::Commander.click(
+        driver,
+        params[1]
+      )
+
+    else
+      eval "driver.#{command}"
+
+    end
+  end
 
-        result.merge!(
-          :success  => false,
-          :message  => e.message
+  def self.wrapper_execute( command, driver, output_path )
+    result = {
+      :time     => Time.now.to_i,
+      :command  => command
+    }
+
+    begin
+      message =
+        BrowserShooter::Commander.execute(
+          command,
+          driver,
+          output_path
         )
 
-      end
 
-      return result
-    end
+      result.merge!(
+        :success => true,
+        :message => message
+      )
 
-    def self.shot( client, path, sufix = nil )
-      sufix = timestamp unless sufix
-      path  = "#{path}_#{sufix}.png"
+    rescue Exception => e
+      BrowserShooter::Logger.log "ERROR: #{e.message}"
 
-      BrowserShooter::Logger.log "shooting in '#{path}'"
-      client.save_screenshot path
+      # puts "XXX: Exception"
+      # puts e.backtrace.join( "\n" )
+
+      result.merge!(
+        :success  => false,
+        :message  => e.message
+      )
 
-      return path
     end
 
-    # FIXME: Not supported in WebDriver
-    # def self.shot_system( client, path, sufix = timestamp )
-    #   sufix = timestamp unless sufix
-    #   path  = "#{path}_#{sufix}.system.png"
+    return result
+  end
 
-    #   BrowserShooter::Logger.log "shooting system in '#{path}'"
+  def self.shot( driver, output_path, sufix = nil )
+    sufix     = timestamp unless sufix
+    shot_path = "#{output_path}/shots/#{sufix}.png"
 
-    #   File.open( path, "wb" ) do |f|
-    #     f.write( Base64.decode64( client.capture_screenshot_to_string ) )
-    #   end
+    BrowserShooter::Logger.log "shooting in '#{shot_path}'"
 
-    #   return path
-    # end
+    FileUtils.mkdir_p( File.dirname( shot_path ) )
+    driver.save_screenshot( shot_path )
 
-    def self.wait_for_element( client, css_selector, timeout )
-      wait = Selenium::WebDriver::Wait.new( :timeout => timeout )
+    return shot_path
+  end
 
-      wait.until do
-        client.find_element( "css", css_selector )
-      end
-    end
+  def self.wait_for_element( driver, css_selector, timeout )
+    wait = Selenium::WebDriver::Wait.new( :timeout => timeout )
 
-    def self.click( client, css_selector )
-      client.find_element( "css", css_selector ).click
+    wait.until do
+      driver.find_element( "css", css_selector )
     end
+  end
 
-    def self.type( client, css_selector, text )
-      client.find_element( "css", css_selector ).send_keys( text )
-    end
+  def self.click( driver, css_selector )
+    driver.find_element( "css", css_selector ).click
+  end
 
-    def self.pause( seconds )
-      BrowserShooter::Logger.log "pausing #{seconds} seconds"
-      Kernel.sleep seconds
+  def self.type( driver, css_selector, text )
+    driver.find_element( "css", css_selector ).send_keys( text )
+  end
 
-      return "#{seconds} seconds later..."
-    end
+  def self.pause( seconds )
+    BrowserShooter::Logger.log "pausing #{seconds} seconds"
+    Kernel.sleep seconds
 
-    def self.timestamp
-      Time.now.to_i
-    end
+    return "#{seconds} seconds later..."
+  end
+
+  def self.timestamp
+    Time.now.to_i
   end
-end
+end

data/lib/browser_shooter/configurator.rb

@@ -1,5 +1,80 @@
-class BrowserShooter
-  module Configurator
+module BrowserShooter
+  class Configurator
+    attr_reader :suites
+
+    def initialize( opts )
+      @config = BrowserShooter::Configurator.load_config( opts[:config_file] )
+      models = BrowserShooter::Configurator.build_models( @config )
+      @suites = BrowserShooter::Configurator.filter_suites( models, opts )
+    end
+
+    def [](value)
+      @config[value]
+    end
+
+    def self.filter_suites( models, opts )
+      suites = []
+
+      if( opts[:suite] )
+        suite  = models[:suites].select{ |e| e.name == opts[:suite] }.first
+        raise ArgumentError, "Not suite found '#{opts[:suite]}'" if suite.nil?
+
+        suites = [suite]
+
+      elsif( opts[:test] && opts[:browsers] )
+        test      = models[:tests].select{ |e| e.name == opts[:test] }.first
+        raise ArgumentError, "Not test found '#{opts[:test]}'" if test.nil?
+
+        browsers  = models[:browsers].select{ |e| opts[:browsers].include? e.name }
+        raise ArgumentError, "Not browsers found '#{opts[:browsers].join( "," )}'" if browsers.empty?
+
+        suite     = BrowserShooter::Models::Suite.new( "anonymous", [test], browsers )
+        suites    = [suite]
+
+      elsif( opts[:test] )
+        test      = models[:tests].select{ |e| e.name == opts[:test] }.first
+        raise ArgumentError, "Not test found '#{opts[:test]}'" if test.nil?
+
+        browsers  = models[:browsers]
+        suite     = BrowserShooter::Models::Suite.new( "anonymous", [test], browsers )
+        suites    = [suite]
+
+      else
+        suites    = models[:suites]
+
+      end
+
+      suites
+    end
+
+    def self.build_models( config )
+      tests =
+        config["tests"].map do |name, commands|
+          test_commands = commands.split( "\n" )
+
+          BrowserShooter::Models::Test.new( name, test_commands )
+        end
+
+      browsers =
+        config["browsers"].map do |name, opts|
+          BrowserShooter::Models::Browser.new( name, opts["url"], opts["type"] )
+        end
+
+      suites =
+        config["suites"].map do |name, opts|
+          suite_tests    = tests.select{ |e| opts["tests"].include? e.name }
+          suite_browsers = browsers.select{ |e| opts["browsers"].include? e.name }
+
+          BrowserShooter::Models::Suite.new( name, suite_tests, suite_browsers )
+        end
+
+      {
+        :tests    => tests,
+        :browsers => browsers,
+        :suites   => suites
+      }
+    end
+
     def self.load_config( config_file_path )
       config = {
         "output_path" => "~/browser_shooter",
@@ -17,10 +92,6 @@ class BrowserShooter
       output_path = File.expand_path( "#{output_path}/#{timestamp}" )
       BrowserShooter::Logger.log( "output_path: #{output_path}" )
 
-      FileUtils.mkdir_p( output_path )
-      FileUtils.mkdir( "#{output_path}/shots" )
-      FileUtils.mkdir( "#{output_path}/logs" )
-
       output_path
     end
 

data/lib/browser_shooter/log_exporter.rb

@@ -1,26 +1,20 @@
-class BrowserShooter
+module BrowserShooter
   module LogExporter
-    def self.export( logs, path, format )
-      BrowserShooter::Logger.log "Exporting '#{format}' logs to #{path}"
-      send(:"export_to_#{format}", logs, path )
-    end
+    def self.export( logs, logs_path, format = "csv" )
+      logs_path = File.expand_path( "#{logs_path}/log.#{format}" )
+      BrowserShooter::Logger.log "Exporting '#{format}' logs to #{logs_path}"
+      FileUtils.mkdir_p( File.dirname( logs_path ) )
 
-    def self.export_to_json( logs, path )
-      File.open( "#{path}/logs.json", "w" ) do |f|
-        f.write JSON.pretty_generate( logs )
-      end
+      send(:"export_to_#{format}", logs, logs_path )
     end
 
     def self.export_to_csv( logs, path )
-      logs.each do |script_name, results|
-        _path = File.expand_path "#{path}/#{script_name}.csv"
-
-        File.open( _path, "w" ) do |f|
-          f.puts results.first.keys.join( " | " )
+      File.open( path, "w" ) do |f|
+        f.puts "time | success | command | message"
 
-          results.each do |result|
-            f.puts result.values.join( " | " )
-          end
+        logs.each do |result|
+          line = "#{result[:time]} | #{result[:success]} | #{result[:command]} | #{result[:message]}".gsub( "\n", " - " )
+          f.puts line
         end
       end
     end

data/lib/browser_shooter/logger.rb

@@ -1,7 +1,24 @@
-class BrowserShooter
+module BrowserShooter
   module Logger
-    def self.log( message )
-      puts "[BrowserShooter #{Time.now.strftime( "%F %T" )}] #{message}"
+    extend self
+
+    attr_accessor :verbose
+
+    def log( message, force = verbose )
+      if force
+        Kernel.puts "[BrowserShooter #{Time.now.strftime( "%F %T" )}] #{message}"
+      end
     end
+
+    def command_result( command_result )
+      Kernel.print "." if command_result[:success]
+      Kernel.print "F" if !command_result[:success]
+    end
+
+    def test_result( test_result )
+      Kernel.puts " (success)" if test_result.all? { |e| e[:success] }
+      Kernel.puts " (fail)"    if !test_result.all? { |e| e[:success] }
+    end
+
   end
 end