sfalma 0.7

data/spec/sfalma/config_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sfalma::Config, 'defaults' do
+  before :each do
+    Sfalma::Config.reset
+  end
+  it "have sensible defaults" do
+    Sfalma::Config.ssl?.should == false
+    Sfalma::Config.remote_host.should == 'api.sfalma.com'
+    Sfalma::Config.remote_port.should == 80
+    Sfalma::Config.application_root.should == Dir.pwd
+    Sfalma::Config.http_proxy_host.should be_nil
+    Sfalma::Config.http_proxy_port.should be_nil
+    Sfalma::Config.http_proxy_username.should be_nil
+    Sfalma::Config.http_proxy_password.should be_nil
+    Sfalma::Config.http_open_timeout.should == 2
+    Sfalma::Config.http_read_timeout.should == 4
+  end
+  it "have correct defaults when ssl" do
+    Sfalma::Config.ssl = true
+    Sfalma::Config.remote_host.should == 'api.sfalma.com'
+    Sfalma::Config.remote_port.should == 443
+  end
+  it "be disabled based on environment by default" do
+    %w(development test).each do |env|
+      Sfalma::Config.stub!(:application_environment).and_return(env)
+      Sfalma::Config.should_send_to_api?.should == false
+    end    
+  end
+  it "be enabled based on environment by default" do
+    %w(production staging).each do |env|
+      Sfalma::Config.stub!(:application_environment).and_return(env)
+      Sfalma::Config.should_send_to_api?.should == true
+    end
+  end
+  context 'production environment' do
+    before :each do
+      Sfalma::Config.stub!(:application_environment).and_return('production')
+    end
+    it "allow a new simpler format for " do
+      Sfalma::Config.load('spec/fixtures/sfalma.yml')
+      Sfalma::Config.api_key.should == 'abc123'
+      Sfalma::Config.ssl?.should == true
+      Sfalma::Config.remote_host.should == 'example.com'
+      Sfalma::Config.remote_port.should == 123
+      Sfalma::Config.should_send_to_api?.should == true
+      Sfalma::Config.http_proxy_host.should == 'annoying-proxy.example.com'
+      Sfalma::Config.http_proxy_port.should == 1066
+      Sfalma::Config.http_proxy_username.should == 'bob'
+      Sfalma::Config.http_proxy_password.should == 'jack'
+      Sfalma::Config.http_open_timeout.should == 5
+      Sfalma::Config.http_read_timeout.should == 10
+    end
+    it "allow disable production environment" do      
+      Sfalma::Config.load('spec/fixtures/sfalma_disabled.yml')
+      Sfalma::Config.api_key.should == 'abc123'
+      Sfalma::Config.should_send_to_api?.should == false
+    end
+    it "load api_key from environment variable" do
+      ENV.should_receive(:[]).with('SFALMA_API_KEY').any_number_of_times.and_return('98765')
+      Sfalma::Config.api_key.should == '98765'
+    end
+  end
+end

data/spec/sfalma/controller_exception_data_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'digest/md5'
+
+
+class Sfalma::FunkyError < StandardError
+  def backtrace
+    'backtrace'
+  end
+end
+
+class BrokenJSON
+  def to_json
+    boom.time!
+  end
+end
+
+describe Sfalma::ControllerExceptionData do
+  it "raises useful error when to_json isn't available on to_hash" do
+    request = ActionController::TestRequest.new
+    brokenJson = BrokenJSON.new
+    session = {:boom => brokenJson}
+    request.stub!(:session).and_return(session)
+    data = Sfalma::ControllerExceptionData.new(Sfalma::FunkyError.new, nil, request)
+    JSON.parse(data.to_json)['request']['session']['data'].should == {"boom" => brokenJson.to_s}
+  end
+end

data/spec/sfalma/exception_data_spec.rb

