fozzie 0.0.22 → 0.0.23

data/fozzie.gemspec

@@ -5,7 +5,7 @@ require "fozzie/version"
 Gem::Specification.new do |s|
   s.name        = "fozzie"
   s.version     = Fozzie::VERSION
-  s.authors     = ["Marc Watts", "Mark Barger"]
+  s.authors     = ["Marc Watts", "Mark Barger", "Dave Nolan"]
   s.email       = ["marc.watts@lonelyplanet.co.uk"]
   s.summary     = %q{Statsd Ruby gem from Lonely Planet Online}
   s.description = %q{

data/lib/fozzie/rails/middleware.rb

@@ -9,12 +9,14 @@ module Fozzie
 
       # Generates the statistics key for the current path
       def generate_key(env)
-        path_str = env['PATH_INFO']
+        path_str       = env['PATH_INFO']
+        request_method = env['REQUEST_METHOD']
+
         return nil unless path_str
 
         begin
           routing = routing_lookup
-          path    = routing.recognize_path(path_str)
+          path    = routing.recognize_path(path_str, :method => request_method)
           stat    = [path[:controller], path[:action], "render"].join('.')
           stat
         rescue => exc
@@ -34,4 +36,4 @@ module Fozzie
     end
 
   end
-end
+end

data/lib/fozzie/version.rb

@@ -1,3 +1,3 @@
 module Fozzie
-  VERSION = "0.0.22"
+  VERSION = "0.0.23"
 end

data/spec/lib/fozzie/rails/middleware_spec.rb

@@ -2,80 +2,124 @@ require 'spec_helper'
 require 'action_controller'
 
 describe Fozzie::Rails::Middleware do
-  let(:path_info) { '/somewhere/railsy' }
-  let(:fake_env)  { ({ 'PATH_INFO' => path_info }) }
-  let(:routing)   { mock 'routing' }
+  let(:routes)  { mock "routes" }
 
   subject do
     RailsApp = Class.new do
       def call(env); env end
     end unless defined?(RailsApp)
-    Rails = RailsApp unless defined?(Rails)
     Fozzie::Rails::Middleware.new RailsApp.new
   end
 
-  describe "subject" do
-    it "returns env on call for testing" do
-      subject.call({}).should == {}
-    end
+  before do
+    Rails = rails unless defined?(Rails)
   end
+  
+  describe "#rails_version" do
+    let(:version) { "10.9.8" }
+    let(:rails)   { mock "rails" }
 
-  describe "rails 2" do
-    let!(:version) { RailsApp.stubs(:version).returns("2.3.1") }
-
-    it "#generate_key" do
-      subject.stubs(:routing_lookup).returns(routing)
-      routing.expects(:recognize_path)
-        .with(path_info)
-        .returns({:controller => 'somewhere', :action => 'railsy'})
-
-      subject.generate_key(fake_env).should == 'somewhere.railsy.render'
+    before do
+      ::Rails.stubs(:version).returns(version)
     end
-
-    it "returns nil on routing error" do
-      subject.stubs(:routing_lookup).returns(routing)
-      routing.expects(:recognize_path)
-        .with(path_info)
-        .raises(RuntimeError)
-
-      subject.generate_key(fake_env).should == nil
+    
+    it "returns the major version from Rails.version" do
+      subject.rails_version.should == 10
     end
-
   end
-
-  describe "rails 3" do
-    let!(:rails)    { RailsApp.stubs(:application).returns(Class.new) }
-    let!(:version)  { RailsApp.stubs(:version).returns("3.1.1") }
-
-    it "#generate_key" do
-      subject.stubs(:routing_lookup).returns(routing)
-      routing.expects(:recognize_path)
-        .with(path_info)
-        .returns({:controller => 'somewhere', :action => 'railsy'})
-
-      subject.generate_key(fake_env).should == 'somewhere.railsy.render'
+  
+  describe "#routing_lookup" do
+    context "when #rails_version == 3" do
+      let(:app) { mock "app" }
+      
+      before do
+        subject.stubs(:rails_version).returns(3)
+      end
+
+      it "returns Rails.application.routes" do
+        Rails.expects(:application).returns(app)
+        app.expects(:routes).returns(routes)
+        subject.routing_lookup.should eq routes
+      end
     end
-
-    it "returns nil on error" do
-      subject.stubs(:routing_lookup).returns(routing)
-      routing.expects(:recognize_path)
-        .with(path_info)
-        .raises(RuntimeError)
-
-      subject.generate_key(fake_env).should == nil
+    
+    context "when #rails_version does not == 3" do
+      before do
+        if defined?(ActionController::Routing::Routes)
+          
+          @old_routes_const = ActionController::Routing::Routes
+          ActionController::Routing.send(:remove_const, :Routes)
+        end
+        ActionController::Routing::Routes = routes
+      end
+
+      after do
+        if @old_routes_const
+          ActionController::Routing.send(:remove_const, :Routes)
+          ActionController::Routing::Routes = @old_routes_const
+        end
+      end
+
+      it "returns ActionController::Routing::Routes" do
+        subject.routing_lookup.should eq routes
+      end
     end
+  end
 
-    it "returns nil on routing error" do
-      subject.stubs(:routing_lookup).returns(routing)
-      routing.expects(:recognize_path)
-        .with(path_info)
-        .raises(RuntimeError)
+  describe "#generate_key" do
+    let(:env)  { mock "env" }
+    let(:path) { mock "path" }
+    let(:request_method) { mock "request_method" }
+    
+    it "gets the path_info and request method from env parameter" do
+      env.expects(:[]).with("PATH_INFO")
+      env.expects(:[]).with("REQUEST_METHOD")
+      subject.generate_key(env)
+    end
 
-      S.expects(:increment).with('routing.error')
+    context "when path_info is nil" do
+      let(:env) { { "PATH_INFO" => nil } }
+          
+      it "does not lookup routing" do
+        subject.expects(:routing_lookup).never
+        subject.generate_key(env)
+      end
+
+      it "does not register any stats" do
+        S.expects(:increment).never
+      end
+
+      it "returns nil" do
+        subject.generate_key(env).should be_nil
+      end
+    end
 
-      subject.generate_key(fake_env).should == nil
+    context "when path info is not nil" do
+      let(:env) { { "PATH_INFO" => path, "REQUEST_METHOD" => request_method } }
+      
+      before do
+        subject.stubs(:routing_lookup).returns(routes)
+        routes.stubs(:recognize_path).returns({ :controller => "controller",
+                                                :action     => "action" })
+      end
+      
+      it "looks up controller and action for the path and request method" do
+        subject.expects(:routing_lookup).returns(routes)
+        routes.expects(:recognize_path).with(path, :method => request_method)
+        subject.generate_key(env)
+      end
+
+      it "returns a bucket generated from the controller, action, and 'render'" do
+        subject.generate_key(env).should eq "controller.action.render"
+      end
     end
+  end
 
+  
+  describe "subject" do
+    it "returns env on call for testing" do
+      subject.call({}).should == {}
+    end
   end
 
-end
+end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: fozzie
 version: !ruby/object:Gem::Version
-  version: 0.0.22
+  version: 0.0.23
   prerelease: 
 platform: ruby
 authors:
 - Marc Watts
 - Mark Barger
+- Dave Nolan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-31 00:00:00.000000000 Z
+date: 2012-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sys-uname
@@ -278,7 +279,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1130845935272544581
+      hash: 3531054699927461571
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -287,7 +288,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1130845935272544581
+      hash: 3531054699927461571
 requirements: []
 rubyforge_project: fozzie
 rubygems_version: 1.8.24