appsignal 2.0.3 → 2.0.4

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

@@ -1,17 +1,22 @@
 require "appsignal/cli"
 
-describe Appsignal::CLI::Diagnose do
+describe Appsignal::CLI::Diagnose, :api_stub => true do
   describe ".run" do
-    let(:out_stream) { StringIO.new }
+    let(:out_stream) { std_stream }
+    let(:output) { out_stream.read }
     let(:config) { project_fixture_config }
     let(:cli) { described_class }
-    let(:output) { out_stream.string }
+    let(:options) { { :environment => config.env } }
+    before(:all) { Appsignal.stop }
     before do
-      ENV["APPSIGNAL_APP_ENV"] = "production"
+      if DependencyHelper.rails_present?
+        allow(Rails).to receive(:root).and_return(Pathname.new(config.root_path))
+      end
+    end
+    before :api_stub => true do
       stub_api_request config, "auth"
     end
     after { Appsignal.config = nil }
-    around { |example| capture_stdout(out_stream) { example.run } }
 
     def run
       run_within_dir project_fixture_path
@@ -19,7 +24,7 @@ describe Appsignal::CLI::Diagnose do
 
     def run_within_dir(chdir)
       Dir.chdir chdir do
-        cli.run
+        capture_stdout(out_stream) { cli.run(options) }
       end
     end
 
@@ -31,13 +36,48 @@ describe Appsignal::CLI::Diagnose do
         "support@appsignal.com"
     end
 
-    it "outputs version numbers" do
-      run
-      gem_path = Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip
-      expect(output).to include \
-        "Gem version: #{Appsignal::VERSION}",
-        "Agent version: #{Appsignal::Extension.agent_version}",
-        "Gem install path: #{gem_path}"
+    describe "agent information" do
+      it "outputs version numbers" do
+        run
+        gem_path = Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip
+        expect(output).to include \
+          "Gem version: #{Appsignal::VERSION}",
+          "Agent version: #{Appsignal::Extension.agent_version}",
+          "Gem install path: #{gem_path}"
+      end
+
+      context "with extension" do
+        it "outputs extension is loaded" do
+          run
+          expect(output).to include "Extension loaded: yes"
+        end
+
+        it "starts the agent in diagnose mode and outputs a log" do
+          run
+          expect(output).to include \
+            "Agent diagnostics:",
+            "Running agent in diagnose mode",
+            "Valid config present",
+            "Logger initialized successfully",
+            "Lock path is writable",
+            "Agent diagnose finished"
+        end
+      end
+
+      context "without extension" do
+        before do
+          # When the extension isn't loaded the Appsignal.start operation exits
+          # early and doesn't load the configuration.
+          # Happens when the extension wasn't installed properly.
+          Appsignal.extension_loaded = false
+          run
+        end
+        after { Appsignal.extension_loaded = true }
+
+        it "outputs extension is not loaded" do
+          expect(output).to include "Extension loaded: no"
+        end
+      end
     end
 
     describe "host information" do
@@ -50,6 +90,26 @@ describe Appsignal::CLI::Diagnose do
           "Ruby version: #{RbConfig::CONFIG["RUBY_VERSION_NAME"]}"
       end
 
+      describe "root user detection" do
+        context "when not root user" do
+          it "prints no" do
+            run
+            expect(output).to include "root user: no"
+          end
+        end
+
+        context "when root user" do
+          before do
+            allow(Process).to receive(:uid).and_return(0)
+            run
+          end
+
+          it "prints yes, with warning" do
+            expect(output).to include "root user: yes (not recommended)"
+          end
+        end
+      end
+
       describe "Heroku detection" do
         context "when not on Heroku" do
           before { recognize_as_container(:none) { run } }
@@ -89,42 +149,20 @@ describe Appsignal::CLI::Diagnose do
     end
 
     describe "configuration" do
