appsignal 0.6.7 → 0.7.0.alpha.1

data/spec/appsignal/railtie_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'action_controller/railtie'
-require 'appsignal/railtie'
-
-describe Appsignal::Railtie do
-  it "should log to the in memory log before init" do
-    Appsignal.logger.error('Log something before init')
-    Appsignal.in_memory_log.string.should include('Log something before init')
-  end
-
-  context "after initializing the app" do
-    before(:all) { MyApp::Application.initialize! }
-
-    it "should start logging to file and have written the in memory log" do
-      Appsignal.logger.should be_instance_of(Logger)
-      File.open(log_file).read.should include(
-        'Log something before init'
-      )
-    end
-
-    it "should have set the appsignal subscriber" do
-      if defined? ActiveSupport::Notifications::Fanout::Subscribers::Timed
-        # Rails 4
-        Appsignal.subscriber.
-          should be_a ActiveSupport::Notifications::Fanout::Subscribers::Timed
-      else
-        # Rails 3
-        Appsignal.subscriber.
-          should be_a ActiveSupport::Notifications::Fanout::Subscriber
-      end
-    end
-
-    it "should have added the listener middleware for exceptions" do
-      MyApp::Application.middleware.to_a.should include Appsignal::Listener
-    end
-
-    context "non action_controller event" do
-      it "should call add_event for non action_controller event" do
-        current = double(:current)
-        current.should_receive(:add_event)
-        Appsignal::Transaction.should_receive(:current).twice.
-          and_return(current)
-      end
-
-      after { ActiveSupport::Notifications.instrument 'query.mongoid' }
-    end
-
-    context "action_controller event" do
-      it "should call set_process_action_event for action_controller event" do
-        current = double(:current)
-        current.should_receive(:set_process_action_event)
-        current.should_receive(:add_event)
-        Appsignal::Transaction.should_receive(:current).exactly(3).times.
-          and_return(current)
-      end
-
-      after do
-        ActiveSupport::Notifications.
-          instrument 'process_action.action_controller'
-      end
-    end
-
-    context "event that starts with a bang" do
-      it "should not be processed" do
-        Appsignal::Transaction.should_not_receive(:current)
-      end
-
-      after do
-        ActiveSupport::Notifications.
-          instrument '!render_template'
-      end
-    end
-  end
-end

data/spec/appsignal/to_appsignal_hash_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Appsignal::ToAppsignalHash do
-  subject { notification_event }
-
-  it { should be_instance_of ActiveSupport::Notifications::Event }
-  it { should respond_to(:to_appsignal_hash) }
-
-  describe "#to_appsignal_hash" do
-    subject { notification_event.to_appsignal_hash }
-
-    it { should == {
-      :time => 978364860.0,
-      :duration => be_within(0.01).of(100.0),
-      :end => 978364860.1,
-      :name => "process_action.action_controller",
-      :payload => {
-        :path=>"/blog",
-        :action=>"show",
-        :controller=>"BlogPostsController",
-        :request_format=>"html",
-        :request_method=>"GET",
-        :status=>"200",
-        :view_runtime=>500,
-        :db_runtime=>500
-      }
-    } }
-  end
-end

data/spec/appsignal_spec.rb

@@ -1,195 +0,0 @@
-require 'spec_helper'
-
-describe Appsignal do
-  it { should respond_to :subscriber }
-  let(:transaction) { regular_transaction }
-
-  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 '.agent' do
-    subject { Appsignal.agent }
-
-    it { should be_a Appsignal::Agent }
-  end
-
-  describe '.logger' do
-    subject { Appsignal.logger }
-
-    it { should be_a Logger }
-    its(:level) { should == Logger::INFO }
-  end
-
-  describe '.config' do
-    subject { Appsignal.config }
-
-    it 'should return the endpoint' do
-      subject[:endpoint].should eq 'http://localhost:3000/1'
-    end
-
-    it 'should return the api key' do
-      subject[:api_key].should eq 'ghi'
-    end
-
-    it 'should return ignored exceptions' do
-      subject[:ignore_exceptions].should eq []
-    end
-
-    it 'should return the slow request threshold' do
-      subject[:slow_request_threshold].should eq 200
-    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::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::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::Middleware::Chain
-        end
-      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
-
-  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

