smart_monkey 0.1

data/lib/ui-auto-monkey/tuneup/image_asserter

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby -w
+
+require File.expand_path(File.join(File.dirname(__FILE__), "image_assertion"))
+
+SUCCESS_EXIT_STATUS = 0
+FAILED_EXIT_STATUS  = 1
+
+test_output     = ARGV[0]
+ref_images_path = ARGV[1]
+image_name      = ARGV[2]
+threshold       = ARGV[3]
+
+unless (test_output && ref_images_path && image_name)
+
+  $stderr.puts('incorrect arguments')
+  exit FAILED_EXIT_STATUS
+end
+
+assertion_result = ImageAssertion.assert_image(File.expand_path(test_output),
+                                               File.expand_path(ref_images_path),
+                                               image_name,
+                                               threshold)
+exit FAILED_EXIT_STATUS unless assertion_result
+
+exit SUCCESS_EXIT_STATUS
+

data/lib/ui-auto-monkey/tuneup/image_assertion.js

@@ -0,0 +1,65 @@
+var ImageAsserter = (function() {
+
+  function ImageAsserter(tuneUpPath, outputPath, refImagesPath) {
+    if (!outputPath || !refImagesPath || !tuneUpPath) {
+      throw new AssertionException("output, refImages, tuneUp pathes can't be null");
+    }
+
+    this.tuneUpPath     = tuneUpPath;
+    this.outputPath     = outputPath;
+    this.refImagesPath  = refImagesPath;
+
+    var target          = UIATarget.localTarget();
+    if (!target) {
+      throw new AssertionException("unable to get localTarget");
+    }
+
+    this.host           = target.host();
+    if (!this.host) {
+      throw new AssertionException("unable to get current UAIHost");
+    }
+  }
+
+  ImageAsserter.prototype.assertImageNamed = function(imageName, threshold) {
+    var command,
+        taskResult,
+        assertSuccessfull = false,
+        SUCCESS_EXIT_CODE = 0,
+        TIMEOUT           = 5,
+        args              = [this.outputPath, this.refImagesPath, imageName, threshold];
+
+    command     = this.tuneUpPath + '/image_asserter';
+    taskResult  = this.host.performTaskWithPathArgumentsTimeout(command,
+                                                                args,
+                                                                TIMEOUT);
+
+    assertSuccessful = (taskResult.exitCode === SUCCESS_EXIT_CODE);
+    if (!assertSuccessful) {
+      UIALogger.logError(taskResult.stderr);
+    }
+
+    return assertSuccessful;
+  };
+
+  return ImageAsserter;
+}());
+
+function createImageAsserter(tuneUpPath, outputPath, refImagesPath) {
+  this.imageAsserter = new ImageAsserter(tuneUpPath, outputPath, refImagesPath);
+}
+
+function assertScreenMatchesImageNamed(imageName, message, threshold) {
+  if (!this.imageAsserter) {
+    throw new AssertionException("imageAsserter isn't created.");
+  }
+
+  UIATarget.localTarget().captureAppScreenWithName(imageName);
+  UIATarget.localTarget().delay(1); // delay for screenshot to be saved
+
+  var assertionPassed = this.imageAsserter.assertImageNamed(imageName, threshold);
+  if (!assertionPassed) {
+
+    if (!message) message = 'Assertion of the image ' + imageName + ' failed.';
+    throw new AssertionException(message);
+  }
+}

data/lib/ui-auto-monkey/tuneup/image_assertion.rb

