domreactor-redglass 0.0.2 → 0.0.3

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.idea/
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+chromedriver.log

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Frank O'Hara
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# DomReactor + RedGlass
+
+A RedGlass plugin which enables snapshot archives to be analyzed by DomReactor.
+
+## Requirements
+
+You will need a DomReactor account and an API token to use DomReactor's automated layout analysis service.  Visit http://domreactor.com to sign up.
+
+## Usage
+
+```ruby
+# Configurations
+browsers = [:firefox, :chrome]
+archive_location = '/Users/you/Desktop/red_glass_snapshots'
+test_id = 1
+opts = {
+    baseline_browser: {name: 'firefox', version: '20.0', platform: 'darwin'},
+    threshold: 0.02
+}
+
+# Take a RedGlass snapshot in each browser.
+browsers.each do |browser|
+  listener = RedGlassListener.new
+  driver = Selenium::WebDriver.for browser, :listener => listener
+  red_glass = RedGlass.new driver, {listener: listener, archive_location: archive_location, test_id: test_id}
+  driver.navigate.to 'http://google.com'
+  red_glass.take_snapshot
+  driver.quit
+end
+
+# Send the page archives to DomReactor.
+DomReactorRedGlass.auth_token = '12345'
+DomReactorRedGlass.create_chain_reaction("#{archive_location}/#{test_id}", opts)
+```
+
+# License
+
+The MIT License - Copyright (c) 2013 Frank O'Hara

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'Run specs'
+task :default => :spec

data/domreactor-redglass.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'domreactor-redglass/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'domreactor-redglass'
+  s.version       = DomReactorRedGlass::VERSION
+  s.date          = '2013-05-31'
+  s.summary       = 'DomReactor plugin for RedGlass.'
+  s.description   = 'Send RedGlass page archives to DomReactor for automated layout analysis.'
+  s.authors       = ["Frank O'Hara", "Chris Lamb"]
+  s.email         = ["frankj.ohara@gmail.com", "lamb.chrisr@gmail.com"]
+  s.homepage      = 'https://github.com/bimech/domreactor-redglass'
+
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rest-client'
+  s.add_dependency 'json'
+  s.add_dependency 'rubyzip'
+  s.add_dependency 'red-glass', '>= 0.1.1'
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.13.0"
+  s.add_development_dependency 'selenium-webdriver'
+end

data/example/domreactor_example.rb

@@ -0,0 +1,27 @@
+require 'selenium-webdriver'
+require 'red-glass'
+require 'domreactor-redglass'
+include DomReactorRedGlass
+
+# Configurations
+browsers = [:firefox, :chrome]
+archive_location = '/Users/you/Desktop/red_glass_snapshots'
+test_id = 1
+opts = {
+    baseline_browser: {name: 'firefox', version: '20.0', platform: 'darwin'},
+    threshold: 0.02
+}
+
+# Take a RedGlass snapshot in each browser.
+browsers.each do |browser|
+  listener = RedGlassListener.new
+  driver = Selenium::WebDriver.for browser, :listener => listener
+  red_glass = RedGlass.new driver, {listener: listener, archive_location: archive_location, test_id: test_id}
+  driver.navigate.to 'http://google.com'
+  red_glass.take_snapshot
+  driver.quit
+end
+
+# Send the page archives to DomReactor.
+DomReactorRedGlass.auth_token = '12345'
+DomReactorRedGlass.create_chain_reaction('http://google.com', "#{archive_location}/#{test_id}", opts)

data/lib/domreactor-redglass/chain_reaction.rb

