guard-unity 0.1.0

data/guard-unity.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'guard/unity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'guard-unity'
+  spec.version       = Guard::UnityVersion::VERSION
+  spec.authors       = ['Thomas Muntaner']
+  spec.email         = ['thomas.muntaner@gmail.com']
+  spec.description   = %q{Guard gem for Unity3D Test Tools}
+  spec.summary       = %q{guard-unity automatically runs Unity Test Tools on file changes}
+  spec.homepage      = 'https://github.com/rubyrainbows/guard-unity-test'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'guard', '~> 2.0'
+  spec.add_dependency 'nokogiri', '~> 1.6'
+  spec.add_dependency 'formatador', '~> 0.2'
+  
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake', '~> 10.1'
+  spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'rspec-core', '~> 2.14'
+  spec.add_development_dependency 'rspec-mocks', '~> 2.14'
+end

data/lib/guard/unity.rb

@@ -0,0 +1,45 @@
+require 'guard'
+require 'guard/plugin'
+
+module Guard
+  class Unity < Plugin
+
+    require 'guard/unity/runner'
+    require 'guard/unity/options'
+
+    attr_accessor :runner, :options
+
+    def initialize(options = {})
+      super
+      @options  = Options.with_defaults(options)
+      @runner   = Runner.new(@options)
+    end
+
+    def start
+      _show_start_message
+      puts runner.run if _should_test_on_start?
+    end
+
+    def run_on_modifications(paths)
+      puts runner.run
+    end
+
+    def reload
+    end
+
+    def run_all
+      puts runner.run
+    end
+
+    private
+
+    def _show_start_message
+      ::Guard::UI::info 'Guard::Unity is running'
+    end
+
+    def _should_test_on_start?
+      options[:test_on_start]
+    end
+
+  end
+end

data/lib/guard/unity/notifier.rb

@@ -0,0 +1,24 @@
+module Guard
+  class Unity
+    class Notifier
+
+      require 'guard/unity/notifier/alert'
+      require 'guard/unity/notifier/cli'
+
+      TITLE = 'Unity Tests Results'
+
+      attr_accessor :alert, :cli
+
+      def initialize(options={})
+        @alert  = options[:alert] || Guard::Unity::Notifier::Alert.new
+        @cli    = options[:cli]   || Guard::Unity::Notifier::CLI.new
+      end
+
+      def notify(results)
+        alert.notify(results, TITLE)
+        cli.notify(results)
+      end
+
+    end
+  end
+end

data/lib/guard/unity/notifier/alert.rb

@@ -0,0 +1,35 @@
+module Guard
+  class Unity
+    class Notifier
+      class Alert
+
+        def notify(results, title)
+          image     = _image(results)
+          message   = _message(results)
+          ::Guard::Notifier::notify(message, {title: title, image: image})
+        end
+
+        private
+
+        def _image(results)
+          return :failed if results[:failures] > 0
+          return :failed if results[:errors] > 0
+          :success
+        end
+
+        def _message(results)
+          message = "#{results[:tests]} tests\n"
+          message << "#{results[:failures]} failures\n" if results[:failures]
+          message << "#{results[:errors]} errors\n" if results[:errors]
+          message << "#{results[:ignored]} ignored\n" if results[:ignored]
+          message << "#{results[:skipped]} skipped\n" if results[:skipped]
+          message << "#{results[:inconclusive]} inconclusive\n" if results[:inconclusive]
+          message << "#{results[:invalid]} invalid\n" if results[:invalid]
+          message << "#{results[:not_run]} not run\n" if results[:not_run]
+          message
+        end
+
+      end
+    end
+  end
+end

data/lib/guard/unity/notifier/cli.rb

