guard-phpunit2 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f96efc03dc54e656212472d776a045c5ad5268e
-  data.tar.gz: ea337d8a51a8ba57c5b5d53101ff0b0fc45be8a6
+  metadata.gz: 81d31e2b034295210e186676f0192edf353604e4
+  data.tar.gz: 6b5f8d0593d418fc6ab4a3789fd6238ab18ac3c5
 SHA512:
-  metadata.gz: 3001101cc7c940c0bbd5a00ea95837c56c6b2f5e47c6b2cf20b91b5a6b5a3a6c86289b13cda46dc0e7ed86131763e4c735da3aebf158648dc9d276c7d9098b47
-  data.tar.gz: 481ecdda28ef0f20f106797adb443f5c0820de6d8bdfd756ab91734c3db4f8f84952a54d0b26c2132f2163e7cd1e27b508aa283c92c4d8fcaa7b23f4427df392
+  metadata.gz: cd75f1a8826faff16feebdd4f98bcb3e9434a31c7f691685ff59dcaa5640f01394c495ffb5b9546ffd8d65166effd1f5a030278d993a5279c3bdadcca0ae9fe9
+  data.tar.gz: dcf12bb176c68eb33dece74c8713b8688b1b77aa3273a808adfcb68d527e60ef0693c8bdd2728865994e16d333c5b1b9027b3f83623fbf276226f9dc6e635b8b

data/lib/guard/phpunit/formatters/PHPUnit-Progress/PHPUnit/Extensions/Progress/ResultPrinter.php

@@ -427,7 +427,7 @@ class PHPUnit_Extensions_Progress_ResultPrinter extends PHPUnit_TextUI_ResultPri
     static $deletedHeader = false;
 
     if ( ! $deletedHeader ) {
-      ob_clean();
+      ob_end_clean();
       $deletedHeader = true;
     }
 

data/lib/guard/phpunit2/logreader.rb

@@ -0,0 +1,114 @@
+require 'json'
+module Guard
+  class PHPUnit2
+    module LogReader
+      class << self
+
+        # Parses the output of --log-json
+        #
+        # @param [String] the file's contents
+        # @return [Hash] with the following properties:
+        #     :tests    => number of tests executed
+        #     :failures => number of tests failing because of an assertion
+        #                  not being met
+        #     :errors   => number of tests failing because of an error (like
+        #                  an Exception)
+        #     :pending  => number of tests skipped or incomplete
+        #     :duration => length of test with units
+        def parse_output(output)
+          log = JSON.parse(clean_output(output))
+
+          tests    = 0
+          passes   = 0
+          errors   = 0
+          failures = 0
+          skips    = 0
+          duration = 0
+
+          tests = log.first['tests'] unless log.empty?
+          log.each do |event|
+            passes   += 1 if passed_test?(event)
+            failures += 1 if failed_test?(event)
+            skips    += 1 if skipped_test?(event)
+            errors   += 1 if error_test?(event)
+
+            duration += event['time'] if event['time']
+          end
+
+          {
+            :tests    => tests,
+            :failures => failures,
+            :errors   => errors,
+            :pending  => skips,
+            :duration => calculate_duration(duration)
+          }
+        end
+
+        private
+
+          # PHPUnit writes out the JSON log as a series of JSON objects
+          # It is not serializable all as one object. We need to 
+          # turn it into an array and add commas between subsequent objects
+          #
+          # @param [String] json log output from PPHUnit
+          #  @return [String] properly-formed JSON string
+          def clean_output(output)
+            "[#{output.gsub(/^}{/, '},{')}]"
+          end
+
+          # Turns a float duration into a array of integer seconds and the 
+          # string 'seconds'
+          #
+          # This is the format expected by Guard
+          #
+          # @param [Float] duration in fractions of a second
+          # @return [Fixnum, String]
+          def calculate_duration(duration)
+            [duration.to_i, 'seconds']
+          end
+
+          # Determines if a PHPUnit event represents a skipped test
+          #
+          # Skipped and Incomplete tests are considered skipped
+          # @param [Hash] json object for a single PHPUnit event
+          # @return [Boolean]
+          def skipped_test?(event)
+            return false unless event['event'] == 'test' && event['status'] == 'error'
+
+            !!event['message'].match(/Skipped|Incomplete/i)
+          end
+
+          # Determine if a PHPUnit event represents a test that errored out
+          #
+          # Errored tests are those that failed because of an error, for example
+          # an exception. Assertion failures are not considered errors
+          #
+          # @param [Hash] json object for a single event
+          # @return [Boolean]
+          def error_test?(event)
+            return false unless event['event'] == 'test' && event['status'] == 'error'
+
+            !skipped_test?(event)
+          end
+
+          # Determine if a PHPUnit event represents a test that passed
+          #
+          # @param [Hash] json object for a single event
+          # @return [Boolean]
+          def passed_test?(event)
+            event['event'] == 'test' && event['status'] == 'pass'
+          end
+
+          # Determine if a PHPUnit event represents a test that failed because an
+          # assertion was not met.
+          #
+          # @param [Hash] JSON object for a single event
+          # @return [Boolean]
+          def failed_test?(event)
+            event['event'] == 'test' && event['status'] == 'fail'
+          end
+
+      end
+    end
+  end
+end

