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

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

@@ -24,9 +24,22 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
   describe ".run" do
     let(:out_stream) { std_stream }
     let(:output) { out_stream.read }
-    let(:config) { project_fixture_config }
+    let(:root_path) { project_fixture_path }
+    let(:app_name) { "TestApp" }
+    let(:push_api_key) { "abc" }
+    let(:environment) { "production" }
+    let(:config) do
+      {
+        :root_path => root_path,
+        :environment => environment.to_s,
+        :name => app_name,
+        :endpoint => Appsignal::Config::DEFAULT_CONFIG[:endpoint],
+        :push_api_key => push_api_key,
+        :hostname => nil
+      }
+    end
     let(:cli_class) { described_class }
-    let(:options) { { :environment => config.env } }
+    let(:options) { { :environment => environment } }
     let(:gem_path) { Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip }
     let(:received_report) { DiagnosticsReportEndpoint.received_report }
     let(:process_user) { Etc.getpwuid(Process.uid).name }
@@ -43,7 +56,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       end
 
       if DependencyHelper.rails_present?
-        allow(Rails).to receive(:root).and_return(Pathname.new(config.root_path))
+        allow(Rails).to receive(:root).and_return(Pathname.new(config[:root_path]))
       end
     end
     around do |example|
@@ -52,6 +65,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       example.run
       $stdin = original_stdin
     end
+    before { clear_integration_env_vars! }
     before :api_stub => true do
       stub_api_request config, "auth"
     end
