browser_shooter 0.2.3 → 0.3.1

data/lib/browser_shooter/models/browser.rb

@@ -0,0 +1,6 @@
+module BrowserShooter
+  module Models
+    class Browser < Struct.new( :name, :url, :type )
+    end
+  end
+end

data/lib/browser_shooter/models/suite.rb

@@ -0,0 +1,6 @@
+module BrowserShooter
+  module Models
+    class Suite < Struct.new( :name, :tests, :browsers )
+    end
+  end
+end

data/lib/browser_shooter/models/test.rb

@@ -0,0 +1,6 @@
+module BrowserShooter
+  module Models
+    class Test < Struct.new( :name, :commands )
+    end
+  end
+end

data/lib/browser_shooter/version.rb

@@ -1,3 +1,3 @@
-class BrowserShooter
-  VERSION = "0.2.3"
+module BrowserShooter
+  VERSION = "0.3.1"
 end

data/test/argv_parser_test.rb

@@ -0,0 +1,15 @@
+require_relative "test_helper"
+
+class ARGVParserTest < Test::Unit::TestCase
+  def test_parse_options
+    argvs = "-c my/file/path.yml -v -s my_suite -t my_test -b browser1,browser2"
+    argv_parser = BrowserShooter::ARGVParsers.new
+    argv_parser.parse_options( argvs.split )
+
+    assert_equal( "my/file/path.yml", argv_parser.config[:config_file] )
+    assert_equal( "my_suite", argv_parser.config[:suite] )
+    assert_equal( "my_test", argv_parser.config[:test] )
+    assert_equal( ["browser1", "browser2"], argv_parser.config[:browsers] )
+    assert_equal( true, argv_parser.config[:verbose] )
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,51 @@
+require_relative "test_helper"
+
+class BaseTest < Test::Unit::TestCase
+  def setup
+    super
+
+    @test1     = BrowserShooter::Models::Test.new( "test1", ["command1", "command2"] )
+    @test2     = BrowserShooter::Models::Test.new( "test2", ["command3"] )
+    @browser1  = BrowserShooter::Models::Browser.new( "browser1", "url1", "type1" )
+    @browser2  = BrowserShooter::Models::Browser.new( "browser2", "url2", "type2" )
+    @suite1    = BrowserShooter::Models::Suite.new( "suite1", [@test1, @test2], [@browser1, @browser2] )
+  end
+
+  def test_initialize
+    assert_equal( "opts", BrowserShooter::Base.new( "opts" ).opts )
+  end
+
+  def test_run
+    BrowserShooter::Configurator.stubs( :set_up_output_path )
+
+    opts = {}
+
+    config_mock = mock()
+    BrowserShooter::Configurator.expects( :new ).with( opts ).returns( config_mock )
+
+    config_mock.stubs( :[] ).returns( "config_value" )
+    config_mock.expects( :suites ).returns( [@suite1] )
+
+    BrowserShooter::Base.expects( :run_test ).with( @suite1, @test1, @browser1, "config_value" )
+    BrowserShooter::Base.expects( :run_test ).with( @suite1, @test1, @browser2, "config_value" )
+    BrowserShooter::Base.expects( :run_test ).with( @suite1, @test2, @browser1, "config_value" )
+    BrowserShooter::Base.expects( :run_test ).with( @suite1, @test2, @browser2, "config_value" )
+
+    BrowserShooter::Base.new( opts ).run
+  end
+
+  def test_run_script
+    expected_opts = {
+      :url                    => "url1",
+      :desired_capabilities   => "type1".to_sym
+    }
+
+    driver = mock()
+    driver.expects( :quit )
+    Selenium::WebDriver.expects( :for ).with( :remote, expected_opts ).returns( driver )
+    BrowserShooter::Commander.expects( :script ).with( @test1.commands, driver, "output_path/suite1/test1/browser1" ).returns( "log1" )
+    BrowserShooter::LogExporter.expects( :export ).with( "log1", "output_path/suite1/test1/browser1/logs" )
+
+    BrowserShooter::Base.run_test( @suite1, @test1, @browser1, "output_path" )
+  end
+end

data/test/commander_test.rb

@@ -1,54 +1,61 @@
 require_relative "test_helper"
 
 class CommanderTest < Test::Unit::TestCase
