appsignal 2.5.0.alpha.1-java

data/spec/lib/appsignal/cli/notify_of_deploy_spec.rb

@@ -0,0 +1,168 @@
+require "appsignal/cli"
+
+describe Appsignal::CLI::NotifyOfDeploy do
+  include CLIHelpers
+
+  let(:out_stream) { std_stream }
+  let(:output) { out_stream.read }
+
+  define :include_deploy_notification do
+    match do |log|
+      log.include?("Notifying AppSignal of deploy with: ") &&
+        log.include?("AppSignal has been notified of this deploy!")
+    end
+  end
+  define :include_deploy_notification_with do |options|
+    match do |log|
+      return false unless options
+      values = "revision: #{options[:revision]}, user: #{options[:user]}"
+      log.include?("Notifying AppSignal of deploy with: #{values}") &&
+        log.include?("AppSignal has been notified of this deploy!")
+    end
+  end
+  define :include_config_error do
+    match do |log|
+      log.include? "Error: No valid config found."
+    end
+  end
+  define :include_missing_options do |options|
+    match do |log|
+      log.include? "Error: Missing options: #{options.join(", ")}"
+    end
+  end
+
+  def run
+    capture_stdout(out_stream) do
+      run_cli("notify_of_deploy", options)
+    end
+  end
+
+  context "without config" do
+    let(:config) { Appsignal::Config.new(tmp_dir, "production") }
+    let(:options) { {} }
+    around do |example|
+      Dir.chdir tmp_dir do
+        example.run
+      end
+    end
+
+    it "prints a config error" do
+      expect { run }.to raise_error(SystemExit)
+      expect(output).to include_config_error
+      expect(output).to_not include_deploy_notification
+    end
+  end
+
+  context "with config" do
+    let(:config) { project_fixture_config }
+    before do
+      config[:name] = options[:name] if options[:name]
+      stub_api_request config, "markers", :revision => options[:revision],
+        :user => options[:user]
+    end
+    around do |example|
+      Dir.chdir project_fixture_path do
+        example.run
+      end
+    end
+
+    context "without environment" do
+      let(:options) { { :environment => "", :revision => "foo", :user => "thijs" } }
+      before do
+        # Makes the config "active"
+        ENV["APPSIGNAL_PUSH_API_KEY"] = "foo"
+      end
+
+      it "requires environment option" do
+        expect { run }.to raise_error(SystemExit)
+        expect(output).to include_missing_options(%w[environment])
+        expect(output).to_not include_deploy_notification
+      end
+    end
+
+    context "without known environment" do
+      let(:options) { { :environment => "foo" } }
+
+      it "prints a config error" do
+        expect { run }.to raise_error(SystemExit)
+        expect(output).to include_config_error
+        expect(output).to_not include_missing_options([])
+        expect(output).to_not include_deploy_notification
+      end
+    end
+
+    context "with known environment" do
+      context "without required options" do
+        let(:options) { { :environment => "production" } }
+
+        it "prints a missing required options error" do
+          expect { run }.to raise_error(SystemExit)
+          expect(output).to_not include_config_error
+          expect(output).to include_missing_options(%w[revision user])
+          expect(output).to_not include_deploy_notification
+        end
+
+        context "with empty required option" do
+          let(:options) { { :environment => "production", :revision => "foo", :user => "" } }
+
+          it "prints a missing required option error" do
+            expect { run }.to raise_error(SystemExit)
+            expect(output).to_not include_config_error
+            expect(output).to include_missing_options(%w[user])
+            expect(output).to_not include_deploy_notification
+          end
+        end
+      end
+
+      context "with required options" do
+        let(:options) { { :environment => "production", :revision => "aaaaa", :user => "thijs" } }
+
+        it "notifies of a deploy" do
+          run
+          expect(output).to_not include_config_error
+          expect(output).to_not include_missing_options([])
+          expect(output).to include_deploy_notification_with(options)
+        end
+
+        context "with no app name configured" do
+          before { ENV["APPSIGNAL_APP_NAME"] = "" }
+
+          context "without name option" do
+            let(:options) { { :environment => "production", :revision => "aaaaa", :user => "thijs" } }
+
+            it "requires name option" do
+              expect { run }.to raise_error(SystemExit)
+              expect(output).to_not include_config_error
+              expect(output).to include_missing_options(%w[name])
+              expect(output).to_not include_deploy_notification
+            end
+          end
+
+          context "with name option" do
+            let(:options) { { :environment => "production", :revision => "aaaaa", :user => "thijs", :name => "foo" } }
+
+            it "notifies of a deploy with a custom name" do
+              run
+              expect(output).to_not include_config_error
+              expect(output).to_not include_missing_options([])
+              expect(output).to include_deploy_notification_with(options)
+            end
+          end
+        end
+
+        context "with name option" do
+          let(:options) do
+            { :environment => "production", :revision => "aaaaa", :user => "thijs", :name => "foo" }
+          end
+
+          it "notifies of a deploy with a custom name" do
+            run
+            expect(output).to_not include_config_error
+            expect(output).to_not include_missing_options([])
+            expect(output).to include_deploy_notification_with(options)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/appsignal/cli_spec.rb

