motion-screenspecs 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e1ee4821ad5489d2e5e5b0b32e5d189733f0c30
+  data.tar.gz: 707ccb1260a5cf1d8607983cfa22bb0639b6451c
+SHA512:
+  metadata.gz: d8a7f61d656df6c054faadf2bfd8f8b965bf40b558c6370f0fc169b960893f303600743b9a8f205d920b2d4f6620960ac04b038c3e9518bbebe86991dfa19ab3
+  data.tar.gz: 0e17a6418a9631c08ebd252b80d4a4efff5241b8d93d997cb4c2c3739a3ed8f394b3fc33e1eeee3bd5b676a6f33297f6db5a4f549c390b930da18f9af138fa9b

data/README.md

@@ -0,0 +1,111 @@
+# motion-screenspecs
+
+Test your RubyMotion app regressions using screenshot comparison (similar to [Huxley](https://github.com/facebook/huxley) and [Wraith](https://github.com/BBC-News/wraith)):
+
+```
+$ rake spec
+
+AppScreenshots
+  - should take screenshots
+
+AppScreenshots.menu
+  - should be <= 5.0% difference
+
+AppScreenshots.timeline
+  - should be <= 5.0% difference [FAILED - was 10.75%]
+
+Bacon::Error: was 10.75%
+    spec.rb:698:in `satisfy:': AppScreenshots.timeline - should be <= 5.0% difference
+    spec.rb:438:in `execute_block'
+    spec.rb:402:in `run_postponed_block:'
+    spec.rb:397:in `resume'
+
+3 specifications (3 requirements), 1 failures, 0 errors
+```
+
+![exampke](readme.png)
+
+(calculated diffs are truer than visual representation)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motion-screenspecs'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motion-screenspecs
+
+## Usage
+
+motion-screenspecs works in unison with [motion-screenshots](https://github.com/usepropeller/motion-screenshots). Here are the steps you need to get everything working:
+
+1. Create a subclass of `Motion::Screenshots::Base` (see the [motion-screenshots README](https://github.com/usepropeller/motion-screenshots/blob/master/README.md)).
+
+2. Create the following directory structure:
+
+    ```
+    spec/
+      screenshots/
+        [YourScreenshotSubclass]
+          expectations/
+            [title of your screenshot].png
+            [title of your other screenshot].png
+            [etc].png
+    ```
+
+    The images in `expectations` are known values for your app. You can take these screenshots manually or using motion-screenshots' `rake screenshots`.
+
+    Failing image diffs will be saved in `spec/screenshots/[YourScreenshotSubclass]/failures`. All results from the latest test are saved to `spec/screenshots/[YourScreenshotSubclass]/results`.
+    
+3. Add a call to `tests_screenshots` in your specs:
+
+    ```ruby
+    describe "Screenshots" do
+      tests_screenshots AppScreenshots
+    end
+    ```
+
+The [sample app](sample) is a complete example with a failing test.
+
+Hats off to [Jeff Kreeftmeijer](http://jeffkreeftmeijer.com/2011/comparing-images-and-creating-image-diffs/) for the image diffing help!
+
+## Configuration
+
+There's a couple of configuration options you can use:
+
+```ruby
+Motion::Project::App.setup do |app|
+  # Set your tolerance % for image differences
+  Motion::Screenspecs.set_tolerance(5.0, app)
+
+  # Set how long the tests will wait for your screenshots to finish
+  Motion::Screenspecs.set_screenshot_timeout(120, app)
+
+  # Set how long the tests will wait for a given image to finish diffing
+  Motion::Screenspecs.set_diff_timeout(20, app)
+
+  # Set whether or not your failed diffs will open in Finder upon finishing tests
+  Motion::Screenspecs.open_failures_at_exit = true
+end
+```
+
+`rake spec`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Contact
+
+[Clay Allsopp](http://clayallsopp.com/)
+[@clayallsopp](https://twitter.com/clayallsopp)

data/lib/motion-screenspecs.rb

@@ -0,0 +1,207 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+require 'motion-screenshots'
+require 'motion-env'
+
+require 'webrick'
+require 'oily_png'
+require 'fileutils'
+require 'shellwords'
+
+is_spec_mode = Rake.application.top_level_tasks.include?('spec')
+
+if is_spec_mode
+  class Motion::Project::Config
+
+    def spec_core_files_with_screenshots
+      files = spec_core_files_without_screenshots
+
+      lib_helper = File.join(File.dirname(__FILE__), 'spec', 'helpers.rb')
+      files << lib_helper unless files.include?(lib_helper)
+      files
+    end
+
+    alias_method "spec_core_files_without_screenshots", "spec_core_files"
+    alias_method "spec_core_files", "spec_core_files_with_screenshots"
+  end
+
+  class Motion::Project::App
+    class << self
+      def build_with_screenspecs(platform, opts = {})
+        unless File.exist?('vendor/Pods/KSScreenshotManager')
+          Rake::Task["pod:install"].reenable
+          Rake::Task["pod:install"].invoke
+        end
+        build_without_screenspecs(platform, opts)
+      end
+
+      alias_method "build_without_screenspecs", "build"
+      alias_method "build", "build_with_screenspecs"
+    end
+  end
+end
+
+module Motion
+  module Screenspecs
+    PORT = 9678
+    TOLERANCE_ENV = '_motion-screenspecs-tolerance'
+    SCREENSHOT_TIMEOUT_ENV = '_motion-screenspecs-screenshot-timeout'
+    DIFF_TIMEOUT_ENV = '_motion-screenspecs-diff-timeout'
+
+    def self.tolerance
+      @tolerance
+    end
+
+    def self.set_tolerance(tolerance, config)
+      @tolerance = tolerance
+      config.env[TOLERANCE_ENV] = tolerance
+      tolerance
+    end
+
+    def self.set_screenshot_timeout(timeout, config)
+      config.env[SCREENSHOT_TIMEOUT_ENV] = timeout
+    end
+
+    def self.set_diff_timeout(timeout, config)
+      config.env[DIFF_TIMEOUT_ENV] = timeout
+    end
+
+    def self.open_failures_at_exit?
+      !!@open_failures_at_exit
+    end
+
+    def self.open_failures_at_exit=(open)
+      @open_failures_at_exit = open
+    end
+
+    def self.failures
+      @failures ||= []
+    end
+
+    def self.screenshots_root(screenshot_class)
+      "spec/screenshots/#{screenshot_class}"
+    end
+
+    def self.start_server!
+      # Start a web server to bounce file paths to-and-from the
+      # RubyMotion-CRuby barrier
+      @web_server ||= begin
+        server = WEBrick::HTTPServer.new(:Port => Motion::Screenspecs::PORT, :Logger => WEBrick::Log.new("/dev/null"), :AccessLog => [])
+        server.mount '/', Motion::Screenspecs::Servlet
+        at_exit {
+          server.shutdown
+        }
+        Thread.start do
+          server.start
+        end
+        server
+      end
+    end
+
+    class Servlet < WEBrick::HTTPServlet::AbstractServlet
+      def do_GET (request, response)
+        if (title = request.query["title"]) &&
+            (screenshot_path = request.query["screenshot_path"]) &&
+            (screenshot_class = request.query['screenshot_class'])
+          screenshot_path.gsub!("file://", "")
+          screenshots_root = Motion::Screenspecs.screenshots_root(screenshot_class)
+          expectation_path = File.expand_path(File.join(screenshots_root, "expectations", "#{title}.png"))
+          result_path = File.expand_path(File.join(screenshots_root, "results", "#{title}.png"))
+          failure_path = File.expand_path(File.join(screenshots_root, "failures", "#{title}.png"))
+          FileUtils.mkdir_p(File.dirname(failure_path))
+          FileUtils.mkdir_p(File.dirname(result_path))
+
+          File.delete(result_path) if File.exists?(result_path)
+          temp_result_path = File.join(File.dirname(result_path), File.basename(screenshot_path))
+          FileUtils.cp(screenshot_path, File.dirname(result_path))
+          FileUtils.mv(temp_result_path, result_path)
+
+          File.delete(failure_path) if File.exists?(failure_path)
+
+          percentage = Motion::Screenspecs::ImageDiff.new.percentage(expectation_path, screenshot_path, failure_path)
+          success = percentage < Motion::Screenspecs.tolerance
+          response.status = success ? 200 : 400
+          response.content_type = "text/plain"
+          response.body = "%05.2f" % percentage
+        else
+          response.status = 404
+          response.body = "You did not provide the correct parameters"
+        end
+      end
+    end
+
+    class ImageDiff
+      include ChunkyPNG::Color
+
+      # via http://jeffkreeftmeijer.com/2011/comparing-images-and-creating-image-diffs/
+      def percentage(image_a, image_b, failure_path)
+        images = [
+          ChunkyPNG::Image.from_file(image_a),
+          ChunkyPNG::Image.from_file(image_b)
+        ]
+
+        output = ChunkyPNG::Image.new(images.first.width, images.last.height, WHITE)
+
+        diff = []
+
+        images.first.height.times do |y|
+          images.first.row(y).each_with_index do |pixel, x|
+            unless pixel == images.last[x,y]
+              score = Math.sqrt(
+                (r(images.last[x,y]) - r(pixel)) ** 2 +
+                (g(images.last[x,y]) - g(pixel)) ** 2 +
+                (b(images.last[x,y]) - b(pixel)) ** 2
+              ) / Math.sqrt(MAX ** 2 * 3)
+
+              output[x,y] = rgb(
+                r(pixel) + r(images.last[x,y]) - 2 * [r(pixel), r(images.last[x,y])].min,
+                g(pixel) + g(images.last[x,y]) - 2 * [g(pixel), g(images.last[x,y])].min,
+                b(pixel) + b(images.last[x,y]) - 2 * [b(pixel), b(images.last[x,y])].min
+              )
+              diff << score
+            end
+          end
+        end
+
+        summed = diff.inject {|sum, value| sum + value}
+        if summed
+          percent = (summed / images.first.pixels.length) * 100
+        else
+          percent = 0
+        end
+        if percent >= Motion::Screenspecs.tolerance
+          output.save(failure_path)
+          Motion::Screenspecs.failures << failure_path
+        end
+        percent
+      end
+    end
+  end
+end
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "motion/**/*.rb")))
+
+  Motion::Screenspecs.set_tolerance(5.0, app)
+  Motion::Screenspecs.set_screenshot_timeout(120, app)
+  Motion::Screenspecs.set_diff_timeout(20, app)
+  Motion::Screenspecs.open_failures_at_exit = true
+
+  if is_spec_mode
+    app.pods do
+      pod 'KSScreenshotManager'
+    end
+
+    Motion::Screenspecs.start_server!
+
+    at_exit {
+      if Motion::Screenspecs.open_failures_at_exit?
+        folder_path = Dir.glob('spec/**/failures').first
+        `open #{folder_path.shellescape}` unless Motion::Screenspecs.failures.empty?
+      end
+    }
+  end
+end

data/lib/spec/helpers.rb

@@ -0,0 +1,76 @@
+module Bacon
+  class Context
+    def tests_screenshots(screenshot_class)
+      describe screenshot_class do
+        shared_screenshots = screenshot_class.send(:shared)
+        shared_screenshots.exitOnComplete = false
+        if shared_screenshots.respond_to?("isLoggingEnabled")
+          shared_screenshots.loggingEnabled = false
+        end
+        tolerance = ENV['_motion-screenspecs-tolerance']
+        screenshot_timeout = ENV['_motion-screenspecs-screenshot-timeout']
+        diff_timeout = ENV['_motion-screenspecs-diff-timeout']
+
+        it "should take screenshots" do
+          existing_after = shared_screenshots.screenshot_groups.last.instance_variable_get("@after_actions")
+          shared_screenshots.screenshot_groups.last.after do
+            existing_after.call if existing_after
+
+            # resume tests
+            resume
+          end
+
+          screenshot_class.start!
+          wait_max screenshot_timeout do
+
+            true.should == true
+          end
+        end
+
+        shared_screenshots.screenshot_groups.each do |group|
+          title = group.instance_variable_get('@title')
+          before do
+            path_url = shared_screenshots.screenshotsURL
+
+            is_retina = UIScreen.mainScreen.scale != 1.0
+            density = is_retina ? "@2x" : ""
+            device_prefix = nil
+
+            if UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPad
+              device_prefix = "ipad"
+            elsif UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPhone
+              device_prefix = "iphone#{CGRectGetHeight(UIScreen.mainScreen.bounds).to_i}"
+            end
+
+            device_prefix << density
+
+            file_name = "#{device_prefix}-#{NSLocale.currentLocale.localeIdentifier}-#{title}.png"
+            path = path_url.URLByAppendingPathComponent(file_name)
+            @screenshot_path = path.absoluteString
+          end
+
+          describe "#{screenshot_class}.#{title}" do
+            it "should be < #{tolerance}% difference" do
+
+              url = NSURL.URLWithString "http://localhost:9678?screenshot_class=#{screenshot_class}&title=#{title}&screenshot_path=#{@screenshot_path}"
+              request = NSURLRequest.requestWithURL(url)
+              NSURLConnection.sendAsynchronousRequest(request, queue:NSOperationQueue.mainQueue,
+                completionHandler:->(ns_url_response, data, error){
+                  @response = ns_url_response
+                  @data = data
+                  resume
+              })
+
+              wait_max diff_timeout do
+                body = NSString.alloc.initWithData(@data, encoding:NSUTF8StringEncoding)
+                @response.statusCode.should.satisfy("was #{body}%") {|object|
+                  object == 200
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: motion-screenspecs
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Clay Allsopp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: motion-screenshots
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+- !ruby/object:Gem::Dependency
+  name: oily_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: motion-env
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Test your RubyMotion apps using screenshot comparison.
+email:
+- clay.allsopp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/motion-screenspecs.rb
+- lib/spec/helpers.rb
+homepage: https://github.com/usepropeller/motion-screenspecs
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Test your RubyMotion apps using screenshot comparison.
+test_files: []