data/lib/guard/phpunit2/realtime_runner.rb

@@ -0,0 +1,54 @@
+require 'tmpdir'
+require 'fileutils'
+
+module Guard
+  class PHPUnit2
+
+    # The Guard::PHPUnit runner handles running the tests, displaying
+    # their output and notifying the user about the results.
+    #
+    class RealtimeRunner < Runner
+
+      def self.run(paths, options)
+        self.new.run(paths, options)
+      end
+
+        protected
+
+        def parse_output(log)
+          LogReader.parse_output(log)
+        end
+
+        # Generates the phpunit command for the tests paths.
+        #
+        # @param (see #run)
+        # @param (see #run)
+        # @see #run_tests
+        #
+        def phpunit_command(path, options, logfile)
+          super(path, options) do |cmd_parts|
+            cmd_parts << "--log-json #{logfile}"
+          end
+        end
+
+        # Executes a system command but does not return the output
+        #
+        # @param [String] command the command to be run
+        #
+        def execute_command(command)
+          system(command)
+        end
+
+        def execute_phpunit(tests_folder, options)
+          log_file = Tempfile.new "guard-phpunit2"
+          execute_command(phpunit_command(tests_folder, options, log_file.path))
+
+          log = log_file.read
+          log_file.close
+          log_file.unlink
+
+          log
+        end
+    end
+  end
+end

data/lib/guard/phpunit2/runner.rb

@@ -7,8 +7,11 @@ module Guard
     # The Guard::PHPUnit runner handles running the tests, displaying
     # their output and notifying the user about the results.
     #
-    module Runner
-      class << self
+    class Runner
+
+      def self.run(paths, options)
+        self.new.run(paths, options)
+      end
 
         # The exittcode phpunit returns when the tests contain failures
         #
@@ -38,7 +41,7 @@ module Guard
           run_tests(paths, options)
         end
 
-        private
+        protected
 
         # Checks that phpunit is installed on the user's
         # machine.
@@ -67,15 +70,13 @@ module Guard
 
           if paths.length == 1
             tests_path = paths.first
-            output = execute_command phpunit_command(tests_path, options)
+            output = execute_phpunit(tests_path, options)
           else
             create_tests_folder_for(paths) do |tests_folder|
-              output = execute_command phpunit_command(tests_folder, options)
+              output = execute_phpunit(tests_folder, options)
             end
           end
           
-          # print the output to the terminal
-          puts output
           
           # return false in case the system call fails with no status!
           return false if $?.nil?
@@ -108,10 +109,15 @@ module Guard
         # @param (see #run)
         #
         def notify_results(output, options)
-          results = Formatter.parse_output(output)
+          results = parse_output(output)
           Notifier.notify_results(results)
         end
 
+        # Parses the output into the hash Guard expects
+        def parse_output(output)
+          Formatter.parse_output(output)
+        end
+
         # Displays a notification about failing to run the tests
         #
         # @param (see #run)
@@ -184,9 +190,14 @@ module Guard
           cmd_parts << command
           cmd_parts << "--include-path #{formatter_path}"
           cmd_parts << "--printer PHPUnit_Extensions_Progress_ResultPrinter"
