appsignal 0.6.7 → 0.7.0.alpha.1

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

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
 describe Appsignal::Transmitter do
-  let(:_80beans_) { 'http://www.80beans.com' }
+  let(:config) { project_fixture_config }
   let(:action) { 'action' }
-  let(:klass) { Appsignal::Transmitter }
-  let(:instance) { klass.new(_80beans_, action, :the_api_key) }
-  subject { instance }
+  let(:instance) { Appsignal::Transmitter.new(action, config) }
 
   describe "#uri" do
-    it "returns the uri" do
-      Socket.stub(:gethostname => 'app1.local')
-      uri = subject.uri.to_s
-      uri.should include "http://www.80beans.com/action?"
-      uri.should include "api_key=the_api_key"
-      uri.should include "hostname=app1.local"
-      uri.should include "gem_version=#{Appsignal::VERSION}"
-    end
+    before { Socket.stub(:gethostname => 'app1.local') }
+
+    subject { instance.uri.to_s }
+
+    it { should include 'https://push.appsignal.com/1/action?' }
+    it { should include 'api_key=abc' }
+    it { should include 'hostname=app1.local' }
+    it { should include 'name=TestApp' }
+    it { should include 'environment=production' }
+    it { should include "gem_version=#{Appsignal::VERSION}" }
   end
 
   describe "#transmit" do
@@ -31,12 +31,17 @@ describe Appsignal::Transmitter do
   describe "#http_post" do
     it "calls Net::HTTP.post_form with the correct params" do
       post = double(:post)
