appsignal 0.4.0

data/spec/appsignal/agent_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+describe Appsignal::Agent do
+  let(:transaction) { stub(
+    :name => 'transaction',
+    :exception? => false,
+    :action => 'something#else'
+  ) }
+
+  describe '#add_to_queue' do
+    before do
+      @agent = Appsignal::Agent.new
+      @exception_transaction = stub(
+        :name => 'exception',
+        :exception? => true,
+        :action => 'controller#action1'
+      )
+      @slow_transaction = stub(
+        :name => 'slow',
+        :action => 'controller#action1',
+        :exception? => false,
+        :process_action_event => stub(
+          :duration => 250.0
+        )
+      )
+      @slower_transaction = stub(
+        :name => 'slow',
+        :action => 'controller#action1',
+        :exception? => false,
+        :process_action_event => stub(
+          :duration => 300.0
+        )
+      )
+      @other_slow_transaction = stub(
+        :name => 'slow',
+        :action => 'controller#action1',
+        :exception? => false,
+        :process_action_event => stub(
+          :duration => 260.0
+        )
+      )
+      @slow_transaction_in_other_action = stub(
+        :name => 'slow',
+        :action => 'controller#action2',
+        :exception? => false,
+        :process_action_event => stub(
+          :duration => 400.0
+        )
+      )
+    end
+    subject { @agent }
+
+    context "an exception transaction" do
+      before do
+        @exception_transaction.should_not_receive(:clear_payload_and_events!)
+        subject.add_to_queue(@exception_transaction)
+      end
+
+      its(:queue) { should include(@exception_transaction) }
+      its(:slowest_transactions) { should be_empty }
+
+      context "a slow transaction" do
+        before do
+          subject.add_to_queue(@slow_transaction)
+        end
+
+        its(:queue) { should include(@slow_transaction) }
+        its(:slowest_transactions) { should == {
+          'controller#action1' => @slow_transaction
+        } }
+
+        context "a slower transaction in the same action" do
+          before do
+            @slow_transaction.should_receive(:clear_payload_and_events!)
+            @slower_transaction.should_not_receive(:clear_payload_and_events!)
+            subject.add_to_queue(@slower_transaction)
+          end
+
+          its(:queue) { should include(@slower_transaction) }
+          its(:slowest_transactions) { should == {
+            'controller#action1' => @slower_transaction
+          } }
+
+          context "a slow but not the slowest transaction in the same action" do
+            before do
+              @other_slow_transaction.should_receive(:clear_payload_and_events!)
+              subject.add_to_queue(@other_slow_transaction)
+            end
+
+            its(:queue) { should include(@other_slow_transaction) }
+            its(:slowest_transactions) { should == {
+              'controller#action1' => @slower_transaction
+            } }
+          end
+
+          context "an even slower transaction in a different action" do
+            before do
+              @slow_transaction_in_other_action.should_not_receive(:clear_payload_and_events!)
+              subject.add_to_queue(@slow_transaction_in_other_action)
+            end
+
+            its(:queue) { should include(@slow_transaction_in_other_action) }
+            its(:slowest_transactions) { should == {
+              'controller#action1' => @slower_transaction,
+              'controller#action2' => @slow_transaction_in_other_action
+            } }
+          end
+        end
+      end
+    end
+  end
+
+  describe "#send_queue" do
+    it "transmits" do
+      subject.stub(:queue => [stub(:to_hash => 'foo')])
+      subject.transmitter.should_receive(:transmit).with(['foo'])
+    end
+
+    it "handles the return code" do
+      subject.transmitter.stub(:transmit => '200')
+      subject.should_receive(:handle_result).with('200')
+    end
+
+    it "handles exceptions in transmit" do
+      subject.transmitter.stub(:transmit).and_raise(Exception.new)
+      subject.should_receive(:handle_result).with(nil)
+      Appsignal.logger.should_receive(:error).with('Exception while communicating with AppSignal: Exception')
+    end
+
+    after { subject.send_queue }
+  end
+
+  describe '#handle_result' do
+    before { subject.add_to_queue(transaction) }
+    before { subject.instance_variable_set(:@sleep_time, 3.0) }
+
+    context "good responses" do
+      before { subject.handle_result(code) }
+
+      context "with 200" do
+        let(:code) { '200' }
+
+        its(:queue) { should be_empty }
+        its(:slowest_transactions) { should be_empty }
+      end
+
+      context "with 420" do
+        let(:code) { '420' }
+
+        its(:queue) { should be_empty }
+        its(:slowest_transactions) { should be_empty }
+        its(:sleep_time) { should == 4.5 }
+      end
+
+      context "with 413" do
+        let(:code) { '413' }
+
+        its(:queue) { should be_empty }
+        its(:slowest_transactions) { should be_empty }
+        its(:sleep_time) { should == 2.0 }
+      end
+    end
+
+    context "bad responses" do
+      context "with 429" do
+        let(:code) { '429' }
+
+        it "calls a stop to logging" do
+          subject.should_receive :stop_logging
+        end
+      end
+
+      context "with 406" do
+        let(:code) { '406' }
+
+        it "calls a stop to logging" do
+          subject.should_receive :stop_logging
+        end
+      end
+
+      context "with 402" do
+        let(:code) { '402' }
+
+        it "calls a stop to logging" do
+          subject.should_receive :stop_logging
+        end
+      end
+
+      context "with 401" do
+        let(:code) { '401' }
+
+        it "calls a stop to logging" do
+          subject.should_receive :stop_logging
+        end
+      end
+
+      context "any other response" do
+        let(:code) { 'any other response' }
+
+        it "calls retry_once" do
+          subject.should_receive :retry_once
+        end
+      end
+
+      after { subject.handle_result(code) }
+    end
+  end
+
+  describe "#good_response" do
+    before do
+      subject.instance_variable_set(:@retry_once, false)
+      subject.add_to_queue(transaction)
+      subject.send :good_response
+    end
+
+    its(:queue) { should be_empty }
+    its(:slowest_transactions) { should be_empty }
+
+    it "allows the next request to be retried" do
+      subject.instance_variable_get(:@retry_request).should be_true
+    end
+  end
+
+  describe "#retry_once" do
+    before do
+      subject.add_to_queue(transaction)
+      subject.send :retry_once
+    end
+
+    context "on time," do
+      its(:queue) { should == [transaction] }
+      its(:slowest_transactions) { should == {
+        'something#else' => transaction
+      } }
+
+      context "two times" do
+        before { subject.send :retry_once }
+
+        its(:queue) { should be_empty }
+      end
+    end
+  end
+
+  describe "#stop_logging" do
+    it "does not raise exceptions" do
+      expect { subject.send :stop_logging }.not_to raise_error
+    end
+  end
+
+  describe "when inactive" do
+    before { Appsignal.stub(:active? => false) }
+
+    it "should not start a new thread" do
+      Thread.should_not_receive(:new)
+    end
+
+    after { Appsignal::Agent.new }
+  end
+end

