janus-cli 0.1.0 → 0.2.0

data/lib/janus/io/selenium.rb

@@ -0,0 +1,43 @@
+require 'oily_png'
+require 'selenium/webdriver'
+require 'janus/screenshot'
+
+module Janus
+  module IO
+    class Selenium
+      @@driver_pool = {}
+
+      def initialize(username, access_key, browser)
+        @username = username
+        @access_key = access_key
+        @browser = browser
+
+        @driver = @@driver_pool[browser] || build_driver
+      end
+
+      def read(test)
+        @driver.get(test.url)
+
+        png = @driver.screenshot_as(:png)
+        image = ChunkyPNG::Image.from_blob(png)
+        Janus::Screenshot.new(image)
+      end
+
+      private
+
+      def build_driver
+        capabilities = ::Selenium::WebDriver::Remote::Capabilities.new(
+          platform: @browser.platform,
+          browser_name: @browser.name,
+          version: @browser.version
+        )
+
+        driver = ::Selenium::WebDriver.for(:remote, {
+          url: "http://#{@username}:#{@access_key}@ondemand.saucelabs.com/wd/hub",
+          desired_capabilities: capabilities
+        })
+        @@driver_pool[@browser] = driver
+      end
+    end
+  end
+end

data/lib/janus/screenshot.rb

@@ -1,37 +1,17 @@
-require 'fileutils'
-require 'selenium/webdriver'
-
 module Janus
   class Screenshot
-    attr_accessor :test, :image
-
-    def self.capture(test, options = {})
-      driver = Selenium::WebDriver.for(:remote, {
-        url: "http://#{options[:username]}:#{options[:access_key]}@ondemand.saucelabs.com/wd/hub",
-        desired_capabilities: Selenium::WebDriver::Remote::Capabilities.chrome
-      })
-      driver.get(test.url)
-
-      Screenshot.new(test: test, image: driver.screenshot_as(:png))
-    end
-
-    def self.load(test, options = {})
-      path = File.join(options[:path], "#{test.name}.janus", 'screenshot.png')
-      image = IO.read(path, mode: 'rb')
+    attr_reader :image
 
-      Screenshot.new(test: test, image: image)
+    def initialize(image)
+      @image = image
     end
 
-    def initialize(parameters = {})
-      @test = parameters[:test]
-      @image = parameters[:image]
+    def dimensions
+      { width: @image.width, height: @image.height }
     end
 
-    def save(path)
-      directory = File.join(path, "#{test.name}.janus")
-
-      FileUtils.mkpath(directory) unless Dir.exists?(directory)
-      IO.write(File.join(directory, 'screenshot.png'), @image, mode: 'wb')
+    def pixels
+      @image.pixels
     end
   end
 end

data/lib/janus/version.rb

@@ -1,3 +1,3 @@
 module Janus
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/integration/engine_spec.rb

@@ -0,0 +1,50 @@
+require 'oily_png'
+require 'janus/configuration'
+require 'janus/core/engine'
+require 'janus/core/error'
+require 'janus/screenshot'
+
+describe 'Engine Integration Test' do
+  let(:config) { Janus::Configuration.new('threshold' => 0.2) }
+  let(:engine) { Janus::Core::Engine.create(config) }
+  let(:square_base) { ChunkyPNG::Image::from_file('spec/support/square-base.png') }
+  let(:square_big) { ChunkyPNG::Image::from_file('spec/support/square-big.png') }
+  let(:square_ten) { ChunkyPNG::Image::from_file('spec/support/square-ten.png') }
+  let(:square_twenty) { ChunkyPNG::Image::from_file('spec/support/square-twenty.png') }
+  let(:square_thirty) { ChunkyPNG::Image::from_file('spec/support/square-thirty.png') }
+
+  it 'succeeds for matching image' do
+    original = Janus::Screenshot.new(square_base)
+    fresh = Janus::Screenshot.new(square_base)
+
+    expect { engine.execute(original, fresh) }.not_to raise_error
+  end
+
+  it 'succeeds for image below threshold' do
+    original = Janus::Screenshot.new(square_base)
+    fresh = Janus::Screenshot.new(square_ten)
+
+    expect { engine.execute(original, fresh) }.not_to raise_error
+  end
+
+  it 'succeeds for image matching threshold' do
+    original = Janus::Screenshot.new(square_base)
+    fresh = Janus::Screenshot.new(square_twenty)
+
+    expect { engine.execute(original, fresh) }.not_to raise_error
+  end
+
+  it 'fails for image exceeding threshold' do
+    original = Janus::Screenshot.new(square_base)
+    fresh = Janus::Screenshot.new(square_thirty)
+
+    expect { engine.execute(original, fresh) }.to raise_error
+  end
+
+  it 'fails for different sized image' do
+    original = Janus::Screenshot.new(square_base)
+    fresh = Janus::Screenshot.new(square_big)
+
+    expect { engine.execute(original, fresh) }.to raise_error
+  end
+end

data/spec/unit/janus/browser_spec.rb

