appsignal 0.6.7 → 0.7.0.alpha.1

data/spec/{appsignal → lib/appsignal}/cli_spec.rb

@@ -1,12 +1,16 @@
 require 'spec_helper'
+require 'appsignal/cli'
 
 describe Appsignal::CLI do
   let(:out_stream) { StringIO.new }
   let(:error_stream) { StringIO.new }
   let(:cli) { Appsignal::CLI }
-  before :each do
+  before do
     @original_stdout, @original_stderr = $stdout, $stderr
     $stdout, $stderr = out_stream, error_stream
+    ENV['PWD'] = project_fixture_path
+    cli.config = nil
+    cli.options = {:environment => 'production'}
   end
   after :each do
     $stdout = @original_stdout
@@ -19,13 +23,11 @@ describe Appsignal::CLI do
     end
   end
 
-  it "should print a message if there is no config file" do
-    File.stub(:exists? => false)
-    lambda {
-        cli.run([])
-      }.should raise_error(SystemExit)
-      out_stream.string.should include 'No config file present at config/appsignal.yml'
-      out_stream.string.should include 'Log in to https://appsignal.com to get instructions on how to generate the config file.'
+  describe "#config" do
+    subject { cli.config }
+
+    it { should be_instance_of(Appsignal::Config) }
+    its(:loaded?) { should be_true }
   end
 
   it "should print the help with no arguments, -h and --help" do
@@ -60,29 +62,28 @@ describe Appsignal::CLI do
   end
 
   describe "#notify_of_deploy" do
-    it "should validate that all options have been supplied" do
-      options = {}
+    it "should validate that the config has been loaded and all options have been supplied" do
+      cli.should_receive(:validate_config_loaded)
       cli.should_receive(:validate_required_options).with(
-        [:revision, :repository, :user, :environment],
-        options
+        [:revision, :repository, :user, :environment]
       )
-      Appsignal::Marker.should_receive(:new).
-        and_return(double(:transmit => true))
-      cli.notify_of_deploy(options)
+      Appsignal::Marker.should_receive(:new).and_return(double(:transmit => true))
+
+      cli.notify_of_deploy
     end
 
     it "should notify of a deploy" do
