teaspoon 0.9.1 → 1.0.0

data/spec/teaspoon/instrumentation_spec.rb

@@ -1,113 +0,0 @@
-# encoding: utf-8
-
-require "spec_helper"
-require "rack/test"
-
-describe Teaspoon::Instrumentation do
-
-  subject { Teaspoon::Instrumentation }
-
-  let(:asset) { double(source: source, pathname: "path/to/instrument.js") }
-  let(:source) { "function add(a, b) { return a + b } // ☃ " }
-  let(:response) { [200, { "Content-Type" => "application/javascript" }, asset] }
-  let(:env) { { "QUERY_STRING" => "instrument=true" } }
-
-  describe ".add_to" do
-
-    before do
-      allow(Teaspoon::Instrumentation).to receive(:executable).and_return("/path/to/istanbul")
-    end
-
-    before do
-      allow(Teaspoon::Instrumentation).to receive(:add?).and_return(true)
-      expect(asset).to receive(:clone).and_return(asset)
-
-      allow(File).to receive(:open)
-      allow_any_instance_of(subject).to receive(:instrument).and_return(source + " // instrumented")
-
-      path = nil
-      Dir.mktmpdir { |p| path = p }
-      allow(Dir).to receive(:mktmpdir).and_yield(path)
-      @output = File.join(path, "instrument.js")
-    end
-
-    it "writes the file to a tmp path" do
-      file = double("file")
-      expect(File).to receive(:open).with(@output, "w").and_yield(file)
-      expect(file).to receive(:write).with("function add(a, b) { return a + b } // ☃ ")
-      subject.add_to(response, env)
-    end
-
-    it "instruments the javascript file" do
-      expect_any_instance_of(subject).to receive(:instrument).with(@output).and_return("_instrumented_")
-      subject.add_to(response, env)
-    end
-
-    it "replaces the response array with the appropriate information" do
-      response = [666, { "Content-Type" => "application/javascript" }, asset]
-      expected = [666, { "Content-Type" => "application/javascript", "Content-Length" => "59" }, asset]
-
-      expect(subject.add_to(response, env)).to eq(expected)
-    end
-
-    it "raises an exception if istanbul fails" do
-      `(exit 1)`
-      allow(subject).to receive(:`)
-      allow_any_instance_of(subject).to receive(:instrument).and_call_original
-      expect { subject.add_to(response, env) }.to raise_error(
-        Teaspoon::DependencyFailure, "Could not generate instrumentation for instrument.js."
-      )
-    end
-
-  end
-
-  describe ".add?" do
-
-    before do
-      allow(Teaspoon::Instrumentation).to receive(:executable).and_return("/path/to/istanbul")
-    end
-
-    it "returns true when everything is good" do
-      expect(subject.add?(response, "QUERY_STRING" => "instrument=true")).to be(true)
-      expect(subject.add?(response, "QUERY_STRING" => "instrument=1")).to be(true)
-    end
-
-    it "doesn't if the query param isn't set (or isn't something we care about)" do
-      expect(subject.add?(response, {})).to_not be(true)
-      expect(subject.add?(response, "QUERY_STRING" => "instrument=foo")).to_not be(true)
-    end
-
-    it "doesn't if response isn't 200" do
-      expect(subject.add?([404, { "Content-Type" => "application/javascript" }, asset], env)).to_not be(true)
-    end
-
-    it "doesn't when the content type isn't application/javascript" do
-      expect(subject.add?([200, { "Content-Type" => "foo/bar" }, asset], env)).to_not be(true)
-    end
-
-    it "doesn't if there's no executable" do
-      expect(subject).to receive(:executable).and_return(false)
-      expect(subject.add?(response, env)).to_not be(true)
-    end
-
-    it "doesn't if there's no asset" do
-      expect(subject.add?([404, { "Content-Type" => "application/javascript" }, []], env)).to_not be(true)
-    end
-
-  end
-
-  describe "integration" do
-
-    let(:asset) { Rails.application.assets.find_asset("instrumented1.coffee") }
-
-    it "instruments a file" do
-      pending("needs istanbul to be installed") unless Teaspoon::Instrumentation.executable
-      status, headers, asset = subject.add_to(response, "QUERY_STRING" => "instrument=true")
-      expect(status).to eq(200)
-      expect(headers).to include("Content-Type" => "application/javascript")
-      expect(asset.source).to match(/var __cov_.+ = \(Function\('return this'\)\)\(\);/)
-    end
-
-  end
-
-end

data/spec/teaspoon/result_spec.rb

@@ -1,98 +0,0 @@
-require "spec_helper"
-require "teaspoon/result"
-
-describe Teaspoon::Result do
-
-  subject { Teaspoon::Result.build_from_json(json) }
-  let(:suite_name) { "My Suite" }
-  let(:json) do
-    {
-      "type" => "spec",
-      "suite" => "_suite_name_",
-      "label" => "_spec_name_",
-      "status" => "failed",
-      "skipped" => false,
-      "link" => "?grep=_spec_description_",
-      "message" => "_message_",
-      "trace" => "_trace_",
-      "coverage" => "_coverage_",
-    }
-  end
-
-  describe ".build_from_json" do
-
-    describe "with a results object" do
-
-      let(:json) do
-        {
-          "elapsed" => 0.01,
-          "failures" => 10,
-          "pending" => 1,
-          "total" => 25
-        }
-      end
-
-      it "assigns from the JSON hash" do
-        expect(subject.elapsed).to eq(0.01)
-        expect(subject.total).to eq(25)
-      end
-
-    end
-
-    describe "with a spec" do
-
-      it "assigns from the JSON hash" do
-        expect(subject.type).to eq("spec")
-        expect(subject.suite).to eq("_suite_name_")
-        expect(subject.label).to eq("_spec_name_")
-        expect(subject.description).to eq("_suite_name_ _spec_name_")
-        expect(subject.status).to eq("failed")
-        expect(subject.skipped).to be_falsey
-        expect(subject.link).to eq("?grep=_spec_description_")
-        expect(subject.message).to eq("_message_")
-        expect(subject.trace).to eq("_trace_")
-        expect(subject.coverage).to eq("_coverage_")
-      end
-
-    end
-
-  end
-
-  describe "#failing?" do
-
-    it "returns a boolean based on status" do
-      subject.status = "foo"
-      expect(subject.failing?).to be_truthy
-      subject.status = "bar"
-      expect(subject.failing?).to be_truthy
-      subject.status = "passed"
-      expect(subject.failing?).to be_falsey
-      subject.status = "pending"
-      expect(subject.failing?).to be_falsey
-    end
-
-  end
-
-  describe "#passing?" do
-
-    it "returns a boolean based on status" do
-      subject.status = "passed"
-      expect(subject.passing?).to be_truthy
-      subject.status = "foo"
-      expect(subject.passing?).to be_falsey
-    end
-
-  end
-
-  describe "#pending?" do
-
-    it "returns a boolean based on status" do
-      subject.status = "pending"
-      expect(subject.pending?).to be_truthy
-      subject.status = "foo"
-      expect(subject.pending?).to be_falsey
-    end
-
-  end
-
-end

data/spec/teaspoon/runner_spec.rb

@@ -1,116 +0,0 @@
-require "spec_helper"
-require "teaspoon/runner"
-require "teaspoon/exceptions"
-require "teaspoon/coverage"
-
-describe Teaspoon::Runner do
-
-  before do
-    allow(Teaspoon.configuration).to receive(:formatters).and_return([])
-  end
-
-  describe "#initialize" do
-
-    it "sets @suite_name and @failure_count" do
-      subject = Teaspoon::Runner.new(:foo)
-      expect(subject.instance_variable_get(:@suite_name)).to eq(:foo)
-      expect(subject.failure_count).to eq(0)
-    end
-
-    it "instantiates formatters based on configuration" do
-      allow(Teaspoon.configuration).to receive(:formatters).and_return(["dot", "xml"])
-      Teaspoon::Formatters::XmlFormatter = Class.new do
-        def initialize(_suite_name = :default, _output_file = nil) end
-      end
-      expect(subject.instance_variable_get(:@formatters)[0]).to be_a(Teaspoon::Formatters::DotFormatter)
-      expect(subject.instance_variable_get(:@formatters)[1]).to be_a(Teaspoon::Formatters::XmlFormatter)
-    end
-
-    it "raises a Teaspoon::UnknownFormatter exception when a formatter isn't found" do
-      allow(Teaspoon.configuration).to receive(:formatters).and_return(["bar"])
-      expect { Teaspoon::Runner.new(:foo) }.to raise_error Teaspoon::UnknownFormatter, "Unknown formatter: \"bar\""
-    end
-
-  end
-
-  describe "#process" do
-
-    let(:formatter) { double }
-    let(:coverage) { double(generate_reports: nil, check_thresholds: nil) }
-
-    before do
-      subject.instance_variable_set(:@formatters, [formatter])
-    end
-
-    it "notifies formatters when it understands the log" do
-      expect(formatter).to receive(:foo)
-      expect(formatter).to_not receive(:bar)
-      subject.process('{"_teaspoon":true,"type":"foo"}')
-      subject.process('{"_teaspoon":false,"type":"bar"}')
-    end
-
-    it "notifies formatters of console output when it doesn't understand the log" do
-      expect(formatter).to receive(:console).with("_line_")
-      expect(subject).to receive(:result_from_line).and_return(false)
-      subject.process("_line_")
-    end
-
-    it "handles bad json" do
-      expect(formatter).to receive(:console).with("{bad: true}")
-      subject.process("{bad: true}")
-    end
-
-    it "handles json when it's not intended for it" do
-      expect(formatter).to receive(:console).with('{"good": true}')
-      subject.process('{"good": true}')
-    end
-
-    it "keeps a count of errors" do
-      subject.process('{"_teaspoon":true,"type":"spec"}')
-      subject.process('{"_teaspoon":true,"type":"spec", "status": "passed"}')
-      subject.process('{"_teaspoon":true,"type":"spec", "status": "pending"}')
-      subject.process('{"_teaspoon":true,"type":"error"}')
-      subject.process('{"_teaspoon":true,"type":"results"}')
-      expect(subject.failure_count).to be(1)
-    end
-
-    describe "with an exception" do
-
-      it "notifies itself, and raises Teaspoon::RunnerException" do
-        expect(subject).to receive(:on_exception).and_call_original
-        expect { subject.process('{"_teaspoon":true,"type":"exception","message":"_message_"}') }.to raise_error(
-          Teaspoon::RunnerException,
-          "_message_"
-        )
-      end
-
-    end
-
-    describe "with a result" do
-
-      before do
-        allow(Teaspoon::Coverage).to receive(:new).and_return(coverage)
-      end
-
-      it "notifies itself" do
-        expect(subject).to receive(:on_result)
-        subject.process('{"_teaspoon":true,"type":"result"}')
-      end
-
-      it "resolves coverage" do
-        expect(Teaspoon.configuration).to receive(:use_coverage).twice.and_return("_config_")
-        expect(Teaspoon::Coverage).to receive(:new).with(:default, "_config_", "_coverage_").and_return(coverage)
-        expect(coverage).to receive(:generate_reports).and_yield("_generated_reports_")
-        expect(coverage).to receive(:check_thresholds).and_yield("_threshold_failures_")
-        expect(subject).to receive(:notify_formatters).once.with("coverage", "_generated_reports_")
-        expect(subject).to receive(:notify_formatters).once.with("threshold_failure", "_threshold_failures_")
-        expect(subject).to receive(:notify_formatters).exactly(2).times.and_call_original
-        subject.process('{"_teaspoon":true,"type":"result","coverage":"_coverage_"}')
-        expect(subject.failure_count).to eq(1)
-      end
-
-    end
-
-  end
-
-end

data/spec/teaspoon/server_spec.rb

@@ -1,105 +0,0 @@
-require "spec_helper"
-require "teaspoon/server"
-require "net/http"
-
-describe Teaspoon::Server do
-
-  subject { Teaspoon::Server.new }
-
-  describe "#start" do
-
-    let(:server) { double(start: nil) }
-
-    before do
-      allow(Thread).to receive(:new) { |&b| @block = b; "_thread_" }
-      allow(subject).to receive(:wait_until_started).and_return(nil)
-    end
-
-    it "spawns a thread" do
-      expect(Thread).to receive(:new)
-      subject.start
-    end
-
-    it "starts a rack server" do
-      expect(Rack::Server).to receive(:new).and_return(server)
-      expect(server).to receive(:start)
-
-      subject.start
-      @block.call
-    end
-
-    it "waits until the server is started" do
-      expect(Thread).to receive(:new)
-      expect(subject).to receive(:wait_until_started).with("_thread_")
-      subject.start
-    end
-
-    it "rescues errors" do
-      expect(Thread).to receive(:new).and_raise("OMG!")
-      expect { subject.start }.to raise_error("Cannot start server: OMG!")
-    end
-
-    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
-      }
-      expect(Rack::Server).to receive(:new).with(expected_opts).and_return(server)
-
-      subject.start
-      @block.call
-    end
-
-    it "raises a ServerException if the timeout fails" do
-      expect(subject).to receive(:wait_until_started).and_call_original
-      expect(Timeout).to receive(:timeout).with(Teaspoon.configuration.server_timeout.to_i).and_raise(Timeout::Error)
-      expect { subject.start }.to raise_error(
-        Teaspoon::ServerException,
-        "Server failed to start. You may need to increase the timeout configuration."
-      )
-    end
-
-  end
-
-  describe "#responsive?" do
-
-    let(:socket) { double(close: nil) }
-
-    it "checks a local port to see if a server is running" do
-      subject.port = 31337
-      expect(TCPSocket).to receive(:new).with("127.0.0.1", 31337).and_return(socket)
-      expect(socket).to receive(:close)
-      subject.responsive?
-    end
-
-  end
-
-  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 "integration" do
-
-    before do
-      allow(Teaspoon.configuration).to receive(:suite_configs).and_return("foo" => { block: proc {} })
-      allow(Teaspoon.configuration).to receive(:suppress_log).and_return(true)
-    end
-
-    it "really starts a server" do
-      subject.start
-      response = Net::HTTP.get_response(URI.parse("#{subject.url}/teaspoon/foo"))
-      expect(response.code).to eq("200")
-    end
-
-  end
-
-end

data/spec/teaspoon/suite_spec.rb

@@ -1,138 +0,0 @@
-require "spec_helper"
-
-describe Teaspoon::Suite do
-
-  before do
-    allow(Teaspoon.configuration).to receive(:suite_configs).and_return("default" => { block: proc {} })
-  end
-
-  describe ".all" do
-
-    before do
-      Teaspoon::Suite.instance_variable_set(:@all, nil)
-      suites = { "default" => { block: proc {} }, "foo" => { block: proc {} } }
-      allow(Teaspoon.configuration).to receive(:suite_configs).and_return(suites)
-    end
-
-    it "returns all the suites" do
-      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
-
-  describe ".resolve_spec_for" do
-
-    it "return a hash with the suite name and path" do
-      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
-      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| result[:path].grep(/#{path}/)[0] }).to be_truthy
-    end
-
-    it "returns false if the spec wasn't found" do
-      expect(Teaspoon::Suite.resolve_spec_for("foo")).to be_falsey
-    end
-
-  end
-
-  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 in the options" do
-      suite = { "test" => { block: proc { |s| s.helper = "helper_file" } } }
-      expect(Teaspoon.configuration).to receive(:suite_configs).and_return(suite)
-      subject = Teaspoon::Suite.new(suite: :test)
-      expect(subject.name).to eql("test")
-      expect(subject.config.helper).to eq("helper_file")
-    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
-      expect(subject).to receive(:glob).and_return([file])
-      expect(subject.spec_files[0]).to eql(path: file, name: "teaspoon/base/reporters/console_spec.js")
-    end
-
-    it "raises an exception if the file isn't servable (in an asset path)" do
-      expect(subject).to receive(:glob).and_return(["/foo"])
-      expect { subject.spec_files[0] }.to raise_error Teaspoon::AssetNotServable
-    end
-
-  end
-
-  describe "#spec_assets" do
-
-    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 just a file if one was requested" 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 the asset tree (all dependencies resolved) if we want coverage" do
-      allow(subject).to receive(:no_coverage).and_return([%r{support/}, "spec_helper.coffee"])
-      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
-
-    it "returns only the top level assets in the asset tree if config/expand_assets is set to false" do
-      allow(subject.config).to receive(:expand_assets).and_return(false)
-      result = subject.spec_assets(true)
-      expect(result.any? { |file| file =~ /body=1/ }).to eq(false)
-    end
-
-  end
-
-  describe "#include_spec?" 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
-
-  end
-
-  describe "#include_spec_for?" do
-
-    it "returns the spec if an exact match was found" do
-      files = subject.send(:glob)
-      expect(subject.include_spec_for?(files.first)).to eq(files.first)
-    end
-
-    it "returns a list of specs when the file name looks like it could be a match" do
-      files = subject.include_spec_for?("fixture_spec")
-      expect(files.any? { |file| file.include?("fixture_spec.coffee") }).to be_truthy
-    end
-
-    it "returns false if a matching spec isn't found" do
-      expect(subject.include_spec_for?("_not_a_match_")).to eq(false)
-    end
-
-  end
-
-end