data/spec/appsignal/auth_check_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Appsignal::AuthCheck do
+  let(:auth_check) { Appsignal::AuthCheck.new('production') }
+  before do
+    @transmitter = mock
+    Appsignal::Transmitter.should_receive(:new).
+      with('http://localhost:3000/1', 'auth', 'abc').
+      and_return(@transmitter)
+  end
+
+  describe "#perform" do
+    it "should not transmit any extra data" do
+      @transmitter.should_receive(:transmit).with({}).and_return({})
+      auth_check.perform
+    end
+  end
+
+  describe "#uri" do
+    before do
+      @transmitter.should_receive(:transmit)
+      auth_check.perform
+    end
+
+    it "should delegate to transmitter" do
+      @transmitter.should_receive(:uri)
+      auth_check.uri
+    end
+
+    it "should return uri" do
+      @transmitter.should_receive(:uri).
+        and_return('http://appsignal.com/1/auth')
+      auth_check.uri.should == 'http://appsignal.com/1/auth'
+    end
+  end
+end

data/spec/appsignal/capistrano_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'appsignal/capistrano'
+require 'capistrano/configuration'
+
+describe Appsignal::Capistrano do
+  before :all do
+    @config = Capistrano::Configuration.new
+    Appsignal::Capistrano.tasks(@config)
+  end
+
+  it "should have a deploy task" do
+    @config.find_task('appsignal:deploy').should_not be_nil
+  end
+
+  describe "appsignal:deploy task" do
+    before :all do
+      @config.set(:rails_env, 'development')
+      @config.set(:repository, 'master')
+      @config.set(:deploy_to, '/home/username/app')
+      @config.set(:current_release, '')
+      @config.set(:current_revision, '503ce0923ed177a3ce000005')
+      ENV['USER'] = 'batman'
+    end
+
+    context "send marker" do
+      let(:marker_data) {
+        {
+          :revision => "503ce0923ed177a3ce000005",
+          :repository => "master",
+          :user => "batman"
+        }
+      }
+      before :all do
+        @io = StringIO.new
+        @logger = Capistrano::Logger.new(:output => @io)
+        @logger.level = Capistrano::Logger::MAX_LEVEL
+        @config.logger = @logger
+      end
+      before do
+        @marker = Appsignal::Marker.new(marker_data, Rails.root.to_s,
+          'development', @logger)
+        Appsignal::Marker.should_receive(:new).
+          with(marker_data, Rails.root.to_s, 'development', anything()).
+          and_return(@marker)
+      end
+
+      context "proper setup" do
+        before do
+          @transmitter = mock()
+          Appsignal::Transmitter.should_receive(:new).and_return(@transmitter)
+        end
+
+        it "should transmit data" do
+          @transmitter.should_receive(:transmit).and_return('200')
+          @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
+        @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(:all) { @config.dry_run = true }
+
+        it "should not send deploy marker" do
+          @marker.should_not_receive(:transmit)
+          @config.find_and_execute_task('appsignal:deploy')
+          @io.string.should include('** Dry run: Deploy marker not actually '\
+            'sent.')
+        end
+      end
+    end
+  end
+end