-  def test_execute_when_shot_with_sufix
-    BrowserShooter::Commander.expects( :shot ).with( "client", "shoot-path", "sufix" )
-    BrowserShooter::Commander.execute( "shot sufix", "client", "shoot-path" )
-  end
+  def test_script
+    commands = [
+      "command1",
+      "  command2 "
+    ]
 
-  def test_execute_when_shot_without_sufix
-    BrowserShooter::Commander.expects( :shot ).with( "client", "shoot-path", nil )
-    BrowserShooter::Commander.execute( "shot", "client", "shoot-path" )
+    BrowserShooter::Commander.expects( :wrapper_execute ).with( "command1", "driver", "output_path" ).returns( "result1" )
+    BrowserShooter::Commander.expects( :wrapper_execute ).with( "command2", "driver", "output_path" ).returns( "result2" )
+    BrowserShooter::Logger.expects( :command_result ).twice
+    BrowserShooter::Logger.expects( :test_result )
+
+    result = BrowserShooter::Commander.script( commands, "driver", "output_path" )
+
+    assert_equal( ["result1", "result2"], result )
   end
 
-  def test_execute_when_shot_system_with_sufix
-    BrowserShooter::Commander.expects( :shot_system ).with( "client", "shoot-path", "sufix" )
-    BrowserShooter::Commander.execute( "shot_system sufix", "client", "shoot-path" )
+  def test_execute_when_shot_with_sufix
+    BrowserShooter::Commander.expects( :shot ).with( "driver", "shoot-path", "sufix" )
+    BrowserShooter::Commander.execute( "shot sufix", "driver", "shoot-path" )
   end
 
-  def test_execute_when_shot_system_without_sufix
-    BrowserShooter::Commander.expects( :shot_system ).with( "client", "shoot-path", nil )
-    BrowserShooter::Commander.execute( "shot_system", "client", "shoot-path" )
+  def test_execute_when_shot_without_sufix
+    BrowserShooter::Commander.expects( :shot ).with( "driver", "shoot-path", nil )
+    BrowserShooter::Commander.execute( "shot", "driver", "shoot-path" )
   end
 
   def test_execute_when_pause
     BrowserShooter::Commander.expects( :pause ).with( 10 )
-    BrowserShooter::Commander.execute( "pause 10", "client", "shoot-path" )
+    BrowserShooter::Commander.execute( "pause 10", "driver", "shoot-path" )
   end
 
   def test_execute_when_wait_for_element
-    BrowserShooter::Commander.expects( :wait_for_element ).with( "client", "css_selector", 10 )
-    BrowserShooter::Commander.execute( "wait_for_element \"css_selector\", 10", "client", nil )
+    BrowserShooter::Commander.expects( :wait_for_element ).with( "driver", "css_selector", 10 )
+    BrowserShooter::Commander.execute( "wait_for_element \"css_selector\", 10", "driver", nil )
   end
 
   def test_execute_when_click
-    BrowserShooter::Commander.expects( :click ).with( "client", "css_selector" )
-    BrowserShooter::Commander.execute( "click \"css_selector\"", "client", nil )
+    BrowserShooter::Commander.expects( :click ).with( "driver", "css_selector" )
+    BrowserShooter::Commander.execute( "click \"css_selector\"", "driver", nil )
   end
 
   def test_execute_when_type
-    BrowserShooter::Commander.expects( :type ).with( "client", "css_selector", "message a b" )
-    BrowserShooter::Commander.execute( "type \"css_selector\", \"message a b\"", "client", nil )
+    BrowserShooter::Commander.expects( :type ).with( "driver", "css_selector", "message a b" )
+    BrowserShooter::Commander.execute( "type \"css_selector\", \"message a b\"", "driver", nil )
   end
 
   def test_shot_with_sufix
     in_tmpdir do |tmpdir|
-      client = mock()
-      path = "#{tmpdir}/myfile"
+      driver      = mock()
+      output_path = tmpdir
 
-      client.expects( :save_screenshot ).with( "#{path}_sufix.png" )
+      FileUtils.expects( :mkdir_p ).with( "#{output_path}/shots" )
+      driver.expects( :save_screenshot ).with( "#{output_path}/shots/sufix.png" )
 
-      BrowserShooter::Commander.shot( client, path, "sufix" )
+      BrowserShooter::Commander.shot( driver, output_path, "sufix" )
     end
   end
 
