diffity 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2f6cdaa452dd137feeb1cd7d70a5072ee4fb473b6d0a2ff0fb2a6de86b824b52
+  data.tar.gz: ca85943b5e9c40f92309b903f3ed8f3a45b03656b2ec1ec6665ffbd8496fe96c
+SHA512:
+  metadata.gz: 0e3f0dca85f3539b12fac404a2f5f8e7e2f8595f46d07a94b6f00189951bb3e6a2d4d77ed03bd4ead3f9bbd4f5aca6d0ed6602d5d260e5c8f9761700f5025398
+  data.tar.gz: 2ef2ca1f6de652a7f701c850056f1e73a3ea94ec67e3789628a58f3223f175d571a1276f1f26d81e52fbccbcdb0ead06c2845fe3eee5868e9613ef851170b60a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Yuva
+
+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/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Diffity'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/Readme.md

@@ -0,0 +1,124 @@
+# Diffity
+
+Currently this supports only RSpec.
+
+### Installation
+
+```rb
+gem 'diffity'
+```
+
+### Configuration
+
+Include `diffity` in your rspec `spec_helper` and configure 6 variables
+which will be used while taking screenshots. Make sure that `enable_service` is
+set to true if images need to be uploaded.
+
+**NOTE:** Make sure that that project exists in service with `project_name`. Also
+api key can be obtained by loggin into service and visiting `/api_key`.
+
+
+```rb
+Diffity.configure do |config|
+  # configure domain to which all images have to be uploaded.
+  config.base_uri = "http://idf.dev"
+
+  # configure project name to which images belong to.
+  config.project_name = "idf"
+
+  # configure api_key required to authorize api access
+  config.api_key = ENV["DIFFITY_API_KEY"]
+
+  # configure js driver which is used for taking screenshots.
+  config.javascript_driver = "poltergeist"
+
+  # configure service to mock capturing and uploading screenshots
+  config.enable_service = !!ENV["DIFFITY_ENABLE"]
+
+  # configure logger to log messages. optional.
+  config.logger = Rails.logger
+end
+```
+
+After configuration, include `Diffity::Dsl` in your `spec_helper` and
+configure before and after suite so that suite interacts with the service.
+
+
+```rb
+RSpec.configure do |config|
+  config.include Diffity::Dsl
+
+  config.before(:suite) do
+    Diffity.start_run
+  end
+
+  config.after(:suite) do
+    Diffity.wrap_run
+  end
+end
+```
+
+### Usage
+
+In your specs, simply use `diffity` helper which has bunch of config utilities.
+
+First, you should specify environment details under which screenshots are
+taken. There are 6 parameters which can be configured.
+
+Parameter|Explanation
+---------|-----------
+browser  | which browser is used to take screenshots. default: 'firefox'
+         | supported: firefox, chrome, safari, ie, opera
+device   | which device is used to take screenshots. default: 'desktop'
+         | supported: desktop, laptop, tablet, phone
+os       | which os is used to take screenshots. default: 'linux'
+         | supported: android, ios, windows, osx, linux
+browser_version | (optional) version of browser used, for eg: '46' for firefox
+device_name     | (optional) name of device, for eg: 'MacBook Air'
+os_version      | (optional) version of os used, for eg: '10.11'
+
+
+They can be configured using `diffity` helper while running specs. For eg:
+
+```rb
+diffity.browser = 'firefox'
+diffity.device = 'laptop'
+diffity.os = 'osx'
+diffity.browser_version = '46'
+diffity.device_name = 'MBA'
+diffity.os_version = '10.11.5'
+```
+
+Also, `diffity` can used to take screenshots also. Make sure that you pass
+unique identifier to screenshots that you take. unique identifier helps
+in differentiating this screenshot taken from other screenshots for a
+given set of `browser`, `device`, and `os`.
+
+
+```rb
+describe "Landing page" do
+  it "has a big banner" do
+    visit root_path
+
+    diffity.browser = 'chrome'
+    diffity.screenshot("unique-identifier")
+  end
+end
+```
+
+Since there is flexibility to specify `browser`, `device`, and `os` while
+running specs dynamically (unlike specifying `project_name`), you can run
+all your specs in a loop by changing `browser`, `device` and `os` by
+changing selenium driver, or changing viewport etc. Flexibility for your
+service!
+
+
+### Concurrency
+
+By default, when all the screenshots are collected, and before suite ends, this
+gem will upload all the screenshots taken. `Diffity.wrap_run` is the method
+responsible for the same.
+
+However, if you want to upload screenshots as and when they are taken, this gem
+has soft dependency on `concurrent-ruby` gem. Make sure that this gem is
+**required** before capturing screenshots, and see the magic yourself :)

