appsignal 4.0.6-java → 4.0.8-java

data/spec/lib/appsignal/utils/integration_memory_logger_spec.rb

@@ -1,153 +0,0 @@
-describe Appsignal::Utils::IntegrationLogger do
-  let(:formatter) { nil }
-  let(:logger) do
-    Appsignal::Utils::IntegrationMemoryLogger.new.tap do |l|
-      l.formatter = formatter if formatter
-    end
-  end
-
-  describe "#add" do
-    it "adds a log message with the severity" do
-      logger.add(:DEBUG, "debug message")
-      logger.add(:INFO, "info message")
-      logger.add(:WARN, "warn message")
-      logger.add(:ERROR, "error message")
-      logger.add(:FATAL, "fatal message")
-      logger.add(:UNKNOWN, "unknown message")
-
-      expect(logger.messages[:DEBUG]).to eq(["debug message"])
-      expect(logger.messages[:INFO]).to eq(["info message"])
-      expect(logger.messages[:WARN]).to eq(["warn message"])
-      expect(logger.messages[:ERROR]).to eq(["error message"])
-      expect(logger.messages[:FATAL]).to eq(["fatal message"])
-      expect(logger.messages[:UNKNOWN]).to eq(["unknown message"])
-    end
-
-    context "without formatter" do
-      it "logs in the default format" do
-        logger.add(:DEBUG, "debug message")
-        expect(logger.messages[:DEBUG]).to eq(["debug message"])
-      end
-    end
-
-    context "with formatter" do
-      let(:formatter) do
-        proc do |severity, _datetime, _progname, msg|
-          "[TIME (process) #PID][#{severity}] #{msg}\n"
-        end
-      end
-
-      it "formats the logs using the formatter" do
-        logger.add(:DEBUG, "debug message")
-        expect(logger.messages[:DEBUG]).to eq(["[TIME (process) #PID][DEBUG] debug message\n"])
-      end
-    end
-  end
-
-  describe "#debug" do
-    it "adds a log message with the debug severity" do
-      logger.debug("debug message")
-
-      expect(logger.messages[:DEBUG]).to eq(["debug message"])
-    end
-  end
-
-  describe "#info" do
-    it "adds a log message with the info severity" do
-      logger.info("info message")
-
-      expect(logger.messages[:INFO]).to eq(["info message"])
-    end
-  end
-
-  describe "#warn" do
-    it "adds a log message with the warn severity" do
-      logger.warn("warn message")
-
-      expect(logger.messages[:WARN]).to eq(["warn message"])
-    end
-  end
-
-  describe "#error" do
-    it "adds a log message with the error severity" do
-      logger.error("error message")
-
-      expect(logger.messages[:ERROR]).to eq(["error message"])
-    end
-  end
-
-  describe "#fatal" do
-    it "adds a log message with the fatal severity" do
-      logger.fatal("fatal message")
-
-      expect(logger.messages[:FATAL]).to eq(["fatal message"])
-    end
-  end
-
-  describe "#unknown" do
-    it "adds a log message with the unknown severity" do
-      logger.unknown("unknown message")
-
-      expect(logger.messages[:UNKNOWN]).to eq(["unknown message"])
-    end
-  end
-
-  describe "#clear" do
-    it "clears all log messages" do
-      logger.add(:DEBUG, "debug message")
-      logger.add(:INFO, "info message")
-      logger.add(:WARN, "warn message")
-      logger.add(:ERROR, "error message")
-      logger.add(:FATAL, "fatal message")
-      logger.add(:UNKNOWN, "unknown message")
-      logger.clear
-
-      expect(logger.messages).to be_empty
-    end
-  end
-
-  describe "#messages_for_level" do
-    it "returns only log messages for level and higher" do
-      logger.add(:DEBUG, "debug message")
-      logger.add(:INFO, "info message")
-      logger.add(:WARN, "warn message")
-      logger.add(:ERROR, "error message")
-      logger.add(:FATAL, "fatal message")
-      logger.add(:UNKNOWN, "unknown message")
-
-      expect(logger.messages_for_level(Logger::DEBUG)).to eq([
-        "debug message",
-        "info message",
-        "warn message",
-        "error message",
-        "fatal message",
-        "unknown message"
-      ])
-      expect(logger.messages_for_level(Logger::INFO)).to eq([
-        "info message",
-        "warn message",
-        "error message",
-        "fatal message",
-        "unknown message"
-      ])
-      expect(logger.messages_for_level(Logger::WARN)).to eq([
-        "warn message",
-        "error message",
-        "fatal message",
-        "unknown message"
-      ])
-      expect(logger.messages_for_level(Logger::ERROR)).to eq([
-        "error message",
-        "fatal message",
-        "unknown message"
-      ])
-      expect(logger.messages_for_level(Logger::FATAL)).to eq([
-        "fatal message",
-        "unknown message"
-      ])
-      expect(logger.messages_for_level(Logger::UNKNOWN)).to eq([
-        "unknown message"
-      ])
-    end
-  end
-end