@@ -56,75 +63,45 @@ class CommanderTest < Test::Unit::TestCase
     BrowserShooter::Commander.stubs( :timestamp ).returns( "timestamp" )
 
     in_tmpdir do |tmpdir|
-      client = mock()
-      path = "#{tmpdir}/myfile"
+      driver      = mock()
+      output_path = tmpdir
 
-      client.expects( :save_screenshot ).with( "#{path}_timestamp.png" )
+      FileUtils.expects( :mkdir_p ).with( "#{output_path}/shots" )
+      driver.expects( :save_screenshot ).with( "#{output_path}/shots/timestamp.png" )
 
-      BrowserShooter::Commander.shot( client, path, nil )
+      BrowserShooter::Commander.shot( driver, output_path, nil )
     end
   end
 
-  # FIXME: shot_system not supported in WebDriver
-  # def test_shot_system_with_sufix
-  #   in_tmpdir do |tmpdir|
-  #     client = stub( :capture_screenshot_to_string => read_fixture( "screenshot.base64" ) )
-  #     path = "#{tmpdir}/myfile"
-
-  #     BrowserShooter::Commander.shot_system( client, path, "sufix" )
-
-  #     assert_equal(
-  #      Digest::MD5.hexdigest( Base64.decode64( read_fixture( "screenshot.base64" ) ) ),
-  #      Digest::MD5.hexdigest( File.read( "#{path}_sufix.system.png" ) )
-  #     )
-  #   end
-  # end
-
-  # def test_shot_system_without_sufix
-  #   BrowserShooter::Commander.stubs( :timestamp ).returns( "timestamp" )
-
-  #   in_tmpdir do |tmpdir|
-  #     client = stub( :capture_screenshot_to_string => read_fixture( "screenshot.base64" ) )
-  #     path = "#{tmpdir}/myfile"
-
-  #     BrowserShooter::Commander.shot_system( client, path, nil )
-
-  #     assert_equal(
-  #      Digest::MD5.hexdigest( Base64.decode64( read_fixture( "screenshot.base64" ) ) ),
-  #      Digest::MD5.hexdigest( File.read( "#{path}_timestamp.system.png" ) )
-  #     )
-  #   end
-  # end
-
   def test_wait_for_element
     wait    = mock()
-    client  = mock()
+    driver  = mock()
 
     Selenium::WebDriver::Wait.expects( :new ).with( :timeout => 10 ).returns( wait )
     wait.expects( :until ).yields
-    client.expects( :find_element ).with( "css", "css_selector" )
+    driver.expects( :find_element ).with( "css", "css_selector" )
 
-    BrowserShooter::Commander.wait_for_element( client, "css_selector", 10 )
+    BrowserShooter::Commander.wait_for_element( driver, "css_selector", 10 )
   end
 
   def test_click
-    client  = mock()
+    driver  = mock()
     element = mock()
 
-    client.expects( :find_element ).with( "css", "css_selector" ).returns( element )
+    driver.expects( :find_element ).with( "css", "css_selector" ).returns( element )
     element.expects( :click )
 
-    BrowserShooter::Commander.click( client, "css_selector" )
+    BrowserShooter::Commander.click( driver, "css_selector" )
   end
 
   def test_type
-    client  = mock()
+    driver  = mock()
     element = mock()
 
-    client.expects( :find_element ).with( "css", "css_selector" ).returns( element )
+    driver.expects( :find_element ).with( "css", "css_selector" ).returns( element )
     element.expects( :send_keys ).with( "message" )
 
-    BrowserShooter::Commander.type( client, "css_selector", "message" )
+    BrowserShooter::Commander.type( driver, "css_selector", "message" )
   end
 
   def test_pause

data/test/configurator_test.rb

@@ -1,11 +1,77 @@
 require_relative "test_helper"
 
 class ConfiguratorTest < Test::Unit::TestCase