data/spec/appsignal/cli_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Appsignal::CLI do
+  let(:out_stream) { StringIO.new }
+  let(:error_stream) { StringIO.new }
+  let(:cli) { Appsignal::CLI }
+  before :each do
+     $stdout, $stderr = out_stream, error_stream
+  end
+
+  describe "#logger" do
+    it "should be a logger" do
+      cli.logger.should be_instance_of(Logger)
+    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.'
+  end
+
+  it "should print the help with no arguments, -h and --help" do
+    [nil, '-h', '--help'].each do |arg|
+      lambda {
+        cli.run([arg].compact)
+      }.should raise_error(SystemExit)
+
+      out_stream.string.should include 'appsignal <command> [options]'
+      out_stream.string.should include 'Available commands: notify_of_deploy'
+    end
+  end
+
+  it "should print the version with -v and --version" do
+    ['-v', '--version'].each do |arg|
+      lambda {
+        cli.run([arg])
+      }.should raise_error(SystemExit)
+
+      out_stream.string.should include 'Appsignal'
+      out_stream.string.should include '.'
+    end
+  end
+
+  it "should print a notice if a command does not exist" do
+    lambda {
+        cli.run(['nonsense'])
+      }.should raise_error(SystemExit)
+
+      out_stream.string.should include "Command 'nonsense' does not exist, run appsignal -h to see the help"
+  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.validate_required_options(
+        required_options,
+        :option_1 => 1,
+        :option_2 => 2,
+        :option_3 => 3
+      )
+      out_stream.string.should be_empty
+    end
+
+    it "should print a message with one option missing" do
+      lambda {
+        cli.validate_required_options(
+          required_options,
+          :option_1 => 1,
+          :option_2 => 2
+        )
+      }.should raise_error(SystemExit)
+      out_stream.string.should include("Missing options: option_3")
+    end
+
+    it "should print a message with multiple options missing" do
+      lambda {
+        cli.validate_required_options(
+          required_options,
+          :option_1 => 1,
+          :option_2 => ''
+        )
+      }.should raise_error(SystemExit)
+      out_stream.string.should include("Missing options: option_2, option_3")
+    end
+  end
+
+  describe "notify_of_deploy" do
+    it "should validate that all options have been supplied" do
+      options = {}
+      cli.should_receive(:validate_required_options).with(
+        [:revision, :repository, :user, :environment],
+        options
+      )
+      cli.notify_of_deploy(options)
+    end
+
+    it "should notify of a deploy" do
+      transmitter = double
+      Appsignal::Transmitter.should_receive(:new).with(
+        'http://localhost:3000/1',
+        'markers',
+        'abc'
+      ).and_return(transmitter)
+      transmitter.should_receive(:transmit).with(
+        :revision => 'aaaaa',
+        :repository => 'git@github.com:our/project.git',
+        :user => 'thijs'
+      )
+
+      cli.run([
+        'notify_of_deploy',
+        '--revision=aaaaa',
+        '--repository=git@github.com:our/project.git',
+        '--user=thijs',
+        '--environment=production'
+      ])
+    end
+  end
+end