appsignal 2.5.0.alpha.1-java

data/spec/lib/appsignal/transmitter_spec.rb

@@ -0,0 +1,152 @@
+describe Appsignal::Transmitter do
+  let(:config) { project_fixture_config }
+  let(:base_uri) { "action" }
+  let(:log) { StringIO.new }
+  let(:instance) { Appsignal::Transmitter.new(base_uri, config) }
+  before do
+    config.config_hash[:hostname] = "app1.local"
+    config.logger = Logger.new(log)
+  end
+
+  describe "#uri" do
+    let(:uri) { instance.uri }
+
+    it "returns a URI object with configuration data" do
+      expect(uri.to_s).to start_with(config[:endpoint])
+      expect(uri.path).to eq("/1/action")
+      expect(CGI.parse(uri.query)).to eq(
+        "api_key" => ["abc"],
+        "hostname" => ["app1.local"],
+        "name" => ["TestApp"],
+        "environment" => ["production"],
+        "gem_version" => [Appsignal::VERSION]
+      )
+    end
+
+    context "when base_uri argument is a full URI" do
+      let(:base_uri) { "http://foo.bar/path" }
+
+      it "uses the full URI" do
+        expect(uri.to_s).to start_with("#{base_uri}?")
+      end
+    end
+
+    context "when base_uri argument is only a path" do
+      it "uses the config[:endpoint] base" do
+        expect(uri.to_s).to start_with("#{config[:endpoint]}/1/#{base_uri}?")
+      end
+    end
+  end
+
+  describe "#transmit" do
+    before do
+      stub_request(:post, "https://push.appsignal.com/1/action").with(
+        :query => {
+          :api_key => "abc",
+          :environment => "production",
+          :gem_version => Appsignal::VERSION,
+          :hostname => config[:hostname],
+          :name => "TestApp"
+        },
+        :body => "{\"the\":\"payload\"}",
+        :headers => {
+          "Content-Type" => "application/json; charset=UTF-8"
+        }
+      ).to_return(:status => 200)
+    end
+    let(:response) { instance.transmit(:the => :payload) }
+
+    it "returns Net::HTTP response" do
+      expect(response).to be_kind_of(Net::HTTPResponse)
+      expect(response.code).to eq "200"
+    end
+
+    context "with ca_file_path config option set" do
+      context "when file does not exist" do
+        before do
+          config.config_hash[:ca_file_path] = File.join(resources_dir, "cacert.pem")
+        end
+
+        it "ignores the config and logs a warning" do
+          expect(response).to be_kind_of(Net::HTTPResponse)
+          expect(response.code).to eq "200"
+          expect(log.string).to_not include "Ignoring non-existing or unreadable " \
+            "`ca_file_path`: #{config[:ca_file_path]}"
+        end
+      end
+
+      context "when not existing file" do
+        before do
+          config.config_hash[:ca_file_path] = File.join(tmp_dir, "ca_file_that_does_not_exist")
+        end
+
+        it "ignores the config and logs a warning" do
+          expect(response).to be_kind_of(Net::HTTPResponse)
+          expect(response.code).to eq "200"
+          expect(log.string).to include "Ignoring non-existing or unreadable " \
+            "`ca_file_path`: #{config[:ca_file_path]}"
+        end
+      end
+
+      context "when not readable file" do
+        let(:file) { File.join(tmp_dir, "ca_file") }
+        before do
+          config.config_hash[:ca_file_path] = file
+          File.open(file, "w") { |f| f.chmod 0o000 }
+        end
+
+        it "ignores the config and logs a warning" do
+          expect(response).to be_kind_of(Net::HTTPResponse)
+          expect(response.code).to eq "200"
+          expect(log.string).to include "Ignoring non-existing or unreadable " \
+            "`ca_file_path`: #{config[:ca_file_path]}"
+        end
+
+        after { File.delete file }
+      end
+    end
+  end
+
+  describe "#http_post" do
+    subject { instance.send(:http_post, "the" => "payload") }
+
+    it "sets the path" do
+      expect(subject.path).to eq instance.uri.request_uri
+    end
+
+    it "sets the correct headers" do
+      expect(subject["Content-Type"]).to eq "application/json; charset=UTF-8"
+    end
+  end
+
+  describe "#http_client" do
+    subject { instance.send(:http_client) }
+
+    context "with a http uri" do
+      let(:config) { project_fixture_config("test") }
+
+      it { expect(subject).to be_instance_of(Net::HTTP) }
+      it { expect(subject.proxy?).to be_falsy }
+      it { expect(subject.use_ssl?).to be_falsy }
+    end
+
+    context "with a https uri" do
+      let(:config) { project_fixture_config("production") }
+
+      it { expect(subject).to be_instance_of(Net::HTTP) }
+      it { expect(subject.proxy?).to be_falsy }
+      it { expect(subject.use_ssl?).to be_truthy }
+      it { expect(subject.verify_mode).to eq OpenSSL::SSL::VERIFY_PEER }
+      it { expect(subject.ca_file).to eq config[:ca_file_path] }
+    end
+
+    context "with a proxy" do
+      let(:config) { project_fixture_config("production", :http_proxy => "http://localhost:8080") }
+
+      it { expect(subject).to be_instance_of(Net::HTTP) }
+      it { expect(subject.proxy?).to be_truthy }
+      it { expect(subject.proxy_address).to eq "localhost" }
+      it { expect(subject.proxy_port).to eq 8080 }
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+describe Appsignal::Utils::ParamsSanitizer do
+  let(:file) { uploaded_file }
+  let(:params) do
+    {
+      :text       => "string",
+      "string"    => "string key value",
+      :file       => file,
+      :float      => 0.0,
+      :bool_true  => true,
+      :bool_false => false,
+      :nil        => nil,
+      :int        => 1, # Fixnum
+      :int64      => 1 << 64, # Bignum
+      :hash       => {
+        :nested_text  => "string",
+        :nested_array => [
+          "something",
+          "else",
+          file,
+          {
+            :key  => "value",
+            :file => file
+          }
+        ]
+      }
+    }
+  end
+
+  describe ".sanitize" do
+    let(:sanitized_params) { described_class.sanitize(params) }
+    subject { sanitized_params }
+
+    it { is_expected.to be_instance_of Hash }
+    it { expect(subject[:text]).to eq("string") }
+    it { expect(subject["string"]).to eq("string key value") }
+    it do
+      expect(subject[:file]).to be_instance_of String
+      expect(subject[:file]).to include "::UploadedFile"
+    end
+    it { expect(subject[:float]).to eq(0.0) }
+    it { expect(subject[:bool_true]).to be(true) }
+    it { expect(subject[:bool_false]).to be(false) }
+    it { expect(subject[:nil]).to be_nil }
+    it { expect(subject[:int]).to eq(1) }
+    it { expect(subject[:int64]).to eq(1 << 64) }
+
+    it "does not change the original params" do
+      subject
+      expect(params[:file]).to eq(file)
+      expect(params[:hash][:nested_array][2]).to eq(file)
+    end
+
+    describe ":hash" do
+      subject { sanitized_params[:hash] }
+
+      it { is_expected.to be_instance_of Hash }
+      it { expect(subject[:nested_text]).to eq("string") }
+
+      describe ":nested_array" do
+        subject { sanitized_params[:hash][:nested_array] }
+
+        it { is_expected.to be_instance_of Array }
+        it { expect(subject[0]).to eq("something") }
+        it { expect(subject[1]).to eq("else") }
+        it do
+          expect(subject[2]).to be_instance_of String
+          expect(subject[2]).to include "::UploadedFile"
+        end
+
+        describe ":nested_hash" do
+          subject { sanitized_params[:hash][:nested_array][3] }
+
+          it { is_expected.to be_instance_of Hash }
+          it { expect(subject[:key]).to eq("value") }
+          it do
+            expect(subject[:file]).to be_instance_of String
+            expect(subject[:file]).to include "::UploadedFile"
+          end
+        end
+      end
+    end
+
+    context "with :filter_parameters option" do
+      let(:sanitized_params) do
+        described_class.sanitize(params, :filter_parameters => %w[text hash])
+      end
+      subject { sanitized_params }
+
+      it { expect(subject[:text]).to eq(described_class::FILTERED) }
+      it { expect(subject[:hash]).to eq(described_class::FILTERED) }
+      it do
+        expect(subject[:file]).to be_instance_of String
+        expect(subject[:file]).to include "::UploadedFile"
+      end
+      it { expect(subject[:float]).to eq(0.0) }
+      it { expect(subject[:bool_true]).to be(true) }
+      it { expect(subject[:bool_false]).to be(false) }
+      it { expect(subject[:nil]).to be_nil }
+      it { expect(subject[:int]).to eq(1) }
+
+      context "with strings as key filter values" do
+        let(:sanitized_params) do
+          described_class.sanitize(params, :filter_parameters => %w[string])
+        end
+
+        it "sanitizes values" do
+          expect(subject["string"]).to eq("[FILTERED]")
+        end
+      end
+
+      describe ":hash" do
+        let(:sanitized_params) do
+          described_class.sanitize(params, :filter_parameters => %w[nested_text])
+        end
+        subject { sanitized_params[:hash] }
+
+        it "sanitizes values in nested hashes" do
+          expect(subject[:nested_text]).to eq("[FILTERED]")
+        end
+
+        describe ":nested_array" do
+          describe ":nested_hash" do
+            let(:sanitized_params) do
+              described_class.sanitize(params, :filter_parameters => %w[key])
+            end
+            subject { sanitized_params[:hash][:nested_array][3] }
+
+            it "sanitizes values in deeply nested hashes and arrays" do
+              expect(subject[:key]).to eq("[FILTERED]")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+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 "should only return the first level of the object" 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 hash 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 questionmark" 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 questionmark" 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