guard-teaspoon 0.0.3

data/spec/features/guard_teaspoon_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+feature "Full setup of an app that can run guard-teaspoon", aruba: true do
+
+  before do
+    unset_bundler_env_vars
+    run_simple("bundle exec rails new testapp --skip-bundle")
+    cd("testapp")
+    append_to_file("Gemfile", "gem 'teaspoon'" + "\n")
+    append_to_file("Gemfile", "gem 'guard-teaspoon', path: '#{File.expand_path('../../../', __FILE__)}'" + "\n")
+    append_to_file("Gemfile", "gem 'rb-fsevent'" + "\n")
+    run_simple("bundle install --local")
+  end
+
+  scenario "installing Teaspoon and generating the Guardfile" do
+    run_simple("bundle exec rails g teaspoon:install")
+    check_file_presence(["config/initializers/teaspoon.rb"], true)
+    check_file_presence(["spec/teaspoon_env.rb"], true)
+    check_file_presence(["spec/javascripts/spec_helper.js"], true)
+
+    run_simple("bundle exec guard init")
+    assert_partial_output("INFO - teaspoon guard added to Guardfile, feel free to edit it", all_output)
+    check_file_presence(["Guardfile"], true)
+  end
+
+  scenario "allows running guard and will notice file changes" do
+    pending if ENV['SKIP_SOME_FEATURES']
+    run_simple("bundle exec rails g teaspoon:install")
+    run_simple("bundle exec guard init")
+
+    write_file("app/assets/javascripts/test.js", "foo = 'something'")
+    write_file "spec/javascripts/test_spec.js", <<-JAVASCRIPT
+      // require application
+      describe("Application", function() {
+        it("tests", function() { expect(true).toBe(true) })
+      });
+    JAVASCRIPT
+
+    run_interactive("bundle exec guard start")
+    sleep 5
+    write_file("app/assets/javascripts/test.js", "foo = 'something else'")
+    sleep 20
+    type("exit")
+
+    # the first time it runs
+    assert_partial_output("Teaspoon running default suite at", all_output)
+
+    # when the file has been modified
+    assert_partial_output("/teaspoon/default/?file[]=", all_output)
+    assert_partial_output("tmp/aruba/testapp/spec/javascripts/test_spec.js", all_output)
+  end
+end

data/spec/guard/teaspoon/resolver_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "teaspoon/console"
+
+describe Guard::Teaspoon::Resolver do
+
+  describe "#initialize" do
+
+    it "assigns options" do
+      options = {foo: "bar"}
+      subject = Guard::Teaspoon::Resolver.new(options)
+      expect(subject.instance_variable_get(:@options)).to be(options)
+    end
+
+  end
+
+  describe "#resolve" do
+
+    it "calls through to Teaspoon::Suite to resolve paths and assigns them to suites" do
+      Teaspoon::Suite.should_receive(:resolve_spec_for).with("foo").and_return(suite: "default", path: "foo")
+      Teaspoon::Suite.should_receive(:resolve_spec_for).with("bar").and_return(suite: "default", path: "bar")
+      Teaspoon::Suite.should_receive(:resolve_spec_for).with("baz").and_return(suite: "other", path: "baz")
+      subject.resolve(["foo", "bar", "baz"])
+      expect(subject.suites).to eq({"default" => ["foo", "bar"], "other" => ["baz"]})
+    end
+
+  end
+
+end