@@ -0,0 +1,102 @@
+require 'open3'
+require 'shellwords'
+
+class ImageAssertion
+
+  MAX_ALLOWED_DIFF_VALUE  = 1.0
+  DIFF_IMAGE_FOLDER_NAME  = 'screens_diff'
+
+  def self.assert_image(test_output, ref_images_path, image_name, threshold)
+    return false unless (test_output && ref_images_path && image_name)
+
+    diff_images_path  = File.join(test_output, DIFF_IMAGE_FOLDER_NAME)
+    Dir.mkdir(diff_images_path) unless File.directory?(diff_images_path)
+
+    image_file_name   = image_name + '.png'
+    expected_path     = File.join(ref_images_path, image_file_name)
+    diff_path         = File.join(diff_images_path, image_file_name)
+
+    run_folder_name   = find_last_folder(test_output)
+    received_path     = File.join(run_folder_name, image_file_name)
+
+    print_status(create_status('started', "Asserting #{image_file_name}."))
+
+    if !File.exists?(received_path)
+      error = "No captured image file found at #{received_path}"
+      print_status(create_status('failed', error))
+      return false
+    elsif !File.exists?(expected_path)
+      error = "No reference image file found at #{expected_path}"
+      print_status(create_status('failed', error))
+      return false
+    else
+      result, exit_status = im_compare(expected_path, received_path, diff_path)
+      if exit_status == 0
+        return process_imagemagick_result(image_file_name, result, threshold)
+      elsif exit_status == 1
+        print_status(create_status('failed', "Images differ, check #{diff_images_path} for details. ImageMagick error: #{result}"))
+      else
+        print_status(create_status('failed', "ImageMagick comparison failed: #{result}"))
+      end
+    end
+  end
+
+private
+
+  # Iterte through folders with name Run* and return with latests run number
+  def self.find_last_folder(test_output)
+    folder_mask = "#{test_output}/Run";
+    run_folders = Dir.glob("#{folder_mask}*")
+
+    return nil unless run_folders.length > 0
+
+    run_folders.sort do |x, y|
+      y.gsub(folder_mask, '').to_i <=> x.gsub(folder_mask, '').to_i
+    end[0]
+  end
+
+  def self.process_imagemagick_result(image_file_name, result, threshold)
+    result_status   = 'failed'
+    result_message  = "#{image_file_name} is not equal to the reference."
+    assertionResult = false
+
+    #imagemagick outputs floating point metrics value when succeeds
+    compare_succeed = ( result.match(/[0-9]*\.?[0-9]+/).length > 0 )
+    threshold ||= MAX_ALLOWED_DIFF_VALUE
+
+    if compare_succeed
+      if result.to_f < threshold
+
+        result_status   = 'passed'
+        result_message  = "#{image_file_name} asserted successfully."
+        assertionResult = true
+      else
+        print_status(create_status(result_status, "expected diff is smaller than #{threshold} but #{result.to_f}."))
+      end
+    else
+
+      result_message    = result
+    end
+
+    print_status(create_status(result_status, result_message))
+    assertionResult
+  end
+
+  def self.create_status(status, message)
+    "#{Time.new} #{status}: #{message}"
+  end
+
+  def self.print_status(message)
+    $stderr.puts(message)
+  end
+
+  def self.im_compare(expected_path, received_path, diff_path)
+    command = '/usr/local/bin/compare -metric MAE '
+    command << Shellwords.escape(expected_path) + ' '
+    command << Shellwords.escape(received_path) + ' '
+    command << ( diff_path ? Shellwords.escape(diff_path) : 'null:' )
+
+    _, _, stderr, wait_thr = Open3.popen3(command)
+    [stderr.read, wait_thr.value.exitstatus]
+  end
+end

data/lib/ui-auto-monkey/tuneup/lang-ext.js

@@ -0,0 +1,76 @@
+/**
+ * Extend +destination+ with +source+
+ */
+function extend(destination, source) {
+  for (var property in source) {
+    destination[property] = source[property];
+  }
+  return destination;
+}
+
+/**
+ * Dump the properties out a String returned by the function.
+ */
+function dumpProperties(_this) {
+  var dumpStr = "";
+  for (var propName in _this) {
+    if (_this.hasOwnProperty(propName)) {
+      if (dumpStr !== "") {
+        dumpStr += ", ";
+      }
+      dumpStr += (propName + "=" + _this[propName]);
+    }
+  }
+
+  return dumpStr;
+};
+
+function getMethods(_this) {
+  var methods = [];
+  for (var m in _this) {
+    //if (typeof _this[m] == "function" && _this.hasOwnProperty(m)) {
+    if (typeof _this[m] == "function") {
+      methods.push(m);
+    }
+  }
+  return methods;
+}
+
+extend(Array.prototype, {
+  /**
+   * Applies the given function to each element in the array until a
+   * match is made. Otherwise returns null.
+   * */
+  contains: function(f) {
+    for (i = 0; i < this.length; i++) {
+      if (f(this[i])) {
+        return this[i];
+      }
+    }
+    return null;
+  },
+
+  unique:  function() {
+    function onlyUnique(value, index, self) {
+      return self.indexOf(value) === index;
+    }
+
+    return this.filter(onlyUnique);
+  }
+});
+
+String.prototype.trim = function() {
+  return this.replace(/^\s+|\s+$/g,"");
+};
+
+String.prototype.ltrim = function() {
+  return this.replace(/^\s+/,"");
+};
+
+String.prototype.rtrim = function() {
+  return this.replace(/\s+$/,"");
+};
+
+String.prototype.lcfirst = function() {
+  return this.charAt(0).toLowerCase() + this.substr(1);
+};

data/lib/ui-auto-monkey/tuneup/screen.js

@@ -0,0 +1,11 @@
+Screen = {
+  screens: {},
+  
+  add: function(name, definition) {
+    this.screens[name] = definition;
+  },
+  
+  named: function(name) {
+    return this.screens[name];
+  }
+};

data/lib/ui-auto-monkey/tuneup/test.js