@@ -0,0 +1,56 @@
+require "appsignal/cli"
+
+describe Appsignal::CLI do
+  let(:out_stream) { std_stream }
+  let(:output) { out_stream.read }
+  let(:cli) { Appsignal::CLI }
+  before { allow(Dir).to receive(:pwd).and_return(project_fixture_path) }
+
+  it "should print the help with no arguments, -h and --help" do
+    [nil, "-h", "--help"].each do |arg|
+      expect do
+        capture_stdout(out_stream) do
+          cli.run([arg].compact)
+        end
+      end.to raise_error(SystemExit)
+
+      expect(output).to include "appsignal <command> [options]"
+      expect(output).to include \
+        "Available commands: demo, diagnose, install, notify_of_deploy"
+    end
+  end
+
+  it "should print the version with -v and --version" do
+    ["-v", "--version"].each do |arg|
+      expect do
+        capture_stdout(out_stream) do
+          cli.run([arg])
+        end
+      end.to raise_error(SystemExit)
+
+      expect(output).to include "AppSignal"
+      expect(output).to include "."
+    end
+  end
+
+  it "should print a notice if a command does not exist" do
+    expect do
+      capture_stdout(out_stream) do
+        cli.run(["nonsense"])
+      end
+    end.to raise_error(SystemExit)
+
+    expect(output).to include "Command 'nonsense' does not exist, run "\
+      "appsignal -h to see the help"
+  end
+
+  describe "diagnose" do
+    it "should call Appsignal::Diagnose.install" do
+      expect(Appsignal::CLI::Diagnose).to receive(:run)
+
+      cli.run([
+        "diagnose"
+      ])
+    end
+  end
+end

data/spec/lib/appsignal/config_spec.rb