@@ -0,0 +1,79 @@
+module Guard
+  class Unity
+    class Notifier
+      class CLI
+
+        require 'formatador'
+
+        attr_accessor :formatador
+
+        SEPARATOR = '-'*100
+
+        def initialize(options={})
+          @formatador = options[:formatador] || Formatador.new
+        end
+
+        def notify(results={})
+          cases   = results[:test_cases] || []
+          table   = []
+          errors  = []
+
+          cases.each do |test_case|
+            table   << _row(test_case)
+            errors  << _error(test_case) if test_case[:failed]
+          end
+          _display_results results
+          _display_table table
+          _display_errors errors
+        end
+
+        private
+
+        def _display_results(results)
+          table = [{
+            'Tests' => results[:tests],
+            'Failures' => results[:failures],
+            'Errors' => results[:errors],
+            'Ignored' => results[:ignored],
+            'Skipped' => results[:skipped],
+            'Inconclusive' => results[:inconclusive],
+            'Invalid' => results[:invalid],
+            'Not Run' => results[:not_run]
+          }]
+          formatador.display_table table, ['Tests', 'Failures', 'Errors', 'Ignored', 'Skipped', 'Inconclusive', 'Invalid', 'Not Run']
+          formatador.display_line
+        end
+
+        def _display_table(table)
+          formatador.display_table table
+        end
+
+        def _display_errors(errors)
+          formatador.display_line
+          formatador.display_line SEPARATOR
+          formatador.display_line "| [red]Failures[/]"
+          formatador.display_line SEPARATOR
+          count = 1
+          errors.each do |error|
+            formatador.display_line
+            formatador.display_line "#{count}: #{error[:name]}:\n"
+            formatador.display_line "[red]#{error[:message]}[/]\n" unless error[:message] == ""
+            formatador.display_line "[red]#{error[:stack]}[/]\n" unless error[:stack] == ""
+            formatador.display_line SEPARATOR
+            count = count + 1
+          end
+        end
+
+        def _row(test_case)
+          success = (test_case[:failed]) ? '[red]Failed[/]' : '[green]Success[/]'
+          {name: test_case[:name], success: success}
+        end
+
+        def _error(test_case)
+          {name: test_case[:name], message: test_case[:message], stack: test_case[:stack]}
+        end
+
+      end
+    end
+  end
+end

data/lib/guard/unity/options.rb

@@ -0,0 +1,26 @@
+module Guard
+  class Unity
+    module Options
+
+      DEFAULTS = {
+          test_on_start:  true,
+          project_path:   Dir.pwd,
+          unity:          '/Applications/Unity/Unity.app/Contents/MacOS/Unity',
+          results_path:   Dir.pwd + '/UnitTestResults.xml'
+      }
+
+      class << self
+        def with_defaults(options={})
+          opts = DEFAULTS.merge(options)
+          opts[:project_path] = clean_directory(opts[:project_path]) # needs to be formatted for cli
+          opts
+        end
+
+        def clean_directory(dir)
+          dir.gsub(' ', '\ ')
+        end
+      end
+
+    end
+  end
+end

data/lib/guard/unity/parser.rb

@@ -0,0 +1,64 @@
+module Guard
+  class Unity
+    class Parser
+
+      require 'nokogiri'
+
+      attr_accessor :options, :doc
+
+      def initialize(options={})
+        @options  = options
+        @doc      = nil
+      end
+
+      def parse()
+        {
+            tests:          _get('total'),
+            failures:       _get('failures'),
+            errors:         _get('errors'),
+            ignored:        _get('ignored'),
+            not_run:        _get('not-run'),
+            inconclusive:   _get('inconclusive'),
+            invalid:        _get('invalid'),
+            skipped:        _get('skipped'),
+            test_cases:     _testCases
+        }
+      end
+
+      private
+
+      def _get (find)
+        doc   ||= _getXMLFile
+        node = doc.at_xpath("/test-results/@" + find)
+        (node == nil) ? 0 : node.value.to_i
+      end
+
+      def _testCases()
+        doc   ||= _getXMLFile
+        nodes = doc.xpath("test-results/test-suite/results/test-case")
+        cases = []
+        
+        nodes.each do |node|
+          message = node.at_xpath('failure/message')     || node.at_xpath('reason/message')
+          stack   = node.at_xpath('failure/stack-trace') || node.at_xpath('reason/stack-trace')
+          cases << {
+            name:     node['name'],
+            failed:   (node['success'] == 'False') ? true                              : false,
+            message:  (message)                   ? message.text.gsub("\n",'').strip  : "",
+            stack:    (stack)                     ? stack.text.gsub("\n",'').strip    : ""
+          }
+        end
+
+        cases
+      end
+
+      def _getXMLFile()
+        f = File.open(options[:results_path])
+        doc = Nokogiri::XML(f)
+        f.close
+        doc
+      end
+
+    end
+  end
+end