@@ -0,0 +1,57 @@
+require 'janus/browser'
+
+describe Janus::Browser do
+  it 'sets platform' do
+    browser = Janus::Browser.new('platform' => 'platform')
+    browser.platform.should == 'platform'
+  end
+
+  it 'sets name' do
+    browser = Janus::Browser.new('name' => 'name')
+    browser.name.should == 'name'
+  end
+
+  it 'sets version' do
+    browser = Janus::Browser.new('version' => '7')
+    browser.version.should == '7'
+  end
+
+  describe '#eql' do
+    let(:platform) { 'platform' }
+    let(:name) { 'name' }
+    let(:version) { 'version' }
+    let(:a) { Janus::Browser.new('platform' => platform, 'name' => name, 'version' => version) }
+
+    it 'is false when platform is different' do
+      b = Janus::Browser.new('platform' => 'different', 'name' => name, 'version' => version)
+      b.should_not eql(a)
+    end
+
+    it 'is false when name is different' do
+      b = Janus::Browser.new('platform' => platform, 'name' => 'different', 'version' => version)
+      b.should_not eql(a)
+    end
+
+    it 'is false when version is different' do
+      b = Janus::Browser.new('platform' => platform, 'name' => name, 'version' => 'different')
+      b.should_not eql(a)
+    end
+
+    it 'is true when browser, name, and version are the same' do
+      b = Janus::Browser.new('platform' => platform, 'name' => name, 'version' => version)
+      b.should eql(a)
+    end
+  end
+
+  describe '#to_s' do
+    it 'converts to string for browser with version' do
+      browser = Janus::Browser.new('platform' => 'platform', 'name' => 'name', 'version' => 0.7)
+      browser.to_s.should == 'platform, name 0.7'
+    end
+
+    it 'converts to string for browser without version' do
+      browser = Janus::Browser.new('platform' => 'platform', 'name' => 'name')
+      browser.to_s.should == 'platform, name'
+    end
+  end
+end

data/spec/{janus → unit/janus}/command/initialize_spec.rb

@@ -8,7 +8,7 @@ describe Janus::Command::Initialize do
     it 'writes samples configuration if file does not exist' do
       File.stub(:exists?) { false }
 
-      source = File.expand_path('../../../../lib/janus/template/Janusfile', __FILE__)
+      source = File.expand_path('../../../../../lib/janus/template/Janusfile', __FILE__)
       destination = 'Janusfile'
       FileUtils.should_receive(:copy).with(source, destination)
 

data/spec/unit/janus/command/record_spec.rb

@@ -0,0 +1,93 @@
+require 'sauce/connect'
+require 'janus/command/record'
+require 'janus/configuration'
+
+describe Janus::Command::Record do
+  let(:config) { Janus::Configuration.new('username' => 'username', 'access_key' => 'key', 'directory' => 'base') }
+  let(:record) { Janus::Command::Record.new(config) }
+
+  before :each do
+    record.stub(:puts)
+    record.stub(:print)
+
+    Sauce::Connect.stub(:connect!)
+  end
+
+  describe '#execute' do
+    before :each do
+      config.stub(:browsers) { ['red', 'blue'] }
+      config.stub(:tests) { ['one', 'two'] }
+    end
+
+    it 'starts tunnel when tunnel is true' do
+      config.stub(:tunnel?) { true }
+      record.stub(:record_screenshot)
+
+      Sauce::Connect.should_receive(:connect!)
+
+      record.execute
+    end
+
+    it 'does not start tunnel when tunnel is false' do
+      config.stub(:tunnel?) { false }
+      record.stub(:record_screenshot)
+
+      Sauce::Connect.should_not_receive(:connect!)
+
+      record.execute
+    end
+
+    it 'records screenshot for each configured test and browser combination' do
+      record.should_receive(:record_screenshot).with('red', 'one')
+      record.should_receive(:record_screenshot).with('red', 'two')
+      record.should_receive(:record_screenshot).with('blue', 'one')
+      record.should_receive(:record_screenshot).with('blue', 'two')
+
+      record.execute
+    end
+  end
+
+  describe '#record_screenshot' do
+    let(:screenshot) { double }
+    let(:browser) { double }
+
+    let(:test) do
+      test = double
+      test.stub(:name)
+      test
+    end
+
+    # TODO: Builder
+    let(:directory) do
+      directory = double
+      directory.stub(:write)
+      directory
+    end
+
+    # TODO: Builder
+    let(:selenium) do
+      selenium = double
+      selenium.stub(:read) { screenshot }
+      selenium
+    end
+
+    before :each do
+      Janus::IO::Directory.stub(:new) { directory }
+      Janus::IO::Selenium.stub(:new) { selenium }
+    end
+
+    it 'reads screenshot from Selenium' do
+      Janus::IO::Selenium.should_receive(:new).with('username', 'key', browser) { selenium }
+      selenium.should_receive(:read).with(test) { screenshot }
+
+      record.record_screenshot(browser, test)
+    end
+
+    it 'writes screenshot to Janus directory' do
+      Janus::IO::Directory.should_receive(:new).with('base', browser) { directory}
+      directory.should_receive(:write).with(test, screenshot)
+
+      record.record_screenshot(browser, test)
+    end
+  end
+end