-      context "without extension" do
-        before do
-          # When the extension isn't loaded the Appsignal.start operation exits
-          # early and doesn't load the configuration.
-          # Happens when the extension wasn't installed properly.
-          Appsignal.extension_loaded = false
-          run
-        end
-        after { Appsignal.extension_loaded = true }
-
-        it "outputs an error" do
-          expect(output).to include \
-            "Error: No config found!\nCould not start AppSignal."
-        end
-
-        it "outputs as much as it can" do
-          expect(output).to include \
-            "AppSignal agent\n  Gem version: #{Appsignal::VERSION}",
-            "Host information\n  Architecture: ",
-            %(Extension install log\n  Path: "),
-            %(Makefile install log\n  Path: ")
-        end
-      end
-
       context "without environment" do
-        let(:config) { project_fixture_config("") }
+        let(:config) { project_fixture_config(nil) }
+        let(:options) { {} }
         before do
-          ENV["APPSIGNAL_APP_ENV"] = ""
-          recognize_as_container(:none) { run }
+          ENV.delete("RAILS_ENV") # From spec_helper
+          ENV.delete("RACK_ENV")
+          recognize_as_container(:none) { run_within_dir tmp_dir }
         end
 
         it "outputs a warning that no config is loaded" do
           expect(output).to_not include "Error"
           expect(output).to include \
             "Environment: \n    Warning: No environment set, no config loaded!",
-            "  APPSIGNAL_APP_ENV=production appsignal diagnose"
+            "  appsignal diagnose --environment=production"
         end
 
         it "outputs config defaults" do
@@ -153,10 +191,7 @@ describe Appsignal::CLI::Diagnose do
 
       context "with unconfigured environment" do
         let(:config) { project_fixture_config("foobar") }
-        before do
-          ENV["APPSIGNAL_APP_ENV"] = "foobar"
-          recognize_as_container(:none) { run }
-        end
+        before { recognize_as_container(:none) { run_within_dir tmp_dir } }
 
         it "outputs environment" do
           expect(output).to include("Environment: foobar")
@@ -172,7 +207,7 @@ describe Appsignal::CLI::Diagnose do
       end
     end
 
-    describe "API key validation" do
+    describe "API key validation", :api_stub => false do
       context "with valid key" do
         before do
           stub_api_request(config, "auth").to_return(:status => 200)
@@ -208,71 +243,185 @@ describe Appsignal::CLI::Diagnose do
     end
 
     describe "paths" do
-      before { FileUtils.mkdir_p(root_path) }
+      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]) }
 
-      context "when a directory is writable" do
+      context "when a directory is not configured" do
         let(:root_path) { File.join(tmp_dir, "writable_path") }
-        let(:log_file) { File.join(root_path, "appsignal.log") }
-        let(:config) { Appsignal::Config.new(root_path, "production") }
+        let(:config) { Appsignal::Config.new(root_path, "production", :log_file => nil) }
+        before do
+          FileUtils.mkdir_p(File.join(root_path, "log"), :mode => 0555)
+          FileUtils.chmod(0555, system_tmp_dir)
+          run_within_dir root_path
+        end
+
+        it "outputs unconfigured directory" do
+          expect(output).to include %(log_file_path: ""\n    - Configured?: no)
+        end
+      end
+
+      context "when a directory does not exist" do
+        let(:root_path) { tmp_dir }
+        let(:execution_path) { File.join(tmp_dir, "not_existing_dir") }
+        let(:config) { Appsignal::Config.new(execution_path, "production") }
+        before do
+          allow(Dir).to receive(:pwd).and_return(execution_path)
+          run_within_dir tmp_dir
+        end
 
-        context "without log file" do
+        it "outputs not existing path" do
+          expect(output).to include %(root_path: "#{execution_path}"\n    - Exists?: no)
+        end
+      end
+
+      describe "ownership" do
+        context "when a directory is owned by the current user" do
+          let(:root_path) { File.join(tmp_dir, "owned_path") }
+          let(:config) { Appsignal::Config.new(root_path, "production") }
+          let(:process_user) { Etc.getpwuid(Process.uid).name }
           before { run_within_dir root_path }
 
-          it "outputs writable" do
+          it "outputs ownership" do
             expect(output).to include \
-              "Required paths",
-              %(root_path: "#{root_path}" - Writable),
-              %(log_file_path: "#{log_file}" - Does not exist)
+              %(root_path: "#{root_path}"\n    - Writable?: yes\n    ) \
+                "- Ownership?: yes (file: #{process_user}:#{Process.uid}, "\
+                "process: #{process_user}:#{Process.uid})"
           end
         end
 