+
+          # Allow callers to inject some parts if needed
+          yield cmd_parts if block_given?
+
           cmd_parts << options[:cli] if options[:cli]
           cmd_parts << path
 
+
           cmd_parts.join(' ')
         end
 
@@ -198,7 +209,13 @@ module Guard
         def execute_command(command)
           %x{#{command}}
         end
-      end
+
+        def execute_phpunit(tests_folder, options)
+          output = execute_command phpunit_command(tests_folder, options)
+          puts output
+
+          output
+        end
     end
   end
 end

data/lib/guard/phpunit2/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module PHPUnit2Version
-    VERSION = '0.2.6'
+    VERSION = '0.2.7'
   end
 end

data/lib/guard/phpunit2.rb

@@ -13,6 +13,8 @@ module Guard
     autoload :Formatter, 'guard/phpunit2/formatter'
     autoload :Notifier,  'guard/phpunit2/notifier'
     autoload :Runner,    'guard/phpunit2/runner'
+    autoload :LogReader, 'guard/phpunit2/logreader'
+    autoload :RealtimeRunner, 'guard/phpunit2/realtime_runner'
 
     DEFAULT_OPTIONS = {
       :all_on_start   => true,
@@ -20,7 +22,8 @@ module Guard
       :keep_failed    => true,
       :cli            => nil,
       :tests_path     => Dir.pwd,
-      :notification   => true
+      :notification   => true,
+      :realtime       => false
     }
 
     # Initialize Guard::PHPUnit.
@@ -57,7 +60,7 @@ module Guard
     # @raise (see #start)
     #
     def run_all
-      success = Runner.run(options[:tests_path], options.merge(
+      success = runner.run(options[:tests_path], options.merge(
         :message => 'Running all tests'
       ))
 
@@ -72,7 +75,7 @@ module Guard
     #
     def run_on_changes(paths)
       paths = Inspector.clean(paths + @failed_paths)
-      success = Runner.run(paths, options)
+      success = runner.run(paths, options)
 
       update_failed_paths(success, paths)
       run_all_after_pass(success)
@@ -81,6 +84,10 @@ module Guard
 
     private
 
+    def runner
+      options[:realtime] ? RealtimeRunner : Runner
+    end
+
     # Adds or removes path to the failed_paths bassed
     # on the tests result.
     #

data/spec/fixtures/failureSampleTest.php

@@ -0,0 +1,11 @@
+<?php
+
+class Fail2 extends PHPUnit_Framework_TestCase {
+  public function testTrueIsTrue() {
+    $this->assertTrue(false);
+  }
+
+  public function testFalseIsFalse() {
+    $this->assertFalse(true);
+  }
+}

data/spec/fixtures/mixedSampleTest.php

@@ -0,0 +1,23 @@
+<?php
+
+class Mixed extends PHPUnit_Framework_TestCase {
+  public function testPass() {
+    $this->assertTrue(true);
+  }
+
+  public function testFail() {
+    $this->assertTrue(false);
+  }
+
+  public function testError() {
+    throw new Exception("Broked!");
+  }
+
+  public function testSkipped() {
+    $this->markTestSkipped();
+  }
+
+  public function testIncomplete() {
+    $this->markTestIncomplete();
+  }
+}

data/spec/fixtures/passingSampleTest.php

@@ -0,0 +1,11 @@
+<?php
+
+class Pass2 extends PHPUnit_Framework_TestCase {
+  public function testTrueIsTrue() {
+    $this->assertTrue(true);
+  }
+
+  public function testFalseIsFalse() {
+    $this->assertFalse(false);
+  }
+}

data/spec/fixtures/results/failing-json.txt

@@ -0,0 +1,53 @@
+{
+    "event": "suiteStart",
+    "suite": "Fail2",
+    "tests": 2
+}{
+    "event": "testStart",
+    "suite": "Fail2",
+    "test": "Fail2::testTrueIsTrue"
+}{
+    "event": "test",
+    "suite": "Fail2",
+    "test": "Fail2::testTrueIsTrue",
+    "status": "fail",
+    "time": 0.0018670558929443,
+    "trace": [
+        {
+            "file": "\/Users\/mburke\/personal\/guard-phpunit2\/spec\/fixtures\/fail2.php",
+            "line": 5,
+            "function": "assertTrue",
+            "class": "PHPUnit_Framework_Assert",
+            "type": "::",
+            "args": [
+                false
+            ]
+        }
+    ],
+    "message": "Failed asserting that false is true.",
+    "output": ""
+}{
+    "event": "testStart",
+    "suite": "Fail2",
+    "test": "Fail2::testFalseIsFalse"
+}{
+    "event": "test",
+    "suite": "Fail2",
+    "test": "Fail2::testFalseIsFalse",
+    "status": "fail",
+    "time": 0.00041508674621582,
+    "trace": [
+        {
+            "file": "\/Users\/mburke\/personal\/guard-phpunit2\/spec\/fixtures\/fail2.php",
+            "line": 9,
+            "function": "assertFalse",
+            "class": "PHPUnit_Framework_Assert",
+            "type": "::",
+            "args": [
+                true
+            ]
+        }
+    ],
+    "message": "Failed asserting that true is false.",
+    "output": ""
+}

data/spec/fixtures/results/mixed-json.txt

@@ -0,0 +1,110 @@
+{
+    "event": "suiteStart",
+    "suite": "Mixed",
+    "tests": 5
+}{
+    "event": "testStart",
+    "suite": "Mixed",
+    "test": "Mixed::testPass"
+}{
+    "event": "test",
+    "suite": "Mixed",
+    "test": "Mixed::testPass",
+    "status": "pass",
+    "time": 0.0012249946594238,
+    "trace": [
+
+    ],
+    "message": "",
+    "output": ""
+}{
+    "event": "testStart",
+    "suite": "Mixed",
+    "test": "Mixed::testFail"
+}{
+    "event": "test",
+    "suite": "Mixed",
+    "test": "Mixed::testFail",
+    "status": "fail",
+    "time": 0.00089907646179199,
+    "trace": [
+        {
+            "file": "\/Users\/mburke\/personal\/guard-phpunit2\/spec\/fixtures\/mixed.php",
+            "line": 9,
+            "function": "assertTrue",
+            "class": "PHPUnit_Framework_Assert",
+            "type": "::",
+            "args": [
+                false
+            ]
+        }
+    ],
+    "message": "Failed asserting that false is true.",
+    "output": ""
+}{
+    "event": "testStart",
+    "suite": "Mixed",
+    "test": "Mixed::testError"
+}{
+    "event": "test",
+    "suite": "Mixed",
+    "test": "Mixed::testError",
+    "status": "error",
+    "time": 0.0003211498260498,
+    "trace": [
+        {
+            "file": "\/Users\/mburke\/personal\/guard-phpunit2\/spec\/fixtures\/mixed.php",
+            "line": 13
+        }
+    ],
+    "message": "Broked!",
+    "output": ""
+}{
+    "event": "testStart",
+    "suite": "Mixed",
+    "test": "Mixed::testSkipped"
+}{
+    "event": "test",
+    "suite": "Mixed",
+    "test": "Mixed::testSkipped",
+    "status": "error",
+    "time": 0.0005791187286377,
+    "trace": [
+        {
+            "file": "\/Users\/mburke\/personal\/guard-phpunit2\/spec\/fixtures\/mixed.php",
+            "line": 17,
+            "function": "markTestSkipped",
+            "class": "PHPUnit_Framework_Assert",
+            "type": "::",
+            "args": [
+
+            ]
+        }
+    ],
+    "message": "Skipped Test: ",
+    "output": ""
+}{
+    "event": "testStart",
+    "suite": "Mixed",
+    "test": "Mixed::testIncomplete"
+}{
+    "event": "test",
+    "suite": "Mixed",
+    "test": "Mixed::testIncomplete",
+    "status": "error",
+    "time": 0.00052285194396973,
+    "trace": [
+        {
+            "file": "\/Users\/mburke\/personal\/guard-phpunit2\/spec\/fixtures\/mixed.php",
+            "line": 21,
+            "function": "markTestIncomplete",
+            "class": "PHPUnit_Framework_Assert",
+            "type": "::",
+            "args": [
+
+            ]
+        }
+    ],
+    "message": "Incomplete Test: ",
+    "output": ""
+}