fozzie 1.0.2 → 1.0.3

data/spec/lib/fozzie/sniff_spec.rb

@@ -1,131 +1,131 @@
-require 'spec_helper'
-require 'fozzie/sniff'
-
-describe Fozzie::Sniff do
-  let(:klass) do
-    class FooBar
-
-      _monitor
-      def self.bar!; :bar end
-
-      _monitor
-      def self.koala(hsh = {}); hsh end
-
-      def self.badger; :cares end
-
-      _monitor("my.awesome.class.bucket.name")
-      def self.class_method_with_non_default_bucket_name; true; end
-      
-      _monitor
-      def foo; :foo; end
-
-      _monitor("my.awesome.bucket.name")
-      def method_with_non_default_bucket_name; true; end
-      
-      _monitor
-      def sloth(a, b, c); [a,b,c] end
-
-      def honeybadger; :dontcare end
-
-      _monitor
-      def method_yielding_to_block
-        yield(:retval_from_block) if block_given?
-      end
-
-      _monitor
-      def self.class_method_yielding_to_block
-        yield(:retval_from_block) if block_given?
-      end
-    end
-
-    FooBar
-  end
-
-  # Turn on sniffing for the duration of this spec
-  before(:all) do
-    Fozzie.c.sniff_envs << :test
-  end
-
-  after(:all) do
-    Fozzie.c.sniff_envs.delete(:test)
-  end
-
-  context 'class methods' do
-    subject { klass }
-
-    it "aliases methods for monitoring" do
-      subject.methods.grep(/bar/).should =~ [:bar!, :"bar_with_monitor!", :"bar_without_monitor!"]
-    end
-
-    it "behaves like original" do
-      subject.bar!.should eq :bar
-    end
-
-    it "utilises Fozzie" do
-      S.should_receive(:time_for).with(['foo_bar', 'bar!'])
-
-      subject.bar!
-    end
-
-    it "handles arguments" do
-      h = { drop: 'bear' }
-      subject.koala(h).should eq h
-    end
-
-    it "does not monitor when mapped" do
-      S.should_receive(:time_for).with(['foo_bar', 'badger']).never
-
-      subject.badger.should eq :cares
-    end
-
-    it "optionally sets the bucket name" do
-      S.should_receive(:time_for).with("my.awesome.class.bucket.name")
-
-      subject.class_method_with_non_default_bucket_name
-    end
-
-
-    it "yields to a block when given" do
-      subject.class_method_yielding_to_block {|val| val }.should eq :retval_from_block
-    end
-  end
-
-  context 'instance methods' do
-    subject { klass.new }
-
-    it "aliases methods for monitoring" do
-      subject.methods.grep(/foo/).should =~ [:foo, :foo_with_monitor, :foo_without_monitor]
-    end
-
-    it "behaves like original" do
-      subject.foo.should eq :foo
-    end
-
-    it "utilises Fozzie" do
-      S.should_receive(:time_for).with(['foo_bar', 'foo'])
-
-      subject.foo
-    end
-
-    it "optionally sets the bucket name" do
-      S.should_receive(:time_for).with("my.awesome.bucket.name")
-
-      subject.method_with_non_default_bucket_name
-    end
-
-    it "handles arguments" do
-      a = [:slow, :slower, :slowest]
-      subject.sloth(*a).should eq a
-    end
-
-    it "does not monitor when mapped" do
-      S.should_receive(:time_for).with(['foo_bar', 'honeybadger']).never
-
-      subject.honeybadger.should eq :dontcare
-    end
-
-    it "yields to a block when given" do
-      subject.method_yielding_to_block {|val| val }.should eq :retval_from_block
-    end
-  end
-end
+require 'spec_helper'
+require 'fozzie/sniff'
+
+describe Fozzie::Sniff do
+  let(:klass) do
+    class FooBar
+
+      _monitor
+      def self.bar!; :bar end
+
+      _monitor
+      def self.koala(hsh = {}); hsh end
+
+      def self.badger; :cares end
+
+      _monitor("my.awesome.class.bucket.name")
+      def self.class_method_with_non_default_bucket_name; true; end
+      
+      _monitor
+      def foo; :foo; end
+
+      _monitor("my.awesome.bucket.name")
+      def method_with_non_default_bucket_name; true; end
+      
+      _monitor
+      def sloth(a, b, c); [a,b,c] end
+
+      def honeybadger; :dontcare end
+
+      _monitor
+      def method_yielding_to_block
+        yield(:retval_from_block) if block_given?
+      end
+
+      _monitor
+      def self.class_method_yielding_to_block
+        yield(:retval_from_block) if block_given?
+      end
+    end
+
+    FooBar
+  end
+
+  # Turn on sniffing for the duration of this spec
+  before(:all) do
+    Fozzie.c.sniff_envs << :test
+  end
+
+  after(:all) do
+    Fozzie.c.sniff_envs.delete(:test)
+  end
+
+  context 'class methods' do
+    subject { klass }
+
+    it "aliases methods for monitoring" do
+      subject.methods.grep(/bar/).should =~ [:bar!, :"bar_with_monitor!", :"bar_without_monitor!"]
+    end
+
+    it "behaves like original" do
+      subject.bar!.should eq :bar
+    end
+
+    it "utilises Fozzie" do
+      S.should_receive(:time_for).with(['foo_bar', 'bar!'])
+
+      subject.bar!
+    end
+
+    it "handles arguments" do
+      h = { drop: 'bear' }
+      subject.koala(h).should eq h
+    end
+
+    it "does not monitor when mapped" do
+      S.should_receive(:time_for).with(['foo_bar', 'badger']).never
+
+      subject.badger.should eq :cares
+    end
+
+    it "optionally sets the bucket name" do
+      S.should_receive(:time_for).with("my.awesome.class.bucket.name")
+
+      subject.class_method_with_non_default_bucket_name
+    end
+
+
+    it "yields to a block when given" do
+      subject.class_method_yielding_to_block {|val| val }.should eq :retval_from_block
+    end
+  end
+
+  context 'instance methods' do
+    subject { klass.new }
+
+    it "aliases methods for monitoring" do
+      subject.methods.grep(/foo/).should =~ [:foo, :foo_with_monitor, :foo_without_monitor]
+    end
+
+    it "behaves like original" do
+      subject.foo.should eq :foo
+    end
+
+    it "utilises Fozzie" do
+      S.should_receive(:time_for).with(['foo_bar', 'foo'])
+
+      subject.foo
+    end
+
+    it "optionally sets the bucket name" do
+      S.should_receive(:time_for).with("my.awesome.bucket.name")
+
+      subject.method_with_non_default_bucket_name
+    end
+
+    it "handles arguments" do
+      a = [:slow, :slower, :slowest]
+      subject.sloth(*a).should eq a
+    end
+
+    it "does not monitor when mapped" do
+      S.should_receive(:time_for).with(['foo_bar', 'honeybadger']).never
+
+      subject.honeybadger.should eq :dontcare
+    end
+
+    it "yields to a block when given" do
+      subject.method_yielding_to_block {|val| val }.should eq :retval_from_block
+    end
+  end
+end