@@ -0,0 +1,198 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'digest/md5'
+
+class Sfalma::FunkyError < StandardError
+  def backtrace
+    'backtrace'
+  end
+end
+
+describe Sfalma::ControllerExceptionData do
+  it "raises useful error when to_json isn't available on to_hash" do
+    begin
+      data = Sfalma::ExceptionData.new(Sfalma::FunkyError.new)
+      hash_without_json = {}
+      hash_without_json.stub!(:to_json).and_raise(NoMethodError)
+      data.stub!(:to_hash).and_return(hash_without_json)
+      data.to_json
+      fail 'expects to raise and error'
+    rescue StandardError => e
+      e.message.should =~ /to_json/
+    end
+  end
+end
+
+describe Sfalma::ControllerExceptionData, 'when no request/controller/params' do
+  before :each do
+    ENV['LOGNAME'] = 'bob'
+    ENV['SOMEVAR'] = 'something'
+    ENV['SOMEOTHERVAR'] = 'something else'
+    Sfalma::ENVIRONMENT_FILTER << 'SOMEOTHERVAR'
+    ENV['HTTP_SOMETHING'] = 'should be stripped'
+    ::RAILS_ENV = 'test' unless defined?(RAILS_ENV)
+    Time.stub!(:now).and_return(Time.mktime(1970, 1, 1))
+    error = Sfalma::FunkyError.new('some message')
+    @data = Sfalma::ControllerExceptionData.new(error)
+    @hash = @data.to_hash
+  end
+
+  it "capture exception details" do
+    error_hash = @hash['exception']
+    error_hash['exception_class'].should == 'Sfalma::FunkyError'
+    error_hash['message'].should == 'some message'
+    error_hash['backtrace'].should == 'backtrace'
+    DateTime.parse(error_hash['occurred_at']).should == DateTime.now
+    client_hash = @hash['client']
+    client_hash['name'].should == Sfalma::CLIENT_NAME
+    client_hash['version'].should == Sfalma::VERSION
+    client_hash['protocol_version'].should == Sfalma::PROTOCOL_VERSION
+  end
+
+  it "generates parseable json" do
+    require 'json'
+    JSON.parse(@data.to_json)['exception']['exception_class'].should == 'Sfalma::FunkyError'
+  end
+
+  it "capture application_environment" do
+    application_env_hash = @hash['application_environment']
+    application_env_hash['environment'].should == 'test'
+    application_env_hash['env'].should_not be_nil
+    application_env_hash['env']['SOMEVAR'].should == 'something'
+    application_env_hash['env']['SOMEOTHERVAR'].should == nil
+    application_env_hash['host'].should == `hostname`.strip
+    application_env_hash['run_as_user'].should == 'bob'
+    application_env_hash['application_root_directory'].should == Dir.pwd
+    application_env_hash['language'].should == 'ruby'
+    application_env_hash['language_version'].should == "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} #{RUBY_RELEASE_DATE} #{RUBY_PLATFORM}"
+    application_env_hash['framework'].should == "rails"
+    application_env_hash['libraries_loaded']['rails'].should =~ /\d\.\d\.\d/
+  end
+end
+
+describe Sfalma::ControllerExceptionData, 'with request/controller/params' do
+  class Sfalma::SomeController < ActionController::Base
+    filter_parameter_logging :filter_me
+  end
+
+  before :each do
+    @controller = Sfalma::SomeController.new
+    @request = ActionController::TestRequest.new({'action' => 'some_action' })
+    @request.request_uri = '/some_path?var1=abc'
+    @request.stub!(:parameters).and_return({'var1' => 'abc', 'action' => 'some_action', 'filter_me' => 'private'})
+    @request.stub!(:request_method).and_return(:get)
+    @request.stub!(:remote_ip).and_return('1.2.3.4')
+    @request.stub!(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_CONTENT_TYPE' => 'text/html'})
+    @error = Sfalma::FunkyError.new('some message')
+    data = Sfalma::ControllerExceptionData.new(@error, @controller, @request)
+    @hash = data.to_hash
+  end
+
+  it "captures request" do
+    request_hash = @hash['request']
+    request_hash['url'].should == 'http://test.host/some_path?var1=abc'
+    request_hash['controller'].should == 'Sfalma::SomeController'
+    request_hash['action'].should == 'some_action'
+    request_hash['parameters'].should == {'var1' => 'abc', 'action' => 'some_action', 'filter_me' => '[FILTERED]'}
+    request_hash['request_method'].should == 'get'
+    request_hash['remote_ip'].should == '1.2.3.4'
+    request_hash['headers'].should == {'Content-Type' => 'text/html'}
+  end
+
+  it "filter out objects that aren't jsonable" do
+    class Crazy
+      def initialize
+        @bar = self
+      end
+    end
+    crazy = Crazy.new
+    input = {'crazy' => crazy, :simple => '123', :some_hash => {'1' => '2'}, :array => ['1', '2']}
+    Sfalma::ControllerExceptionData.sanitize_hash(input).should == {'crazy' => crazy.to_s, :simple => '123', :some_hash => {'1' => '2'}, :array => ['1', '2']}
+  end
+  
+  it "allow if non jsonable objects are hidden in an array" do
+    class Bonkers
+      def to_json
+        no.can.do!
+      end
+    end
+    crazy = Bonkers.new
+    input = {'crazy' => [crazy]}
+    Sfalma::ControllerExceptionData.sanitize_hash(input).should == {'crazy' => [crazy.to_s]}    
+  end
+
+  it "filter params specified in env['action_dispatch.parameter_filter']" do
+    @request.stub!(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_CONTENT_TYPE' => 'text/html', 'action_dispatch.parameter_filter' => [:var1]})
+    @request.stub!(:parameters).and_return({'var1' => 'abc'})
+    data = Sfalma::ControllerExceptionData.new(@error, @controller, @request)
+    data.to_hash['request']['parameters'].should == {'var1' => '[FILTERED]'}
+  end
+
+  it "formats the occurred_at as iso8601" do
+    @request.stub!(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_CONTENT_TYPE' => 'text/html', 'action_dispatch.parameter_filter' => [:var1]})
+    @request.stub!(:parameters).and_return({'var1' => 'abc'})
+    data = Sfalma::ControllerExceptionData.new(@error, @controller, @request)
+    data.to_hash['exception']['occurred_at'].should match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.{1,6}$/)
+  end
+
+  it "ArgumentError bug with file object" do
+    file = File.new(File.expand_path('../../fixtures/favicon.png',__FILE__))
+    @request.stub!(:parameters).and_return({'something' => file })
+    data = Sfalma::ControllerExceptionData.new(@error, @controller, @request)
+    data.to_hash['request']['parameters']['something'].should == file.to_s
+  end
+
+  it "to_strings regex because JSON.parse(/aa/.to_json) doesn't work" do
+    input = {'crazy' => /abc.*/}
+    Sfalma::ExceptionData.sanitize_hash(input).should == {'crazy' => /abc.*/.to_s}
+  end
+
+  it "handles session objects with various interfaces" do
+    class SessionWithInstanceVariables
+      def initialize
+        @data = {'a' => '1', 'b' => /hello there Im a regex/i}
+        @session_id = '123'
+      end
+    end
+    
+    request = ActionController::TestRequest.new
+    session = SessionWithInstanceVariables.new
+    request.stub!(:session).and_return(session)
+    request.stub!(:session_options).and_return({})
+    Sfalma::ControllerExceptionData.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1', 'b' => "(?i-mx:hello there Im a regex)"}}
+    session = mock('session', :session_id => '123', :instance_variable_get => {'a' => '1', 'b' => /another(.+) regex/mx})
+    request.stub!(:session).and_return(session)
+    Sfalma::ControllerExceptionData.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1', 'b' => "(?mx-i:another(.+) regex)"}}
+    session = mock('session', :session_id => nil, :to_hash => {:session_id => '123', 'a' => '1'})
+    request.stub!(:session).and_return(session)
+    Sfalma::ControllerExceptionData.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1'}}
+    request.stub!(:session_options).and_return({:id => 'xyz'})
+    Sfalma::ControllerExceptionData.sanitize_session(request).should == {'session_id' => 'xyz', 'data' => {'a' => '1'}}
+  end
+
+  it "filter session cookies from headers" do
+    @request.stub!(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_COOKIE' => '_something_else=faafsafafasfa; _myapp-lick-nation_session=BAh7DDoMbnVtYmVyc1sJaQZpB2kIaQk6FnNvbWVfY3Jhenlfb2JqZWN0bzobU3Bpa2VDb250cm9sbGVyOjpDcmF6eQY6CUBiYXJABzoTc29tZXRoaW5nX2Vsc2UiCGNjYzoKYXBwbGUiDUJyYWVidXJuOgloYXNoewdpBmkHaQhpCToPc2Vzc2lvbl9pZCIlMmJjZTM4MjVjMThkNzYxOWEyZDA4NTJhNWY1NGQzMmU6C3RvbWF0byIJQmVlZg%3D%3D--66fb4606851f06bf409b8bc4ba7aea47a0259bf7'})
+    @hash = Sfalma::ControllerExceptionData.new(Sfalma::FunkyError.new('some message'), @controller, @request).to_hash
+    @hash['request']['headers'].should == {'Cookie' => '_something_else=faafsafafasfa; _myapp-lick-nation_session=[FILTERED]'}
+  end
+
+  it "creates a uniqueness_hash from backtrace" do
+    exception = Exception.new
+    exception.stub!(:backtrace).and_return(['123'])
+    data = Sfalma::ControllerExceptionData.new(exception)
+    data.uniqueness_hash.should == Digest::MD5.hexdigest('123')
+  end
+  
+  it "creates a nil uniqueness_hash if nil backtrace" do
+    exception = Exception.new
+    exception.stub!(:backtrace).and_return(nil)
+    data = Sfalma::ControllerExceptionData.new(exception)
+    data.uniqueness_hash.should == nil
+  end
+  
+  it "creates a uniqueness_hash from backtrace" do
+    exception = Exception.new
+    exception.stub!(:backtrace).and_return([])
+    data = Sfalma::ControllerExceptionData.new(exception)
+    data.uniqueness_hash.should == nil
+  end
+end

data/spec/sfalma/monkeypatches_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.join(File.dirname(__FILE__), '../..', 'lib', 'sfalma', 'monkeypatches')
+
+describe Regexp do
+  it "should output a correctly formatted string" do
+    /hello/.to_json.should == "\"(?-mix:hello)\""
+  end
+  it "should output a correctly formatted string" do
+    2.to_json.should == "2"
+  end
+end

data/spec/sfalma/rack_exception_data_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'digest/md5'
+
+describe Sfalma::RackExceptionData do
+
+  class Sfalma::FunkyError < StandardError
+    def backtrace
+      'backtrace'
+    end
+  end
+
+  before :each do
+    app = lambda { |env| [200, {'Content-Type'=>'text/plain'}, 'Hello World']}     
+        
+    @env = {
+      "HTTP_HOST" =>"localhost:9292",
+      "HTTP_ACCEPT" =>"*/*",
+      "SERVER_NAME" =>"localhost",
+      "REQUEST_PATH" =>"/",
+      "rack.url_scheme" =>"http",
+      "HTTP_USER_AGENT" =>"curl/7.19.6 (i386-apple-darwin9.8.0) libcurl/7.19.6 zlib/1.2.3",
+      "REMOTE_HOST" =>"testing.com",
+      "rack.errors" => StringIO.new,
+      "SERVER_PROTOCOL" =>"HTTP/1.1",
+      "rack.version" =>[1, 1],
+      "rack.run_once" =>false,
+      "SERVER_SOFTWARE" =>"WEBrick/1.3.1 (Ruby/1.8.7/2009-06-12)",
+      "REMOTE_ADDR" =>"127.0.0.1",
+      "PATH_INFO" => "/",
+      "SCRIPT_NAME" =>"",
+      "HTTP_VERSION" =>"HTTP/1.1",
+      "rack.multithread" =>true,
+      "rack.multiprocess" =>false,
+      "REQUEST_URI" =>"http://localhost:9292/",
+      "SERVER_PORT" =>"9292",
+      "REQUEST_METHOD" =>"GET",
+      "rack.input" => StringIO.new,
+      "QUERY_STRING" =>"cockle=shell&bay=cool",
+      "GATEWAY_INTERFACE" =>"CGI/1.1"
+    }
+                        
+    error = Sfalma::FunkyError.new('some message')
+    request = Rack::Request.new(@env)
+    @data = Sfalma::RackExceptionData.new(error, @env, request)
+  end
+  
+  it "capture exception details" do    
+    error_hash = @data.to_hash['exception']
+    error_hash['exception_class'].should == 'Sfalma::FunkyError'
+    error_hash['message'].should == 'some message'
+    error_hash['backtrace'].should == 'backtrace'
+    DateTime.parse(error_hash['occurred_at']).should == DateTime.parse(Time.now.to_json)
+  end
+
+  it "should capture request details" do
+    request_hash = @data.to_hash['request']
+    request_hash['url'].should == 'http://localhost:9292/?cockle=shell&bay=cool'
+    request_hash['parameters'].should == {"cockle"=>"shell", "bay"=>"cool"} 
+    request_hash['request_method'].should == 'GET'
+    request_hash['remote_ip'].should == '127.0.0.1'
+    request_hash['headers'].should == {"Host"=>"localhost:9292", "Accept"=>"*/*", "User-Agent"=>"curl/7.19.6 (i386-apple-darwin9.8.0) libcurl/7.19.6 zlib/1.2.3", "Version"=>"HTTP/1.1"}
+    request_hash['session'].should == {'data' => {}, 'session_id' => ''}
+  end
+
+  it "should capture client detais" do
+    client_hash = @data.to_hash['client']
+    client_hash['name'].should == Sfalma::CLIENT_NAME
+    client_hash['version'].should == Sfalma::VERSION
+    client_hash['protocol_version'].should == Sfalma::PROTOCOL_VERSION
+  end
+  
+  it "should captire application environment" do
+    env_hash = @data.to_hash['application_environment']
+    env_hash['env'].should_not be_empty #execution dependent
+    env_hash['libraries_loaded'].should_not be_empty #execution dependent
+    env_hash['language'].should == 'ruby' #execution dependent
+    
+    env_hash['language_version'].should_not be_empty #execution dependent
+    env_hash['environment'].should == 'test'
+    env_hash['application_root_directory'].should_not be_empty
+    env_hash['run_as_user'].should_not be_empty
+    env_hash['host'].should_not be_empty
+    
+    env_hash['framework'].should == 'rack'
+  end
+  
+end

data/spec/sfalma/remote_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'zlib'
+require 'digest/md5'
+
+describe Sfalma::Remote do
+  before :each do
+    Sfalma::Config.reset
+    Sfalma::Config.api_key = 'abc123'
+  end
+
+  it "calls remote with api_key, protocol_version and json" do
+    expected_url = "/api/errors?api_key=abc123&protocol_version=#{Sfalma::PROTOCOL_VERSION}"
+    expected_data = mock('data',:uniqueness_hash => nil, :to_json => '123')
+    Sfalma::Remote.should_receive(:call_remote).with(expected_url, Zlib::Deflate.deflate(expected_data.to_json,Zlib::BEST_SPEED))
+    Sfalma::Remote.error(expected_data)
+  end
+
+  it "adds hash of backtrace as paramater if it is present" do
+    expected_url = "/api/errors?api_key=abc123&protocol_version=#{Sfalma::PROTOCOL_VERSION}&hash=blah"
+    expected_data = mock('data',:uniqueness_hash => 'blah', :to_json => '123')
+    Sfalma::Remote.should_receive(:call_remote).with(expected_url, Zlib::Deflate.deflate(expected_data.to_json,Zlib::BEST_SPEED))
+    Sfalma::Remote.error(expected_data)
+  end
+
+  it "calls remote for startup" do
+    expected_url = "/api/announcements?api_key=abc123&protocol_version=#{Sfalma::PROTOCOL_VERSION}"
+    startup_data = mock('data',:to_json => '123')
+    Sfalma::Remote.should_receive(:call_remote).with(expected_url, Zlib::Deflate.deflate(startup_data.to_json,Zlib::BEST_SPEED))
+    Sfalma::Remote.startup_announce(startup_data)
+  end
+end

data/spec/sfalma/startup_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sfalma::Startup, 'announce_and_authenticate' do
+  it "raise StartupException if api_key is nil" do
+    Sfalma::Config.api_key = ''
+    lambda { Sfalma::Startup.announce }.should raise_error(Sfalma::StartupException, /API Key/)
+  end
+  it "calls Remote announce" do
+    Sfalma::Config.api_key = '123'
+    Sfalma::Remote.should_receive(:startup_announce).with(hash_including({'client' => { 'name' => Sfalma::CLIENT_NAME,
+                                                                                     'version' => Sfalma::VERSION,
+                                                                                     'protocol_version' => Sfalma::PROTOCOL_VERSION}}))
+    Sfalma::Startup.announce
+  end
+end

data/spec/sfalma_rescue_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context 'resuce errors from within a block' do
+  class FunkyException < StandardError;
+  end
+  it "Sfalma.rescue should send to sfalma and swallow error " do
+    to_raise = FunkyException.new
+    Sfalma::Catcher.should_receive(:handle).with(to_raise, 'my rescue name')
+    Sfalma.rescue('my rescue name') do
+      raise to_raise
+    end
+  end
+
+  it "reraises error with rescue_and_reraise" do
+    to_raise = FunkyException.new
+    Sfalma::Catcher.should_receive(:handle).with(to_raise, 'my rescue name')
+    begin
+      Sfalma.rescue_and_reraise('my rescue name') do
+        raise to_raise
+      end
+      fail 'expected a reraise'
+    rescue FunkyException => e
+    end
+  end
+
+  it "Sfalma.handle calls Sfalma::Catcher.handle" do
+    to_raise = FunkyException.new
+    Sfalma::Catcher.should_receive(:handle).with(to_raise, 'optional name for where it has occurred')
+    begin
+      raise to_raise
+    rescue => e
+      Sfalma.handle(e, 'optional name for where it has occurred')
+    end
+  end
+
+  it "collects context information but leaves thread local empty after block" do
+    to_raise = FunkyException.new
+    Sfalma::Config.should_receive(:should_send_to_api?).and_return(true)
+    Sfalma::Remote.should_receive(:error) {|exception_data|
+      exception_data.to_hash['context']['foo'] == 'bar'
+      exception_data.to_hash['context']['baz'] == 42
+      exception_data.to_hash['context']['cats'] == {'lol' => 'bot'}
+    }
+    Sfalma.rescue('my rescue name') do
+      Sfalma.context('foo' => 'bar')
+      Sfalma.context('baz' => 42)
+      Sfalma.context('cats' => {'lol' => 'bot'})
+      raise to_raise
+    end
+    Thread.current[:exceptional_context].should == nil
+  end
+
+  it "clearr context with Sfalma.context.clear!" do
+    Sfalma.context('foo' => 'bar')
+    Thread.current[:exceptional_context].should_not == nil
+    Sfalma.context.clear!
+    Thread.current[:exceptional_context].should == nil
+  end
+
+  it "allows optional second paramater hash to get added to context" do
+    Sfalma.should_receive(:context).with(context_hash = {'foo' => 'bar', 'baz' => 42})
+    Sfalma.rescue('my rescue', context_hash) {}
+  end
+  
+  it "should clear context after every invocation" do
+    Thread.current[:exceptional_context].should == nil
+
+    Sfalma.rescue('my rescue', context_hash = {'foo' => 'bar', 'baz' => 42}) {
+      Thread.current[:exceptional_context].should_not == nil      
+    }
+    
+    Thread.current[:exceptional_context].should == nil        
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+begin
+  require 'ginger'
+rescue LoadError
+  raise "cant load ginger"
+end
+
+gem 'rails'
+require File.dirname(__FILE__) + '/../lib/sfalma' unless defined?(Sfalma)
+
+ENV['RAILS_ENV'] = 'test'
+
+require 'action_controller'
+require 'action_controller/test_process'
+
+def send_request(action = nil,params={})
+  @request = ActionController::TestRequest.new
+  @request.query_parameters = @request.query_parameters.merge(params)
+  @request.stub!(:request_method).and_return('GET')
+  @request.action = action ? action.to_s : ""
+  @response = ActionController::TestResponse.new
+  @controller.process(@request, @response)
+end

data/spec/standalone_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'sfalma', 'integration', 'rails')
+
+describe Sfalma do
+  it "set the api key" do
+    Sfalma.configure('api-key')
+    Sfalma::Config.api_key.should == 'api-key'
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: sfalma
+version: !ruby/object:Gem::Version
+  version: '0.7'
+  prerelease: 
+platform: ruby
+authors:
+- Sfalma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-05-05 00:00:00.000000000 +03:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &15079640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *15079640
+description: ! 'Sfalma is the Ruby gem for communicating with http://sfalma.com (hosted
+  error tracking service). Use it to find out about errors that happen in your web
+  or mobile app. '
+email: info@sfalma.com
+executables:
+- sfalma
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tasks/sfalma_tasks.rake
+- lib/sfalma/vcs.rb
+- lib/sfalma/config.rb
+- lib/sfalma/log_factory.rb
+- lib/sfalma/rack_exception_data.rb
+- lib/sfalma/railtie.rb
+- lib/sfalma/application_environment.rb
+- lib/sfalma/version.rb
+- lib/sfalma/integration/dj.rb
+- lib/sfalma/integration/rack_rails.rb
+- lib/sfalma/integration/rack.rb
+- lib/sfalma/integration/rails.rb
+- lib/sfalma/integration/alerter.rb
+- lib/sfalma/integration/tester.rb
+- lib/sfalma/integration/sinatra.rb
+- lib/sfalma/remote.rb
+- lib/sfalma/monkeypatches.rb
+- lib/sfalma/alert_data.rb
+- lib/sfalma/startup.rb
+- lib/sfalma/controller_exception_data.rb
+- lib/sfalma/catcher.rb
+- lib/sfalma/exception_data.rb
+- lib/sfalma.rb
+- spec/rails_integration_spec.rb
+- spec/sfalma_rescue_spec.rb
+- spec/ginger_scenarios.rb
+- spec/fixtures/favicon.png
+- spec/fixtures/sfalma.yml
+- spec/fixtures/sfalma_disabled.yml
+- spec/bin/ginger
+- spec/rails_rack_integration_spec.rb
+- spec/rack_integration_spec.rb
+- spec/sfalma/alert_exception_data_spec.rb
+- spec/sfalma/rack_exception_data_spec.rb
+- spec/sfalma/startup_spec.rb
+- spec/sfalma/config_spec.rb
+- spec/sfalma/catcher_spec.rb
+- spec/sfalma/remote_spec.rb
+- spec/sfalma/exception_data_spec.rb
+- spec/sfalma/monkeypatches_spec.rb
+- spec/sfalma/controller_exception_data_spec.rb
+- spec/spec_helper.rb
+- spec/dj_integration_spec.rb
+- spec/standalone_spec.rb
+- rails/init.rb
+- init.rb
+- install.rb
+- sfalma.gemspec
+- bin/sfalma
+has_rdoc: true
+homepage: http://sfalma.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- json_pure, json-jruby or json gem required
+rubyforge_project: sfalma
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: sfalma.com is a cloud-based error tracker with a social twist with a focus
+  on mobile apps
+test_files: []