teaspoon 0.7.9 → 0.8.0

data/spec/teaspoon/server_spec.rb

@@ -6,14 +6,12 @@ describe Teaspoon::Server do
 
   subject { Teaspoon::Server.new }
 
-  before do
-    Teaspoon::Server.any_instance.stub(find_available_port: 31337)
-    STDOUT.stub(:print)
-  end
-
   describe "#start" do
 
+    let(:server) { double(start: nil) }
+
     before do
+      Thread.stub(:new) { |&b| @block = b; "_thread_" }
       subject.stub(wait_until_started: nil)
     end
 
@@ -23,10 +21,6 @@ describe Teaspoon::Server do
     end
 
     it "starts a rack server" do
-      STDOUT.should_receive(:print).with("Starting the Teaspoon server...\n")
-      server = double(start: nil)
-      Thread.stub(:new) { |&b| @block = b }
-
       Rack::Server.should_receive(:new).and_return(server)
       server.should_receive(:start)
 
@@ -34,58 +28,49 @@ describe Teaspoon::Server do
       @block.call
     end
 
-    it "rescues errors" do
-      Thread.should_receive(:new).and_raise("OMG!")
-      expect{ subject.start }.to raise_error("Cannot start server: OMG!")
+    it "waits until the server is started" do
+      Thread.should_receive(:new)
+      subject.should_receive(:wait_until_started).with("_thread_")
+      subject.start
     end
 
-    describe "when the server configuration option is set" do
-      before do
-        Teaspoon.configuration.server = :cgi
-      end
-
-      after do
-        Teaspoon.configuration.server = nil
-      end
-
-      it "creates a Rack::Server with the correct setting" do
-        Thread.stub(:new) { |&b| @block = b }
-
-        Rack::Server.should_receive(:new) do |options|
-          options.should include(:server => :cgi)
-        end.and_return(double(start: nil))
-
-        subject.start
-        @block.call
-      end
+    it "rescues errors" do
+      Thread.should_receive(:new).and_raise("OMG!")
+      expect { subject.start }.to raise_error("Cannot start server: OMG!")
     end
-  end
 
-  describe "#wait_until_started" do
+    it "creates a Rack::Server with the correct setting" do
+      expected_opts = {
+        app: Rails.application,
+        Port: subject.port,
+        environment: "test",
+        AccessLog: [],
+        Logger: Rails.logger,
+        server: Teaspoon.configuration.server
+      }
+      Rack::Server.should_receive(:new).with(expected_opts).and_return(server)
 
-    it "uses Timeout" do
-      Timeout.should_receive(:timeout).with(20)
-      subject.wait_until_started
+      subject.start
+      @block.call
     end
 
-    it "handles Timeout::Error" do
-      Timeout.should_receive(:timeout).and_raise(Timeout::Error)
-      expect{ subject.wait_until_started }.to raise_error("Server failed to start. You may need to increase the timeout configuration.")
+    it "raises a ServerException if the timeout fails" do
+      subject.should_receive(:wait_until_started).and_call_original
+      Timeout.should_receive(:timeout).with(Teaspoon.configuration.server_timeout.to_i).and_raise(Timeout::Error)
+      expect{ subject.start }.to raise_error Teaspoon::ServerException
     end
 
   end
 
   describe "#responsive?" do
 
-    before do
-      subject.instance_variable_set(:@thread, double(join: nil))
-    end
+    let(:socket) { double(close: nil) }
 
     it "checks a local port to see if a server is running" do
-      socket = double(close: nil)
+      subject.port = 31337
       TCPSocket.should_receive(:new).with("127.0.0.1", 31337).and_return(socket)
       socket.should_receive(:close)
-      subject.wait_until_started
+      subject.responsive?
     end
 
   end
@@ -93,23 +78,20 @@ describe Teaspoon::Server do
   describe "#url" do
 
     it "returns a url for the server that includes the port" do
+      subject.port = 31337
       expect(subject.url).to eq("http://127.0.0.1:31337")
     end
 
   end
 
