appsignal 3.12.6-java → 4.0.0.beta.1-java

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

@@ -13,10 +13,11 @@ describe Appsignal::Rack::EventHandler do
   let(:request) { Rack::Request.new(env) }
   let(:response) { nil }
   let(:log_stream) { StringIO.new }
-  let(:log) { log_contents(log_stream) }
+  let(:logs) { log_contents(log_stream) }
   let(:event_handler_instance) { described_class.new }
+  let(:appsignal_env) { :default }
   before do
-    start_agent
+    start_agent(:env => appsignal_env)
     Appsignal.internal_logger = test_logger(log_stream)
   end
   around { |example| keep_transactions { example.run } }
@@ -41,9 +42,9 @@ describe Appsignal::Rack::EventHandler do
     end
 
     context "when not active" do
-      it "does not create a new transaction" do
-        allow(Appsignal).to receive(:active?).and_return(false)
+      let(:appsignal_env) { :inactive_env }
 
+      it "does not create a new transaction" do
         expect { on_start }.to_not(change { created_transactions.length })
       end
     end
@@ -95,7 +96,7 @@ describe Appsignal::Rack::EventHandler do
       end
 
       it "logs an error" do
-        expect(log).to contains_log(
+        expect(logs).to contains_log(
           :error,
           "Error occurred in Appsignal::Rack::EventHandler's after_reply: " \
             "ExampleStandardError: oh no"
@@ -112,7 +113,7 @@ describe Appsignal::Rack::EventHandler do
       callback = request.env[Appsignal::Rack::RACK_AFTER_REPLY].first
       callback.call
 
-      expect(log).to contains_log(
+      expect(logs).to contains_log(
         :error,
         "Error occurred in Appsignal::Rack::EventHandler's after_reply: ExampleStandardError: oh no"
       )
@@ -124,7 +125,7 @@ describe Appsignal::Rack::EventHandler do
 
       on_start
 
-      expect(log).to contains_log(
+      expect(logs).to contains_log(
         :error,
         "Error occurred in Appsignal::Rack::EventHandler#on_start: ExampleStandardError: oh no"
       )
@@ -140,9 +141,9 @@ describe Appsignal::Rack::EventHandler do
     end
 
     context "when not active" do
-      it "does not report the transaction" do
-        allow(Appsignal).to receive(:active?).and_return(false)
+      let(:appsignal_env) { :inactive_env }
 
+      it "does not report the transaction" do
         on_start
         on_error(ExampleStandardError.new("the error"))
 
@@ -167,7 +168,7 @@ describe Appsignal::Rack::EventHandler do
 
       on_error(ExampleStandardError.new("the error"))
 
-      expect(log).to contains_log(
+      expect(logs).to contains_log(
         :error,
         "Error occurred in Appsignal::Rack::EventHandler#on_error: ExampleStandardError: oh no"
       )
@@ -195,9 +196,9 @@ describe Appsignal::Rack::EventHandler do
     end
 
     context "when not active" do
-      it "doesn't do anything" do
-        allow(Appsignal).to receive(:active?).and_return(false)
+      let(:appsignal_env) { :inactive_env }
 
+      it "doesn't do anything" do
         request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = http_request_transaction
         on_finish
 
@@ -353,8 +354,10 @@ describe Appsignal::Rack::EventHandler do
       end
 
       it "logs an error" do
-        expect(log).to contains_log(:error,
-          "Error occurred in Appsignal::Rack::EventHandler#on_finish: ExampleStandardError: oh no")
+        expect(logs).to contains_log(
+          :error,
+          "Error occurred in Appsignal::Rack::EventHandler#on_finish: ExampleStandardError: oh no"
+        )
       end
     end
 
@@ -429,7 +432,7 @@ describe Appsignal::Rack::EventHandler do
       on_start
       on_finish
 
-      expect(log).to contains_log(
+      expect(logs).to contains_log(
         :error,
         "Error occurred in Appsignal::Rack::EventHandler#on_finish: ExampleStandardError: oh no"
       )

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

@@ -2,14 +2,7 @@ if DependencyHelper.rails_present?
   describe Appsignal::Rack::RailsInstrumentation do
     class MockController; end
 
-    let(:log) { StringIO.new }
-    let(:transaction) do
-      Appsignal::Transaction.new(
-        "transaction_id",
-        Appsignal::Transaction::HTTP_REQUEST,
-        Rack::Request.new(env)
-      )
-    end
+    let(:transaction) { new_transaction }
     let(:app) { DummyApp.new }
     let(:params) do
       {
@@ -36,7 +29,6 @@ if DependencyHelper.rails_present?
     around { |example| keep_transactions { example.run } }
     before do
       start_agent
-      Appsignal.internal_logger = test_logger(log)
       env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
     end
 
@@ -111,10 +103,10 @@ if DependencyHelper.rails_present?
       it "does not store the invalid HTTP request method" do
         env[:request_method] = "FOO"
         env["REQUEST_METHOD"] = "FOO"
-        make_request
+        logs = capture_logs { make_request }
 
         expect(last_transaction).to_not include_metadata("method" => anything)
-        expect(log_contents(log)).to contains_log(
+        expect(logs).to contains_log(
           :error,
           "Exception while fetching the HTTP request method: "
         )

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

@@ -51,13 +51,12 @@ if DependencyHelper.sinatra_present?
     let(:env) do
       Rack::MockRequest.env_for("/path", "sinatra.route" => "GET /path", "REQUEST_METHOD" => "GET")
     end
+    let(:appsignal_env) { :default }
     let(:options) { {} }
     let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
 
-    before { start_agent }
-    around do |example|
-      keep_transactions { example.run }
-    end
+    before { start_agent(:env => appsignal_env) }
+    around { |example| keep_transactions { example.run } }
 
     describe "#initialize" do
       context "with no settings method in the Sinatra app" do
@@ -97,7 +96,7 @@ if DependencyHelper.sinatra_present?
       before { allow(middleware).to receive(:raw_payload).and_return({}) }
 
       context "when appsignal is not active" do
-        before { allow(Appsignal).to receive(:active?).and_return(false) }
+        let(:appsignal_env) { :inactive_env }
 
         it "does not instrument requests" do
           expect { make_request }.to_not(change { created_transactions.count })

data/spec/lib/appsignal/sample_data_spec.rb

@@ -0,0 +1,174 @@
+describe Appsignal::SampleData do
+  let(:data) { described_class.new(:data_key) }
+
+  describe "#add" do
+    it "sets the given value" do
+      data.add(:key1 => "value 1")
+
+      expect(data.value).to eq(:key1 => "value 1")
+    end
+
+    it "adds the given value with the block being leading" do
+      data.add(:key1 => "value 1") { { :key2 => "value 2" } }
+
+      expect(data.value).to eq(:key2 => "value 2")
+    end
+
+    it "merges multiple values" do
+      data.add(:key1 => "value 1")
+      data.add(:key2 => "value 2")
+
+      expect(data.value).to eq(:key1 => "value 1", :key2 => "value 2")
+    end
+
+    it "merges only root level Hash keys" do
+      data.add(:key => { :abc => "value" })
+      data.add(:key => { :def => "value" })
+
+      expect(data.value).to eq(:key => { :def => "value" })
+    end
+
+    it "merges values from arguments and blocks" do
+      data.add(:key1 => "value 1")
+      data.add { { :key2 => "value 2" } }
+      data.add(:key3 => "value 3")
+
+      expect(data.value).to eq(:key1 => "value 1", :key2 => "value 2", :key3 => "value 3")
+    end
+
+    it "merges array values" do
+      data.add([:first_arg])
+      data.add { [:from_block] }
+      data.add([:second_arg])
+
+      expect(data.value).to eq([:first_arg, :from_block, :second_arg])
+    end
+
+    it "overwrites the value if the new value is of a different type" do
+      data.add(:key1 => "value 1")
+      expect(data.value).to eq(:key1 => "value 1")
+
+      data.add(["abc"])
+      expect(data.value).to eq(["abc"])
+
+      logs = capture_logs { data.value }
+      expect(logs).to contains_log(
+        :warn,
+        "The sample data 'data_key' changed type from 'Hash' to 'Array'."
+      )
+    end
+
+    it "ignores invalid values" do
+      logs = capture_logs { data.add("string") }
+      expect(data.value).to be_nil
+      expect(logs).to contains_log(
+        :error,
+        "Sample data 'data_key': Unsupported data type 'String' received: \"string\""
+      )
+
+      set = Set.new
+      set.add("abc")
+      logs = capture_logs { data.add(set) }
+      expect(data.value).to be_nil
+      expect(logs).to contains_log(
+        :error,
+        "Sample data 'data_key': Unsupported data type 'Set' received: #<Set: {\"abc\"}>"
+      )
+
+      instance = Class.new
+      logs = capture_logs { data.add(instance) }
+      expect(data.value).to be_nil
+      expect(logs).to contains_log(
+        :error,
+        "Sample data 'data_key': Unsupported data type 'Class' received: #<Class:"
+      )
+    end
+
+    context "with a type specified" do
+      it "only accepts values of Hash type" do
+        data = described_class.new(:data_key, Hash)
+
+        data.add(:key1 => "value 1")
+        data.add(["abc"])
+        data.add { { :key2 => "value 2" } }
+        data.add { ["def"] }
+        data.add(:key3 => "value 3")
+
+        expect(data.value).to eq(:key1 => "value 1", :key2 => "value 2", :key3 => "value 3")
+      end
+
+      it "only accepts values of Array type" do
+        data = described_class.new(:data_key, Array)
+
+        data.add(:key1 => "value 1")
+        data.add(["abc"])
+        data.add { { :key2 => "value 2" } }
+        data.add { ["def"] }
+        data.add(:key3 => "value 3")
+
+        expect(data.value).to eq(["abc", "def"])
+      end
+    end
+  end
+
+  describe "#value" do
+    it "caches the block value after calling it once" do
+      Appsignal::Testing.store[:block_call] = 0
+      data.add do
+        Appsignal::Testing.store[:block_call] += 1
+        { :key => "value" }
+      end
+
+      expect(data.value).to eq(:key => "value")
+      data.value
+
+      expect(Appsignal::Testing.store[:block_call]).to eq(1)
+    end
+  end
+
+  describe "#value?" do
+    it "returns true when value is set" do
+      data.add(["abc"])
+      expect(data.value?).to be_truthy
+    end
+
+    it "returns true when value is set with a block" do
+      data.add { ["abc"] }
+      expect(data.value?).to be_truthy
+    end
+
+    it "returns false when the value is not set" do
+      expect(data.value?).to be_falsey
+    end
+  end
+
+  describe "#duplicate" do
+    it "duplicates the internal Hash state without modifying the original" do
+      data = described_class.new(:my_key, Hash)
+      data.add(:abc => :value)
+
+      duplicate = data.dup
+      duplicate.add(:def => :value)
+
+      expect(data.value).to eq(:abc => :value)
+      expect(duplicate.value).to eq(:abc => :value, :def => :value)
+
+      expect(duplicate.instance_variable_get(:@key)).to eq(:my_key)
+      expect(duplicate.instance_variable_get(:@accepted_type)).to eq(Hash)
+    end
+
+    it "duplicates the internal Array state without modifying the original" do
+      data = described_class.new(:my_key, Array)
+      data.add([:abc])
+
+      duplicate = data.dup
+      duplicate.add([:def])
+
+      expect(data.value).to eq([:abc])
+      expect(duplicate.value).to eq([:abc, :def])
+
+      expect(duplicate.instance_variable_get(:@key)).to eq(:my_key)
+      expect(duplicate.instance_variable_get(:@accepted_type)).to eq(Array)
+    end
+  end
+end