yordi_tests 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 783043661bdec27c6adf4c9f4d3b1d545d675ef4
+  data.tar.gz: 64fc1f61a1a524e3e61aaedc4931c6dce74523b7
+SHA512:
+  metadata.gz: 7784cb732fcd3cb3794b3058d39efa00cace7d44dca2778f3a2c09549831997dffa5ce058063f553af65d476f34de4fe7334bb4bf0c2394a61efe5fbead0119f
+  data.tar.gz: 4a2b864d577a4d56f762ca2d57d62226c5e83fa08cee69aeb68f2dc35b0078c7f511621d5961670ab75bf4a8d30f62ed35f385cba8ccf714325079e5af65d002

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/
+/test/fixtures/
+/test/fixtures/benchmarks/
+/test/fixtures/screenshots/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.4

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in yordi_tests.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Brian OQR
+
+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,124 @@
+# YordiTests CLI 
+
+The yordi_tests gem is a companion for [YordiTests](https://yorditests.com). 
+This project is rapidly changing and in alpha phase, use at your own risk. 
+
+Basically YordiTests compares screenshots with benchmarks and can apply masks to hide dynamic content. 
+
+It only works with PNG files and requires the files to have the extensions .png for now and does not recurse directories. 
+
+## Installation
+
+<!-- Add this line to your application's Gemfile:
+
+```ruby
+gem 'yordi_tests'
+```
+
+And then execute:
+
+    $ bundle
+Or -->
+Install it yourself as:
+
+    $ gem install yordi_tests
+
+## Usage
+It's a CLI with Thor so calling help on the command line will give you more details
+``` ruby
+  yordi help
+```
+To start a .yordi_tests directory must be initialized, either of these commands will create the directory relative 
+to the where you execute it. Using an apikey will automatically sync your local test directory with the benchmarks online. 
+``` ruby
+  yordi help init  # for all the options
+  yordi init   
+  yordi init --api_key apikey_from_yorditests.com
+```
+To test your screenshots
+``` ruby
+  yordi help test  # for more options
+  yordi test /path/to/screenshots
+  yordi test /path/to/screenshots --sync-all # push the new screenshots to yorditests.com
+  yordi test /path/to/screenshots --clean-dir # after the tests it deletes the screenshots tested
+```
+Show the report (only works on OSX, the report is located at .yordi_tests/report.html)
+``` ruby 
+  yordi open_report  # opens the last generated html report
+```
+Refetch benchmarks and masks from online
+``` ruby 
+  yordi help fetch  # for more options
+  yordi fetch -bm  # fetches all benchmark details and masks from online for testing
+```
+Push benchmarks and masks to online store (not yet implemented)
+``` ruby 
+  yordi help push  # for more options
+  yordi push -bm  # pushes all benchmark details and masks to online store
+```
+### Standalone Scenario
+So you have run an appium or selenium test that made a lot of screenshots.
+Wherever you want to run your yordi test do the following.
+``` ruby
+  yordi init
+  yordi test path/to/screenshot
+  yordi open_report
+```
+At which point you will see a report and all of your screens will have passed the test as there was no benchmark.
+So run your appium or selenium tests again and create the screenshots a second time.
+``` ruby
+  yordi test path/to/screenshot
+  yordi open_report
+```
+Now there is a good chance that some of your screenshots haved failed the test due to status bars with time or other
+dynamic issues. If the screen changes are different but valid you need to mask this dynamic area to ensure 100% on the test. 
+This is easiest done with YordiTests.com editor, however the masks are simple JSON areas. 
+
+So if you don't want to use YordiTests.com you can manually open the config.json at .yordi_tests/config.json
+and add some rectangles for masks as a value for masked_area: in the json, 
+you can use any image editing program to get the x, y, width and height you want 
+
+Here is an example of a masked_area value, masked_area is an array. 
+``` javascript
+  masked_area: [
+     {
+           "x": 0,
+           "y": 0,
+           "width": 800,
+           "height": 48
+     },
+    {
+           "x": 419,
+           "y": 385,
+           "width": 619,
+           "height": 372
+     },
+     
+     
+   ]
+```
+In the config.json the property masked_area: is available in the root and in individual screens in the test_benchmarks array. 
+Placing a mask in root will have the mask be applied to all screens during the comparision. Placing the mask on a screen will apply the mask only to that screen.
+So the screens get compared after both the benchmark and resulting screenshot have all global and local masks applied. 
+
+At some point you will want to update your benchmarks, for example if the design has changed. If you are using YordiTests.com 
+then if you sync your tests with the online store you can make the screenshot the benchmark online
+and then re-fetch the benchmarks from the comand with `yordi fetch -b`.  
+
+However if you are running in standalone mode to update a benchmark at the moment you must manually copy the 
+screenshot into the benchmark folder in the subdirectories of .yordi_tests.  Eventually a command will be added to make this easier. 
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/PurelyCode/gem-yorditests.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "yordi_tests"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/yordi

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'yordi_tests/cli'
+YordiTests::CLI.start

data/lib/yordi_tests/cli.rb

@@ -0,0 +1,78 @@
+require 'thor'
+require 'yordi_tests'
+require 'yordi_tests/data_manager'
+module YordiTests
+  class CLI < Thor
+    package_name 'YordiTests'
+
+    desc 'init --api_key', 'Initializes a Yordi test directory at .yordi_tests relative to where you execute the command'
+    method_option :api_key, type: :string, aliases: '-k', desc: 'APIKEY from YordiTest.com if you want to sync results online'
+
+    def init
+      puts 'init'
+      if Dir.exist?(YORDI_DIR)
+        puts 'Already initialized'
+        exit(1)
+      end
+      puts "Creating #{YORDI_DIR} directory"
+      DataManager.create_store
+
+      store = DataManager.default_store(options.api_key)
+      puts "Saving store #{CONFIG_FILE}"
+      DataManager.save_store store
+
+      return unless options.api_key
+      puts 'Fetching remote store.'
+      DataManager.fetch(true, true, nil)
+    end
+
+
+    desc 'test PATH_TO_SCREENSHOTS', 'Run a Yordi test on all images in folder'
+    method_option :name, type: :string, default: 'Generic Test', aliases: '-n', desc: 'Name for this test in report.'
+    method_option :clean_dir, type: :boolean, default: false, aliases: '-D', desc: 'This will DELETE all screenshots in PATH_TO_SCREENSHOTS after test completes.'
+    method_option :sync_all, type: :boolean, default: false, aliases: '-a', desc: 'Push all screens to YordiTests.com for evaluation.'
+    method_option :sync_failures, type: :boolean, default: false, aliases: '-f', desc: 'Push only failed screens to YordiTests.com for evaluation.'
+    method_option :filenames, type: :array, aliases: '-i', desc: 'Only test these specific files'
+    method_option :screens, type: :array, aliases: '-s', desc: 'Give the files a name other than there filename in the report (best used with -i option)'
+
+    def test(path_to_screens)
+      puts "Testing #{path_to_screens} name: #{options.name}, clean_dir: #{options.clean_dir}, sync_all: #{options.sync_all}, sync_failures: #{options.sync_failures}, filenames: #{options.filenames}, screens: #{options.screens}"
+
+      DataManager.run_test(path_to_screens, options.name, options.clean_dir, options.sync_all, options.sync_failures, options.filenames, options.screens)
+    end
+
+    desc 'make_report', 'Regenerate a Yordi report based on json report'
+
+    def make_report
+      DataManager.generate_report
+    end
+
+    desc 'fetch', 'Fetch remote data from YordiTests.com'
+    method_option :benchmarks, type: :boolean, default: false, aliases: '-b', desc: 'Fetch benchmarks'
+    method_option :masks, type: :boolean, default: false, aliases: '-m', desc: 'Fetch masks'
+    method_option :screens, type: :array, aliases: '-s', desc: 'Only fetch items associated with this list of screen names'
+
+    def fetch
+      puts "Fetching with options benchmarks: #{options.benchmarks}, masks: #{options.masks}, screens: #{options.screens}"
+      DataManager.fetch(options.benchmarks, options.masks, options.screens)
+    end
+
+    desc 'push', 'Push local data to YordiTests.com'
+    method_option :benchmarks, type: :boolean, default: false, aliases: '-b', desc: 'Push benchmarks'
+    method_option :masks, type: :boolean, default: false, aliases: '-m', desc: 'Push masks'
+    method_option :screens, type: :array, aliases: '-s', desc: 'Only push items associated with this list of screen names'
+
+    def push(path_to_screens)
+      puts "test #{path_to_screens}"
+    end
+
+
+    desc 'open_report', 'Open the last generated report'
+
+    def open_report
+      system "open #{REPORT_HTML}"
+    end
+
+
+  end
+end

data/lib/yordi_tests/client.rb

@@ -0,0 +1,59 @@
+require 'rest-client'
+require 'yordi_tests'
+module YordiTests
+
+  module Client
+    module_function
+
+    def apikey
+      @api_key
+    end
+
+    def apikey=(v)
+      @api_key = v
+    end
+
+    def auth_header
+      "Bearer #{@api_key}"
+    end
+
+    # @param [String] test_name
+    def start(test_name)
+      response = RestClient::Request.execute(method: :get, url: HOST + START_PATH,
+                                             payload: {name: test_name}, headers: {authorization: auth_header})
+      @test_key = JSON(response)['testkey']
+      true
+    end
+
+    # @param [String] screenshot_path
+    # @param [String] screen_name
+    def upload(screenshot_path, screen_name)
+      RestClient.post(HOST + UPLOAD_PATH,
+                      {screenshot: File.new(screenshot_path),
+                       screenname: screen_name, testkey: @test_key},
+                      authorization: auth_header)
+      true
+    end
+
+    def stop
+      RestClient::Request.execute(method: :get, url: HOST + STOP_PATH,
+                                  payload: {testkey: @test_key}, headers: {authorization: auth_header})
+
+      true
+    end
+
+    def fetch_application
+      response = RestClient::Request.execute(method: :get, url: HOST + FETCH_APPLICATION,
+                                             payload: {}, headers: {authorization: auth_header})
+      JSON(response)
+    end
+
+    def fetch_benchmark(screen_name)
+      RestClient::Request.execute(method: :get, url: HOST + FETCH_BENCHMARK,
+                                  payload: {screenname: screen_name}, headers: {authorization: auth_header})
+
+    end
+
+
+  end
+end

data/lib/yordi_tests/data_manager.rb

@@ -0,0 +1,190 @@
+require 'yordi_tests'
+require 'yordi_tests/local_store'
+require 'yordi_tests/image_compare'
+require 'yordi_tests/generators/report'
+module YordiTests
+  module DataManager
+    module_function
+
+    def default_store(apikey)
+      {title: 'YordiTests', apikey: apikey, test_benchmarks: []}
+    end
+
+    def create_store
+      Dir.mkdir(YORDI_DIR) unless Dir.exist? YORDI_DIR
+    end
+
+    def read_store
+      read_json(CONFIG_FILE)
+    end
+
+    def read_report
+      read_json(REPORT_FILE)
+    end
+
+    def read_json(path)
+      if File.exist? path
+        file = File.read path
+        JSON(file)
+      else
+        puts "No file at: #{path} did you call initialize this directory"
+      end
+
+    end
+
+    def save_store(store_hash)
+      File.open(CONFIG_FILE, 'w') {|file| file.write(store_hash.to_json)}
+    end
+
+    # Test entry from the CLI
+    def run_test(path_to_screens, name, clean_dir, sync_all, sync_failures, filenames, screens)
+      local_store = LocalStore.new(read_store)
+      if filenames
+        files = []
+        filenames.each do |filename|
+          files << path_to_screens + '/' + filename
+        end
+      else
+        files = Dir.glob(path_to_screens + '/*.png').sort
+      end
+
+      Dir.mkdir(BENCHMARKS_PATH) unless Dir.exist? BENCHMARKS_PATH
+      Dir.mkdir(SCREENS_PATH) unless Dir.exist? SCREENS_PATH
+      responses = []
+      files.each_with_index do |item, index|
+        puts "Testing #{item}"
+        screenname = (!screens.nil? && screens.size > index) ? screens[index] : File.basename(item, '.*')
+        benchmark = local_store.benchmark_by_screenname(screenname)
+        local_name = benchmark.nil? ? sanitize(screenname) + File.extname(item) : benchmark[LOCAL_FILENAME]
+        benchmark_path = BENCHMARKS_PATH + '/' + local_name
+        screenshot_path = SCREENS_PATH + '/' + local_name
+        FileUtils.copy item, screenshot_path
+        if benchmark.nil?
+          FileUtils.copy item, benchmark_path
+          benchmark = {SCREENNAME => screenname,
+                       MASKED_AREA => nil,
+                       FILENAME => local_name,
+                       LOCAL_FILENAME => local_name}
+          local_store.update_benchmark(benchmark)
+          save_store local_store.data
+        end
+        global_mask = local_store.get(MASKED_AREA)
+        screen_mask = benchmark.nil? ? nil : benchmark[MASKED_AREA]
+        response = ImageCompare.perform(benchmark_path, screenshot_path, global_mask, screen_mask)
+        response[SCREENNAME] = screenname
+        response[LOCAL_FILENAME] = local_name
+        responses << response
+        File.delete item if clean_dir
+      end
+      report_hash = {name: name, tests: responses}
+      File.open(REPORT_FILE, 'w') {|file| file.write(report_hash.to_json)}
+
+      # sync with yorditests.com if desired
+      sync_with_yordi local_store, sync_all, sync_failures if sync_all || sync_failures
+      generate_report
+    end
+
+    def generate_report
+      # generate report
+      YordiTests::Generators::Report.start([REPORT_HTML, read_report])
+
+    end
+
+    def sync_with_yordi(store, sync_all, sync_failures)
+      # sync with remote
+      puts 'Syncing with YordiTests'
+      report = read_report
+      client = YordiTests.client
+      client.apikey = store.apikey if store.apikey
+      if !report.nil? && !report['tests'].empty?
+        reports = report['tests']
+        failures = 0
+        if sync_failures
+          reports.each do |item|
+            failures += 1 unless item['passed']
+          end
+        end
+
+        if sync_all || failures > 0
+          client.start report['name']
+          reports.each do |item|
+            next unless sync_all || !item['passed']
+            puts item[SCREENNAME]
+            benchmark = store.benchmark_by_screenname(item[SCREENNAME])
+            filename = SCREENS_PATH + '/' + benchmark[LOCAL_FILENAME]
+            client.upload filename, item[SCREENNAME]
+          end
+          client.stop
+        end
+      end
+    end
+
+    # Fetch entry from the CLI
+    def fetch(get_benchmarks, get_masks, screens)
+      local_store = LocalStore.new(read_store)
+      ## no api key
+      return unless local_store.apikey
+
+      client = YordiTests.client
+      client.apikey = local_store.apikey
+      remote_data = client.fetch_application
+
+      ## no remote store
+      return unless remote_data
+
+      remote_store = LocalStore.new(remote_data)
+
+      update_store_base(local_store, remote_store)
+      replace_benchmarks(client, local_store, remote_store, screens) if get_benchmarks
+      replace_masks(local_store, remote_store, screens) if get_masks
+
+      save_store local_store.data
+    end
+
+    def update_store_base(local_store, remote_store)
+      local_store.put(TITLE, remote_store.get(TITLE))
+      local_store.put(APIKEY, remote_store.apikey)
+    end
+
+    def replace_benchmarks(client, local_store, remote_store, screens)
+      # no api key
+      screens = remote_store.all_screens unless screens
+
+      Dir.mkdir(BENCHMARKS_PATH) unless Dir.exist? BENCHMARKS_PATH
+
+      screens.each do |screen|
+        benchmark = remote_store.benchmark_by_screenname(screen)
+        next unless benchmark
+
+        benchmark[LOCAL_FILENAME] = sanitize(screen) + File.extname(benchmark[FILENAME])
+
+        # download benchmark
+        puts "Downloading #{screen}"
+        benchmark_image = client.fetch_benchmark(screen)
+
+        # update store to reflex file name of benchmark
+        file_path = "#{BENCHMARKS_PATH}/#{benchmark[LOCAL_FILENAME]}"
+        File.open(file_path, 'w') {|file| file.write(benchmark_image)}
+        local_store.update_benchmark(benchmark)
+      end
+    end
+
+    def replace_masks(local_store, remote_store, screens)
+      # global mask
+      local_store.put(MASKED_AREA, remote_store.get(MASKED_AREA))
+      screens = remote_store.all_screens unless screens
+      screens.each do |screen|
+        benchmark = remote_store.benchmark_by_screenname(screen)
+        # download benchmark
+        puts "Update mask for #{screen}"
+        local_store.update_mask(benchmark) if benchmark
+      end
+    end
+
+
+    def sanitize(filename)
+      # Remove any character that aren't 0-9, A-Z, or a-z
+      filename.gsub(/[^0-9A-Z]/i, '_')
+    end
+  end
+end

data/lib/yordi_tests/generators/report.html.erb

@@ -0,0 +1,100 @@
+<html>
+<head>
+  <title><%= report_data['name'] %></title>
+  <style>
+    body {
+      font-family: "Roboto", Helvetica, sans-serif;
+      background-color: #8F5699;
+    }
+
+    .passed {
+      display: none;
+    }
+
+    table {
+      background: #fff;
+      border-radius: 4px;
+      padding: 10px;
+      margin: 2%;
+    }
+
+    h1 {
+      color:white;
+      margin-left: 2%;
+    }
+
+    h2 {
+      margin-top: 20px;
+    }
+
+    .toggle {
+      margin-right: 2%;
+      display: inline-block;
+      color: white;
+      float: right;
+      clear: both;
+    }
+
+  </style>
+  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
+  <script>
+      $(document).ready(function () {
+          $('.toggle').on('click', function () {
+              if ($('.passed').css('display') == 'none') {
+                  $('.passed').css('display', 'table-row');
+                  $('.toggle').text('Hide successful tests');
+              } else {
+
+                  $('.passed').css('display', 'none');
+                  $('.toggle').text('Show successful tests');
+              }
+          })
+      });
+  </script>
+</head>
+<body>
+<a class="toggle" href="#">
+  Show successful tests
+</a>
+<h1><%= report_data['name'] %></h1>
+
+<table style="width:96%">
+
+  <% report_data['tests'].each do |item|
+    class_name = item['passed'] ? 'passed' : 'failed'
+          %>
+    <tr class="<%= class_name %>">
+      <td colspan="3">
+        <h2> <%= item['screenname'] %></h2>
+        <p>
+          <b style="font-size:24px;"><%= item['passed'] ? 'Passed' : 'Failed' %></b><br/>
+          <%= item['passed'] ? item['message'] : '' %><br/>
+        </p>
+
+      </td>
+    </tr>
+    <tr class="<%= class_name %>">
+      <td>
+        <b>Benchmark</b><br/>
+        <img style="width:100%" src="benchmarks/<%= item['local_filename'] %>"/>
+
+      </td>
+
+      <td>
+        <% if item['has_diff'] %>
+          <b>Diff</b><br/>
+          <img style="width:100%" src="screenshots/<%= item['local_filename'] %>.diff.png"/>
+        <% end %>
+      </td>
+
+      <td>
+        <b>Result</b><br/>
+        <img style="width:100%" src="benchmarks/<%= item['local_filename'] %>"/>
+
+      </td>
+    </tr>
+  <% end %>
+
+</table>
+</body>
+</html>

data/lib/yordi_tests/generators/report.rb

@@ -0,0 +1,19 @@
+require 'thor/group'
+module YordiTests
+  module Generators
+    class Report < Thor::Group
+      include Thor::Actions
+      argument :report_path, type: :string
+      argument :report_data, type: :hash, default: {name: 'Unknown'}
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      def create_report
+        template("report.html.erb", report_path, force: true)
+      end
+
+    end
+  end
+end

data/lib/yordi_tests/image_compare.rb

@@ -0,0 +1,92 @@
+require 'yordi_tests'
+require 'mini_magick'
+require 'securerandom'
+require 'yordi_tests/local_store'
+module YordiTests
+  module ImageCompare
+    module_function
+
+    def addMask(image_path, global_mask, screen_mask)
+      output_path = "#{image_path}#{SecureRandom.hex}.png"
+      convert = MiniMagick::Tool::Convert.new(whiny: false)
+      convert << image_path
+      convert.fill('white')
+      convert.stroke('none')
+      unless screen_mask.nil?
+        screen_mask.each do |item|
+          convert.draw("rectangle #{item['x']}, #{item['y']} #{item['x'] + item['width']},#{item['y'] + item['height']}")
+        end
+      end
+      unless global_mask.nil?
+        global_mask.each do |item|
+          convert.draw("rectangle #{item['x']}, #{item['y']} #{item['x'] + item['width']},#{item['y'] + item['height']}")
+        end
+      end
+      convert << output_path
+
+      convert.call do |stdout, stderr, status|
+        unless stderr.nil?
+          # error_count = stderr.to_i
+        end
+      end
+      output_path
+    end
+
+    def perform( benchmark_path, screenshot_path, global_mask, screen_mask)
+      response = { passed: false, message: 'None', has_diff: false, diff: nil}
+
+      #compare images
+      # begin
+      screenshot = MiniMagick::Image.open(screenshot_path)
+      benchmark_screenshot = MiniMagick::Image.open(benchmark_path)
+      if screenshot.nil?
+        response[:message] = 'Screen shot unreadable'
+      elsif benchmark_screenshot.nil?
+        response[:message] = 'Benchmark image unreadable'
+      elsif screenshot.width != benchmark_screenshot.width || screenshot.height != benchmark_screenshot.height
+        response[:message] = 'Screenshot has wrong dimensions'
+
+      else
+        if screenshot.signature == benchmark_screenshot.signature
+          response[:passed] = true
+          response[:message] = 'Screenshot is perfect'
+        else
+          compare_mask_one = addMask(benchmark_path, global_mask, screen_mask)
+          compare_mask_two = addMask(screenshot_path, global_mask, screen_mask)
+
+          image_diff = "#{screenshot_path}.diff.png"
+          compare = MiniMagick::Tool::Compare.new(whiny: false)
+          compare.metric('AE')
+          compare.fuzz('5%')
+
+          compare << compare_mask_one
+          compare << compare_mask_two
+          #  compare.compose('Src')
+          compare << image_diff
+
+          error_count = 0
+          compare.call do |stdout, stderr, status|
+            unless stderr.nil?
+              error_count = stderr.to_i
+            end
+          end
+
+          if error_count.zero?
+            response[:passed] = true
+            response[:message] = 'Screenshot seems to be the same.'
+          else
+            response[:message] = 'Hmm, has something changed, WTF!'
+          end
+
+          response[:diff] = image_diff
+          response[:has_diff] = true
+          File.delete(compare_mask_one) unless compare_mask_one.nil?
+          File.delete(compare_mask_two) unless compare_mask_two.nil?
+
+        end
+      end
+      response
+
+    end
+  end
+end

data/lib/yordi_tests/local_store.rb

@@ -0,0 +1,75 @@
+require 'yordi_tests'
+module YordiTests
+  BENCHMARKS = 'test_benchmarks'.freeze
+  SCREENNAME = 'screenname'.freeze
+  FILENAME = 'filename'.freeze
+  MASKED_AREA = 'masked_area'.freeze
+  APIKEY = 'apikey'.freeze
+  LOCAL_FILENAME = 'local_filename'.freeze
+  TITLE = 'title'.freeze
+
+  class LocalStore
+
+    def initialize(json_store)
+      @store = json_store
+    end
+
+    def apikey
+      get(APIKEY)
+    end
+
+    def data
+      @store
+    end
+
+    def put(key, data)
+      @store[key] = data
+    end
+
+    def get(key)
+      @store[key]
+    end
+
+    def all_screens
+      screens = []
+      @store[BENCHMARKS].each do |benchmark|
+        screens << benchmark[SCREENNAME]
+      end
+      screens
+    end
+
+    def update_benchmark(benchmark)
+      benchmark_pos = benchmark_pos_by_screenname(benchmark[SCREENNAME])
+      if benchmark_pos < 0
+        @store[BENCHMARKS] << benchmark.dup
+      else
+        @store[BENCHMARKS][benchmark_pos][SCREENNAME] = benchmark[SCREENNAME]
+        @store[BENCHMARKS][benchmark_pos][FILENAME] = benchmark[FILENAME]
+        @store[BENCHMARKS][benchmark_pos][LOCAL_FILENAME] = benchmark[LOCAL_FILENAME]
+      end
+    end
+
+    def update_mask(benchmark)
+      benchmark_pos = benchmark_pos_by_screenname(benchmark[SCREENNAME])
+      if benchmark_pos < 0
+        @store[BENCHMARKS] << benchmark.dup
+      else
+        @store[BENCHMARKS][benchmark_pos][MASKED_AREA] = benchmark[MASKED_AREA]
+      end
+    end
+
+    def benchmark_by_screenname(screenname)
+      @store[BENCHMARKS].each do |benchmark|
+        return benchmark.dup if screenname.eql? benchmark[SCREENNAME]
+      end
+      nil
+    end
+
+    def benchmark_pos_by_screenname(screenname)
+      @store[BENCHMARKS].each_with_index do |benchmark, index|
+        return index if screenname.eql? benchmark[SCREENNAME]
+      end
+      -1
+    end
+  end
+end

data/lib/yordi_tests/version.rb

@@ -0,0 +1,3 @@
+module YordiTests
+  VERSION = "0.1.7"
+end

data/lib/yordi_tests.rb

@@ -0,0 +1,41 @@
+require 'yordi_tests/version'
+require 'yordi_tests/client'
+module YordiTests
+
+  HOST = ENV['YORDI_HOST'].freeze || 'https://yorditests.com'.freeze
+  START_PATH = '/api/v1/start'.freeze
+  UPLOAD_PATH = '/api/v1/upload'.freeze
+  STOP_PATH = '/api/v1/stop'.freeze
+  FETCH_APPLICATION = '/api/v1/fetch_application'.freeze
+  PUSH_BENCHMARK = '/api/v1/push_benchmarks'.freeze
+  PUSH_MASK = '/api/v1/push_masks'.freeze
+  FETCH_BENCHMARK = '/api/v1/benchmark'.freeze
+
+
+  YORDI_DIR = ENV['YORDI_DIR'].freeze || '.yordi_tests'.freeze
+  BENCHMARKS_PATH = YORDI_DIR + '/benchmarks'.freeze
+  SCREENS_PATH = YORDI_DIR + '/screenshots'.freeze
+  CONFIG_FILE = YORDI_DIR + '/config.json'.freeze
+  REPORT_FILE = YORDI_DIR + '/report.json'.freeze
+  REPORT_HTML = YORDI_DIR + '/report.html'.freeze
+
+  module_function
+
+  def client=(v)
+    @client = v
+  end
+
+  def client
+    @client
+  end
+
+  # set default value
+  @client = Client
+
+  def new_client(apikey)
+    client = new
+    client.extend(Client)
+    client.apikey = apikey
+    client
+  end
+end

data/yordi_tests.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "yordi_tests"
+
+Gem::Specification.new do |spec|
+  spec.name          = "yordi_tests"
+  spec.version       = YordiTests::VERSION
+  spec.authors       = ["Brian OQR"]
+  spec.email         = ["oqrbrian@gmail.com"]
+
+  spec.summary       = "This is a CLI to run standalone or integrate with online YordiTests.com"
+  spec.description   = "This is an alpha version and under continual development, not yet stable"
+  spec.homepage      = "https://www.yorditests.com"
+  spec.license       = "MIT"
+  spec.required_ruby_version = '~> 2.0'
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thor', '~>0.20'
+  spec.add_dependency 'rest-client', '~>2.0'
+  spec.add_dependency 'mini_magick', '~>4.8'
+
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: yordi_tests
+version: !ruby/object:Gem::Version
+  version: 0.1.7
+platform: ruby
+authors:
+- Brian OQR
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: This is an alpha version and under continual development, not yet stable
+email:
+- oqrbrian@gmail.com
+executables:
+- yordi
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/yordi
+- lib/yordi_tests.rb
+- lib/yordi_tests/cli.rb
+- lib/yordi_tests/client.rb
+- lib/yordi_tests/data_manager.rb
+- lib/yordi_tests/generators/report.html.erb
+- lib/yordi_tests/generators/report.rb
+- lib/yordi_tests/image_compare.rb
+- lib/yordi_tests/local_store.rb
+- lib/yordi_tests/version.rb
+- yordi_tests.gemspec
+homepage: https://www.yorditests.com
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: This is a CLI to run standalone or integrate with online YordiTests.com
+test_files: []