-  describe "#port" do
+  describe "integration" do
 
-    it "returns the port the server is on" do
-      expect(subject.port).to eq(31337)
+    before do
+      Teaspoon.configuration.stub(:suite_configs).and_return("foo" => {block: proc{}})
+      Teaspoon.configuration.stub(:suppress_log).and_return(true)
     end
 
-  end
-
-  describe "integration" do
-
     it "really starts a server" do
-      Teaspoon.configuration.stub(:suites).and_return "foo" => proc{ |suite| }
       subject.start
       response = Net::HTTP.get_response(URI.parse("#{subject.url}/teaspoon/foo"))
       expect(response.code).to eq("200")

data/spec/teaspoon/suite_spec.rb

@@ -3,18 +3,22 @@ require "spec_helper"
 describe Teaspoon::Suite do
 
   before do
-    Teaspoon.configuration.stub(:suites).and_return "default" => proc{}
+    Teaspoon.configuration.stub(:suite_configs).and_return("default" => {block: proc{}})
   end
 
   describe ".all" do
 
+    before do
+      Teaspoon::Suite.instance_variable_set(:@all, nil)
+      Teaspoon.configuration.stub(:suite_configs).and_return("default" => {block: proc{}}, "foo" => {block: proc{}})
+    end
+
     it "returns all the suites" do
-      Teaspoon.configuration.stub(:suites).and_return "default" => proc{}, "foo" => proc{}
-      results = Teaspoon::Suite.all
-      expect(results.first).to be_a(Teaspoon::Suite)
-      expect(results.length).to be(2)
-      expect(results.first.name).to eq("default")
-      expect(results.last.name).to eq("foo")
+      result = Teaspoon::Suite.all
+      expect(result.first).to be_a(Teaspoon::Suite)
+      expect(result.length).to be(2)
+      expect(result.first.name).to eq("default")
+      expect(result.last.name).to eq("foo")
     end
 
   end
@@ -22,16 +26,16 @@ describe Teaspoon::Suite do
   describe ".resolve_spec_for" do
 
     it "return a hash with the suite name and path" do
-      results = Teaspoon::Suite.resolve_spec_for("fixture_spec")
-      expect(results[:suite]).to eq("default")
-      expect(results[:path].first).to include("base/fixture_spec.")
+      result = Teaspoon::Suite.resolve_spec_for("fixture_spec")
+      expect(result[:suite]).to eq("default")
+      expect(result[:path].first).to include("base/fixture_spec.")
     end
 
     it "returns a hash with the suite name and an array of paths if a directory is given" do
-      results = Teaspoon::Suite.resolve_spec_for("base")
-      expect(results[:suite]).to eq("default")
+      result = Teaspoon::Suite.resolve_spec_for("base")
+      expect(result[:suite]).to eq("default")
       dirs = ["base/fixture_spec.", "base/runner_spec.", "base/teaspoon_spec"]