@@ -0,0 +1,637 @@
+describe Appsignal::Config do
+  describe "#initialize" do
+    subject { config.env }
+
+    describe "environment" do
+      context "when environment is nil" do
+        let(:config) { described_class.new("", "") }
+
+        it "sets an empty string" do
+          expect(subject).to eq("")
+        end
+      end
+
+      context "when environment is given" do
+        let(:config) { described_class.new("", "my_env") }
+
+        it "sets the environment" do
+          expect(subject).to eq("my_env")
+        end
+
+        context "with APPSIGNAL_APP_ENV environment variable" do
+          before { ENV["APPSIGNAL_APP_ENV"] = "my_env_env" }
+
+          it "uses the environment variable" do
+            expect(subject).to eq("my_env_env")
+          end
+        end
+      end
+    end
+  end
+
+  describe "config based on the system" do
+    let(:config) { project_fixture_config(:none) }
+
+    describe ":active" do
+      subject { config[:active] }
+
+      context "with APPSIGNAL_PUSH_API_KEY env variable" do
+        before { ENV["APPSIGNAL_PUSH_API_KEY"] = "abc" }
+
+        it "becomes active" do
+          expect(subject).to be_truthy
+        end
+      end
+
+      context "without APPSIGNAL_PUSH_API_KEY env variable" do
+        it "remains inactive" do
+          expect(subject).to be_falsy
+        end
+      end
+    end
+
+    describe ":log" do
+      subject { config[:log] }
+
+      context "when running on Heroku" do
+        around { |example| recognize_as_heroku { example.run } }
+
+        it "is set to stdout" do
+          expect(subject).to eq("stdout")
+        end
+      end
+
+      context "when not running on Heroku" do
+        it "is set to file" do
+          expect(subject).to eq("file")
+        end
+      end
+    end
+  end
+
+  describe "initial config" do
+    let(:config) do
+      described_class.new(
+        "non-existing-path",
+        "production",
+        :push_api_key => "abc",
+        :name => "TestApp",
+        :active => true
+      )
+    end
+
+    it "merges with the default config" do
+      expect(config.config_hash).to eq(
+        :debug                          => false,
+        :log                            => "file",
+        :ignore_actions                 => [],
+        :ignore_errors                  => [],
+        :ignore_namespaces              => [],
+        :filter_parameters              => [],
+        :instrument_net_http            => true,
+        :instrument_redis               => true,
+        :instrument_sequel              => true,
+        :skip_session_data              => false,
+        :send_params                    => true,
+        :endpoint                       => "https://push.appsignal.com",
+        :push_api_key                   => "abc",
+        :name                           => "TestApp",
+        :active                         => true,
+        :enable_frontend_error_catching => false,
+        :frontend_error_catching_path   => "/appsignal_error_catcher",
+        :enable_allocation_tracking     => true,
+        :enable_gc_instrumentation      => false,
+        :enable_host_metrics            => true,
+        :enable_minutely_probes         => false,
+        :hostname                       => Socket.gethostname,
+        :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
+        :dns_servers                    => [],
+        :files_world_accessible         => true
+      )
+    end
+
+    describe "overriding system detected config" do
+      describe ":running_in_container" do
+        let(:config) do
+          described_class.new(
+            "non-existing-path",
+            "production",
+            :running_in_container => true
+          )
+        end
+        subject { config[:running_in_container] }
+
+        it "overrides system detected config" do
+          expect(subject).to be_truthy
+        end
+      end
+
+      describe ":active" do
+        subject { config[:active] }
+
+        context "with APPSIGNAL_PUSH_API_KEY env variable" do
+          let(:config) do
+            described_class.new(
+              "non-existing-path",
+              "production",
+              :active => false
+            )
+          end
+          before { ENV["APPSIGNAL_PUSH_API_KEY"] = "abc" }
+
+          it "sets given config rather than env variable" do
+            expect(subject).to be_falsy
+          end
+        end
+      end
+    end
+  end
+
+  context "when root path is nil" do
+    let(:config) { described_class.new(nil, "production") }
+
+    it "is not valid or active" do
+      expect(config.valid?).to be_falsy
+      expect(config.active?).to be_falsy
+    end
+  end
+
+  context "without config file" do
+    let(:config) { described_class.new(tmp_dir, "production") }
+
+    it "is not valid or active" do
+      expect(config.valid?).to be_falsy
+      expect(config.active?).to be_falsy
+    end
+  end
+
+  context "with a config file" do
+    let(:config) { project_fixture_config("production") }
+
+    it "is not valid or active" do
+      expect(config.valid?).to be_truthy
+      expect(config.active?).to be_truthy
+    end
+
+    it "does not log an error" do
+      expect_any_instance_of(Logger).to_not receive(:error)
+      config
+    end
+
+    describe "overriding system and defaults config" do
+      let(:config) do
+        described_class.new(
+          "non-existing-path",
+          "production",
+          :running_in_container => true,
+          :debug => true
+        )
+      end
+
+      it "overrides system detected and defaults config" do
+        expect(config[:running_in_container]).to be_truthy
+        expect(config[:debug]).to be_truthy
+      end
+    end
+
+    context "with the env name as a symbol" do
+      let(:config) { project_fixture_config(:production) }
+
+      it "loads the config" do
+        expect(config.valid?).to be_truthy
+        expect(config.active?).to be_truthy
+
+        expect(config[:push_api_key]).to eq("abc")
+      end
+    end
+
+    context "without the selected env" do
+      let(:config) { project_fixture_config("nonsense") }
+
+      it "is not valid or active" do
+        expect(config.valid?).to be_falsy
+        expect(config.active?).to be_falsy
+      end
+
+      it "logs an error" do
+        expect_any_instance_of(Logger).to receive(:error).once
+          .with("Not loading from config file: config for 'nonsense' not found")
+        expect_any_instance_of(Logger).to receive(:error).once
+          .with("Push api key not set after loading config")
+        config
+      end
+    end
+
+    describe "support for old config keys" do
+      let(:config) { project_fixture_config(env, {}, test_logger(log)) }
+      let(:log) { StringIO.new }
+
+      describe ":api_key" do
+        context "without :push_api_key" do
+          let(:env) { "old_config" }
+
+          it "sets the :push_api_key with the old :api_key value" do
+            expect(config[:push_api_key]).to eq "def"
+            expect(config.config_hash).to_not have_key :api_key
+            expect(log_contents(log)).to contains_log :warn,
+              "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
+          end
+        end
+
+        context "with :push_api_key" do
+          let(:env) { "old_config_mixed_with_new_config" }
+
+          it "ignores the :api_key config and deletes it" do
+            expect(config[:push_api_key]).to eq "ghi"
+            expect(config.config_hash).to_not have_key :api_key
+            expect(log_contents(log)).to contains_log :warn,
+              "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
+          end
+        end
+      end
+
+      describe ":ignore_exceptions" do
+        context "without :ignore_errors" do
+          let(:env) { "old_config" }
+
+          it "sets :ignore_errors with the old :ignore_exceptions value" do
+            expect(config[:ignore_errors]).to eq ["StandardError"]
+            expect(config.config_hash).to_not have_key :ignore_exceptions
+            expect(log_contents(log)).to contains_log :warn,
+              "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
+          end
+        end
+
+        context "with :ignore_errors" do
+          let(:env) { "old_config_mixed_with_new_config" }
+
+          it "ignores the :ignore_exceptions config" do
+            expect(config[:ignore_errors]).to eq ["NoMethodError"]
+            expect(config.config_hash).to_not have_key :ignore_exceptions
+            expect(log_contents(log)).to contains_log :warn,
+              "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
+          end
+        end
+      end
+    end
+  end
+
+  context "with config in the environment" do
+    let(:config) do
+      described_class.new(
+        "non-existing-path",
+        "production",
+        :running_in_container => true,
+        :debug => true
+      )
+    end
+    before do
+      ENV["APPSIGNAL_RUNNING_IN_CONTAINER"]    = "true"
+      ENV["APPSIGNAL_PUSH_API_KEY"]            = "aaa-bbb-ccc"
+      ENV["APPSIGNAL_ACTIVE"]                  = "true"
+      ENV["APPSIGNAL_APP_NAME"]                = "App name"
+      ENV["APPSIGNAL_DEBUG"]                   = "true"
+      ENV["APPSIGNAL_IGNORE_ACTIONS"]          = "action1,action2"
+      ENV["APPSIGNAL_IGNORE_ERRORS"]           = "ExampleStandardError,AnotherError"
+      ENV["APPSIGNAL_IGNORE_NAMESPACES"]       = "admin,private_namespace"
+      ENV["APPSIGNAL_INSTRUMENT_NET_HTTP"]     = "false"
+      ENV["APPSIGNAL_INSTRUMENT_REDIS"]        = "false"
+      ENV["APPSIGNAL_INSTRUMENT_SEQUEL"]       = "false"
+      ENV["APPSIGNAL_FILES_WORLD_ACCESSIBLE"]  = "false"
+    end
+
+    it "overrides config with environment values" do
+      expect(config.valid?).to be_truthy
+      expect(config.active?).to be_truthy
+
+      expect(config[:running_in_container]).to be_truthy
+      expect(config[:push_api_key]).to eq "aaa-bbb-ccc"
+      expect(config[:active]).to eq(true)
+      expect(config[:name]).to eq "App name"
+      expect(config[:debug]).to eq(true)
+      expect(config[:ignore_actions]).to eq %w[action1 action2]
+      expect(config[:ignore_errors]).to eq %w[ExampleStandardError AnotherError]
+      expect(config[:ignore_namespaces]).to eq %w[admin private_namespace]
+      expect(config[:instrument_net_http]).to eq(false)
+      expect(config[:instrument_redis]).to eq(false)
+      expect(config[:instrument_sequel]).to eq(false)
+      expect(config[:files_world_accessible]).to eq(false)
+    end
+
+    context "with mixed case `true` env variables values" do
+      before do
+        ENV["APPSIGNAL_DEBUG"] = "TRUE"
+        ENV["APPSIGNAL_INSTRUMENT_SEQUEL"] = "True"
+      end
+
+      it "accepts mixed case `true` values" do
+        expect(config[:debug]).to eq(true)
+        expect(config[:instrument_sequel]).to eq(true)
+      end
+    end
+  end
+
+  describe "config keys" do
+    describe ":endpoint" do
+      subject { config[:endpoint] }
+
+      context "with an pre-0.12-style endpoint" do
+        let(:config) do
+          project_fixture_config("production", :endpoint => "https://push.appsignal.com/1")
+        end
+
+        it "strips off the path" do
+          expect(subject).to eq "https://push.appsignal.com"
+        end
+      end
+
+      context "with a non-standard port" do
+        let(:config) { project_fixture_config("production", :endpoint => "http://localhost:4567") }
+
+        it "keeps the port" do
+          expect(subject).to eq "http://localhost:4567"
+        end
+      end
+    end
+  end
+
+  describe "#[]" do
+    let(:config) { project_fixture_config(:none, :push_api_key => "foo") }
+
+    context "with existing key" do
+      it "gets the value" do
+        expect(config[:push_api_key]).to eq "foo"
+      end
+    end
+
+    context "without existing key" do
+      it "returns nil" do
+        expect(config[:nonsense]).to be_nil
+      end
+    end
+  end
+
+  describe "#[]=" do
+    let(:config) { project_fixture_config(:none) }
+
+    context "with existing key" do
+      it "changes the value" do
+        expect(config[:push_api_key]).to be_nil
+        config[:push_api_key] = "abcde"
+        expect(config[:push_api_key]).to eq "abcde"
+      end
+    end
+
+    context "with new key" do
+      it "sets the value" do
+        expect(config[:foo]).to be_nil
+        config[:foo] = "bar"
+        expect(config[:foo]).to eq "bar"
+      end
+    end
+  end
+
+  describe "#write_to_environment" do
+    let(:config) { project_fixture_config(:production) }
+    before do
+      config[:http_proxy] = "http://localhost"
+      config[:ignore_actions] = %w[action1 action2]
+      config[:ignore_errors] = %w[ExampleStandardError AnotherError]
+      config[:ignore_namespaces] = %w[admin private_namespace]
+      config[:log] = "stdout"
+      config[:log_path] = "/tmp"
+      config[:hostname] = "app1.local"
+      config[:filter_parameters] = %w[password confirm_password]
+      config[:running_in_container] = false
+      config[:dns_servers] = ["8.8.8.8", "8.8.4.4"]
+      config.write_to_environment
+    end
+
+    it "writes the current config to environment variables" do
+      expect(ENV["_APPSIGNAL_ACTIVE"]).to                       eq "true"
+      expect(ENV["_APPSIGNAL_APP_PATH"]).to                     end_with("spec/support/project_fixture")
+      expect(ENV["_APPSIGNAL_AGENT_PATH"]).to                   end_with("/ext")
+      expect(ENV["_APPSIGNAL_DEBUG_LOGGING"]).to                eq "false"
+      expect(ENV["_APPSIGNAL_LOG"]).to                          eq "stdout"
+      expect(ENV["_APPSIGNAL_LOG_FILE_PATH"]).to                end_with("/tmp/appsignal.log")
+      expect(ENV["_APPSIGNAL_PUSH_API_ENDPOINT"]).to            eq "https://push.appsignal.com"
+      expect(ENV["_APPSIGNAL_PUSH_API_KEY"]).to                 eq "abc"
+      expect(ENV["_APPSIGNAL_APP_NAME"]).to                     eq "TestApp"
+      expect(ENV["_APPSIGNAL_ENVIRONMENT"]).to                  eq "production"
+      expect(ENV["_APPSIGNAL_AGENT_VERSION"]).to                eq Appsignal::Extension.agent_version
+      expect(ENV["_APPSIGNAL_LANGUAGE_INTEGRATION_VERSION"]).to eq "ruby-#{Appsignal::VERSION}"
+      expect(ENV["_APPSIGNAL_HTTP_PROXY"]).to                   eq "http://localhost"
+      expect(ENV["_APPSIGNAL_IGNORE_ACTIONS"]).to               eq "action1,action2"
+      expect(ENV["_APPSIGNAL_IGNORE_ERRORS"]).to                eq "ExampleStandardError,AnotherError"
+      expect(ENV["_APPSIGNAL_IGNORE_NAMESPACES"]).to            eq "admin,private_namespace"
+      expect(ENV["_APPSIGNAL_FILTER_PARAMETERS"]).to            eq "password,confirm_password"
+      expect(ENV["_APPSIGNAL_SEND_PARAMS"]).to                  eq "true"
+      expect(ENV["_APPSIGNAL_RUNNING_IN_CONTAINER"]).to         eq "false"
+      expect(ENV["_APPSIGNAL_ENABLE_HOST_METRICS"]).to          eq "true"
+      expect(ENV["_APPSIGNAL_ENABLE_MINUTELY_PROBES"]).to       eq "false"
+      expect(ENV["_APPSIGNAL_HOSTNAME"]).to                     eq "app1.local"
+      expect(ENV["_APPSIGNAL_PROCESS_NAME"]).to                 include "rspec"
+      expect(ENV["_APPSIGNAL_CA_FILE_PATH"]).to                 eq File.join(resources_dir, "cacert.pem")
+      expect(ENV["_APPSIGNAL_DNS_SERVERS"]).to                  eq "8.8.8.8,8.8.4.4"
+      expect(ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]).to       eq "true"
+      expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIR_PATH")
+    end
+
+    context "with :working_dir_path" do
+      before do
+        config[:working_dir_path] = "/tmp/appsignal2"
+        config.write_to_environment
+      end
+
+      it "sets the modified :working_dir_path" do
+        expect(ENV["_APPSIGNAL_WORKING_DIR_PATH"]).to eq "/tmp/appsignal2"
+      end
+    end
+  end
+
+  describe "#log_file_path" do
+    let(:out_stream) { std_stream }
+    let(:output) { out_stream.read }
+    let(:config) { project_fixture_config("production", :log_path => log_path) }
+    subject { capture_stdout(out_stream) { config.log_file_path } }
+
+    context "when path is writable" do
+      let(:log_path) { File.join(tmp_dir, "writable-path") }
+      before { FileUtils.mkdir_p(log_path, :mode => 0o755) }
+      after { FileUtils.rm_rf(log_path) }
+
+      it "returns log file path" do
+        expect(subject).to eq File.join(log_path, "appsignal.log")
+      end
+
+      it "prints no warning" do
+        subject
+        expect(output).to be_empty
+      end
+    end
+
+    shared_examples "#log_file_path: tmp path" do
+      let(:system_tmp_dir) { described_class.system_tmp_dir }
+      before { FileUtils.mkdir_p(system_tmp_dir) }
+      after { FileUtils.rm_rf(system_tmp_dir) }
+
+      context "when the /tmp fallback path is writable" do
+        before { FileUtils.chmod(0o777, system_tmp_dir) }
+
+        it "returns returns the tmp location" do
+          expect(subject).to eq(File.join(system_tmp_dir, "appsignal.log"))
+        end
+
+        it "prints a warning" do
+          subject
+          expect(output).to include "appsignal: Unable to log to '#{log_path}'. "\
+            "Logging to '#{system_tmp_dir}' instead."
+        end
+      end
+
+      context "when the /tmp fallback path is not writable" do
+        before { FileUtils.chmod(0o555, system_tmp_dir) }
+
+        it "returns nil" do
+          expect(subject).to be_nil
+        end
+
+        it "prints a warning" do
+          subject
+          expect(output).to include "appsignal: Unable to log to '#{log_path}' "\
+            "or the '#{system_tmp_dir}' fallback."
+        end
+      end
+    end
+
+    context "when path is nil" do
+      let(:log_path) { nil }
+
+      context "when root_path is nil" do
+        before { allow(config).to receive(:root_path).and_return(nil) }
+
+        include_examples "#log_file_path: tmp path"
+      end
+
+      context "when root_path is set" do
+        it "returns returns the project log location" do
+          expect(subject).to eq File.join(config.root_path, "log/appsignal.log")
+        end
+
+        it "prints no warning" do
+          subject
+          expect(output).to be_empty
+        end
+      end
+    end
+
+    context "when path does not exist" do
+      let(:log_path) { "/non-existing" }
+
+      include_examples "#log_file_path: tmp path"
+    end
+
+    context "when path is not writable" do
+      let(:log_path) { File.join(tmp_dir, "not-writable-path") }
+      before { FileUtils.mkdir_p(log_path, :mode => 0o555) }
+      after { FileUtils.rm_rf(log_path) }
+
+      include_examples "#log_file_path: tmp path"
+    end
+
+    context "when path is a symlink" do
+      context "when linked path does not exist" do
+        let(:real_path) { File.join(tmp_dir, "real-path") }
+        let(:log_path) { File.join(tmp_dir, "symlink-path") }
+        before { File.symlink(real_path, log_path) }
+        after { FileUtils.rm(log_path) }
+
+        include_examples "#log_file_path: tmp path"
+      end
+
+      context "when linked path exists" do
+        context "when linked path is not writable" do
+          let(:real_path) { File.join(tmp_dir, "real-path") }
+          let(:log_path) { File.join(tmp_dir, "symlink-path") }
+          before do
+            FileUtils.mkdir_p(real_path)
+            FileUtils.chmod(0o444, real_path)
+            File.symlink(real_path, log_path)
+          end
+          after do
+            FileUtils.rm_rf(real_path)
+            FileUtils.rm(log_path)
+          end
+
+          include_examples "#log_file_path: tmp path"
+        end
+
+        context "when linked path is writable" do
+          let(:real_path) { File.join(tmp_dir, "real-path") }
+          let(:log_path) { File.join(tmp_dir, "symlink-path") }
+          before do
+            FileUtils.mkdir_p(real_path)
+            File.symlink(real_path, log_path)
+          end
+          after do
+            FileUtils.rm_rf(real_path)
+            FileUtils.rm(log_path)
+          end
+
+          it "returns real path of log path" do
+            expect(subject).to eq(File.join(real_path, "appsignal.log"))
+          end
+        end
+      end
+    end
+  end
+
+  describe ".system_tmp_dir" do
+    before do
+      # To counteract the stub in spec_helper
+      expect(Appsignal::Config).to receive(:system_tmp_dir).and_call_original
+    end
+
+    context "when on a *NIX OS" do
+      before do
+        expect(Gem).to receive(:win_platform?).and_return(false)
+      end
+
+      it "returns the system's tmp dir" do
+        expect(described_class.system_tmp_dir).to eq(File.realpath("/tmp"))
+      end
+    end
+
+    context "when on Microsoft Windows" do
+      before do
+        expect(Gem).to receive(:win_platform?).and_return(true)
+      end
+
+      it "returns the system's tmp dir" do
+        expect(described_class.system_tmp_dir).to eq(Dir.tmpdir)
+      end
+    end
+  end
+
+  describe "#validate" do
+    before { config.validate }
+    subject { config.valid? }
+    let(:config) { described_class.new(Dir.pwd, "production", :push_api_key => push_api_key) }
+
+    context "with missing push_api_key" do
+      let(:push_api_key) { nil }
+
+      it "sets valid to false" do
+        is_expected.to eq(false)
+      end
+    end
+
+    context "with push_api_key present" do
+      let(:push_api_key) { "abc" }
+
+      it "sets valid to true" do
+        is_expected.to eq(true)
+      end
+    end
+  end
+end