+  def test_initialize
+    opts    = { :config_file => "config_file" }
+    config  = { :key1 => "value1" }
+
+    BrowserShooter::Configurator.expects( :load_config ).with( "config_file" ).returns( config )
+    BrowserShooter::Configurator.expects( :build_models ).with( config ).returns( "models" )
+    BrowserShooter::Configurator.expects( :filter_suites ).with( "models", opts ).returns( "suites" )
+
+    configurator = BrowserShooter::Configurator.new( opts )
+
+    assert_equal( "value1", configurator[:key1] )
+    assert_equal( "suites", configurator.suites )
+  end
+
+  def test_build_models
+    BrowserShooter::Configurator.stubs( :set_up_output_path )
+    config = BrowserShooter::Configurator.load_config( "#{FIXTURES}/config.yml" )
+    models = BrowserShooter::Configurator.build_models( config )
+
+    assert_equal( 2, models[:tests].size )
+    assert_equal( "google", models[:tests].first.name )
+    assert_equal( 6, models[:tests].first.commands.size )
+    assert_equal( "navigate.to \"http://www.google.de\"", models[:tests].first.commands.first )
+
+    assert_equal( 3, models[:browsers].size )
+    assert_equal( "windows-firefox", models[:browsers].first.name )
+    assert_equal( "http://10.211.55.4:4444/wd/hub", models[:browsers].first.url )
+    assert_equal( "firefox", models[:browsers].first.type )
+
+    assert_equal( 2, models[:suites].size )
+    assert_equal( "suite1", models[:suites].first.name )
+    assert_equal( 2, models[:suites].first.tests.size )
+    assert_equal( models[:tests].first, models[:suites].first.tests.first )
+    assert_equal( 2, models[:suites].first.browsers.size )
+    assert_equal( models[:browsers].first, models[:suites].first.browsers.first )
+  end
+
+  def test_filter_suites
+    BrowserShooter::Configurator.stubs( :set_up_output_path )
+    config = BrowserShooter::Configurator.load_config( "#{FIXTURES}/config.yml" )
+    models = BrowserShooter::Configurator.build_models( config )
+
+    opts = {}
+    suites = BrowserShooter::Configurator.filter_suites( models, opts )
+    assert_equal( 2, suites.size )
+
+    opts = { :suite => "suite2" }
+    suites = BrowserShooter::Configurator.filter_suites( models, opts )
+    assert_equal( 1, suites.size )
+    assert_equal( "suite2", suites.first.name )
+
+    opts = { :test => "google" }
+    suites = BrowserShooter::Configurator.filter_suites( models, opts )
+    assert_equal( 1, suites.size )
+    assert_equal( "anonymous", suites.first.name )
+    assert_equal( 1, suites.first.tests.size )
+    assert_equal( "google", suites.first.tests.first.name )
+    assert_equal( 3, suites.first.browsers.size )
+
+    opts = { :test => "google", :browsers => ["windows-firefox", "windows-iexplore"] }
+    suites = BrowserShooter::Configurator.filter_suites( models, opts )
+    assert_equal( 1, suites.size )
+    assert_equal( "anonymous", suites.first.name )
+    assert_equal( 1, suites.first.tests.size )
+    assert_equal( "google", suites.first.tests.first.name )
+    assert_equal( 2, suites.first.browsers.size )
+    assert_equal( "windows-firefox", suites.first.browsers.first.name )
+  end
+
   def test_load_config
     BrowserShooter::Configurator.expects( :timestamp ).returns( "timestamp" )
-    FileUtils.expects( :mkdir_p ).with( "/output_path/timestamp" )
-    FileUtils.expects( :mkdir ).with( "/output_path/timestamp/shots" )
-    FileUtils.expects( :mkdir ).with( "/output_path/timestamp/logs" )
 
     config = BrowserShooter::Configurator.load_config( "#{FIXTURES}/config_simple.yml" )
 

data/test/fixtures/config.yml

@@ -1,34 +1,43 @@
 output_path: "/tmp/output"
 
-scripts:
-  google:
-    name: "google"
-    commands: |
-      navigate.to "http://www.google.de"
-      shot 01_before
-      type "id=lst-ib", "fernando guillen"
-      click "name=btnG", wait_for :page
-      pause 3
-      shot 02_after
+tests:
+  google: |
+    navigate.to "http://www.google.de"
+    shot 01_before
+    type "id=lst-ib", "fernando guillen"
+    click "name=btnG", wait_for :page
+    pause 3
+    shot 02_after
 
-  miniclip:
-    name: "miniclip"
-    commands: |
-      navigate.to "http://www.miniclip.com/games/de/"
-      shot
+  miniclip: |
+    navigate.to "http://www.miniclip.com/games/de/"
+    shot
 
 browsers:
   windows-firefox:
-    name: "windows-firefox"
     url: "http://10.211.55.4:4444/wd/hub"