data/lib/diffity.rb

@@ -0,0 +1,77 @@
+require 'faraday'
+require 'diffity/dummy_runner'
+require 'diffity/runner'
+require 'diffity/dsl'
+require 'logger'
+
+module Diffity
+  # configure domain to which all images have to be uploaded.
+  @@base_uri = "http://diffity.com"
+  def self.base_uri=(uri)
+    @@base_uri = uri
+  end
+  def self.base_uri
+    @@base_uri
+  end
+
+  # configure project name to which images belong to.
+  @@project_name = "idf"
+  def self.project_name=(name)
+    @@project_name = name
+  end
+  def self.project_name
+    @@project_name
+  end
+
+  # configure api_key required to authorize api access
+  @@api_key = ''
+  def self.api_key=(key)
+    @@api_key = key
+  end
+  def self.api_key
+    @@api_key
+  end
+
+  # configure js driver which is used for taking screenshots.
+  @@javascript_driver = "poltergeist"
+  def self.javascript_driver=(driver)
+    @@javascript_driver = driver
+  end
+  def self.javascript_driver
+    @@javascript_driver
+  end
+
+  # configure service to be mocked so that no screenshots are
+  # taken, and uploaded to service.
+  @@enable_service = false
+  def self.enable_service=(enable)
+    @@enable_service = enable
+  end
+  def self.enable_service
+    @@enable_service
+  end
+
+  # configure logger, which will be used to log issues if any
+  @@logger = Logger.new(STDOUT)
+  def self.logger=(new_logger)
+    @@logger = new_logger
+  end
+  def self.logger
+    @@logger
+  end
+
+  # helper to configure above variables.
+  def self.configure
+    yield(self)
+  end
+
+  # helps in setting up the run
+  def self.start_run
+    Diffity::Dsl.diffity.start_run
+  end
+
+  # helps in wrapping up run by uploading images
+  def self.wrap_run
+    Diffity::Dsl.diffity.wrap_run
+  end
+end

data/lib/diffity/dsl.rb

@@ -0,0 +1,22 @@
+module Diffity
+  module Dsl
+    def self.diffity
+      @diffity ||=
+        begin
+          klass =
+            if Diffity.enable_service
+              Diffity::Runner
+            else
+              Diffity::DummyRunner
+            end
+
+          Diffity.logger.info "Using runner #{klass}"
+          klass.instance
+        end
+    end
+
+    def diffity
+      Diffity::Dsl.diffity
+    end
+  end
+end

data/lib/diffity/dummy_runner.rb

@@ -0,0 +1,19 @@
+module Diffity
+  class DummyRunner
+    def self.instance
+      @runner ||= DummyRunner.new
+    end
+
+    attr_accessor :browser, :device, :os
+    attr_accessor :browser_version, :device_name, :os_version
+
+    def start_run
+    end
+
+    def wrap_run
+    end
+
+    def screenshot(_)
+    end
+  end
+end

data/lib/diffity/run_details.rb