data/spec/unit/janus/command/validate_spec.rb

@@ -0,0 +1,105 @@
+require 'janus/command/validate'
+require 'janus/configuration'
+
+describe Janus::Command::Validate do
+  let(:config) { Janus::Configuration.new('username' => 'username', 'access_key' => 'key', 'directory' => 'base') }
+  let(:validate) { Janus::Command::Validate.new(config) }
+
+  before :each do
+    validate.stub(:puts)
+    validate.stub(:print)
+  end
+
+  describe '#execute' do
+    before :each do
+      config.stub(:browsers) { %w(red blue) }
+      config.stub(:tests) { %w(one two) }
+    end
+
+    it 'starts tunnel when tunnel is true' do
+      config.stub(:tunnel?) { true }
+      validate.stub(:validate_screenshot)
+
+      Sauce::Connect.should_receive(:connect!)
+
+      validate.execute
+    end
+
+    it 'does not start tunnel when tunnel is false' do
+      config.stub(:tunnel?) { false }
+      validate.stub(:validate_screenshot)
+
+      Sauce::Connect.should_not_receive(:connect!)
+
+      validate.execute
+    end
+
+    it 'validates screenshots for each configured test' do
+      validate.should_receive(:validate_screenshot).with('red', 'one')
+      validate.should_receive(:validate_screenshot).with('red', 'two')
+      validate.should_receive(:validate_screenshot).with('blue', 'one')
+      validate.should_receive(:validate_screenshot).with('blue', 'two')
+
+      validate.execute
+    end
+  end
+
+  describe '#validate_screenshot' do
+    let(:test) do
+      test = double
+      test.stub(:name)
+      test
+    end
+
+    let(:fresh) { double }
+    let(:original) { double }
+    let(:browser) { double }
+
+    # TODO: Builder
+    let(:engine) do
+      engine = double
+      engine.stub(:execute)
+      engine
+    end
+
+    # TODO: Builder
+    let(:directory) do
+      directory = double
+      directory.stub(:read) { original }
+      directory
+    end
+
+    # TODO: Builder
+    let(:selenium) do
+      selenium = double
+      selenium.stub(:read) { fresh }
+      selenium
+    end
+
+    before :each do
+      Janus::IO::Directory.stub(:new) { directory }
+      Janus::IO::Selenium.stub(:new) { selenium }
+      Janus::Core::Engine.stub(:create) { engine }
+    end
+
+    it 'reads screenshot from Selenium' do
+      Janus::IO::Selenium.should_receive(:new).with('username', 'key', browser) { selenium }
+      selenium.should_receive(:read).with(test) { fresh }
+
+      validate.validate_screenshot(browser, test)
+    end
+
+    it 'reads screenshot from directory' do
+      Janus::IO::Directory.should_receive(:new).with('base', browser) { directory }
+      selenium.should_receive(:read).with(test) { original }
+
+      validate.validate_screenshot(browser, test)
+    end
+
+    it 'executes engine' do
+      engine.should_receive(:execute).with(original, fresh)
+
+      validate.validate_screenshot(browser, test)
+    end
+  end
+end

data/spec/{janus → unit/janus}/configuration_spec.rb

@@ -40,6 +40,48 @@ describe Janus::Configuration do
     end
   end
 
+  describe '#tunnel' do
+    it 'returns tunnel setting' do
+      configuration = Janus::Configuration.new('tunnel' => true)
+      configuration.tunnel?.should == true
+    end
+  end
+
+  describe '#directory' do
+    it 'returns directory' do
+      configuration = Janus::Configuration.new('directory' => 'directory')
+      configuration.directory.should == 'directory'
+    end
+  end
+
+  describe '#threshold' do
+    it 'returns threshold' do
+      configuration = Janus::Configuration.new('threshold' => 0.1)
+      configuration.threshold.should == 0.1
+    end
+
+    it 'defaults threshold to zero' do
+      configuration = Janus::Configuration.new
+      configuration.threshold.should == 0
+    end
+  end
+
+  describe '#browsers' do
+    it 'creates browser for each entry in configuration file' do
+      browser_configuration = []
+      browser_configuration << { 'platform' => 'a', 'name' => 'a', 'version' => 'a' }
+      browser_configuration << { 'platform' => 'b', 'name' => 'b', 'version' => 'b' }
+
+      configuration = Janus::Configuration.new({ 'browsers' => browser_configuration })
+
+      configuration.browsers.each_with_index do |browser, i|
+        browser.platform.should == browser_configuration[i]['platform']
+        browser.name.should == browser_configuration[i]['name']
+        browser.version.should == browser_configuration[i]['version']
+      end
+    end
+  end
+
   describe '#tests' do
     it 'creates test for each entry in configuration file' do
       test_configuration = []