guard-rackunit 1.0.0

data/spec/lib/guard/rackunit/command_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Guard::RackUnit::Command do
+
+  let(:instance){described_class.new}
+
+  it 'returns failure result when it is unsuccessful' do
+    stub_failed_run do
+      expect(instance.execute(['paths'])).
+        to be_instance_of Guard::RackUnit::RunResult::Failure
+    end
+  end
+
+  it "returns a success result when it is successful" do
+    stub_successful_run do
+      expect(instance.execute(['paths'])).
+        to be_instance_of Guard::RackUnit::RunResult::Success
+    end
+  end
+
+  it "returns pending result if there are no are no paths" do
+    expect(instance.execute([])).to be_instance_of Guard::RackUnit::RunResult::Pending
+  end
+
+  it "runs the correct command" do
+    expect(Open3).to receive(:popen3).with("raco test paths1 paths2")
+    instance.execute(['paths1', 'paths2'])
+  end
+end

data/spec/lib/guard/rackunit/notifier_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Guard::RackUnit::Notifier do
+
+
+  let(:valid_options) do
+    {image: :pending, priority: 2}
+  end
+
+  it "notifies" do
+    message = "A message!"
+    expect(Guard::Notifier).to receive(:notify).with(message, {title: 'RackUnit Results'}.merge(valid_options))
+    instance = described_class.new(message)
+    instance.notify(valid_options)
+  end
+end