@@ -0,0 +1,71 @@
+/**
+ * Run a new test with the given +title+ and function body, which will
+ * be executed within the proper test declarations for the UIAutomation
+ * framework. The given function will be handed a +UIATarget+ and
+ * a +UIApplication+ object which it can use to exercise and validate your
+ * application.
+ *
+ * The +options+ parameter is an optional object/hash thingie that
+ * supports the following:
+ *    logTree -- a boolean to log the element tree when the test fails (default 'true')
+ *
+ * Example:
+ * test("Sign-In", function(target, application) {
+ *   // exercise and validate your application.
+ * });
+ *
+ * The +title+ is checked against every element of a global TUNEUP_ONLY_RUN
+ * array. To check, each element is converted to a RegExp. The test is only
+ * executed, if one check succeeds. If TUNEUP_ONLY_RUN is not defined,
+ * no checks are performed.
+ */
+function test(title, f, options) {
+  if (typeof TUNEUP_ONLY_RUN !== 'undefined') {
+    for (var i = 0; i < TUNEUP_ONLY_RUN.length; i++) {
+        if (new RegExp("^" + TUNEUP_ONLY_RUN[i] + "$").test(title)) {
+          break;
+        }
+        if (i == TUNEUP_ONLY_RUN.length -1) {
+          return;
+        }
+    }
+  }
+
+  if (!options) {
+    options = testCreateDefaultOptions();
+  }
+  target = UIATarget.localTarget();
+  application = target.frontMostApp();
+  UIALogger.logStart(title);
+  try {
+    target.logDeviceInfo();//打印设备信息
+    f(target, application);
+    UIALogger.logPass(title);
+  }
+  catch (e) {
+    UIALogger.logError(e.toString());
+    if (options.logStackTrace) UIALogger.logError(e.stack);
+    if (options.logTree) target.logElementTree();
+    if (options.logTreeJSON) application.mainWindow().logElementTreeJSON();
+    if (options.screenCapture) target.captureScreenWithName(title + '-fail');
+    UIALogger.logFail(title);
+  }
+  finally{
+    target.captureScreenWithName('finish');
+  }
+}
+
+/**
+ * Helper function to isolate clients from additional option changes. Clients can use this function to get a new option object and then only change the options they care about, confident that any new options added since their
+ * code was created will contain the new default values.
+ * @returns {Object} containing the error options
+ */
+function testCreateDefaultOptions() {
+  return {
+    logStackTrace: false,
+    logTree: false,
+    logTreeJSON: false,
+    screenCapture: false
+  };
+}
+

data/lib/ui-auto-monkey/tuneup/test_runner/abbreviated_console_output.rb

@@ -0,0 +1,38 @@
+class AbbreviatedConsoleOutput < ColoredConsoleOutput
+
+  def add_status(status, date, time, time_zone, msg)
+    message = format(status, msg)
+    if !message.nil?
+      puts message
+    end
+  end
+
+  def format(status, msg)
+    output = nil
+    if status
+        output = self.message_for_status(status, msg);
+        output = colorize(output, STATUS_COLORS[status]) if STATUS_COLORS[status]
+    end
+    output
+  end
+
+  def message_for_status(status, msg)
+    message = nil
+    case status
+      when /^default/
+        message = "    > #{msg}"
+      when /^start/
+        message = "\n> #{status.to_s.capitalize}: #{msg}"
+      when /^fail/
+        message = "X #{status.to_s.capitalize}: #{msg}"
+      when /^pass/
+        message = "#{status.to_s.capitalize}: #{msg}"
+      when /^warning/
+        message = "    ! #{status.to_s.capitalize}: #{msg}"
+      when /^issue/
+        message = "    ! #{status.to_s.capitalize}: #{msg}"
+    end
+
+    message
+  end
+end

data/lib/ui-auto-monkey/tuneup/test_runner/colored_console_output.rb

@@ -0,0 +1,27 @@
+class ColoredConsoleOutput < ConsoleOutput
+  COLORS = {
+    :red => 31,
+    :green => 32,
+    :yellow => 33,
+    :cyan => 36
+  }
+  
+  STATUS_COLORS = {
+    :start => :cyan,
+    :pass => :green,
+    :fail => :red,
+    :error => :red,
+    :warning => :yellow,
+    :issue => :yellow
+  }
+  
+  def format(status, date, time, time_zone, msg)
+    output = super
+    output = colorize(output, STATUS_COLORS[status]) if STATUS_COLORS[status]
+    output
+  end
+  
+  def colorize(text, color)
+    "\e[#{COLORS[color]}m#{text}\e[0m"
+  end
+end

data/lib/ui-auto-monkey/tuneup/test_runner/console_output.rb

@@ -0,0 +1,17 @@
+class ConsoleOutput
+  def add(line)
+    puts line
+  end
+  
+  def add_status(status, date, time, time_zone, msg)
+    puts "\n" if status == :start     # add a blank line before each test to visually group the output
+    puts format(status, date, time, time_zone, msg)
+  end
+  
+  def format(status, date, time, time_zone, msg)
+    "#{date} #{time} #{time_zone} #{status.to_s.capitalize}: #{msg}"
+  end
+  
+  def close
+  end
+end