appsignal 1.4.0.beta.1 → 2.0.0.beta.1

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

@@ -1,122 +1,170 @@
-require 'appsignal/cli'
+require "appsignal/cli"
 
 describe Appsignal::CLI::NotifyOfDeploy do
+  include CLIHelpers
+
   let(:out_stream) { StringIO.new }
-  let(:cli) { Appsignal::CLI::NotifyOfDeploy }
-  let(:config) { Appsignal::Config.new(project_fixture_path, {}) }
-  let(:marker_data) { {:revision => 'aaaaa', :user => 'thijs', :environment => 'production'} }
-  before do
-    config.stub(:active? => true)
-  end
+  let(:output) { out_stream.string }
   around do |example|
     capture_stdout(out_stream) { example.run }
   end
 
-  describe ".run" do
-    it "should validate that the config has been loaded and all options have been supplied" do
-      cli.should_receive(:validate_active_config)
-      cli.should_receive(:validate_required_options).with(
-        {},
-        [:revision, :user, :environment]
-      )
-      Appsignal::Marker.should_receive(:new).and_return(double(:transmit => true))
-
-      cli.run({}, config)
+  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
+    run_cli("notify_of_deploy", options)
+  end
 
-    it "should notify of a deploy" do
-      marker = double
-      Appsignal::Marker.should_receive(:new).with(
-        {
-          :revision => 'aaaaa',
-          :user => 'thijs'
-        },
-        kind_of(Appsignal::Config)
-      ).and_return(marker)
-      marker.should_receive(:transmit)
-
-      cli.run(marker_data, config)
+  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 "should notify of a deploy with no config file and a name specified" do
-      ENV['PWD'] = '/nonsense'
-      ENV['APPSIGNAL_PUSH_API_KEY'] = 'key'
-
-      marker = double
-      Appsignal::Marker.should_receive(:new).with(
-        {
-          :revision => 'aaaaa',
-          :user => 'thijs'
-        },
-        kind_of(Appsignal::Config)
-      ).and_return(marker)
-      marker.should_receive(:transmit)
-
-      cli.run(marker_data, config)
+    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
 
-  describe "#validate_required_options" do
-    let(:required_options) { [:option_1, :option_2, :option_3] }
-
-    it "should do nothing with all options supplied" do
-      cli.send(
-        :validate_required_options,
-        {
-          :option_1 => 1,
-          :option_2 => 2,
-          :option_3 => 3
-        },
-        required_options
-      )
-      out_stream.string.should be_empty
+  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
-
-    it "should print a message with one option missing and exit" do
-      lambda {
-        cli.send(
-          :validate_required_options,
-          {
-            :option_1 => 1,
-            :option_2 => 2
-          },
-          required_options
-        )
-      }.should raise_error(SystemExit)
-      out_stream.string.should include('Missing options: option_3')
+    around do |example|
+      Dir.chdir project_fixture_path do
+        example.run
+      end
     end
 
-    it "should print a message with multiple options missing and exit" do
-      lambda {
-        cli.send(
-          :validate_required_options,
-          {
-            :option_1 => 1,
-            :option_2 => ''
-          },
-          required_options
-        )
-      }.should raise_error(SystemExit)
-      out_stream.string.should include("Missing options: option_2, option_3")
+    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
-  end
 
-  describe "#validate_active_config" do
-    context "when config is present" do
-      it "should do nothing" do
-        cli.send(:validate_active_config, config)
-        out_stream.string.should be_empty
+    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 "when config is not active" do
-      before { config.stub(:active? => false) }
+    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 "should print a message and exit" do
-        lambda {
-          cli.send(:validate_active_config, config)
-        }.should raise_error(SystemExit)
-        out_stream.string.should include('Exiting: No config file or push api key env var found')
+          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

data/spec/lib/appsignal/cli_spec.rb

@@ -35,7 +35,7 @@ describe Appsignal::CLI do
         cli.run([arg])
       }.should raise_error(SystemExit)
 
-      out_stream.string.should include 'Appsignal'
+      out_stream.string.should include 'AppSignal'
       out_stream.string.should include '.'
     end
   end
@@ -72,21 +72,4 @@ describe Appsignal::CLI do
       ])
     end
   end
-
-  describe "notify_of_deploy" do
-    it "should call Appsignal::Install.install" do
-      Appsignal::CLI::NotifyOfDeploy.should_receive(:run).with(
-        {:revision=>"aaaaa", :user=>"thijs", :environment=>"production"},
-        instance_of(Appsignal::Config)
-      )
-
-      cli.run([
-        'notify_of_deploy',
-        '--name=project-production',
-        '--revision=aaaaa',
-        '--user=thijs',
-        '--environment=production'
-      ])
-    end
-  end
 end

data/spec/lib/appsignal/config_spec.rb