data/lib/guard/unity/runner.rb

@@ -0,0 +1,45 @@
+module Guard
+  class Unity
+    class Runner
+
+      require 'guard/unity/parser'
+      require 'guard/unity/notifier'
+
+      attr_accessor :options, :parser, :notifier
+
+      def initialize(options = {})
+        @options  = options
+        @parser   = options[:parser]    || Guard::Unity::Parser.new(options)
+        @notifier = options[:notifier]  || Guard::Unity::Notifier.new
+      end
+
+      def run
+        _run
+      end
+
+      private
+
+      def _run
+        UI.info 'Guard::Unity - Starting Tests. Results will be displayed when finished testing.'
+        output = _execute_command _command
+        notifier.notify(parser.parse) if $?.success?
+        output
+      end
+
+      def _command
+        cmd = []
+
+        cmd << options[:unity]
+        cmd << '-projectPath ' + options[:project_path]
+        cmd << '-batchmode -executeMethod UnityTest.UnitTestView.RunAllTestsBatch'
+
+        cmd.join ' '
+      end
+
+      def _execute_command(command)
+        %x{#{command}}
+      end
+
+    end
+  end
+end

data/lib/guard/unity/templates/Guardfile

@@ -0,0 +1,3 @@
+guard :unity do
+  watch(%r{^.*\.cs$})
+end

data/lib/guard/unity/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  module UnityVersion
+    VERSION = '0.1.0'
+  end
+end

data/spec/fixtures/UnitTestResults.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--This file represents the results of running a test suite-->
+<test-results name="Unity Tests" total="21" errors="1" failures="2" not-run="2" inconclusive="4" ignored="1" skipped="1" invalid="0">
+  <environment />
+  <culture-info current-culture="" current-uiculture="" />
+  <test-suite name="Unit Tests" type="Assembly" executed="True" result="Failure" success="False" time="0.400">
+    <results>
+      <test-case name="test 1" executed="True" result="Success" success="True">
+      </test-case>
+      <test-case name="test 2" executed="True" result="Skipped" success="False">
+        <reason>
+          <message>
+Message
+          </message>
+          <stack-trace>
+foo
+          </stack-trace>
+        </reason>
+      </test-case>
+      <test-case name="test 3" executed="True" result="Failure" success="False">
+        <failure>
+          <message>
+Message
+          </message>
+          <stack-trace>
+foo
+          </stack-trace>
+        </failure>
+      </test-case>
+    </results>
+  </test-suite>
+</test-results>

data/spec/guard/unity-test/notifier/alert_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Guard::Unity::Notifier do
+
+  let (:results) {
+    {
+      tests: 100,
+      errors: 0,
+      failures: 0
+    }
+  }
+  let (:subject) { Guard::Unity::Notifier::Alert.new}
+
+  describe '#notify' do
+
+    it 'should give a success message' do
+      @results = results
+      ::Guard::Notifier::should_receive(:notify).with(message(@results), {image: :success, title: Guard::Unity::Notifier::TITLE})
+      subject.notify(@results, Guard::Unity::Notifier::TITLE)
+    end
+
+    it 'should give failed message' do
+      @results = results.merge(failures: 1)
+      ::Guard::Notifier::should_receive(:notify).with(message(@results), {image: :failed, title: Guard::Unity::Notifier::TITLE})
+      subject.notify(@results, Guard::Unity::Notifier::TITLE)
+    end
+
+    it 'should give error message' do
+      @results = results.merge(errors: 1)
+      ::Guard::Notifier::should_receive(:notify).with(message(@results), {image: :failed, title: Guard::Unity::Notifier::TITLE})
+      subject.notify(@results, Guard::Unity::Notifier::TITLE)
+    end
+
+  end
+
+  # taken from the class to make testing easier
+  def message(results)
+    message = "#{results[:tests]} tests\n"
+    message << "#{results[:failures]} failures\n"
+    message << "#{results[:errors]} errors\n"
+    message
+  end
+
+end