-    browser: "firefox"
+    type: "firefox"
 
   windows-iexplore:
-    name: "windows-iexploreproxy"
     url: "http://10.211.55.4:4444/wd/hub"
-    browser: "iexploreproxy"
+    type: "iexploreproxy"
 
   linux-firefox:
-    name: "linux-firefox"
     url: "http://10.211.55.4:4444/wd/hub"
-    browser: "firefox"
+    type: "firefox"
+
+suites:
+  suite1:
+    tests:
+     - google
+     - miniclip
+    browsers:
+     - windows-firefox
+     - windows-iexplore
+
+  suite2:
+    tests:
+     - miniclip
+    browsers:
+     - windows-firefox
+     - linux-firefox

data/test/fixtures/config_simple.yml

@@ -5,6 +5,9 @@ scripts:
   script-one: "script-one"
   script-two: "script-two"
 
+suites:
+  suite-one: "suite-one"
+
 browsers:
   browser-one: "browser-one"
   browser-two: "browser-two"

data/test/fixtures/logs/{script1.csv → log.csv}

@@ -1,3 +1,3 @@
 time | success | command | message
-the time 1 | true | the command 1 | the message 1
+the time 1 | true | the command 1 | the message 1  -  with 2 lines
 the time 2 | false | the command 2 | the message 2

data/test/log_exporter_test.rb

@@ -4,59 +4,41 @@ class LogExporterTest < Test::Unit::TestCase
   def setup
     super
 
-    @logs = {
-      "script1" => [
-        {
-          :time     => "the time 1",
-          :success  => true,
-          :command  => "the command 1",
-          :message  => "the message 1"
-        },
-        {
-          :time     => "the time 2",
-          :success  => false,
-          :command  => "the command 2",
-          :message  => "the message 2"
-        }
-      ],
-      "script2" => [
-        {
-          :time     => "the time 3",
-          :success  => true,
-          :command  => "the command 3",
-          :message  => "the message 3"
-        }
-      ]
-    }
+    @logs = [
+      {
+        :time     => "the time 1",
+        :success  => true,
+        :command  => "the command 1",
+        :message  => "the message 1 \n with 2 lines"
+      },
+      {
+        :time     => "the time 2",
+        :success  => false,
+        :command  => "the command 2",
+        :message  => "the message 2"
+      }
+    ]
   end
 
   def test_export_should_call_sub_methods
-    BrowserShooter::LogExporter.expects( :"export_to_format" ).with( "logs", "path" )
+    BrowserShooter::LogExporter.expects( :export_to_format ).with( "logs", File.expand_path( "path/log.format" ) )
     BrowserShooter::LogExporter.export( "logs", "path", "format" )
   end
 
-  def test_export_to_json
-    in_tmpdir do |path|
-      BrowserShooter::LogExporter.export_to_json( @logs, path )
-      result = File.read( "#{path}/logs.json" )
-
-      # File.open( "#{FIXTURES}/logs/logs.json", "w" ) { |f| f.write result }
-
-      assert_equal( read_fixture( "logs/logs.json" ), result )
-    end
+  def the_export_should_create_dir
+    BrowserShooter::LogExporter.stubs( :export_to_format )
+    FileUtils.expects( :mkdir_p ).with( File.expand_path( "output_path/log.format" ) )
+    BrowserShooter::LogExporter.export( "logs", "output_path", "format" )
   end
 
   def test_export_to_csv
     in_tmpdir do |path|
-      BrowserShooter::LogExporter.export_to_csv( @logs, path )
-      result1 = File.read( "#{path}/script1.csv" )
-      result2 = File.read( "#{path}/script2.csv" )
+      BrowserShooter::LogExporter.export_to_csv( @logs, "#{path}/log.csv" )
+      result = File.read( "#{path}/log.csv" )
 
-      # File.open( "#{FIXTURES}/logs/script1.csv", "w" ) { |f| f.write result1 }
-      # File.open( "#{FIXTURES}/logs/script2.csv", "w" ) { |f| f.write result2 }
+      # File.open( "#{FIXTURES}/logs/log.csv", "w" ) { |f| f.write result }
 
-      assert_equal( read_fixture( "logs/script1.csv" ), result1 )
-      assert_equal( read_fixture( "logs/script2.csv" ), result2 )
+      assert_equal( read_fixture( "logs/log.csv" ), result )
     end
   end
 end