data/spec/lib/fozzie/version_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper'
-
-describe "Fozzie Version" do
-
-  it "is correct formatted" do
-    Fozzie::VERSION.should be_kind_of(String)
-    Fozzie::VERSION.should match(/\d{1,3}?\.?/)
-  end
-
+require 'spec_helper'
+
+describe "Fozzie Version" do
+
+  it "is correct formatted" do
+    Fozzie::VERSION.should be_kind_of(String)
+    Fozzie::VERSION.should match(/\d{1,3}?\.?/)
+  end
+
 end

data/spec/lib/fozzie_spec.rb

@@ -1,39 +1,39 @@
-require 'spec_helper'
-require 'logger'
-
-describe Fozzie do
-  it "allows dynamic assignment" do
-    { :host => 'somewhere.local', :port => 99 }.each do |field, val|
-      Fozzie.configure {|c| c.send("#{field}=", val) }
-      Fozzie.c.send(field).should == val
-    end
-  end
-
-  describe ".logger" do
-    let(:logger) { double "logger" }
-
-    before do
-      @old_logger = Fozzie.logger
-    end
-    
-    it "assigns a logger" do
-      Fozzie.logger = logger
-      Fozzie.logger.should eq logger
-    end
-
-    after do
-      Fozzie.logger = @old_logger
-    end
-  end
-
-  it "has configuration" do
-    Fozzie.config.should be_kind_of(Fozzie::Configuration)
-    Fozzie.c.should be_kind_of(Fozzie::Configuration)
-  end
-
-  it "creates new classes for statistics gathering" do
-    Fozzie.c.namespaces.each do |k|
-      Kernel.const_defined?(k).should == true
-    end
-  end
-end
+require 'spec_helper'
+require 'logger'
+
+describe Fozzie do
+  it "allows dynamic assignment" do
+    { :host => 'somewhere.local', :port => 99 }.each do |field, val|
+      Fozzie.configure {|c| c.send("#{field}=", val) }
+      Fozzie.c.send(field).should == val
+    end
+  end
+
+  describe ".logger" do
+    let(:logger) { double "logger" }
+
+    before do
+      @old_logger = Fozzie.logger
+    end
+    
+    it "assigns a logger" do
+      Fozzie.logger = logger
+      Fozzie.logger.should eq logger
+    end
+
+    after do
+      Fozzie.logger = @old_logger
+    end
+  end
+
+  it "has configuration" do
+    Fozzie.config.should be_kind_of(Fozzie::Configuration)
+    Fozzie.c.should be_kind_of(Fozzie::Configuration)
+  end
+
+  it "creates new classes for statistics gathering" do
+    Fozzie.c.namespaces.each do |k|
+      Kernel.const_defined?(k).should == true
+    end
+  end
+end