data/spec/lib/guard/rackunit/run_result_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+describe Guard::RackUnit::RunResult do
+
+  context 'success' do
+    it "returns a result" do
+      stub_successful_run do |out, err, _|
+        result = described_class.create(out, err)
+        expect(result).to be_instance_of Guard::RackUnit::RunResult::Success
+      end
+    end
+  end
+
+  context 'failure' do
+    it "returns a result" do
+      stub_failed_run do |out, err, _|
+        result = described_class.create(out,err)
+        expect(result).to be_instance_of Guard::RackUnit::RunResult::Failure
+      end
+    end
+
+    context "when there are successes too, but a runtime failure" do
+
+      it "returns a failure result" do
+        with_successful_stdout do |stdout|
+          with_failed_stderr('/samples/runtime_error') do |stderr|
+            stub_run(stdout, stderr)
+            result = described_class.create(stdout, stderr)
+            expect(result).to be_instance_of Guard::RackUnit::RunResult::Failure
+          end
+        end
+      end
+
+      it "prints both the stdout and stderr" do
+        with_successful_stdout do |stdout|
+          with_failed_stderr('/samples/runtime_error') do |stderr|
+            stub_run(stdout, stderr)
+            expected = stdout.read
+            stdout.rewind
+            expected << stderr.read
+            stderr.rewind
+            result = capture_stdout do
+              described_class.create(stdout,stderr)
+            end
+            expect(result).to eq expected
+          end
+        end
+      end
+    end
+  end
+
+  describe Guard::RackUnit::RunResult::Pending do
+    let(:instance){Guard::RackUnit::RunResult::Pending.new}
+    it 'returns an empty set of paths' do
+      expect(instance.paths).to be_instance_of Set
+      expect(instance.paths).to be_empty
+    end
+
+    it "issue notifications that do nothing" do
+      expect(Guard::Notifier).to_not receive(:notify)
+      instance.issue_notification
+    end
+
+    it "return false for successful" do
+      expect(instance.successful?).to be_false
+    end
+  end
+
+  describe Guard::RackUnit::RunResult::Success do
+    it "returns a set of empty paths" do
+      with_successful_stdout do |out|
+        result = Guard::RackUnit::RunResult::Success.new out
+        expect(result.paths).to be_instance_of Set
+        expect(result.paths).to be_empty
+      end
+    end
+
+    it "returns true for successful" do
+      with_successful_stdout do |out|
+        result = Guard::RackUnit::RunResult::Success.new out
+        expect(result.successful?).to be_true
+      end
+    end
+
+    it "issues the correct notification message" do
+      success =<<SUCCESS
+raco test: (submod "tests/vm-tests.rkt" test)
+8 tests passed
+SUCCESS
+      result = Guard::RackUnit::RunResult::Success.new StringIO.new(success)
+      expect(Guard::Notifier).to receive(:notify).with("8 tests passed", {title: 'RackUnit Results', image: :success, priority: -2})
+      result.issue_notification
+    end
+
+    it "issues a default notification message when there is no content in stdout" do
+      result = Guard::RackUnit::RunResult::Success.new StringIO.new('')
+      expect(Guard::Notifier).to receive(:notify).with("Success", {title: 'RackUnit Results', image: :success, priority: -2})
+      result.issue_notification
+    end
+
+
+    it "outputs the stdout" do
+      expected = 'expected'
+      result = 'not expected'
+      with_successful_stdout do |out|
+        expected = out.read # read it to build the expectation
+        out.rewind
+        result = capture_stdout do
+          Guard::RackUnit::RunResult::Success.new out
+        end
+      end
+      expect(result).to eq expected
+    end
+  end
+
+  describe Guard::RackUnit::RunResult::Failure do
+
+    it "returns a populated set of failed paths" do
+      with_failed_stderr do |err|
+        result = Guard::RackUnit::RunResult::Failure.new(err)
+        expect(result.paths).to be_instance_of Set
+        expect(result.paths).to_not be_empty
+      end
+    end
+
+    it "returns false for successful" do
+      with_failed_stderr do |err|
+        result = Guard::RackUnit::RunResult::Failure.new(err)
+        expect(result.successful?).to be_false
+      end
+    end
+
+
+    it "retrieves the correct failed paths" do
+      failure =<<FAIL
+--------------------
+parsing: """
+FAILURE
+message:    "No exception raised"
+name:       check-exn
+location:   (#<path:/home/test-user/racket-project/tests/sample-tests.rkt> 19 4 389 113)
+expression: (check-exn exn:fail:parsack? (lambda () (parsack-parse string)))
+params:     (#<procedure:exn:fail:parsack?> #<procedure:temp6>)
+
+Check failure
+--------------------
+1/101 test failures
+FAIL
+      result = Guard::RackUnit::RunResult::Failure.new(StringIO.new(failure))
+      expect(result.paths).to include '/home/test-user/racket-project/tests/sample-tests.rkt'
+    end
+
+    it "outputs the stderr" do
+      expected = 'expected'
+      result = 'not expected'
+      with_failed_stderr do |err|
+        expected = err.read # read it to build the expectation
+        err.rewind
+        result = capture_stdout do
+          Guard::RackUnit::RunResult::Failure.new(err)
+        end
+      end
+      expect(result).to eq expected
+    end
+
+    it "issues a notification with the correct message when it's simple" do
+      failure =<<FAIL
+--------------------
+parsing: """
+FAILURE
+message:    "No exception raised"
+name:       check-exn
+location:   (#<path:/home/test-user/racket-project/tests/sample-tests.rkt> 19 4 389 113)
+expression: (check-exn exn:fail:parsack? (lambda () (parsack-parse string)))
+params:     (#<procedure:exn:fail:parsack?> #<procedure:temp6>)
+
+Check failure
+--------------------
+1/101 test failures
+FAIL
+      result = Guard::RackUnit::RunResult::Failure.new(StringIO.new(failure))
+      expect(Guard::Notifier).to receive(:notify).with("1/101 test failures", {title: 'RackUnit Results', image: :failed, priority: 2})
+      result.issue_notification
+    end
+
+    it "issues a notification with default message if stderr is empty" do
+      result = Guard::RackUnit::RunResult::Failure.new(StringIO.new(''))
+      expect(Guard::Notifier).to receive(:notify).with("Failed", {title: 'RackUnit Results', image: :failed, priority: 2})
+      result.issue_notification
+    end
+
+    it "issues a notification with a message when hit hits an exception" do
+      stdout =<<FAILED
+--------------------
+creates an assembly s-expression
+ERROR
+this is an error
+  context...:
+   /home/calbers/src/mine/scheme-assembler/evaluator.rkt:50:0: parsed-sexp->sexp-assembly
+   /home/calbers/src/mine/scheme-assembler/tests/evaluator-tests.rkt: [running body]
+   /usr/share/racket/collects/compiler/commands/test.rkt:29:10: for-loop
+   f8
+   /usr/share/racket/collects/compiler/commands/test.rkt: [running body]
+   /usr/share/racket/collects/raco/raco.rkt: [running body]
+   /usr/share/racket/collects/raco/main.rkt: [running body]
+
+--------------------
+FAILED
+      result = Guard::RackUnit::RunResult::Failure.new(StringIO.new(stdout))
+      expect(Guard::Notifier).to receive(:notify).
+        with("ERROR: /home/calbers/src/mine/scheme-assembler/evaluator.rkt:50:0: parsed-sexp->sexp-assembly",
+             {title: 'RackUnit Results', image: :failed, priority: 2})
+      result.issue_notification
+    end
+  end
+end

data/spec/lib/guard/rackunit/runner_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Guard::RackUnit::Runner do
+
+  let(:instance){described_class.new}
+  let(:paths){['some_paths/']}
+
+  context "success" do
+    it "runs test with the given paths and returns a success result " do
+      stub_successful_run(paths) do
+        result = instance.run paths
+        expect(result).to be_instance_of Guard::RackUnit::RunResult::Success
+      end
+    end
+  end
+
+  context "failure" do
+    it "runs test with the given paths and returns a failure result " do
+      stub_failed_run(paths) do
+        result = instance.run(paths)
+        expect(result).to be_instance_of Guard::RackUnit::RunResult::Failure
+      end
+    end
+  end
+
+  it 'returns pending result when no paths have been supplied' do
+    expect(instance.run([])).to be_instance_of Guard::RackUnit::RunResult::Pending
+  end
+
+
+  it "does not run duplicates" do
+    paths_with_dups = ['/home/test-user/tests.rkt', '/home/test-user/tests.rkt']
+    expect(Open3).to receive(:popen3).with('raco test /home/test-user/tests.rkt')
+    stub_successful_run(paths_with_dups) do
+      instance.run(paths_with_dups)
+    end
+  end
+
+  context "with other failed tasks" do
+    let(:failed_output) do
+      <<FAILED
+--------------------
+parsing: """
+FAILURE
+message:    "No exception raised"
+name:       check-exn
+location:   (#<path:/home/test-user/tests.rkt> 19 4 389 113)
+expression: (check-exn exn:fail:parsack? (lambda () (parsack-parse string)))
+params:     (#<procedure:exn:fail:parsack?> #<procedure:temp6>)
+
+Check failure
+--------------------
+1/101 test failures
+FAILED
+    end
+
+    it "run all previous failed paths" do
+      stub_failed_run_err(StringIO.new(failed_output), '/home/test-user/tests.rkt') do
+        catch(:task_has_failed) do
+          instance.run(['/home/test-user/tests.rkt'])
+        end
+      end
+      expect(Open3).to receive(:popen3).with('raco test /home/test-user/tests.rkt /paths/test.rkt /paths/another.rkt')
+      stub_successful_run(['/home/test-user/tests.rkt','/paths/test.rkt', '/paths/another.rkt']) do
+        instance.run(['/paths/test.rkt', '/paths/another.rkt'])
+      end
+    end
+
+    it "does not run duplicates when new tests are added to the previous failed" do
+      first_path = '/home/test-user/tests.rkt'
+      stub_failed_run_err(StringIO.new(failed_output), '/home/test-user/tests.rkt') do
+        catch(:task_has_failed) do
+          instance.run(['/home/test-user/tests.rkt'])
+        end
+      end
+      new_path = '/new/path.rkt'
+      new_paths = [first_path, first_path, new_path]
+      expect(Open3).to receive(:popen3).with("raco test #{first_path} #{new_path}")
+      stub_successful_run(new_paths) do
+        instance.run(new_paths)
+      end
+    end
+  end
+end

data/spec/lib/guard/rackunit_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Guard::RackUnit do
+  it "is a plugin" do
+    expect(described_class.new).to be_kind_of Guard::Plugin
+  end
+
+  describe "start" do
+    context "when all_on_start is enabled" do
+      let(:test_paths){['/tests']}
+      let(:instance){described_class.new({all_on_start: true, test_paths: test_paths})}
+
+      it "returns a success result on success" do
+        stub_successful_run(test_paths) do
+          result = instance.start
+          expect(result).to be_instance_of Guard::RackUnit::RunResult::Success
+        end
+      end
+
+      it "throw a :task_has_failed symbol when it has a test directory" do
+        stub_failed_run(test_paths) do
+          expect{instance.start}.to throw_symbol :task_has_failed
+        end
+      end
+
+      it "returns a failure result on failure when it has a test directory" do
+        result = described_class.new({all_on_start: true}).start
+        expect(result).to be_instance_of Guard::RackUnit::RunResult::Pending
+      end
+
+      it "updates the UI" do
+        expect(::Guard::UI).to receive(:info).at_least(:once).ordered.with('Guard::RackUnit is running')
+        expect(::Guard::UI).to receive(:info).at_least(:once).ordered.with('Resetting', reset: true)
+        catch(:task_has_failed){instance.start}
+      end
+    end
+
+    context "when all_on_start is not enabled" do
+      let(:instance){described_class.new}
+
+      it "updates the UI telling the user it has started" do
+        expect(::Guard::UI).to receive(:info).with('Guard::RackUnit is running')
+        instance.start
+      end
+
+      it "updates the UI telling the user it has started" do
+        expect(instance.start).to be_instance_of Guard::RackUnit::RunResult::Pending
+      end
+    end
+  end
+
+  describe "run_all" do
+
+    let(:test_paths) { ['tests/'] }
+    let(:instance){described_class.new({test_paths: test_paths})}
+
+    context "success" do
+      it "returns a success result on success" do
+        stub_successful_run(test_paths) do
+          expect(instance.run_all).to be_instance_of Guard::RackUnit::RunResult::Success
+        end
+      end
+
+      it "issues a notification" do
+        expect(Guard::Notifier).to receive(:notify).with("8 tests passed", {title: 'RackUnit Results', image: :success, priority: -2})
+        stub_successful_run(test_paths) do
+          instance.run_all
+        end
+      end
+    end
+
+    context "failure" do
+      it "returns a failure result on failure" do
+        stub_failed_run(test_paths) do
+          expect{instance.run_all}.to throw_symbol :task_has_failed
+        end
+      end
+
+      it "issues a notification" do
+        stub_failed_run(test_paths) do
+          expect(Guard::Notifier).to receive(:notify).with("1/101 test failures", {title: 'RackUnit Results', image: :failed, priority: 2})
+          catch(:task_has_failed){instance.run_all }
+        end
+      end
+    end
+
+    it "issues a notification" do
+      expect(Guard::UI).to receive(:info).with("Resetting", reset: true)
+      stub_successful_run(test_paths) do
+        instance.run_all
+      end
+    end
+  end
+
+  describe "running on modifications" do
+    let(:instance){described_class.new}
+
+    context "with no supplied paths" do
+      it "does not issue a notification when the path is empty" do
+        expect(Guard::UI).to_not receive(:info)
+        instance.run_on_modifications([])
+      end
+    end
+
+    context "with paths" do
+
+      let(:test_paths){['/paths/test.rkt', '/paths/another.rkt']}
+
+      it "issues a notification" do
+        expect(Guard::UI).to receive(:info).with("Running: #{test_paths.join(', ')}", reset: true)
+        stub_successful_run(test_paths) do
+          instance.run_on_modifications(test_paths)
+        end
+      end
+
+      it "returns a success result on success" do
+        stub_successful_run(test_paths) do
+          result = instance.run_on_modifications(test_paths)
+          expect(result).to be_instance_of Guard::RackUnit::RunResult::Success
+        end
+      end
+
+      it "throws a :task_has_failed symbol on failure" do
+        stub_failed_run(test_paths) do
+          expect do
+            result = instance.run_on_modifications(['/paths/test.rkt', '/paths/another.rkt'])
+            expect(result).to be_instance_of Guard::RackUnit::RunResult::Failure
+          end
+        end
+      end
+    end
+  end
+end