data/spec/guard/teaspoon/runner_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+require "teaspoon/console"
+
+describe Guard::Teaspoon::Runner do
+
+  before do
+    Teaspoon::Console.stub(:new)
+  end
+
+  describe "#initialize" do
+
+    it "assigns options" do
+      options = {foo: "bar"}
+      subject = Guard::Teaspoon::Runner.new(options)
+      expect(subject.instance_variable_get(:@options)).to be(options)
+    end
+
+    it "aborts with a message on Teaspoon::EnvironmentNotFound" do
+      Teaspoon::Console.should_receive(:new).and_raise(Teaspoon::EnvironmentNotFound)
+      Guard::Teaspoon::Runner.any_instance.should_receive(:abort)
+      STDOUT.should_receive(:print).with("Unable to load Teaspoon environment in {spec/teaspoon_env.rb, test/teaspoon_env.rb, teaspoon_env.rb}.\n")
+      STDOUT.should_receive(:print).with("Consider using -r path/to/teaspoon_env\n")
+      Guard::Teaspoon::Runner.new
+    end
+
+  end
+
+  describe "#run_all" do
+
+    let(:console) { mock(execute: nil) }
+
+    before do
+      subject.console = console
+      subject.instance_variable_set(:@options, {foo: "bar"})
+    end
+
+    it "calls execute on console" do
+      console.should_receive(:execute).with({foo: "bar", baz: "teaspoon"})
+      subject.run_all(baz: "teaspoon")
+    end
+
+  end
+
+  describe "#run" do
+
+    let(:console) { mock(execute: nil) }
+
+    before do
+      subject.console = console
+      subject.instance_variable_set(:@options, {foo: "bar"})
+    end
+
+    it "calls execute on console" do
+      files = ["file1", "file2"]
+      console.should_receive(:execute).with({foo: "bar", baz: "teaspoon"}, files)
+      subject.run(files, baz: "teaspoon")
+    end
+
+    it "does nothing if there's no paths" do
+      console.should_not_receive(:execute)
+      subject.run([], baz: "teaspoon")
+    end
+
+  end
+
+end

data/spec/guard/teaspoon_spec.rb

@@ -0,0 +1,113 @@
+require "spec_helper"
+require "guard/teaspoon"
+
+describe Guard::Teaspoon do
+
+  subject { Guard::Teaspoon.new([], {}) }
+
+  before do
+    Guard::Teaspoon::Resolver.stub(:new)
+    Guard::Teaspoon::Runner.stub(:new)
+  end
+
+  describe "#initialize" do
+
+    it "merges the options" do
+      options = {focus_on_failed: true, other_option: "foo"}
+      subject = Guard::Teaspoon.new([], options)
+      expect(subject.instance_variable_get(:@options)).to eql({
+        focus_on_failed: true,
+        all_after_pass:  true,
+        all_on_start:    true,
+        keep_failed:     true,
+        formatters:      "clean",
+        run_all:         {},
+        run_on_changes:  {},
+        other_option:    "foo"
+      })
+    end
+
+    it "calls reload" do
+      Guard::Teaspoon.any_instance.should_receive(:reload)
+      Guard::Teaspoon.new
+    end
+
+    it "creates a resolver, and a runner" do
+      Guard::Teaspoon::Resolver.should_receive(:new)
+      Guard::Teaspoon::Runner.should_receive(:new)
+      Guard::Teaspoon.new
+    end
+
+  end
+
+  describe "#start" do
+
+    before do
+      subject.stub(:run_all)
+      Guard::UI.stub(:info)
+    end
+
+    it "logs that we're starting" do
+      Guard::UI.should_receive(:info).with("Guard::Teaspoon is running")
+      subject.start
+    end
+
+    it "calls #run_all if we're supposed to" do
+      subject.should_receive(:run_all)
+      subject.start
+    end
+
+    it "doesn't run all if we're not supposed to" do
+      subject.instance_variable_set(:@options, {all_on_start: false})
+      subject.should_not_receive(:run_all)
+      subject.start
+    end
+
+  end
+
+  describe "#run_all" do
+
+    let(:runner) { mock(run_all: nil) }
+
+    before do
+      subject.runner = runner
+    end
+
+    it "calls #run_all on the runner" do
+      runner.should_receive(:run_all).and_return(true)
+      subject.run_all
+    end
+
+    it "resets failed_paths if all tests passed" do
+      subject.failed_paths = ["1", "2"]
+      runner.should_receive(:run_all).and_return(true)
+      subject.run_all
+      expect(subject.failed_paths).to eq([])
+    end
+
+    it "throws :task_has_failed if the tests didn't pass" do
+      runner.should_receive(:run_all).and_return(false)
+      expect { subject.run_all }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "#reload" do
+
+    it "resets last_failed, and failed_paths" do
+      subject.last_failed = true
+      subject.failed_paths = ["1", "2"]
+      subject.reload
+      expect(subject.last_failed).to eq(false)
+      expect(subject.failed_paths).to eq([])
+    end
+
+  end
+
+  describe "#run_on_changes" do
+
+    it "needs to be written out fully and tested"
+
+  end
+
+end