@@ -0,0 +1,119 @@
+require 'json'
+require 'rest-client'
+
+module DomReactorRedGlass
+  class ChainReaction
+    attr_reader :id, :info, :page_url
+
+    def initialize(page_url, opts)
+      @page_url = page_url
+      @opts = opts
+      @info = info
+    end
+
+    def auth_token
+      Config.auth_token
+    end
+
+    def resource_url
+      "#{Config.url}/api/v1/chain_reactions"
+    end
+
+    def chain_reaction_url
+      "#{resource_url}/#{id}"
+    end
+
+    def id
+      id ||= info[:id]
+    end
+
+    def info
+      @info ||= create_chain_reaction(@opts)
+    end
+
+    def post_archives(archive_location)
+      web_browser_ids = []
+      #TODO: Cache the web prowser for each archive location.
+      Dir.foreach(archive_location) do |file|
+        next if file == '.' or file == '..'
+        path = "#{archive_location}/#{file}"
+        if is_valid_page_archive? path
+          web_browser_ids << get_web_browser_info(parse_json_file("#{path}/metadata.json")[:browser])[:id]
+        end
+      end
+      update_chain_reaction(web_browser_ids: web_browser_ids)
+      dom_gun_reaction = create_dom_gun_reaction
+      Dir.foreach(archive_location) do |file|
+        next if file == '.' or file == '..'
+        path = "#{archive_location}/#{file}"
+        if is_valid_page_archive? path
+          payload = create_payload(path)
+          RestClient.put("#{chain_reaction_url}/dom_gun_reactions/#{dom_gun_reaction[:id]}", payload, content_type: 'application/json')
+        end
+      end
+      start_reaction(dom_gun_reaction[:id])
+    end
+
+    def start_reaction(id)
+      params = {
+        auth_token: auth_token,
+      }
+      RestClient.post("#{chain_reaction_url}/dom_gun_reactions/#{id}/start", params, content_type: 'application/json')
+    end
+
+    def baseline_browser
+      get_web_browser_info(@opts[:baseline_browser])
+    end
+
+    private
+
+    def get_web_browser_info(browser_info={})
+      parameters = {auth_token: auth_token,content_type: 'application/json', accept: :json}.merge(browser_info)
+      #TODO: Handle errors.
+      response = RestClient.get("#{Config.url}/api/v1/web_browsers", {params: parameters})
+      JSON.parse(response, symbolize_names: true)[:web_browsers].first
+    end
+
+    def update_chain_reaction(params)
+      RestClient.put(chain_reaction_url, params.merge(auth_token: auth_token), content_type: 'application/json')
+    end
+
+    def create_chain_reaction(opts)
+      payload = {
+        auth_token: auth_token,
+        analysis_only: true,
+        displacement_threshold: opts[:threshold] || 0.04,
+        baseline_browser_id: baseline_browser[:id]
+      }.to_json
+      response = RestClient.post(resource_url, payload, content_type: 'application/json') do |response|
+        unless response.code == 200 && response.body.match(/chain_reaction/)
+          raise "ChainReaction initialization failed with code #{response.code} : #{response.body}"
+        end
+        response
+      end
+      JSON.parse(response, symbolize_names: true)[:chain_reaction]
+    end
+
+    def create_dom_gun_reaction
+      payload = {
+        chain_reaction_id: id,
+        auth_token: auth_token,
+        page_url: page_url
+      }
+      dom_gun = RestClient.post("#{chain_reaction_url}/dom_gun_reactions", payload, content_type: 'application/json')
+      JSON.parse(dom_gun, symbolize_names: true)
+    end
+
+    def create_payload(path)
+      meta_data = parse_json_file("#{path}/metadata.json")
+      {
+        auth_token: auth_token,
+        meta_data: meta_data,
+        web_browser_id: get_web_browser_info(meta_data[:browser])[:id],
+        dom_elements: File.open("#{path}/dom.json", 'rb') {|f| f.read},
+        page_source: File.open("#{path}/source.html") {|f| f.read},
+        file: File.open("#{path}/screenshot.png")
+      }
+    end
+  end
+end

data/lib/domreactor-redglass/config.rb

@@ -0,0 +1,24 @@
+module DomReactorRedGlass
+  class Config
+    #DOMREACTOR_INIT_CHAIN_REACTION_URL = 'http://domreactor.com'
+    DOMREACTOR_INIT_CHAIN_REACTION_URL = 'http://localhost:3000'
+
+    class << self
+      def url
+        @url || DOMREACTOR_INIT_CHAIN_REACTION_URL
+      end
+
+      def url=(url)
+        @url = url
+      end
+
+      def auth_token
+        @auth_token
+      end
+
+      def auth_token=(auth_token)
+        @auth_token = auth_token
+      end
+    end
+  end
+end

data/lib/domreactor-redglass/version.rb

@@ -0,0 +1,3 @@
+module DomReactorRedGlass
+  VERSION = "0.0.3"
+end

data/lib/domreactor-redglass.rb

@@ -1,22 +1,26 @@
-require 'json'
-require 'rest-client'
-require 'zip/zip'
+require 'domreactor-redglass/chain_reaction'
+require 'domreactor-redglass/config'
+require 'domreactor-redglass/version'
 
 module DomReactorRedGlass
 
   REQUIRED_ARCHIVE_FILES = %w(dom.json metadata.json screenshot.png source.html)
   REQUIRED_BASELINE_BROWSER_CONFIG_KEYS = [:name, :version, :platform]
-  DOMREACTOR_INIT_CHAIN_REACTION_URL = 'http://domreactor.com/api/v1/chain_reactions'
 
