appsignal 2.11.7 → 3.0.0

data/spec/lib/appsignal/integrations/resque_active_job_spec.rb

@@ -1,28 +0,0 @@
-require "appsignal/integrations/resque_active_job"
-
-describe "Legacy Resque ActiveJob integration" do
-  let(:err_stream) { std_stream }
-  let(:stderr) { err_stream.read }
-  let(:log_stream) { std_stream }
-  let(:log) { log_contents(log_stream) }
-
-  it "logs and prints a deprecation message on extend" do
-    Appsignal.logger = test_logger(log_stream)
-
-    capture_std_streams(std_stream, err_stream) do
-      Class.new do
-        include Appsignal::Integrations::ResqueActiveJobPlugin
-      end
-    end
-
-    deprecation_message =
-      "The AppSignal ResqueActiveJobPlugin is deprecated and does " \
-      "nothing on extend. In this version of the AppSignal Ruby gem " \
-      "the integration with Resque is automatic on all Resque workers. " \
-      "Please remove the following line from this file to remove this " \
-      "message: include Appsignal::Integrations::ResqueActiveJobPlugin\n" \
-      "#{__FILE__}:"
-    expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-    expect(log).to contains_log :warn, deprecation_message
-  end
-end

data/spec/lib/appsignal/integrations/resque_spec.rb

@@ -1,28 +0,0 @@
-require "appsignal/integrations/resque"
-
-describe "Legacy Resque integration" do
-  let(:err_stream) { std_stream }
-  let(:stderr) { err_stream.read }
-  let(:log_stream) { std_stream }
-  let(:log) { log_contents(log_stream) }
-
-  it "logs and prints a deprecation message on extend" do
-    Appsignal.logger = test_logger(log_stream)
-
-    capture_std_streams(std_stream, err_stream) do
-      Class.new do
-        extend Appsignal::Integrations::ResquePlugin
-      end
-    end
-
-    deprecation_message =
-      "The AppSignal ResquePlugin is deprecated and does " \
-      "nothing on extend. In this version of the AppSignal Ruby gem " \
-      "the integration with Resque is automatic on all Resque workers. " \
-      "Please remove the following line from this file to remove this " \
-      "message: extend Appsignal::Integrations::ResquePlugin\n" \
-      "#{__FILE__}:"
-    expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-    expect(log).to contains_log :warn, deprecation_message
-  end
-end

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -1,128 +0,0 @@
-describe Appsignal::JSExceptionTransaction do
-  before { allow(SecureRandom).to receive(:uuid).and_return("123abc") }
-
-  let!(:transaction) { Appsignal::JSExceptionTransaction.new(data) }
-  let(:data) do
-    {
-      "name"        => "TypeError",
-      "message"     => "foo is not a valid method",
-      "action"      => "ExceptionIncidentComponent",
-      "path"        => "foo.bar/moo",
-      "environment" => "development",
-      "backtrace"   => [
-        "foo.bar/js:11:1",
-        "foo.bar/js:22:2"
-      ],
-      "tags" => [
-        "tag1"
-      ]
-    }
-  end
-
-  describe "#initialize" do
-    it "should call all required methods" do
-      expect(Appsignal::Extension).to receive(:start_transaction).with("123abc", "frontend", 0).and_return(1)
-
-      expect(transaction).to receive(:set_action)
-      expect(transaction).to receive(:set_metadata)
-      expect(transaction).to receive(:set_error)
-      expect(transaction).to receive(:set_sample_data)
-
-      transaction.send :initialize, data
-
-      expect(transaction.ext).to_not be_nil
-    end
-  end
-
-  describe "#set_action" do
-    it "should call `Appsignal::Extension.set_action`" do
-      expect(transaction.ext).to receive(:set_action).with(
-        "ExceptionIncidentComponent"
-      )
-
-      transaction.set_action
-    end
-  end
-
-  describe "#set_metadata" do
-    it "should call `Appsignal::Extension.set_transaction_metadata`" do
-      expect(transaction.ext).to receive(:set_metadata).with(
-        "path",
-        "foo.bar/moo"
-      )
-
-      transaction.set_metadata
-    end
-  end
-
-  describe "#set_error" do
-    it "should call `Appsignal::Extension.set_transaction_error`" do
-      expect(transaction.ext).to receive(:set_error).with(
-        "TypeError",
-        "foo is not a valid method",
-        Appsignal::Utils::Data.generate(["foo.bar/js:11:1", "foo.bar/js:22:2"])
-      )
-
-      transaction.set_error
-    end
-  end
-
-  describe "#set_sample_data" do
-    it "should call `Appsignal::Extension.set_transaction_error_data`" do
-      expect(transaction.ext).to receive(:set_sample_data).with(
-        "tags",
-        Appsignal::Utils::Data.generate(["tag1"])
-      )
-
-      transaction.set_sample_data
-    end
-  end
-
-  context "when sending just the name" do
-    let(:data) { { "name" => "TypeError" } }
-
-    describe "#set_action" do
-      it "should not call `Appsignal::Extension.set_action`" do
-        expect(transaction.ext).to_not receive(:set_action)
-
-        transaction.set_action
-      end
-    end
-
-    describe "#set_metadata" do
-      it "should not call `Appsignal::Extension.set_transaction_metadata`" do
-        expect(transaction.ext).to_not receive(:set_metadata)
-
-        transaction.set_metadata
-      end
-    end
-
-    describe "#set_error" do
-      it "should call `Appsignal::Extension.set_transaction_error` with just the name" do
-        expect(transaction.ext).to receive(:set_error).with(
-          "TypeError",
-          "",
-          Appsignal::Utils::Data.generate([])
-        )
-
-        transaction.set_error
-      end
-    end
-
-    describe "#set_sample_data" do
-      it "should not call `Appsignal::Extension.set_transaction_error_data`" do
-        expect(transaction.ext).to_not receive(:set_sample_data)
-
-        transaction.set_sample_data
-      end
-    end
-  end
-
-  describe "#complete!" do
-    it "should call all required methods" do
-      expect(transaction.ext).to receive(:finish).and_call_original
-      expect(transaction.ext).to receive(:complete).and_call_original
-      transaction.complete!
-    end
-  end
-end