@@ -0,0 +1,55 @@
+module Diffity
+  class RunDetails
+    class Jenkins
+      def branch
+        ENV.fetch('GIT_BRANCH').split('/').last
+      end
+
+      def author
+        'Jenkins'.freeze
+      end
+    end
+
+    class Travis
+      def branch
+        ENV.fetch('TRAVIS_BRANCH')
+      end
+
+      def author
+        'Travis'.freeze
+      end
+    end
+
+    class GitRepo
+      def branch
+        `git rev-parse --abbrev-ref HEAD`.strip
+      end
+
+      def author
+        `git config user.name`.strip
+      end
+    end
+
+    class Default
+      def branch
+        'HEAD'.freeze
+      end
+
+      def author
+        'None'.freeze
+      end
+    end
+
+    def details
+      if !!ENV['JENKINS_HOME']
+        Jenkins.new
+      elsif !!ENV['TRAVIS']
+        Travis.new
+      elsif system('git branch')
+        GitRepo.new
+      else
+        Default.new
+      end
+    end
+  end
+end

data/lib/diffity/runner.rb

@@ -0,0 +1,87 @@
+require 'time'
+require 'json'
+require 'diffity/run_details'
+require 'diffity/uploader'
+require 'diffity/utils'
+
+module Diffity
+  class Runner
+    include Capybara::DSL
+
+    def self.instance
+      @runner ||= Runner.new(Diffity.project_name,
+                             Diffity.javascript_driver)
+    end
+
+    attr_accessor :browser, :device, :os
+    attr_accessor :browser_version, :device_name, :os_version
+
+    def initialize(project_name, javascript_driver)
+      @project_name = project_name
+      @javascript_driver = javascript_driver
+
+      dir = Diffity::Utils.images_dir
+      Dir.mkdir('tmp') unless Dir.exist?('tmp')
+      Dir.mkdir(dir) unless Dir.exist?(dir)
+
+      self.browser = 'firefox'
+      self.device = 'desktop'
+      self.os = 'linux'
+    end
+
+    # TODO: Improve error handling here for network timeouts
+    def start_run
+      draft_run
+      @uploader = Diffity::Uploader.build(@run_id)
+    rescue StandardError => e
+      Diffity.logger.fatal e.message
+      raise e
+    end
+
+    # TODO: Improve error handling here for network timeouts
+    def wrap_run
+      @uploader.wrapup
+
+      complete_run if @run_id
+    rescue StandardError => e
+      Diffity.logger.fatal e.message
+      raise e
+    end
+
+    def screenshot(identifier)
+      raise 'no browser information provided' if browser.nil?
+      raise 'no device information provided' if device.nil?
+      raise 'no os information provided' if os.nil?
+
+      screenshot_name = Diffity::Utils.image_file(identifier)
+      page.save_screenshot(screenshot_name, full: true)
+      @uploader.enqueue(identifier, browser, device, os, browser_version,
+                        device_name, os_version)
+    end
+
+    private
+
+    def draft_run
+      run_name = @project_name + "-" + Time.now.iso8601
+
+      details = Diffity::RunDetails.new.details
+      branch = details.branch
+      author = details.author
+      project = @project_name
+
+      response = connection.post('/api/v1/runs',
+                                 name: run_name, project: project, group: branch,
+                                 author: author, js_driver: @javascript_driver)
+
+      @run_id = JSON.parse(response.body)["id"]
+    end
+
+    def complete_run
+      connection.put("/api/v1/runs/#{@run_id}/status", status: "completed")
+    end
+
+    def connection
+      @connection ||= Diffity::Utils.connection
+    end
+  end
+end

data/lib/diffity/uploader.rb

@@ -0,0 +1,13 @@
+module Diffity
+  class Uploader
+    def self.build(run_id)
+      if defined?(::Concurrent)
+        require 'diffity/uploaders/concurrent'
+        Diffity::Uploaders::Concurrent.new(run_id)
+      else
+        require 'diffity/uploaders/sequential'
+        Diffity::Uploaders::Sequential.new(run_id)
+      end
+    end
+  end
+end