-  def create_chain_reaction(api_token, archive_location, config)
+  def auth_token=(auth_token)
+    Config.auth_token=auth_token
+  end
+
+  def auth_token
+    Config.auth_token
+  end
+
+  def create_chain_reaction(page_url, archive_location, opts)
     detect_archive_location archive_location
     detect_min_archive_quota archive_location
-    detect_baseline_browser archive_location, config
-    id = init_chain_reaction(api_token, archive_location, config)[:chain_reaction][:id]
-    api_url = config[:api_url] || DOMREACTOR_INIT_CHAIN_REACTION_URL
-    post_url = "#{api_url}/#{id}"
-    archive_files = zip_archives archive_location
-    post_archives(api_token, post_url, archive_files)
+    detect_baseline_browser archive_location, opts
+    @chain_reaction = ChainReaction.new(page_url, opts)
+    @chain_reaction.post_archives(archive_location)
   end
 
   def detect_archive_location(archive_location)
@@ -87,55 +91,8 @@ module DomReactorRedGlass
     metadata
   end
 
-  def init_chain_reaction(api_token, archive_location, config)
-    payload = {
-        auth_token: api_token,
-        analysis_only: true,
-        threshold: config[:threshold] || 0.04,
-        baseline_browser: config[:baseline_browser],
-        archive_count: sum_archive_count(archive_location),
-        metadata: archive_metadata(archive_location)
-    }.to_json
-    api_url = config[:api_url] || DOMREACTOR_INIT_CHAIN_REACTION_URL
-    response = RestClient.post(api_url, payload, content_type: 'application/json') do |response|
-      unless response.code == 200 && response.body.match(/chain_reaction/)
-        raise "ChainReaction initialization failed with code #{response.code} : #{response.body}"
-      end
-      response
-    end
-    JSON.parse(response, symbolize_names: true)
-  end
-
-  def zip_archives(archive_location)
-    zip_files = []
-    Dir.foreach(archive_location) do |file|
-      next if file == '.' or file == '..'
-      path = "#{archive_location}/#{file}"
-      if is_valid_page_archive? path
-        zip_file = "#{path}.zip"
-        zip_files << zip_file
-        Zip::ZipFile.open(zip_file, Zip::ZipFile::CREATE) do |zipfile|
-          REQUIRED_ARCHIVE_FILES.each do |filename|
-            zipfile.add(filename, path + '/' + filename)
-          end
-        end
-      end
-    end
-    zip_files
-  end
-
-  def post_archives(api_token, post_url, zip_files)
-    zip_files.each do |file|
-      payload = {
-          auth_token: api_token,
-          file: File.new(file, 'rb')
-      }
-      RestClient.put(post_url, payload)
-    end
-  end
-
   def parse_json_file(path)
     json_str = File.open(path, 'rb') {|f| f.read}
     JSON.parse(json_str, symbolize_names: true)
   end
-end
+end

data/spec/chain_reaction_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe DomReactorRedGlass::ChainReaction do
+  let(:chain_reaction) { DomReactorRedGlass::ChainReaction.new('http://domreactor.com', {}) }
+  before do
+    #stub chain reaction creation call
+    RestClient.stub(:post) { {chain_reaction: {id: 42, some_info: 'yay'}}.to_json }
+    ChainReaction.any_instance.stub(:baseline_browser) { {id: 1} }
+  end
+
+  describe '#new' do
+    it 'posts to domreactor to create a chain reaction' do
+      expected_response = {chain_reaction: {id:  42, some_info: 'yay'}}
+      RestClient.should_receive(:post).once.and_return(expected_response.to_json)
+      chain_reaction.info.should eq(expected_response[:chain_reaction])
+    end
+  end
+
+  describe '#info' do
+    it "gets the id from the info" do
+      chain_reaction.info.should eq({id: 42, some_info: 'yay'})
+    end
+  end
+
+  describe '#post_archives' do
+    before do
+      chain_reaction.stub(:create_dom_gun_reaction) { {id: 81, stuff: true} }
+      chain_reaction.stub(:get_web_browser_info).exactly(4).times.
+        with({:name=>"firefox", :version=>"20.0", :platform=>"darwin"}) { {id: 22, browser: 'firefox'} }
+      RestClient.should_receive(:put).exactly(3).times
+      RestClient.should_receive(:post).once
+    end
+    it 'creates a dom gun reaction' do
+      chain_reaction.post_archives("#{SPEC_ROOT}/data/valid_archive")
+    end
+  end
+  describe '#id' do
+    it "gets the id from the info" do
+      chain_reaction.id.should eq(42)
+    end
+  end
+end
+