guardrail_notifier 0.2.11

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "actionpack", "3.2.8"
+  gem "json"
+  gem "fakeweb"
+  gem "shoulda"
+  gem "mocha"
+  gem "rake"
+  gem "jeweler"
+end
+

data/Gemfile.lock

@@ -0,0 +1,67 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionpack (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    builder (3.0.3)
+    erubis (2.7.0)
+    fakeweb (1.3.0)
+    git (1.2.5)
+    hike (1.2.1)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    journey (1.0.4)
+    json (1.7.5)
+    metaclass (0.0.1)
+    mocha (0.12.7)
+      metaclass (~> 0.0.1)
+    multi_json (1.3.6)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    shoulda (3.3.0)
+      shoulda-context (~> 1.0)
+      shoulda-matchers (~> 1.4)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.4.0)
+      activesupport (>= 3.0.0)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    tilt (1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  actionpack (= 3.2.8)
+  fakeweb
+  jeweler
+  json
+  mocha
+  rake
+  shoulda

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Terrible Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,98 @@
+= GuardrailNotifier
+
+{<img src="https://travis-ci.org/terriblelabs/guardrail_notifier.png" />}[https://travis-ci.org/terriblelabs/guardrail_notifier]
+
+Stop hurting your users!
+
+Guardrail captures validation errors from your Ruby on Rails application to help you identify and fix user experience issues. The GuardrailNotifier gem makes it easy to hook up your app to the Guardrail web service.
+
+If you haven't already signed up for a Guardrail account, visit http://guardrailapp.com.
+
+
+= Installation
+
+=== Rails 3
+
+* Add the following line to Gemfile:
+
+    gem 'guardrail_notifier'
+
+* Install the gem:
+
+    bundle install
+
+=== Rails 2.3
+
+* Add the following line to config/environment.rb:
+
+    config.gem 'guardrail_notifier'
+
+* Install the gem:
+
+    [sudo] rake gems:install GEM=guardrail_notifier
+
+= Configuration
+
+In your Rails app, create config/initializers/guardrail_notifier.rb and add the following line with the API key for your Guardrail project:
+
+    GuardrailNotifier.configure do |config|
+      config.api_key = "<YOUR API KEY>"
+    end
+
+Or, if you prefer to keep API keys and the like out of your code, set the GUARDRAIL_API_KEY environment variable and GuardrailNotifier will find it automatically.
+
+Validation errors will now be submitted to the Guardrail service on your create and update actions in production mode.
+
+= Advanced Usage
+
+=== Tracking custom actions
+
+GuardrailNotifier assumes your app is RESTful, so it only monitors the create and update actions by default. If you're creating or updating records in non-RESTful actions, you can use an after_filter to make sure any validation failures in those actions are caught as well:
+
+    after_filter :log_validation_failures_to_guardrail, :only => [:create, :update, :my_custom_action]
+
+=== Running in other environments
+
+GuardrailNotifier is only enabled in the production environment by default. If you want to enable it in additional environments, such as staging, you'll need to add the following line to your Guardrail initializer:
+
+    GuardrailNotifier.configure do |config|
+      config.monitored_environments << 'staging'
+    end
+
+=== SSL
+
+GuardrailNotifier uses a secure connection over SSL by default, but you can easily disable it if you prefer:
+
+    GuardrailNotifier.configure do |config|
+      config.secure = false
+    end
+
+=== Filtering params
+
+GuardrailNotifier records the parameters submitted in actions that cause validation errors. Because your app may handle sensitive data, like passwords, credit card numbers, and nuclear launch codes, GuardrailNotifier respects the parameter filtering that you configure in Rails in config/application.rb (Rails 3) or ApplicationController (Rails 2.3). For example in Rails 3:
+
+    config.filter_parameters += [:password, :secret, :cvv]
+
+Per Rails convention, those params will show up as "[FILTERED]" in the data submitted to Guardrail.
+
+
+== Contact information
+
+* Twitter: @guardrailapp
+* Email: jeremy@guardrailapp.com, jeff@guardrailapp.com
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with Rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Terrible Labs, Inc. See LICENSE for details.
+

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rake'
+require File.dirname(__FILE__) + "/lib/guardrail_notifier/version.rb"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version = GuardrailNotifier::VERSION
+    gem.name = "guardrail_notifier"
+    gem.summary = %Q{Guardrail (http://guardrailapp.com) captures validation errors from your Ruby on Rails application.}
+    gem.description = %Q{Guardrail captures validation errors from your Ruby on Rails application to help you identify and fix user experience issues. The GuardrailNotifier gem makes it easy to hook up your app to the Guardrail web service.}
+    gem.email = "support@guardrailapp.com"
+    gem.homepage = "http://github.com/terriblelabs/guardrail_notifier"
+    gem.authors = ["Jeffrey Chupp", "Jeremy Weiskotten"]
+    gem.add_development_dependency "shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = GuardrailNotifier::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "guardrail_notifier #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/guardrail_notifier.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "guardrail_notifier"
+  s.version = "0.2.11"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jeffrey Chupp", "Jeremy Weiskotten"]
+  s.date = "2012-10-12"
+  s.description = "Guardrail captures validation errors from your Ruby on Rails application to help you identify and fix user experience issues. The GuardrailNotifier gem makes it easy to hook up your app to the Guardrail web service."
+  s.email = "support@guardrailapp.com"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "guardrail_notifier.gemspec",
+    "lib/guardrail_notifier.rb",
+    "lib/guardrail_notifier/configuration.rb",
+    "lib/guardrail_notifier/rails/action_controller_monitor.rb",
+    "lib/guardrail_notifier/sender.rb",
+    "lib/guardrail_notifier/version.rb",
+    "test/guardrail_test.rb",
+    "test/helper.rb",
+    "test/sender_test.rb"
+  ]
+  s.homepage = "http://github.com/terriblelabs/guardrail_notifier"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "Guardrail (http://guardrailapp.com) captures validation errors from your Ruby on Rails application."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<actionpack>, ["= 3.2.8"])
+      s.add_development_dependency(%q<json>, [">= 0"])
+      s.add_development_dependency(%q<fakeweb>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<actionpack>, ["= 3.2.8"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<fakeweb>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<actionpack>, ["= 3.2.8"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<fakeweb>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+  end
+end
+

data/lib/guardrail_notifier.rb

@@ -0,0 +1,37 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'guardrail_notifier/version'
+require 'guardrail_notifier/configuration'
+require 'guardrail_notifier/sender'
+require 'guardrail_notifier/rails/action_controller_monitor'
+
+module GuardrailNotifier
+  API_VERSION = "alpha 1"
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(self.configuration)
+    end
+
+    def sender
+      @sender ||= Sender.new(self.configuration)
+    end
+
+    def notify(data)
+      self.sender.send_to_guardrail(data.merge(notifier_params))
+    end
+
+    def notifier_params
+      @notifier_params ||= {
+        :notifier_version => self.configuration.notifier_version,
+        :api_key          => self.configuration.api_key || ENV['GUARDRAIL_API_KEY'],
+        :api_version      => API_VERSION
+      }
+    end
+  end
+end

data/lib/guardrail_notifier/configuration.rb

@@ -0,0 +1,33 @@
+module GuardrailNotifier
+  class Configuration
+    attr_accessor :api_key
+
+    # The set of environments that should be monitored for validation errors (defaults to
+    # only the production environment).
+    attr_accessor :monitored_environments
+
+    # Number of seconds after which submission to Guardrail should timeout (defaults to 5).
+    attr_accessor :timeout_in_seconds
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+    alias_method :secure?, :secure
+
+    # A +call+able object, such as a Proc, to be invoked if an exception occurs when
+    # logging to Guardrail (defaults to nil). For example, to notify Hoptoad:
+    #
+    #   config.on_exception = proc { |e| notify_hoptoad(e) }
+    attr_accessor :on_exception
+
+    # The version of the notifier (defaults to the version of this gem).
+    attr_reader :notifier_version
+
+    def initialize
+      @notifier_version = VERSION
+      @timeout_in_seconds = 5
+      @monitored_environments = ['production']
+      @secure = true
+      @on_exception = nil
+    end
+  end
+end

data/lib/guardrail_notifier/rails/action_controller_monitor.rb

@@ -0,0 +1,125 @@
+module GuardrailNotifier
+  module Rails
+    # This module is mixed into ActionController::Base.
+    module ActionControllerMonitor
+
+      def self.included(base)
+        base.after_filter :log_validation_failures_to_guardrail, :only => [:create, :update]
+      end
+
+      protected
+
+      def log_validation_failures_to_guardrail
+        if should_log_failures_to_guardrail? && records_with_errors.present?
+          GuardrailNotifier.notify(guardrail_params)
+        end
+      rescue Exception => e
+        ::Rails.logger.error("Failed to log validation failure to Guardrail")
+
+        handler = GuardrailNotifier.configuration.on_exception
+        handler.call(e) if !handler.nil? && handler.respond_to?(:call)
+      end
+
+      def should_log_failures_to_guardrail?
+        GuardrailNotifier.configuration.monitored_environments.include?(::Rails.env.to_s)
+      end
+
+      def records_with_errors
+        @records_with_errors ||= begin
+          instance_variable_names.map do |var_name|
+            var = instance_variable_get(var_name)
+            if var.is_a?(Array)
+              var.select{|v| record_has_errors?(v)}
+            else
+              var if record_has_errors?(var)
+            end
+          end.flatten.compact
+        end
+      end
+
+      def record_has_errors?(record)
+        record.respond_to?(:errors) && record.errors.present?
+      end
+
+      def guardrail_params
+        {}.tap do |query|
+          query[:_controller]  = params['controller']
+          query[:_action]      = params['action']
+          query[:path]         = request.path
+          query[:data]         = request_data.to_json
+
+          query[:failures] = records_with_errors.map do |record|
+            error_hashes(record)
+          end.flatten.to_json
+        end
+      end
+
+      def error_hashes(record)
+        record.errors.map do |field, messages|
+          Array.wrap(messages).map do |message|
+            error_hash(record.class, field, message)
+          end
+        end
+      end
+
+      def error_hash(clazz, field, message)
+        {
+          :model   => clazz.to_s,
+          :field   => field,
+          :message => message
+        }
+      end
+
+      def request_data
+        {}.tap do |data|
+          # TODO: limit this in size - how big?
+          data[:params] = filtered_params # TODO: controller and action are redundant
+
+          if respond_to?(:current_user) && !current_user.nil?
+            data[:current_user] = current_user.id
+          end
+
+          data[:user_agent] = request.user_agent
+          data[:cookies] = stringify_values(request.cookies)
+          data[:session] = stringify_values(request.session)
+        end
+      end
+
+      def filtered_params
+        p = if respond_to?(:filter_parameters)
+          # pre-Rails 3
+          filter_parameters(params)
+        elsif request.respond_to?(:filtered_parameters)
+          # Rails 3
+          request.filtered_parameters
+        else
+          params
+        end
+        filter_files_from_params(p)
+      end
+
+      def filter_files_from_params(params)
+        params.each do |k,v|
+          if v.is_a?(Hash)
+            filter_files_from_params(v)
+          elsif v.is_a?(Tempfile)
+            params[k] = '[FILTERED]'
+          end
+        end
+      end
+
+      def stringify_values(values)
+        case values
+        when Array
+          values.map { |v| stringify_values(v) }
+        when Hash
+          Hash[values.map { |k,v| [k, stringify_values(v)] }]
+        else
+          values.to_s
+        end
+      end
+    end
+  end
+end
+
+ActionController::Base.send(:include, GuardrailNotifier::Rails::ActionControllerMonitor)

data/lib/guardrail_notifier/sender.rb

@@ -0,0 +1,43 @@
+module GuardrailNotifier
+  class Sender
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def protocol
+      self.configuration.secure? ? 'https' : 'http'
+    end
+
+    def port
+      self.configuration.secure? ? 443 : 80
+    end
+
+    def host
+      'api.guardrailapp.com'
+    end
+
+    def uri
+      URI.parse("#{protocol}://#{host}:#{port}").merge('/')
+    end
+
+    def send_to_guardrail(data)
+      uri = self.uri
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = self.configuration.timeout_in_seconds
+      http.use_ssl      = self.configuration.secure?
+      http.verify_mode  = OpenSSL::SSL::VERIFY_NONE
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.set_form_data(data)
+
+      begin
+        response = http.request(request)
+      rescue Exception => ex
+        warn "Could not submit guardrailapp notification: #{ex.class} - #{ex.message}"
+      end
+    end
+  end
+end

data/lib/guardrail_notifier/version.rb

@@ -0,0 +1,3 @@
+module GuardrailNotifier
+  VERSION = '0.2.11'
+end

data/test/guardrail_test.rb

@@ -0,0 +1,156 @@
+require 'helper'
+
+class TestGuardrail < Test::Unit::TestCase
+  def fake_controller(klass)
+    fake = klass.new
+    fake.params = {'action' => "foo", 'controller' => "bar"}
+    fake.request = OpenStruct.new(
+      :user_agent => 'FooFox',
+      :cookies => {'one' => 'two', 'three' => 'four'},
+      :session => {'something' => 'ok', 'some_class' => String, 'some_number' => 42, :some_array => [Date, 24]}
+    )
+    fake
+  end
+
+  def setup
+    Rails.stubs(:env => 'production')
+
+    @foo_controller = fake_controller(FooController)
+
+    FakeWeb.register_uri(:post, 'http://api.guardrailapp.com', :body => "")
+
+    GuardrailNotifier.configure do |config|
+      config.api_key = "SOME API KEY"
+      config.monitored_environments = ['production']
+    end
+
+    @model_one   = OpenStruct.new(:errors => {"bar" => "is blank"})
+    @model_two   = OpenStruct.new(:errors => {"baz" => "is blank"})
+    @model_three = OpenStruct.new(:errors => {"f1" => "is blank","f2" => ["is too large", "is delicious"]})
+
+    @foo_controller.instance_variable_set("@lol", @model_one)
+    @foo_controller.instance_variable_set("@wtf", [@model_two, @model_three])
+
+    # we also set a non-errored model just to ensure that it is not matched
+    @foo_controller.instance_variable_set("@bbq", OpenStruct.new(:errors => []))
+  end
+
+  should "set an api key" do
+    GuardrailNotifier.configure { |c| c.api_key = "Foo" }
+    assert_equal "Foo", GuardrailNotifier.configuration.api_key
+  end
+
+  should "fallback to the ENV api key" do
+    GuardrailNotifier.configure { |c| c.api_key = nil }
+    ENV['GUARDRAIL_API_KEY'] = 'Cupcakes'
+    assert_equal "Cupcakes", GuardrailNotifier.notifier_params[:api_key]
+  end
+
+  should "set secure" do
+    GuardrailNotifier.configure { |c| c.secure = true }
+    assert GuardrailNotifier.configuration.secure?
+  end
+
+  should "set a timeout_in_seconds" do
+    assert_equal 5, GuardrailNotifier.configuration.timeout_in_seconds
+    GuardrailNotifier.configure { |c| c.timeout_in_seconds = 6 }
+    assert_equal 6, GuardrailNotifier.configuration.timeout_in_seconds
+  end
+
+  should "set monitored environments" do
+    assert_equal ["production"], GuardrailNotifier.configuration.monitored_environments
+    GuardrailNotifier.configure { |c| c.monitored_environments = ['stage', 'development'] }
+    assert_equal ['stage', 'development'], GuardrailNotifier.configuration.monitored_environments
+  end
+
+  should "respect monitored environments" do
+    assert @foo_controller.send(:should_log_failures_to_guardrail?)
+
+    GuardrailNotifier.configuration.monitored_environments = ['stage', 'development']
+    assert !@foo_controller.send(:should_log_failures_to_guardrail?)
+  end
+
+  should "identify no errors by default" do
+    assert_equal [], FooController.new.send(:records_with_errors)
+  end
+
+  should "identify records with errors" do
+    assert_same_elements [@model_one, @model_two, @model_three], @foo_controller.send(:records_with_errors)
+  end
+
+  should "create params via guardrail_params" do
+    expected = [
+      {"model"=>"OpenStruct", "field"=>"baz", "message"=>"is blank"},
+      {"model"=>"OpenStruct", "field"=>"f1", "message"=>"is blank"},
+      {"model"=>"OpenStruct", "field"=>"f2", "message"=>"is too large"},
+      {"model"=>"OpenStruct", "field"=>"f2", "message"=>"is delicious"},
+      {"model"=>"OpenStruct", "field"=>"bar", "message"=>"is blank"}
+    ]
+
+    params = @foo_controller.send(:guardrail_params)
+    failures = JSON.parse(params[:failures])
+    assert_same_elements expected, failures
+  end
+
+  # should "submit errors via log_validation_failures_to_guardrail" do
+  #   Net::HTTP.expects(:post_form).with(URI.parse("http://api.guardrailapp.com:80"), @foo_controller.send(:guardrail_params))
+  #   @foo_controller.send(:log_validation_failures_to_guardrail)
+  # end
+
+  should "log controller and action" do
+    assert_equal @foo_controller.params['action'], @foo_controller.send(:guardrail_params)[:_action]
+    assert_equal @foo_controller.params['controller'], @foo_controller.send(:guardrail_params)[:_controller]
+  end
+
+  should "log params" do
+    @foo_controller.params.merge!('lolcats' => "no longer funny")
+    assert_equal @foo_controller.params, JSON.parse(@foo_controller.send(:guardrail_params)[:data])['params']
+  end
+
+  should "filter tempfiles" do
+    Tempfile.open('foo') do |tempfile|
+      tempfile.write('test data')
+      tempfile.rewind
+
+      @foo_controller.params.merge!('value' => 'abc', 'photo' => tempfile, 'nested' => { 'nested_value' => 1, 'nested_photo' => tempfile })
+      params = JSON.parse(@foo_controller.send(:guardrail_params)[:data])['params']
+      assert_equal @foo_controller.params.merge('value' => 'abc', 'photo' => '[FILTERED]', 'nested' => { 'nested_value' => 1, 'nested_photo' => '[FILTERED]' }), params
+    end
+  end
+
+  should "log current user's id if the method is exposed" do
+    assert_equal nil, JSON.parse(@foo_controller.send(:guardrail_params)[:data])['current_user']
+    assert_equal 53077, JSON.parse(fake_controller(BarController).send(:guardrail_params)[:data])['current_user']
+  end
+
+  should "handle exceptions" do
+    logger = mock()
+    logger.expects(:error)
+    Rails.stubs(:logger => logger)
+
+    @foo_controller.stubs(:guardrail_params).raises(StandardError)
+    @foo_controller.send(:log_validation_failures_to_guardrail)
+
+    # with a custom exception handler
+    list = []
+    GuardrailNotifier.configure { |c| c.on_exception = proc { |e| list << e } }
+
+    logger.expects(:error)
+    @foo_controller.send(:log_validation_failures_to_guardrail)
+
+    assert_equal 1, list.size
+    assert_kind_of StandardError, list.first
+  end
+
+  [:cookies, :user_agent].each do |kind|
+    should "log #{kind}" do
+      assert @foo_controller.request.send(kind).present?
+      assert_equal @foo_controller.request.send(kind), JSON.parse(fake_controller(BarController).send(:guardrail_params)[:data])[kind.to_s]
+    end
+  end
+
+  should "log session" do
+    expected = {'something'=>'ok', 'some_class'=>'String', 'some_number'=>'42', 'some_array'=>['Date', '24']}
+    assert_equal expected, JSON.parse(fake_controller(BarController).send(:guardrail_params)[:data])['session']
+  end
+end

data/test/helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'test/unit'
+require 'ostruct'
+require 'shoulda'
+gem 'actionpack', '~>3.2'
+require 'action_controller'
+require 'fakeweb'
+require 'mocha'
+require 'tempfile'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'guardrail_notifier'
+
+class Test::Unit::TestCase
+end
+
+class FooController < ActionController::Base
+end
+
+class User
+  attr_accessor :id
+  def initialize
+    @id = 53077
+  end
+end
+
+class BarController < ActionController::Base
+  def current_user
+    User.new
+  end
+end
+
+class Rails
+end

data/test/sender_test.rb

@@ -0,0 +1,75 @@
+require 'helper'
+
+class SenderTest < Test::Unit::TestCase
+  def setup
+    GuardrailNotifier.configure do |c|
+      c.api_key = 'API_KEY'
+    end
+    @sender = GuardrailNotifier::Sender.new(GuardrailNotifier.configuration)
+  end
+
+  context "initialize" do
+    should "set configuration" do
+      assert_same GuardrailNotifier.configuration, @sender.configuration
+      assert_equal 'API_KEY', @sender.configuration.api_key
+    end
+  end
+
+  context "when not configured to be secure" do
+    setup do
+      GuardrailNotifier.configuration.secure = false
+    end
+
+    should "return 'http' for #protocol" do
+      assert_equal 'http', @sender.protocol
+    end
+
+    should "return 80 for #port" do
+      assert_equal 80, @sender.port
+    end
+
+    should "post data without ssl on insecure port" do
+      assert_sends_to_guardrail(false, 80)
+    end
+  end
+
+  context "when configured to be secure" do
+    setup do
+      GuardrailNotifier.configuration.secure = true
+    end
+
+    should "return 'https' for protocol" do
+      assert_equal 'https', @sender.protocol
+    end
+
+    should "return 443 for #port" do
+      assert_equal 443, @sender.port
+    end
+
+    should "post data with ssl on secure port" do
+      assert_sends_to_guardrail(true, 443)
+    end
+  end
+
+  should "return api.guardrailapp.com for #host" do
+    assert_equal 'api.guardrailapp.com', @sender.host
+  end
+
+
+  def assert_sends_to_guardrail(use_ssl, port)
+    data = {:key => :value}
+
+    mock_request = mock()
+    mock_request.expects(:set_form_data).with(data)
+    Net::HTTP::Post.stubs(:new => mock_request)
+
+    mock_http = mock()
+    mock_http.expects(:open_timeout=)
+    mock_http.expects(:use_ssl=).with(use_ssl)
+    mock_http.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+    mock_http.expects(:request).with(mock_request)
+    Net::HTTP.stubs(:new => mock_http)
+
+    @sender.send_to_guardrail(data)
+  end
+end

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: guardrail_notifier
+version: !ruby/object:Gem::Version
+  version: 0.2.11
+  prerelease: 
+platform: ruby
+authors:
+- Jeffrey Chupp
+- Jeremy Weiskotten
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Guardrail captures validation errors from your Ruby on Rails application
+  to help you identify and fix user experience issues. The GuardrailNotifier gem makes
+  it easy to hook up your app to the Guardrail web service.
+email: support@guardrailapp.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- guardrail_notifier.gemspec
+- lib/guardrail_notifier.rb
+- lib/guardrail_notifier/configuration.rb
+- lib/guardrail_notifier/rails/action_controller_monitor.rb
+- lib/guardrail_notifier/sender.rb
+- lib/guardrail_notifier/version.rb
+- test/guardrail_test.rb
+- test/helper.rb
+- test/sender_test.rb
+homepage: http://github.com/terriblelabs/guardrail_notifier
+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: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Guardrail (http://guardrailapp.com) captures validation errors from your
+  Ruby on Rails application.
+test_files: []