-        context "with log file" do
-          context "when writable" do
-            before do
-              FileUtils.touch(log_file)
-              run_within_dir root_path
-            end
+        context "when a directory is not owned by the current user" do
+          let(:root_path) { File.join(tmp_dir, "not_owned_path") }
+          let(:config) { Appsignal::Config.new(root_path, "production") }
+          let(:process_user) { Etc.getpwuid(Process.uid).name }
+          before do
+            stat = File.stat(root_path)
+            allow(stat).to receive(:uid).and_return(0)
+            allow(File).to receive(:stat).and_return(stat)
+            run_within_dir root_path
+          end
 
-            it "lists log file as writable" do
-              expect(output).to include \
-                %(root_path: "#{root_path}" - Writable),
-                %(log_file_path: "#{File.join(root_path, "appsignal.log")}" - Writable)
-            end
+          it "outputs no ownership" do
+            expect(output).to include \
+              %(root_path: "#{root_path}"\n    - Writable?: yes\n    ) \
+                "- Ownership?: no (file: root:0, process: #{process_user}:#{Process.uid})"
           end
+        end
+      end
 
-          context "when not writable" do
+      describe "current_path" do
+        let(:root_path) { tmp_dir }
+        let(:config) { Appsignal::Config.new(root_path, "production") }
+        before { run_within_dir root_path }
+
+        it "outputs current path" do
+          expect(output).to include %(current_path: "#{tmp_dir}"\n    - Writable?: yes)
+        end
+      end
+
+      describe "root_path" do
+        let(:system_tmp_log_file) { File.join(system_tmp_dir, "appsignal.log") }
+        context "when not writable" do
+          let(:root_path) { File.join(tmp_dir, "not_writable_path") }
+          let(:config) { Appsignal::Config.new(root_path, "production") }
+          before do
+            FileUtils.chmod(0555, root_path)
+            run_within_dir root_path
+          end
+
+          it "outputs not writable root path" do
+            expect(output).to include %(root_path: "#{root_path}"\n    - Writable?: no)
+          end
+
+          it "log files fall back on system tmp directory" do
+            expect(output).to include \
+              %(log_dir_path: "#{system_tmp_dir}"\n    - Writable?: yes)
+              %(log_file_path: "#{system_tmp_log_file}"\n    - Exist?: false)
+          end
+        end
+
+        context "when writable" do
+          let(:root_path) { File.join(tmp_dir, "writable_path") }
+          let(:config) { Appsignal::Config.new(root_path, "production") }
+
+          context "without log dir" do
             before do
-              FileUtils.touch(log_file)
-              FileUtils.chmod(0444, log_file)
+              FileUtils.chmod(0777, root_path)
               run_within_dir root_path
             end
 
-            it "lists log file as not writable" do
+            it "outputs writable root path" do
+              expect(output).to include %(root_path: "#{root_path}"\n    - Writable?: yes)
+            end
+
+            it "log files fall back on system tmp directory" do
               expect(output).to include \
-                %(root_path: "#{root_path}" - Writable),
-                %(log_file_path: "#{File.join(root_path, "appsignal.log")}" - Not writable)
+                %(log_dir_path: "#{system_tmp_dir}"\n    - Writable?: yes),
+                %(log_file_path: "#{system_tmp_log_file}"\n    - Exists?: no)
             end
           end
-        end
-      end
 
-      context "when a directory is not writable" do
-        let(:root_path) { File.join(tmp_dir, "not_writable_path") }
-        let(:config) { Appsignal::Config.new(root_path, "production") }
-        before do
-          FileUtils.chmod(0555, root_path)
-          run_within_dir root_path
-        end
+          context "with log dir" do
+            let(:log_dir) { File.join(root_path, "log") }
+            let(:log_file) { File.join(log_dir, "appsignal.log") }
+            before { FileUtils.mkdir_p(log_dir) }
+
+            context "when not writable" do
+              before do
+                FileUtils.chmod(0444, log_dir)
+                run_within_dir root_path
+              end
+
+              it "log files fall back on system tmp directory" do
+                expect(output).to include \
+                  %(log_dir_path: "#{system_tmp_dir}"\n    - Writable?: yes),
+                  %(log_file_path: "#{system_tmp_log_file}"\n    - Exists?: no)
+              end
+            end
 