@@ -29,6 +29,26 @@ describe Appsignal::Config do
         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
+        around { |example| recognize_as_container(:none) { example.run } }
+
+        it "is set to file" do
+          expect(subject).to eq("file")
+        end
+      end
+    end
   end
 
   describe "initial config" do
@@ -46,6 +66,7 @@ describe Appsignal::Config do
     it "merges with the default config" do
       expect(config.config_hash).to eq(
         :debug                          => false,
+        :log                            => 'file',
         :ignore_errors                  => [],
         :ignore_actions                 => [],
         :filter_parameters              => [],
@@ -319,7 +340,7 @@ describe Appsignal::Config do
       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 Appsignal::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_FILTER_PARAMETERS']).to            eq 'password,confirm_password'
@@ -349,7 +370,11 @@ describe Appsignal::Config do
     let(:stdout) { StringIO.new }
     let(:config) { project_fixture_config('production', :log_path => log_path) }
     subject { config.log_file_path }
-    around { |example| capture_stdout(stdout) { example.run } }
+    around do |example|
+      recognize_as_container(:none) do
+        capture_stdout(stdout) { example.run }
+      end
+    end
 
     context "when path is writable" do
       let(:log_path) { File.join(tmp_dir, 'writable-path') }

data/spec/lib/appsignal/hooks/rake_spec.rb

@@ -1,72 +1,55 @@
 require 'rake'
 
 describe Appsignal::Hooks::RakeHook do
-  let(:app)  { double(:current_scope => nil) }
-  let(:task) { Rake::Task.new('task', app) }
-  before do
-    task.stub(
-      :name                      => 'task:name',
-      :execute_without_appsignal => true
-    )
-  end
-  before :all do
-    Appsignal::Hooks::RakeHook.new.install
+  let(:task) { Rake::Task.new('task:name', Rake::Application.new) }
+  before(:all) do
+    Appsignal.config = project_fixture_config
+    expect(Appsignal.active?).to be_true
+    Appsignal::Hooks.load_hooks
   end
 
   describe "#execute" do
-    context "with transaction" do
-      let!(:transaction) { background_job_transaction }
-      let!(:agent)       { double('Agent', :send_queue => true) }
-      before do
-        transaction.stub(:set_action)
-        transaction.stub(:set_error)
-        transaction.stub(:complete)
-        SecureRandom.stub(:uuid => '123')
-        Appsignal::Transaction.stub(:create => transaction)
-        Appsignal.stub(:active? => true)
-      end
-
-      it "should call the original task" do
-        expect( task ).to receive(:execute_without_appsignal).with('foo')
+    context "without error" do
+      it "creates no transaction" do
+        expect(Appsignal::Transaction).to_not receive(:create)
       end
 
-      it "should not create a transaction" do
-        expect( Appsignal::Transaction ).not_to receive(:create)
+      it "calls the original task" do
+        expect(task).to receive(:execute_without_appsignal).with('foo')
       end
 
-      context "with an exception" do
-        let(:exception) { VerySpecificError.new }
+      after { task.execute('foo') }
+    end
 
-        before do
-          task.stub(:execute_without_appsignal).and_raise(exception)
-        end
+    context "with error" do
+      let(:error) { VerySpecificError.new }
+      let(:transaction) { background_job_transaction }
+      before do
+        task.enhance { raise error }
 
-        it "should create a transaction" do
-          expect( Appsignal::Transaction ).to receive(:create).with(
-            '123',
-            Appsignal::Transaction::BACKGROUND_JOB,
-            kind_of(Appsignal::Transaction::GenericRequest)
-          )
-        end
+        expect(Appsignal::Transaction).to receive(:create).with(
+          kind_of(String),
+          Appsignal::Transaction::BACKGROUND_JOB,
+          kind_of(Appsignal::Transaction::GenericRequest)
+        ).and_return(transaction)
+      end
 
-        it "should set the action on the transaction" do
-          expect( transaction ).to receive(:set_action).with('task:name')
-        end
+      it "sets the action" do
+        expect(transaction).to receive(:set_action).with('task:name')
+      end
 
-        it "should add the exception to the transaction" do
-          expect( transaction ).to receive(:set_error).with(exception)
-        end
+      it "sets the error" do
+        expect(transaction).to receive(:set_error).with(error)
+      end
 
-        it "should call complete! on the transaction" do
-          expect( transaction ).to receive(:complete)
-        end
+      it "completes the transaction and stops" do
+        expect(transaction).to receive(:complete).ordered
+        expect(Appsignal).to receive(:stop).with('rake').ordered
+      end
 
-        it "should stop appsignal" do
-          expect( Appsignal ).to receive(:stop)
-        end
+      after do
+        expect { task.execute('foo') }.to raise_error VerySpecificError
       end
     end
-
-    after { task.execute('foo') rescue VerySpecificError }
   end
 end