-      transmitter = double
-      Appsignal::Transmitter.should_receive(:new).with(
-        'http://localhost:3000/1',
-        'markers',
-        'def'
-      ).and_return(transmitter)
-      transmitter.should_receive(:transmit).with(
-        :revision => 'aaaaa',
-        :repository => 'git@github.com:our/project.git',
-        :user => 'thijs'
-      )
+      marker = double
+      Appsignal::Marker.should_receive(:new).with(
+        {
+          :revision => 'aaaaa',
+          :repository => 'git@github.com:our/project.git',
+          :user => 'thijs'
+        },
+        kind_of(Appsignal::Config),
+        kind_of(Logger)
+      ).and_return(marker)
+      marker.should_receive(:transmit)
 
       cli.run([
         'notify_of_deploy',
@@ -94,72 +95,70 @@ describe Appsignal::CLI do
     end
   end
 
-  describe "#api_check" do
-    it "should detect configured environments" do
-      authcheck = double
-      Appsignal::AuthCheck.should_receive(:new).with(
-        :development,
-        kind_of(Hash)
-      ).and_return(authcheck)
-      Appsignal::AuthCheck.should_receive(:new).with(
-        :production,
-        kind_of(Hash)
-      ).and_return(authcheck)
-      Appsignal::AuthCheck.should_receive(:new).with(
-        :test,
-        kind_of(Hash)
-      ).and_return(authcheck)
-
-      authcheck.should_receive(:perform_with_result).exactly(3).times.
-        and_return(['200', 'result'])
-      cli.run([
-        'api_check'
-      ])
-      out_stream.string.should =~ /\[development\]/
-      out_stream.string.should =~ /\[production\]/
-      out_stream.string.should =~ /\[test\]/
-      out_stream.string.should =~ /\* result/
-    end
-  end
-
   # protected
 
   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,
-        required_options,
+      cli.options = {
         :option_1 => 1,
         :option_2 => 2,
         :option_3 => 3
+      }
+      cli.send(
+        :validate_required_options,
+        required_options
       )
       out_stream.string.should be_empty
     end
 
-    it "should print a message with one option missing" do
+    it "should print a message with one option missing and exit" do
+      cli.options = {
+        :option_1 => 1,
+        :option_2 => 2
+      }
       lambda {
         cli.send(
           :validate_required_options,
-          required_options,
-          :option_1 => 1,
-          :option_2 => 2
+          required_options
         )
       }.should raise_error(SystemExit)
-      out_stream.string.should include("Missing options: option_3")
+      out_stream.string.should include('Missing options: option_3')
     end
 
-    it "should print a message with multiple options missing" do
+    it "should print a message with multiple options missing and exit" do
+      cli.options = {
+        :option_1 => 1,
+        :option_2 => ''
+      }
       lambda {
         cli.send(
           :validate_required_options,
-          required_options,
-          :option_1 => 1,
-          :option_2 => ''
+          required_options
         )
       }.should raise_error(SystemExit)
       out_stream.string.should include("Missing options: option_2, option_3")
     end
   end
+
+  describe "#validate_config_loaded" do
+    context "when config is present" do
+      it "should do nothing" do
+        cli.send(:validate_config_loaded)
+        out_stream.string.should be_empty
+      end
+    end
+
+    context "when config is not present" do
+      before { cli.options = {:environment => 'nonsense'} }
+
+      it "should print a message and exit" do
+        lambda {
+          cli.send(:validate_config_loaded)
+        }.should raise_error(SystemExit)
+        out_stream.string.should include('Exiting: No config file or push api key env var found')
+      end
+    end
+  end
 end

data/spec/lib/appsignal/config_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Appsignal::Config do
+  subject { config }
+
+  describe "when there is a config file" do
+    let(:config) { project_fixture_config('production') }
+
+    it "should not log an error" do
+      Appsignal::Config.any_instance.should_not_receive(:carefully_log_error)
+      subject
+    end
+
+    its(:loaded?) { should be_true }
+
+    it "should merge with the default config and fill the config hash" do
+      subject.config_hash.should == {
+        :ignore_exceptions => [],
+        :endpoint => 'https://push.appsignal.com/1',
+        :slow_request_threshold => 200,
+        :push_api_key => 'abc',
+        :name => 'TestApp',
+        :active => true
+      }
+    end
+
+    describe "#[]" do
+      it "should get the value for an existing key" do
+        subject[:push_api_key].should == 'abc'
+      end
+
+      it "should return nil for a non-existing key" do
+        subject[:nonsense].should be_nil
+      end
+    end
+
+    context "and there's also an env var present" do
+      before do
+        ENV['APPSIGNAL_PUSH_API_KEY'] = 'push_api_key'
+      end
+
+      it "should ignore the env var" do
+        subject[:push_api_key].should == 'abc'
+      end
+    end
+
+    context "and there is an old-style api_key defined" do
+      let(:config) { project_fixture_config('old_api_key') }
+
+      it "should fill the push_api_key with the old style key" do
+        subject[:push_api_key].should == 'def'
+      end
+    end
+  end
+
+  context "when there is a config file without the current env" do
+    let(:config) { project_fixture_config('nonsense') }
+
+    it "should log an error" do
+      Appsignal::Config.any_instance.should_receive(:carefully_log_error).with(
+        "Not loading: config for 'nonsense' not found"
+      )
+      subject
+    end
+
+    its(:loaded?) { should be_false }
+  end
+
+  context "when there is no config file" do
+    let(:config) { Appsignal::Config.new('/nothing', 'production') }
+
+    it "should log an error" do
+      Appsignal::Config.any_instance.should_receive(:carefully_log_error).with(
+        "Not loading: No config file found at '/nothing/config/appsignal.yml' " \
+        "and no APPSIGNAL_PUSH_API_KEY env var present"
+      )
+      subject
+    end
+
+    its(:loaded?) { should be_false }
+
+    describe "#[]" do
+      it "should return nil" do
+        subject[:endpoint].should be_nil
+      end
+    end
+
+    context "and an env var is present" do
+      before do
+        ENV['APPSIGNAL_PUSH_API_KEY'] = 'push_api_key'
+      end
+
+      it "should not log an error" do
+        Appsignal::Config.any_instance.should_not_receive(:carefully_log_error)
+        subject
+      end
+
+      its(:loaded?) { should be_true }
+
+      it "should merge with the default config and fill the config hash" do
+        subject.config_hash.should == {
+          :push_api_key => 'push_api_key',
+          :ignore_exceptions => [],
+          :endpoint => 'https://push.appsignal.com/1',
+          :slow_request_threshold => 200,
+          :active => true
+        }
+      end
+
+      context "with only APPSIGNAL_API_KEY" do
+        before do
+          ENV.delete('APPSIGNAL_PUSH_API_KEY')
+          ENV['APPSIGNAL_API_KEY'] = 'old_style_api_key'
+        end
+
+        it "should use the old style api key" do
+          subject[:push_api_key].should == 'old_style_api_key'
+        end
+      end
+
+      context "with both APPSIGNAL_PUSH_API_KEY and APPSIGNAL_API_KEY" do
+        before do
+          ENV['APPSIGNAL_API_KEY'] = 'old_style_api_key'
+        end
+
+        it "should use the new style push api key" do
+          subject[:push_api_key].should == 'push_api_key'
+        end
+      end
+    end
+  end
+end

data/spec/lib/appsignal/integrations/capistrano_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'appsignal/capistrano'
+require 'capistrano/configuration'
+
+describe Appsignal::Integrations::Capistrano do
+  let(:config) { project_fixture_config }
+
+  before :all do
+    @capistrano_config = Capistrano::Configuration.new
+    Appsignal::Integrations::Capistrano.tasks(@capistrano_config)
+  end
+
+  it "should have a deploy task" do
+    @capistrano_config.find_task('appsignal:deploy').should_not be_nil
+  end
+
+  describe "appsignal:deploy task" do
+    before do
+      @capistrano_config.set(:rails_env, 'production')
+      @capistrano_config.set(:repository, 'master')
+      @capistrano_config.set(:deploy_to, '/home/username/app')
+      @capistrano_config.set(:current_release, '')
+      @capistrano_config.set(:current_revision, '503ce0923ed177a3ce000005')
+      @capistrano_config.dry_run = false
+      ENV['USER'] = 'batman'
+    end
+
+    context "config" do
+      before { @capistrano_config.dry_run = true }
+
+      it "should be instantiated with the right params" do
+        Appsignal::Config.should_receive(:new).with(
+          ENV['PWD'],
+          'production',
+          kind_of(Capistrano::Logger)
+        )
+      end
+
+      context "when rack_env is used instead of rails_env" do
+        before do
+          @capistrano_config.unset(:rails_env)
+          @capistrano_config.set(:rack_env, 'rack_production')
+        end
+
+        it "should be instantiated with the right params" do
+          Appsignal::Config.should_receive(:new).with(
+            ENV['PWD'],
+            'rack_production',
+            kind_of(Capistrano::Logger)
+          )
+        end
+      end
+
+      after { @capistrano_config.find_and_execute_task('appsignal:deploy') }
+    end
+
+    context "send marker" do
+      before :all do
+        @io = StringIO.new
+        @logger = Capistrano::Logger.new(:output => @io)
+        @logger.level = Capistrano::Logger::MAX_LEVEL
+        @capistrano_config.logger = @logger
+      end
+
+      let(:marker_data) do
+        {
+          :revision => "503ce0923ed177a3ce000005",
+          :repository => "master",
+          :user => "batman"
+        }
+      end
+
+      before do
+        @marker = Appsignal::Marker.new(
+          marker_data,
+          config,
+          @logger
+        )
+        Appsignal::Marker.should_receive(:new).with(
+          marker_data,
+          kind_of(Appsignal::Config),
+          kind_of(Capistrano::Logger)
+        ).and_return(@marker)
+      end
+
+      context "proper setup" do
+        before do
+          @transmitter = double
+          Appsignal::Transmitter.should_receive(:new).and_return(@transmitter)
+        end
+
+        it "should transmit data" do
+          @transmitter.should_receive(:transmit).and_return('200')
+          @capistrano_config.find_and_execute_task('appsignal:deploy')
+          @io.string.should include('** Notifying Appsignal of deploy...')
+          @io.string.should include(
+            '** Appsignal has been notified of this deploy!'
+          )
+        end
+      end
+
+      it "should not transmit data" do
+        @capistrano_config.find_and_execute_task('appsignal:deploy')
+        @io.string.should include('** Notifying Appsignal of deploy...')
+        @io.string.should include(
+          '** Something went wrong while trying to notify Appsignal:'
+        )
+      end
+
+      context "dry run" do
+        before { @capistrano_config.dry_run = true }
+
+        it "should not send deploy marker" do
+          @marker.should_not_receive(:transmit)
+          @capistrano_config.find_and_execute_task('appsignal:deploy')
+          @io.string.should include(
+            '** Dry run: Deploy marker not actually sent.'
+          )
+        end
+      end
+    end
+  end
+end