data/spec/lib/appsignal/rack/js_exception_catcher_spec.rb

@@ -1,170 +0,0 @@
-describe Appsignal::Rack::JSExceptionCatcher do
-  let(:app)            { double(:call => true) }
-  let(:options)        { nil }
-  let(:config_options) { { :enable_frontend_error_catching => true } }
-  let(:config)         { project_fixture_config("production", config_options) }
-  let(:deprecation_message) do
-    "The Appsignal::Rack::JSExceptionCatcher is " \
-      "deprecated and will be removed in a future version. Please use " \
-      "the official AppSignal JavaScript integration by disabling " \
-      "`enable_frontend_error_catching` in your configuration and " \
-      "installing AppSignal for JavaScript instead. " \
-      "(https://docs.appsignal.com/front-end/)"
-  end
-  before { Appsignal.config = config }
-
-  describe "#initialize" do
-    let(:out_stream) { std_stream }
-    let(:err_stream) { std_stream }
-    let(:output) { out_stream.read }
-    let(:stderr) { err_stream.read }
-
-    it "logs to the logger" do
-      log = capture_logs do
-        capture_std_streams(out_stream, err_stream) do
-          Appsignal::Rack::JSExceptionCatcher.new(app, options)
-        end
-      end
-      expect(log).to contains_log(:warn, deprecation_message)
-      expect(log).to contains_log(:debug, "Initializing Appsignal::Rack::JSExceptionCatcher")
-      expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-      expect(stderr).to_not include("appsignal:")
-      expect(output).to be_empty
-    end
-  end
-
-  describe "#call" do
-    let(:catcher) do
-      silence :allowed => ["enable_frontend_error_catching"] do
-        Appsignal::Rack::JSExceptionCatcher.new(app, options)
-      end
-    end
-    after { catcher.call(env) }
-
-    context "when path is not frontend_error_catching_path" do
-      let(:env) { { "PATH_INFO" => "/foo" } }
-
-      context "when AppSignal is not active" do
-        before { config[:active] = false }
-
-        it "calls the next middleware" do
-          expect(app).to receive(:call).with(env)
-        end
-      end
-
-      context "when AppSignal is active" do
-        before { config[:active] = true }
-
-        it "calls the next middleware" do
-          expect(app).to receive(:call).with(env)
-        end
-      end
-    end
-
-    context "when path is frontend_error_catching_path" do
-      let(:transaction) { double(:complete! => true) }
-      let(:env) do
-        {
-          "PATH_INFO"  => "/appsignal_error_catcher",
-          "rack.input" => double(:read => '{"name": "error"}')
-        }
-      end
-
-      context "when AppSignal is not active" do
-        before { config[:active] = false }
-
-        it "doesn't create an AppSignal transaction" do
-          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-        end
-
-        it "returns a 202 status" do
-          expect(catcher.call(env)).to eq(
-            [202, {}, ["AppSignal JavaScript error catching endpoint is not active."]]
-          )
-        end
-      end
-
-      context "when AppSignal is active" do
-        before { config[:active] = true }
-
-        it "creates a JSExceptionTransaction" do
-          expect(Appsignal::JSExceptionTransaction).to receive(:new)
-            .with("name" => "error")
-            .and_return(transaction)
-
-          expect(transaction).to receive(:complete!)
-        end
-
-        it "returns 200" do
-          allow(Appsignal::JSExceptionTransaction).to receive(:new)
-            .and_return(transaction)
-
-          expect(catcher.call(env)).to eq([200, {}, []])
-        end
-
-        context "when request payload is empty" do
-          let(:env) do
-            {
-              "PATH_INFO"  => "/appsignal_error_catcher",
-              "rack.input" => double(:read => "")
-            }
-          end
-
-          it "does not create a transaction" do
-            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-          end
-
-          it "returns 400" do
-            expect(catcher.call(env)).to eq([400, {}, ["Request payload is not valid JSON."]])
-          end
-        end
-
-        context "when `frontend_error_catching_path` is different" do
-          let(:config_options) { { :frontend_error_catching_path => "/foo" } }
-
-          it "does not create a transaction" do
-            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-          end
-
-          it "calls the next middleware" do
-            expect(app).to receive(:call).with(env)
-          end
-        end
-
-        context "when `name` is empty" do
-          let(:env) do
-            {
-              "PATH_INFO"  => "/appsignal_error_catcher",
-              "rack.input" => double(:read => '{"name": ""}')
-            }
-          end
-
-          it "does not create a transaction" do
-            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-          end
-
-          it "returns 422" do
-            expect(catcher.call(env)).to eq([422, {}, []])
-          end
-        end
-
-        context "when `name` doesn't exist" do
-          let(:env) do
-            {
-              "PATH_INFO"  => "/appsignal_error_catcher",
-              "rack.input" => double(:read => '{"foo": ""}')
-            }
-          end
-
-          it "does not create a transaction" do
-            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-          end
-
-          it "returns 422" do
-            expect(catcher.call(env)).to eq([422, {}, []])
-          end
-        end
-      end
-    end
-  end
-end