data/spec/shared_examples/fozzie_adapter.rb

@@ -1,7 +1,7 @@
-shared_examples_for "fozzie adapter" do
-
-  it { should respond_to(:register) }
-
-  it { should respond_to(:delimeter) }
-  
-end
+shared_examples_for "fozzie adapter" do
+
+  it { should respond_to(:register) }
+
+  it { should respond_to(:delimeter) }
+  
+end

data/spec/shared_examples/interface.rb

@@ -1,160 +1,160 @@
-shared_examples "interface" do
-
-  it "#increment" do
-    subject.should_receive(:send).with('wat', 1, :count, 1)
-    subject.increment 'wat'
-  end
-
-  it "#decrement" do
-    subject.should_receive(:send).with('wat', -1, :count, 1)
-    subject.decrement 'wat'
-  end
-
-  it "#count" do
-    subject.should_receive(:send).with('wat', 5, :count, 1)
-    subject.count 'wat', 5
-  end
-
-  it "#timing" do
-    subject.should_receive(:send).with('wat', 500, :timing, 1)
-    subject.timing 'wat', 500
-  end
-
-  it "times a given block" do
-    subject.should_receive(:timing).with do |b, val, timing|
-      b == 'data.bin' && (1..11).include?(val)
-    end.exactly(3).times
-
-    subject.time_for('data.bin')   { sleep 0.01 }
-    subject.time_to_do('data.bin') { sleep 0.01 }
-    subject.time('data.bin')       { sleep 0.01 }
-  end
-
-  describe "event" do
-    it "for a commit" do
-      subject.should_receive(:gauge).with(['event', 'commit', nil], anything).twice
-      subject.commit
-      subject.committed
-    end
-
-    it "for a build" do
-      subject.should_receive(:gauge).with(['event', 'build', nil], anything).twice
-      subject.build
-      subject.built
-    end
-
-    it "for a deploy" do
-      subject.should_receive(:gauge).with(['event', 'deploy', nil], anything).twice
-      subject.deploy
-      subject.deployed
-    end
-
-    it "for anything" do
-      subject.should_receive(:send).with(['event', 'foo', nil], anything, :gauge, 1)
-      subject.event 'foo'
-    end
-
-    it "accepts an app name" do
-      subject.should_receive(:send).with(['event', 'foo', 'fozzie'], anything, :gauge, 1)
-      subject.event 'foo', 'fozzie'
-    end
-  end
-
-  describe "#increment_on" do
-    it "registers success" do
-      subject.should_receive(:increment).with(["event.increment", "success"], 1)
-      subject.increment_on('event.increment', true).should == true
-    end
-
-    it "registers failure" do
-      subject.should_receive(:increment).with(["event.increment", "fail"], 1)
-      subject.increment_on('event.increment', false).should == false
-    end
-
-    it "simply questions the passed val with if" do
-      a = double
-      a.should_receive(:save).and_return({})
-      subject.should_receive(:increment).with(["event.increment", "success"], 1)
-      subject.increment_on('event.increment', a.save).should == {}
-    end
-
-    it "registers fail on nil return" do
-      a = double
-      a.should_receive(:save).and_return(nil)
-      subject.should_receive(:increment).with(["event.increment", "fail"], 1)
-      subject.increment_on('event.increment', a.save).should == nil
-    end
-
-    describe "performing actions" do
-      it "registers success" do
-        a = double
-        a.should_receive(:save).and_return(true)
-        subject.should_receive(:increment).with(["event.increment", "success"], 1)
-        subject.increment_on('event.increment', a.save).should == true
-      end
-
-      it "registers failure" do
-        a = double
-        a.should_receive(:save).and_return(false)
-        subject.should_receive(:increment).with(["event.increment", "fail"], 1)
-        subject.increment_on('event.increment', a.save).should == false
-      end
-
-      it "registers positive even when nested" do
-        a = double
-        a.should_receive(:save).and_return(true)
-        subject.should_receive(:timing).with('event.run', anything, anything)
-        subject.should_receive(:increment).with(["event.increment", "success"], 1)
-
-        res = subject.time_to_do "event.run" do
-          subject.increment_on('event.increment', a.save)
-        end
-        res.should == true
-      end
-
-      it "registers negative even when nested" do
-        a = double
-        a.should_receive(:save).and_return(false)
-        subject.should_receive(:timing).with('event.run', anything, anything)
-        subject.should_receive(:increment).with(["event.increment", "fail"], 1)
-
-        res = subject.time_to_do "event.run" do
-          subject.increment_on('event.increment', a.save)
-        end
-        res.should == false
-      end
-    end
-  end
-
-  describe "#bulk" do
-
-    it "registers statistics in a single call" do
-      Fozzie.c.adapter.should_receive(:register).once
-
-      subject.bulk do
-        increment :foo
-        decrement :bar
-      end
-    end
-
-  end
-
-  it "registers a gauge measurement" do
-    subject.should_receive(:send).with("mystat", 99, :gauge, 1)
-    subject.gauge("mystat", 99)
-  end
-
-  it "raises exception if natural exception from block" do
-    proc { subject.time_to_do('data.bin', 1, :gauge, 1) { raise ArgumentError, "testing" } }.should raise_error(ArgumentError)
-  end
-
-  it "only calls the block once on error" do
-    Fozzie.c.adapter.stub(:send) { raise SocketError }
-    i = 0
-    p = proc {|n| (n + 1) }
-    val = subject.time_to_do('data.bin') { i+= p.call(i) }
-
-    val.should == 1
-  end
-
+shared_examples "interface" do
+
+  it "#increment" do
+    subject.should_receive(:send).with('wat', 1, :count, 1)
+    subject.increment 'wat'
+  end
+
+  it "#decrement" do
+    subject.should_receive(:send).with('wat', -1, :count, 1)
+    subject.decrement 'wat'
+  end
+
+  it "#count" do
+    subject.should_receive(:send).with('wat', 5, :count, 1)
+    subject.count 'wat', 5
+  end
+
+  it "#timing" do
+    subject.should_receive(:send).with('wat', 500, :timing, 1)
+    subject.timing 'wat', 500
+  end
+
+  it "times a given block" do
+    subject.should_receive(:timing).with do |b, val, timing|
+      b == 'data.bin' && (1..11).include?(val)
+    end.exactly(3).times
+
+    subject.time_for('data.bin')   { sleep 0.01 }
+    subject.time_to_do('data.bin') { sleep 0.01 }
+    subject.time('data.bin')       { sleep 0.01 }
+  end
+
+  describe "event" do
+    it "for a commit" do
+      subject.should_receive(:gauge).with(['event', 'commit', nil], anything).twice
+      subject.commit
+      subject.committed
+    end
+
+    it "for a build" do
+      subject.should_receive(:gauge).with(['event', 'build', nil], anything).twice
+      subject.build
+      subject.built
+    end
+
+    it "for a deploy" do
+      subject.should_receive(:gauge).with(['event', 'deploy', nil], anything).twice
+      subject.deploy
+      subject.deployed
+    end
+
+    it "for anything" do
+      subject.should_receive(:send).with(['event', 'foo', nil], anything, :gauge, 1)
+      subject.event 'foo'
+    end
+
+    it "accepts an app name" do
+      subject.should_receive(:send).with(['event', 'foo', 'fozzie'], anything, :gauge, 1)
+      subject.event 'foo', 'fozzie'
+    end
+  end
+
+  describe "#increment_on" do
+    it "registers success" do
+      subject.should_receive(:increment).with(["event.increment", "success"], 1)
+      subject.increment_on('event.increment', true).should == true
+    end
+
+    it "registers failure" do
+      subject.should_receive(:increment).with(["event.increment", "fail"], 1)
+      subject.increment_on('event.increment', false).should == false
+    end
+
+    it "simply questions the passed val with if" do
+      a = double
+      a.should_receive(:save).and_return({})
+      subject.should_receive(:increment).with(["event.increment", "success"], 1)
+      subject.increment_on('event.increment', a.save).should == {}
+    end
+
+    it "registers fail on nil return" do
+      a = double
+      a.should_receive(:save).and_return(nil)
+      subject.should_receive(:increment).with(["event.increment", "fail"], 1)
+      subject.increment_on('event.increment', a.save).should == nil
+    end
+
+    describe "performing actions" do
+      it "registers success" do
+        a = double
+        a.should_receive(:save).and_return(true)
+        subject.should_receive(:increment).with(["event.increment", "success"], 1)
+        subject.increment_on('event.increment', a.save).should == true
+      end
+
+      it "registers failure" do
+        a = double
+        a.should_receive(:save).and_return(false)
+        subject.should_receive(:increment).with(["event.increment", "fail"], 1)
+        subject.increment_on('event.increment', a.save).should == false
+      end
+
+      it "registers positive even when nested" do
+        a = double
+        a.should_receive(:save).and_return(true)
+        subject.should_receive(:timing).with('event.run', anything, anything)
+        subject.should_receive(:increment).with(["event.increment", "success"], 1)
+
+        res = subject.time_to_do "event.run" do
+          subject.increment_on('event.increment', a.save)
+        end
+        res.should == true
+      end
+
+      it "registers negative even when nested" do
+        a = double
+        a.should_receive(:save).and_return(false)
+        subject.should_receive(:timing).with('event.run', anything, anything)
+        subject.should_receive(:increment).with(["event.increment", "fail"], 1)
+
+        res = subject.time_to_do "event.run" do
+          subject.increment_on('event.increment', a.save)
+        end
+        res.should == false
+      end
+    end
+  end
+
+  describe "#bulk" do
+
+    it "registers statistics in a single call" do
+      Fozzie.c.adapter.should_receive(:register).once
+
+      subject.bulk do
+        increment :foo
+        decrement :bar
+      end
+    end
+
+  end
+
+  it "registers a gauge measurement" do
+    subject.should_receive(:send).with("mystat", 99, :gauge, 1)
+    subject.gauge("mystat", 99)
+  end
+
+  it "raises exception if natural exception from block" do
+    proc { subject.time_to_do('data.bin', 1, :gauge, 1) { raise ArgumentError, "testing" } }.should raise_error(ArgumentError)
+  end
+
+  it "only calls the block once on error" do
+    Fozzie.c.adapter.stub(:send) { raise SocketError }
+    i = 0
+    p = proc {|n| (n + 1) }
+    val = subject.time_to_do('data.bin') { i+= p.call(i) }
+
+    val.should == 1
+  end
+
 end