data/spec/lib/appsignal/utils/json_spec.rb

@@ -1,44 +0,0 @@
-describe Appsignal::Utils::JSON do
-  describe ".generate" do
-    subject { Appsignal::Utils::JSON.generate(body) }
-
-    context "with a valid body" do
-      let(:body) do
-        {
-          "the" => "payload",
-          1 => true,
-          nil => "test",
-          :foo => [1, 2, "three"],
-          "bar" => nil,
-          "baz" => { "foo" => "bar" }
-        }
-      end
-
-      it "returns a JSON string" do
-        is_expected.to eq %({"the":"payload","1":true,"":"test",) +
-          %("foo":[1,2,"three"],"bar":null,"baz":{"foo":"bar"}})
-      end
-    end
-
-    context "with a body that contains strings with invalid UTF-8 content" do
-      let(:string_with_invalid_utf8) { [0x61, 0x61, 0x85].pack("c*") }
-      let(:body) do
-        {
-          "field_one" => [0x61, 0x61].pack("c*"),
-          :field_two => string_with_invalid_utf8,
-          "field_three" => [
-            "one", string_with_invalid_utf8
-          ],
-          "field_four" => {
-            "one" => string_with_invalid_utf8
-          }
-        }
-      end
-
-      it "returns a JSON string with invalid UTF-8 content" do
-        is_expected.to eq %({"field_one":"aa","field_two":"aa�",) +
-          %("field_three":["one","aa�"],"field_four":{"one":"aa�"}})
-      end
-    end
-  end
-end

data/spec/lib/appsignal/utils/query_params_sanitizer_spec.rb