-      post.should_receive(:[]=).
-        with('Content-Type', 'application/json; charset=UTF-8')
-      post.should_receive(:[]=).
-        with('Content-Encoding', 'gzip')
-      post.should_receive(:body=).
-        with(Zlib::Deflate.deflate("{\"the\":\"payload\"}", Zlib::BEST_SPEED))
+      post.should_receive(:[]=).with(
+        'Content-Type',
+        'application/json; charset=UTF-8'
+      )
+      post.should_receive(:[]=).with(
+        'Content-Encoding',
+        'gzip'
+      )
+      post.should_receive(:body=).with(
+        Zlib::Deflate.deflate("{\"the\":\"payload\"}", Zlib::BEST_SPEED)
+      )
       Socket.stub(:gethostname => 'app1.local')
 
       Net::HTTP::Post.should_receive(:new).with(
@@ -57,14 +62,16 @@ describe Appsignal::Transmitter do
     subject { instance.send(:http_client) }
 
     context "with a http uri" do
-      it { should be_instance_of(Net::HTTP) }
+      let(:config) { project_fixture_config('test') }
 
+      it { should be_instance_of(Net::HTTP) }
       its(:use_ssl?) { should be_false }
     end
 
     context "with a https uri" do
-      let(:instance) { klass.new('https://www.80beans.com', action, :the_api_key) }
+      let(:config) { project_fixture_config('production') }
 
+      it { should be_instance_of(Net::HTTP) }
       its(:use_ssl?) { should be_true }
       its(:verify_mode) { should == OpenSSL::SSL::VERIFY_PEER }
       its(:ca_file) { Appsignal::Transmitter::CA_FILE_PATH }

data/spec/lib/appsignal_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Appsignal do
+  before do
+    # Make sure we have a clean state because we want to test
+    # initialization here.
+    Appsignal.agent.shutdown if Appsignal.agent
+    Appsignal.config = nil
+    Appsignal.agent = nil
+  end
+
+  let(:transaction) { regular_transaction }
+
+  describe ".config=" do
+    it "should set the config" do
+      config = project_fixture_config
+      Appsignal.logger.should_not_receive(:level=)
+
+      Appsignal.config = config
+      Appsignal.config.should == config
+    end
+  end
+
+  describe ".start" do
+    it "should do nothing when config is not loaded" do
+      Appsignal.logger.should_receive(:error).with(
+        "Can't start, no config loaded"
+      )
+      Appsignal.start
+      Appsignal.agent.should be_nil
+    end
+
+    context "when config is loaded" do
+      before { Appsignal.config = project_fixture_config }
+
+      it "should start an agent" do
+        Appsignal.start
+        Appsignal.agent.should be_a Appsignal::Agent
+        Appsignal.logger.level.should == Logger::INFO
+      end
+    end
+
+    context "with debug logging" do
+      before { Appsignal.config = project_fixture_config('test') }
+
+      it "should change the log level" do
+        Appsignal.start
+        Appsignal.logger.level.should == Logger::DEBUG
+      end
+    end
+  end
+
+  describe '.active?' do
+    subject { Appsignal.active? }
+
+    context "without config" do
+      before { Appsignal.stub(:config => nil) }
+
+      it { should be_false }
+    end
+
+    context "with config but inactive" do
+      before { Appsignal.stub(:config => {:active => false}) }
+
+      it { should be_false }
+    end
+
+    context "with active config" do
+      before { Appsignal.stub(:config => {:active => true}) }
+
+      it { should be_true }
+    end
+  end
+
+  context "with config and started" do
+    before do
+      Appsignal.config = project_fixture_config
+      Appsignal.start
+    end
+
+    describe ".enqueue" do
+      subject { Appsignal.enqueue(transaction) }
+
+      it "forwards the call to the agent" do
+        Appsignal.agent.should respond_to(:enqueue)
+        Appsignal.agent.should_receive(:enqueue).with(transaction)
+        subject
+      end
+    end
+
+    describe ".tag_request" do
+      before { Appsignal::Transaction.stub(:current => transaction) }
+
+      context "with transaction" do
+        let(:transaction) { double }
+        it "should call set_tags on transaction" do
+
+          transaction.should_receive(:set_tags).with({'a' => 'b'})
+        end
+
+        after { Appsignal.tag_request({'a' => 'b'}) }
+      end
+
+      context "without transaction" do
+        let(:transaction) { nil }
+
+        it "should call set_tags on transaction" do
+          Appsignal.tag_request.should be_false
+        end
+      end
+    end
+
+    describe ".transactions" do
+      subject { Appsignal.transactions }
+
+      it { should be_a Hash }
+    end
+
+    describe '.logger' do
+      subject { Appsignal.logger }
+
+      it { should be_a Logger }
+    end
+
+    describe '.config' do
+      subject { Appsignal.config }
+
+      it { should be_a Appsignal::Config }
+      it 'should return configuration' do
+        subject[:endpoint].should == 'https://push.appsignal.com/1'
+      end
+    end
+
+    describe ".json" do
+      subject { Appsignal.json }
+
+      it { should == ActiveSupport::JSON }
+    end
+
+    describe ".post_processing_middleware" do
+      before { Appsignal.instance_variable_set(:@post_processing_chain, nil) }
+
+      it "returns the default middleware stack" do
+        Appsignal::Aggregator::PostProcessor.should_receive(:default_middleware)
+        Appsignal.post_processing_middleware
+      end
+
+      it "returns a chain when called without a block" do
+        instance = Appsignal.post_processing_middleware
+        instance.should be_an_instance_of Appsignal::Aggregator::Middleware::Chain
+      end
+
+      context "when passing a block" do
+        it "yields an appsignal middleware chain" do
+          Appsignal.post_processing_middleware do |o|
+            o.should be_an_instance_of Appsignal::Aggregator::Middleware::Chain
+          end
+        end
+      end
+    end
+
+    describe ".send_exception" do
+      it "should send the exception to AppSignal" do
+        agent = double
+        Appsignal.stub(:agent).and_return(agent)
+        agent.should_receive(:send_queue)
+        agent.should_receive(:enqueue).with(kind_of(Appsignal::Transaction))
+
+        Appsignal::Transaction.should_receive(:create).and_call_original
+      end
+
+      it "should not send the exception if it's in the ignored list" do
+        Appsignal.stub(:is_ignored_exception? => true)
+        Appsignal::Transaction.should_not_receive(:create)
+      end
+
+      after do
+        begin
+          raise "I am an exception"
+        rescue Exception => e
+          Appsignal.send_exception(e)
+        end
+      end
+    end
+
+    describe ".listen_for_exception" do
+      it "should call send_exception and re-raise" do
+        Appsignal.should_receive(:send_exception).with(kind_of(Exception))
+        lambda {
+          Appsignal.listen_for_exception do
+            raise "I am an exception"
+          end
+        }.should raise_error(RuntimeError, "I am an exception")
+      end
+    end
+
+    describe ".add_exception" do
+      before { Appsignal::Transaction.stub(:current => transaction) }
+      let(:exception) { RuntimeError.new('I am an exception') }
+
+      it "should add the exception to the current transaction" do
+        transaction.should_receive(:add_exception).with(exception)
+
+        Appsignal.add_exception(exception)
+      end
+
+      it "should do nothing if there is no current transaction" do
+        Appsignal::Transaction.stub(:current => nil)
+
+        transaction.should_not_receive(:add_exception).with(exception)
+
+        Appsignal.add_exception(exception)
+      end
+
+      it "should not add the exception if it's in the ignored list" do
+        Appsignal.stub(:is_ignored_exception? => true)
+
+        transaction.should_not_receive(:add_exception).with(exception)
+
+        Appsignal.add_exception(exception)
+      end
+
+      it "should do nothing if the exception is nil" do
+        transaction.should_not_receive(:add_exception)
+
+        Appsignal.add_exception(nil)
+      end
+    end
+  end
+end

data/spec/lib/generators/appsignal/appsignal_generator_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+if rails_present?
+  require 'generator_spec/test_case'
+  require './lib/generators/appsignal/appsignal_generator'
+
+  # The generator doesn't know we're testing
+  # So change the path while running the generator
+  # Change it back upon completion
+  def run_generator_in_tmp(args=[])
+    FileUtils.cd(tmp_dir) do
+      FileUtils.mkdir_p('config/environments')
+      FileUtils.touch('config/environments/development.rb')
+      FileUtils.touch('config/environments/production.rb')
+      @output = run_generator(args)
+    end
+  end
+
+  describe AppsignalGenerator do
+    include GeneratorSpec::TestCase
+    destination tmp_dir
+
+    before do
+      FileUtils.rm_rf(tmp_dir)
+    end
+
+    context "with key" do
+      context "known key" do
+        before do
+          authcheck = double
+          Appsignal::AuthCheck.should_receive(:new).and_return(authcheck)
+          authcheck.should_receive(:perform_with_result).and_return(['200', 'everything ok'])
+
+          prepare_destination
+          run_generator_in_tmp %w(my_app_key)
+        end
+
+        it "should generate a correct config file" do
+          fixture_config_file = File.open(File.join(fixtures_dir, 'generated_config.yml')).read
+          generated_config_file = File.open(File.join(tmp_dir, 'config/appsignal.yml')).read
+
+          generated_config_file.should == fixture_config_file
+        end
+
+        it "should mention successful auth check" do
+          @output.should include('success  everything ok')
+        end
+      end
+
+      context "invalid key" do
+        before do
+          authcheck = double
+          Appsignal::AuthCheck.should_receive(:new).and_return(authcheck)
+          authcheck.should_receive(:perform_with_result).and_return(['401', 'unauthorized'])
+
+          prepare_destination
+          run_generator_in_tmp %w(my_app_key)
+        end
+
+        it "should mention invalid key" do
+          @output.should include('error  unauthorized')
+        end
+      end
+
+      context "failed check" do
+        before do
+          authcheck = double
+          Appsignal::AuthCheck.should_receive(:new).and_return(authcheck)
+          authcheck.should_receive(:perform_with_result).and_return(['500', 'error!'])
+
+          prepare_destination
+          run_generator_in_tmp %w(my_app_key)
+        end
+
+        it "should mention failed check" do
+          @output.should include('error  error!')
+        end
+      end
+
+      context "internal failure" do
+        before do
+          authcheck = Appsignal::AuthCheck.new(nil, nil)
+          authcheck.stub(:perform).and_throw(:error)
+          Appsignal::AuthCheck.should_receive(:new).and_return(authcheck)
+
+          prepare_destination
+          run_generator_in_tmp %w(my_app_key)
+        end
+
+        it "should mention internal failure" do
+          @output.should include(
+            'Something went wrong while trying to '\
+            'authenticate with AppSignal:'
+          )
+        end
+      end
+    end
+
+    context "without key" do
+      before do
+        prepare_destination
+        run_generator_in_tmp %w()
+      end
+
+      it "should not create a config file" do
+        destination_root.should have_structure {
+          directory 'config' do
+            no_file 'appsignal.yml'
+            no_file 'deploy.rb'
+          end
+        }
+      end
+    end
+
+    context "without capistrano" do
+      before do
+        prepare_destination
+        run_generator_in_tmp %w(my_app_key)
+      end
+
+      it "should create a config file" do
+        destination_root.should have_structure {
+          directory 'config' do
+            file 'appsignal.yml'
+            no_file 'deploy.rb'
+          end
+        }
+      end
+
+      it "should mention the deploy task" do
+        @output.should include('No capistrano setup detected!')
+        @output.should include('appsignal notify_of_deploy -h')
+      end
+    end
+
+    context "with capistrano" do
+      before do
+        cap_file = File.join(destination_root, 'Capfile')
+        deploy_file = File.join(destination_root, 'config', 'deploy.rb')
+
+        prepare_destination
+        File.open(cap_file, 'w') {}
+        FileUtils.mkdir(File.join(destination_root, 'config'))
+        File.open(deploy_file, 'w') {}
+        run_generator_in_tmp %w(my_app_key)
+      end
+
+      it "should create a config file and modify the capistrano deploy file" do
+        destination_root.should have_structure {
+          file 'Capfile'
+          directory 'config' do
+            file 'appsignal.yml'
+            file 'deploy.rb' do
+              contains "require 'appsignal/capistrano'"
+            end
+          end
+        }
+      end
+
+      it "should not mention the deploy task" do
+        @output.should_not include('No capistrano setup detected!')
+        @output.should_not include('appsignal notify_of_deploy -h')
+      end
+    end
+  end
+end