-      expect(dirs.all? { |path| results[:path].grep(/#{path}/)[0] }).to be_true
+      expect(dirs.all? { |path| result[:path].grep(/#{path}/)[0] }).to be_true
     end
 
   end
@@ -39,151 +43,61 @@ describe Teaspoon::Suite do
   describe "#initialize" do
 
     it "uses default suite configuration" do
+      expect(subject.name).to eq("default")
       expect(subject.config.helper).to eq("spec_helper")
     end
 
-    it "accepts a suite configuration name" do
-      Teaspoon.configuration.should_receive(:suites).and_return "test" => proc{ |s| s.helper = "helper_file" }
-      subject = Teaspoon::Suite.new({suite: :test})
+    it "accepts a suite in the options" do
+      Teaspoon.configuration.should_receive(:suite_configs).and_return("test" => {block: proc{ |s| s.helper = "helper_file" }})
+      subject = Teaspoon::Suite.new(suite: :test)
+      expect(subject.name).to eql("test")
       expect(subject.config.helper).to eq("helper_file")
     end
 
   end
 
-  describe "#name" do
-
-    it "returns the name of the suite" do
-      expect(subject.name).to eql("default")
-    end
-
-  end
-
-  describe "#stylesheets" do
-
-    it "returns an array of stylesheets" do
-      expect(subject.stylesheets).to include("teaspoon")
-    end
-
-  end
-
-  describe "#helper" do
-
-    it "returns the javascript helper" do
-      expect(subject.helper).to eq("spec_helper")
-    end
-
-  end
-
-  describe "#javascripts" do
-
-    it "returns an array of all javascripts" do
-      results = subject.javascripts
-      expect(results).to include("teaspoon-jasmine")
-      expect(results).to include("spec_helper")
-    end
-
-  end
-
-  describe "#core_javascripts" do
-
-    it "returns an array of core javascripts" do
-      results = subject.core_javascripts
-      expect(results).to eql(["teaspoon-jasmine"])
-    end
-
-  end
-
-  describe "#spec_javascripts" do
-
-    it "returns an array of spec javascripts" do
-      results = subject.spec_javascripts
-      expect(results).to include("spec_helper")
-      expect(results).to include("teaspoon/base/reporters/console_spec.js")
-    end
-
-    it "returns the file requested if one was passed" do
-      subject = Teaspoon::Suite.new({file: "spec/javascripts/foo.js"})
-      results = subject.spec_javascripts
-      expect(results).to eql(["spec_helper", "foo.js"])
-    end
-
-  end
-
-  describe "#spec_javascripts_for_require" do
-
-    let(:files) { ['/path/file1.js.coffee', 'path/file2.coffee', 'file3.coffee.erb', 'file4.js.erb' ] }
-
-    before do
-      subject.should_receive(:specs).and_return(files)
-    end
-
-    it 'returns an array of spec javascripts without .js and Teaspoon prefix' do
-      expect( subject.spec_javascripts_for_require ).to eq(['/path/file1', 'path/file2', 'file3', 'file4'])
-    end
-
-  end
-
-  describe "#suites" do
-
-    it "returns as hash with expected results" do
-      expect(subject.suites).to eql({all: ["default"], active: "default"})
-    end
-
-  end
-
   describe "#spec_files" do
 
     it "returns an array of hashes with the filename and the asset name" do
       file = Teaspoon::Engine.root.join("spec/javascripts/teaspoon/base/reporters/console_spec.js").to_s
       subject.should_receive(:glob).and_return([file])
-      expect(subject.spec_files[0]).to eql({path: file, name: "teaspoon/base/reporters/console_spec.js"})
+      expect(subject.spec_files[0]).to eql(path: file, name: "teaspoon/base/reporters/console_spec.js")
     end
 
-  end
-
-  describe "#link" do
-
-    it "returns a link for the specific suite" do
-      expect(subject.link).to eql("/teaspoon/default")
-    end
-
-    it "returns a link with added params" do
-      expect(subject.link(file: ["file1", "file2"], grep: "foo")).to eql("/teaspoon/default/?file%5B%5D=file1&file%5B%5D=file2&grep=foo")
-    end
-
-    it "returns a link prefixed by app context if given" do
-      Teaspoon.configuration.stub(:context).and_return('/foo')
-      expect(subject.link).to eql("/foo/teaspoon/default")
+    it "raises an exception if the file isn't servable (in an asset path)" do
+      subject.should_receive(:glob).and_return(["/foo"])
+      expect { subject.spec_files[0] }.to raise_error Teaspoon::AssetNotServable
     end
 
   end
 
-  describe "#instrument_file?" do
-
-    before do
-      Teaspoon.configuration.stub(:suites).and_return "default" => proc{ |s| s.no_coverage = ["file_", /some\/other/] }
-      subject.stub(:include_spec?).and_return(false)
-    end
+  describe "#spec_assets" do
 
-    it "returns false if the file is a spec" do
-      subject.should_receive(:include_spec?).with("_some/file_").and_return(true)
-      expect(subject.instrument_file?("_some/file_")).to be(false)
+    it "returns an array of assets" do
+      result = subject.spec_assets
+      expect(result).to include("spec_helper.js?body=1")
+      expect(result).to include("teaspoon/base/reporters/console_spec.js?body=1")
     end
 
-    it "returns false if the file should be ignored" do
-      expect(subject.instrument_file?("_some/file_")).to be(false)
-      expect(subject.instrument_file?("_some/other_file_")).to be(false)
+    it "returns just a file if one was requests" do
+      subject.instance_variable_set(:@options, file: "spec/javascripts/foo.js")
+      result = subject.spec_assets(false)
+      expect(result).to eql(["foo.js"])
     end
 
-    it "returns true if it's a valid file that should get instrumented" do
-      expect(subject.instrument_file?("_some/file_for_instrumenting_")).to be(true)
+    it "returns the asset tree (all dependencies resolved) if we want coverage" do
+      subject.instance_variable_set(:@options, coverage: true)
+      result = subject.spec_assets(true)
+      expect(result).to include("support/json2.js?body=1")
+      expect(result).to include("spec_helper.js?body=1")
+      expect(result).to include("drivers/phantomjs/runner.js?body=1&instrument=1")
     end
 
   end
 
   describe "#include_spec?" do
 
-    it "returns true if the spec was found" do
+    it "returns true if the spec was found in the suite" do
       files = subject.send(:glob)
       expect(subject.include_spec?(files.first)).to eq(true)
     end
@@ -207,64 +121,4 @@ describe Teaspoon::Suite do
 
   end
 
-  describe "#specs" do
-
-    it "converts file names that are in registered asset paths into usable asset urls" do
-      Teaspoon.configuration.should_receive(:suites).and_return "default" => proc{ |s| s.matcher = Teaspoon::Engine.root.join("spec/javascripts/support/*.*") }
-      expect(subject.send(:specs)).to include("support/support.js")
-    end
-
-    it "raises an AssetNotServable exception if the file can't be served by sprockets" do
-      Teaspoon.configuration.should_receive(:suites).and_return "default" => proc{ |s| s.matcher = __FILE__ }
-      expect{ subject.send(:specs) }.to raise_error(Teaspoon::AssetNotServable, "#{__FILE__} is not within an asset path")
-    end
-
-  end
-
-  describe "#asset_from_file" do
-    before do
-      Rails.application.config.assets.stub(paths: ["/Users/person/workspace/spec/javascripts"])
-    end
-
-    it "converts a file name into a usable asset url" do
-      file = '/Users/person/workspace/spec/javascripts/support/support.js'
-      expect(subject.send(:asset_from_file, file)).to eq('support/support.js')
-    end
-
-    context "when the file name has .js.coffee or .coffee extensions" do
-      it "returns an asset url with a .js suffix" do
-        coffee_file = '/Users/person/workspace/spec/javascripts/support/support.coffee'
-        expect(subject.send(:asset_from_file, coffee_file)).to eq('support/support.js')
-        jscoffee_file = '/Users/person/workspace/spec/javascripts/support/support.js.coffee'
-        expect(subject.send(:asset_from_file, jscoffee_file)).to eq('support/support.js')
-      end
-    end
-
-    context "when the file name contains regex special characters" do
-      it "converts a file name into a usable asset url" do
-        regex_file = '/Users/person/.$*?{}/spec/javascripts/support/support.js'
-        Rails.application.config.assets.stub(paths: ["/Users/person/.$*?{}/spec/javascripts"])
-        expect(subject.send(:asset_from_file, regex_file)).to eq('support/support.js')
-      end
-    end
-  end
-
-  describe "#run_hooks" do
-    it "runs blocks added with hook" do
-      first_value = nil; second_value = nil
-
-      default_suite_config = proc do |suite|
-        suite.hook(:before) { first_value = true }
-        suite.hook(:before) { second_value = true }
-      end
-
-      Teaspoon.configuration.stub(:suites).and_return "default" => default_suite_config
-
-      suite = Teaspoon::Suite.new({suite: :default})
-      suite.run_hooks :before
-
-      expect(first_value).to eql(true)
-      expect(second_value).to eql(true)
-    end
-  end
 end

data/spec/teaspoon_env.rb

@@ -1,33 +1,44 @@
-# This file allows you to override various Teaspoon configuration directives when running from the command line. It is not
-# required from within the Rails environment, so overriding directives that have been defined within the initializer
-# is not possible.
-#
-# Set RAILS_ROOT and load the environment.
-ENV["RAILS_ROOT"] = File.expand_path("../dummy", __FILE__)
-require File.expand_path("../dummy/config/environment", __FILE__)
+# Set RAILS_ROOT and load the environment if it's not already loaded.
+unless defined?(Rails)
+  ENV["RAILS_ROOT"] = File.expand_path("../dummy", __FILE__)
+  require File.expand_path("../dummy/config/environment", __FILE__)
+end
+
+Teaspoon.configure do |config|
+  config.root = Teaspoon::Engine.root
+  config.asset_paths << Teaspoon::Engine.root.join('lib/teaspoon')
+
+  config.suite do |suite|
+    suite.matcher = "{spec/javascripts,spec/dummy/app/assets/javascripts/specs}/**/*_spec.{js,js.coffee,coffee,js.coffee.erb}"
+    suite.javascripts = ["jasmine/1.3.1", "teaspoon/jasmine"]
+  end
+
+  config.suite :jasmine do |suite|
+    suite.matcher = "spec/javascripts/**/*_jspec.{js,js.coffee,coffee}"
+    suite.helper = "jasmine_helper"
+    suite.body_partial = "/body"
+  end
 
-# Provide default configuration.
-#
-# You can override various configuration directives defined here by using arguments with the teaspoon command.
-#
-# teaspoon --driver=selenium --suppress-log
-# rake teaspoon DRIVER=selenium SUPPRESS_LOG=false
-Teaspoon.setup do |config|
-  # Driver
-  #config.driver              = "phantomjs" # available: phantomjs, selenium
+  config.suite :mocha do |suite|
+    suite.matcher = "spec/javascripts/**/*_mspec.{js,js.coffee,coffee}"
+    suite.javascripts = ["mocha/1.17.1", "teaspoon/mocha"]
+    suite.helper = "mocha_helper"
+  end
 
-  # Behaviors
-  #config.server_timeout      = 20 # timeout for starting the server
-  #config.server_port         = nil # defaults to any open port unless specified
-  #config.fail_fast           = true # abort after the first failing suite
+  config.suite :qunit do |suite|
+    suite.matcher = "test/javascripts/**/*_test.{js,js.coffee,coffee}"
+    suite.javascripts = ["qunit/1.14.0", "teaspoon/qunit"]
+    suite.helper = "qunit_helper"
+  end
 
-  # Output
-  #config.formatters          = "dot" # available: dot, tap_y, swayze_or_oprah
-  #config.suppress_log        = false # suppress logs coming from console[log/error/debug]
-  #config.color               = true
+  config.suite :angular do |suite|
+    suite.matcher = "spec/javascripts/**/*_aspec.{js,js.coffee,coffee}"
+    suite.javascripts = ["angular/1.0.5", "teaspoon/angular"]
+    suite.helper = "angular_helper"
+  end
 
-  # Coverage (requires istanbul -- https://github.com/gotwarlost/istanbul)
-  #config.coverage             = true
-  #config.coverage_reports     = "text-summary,text,html,cobertura"
-  #config.coverage_output_dir  = "coverage"
+  #config.suite :integration do |suite|
+  #  suite.matcher = "spec/dummy/app/assets/javascripts/integration/*_spec.{js,js.coffee,coffee}"
+  #  suite.helper = nil
+  #end
 end