@@ -1,192 +0,0 @@
-describe Appsignal::Utils::QueryParamsSanitizer do
-  describe ".sanitize" do
-    context "when only_top_level = true" do
-      subject { described_class.sanitize(value, true) }
-
-      context "when value is a hash" do
-        let(:value) { { "foo" => "bar" } }
-
-        it "should only return the first level of the object" do
-          expect(subject).to eq("foo" => "?")
-        end
-
-        it "should not modify source value" do
-          subject
-          expect(value).to eq("foo" => "bar")
-        end
-      end
-
-      context "when value is a nested hash" do
-        let(:value) { { "foo" => { "bar" => "baz" } } }
-
-        it "should only return the first level of the object" do
-          expect(subject).to eq("foo" => "?")
-        end
-
-        it "should not modify source value" do
-          subject
-          expect(value).to eq("foo" => { "bar" => "baz" })
-        end
-      end
-
-      context "when value is an array of hashes" do
-        let(:value) { ["foo" => "bar"] }
-
-        it "should sanitize all hash values with a questionmark" do
-          expect(subject).to eq(["foo" => "?"])
-        end
-
-        it "should not modify source value" do
-          subject
-          expect(value).to eq(["foo" => "bar"])
-        end
-      end
-
-      context "when value is an array" do
-        let(:value) { %w[foo bar] }
-
-        it "sanitizes all array values" do
-          expect(subject).to eq(["?"])
-        end
-
-        it "should not modify source value" do
-          subject
-          expect(value).to eq(%w[foo bar])
-        end
-      end
-
-      context "when value is a mixed array" do
-        let(:value) { [nil, "foo", "bar"] }
-
-        it "should sanitize all array values with a single questionmark" do
-          expect(subject).to eq(["?"])
-        end
-      end
-
-      context "when value is a string" do
-        let(:value) { "foo" }
-
-        it "should sanitize all hash values with a questionmark" do
-          expect(subject).to eq("?")
-        end
-      end
-    end
-
-    context "when only_top_level = false" do
-      subject { described_class.sanitize(value, false) }
-
-      context "when value is a hash" do
-        let(:value) { { "foo" => "bar" } }
-
-        it "should sanitize all hash values with a questionmark" do
-          expect(subject).to eq("foo" => "?")
-        end
-
-        it "should not modify source value" do
-          subject
-          expect(value).to eq("foo" => "bar")
-        end
-      end
-
-      context "when value is a nested hash" do
-        let(:value) { { "foo" => { "bar" => "baz" } } }
-
-        it "should replaces values" do
-          expect(subject).to eq("foo" => { "bar" => "?" })
-        end
-
-        it "should not modify source value" do
-          subject
-          expect(value).to eq("foo" => { "bar" => "baz" })
-        end
-      end
-
-      context "when value is an array of hashes" do
-        let(:value) { ["foo" => "bar"] }
-
-        it "should sanitize all hash values with a questionmark" do
-          expect(subject).to eq(["foo" => "?"])
-        end
-
-        it "should not modify source value" do
-          subject
-          expect(value).to eq(["foo" => "bar"])
-        end
-      end
-
-      context "when value is an array" do
-        let(:value) { %w[foo bar] }
-
-        it "should sanitize all hash values with a single question mark" do
-          expect(subject).to eq(["?"])
-        end
-      end
-
-      context "when value is a mixed array" do
-        let(:value) { [nil, "foo", "bar"] }
-
-        it "should sanitize all hash values with a single question mark" do
-          expect(subject).to eq(["?"])
-        end
-      end
-
-      context "when value is a string" do
-        let(:value) { "bar" }
-
-        it "should sanitize all hash values with a questionmark" do
-          expect(subject).to eq("?")
-        end
-      end
-    end
-  end
-
-  describe "key_sanitizer option" do
-    context "without key_sanitizer" do
-      subject { described_class.sanitize(value) }
-
-      context "when dots are in the key" do
-        let(:value) { { "foo.bar" => "bar" } }
-
-        it "should not sanitize the key" do
-          expect(subject).to eql("foo.bar" => "?")
-        end
-      end
-
-      context "when key is a symbol" do
-        let(:value) { { :ismaster => "bar" } }
-
-        it "should sanitize the key" do
-          expect(subject).to eql(:ismaster => "?")
-        end
-      end
-    end
-
-    context "with mongodb key_sanitizer" do
-      subject { described_class.sanitize(value, false, :mongodb) }
-
-      context "when no dots are in the key" do
-        let(:value) { { "foo" => "bar" } }
-
-        it "should not sanitize the key" do
-          expect(subject).to eql("foo" => "?")
-        end
-      end
-
-      context "when dots are in the key" do
-        let(:value) { { "foo.bar" => "bar" } }
-
-        it "should sanitize the key" do
-          expect(subject).to eql("foo.?" => "?")
-        end
-      end
-
-      context "when key is a symbol" do
-        let(:value) { { :ismaster => "bar" } }
-
-        it "should sanitize the key" do
-          expect(subject).to eql("ismaster" => "?")
-        end
-      end
-    end
-  end
-end