@@ -87,7 +101,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       stub_request(:post, "https://appsignal.com/diag").with(
         :query => {
           :api_key => config[:push_api_key],
-          :environment => config.env,
+          :environment => config[:environment],
           :gem_version => Appsignal::VERSION,
           :hostname => config[:hostname],
           :name => config[:name]
@@ -114,7 +128,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
     it "logs to the log file" do
       run
-      log_contents = File.read(config.log_file_path)
+      log_contents = File.read(Appsignal.config.log_file_path)
       expect(log_contents).to contains_log :info, "Starting AppSignal diagnose"
     end
 
@@ -466,15 +480,6 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       end
 
       context "when the extension returns invalid JSON" do
-        # The JSON gem reworded this error in version 2.10. Accept the wording
-        # from before that release and the wording from after it.
-        let(:parse_error) do
-          Regexp.union(
-            "unexpected token at 'invalid agent\njson'",
-            "unexpected character: 'invalid' at line 1 column 1"
-          )
-        end
-
         before do
           expect(Appsignal::Extension).to receive(:diagnose).and_return("invalid agent\njson")
           run
@@ -485,11 +490,12 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
             "Agent diagnostics",
             "  Error while parsing agent diagnostics report:",
             "    Output: invalid agent\njson"
-          expect(output).to match(/Error:( \d+:)? #{parse_error}/)
+          expect(output).to match(/Error:( \d+:)? unexpected token at 'invalid agent\njson'/)
         end
 
         it "adds the output to the report" do
-          expect(received_report["agent"]["error"]).to match(parse_error)
+          expect(received_report["agent"]["error"])
+            .to match(/unexpected token at 'invalid agent\njson'/)
           expect(received_report["agent"]["output"]).to eq(["invalid agent", "json"])
         end
       end
@@ -749,7 +755,9 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
     describe "configuration" do
       context "without environment" do
-        let(:config) { project_fixture_config(nil) }
+        let(:app_name) { nil }
+        let(:environment) { nil }
+        let(:push_api_key) { nil }
         let(:options) { {} }
         let(:warning_message) do
           "    Warning: No environment set, no config loaded!\n" \
@@ -787,13 +795,12 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
             "sources" => {
               "default" => default_config,
               "system" => {},
+              "loaders" => {},
               "initial" => { "env" => "" },
               "file" => {},
               "env" => {},
-              "override" => { "send_session_data" => true }
-            },
-            "modifiers" => {
-              "APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR" => ""
+              "override" => {},
+              "dsl" => {}
             }
           )
         end
@@ -811,13 +818,13 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
             it "outputs the label source after the value" do
               expect(output).to include(
-                %(environment: "#{Appsignal.config.env}" (Loaded from: initial)\n)
+                %(environment: "#{environment}" (Loaded from: initial)\n)
               )
             end
           end
 
           context "when the source is the RACK_ENV env variable", :send_report => :no_cli_option do
-            let(:config) { project_fixture_config("rack_env") }
+            let(:environment) { "rack_env" }
             let(:options) { {} }
             before do
               ENV["RACK_ENV"] = "rack_env"
@@ -833,10 +840,9 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           end
 
           context "when the source is the RAILS_ENV env variable", :send_report => :no_cli_option do
-            let(:config) { project_fixture_config("rails_env") }
+            let(:environment) { "rails_env" }
             let(:options) { {} }
             before do
-              ENV.delete("RACK_ENV")
               ENV["RAILS_ENV"] = "rails_env"
               run
             end
@@ -850,10 +856,9 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           end
 
           context "when the source is multiple sources" do
-            let(:options) { { :environment => "development" } }
+            let(:options) { { :environment => "production" } }
             before do
-              ENV["APPSIGNAL_APP_ENV"] = "production"
-              config.instance_variable_set(:@env, ENV.fetch("APPSIGNAL_APP_ENV", nil))
+              ENV["APPSIGNAL_APP_ENV"] = "development"
               stub_api_request(config, "auth").to_return(:status => 200)
               capture_diagnatics_report_request
               run
@@ -863,8 +868,8 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
               expect(output).to include(
                 "  environment: \"production\"\n" \
                   "    Sources:\n" \
-                  "      initial: \"development\"\n" \
-                  "      env:     \"production\"\n"
+                  "      initial: \"production\"\n" \
+                  "      env:     \"development\"\n"
               )
             end
           end
@@ -888,98 +893,109 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
             context "when the source is only default" do
               it "does not print a source" do
-                expect(output).to include("debug: #{Appsignal.config[:debug]}\n")
+                expect(output)
+                  .to include("enable_host_metrics: #{Appsignal.config[:enable_host_metrics]}\n")
               end
             end
           end
 
           context "when the source is multiple sources" do
+            let(:app_name) { "MyApp" }
             before do
-              ENV["APPSIGNAL_APP_NAME"] = "MyApp"
-              config[:name] = ENV.fetch("APPSIGNAL_APP_NAME", nil)
-              stub_api_request(config, "auth").to_return(:status => 200)
-              capture_diagnatics_report_request
+              ENV["APPSIGNAL_APP_NAME"] = app_name
               run
             end
 
-            if DependencyHelper.rails_present?
-              it "outputs a list of sources with their values" do
-                expect(output).to include(
-                  "  name: \"MyApp\"\n" \
-                    "    Sources:\n" \
-                    "      initial: \"MyApp\"\n" \
-                    "      file:    \"TestApp\"\n" \
-                    "      env:     \"MyApp\"\n"
-                )
+            it "outputs a list of sources with their values" do
+              expect(output).to include(
+                "  name: \"MyApp\"\n" \
+                  "    Sources:\n" \
+                  "      file: \"TestApp\"\n" \
+                  "      env:  \"MyApp\"\n"
+              )
+            end
+          end
+
+          if DependencyHelper.rails_present?
+            context "when is a Rails app" do
+              let(:root_path) { rails_project_fixture_path }
+              let(:app_name) { "TestApp" }
+              let(:environment) { "test" }
+              let(:options) { {} }
+              before do
+                # Workaround to not being able to require the railtie file
+                # multiple times and triggering the Rails initialization process.
+                # This will be used whtn the MyApp app has already been loaded.
+                Appsignal::Integrations::Railtie.load_default_config if defined?(MyApp)
+                run_within_dir(root_path)
               end
-            else
-              it "outputs a list of sources with their values" do
+
+              it "includes the Rails default config in the output and transmitted report" do
                 expect(output).to include(
-                  "  name: \"MyApp\"\n" \
+                  "  name: \"TestApp\"\n" \
                     "    Sources:\n" \
-                    "      file: \"TestApp\"\n" \
-                    "      env:  \"MyApp\"\n"
+                    "      loaders: \"MyApp\"\n" \
+                    "      file:    \"TestApp\"\n"
                 )
-              end
-            end
-          end
-        end
-
-        describe "modifiers" do
-          before do
-            ENV["APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR"] = "1"
-            run
-          end
 
-          it "outputs config modifiers" do
-            expect(output).to include(
-              "Configuration modifiers\n" \
-                "  APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR: \"1\""
-            )
-          end
+                expect(received_report["app"]["rails"]).to be(true)
+                expect(received_report["config"]["sources"]).to include(
+                  "loaders" => {
+                    "root_path" => root_path,
+                    "env" => "test",
+                    "log_path" => File.join(rails_project_fixture_path, "log"),
+                    "name" => "MyApp"
+                  }
+                )
+              end
 
-          it "transmits config modifiers in report" do
-            expect(received_report["config"]).to include(
-              "modifiers" => {
-                "APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR" => "1"
-              }
-            )
+              context "when there's a problem loading the app" do
+                before do
+                  # A spot where we can mock an error raise
+                  expect(Appsignal::Utils::RailsHelper).to receive(:environment_config_path)
+                    .and_raise(ExampleStandardError, "error message", ["line 1", "line 2"])
+                  run_within_dir(root_path)
+                end
+
+                it "includes a load error" do
+                  expect(output).to include(
+                    "ERROR: Error encountered while loading the Rails app\n" \
+                      "ExampleStandardError: error message"
+                  )
+
+                  pp received_report["app"]
+                  expect(received_report["app"]["load_error"])
+                    .to eq("ExampleStandardError: error message\nline 1\nline 2")
+                end
+              end
+            end
           end
         end
 
         it "transmits config in report" do
           run
-          additional_initial_config = {}
-          if DependencyHelper.rails_present?
-            additional_initial_config = {
-              :name => "MyApp",
-              :log_path => File.join(Rails.root, "log")
-            }
-          end
-          final_config = { "env" => "production" }
-            .merge(additional_initial_config)
-            .merge(config.config_hash)
+          final_config = Appsignal.config.config_hash
+            .merge(:env => "production")
           expect(received_report["config"]).to match(
             "options" => hash_with_string_keys(final_config),
             "sources" => {
               "default" => hash_with_string_keys(Appsignal::Config::DEFAULT_CONFIG),
               "system" => {},
-              "initial" => hash_with_string_keys(
-                config.initial_config.merge(additional_initial_config)
-              ),
-              "file" => hash_with_string_keys(config.file_config),
+              "loaders" => {},
+              "initial" => hash_with_string_keys(Appsignal.config.initial_config),
+              "file" => hash_with_string_keys(Appsignal.config.file_config),
               "env" => {},
-              "override" => { "send_session_data" => true }
-            },
-            "modifiers" => {
-              "APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR" => ""
+              "override" => {},
+              "dsl" => {}
             }
           )
         end
       end
 
       context "with unconfigured environment" do
-        let(:config) { project_fixture_config("foobar") }
+        let(:app_name) { nil }
+        let(:push_api_key) { nil }
+        let(:environment) { "foobar" }
         before { run_within_dir tmp_dir }
 
         it "outputs environment" do
@@ -993,17 +1009,18 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
         it "transmits config in report" do
           expect(received_report["config"]).to match(
-            "options" => hash_with_string_keys(config.config_hash).merge("env" => "foobar"),
+            "options" => hash_with_string_keys(
+              Appsignal.config.config_hash.merge("env" => "foobar")
+            ),
             "sources" => {
               "default" => hash_with_string_keys(Appsignal::Config::DEFAULT_CONFIG),
               "system" => {},
-              "initial" => hash_with_string_keys(config.initial_config),
-              "file" => hash_with_string_keys(config.file_config),
+              "loaders" => {},
+              "initial" => hash_with_string_keys(Appsignal.config.initial_config),
+              "file" => hash_with_string_keys(Appsignal.config.file_config),
               "env" => {},
-              "override" => { "send_session_data" => true }
-            },
-            "modifiers" => {
-              "APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR" => ""
+              "override" => {},
+              "dsl" => {}
             }
           )
         end
@@ -1116,18 +1133,9 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
     end
 
     describe "paths" do
-      let(:config) { Appsignal::Config.new(root_path, "production") }
-      let(:root_path) { tmp_dir }
-      let(:system_tmp_dir) { Appsignal::Config.system_tmp_dir }
-      before do
-        FileUtils.mkdir_p(root_path)
-        FileUtils.mkdir_p(system_tmp_dir)
-      end
-      after { FileUtils.rm_rf([root_path, system_tmp_dir]) }
-
       describe "report" do
         it "adds paths to the report" do
-          run_within_dir root_path
+          run
           expect(received_report["paths"].keys).to match_array(
             %w[
               package_install_path root_path working_dir log_dir_path
@@ -1137,15 +1145,15 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         end
 
         describe "working_dir" do
-          before { run_within_dir root_path }
+          before { run }
 
           it "outputs current path" do
-            expect(output).to include %(Current working directory\n    Path: "#{tmp_dir}")
+            expect(output).to include %(Current working directory\n    Path: "#{root_path}")
           end
 
           it "transmits path data in report" do
             expect(received_report["paths"]["working_dir"]).to match(
-              "path" => tmp_dir,
+              "path" => root_path,
               "exists" => true,
               "type" => "directory",
               "mode" => kind_of(String),
@@ -1161,7 +1169,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         end
 
         describe "root_path" do
-          before { run_within_dir root_path }
+          before { run }
 
           it "outputs root path" do
             expect(output).to include %(Root path\n    Path: "#{root_path}")
@@ -1185,7 +1193,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         end
 
         describe "package_install_path" do
-          before { run_within_dir root_path }
+          before { run }
 
           it "outputs gem install path" do
             expect(output).to match %(AppSignal gem path\n    Path: "#{gem_path}")
@@ -1209,15 +1217,16 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         end
 
         describe "log_dir_path" do
-          before { run_within_dir root_path }
+          let(:log_path) { File.dirname(Appsignal.config.log_file_path) }
+          before { run }
 
           it "outputs log directory path" do
-            expect(output).to match %(Log directory\n    Path: "#{system_tmp_dir}")
+            expect(output).to match %(Log directory\n    Path: "#{log_path}")
           end
 
           it "transmits path data in report" do
             expect(received_report["paths"]["log_dir_path"]).to match(
-              "path" => system_tmp_dir,
+              "path" => log_path,
               "exists" => true,
               "type" => "directory",
               "mode" => kind_of(String),
@@ -1235,15 +1244,15 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
       context "when a directory does not exist" do
         let(:root_path) { tmp_dir }
+        let(:environment) { nil }
+        let(:push_api_key) { nil }
+        let(:app_name) { nil }
+        let(:options) { {} }
         let(:execution_path) { File.join(tmp_dir, "not_existing_dir") }
-        let(:config) do
-          silence(:allowed => ["Push api key not set after loading config"]) do
-            Appsignal::Config.new(execution_path, "production")
-          end
-        end
         before do
           allow(Dir).to receive(:pwd).and_return(execution_path)
-          run_within_dir tmp_dir
+          FileUtils.rm_rf(execution_path)
+          run_within_dir root_path
         end
 
         it "outputs not existing path" do
@@ -1260,7 +1269,12 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
       context "when not writable" do
         let(:root_path) { File.join(tmp_dir, "not_writable_path") }
+        let(:environment) { nil }
+        let(:push_api_key) { nil }
+        let(:app_name) { nil }
+        let(:options) { {} }
         before do
+          FileUtils.mkdir_p(root_path)
           FileUtils.chmod(0o555, root_path)
           run_within_dir root_path
         end
@@ -1288,7 +1302,12 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
       context "when writable" do
         let(:root_path) { File.join(tmp_dir, "writable_path") }
+        let(:environment) { nil }
+        let(:push_api_key) { nil }
+        let(:app_name) { nil }
+        let(:options) { {} }
         before do
+          FileUtils.mkdir_p(root_path)
           FileUtils.chmod(0o755, root_path)
           run_within_dir root_path
         end
@@ -1315,6 +1334,14 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       end
 
       describe "ownership" do
+        let(:environment) { nil }
+        let(:push_api_key) { nil }
+        let(:app_name) { nil }
+        let(:options) { {} }
+        before do
+          FileUtils.mkdir_p(root_path)
+        end
+
         context "when a directory is owned by the current user" do
           let(:root_path) { File.join(tmp_dir, "owned_path") }
           before { run_within_dir root_path }