data/lib/diffity/uploaders/concurrent.rb

@@ -0,0 +1,41 @@
+require 'diffity/utils'
+
+module Diffity
+  module Uploaders
+    class Concurrent
+      MAX_NO_OF_THREADS = 20
+
+      def initialize(run_id)
+        @run_id = run_id
+        @pool = ::Concurrent::FixedThreadPool.new(MAX_NO_OF_THREADS)
+        @screenshots_taken = 0
+      end
+
+      def enqueue(identifier, browser, device, os, browser_version,
+                  device_name, os_version)
+        @screenshots_taken += 1
+
+        @pool.post do
+          Diffity::Utils
+            .upload_image(@run_id, identifier, browser, device, os,
+                          browser_version, device_name, os_version)
+        end
+      end
+
+      def wrapup
+        retries = 180           # 30 mins
+
+        # if all screenshots are not uploaded, wait.
+        until @screenshots_taken == @pool.completed_task_count
+          retries -= 1
+          break if retries.zero?
+
+          sleep 10
+        end
+
+        @pool.shutdown
+        @pool.wait_for_termination
+      end
+    end
+  end
+end

data/lib/diffity/uploaders/sequential.rb

@@ -0,0 +1,28 @@
+require 'diffity/utils'
+
+module Diffity
+  module Uploaders
+    class Sequential
+      def initialize(run_id)
+        @run_id = run_id
+        @identifiers_with_env = []
+      end
+
+      def enqueue(identifier, browser, device, os, browser_version,
+                  device_name, os_version)
+        @identifiers_with_env << [identifier, browser, device, os,
+                                  browser_version, device_name,
+                                  os_version]
+      end
+
+      def wrapup
+        @identifiers_with_env
+          .each do |identifier, browser, device, os, browser_version, device_name, os_version|
+          Diffity::Utils
+            .upload_image(@run_id, identifier, browser, device, os,
+                          browser_version, device_name, os_version)
+        end
+      end
+    end
+  end
+end

data/lib/diffity/utils.rb

@@ -0,0 +1,32 @@
+module Diffity
+  module Utils
+    # http connection that will be used for uploading images
+    def self.connection
+      base_uri = Diffity.base_uri
+      Faraday.new(base_uri, request: { timeout: 120, open_timeout: 120 }) do |f|
+        f.request :basic_auth, Diffity.api_key, 'X'
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter :net_http
+      end
+    end
+
+    def self.images_dir
+      'tmp/diffity'.freeze
+    end
+
+    def self.upload_image(run_id, identifier, browser, device, os, browser_version,
+                          device_name, os_version)
+      Diffity.logger.fatal "uploading #{identifier}"
+      image_io = Faraday::UploadIO.new(image_file(identifier), 'image/png')
+      connection.post("/api/v1/runs/#{run_id}/run_images",
+                      identifier: identifier, image: image_io, browser: browser,
+                      device: device, os: os, browser_version: browser_version,
+                      device_name: device_name, os_version: os_version)
+    end
+
+    def self.image_file(identifier)
+      "#{Dir.pwd}/#{images_dir}/#{identifier}.png"
+    end
+  end
+end

data/lib/diffity/version.rb

@@ -0,0 +1,3 @@
+module Diffity
+  VERSION = "0.3.0"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: diffity
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Yuva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rails integration for diffity service
+email:
+- yuva@codemancers.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- Readme.md
+- lib/diffity.rb
+- lib/diffity/dsl.rb
+- lib/diffity/dummy_runner.rb
+- lib/diffity/run_details.rb
+- lib/diffity/runner.rb
+- lib/diffity/uploader.rb
+- lib/diffity/uploaders/concurrent.rb
+- lib/diffity/uploaders/sequential.rb
+- lib/diffity/utils.rb
+- lib/diffity/version.rb
+homepage: http://diffity.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Rails integration for diffity service
+test_files: []