data/spec/generators/appsignal/appsignal_generator_spec.rb

@@ -1,181 +0,0 @@
-require 'spec_helper'
-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("spec/tmp") do
-    @output = run_generator(args)
-  end
-end
-
-describe AppsignalGenerator do
-  include GeneratorSpec::TestCase
-  destination File.expand_path("../../../tmp", __FILE__)
-
-  context "with key" do
-    context "known key" do
-      before do
-        prepare_destination
-        authcheck = double
-        Appsignal::AuthCheck.should_receive(:new).and_return(authcheck)
-        authcheck.should_receive(:perform_with_result).
-          and_return(['200', 'everything ok'])
-        run_generator_in_tmp %w(production my_app_key)
-      end
-
-      specify "should mention successful auth check" do
-        @output.should include('success  everything ok')
-      end
-    end
-
-    context "invalid key" do
-      before do
-        prepare_destination
-        authcheck = double
-        Appsignal::AuthCheck.should_receive(:new).and_return(authcheck)
-        authcheck.should_receive(:perform_with_result).
-          and_return(['401', 'unauthorized'])
-        run_generator_in_tmp %w(production my_app_key)
-      end
-
-      specify "should mention invalid key" do
-        @output.should include('error  unauthorized')
-      end
-    end
-
-    context "failed check" do
-      before do
-        prepare_destination
-        authcheck = double
-        Appsignal::AuthCheck.should_receive(:new).and_return(authcheck)
-        authcheck.should_receive(:perform_with_result).
-          and_return(['500', 'error!'])
-        run_generator_in_tmp %w(production my_app_key)
-      end
-
-      specify "should mention failed check" do
-        @output.should include('error  error!')
-      end
-    end
-
-    context "internal failure" do
-      before do
-        prepare_destination
-        authcheck = Appsignal::AuthCheck.new
-        Appsignal::AuthCheck.should_receive(:new).and_return(authcheck)
-        authcheck.should_receive(:perform).
-          and_throw(:error)
-        run_generator_in_tmp %w(production my_app_key)
-      end
-
-      specify "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
-
-    specify "no config files are created" 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 :all do
-      prepare_destination
-      run_generator_in_tmp %w(production my_app_key)
-    end
-
-    specify "config file is created" do
-      destination_root.should have_structure {
-        directory 'config' do
-          file 'appsignal.yml'
-          no_file 'deploy.rb'
-        end
-      }
-    end
-
-    specify "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 :all do
-      prepare_destination
-      cap_file = File.expand_path('Capfile', destination_root)
-      File.open(cap_file, 'w') {}
-      FileUtils.mkdir(File.expand_path('config', destination_root))
-      deploy_file = File.expand_path(File.join('config', 'deploy.rb'),
-        destination_root)
-      File.open(deploy_file, 'w') {}
-      run_generator_in_tmp %w(production my_app_key)
-    end
-
-    specify "config file is created and capistrano deploy file modified" 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
-
-    specify "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
-
-  context "with custom environment" do
-    before do
-      prepare_destination
-      run_generator_in_tmp %w(development my_app_key)
-    end
-
-    specify "config file is created" do
-      destination_root.should have_structure {
-        directory 'config' do
-          file 'appsignal.yml'
-          no_file 'deploy.rb'
-        end
-      }
-    end
-  end
-
-  context "with multiple environments" do
-    context "with new environment" do
-      before :all do
-        prepare_destination
-        FileUtils.mkdir(File.expand_path('config', destination_root))
-        config_file = File.join('config', 'appsignal.yml')
-        File.open(File.expand_path(config_file, destination_root), 'w') do |f|
-          f.write("production:\n  api_key: 111")
-        end
-        run_generator_in_tmp %w(development my_app_key)
-      end
-
-      it "exits and tells to manually edit config/appsignal.yml" do
-        @output.should include('error  Looks like you already have a config file')
-      end
-    end
-  end
-end