-        it "outputs not writable" do
-          expect(output).to include \
-            "Required paths",
-            %(root_path: "#{root_path}" - Not writable),
-            %(log_file_path: "" - Not writable)
+            context "when writable" do
+              context "without log file" do
+                before { run_within_dir root_path }
+
+                it "outputs writable but without log file" do
+                  expect(output).to include \
+                    %(root_path: "#{root_path}"\n    - Writable?: yes),
+                    %(log_dir_path: "#{log_dir}"\n    - Writable?: yes),
+                    %(log_file_path: "#{log_file}"\n    - Exists?: no)
+                end
+              end
+
+              context "with log file" do
+                context "when writable" do
+                  before do
+                    FileUtils.touch(log_file)
+                    run_within_dir root_path
+                  end
+
+                  it "lists log file as writable" do
+                    expect(output).to include %(log_file_path: "#{log_file}"\n    - Writable?: yes)
+                  end
+                end
+
+                context "when not writable" do
+                  before do
+                    FileUtils.touch(log_file)
+                    FileUtils.chmod(0444, log_file)
+                    run_within_dir root_path
+                  end
+
+                  it "lists log file as not writable" do
+                    expect(output).to include %(log_file_path: "#{log_file}"\n    - Writable?: no)
+                  end
+                end
+              end
+            end
+          end
         end
       end
-
-      after { FileUtils.rm_rf(root_path) }
     end
 
     describe "logs" do

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

@@ -0,0 +1,99 @@
+require "appsignal/cli/helpers"
+
+describe Appsignal::CLI::Helpers do
+  include CLIHelpers
+
+  let(:out_stream) { std_stream }
+  let(:output) { out_stream.read }
+  let(:cli) do
+    Class.new do
+      extend Appsignal::CLI::Helpers
+    end
+  end
+  before do
+    # Speed up tests
+    allow(cli).to receive(:sleep)
+  end
+  around do |example|
+    original_stdin = $stdin
+    $stdin = StringIO.new
+    example.run
+    $stdin = original_stdin
+  end
+
+  describe ".colorize" do
+    subject { cli.send(:colorize, "text", :green) }
+
+    context "on windows" do
+      before { allow(Gem).to receive(:win_platform?).and_return(true) }
+
+      it "outputs plain string" do
+        expect(subject).to eq "text"
+      end
+    end
+
+    context "not on windows" do
+      before { allow(Gem).to receive(:win_platform?).and_return(false) }
+
+      it "wraps text in color tags" do
+        expect(subject).to eq "\e[32mtext\e[0m"
+      end
+    end
+  end
+
+  describe ".periods" do
+    it "prints three periods" do
+      capture_stdout(out_stream) { cli.send :periods }
+      expect(output).to include("...")
+    end
+  end
+
+  describe ".press_any_key" do
+    before do
+      set_input "a" # a as in any
+    end
+
+    it "continues after press" do
+      capture_stdout(out_stream) { cli.send :press_any_key }
+      expect(output).to include("Press any key")
+    end
+  end
+
+  describe ".yes_or_no" do
+    def yes_or_no
+      capture_stdout(out_stream) { cli.send(:yes_or_no, "yes or no?: ") }
+    end
+
+    it "takes yes for an answer" do
+      set_input ""
+      set_input "nonsense"
+      set_input "y"
+      prepare_input
+
+      expect(yes_or_no).to be_true
+    end
+
+    it "takes no for an answer" do
+      set_input ""
+      set_input "nonsense"
+      set_input "n"
+      prepare_input
+
+      expect(yes_or_no).to be_false
+    end
+  end
+
+  describe ".required_input" do
+    def required_input
+      capture_stdout(out_stream) { cli.send(:required_input, "provide: ") }
+    end
+
+    it "collects required input" do
+      set_input ""
+      set_input "value"
+      prepare_input
+
+      expect(required_input).to eq("value")
+    end
+  end
+end