fiveruns-dash-ruby 0.7.0

data/test/configuration_test.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) << "/test_helper"
+
+class ConfigurationTest < Test::Unit::TestCase
+  
+   context "Configuration" do
+
+    setup do
+      no_recipe_loading!
+      mock_streams!
+    end
+    
+    teardown do
+      restore_streams!
+      Fiveruns::Dash.class_eval { @configuration = nil }
+    end
+
+    should "update options passed by Fiveruns::Dash.configure convenience method" do
+      assert_nil config.options[:app]
+      token = 'foo-bar'
+      Fiveruns::Dash.configure :app => token
+      assert_equal token, config.options[:app]
+    end
+    
+    context "metric definitions" do
+      setup do
+        @configuration = Configuration.new do |config|
+          metric_types.each do |type|
+            config.__send__(type, "Metric: #{type}") do
+              # Empty block for metric types that require it
+            end
+          end
+        end
+      end
+      should "assign all metrics" do
+        assert_equal 3, @configuration.metrics.size
+        types = @configuration.metrics.map { |metric| metric.class.metric_type }
+        assert_equal metric_types.map(&:to_s).sort, types.map(&:to_s).sort
+      end
+      should "not allow invalid types" do
+        assert_raises NoMethodError do
+          @configuration.__send__(:bad_type, 'My Horrible Metric')
+        end
+      end
+    end
+    
+    context "setting by version" do
+      setup do
+        @version = '0.1.6'
+        @config = Configuration.new do |config|
+          config.for_version @version, '0.1.6' do
+            config.counter :foo do
+              1
+            end
+          end
+          config.for_version @version, ['=', '0.1.6'] do
+            config.counter :bar do
+              1
+            end
+          end
+          config.for_version @version, ['==', '0.1.5'] do
+            config.counter :spam do
+              1
+            end
+          end
+          config.for_version @version, ['>', '0.1.6'] do
+            config.counter :baz do
+              1
+            end
+          end
+          config.for_version nil, ['>', '0.1.6'] do
+            config.counter :quux do
+              1
+            end
+          end
+        end
+      end
+      should "execute if correct version" do
+        assert_equal 2, @config.metrics.size
+        assert_equal %w(bar foo), @config.metrics.map(&:name).map(&:to_s).sort
+      end
+    end
+
+  end
+  
+  #######
+  private
+  #######
+  
+  def metric_types
+    [:counter, :percentage, :absolute]
+  end
+
+  def config
+    Fiveruns::Dash.configuration
+  end
+
+end

data/test/exception_recorder_test.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) << "/test_helper"
+
+class ExceptionRecorderTest < Test::Unit::TestCase
+  
+  attr_reader :payload
+  attr_reader :recorder, :exceptions
+
+  context "ExceptionRecorder" do
+    
+    setup do
+      @recorder = Fiveruns::Dash::ExceptionRecorder.new(flexmock(:session))
+      flexmock(ExceptionRecorder).should_receive(:replacements).and_return({
+        :foo => /^foo\b/
+      })
+    end
+    
+    context "when recording an exception" do
+      setup do
+        recorder.record(build("Message", "foo/bar/baz"))
+      end
+      should "record an exception" do
+        assert_equal 1, recorder.data.size
+      end
+      should "normalize a backtrace" do
+        assert(recorder.data.first[:backtrace] =~ /\[FOO\]/)
+      end
+    end
+
+    context "when recording an exception with a sample" do
+      setup do
+        recorder.record(build("Message", "foo/bar/baz"), {:key => :value})
+      end
+      should "record an exception" do
+        assert_equal 1, recorder.data.size
+      end
+      should "normalize a backtrace" do
+        assert(recorder.data.first[:backtrace] =~ /\[FOO\]/)
+      end      
+      should "not serialize sample" do
+        assert_equal({'key' => 'value'}, recorder.data.first[:sample])
+      end      
+    end
+    
+    context "when recording exceptions with the same message and backtrace" do
+      setup do
+        recorder.record(build, :key1=>:value1)
+        recorder.record(build, :key2=>:value2)
+      end
+      should "collapse" do
+        assert_equal 1, recorder.data.size
+      end
+      should "count them together" do
+        assert_equal [2], recorder.data.map { |exc| exc[:total] }
+      end
+      should "store only the first sample" do
+        assert_equal({'key1' => 'value1'}, recorder.data.first[:sample])
+      end
+    end
+    
+    context "when recording exceptions with different messages" do
+      setup do
+        recorder.record(build("Message1", "Line 1"))
+        recorder.record(build("Message2", "Line 1"))
+      end
+      should "collapse" do
+        assert_equal 1, recorder.data.size
+      end
+      should "count them together" do
+        assert_equal [2], recorder.data.map { |exc| exc[:total] }
+      end
+    end
+    
+    context "when recording exceptions with different backtraces" do
+      setup do
+        recorder.record(build("Message", "Line 1"))
+        recorder.record(build("Message", "Line 2"))
+      end
+      should "not collapse" do
+        assert_equal 2, recorder.data.size
+      end
+      should "count them separately" do
+        assert_equal [1, 1], recorder.data.map { |exc| exc[:total] }
+      end
+    end
+
+    context "when retrieving the data" do
+      should "call reset when returning data hash" do
+        flexmock(recorder).should_receive(:reset).once
+        recorder.data
+      end
+    
+      should "empty the exception list on reset" do
+        recorder.send(:exceptions) << "Item"
+        assert_equal( 1, recorder.send(:exceptions).size )
+        recorder.send(:reset)
+        assert_equal( 0, recorder.send(:exceptions).size )
+      end
+    end
+
+  end
+  
+  #######
+  private
+  #######
+
+  def build(message = 'This is a message', line = 'backtrace line')
+    flexmock(:exception) do |mock|
+      mock.should_receive(:backtrace).and_return([line])        
+      mock.should_receive(:message).and_return(message)
+    end
+  end
+end

data/test/file_store_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) << "/test_helper"
+
+class FileStoreTest < Test::Unit::TestCase
+
+  context "FileStore" do
+
+    setup do
+      mock_storage!
+      directories.each do |dir|
+        FileUtils.mkdir_p dir
+      end
+      @update = @klass.new
+      @update.store_file(*uris)
+    end
+
+    teardown do
+      FileUtils.rm_rf(File.dirname(__FILE__) << "/tmp")
+    end
+    
+    should "write to all filenames" do
+      assert_equal 2, files.size
+    end
+    
+    should "name all filenames the same" do
+      assert_equal 1, files.map { |f| File.basename(f) }.uniq.size
+    end
+
+  end
+  
+  #######
+  private
+  #######
+  
+  def files
+    Dir[File.dirname(__FILE__) << "/tmp/**/*.json"]
+  end
+  
+  def mock_storage!
+    @klass = Class.new { include Store::File }
+    flexmock(@klass).new_instances do |mock|
+      mock.should_receive(:payload).and_return(:foo => 1, :bar => 2)
+      mock.should_receive(:guid).and_return('GUID')
+    end
+  end
+  
+  def directories
+    %w(foo bar).map do |name|
+      File.expand_path(File.join(File.dirname(__FILE__), 'tmp', 'file_store', name))
+    end  
+  end
+  
+  def uris
+    directories.map { |path| URI.parse("file://#{path}") }
+  end
+
+end

data/test/fixtures/http_store_test/response.json

@@ -0,0 +1,6 @@
+{
+  "process_id":1,
+  "metric_infos": [
+    {"id":1, "name":"MetricTest.time_me","recipe_url":null, "recipe_name":null}
+  ]
+}

data/test/http_store_test.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) << "/test_helper"
+
+class HTTPStoreTest < Test::Unit::TestCase
+  
+  attr_reader :payload
+
+  context "HTTPStore" do
+    
+    setup do
+      Thread.current[:resolved_hostnames] = nil
+      @urls = %w(http://metrics.foo.com http://metrics02.bar.com http://metrics03.bar.com)
+      @klass = Class.new { include Store::HTTP }
+      @params = {:this_is_a_param => 'value'}
+      @metric = flexmock(:metric) do |mock|
+        mock.should_receive(:key).and_return(:name => 'MetricTest.time_me', :recipe_name => nil, :recipe_url => nil)
+        mock.should_receive(:info_id=)
+      end
+      @configuration = flexmock(:config) do |mock|
+        mock.should_receive(:options).and_return(:app => '123')
+        mock.should_receive(:metrics).and_return([@metric])
+      end
+      flexmock(::Fiveruns::Dash).should_receive(:configuration).and_return(@configuration)
+      flexmock(@klass).new_instances do |mock|
+        mock.should_receive(:payload).and_return { payload }
+        mock.should_receive(:params).and_return(@params)
+      end
+      @update = @klass.new
+      no_recipe_loading!
+   #   mock_streams!
+    end
+    
+    teardown do
+      FakeWeb.clean_registry
+   #   restore_streams!
+    end
+    
+    #TODO
+    context "collector hostnames" do
+      should "should be resolved on the first access" do 
+        flexmock(IPSocket).should_receive(:getaddress).times(1).returns("1.1.1.1")
+        assert_equal @update.resolved_hostnames.keys.size, 0
+        new_uri = @update.resolved_hostname(uris.first.host)        
+        assert_equal new_uri, "1.1.1.1"
+        assert_equal @update.resolved_hostnames.keys.size, 1
+        assert @update.resolved_hostnames[uris.first.host].next_update > (Time.now + 23.hours)
+        assert_equal @update.resolved_hostname(uris.first.host), "1.1.1.1"
+        junk = @update.resolved_hostname(uris.first.host)        
+        
+      end
+      
+      should "re-cache address if time has expired" do
+        flexmock(@update).should_receive(:rand).returns(1)
+        flexmock(IPSocket).should_receive(:getaddress).returns("1.1.1.1", "2.2.2.2")
+        assert_equal @update.resolved_hostnames.keys.size, 0
+        new_uri = @update.resolved_hostname(uris.first.host)   
+        assert_equal new_uri, "1.1.1.1"
+        @update.resolved_hostnames[uris.first.host].next_update = 10.hours.ago
+        first_expire = @update.resolved_hostnames[uris.first.host].next_update
+        
+        new_uri = @update.resolved_hostname(uris.first.host)   
+        second_expire = @update.resolved_hostnames[uris.first.host].next_update
+        assert_equal new_uri, "2.2.2.2"
+        assert second_expire < (Time.now + 25.hours)
+        assert second_expire > (Time.now + 23.hours)
+      end
+    end
+    
+    context "with info payload" do
+      setup do
+        @payload = InfoPayload.new({:pid => 987}, Time.now.utc)
+        @update#TODO
+        flexmock(@update).should_receive(:resolved_hostname).and_return {|c| c }
+   #     restore_streams!
+      end
+      teardown do
+   #     mock_streams!
+      end
+      context "on connection error" do
+        setup do
+          FakeWeb.register_uri full_urls(:processes).first, :string => 'FAIL!', :exception => Net::HTTPError
+          full_urls(:processes)[1..-1].each do |url|
+            FakeWeb.register_uri url, :status => 201, :string => File.read(File.dirname(__FILE__) << "/fixtures/http_store_test/response.json")
+          end
+        end
+        should "fallback to working URL" do
+          returning @update.store_http(*uris) do |pass_uri|
+            assert_equal uris[1], pass_uri
+          end
+        end
+      end
+      context "on non-201 response" do
+        setup do
+          [500, 403, 200].zip(full_urls(:processes)).each do |status, url|
+            FakeWeb.register_uri url, :string => 'Not what we want', :status => status
+          end
+        end
+        should "not succeed" do
+          assert !@update.store_http(*uris)
+        end
+      end
+    end
+    
+    context "with data payload" do
+
+      setup do
+        @payload = DataPayload.new([{:metric_info_id => 123, :name => 'bar'}])
+        flexmock(@update).should_receive(:resolved_hostname).and_return {|c| c}
+        
+      end
+    
+      context "fallback URLs" do
+        context "on connection error" do
+          setup do
+            FakeWeb.register_uri full_urls(:metrics).first, :string => 'FAIL!', :exception => Net::HTTPError
+            full_urls(:metrics)[1..-1].each do |url|
+              FakeWeb.register_uri url, :string => '{"message" : "OK!"}', :status => 201
+            end
+          end
+          should "fallback to working URL" do
+            returning @update.store_http(*uris) do |pass_uri|
+              assert_equal uris[1], pass_uri
+            end
+          end
+        end
+        context "on non-201 response" do
+          setup do
+            [500, 403, 200].zip(full_urls(:metrics)).each do |status, url|
+              FakeWeb.register_uri url, :string => 'Not what we want', :status => status
+            end
+          end
+          should "not succeed" do
+            assert !@update.store_http(*uris)
+          end
+        end
+      end
+
+    end
+    
+    context "with exceptions payload" do
+
+      setup do
+        @payload = ExceptionsPayload.new([
+          {
+            :name => 'FooError',
+            :message => 'Fake Foo Error',
+            :backtrace => '--- This is not real',
+            :total => 3
+          },
+          {
+            :name => 'BarError',
+            :message => 'Fake Bar Error',
+            :backtrace => '--- This is not real',
+            :total => 10
+          }
+        ])
+        flexmock(@update).should_receive(:resolved_hostname).and_return {|c| c}
+        
+      end
+    
+      context "fallback URLs" do
+        context "on connection error" do
+          setup do
+            FakeWeb.register_uri full_urls(:exceptions).first, :string => 'FAIL!', :exception => Net::HTTPError
+            full_urls(:exceptions)[1..-1].each do |url|
+              FakeWeb.register_uri url, :string => '{"message" : "OK!"}', :status => 201
+            end
+          end
+          should "fallback to working URL" do
+            returning @update.store_http(*uris) do |pass_uri|
+              assert_equal uris[1], pass_uri
+            end
+          end
+        end
+        context "on non-201 response" do
+          setup do
+            [500, 403, 200].zip(full_urls(:exceptions)).each do |status, url|
+              FakeWeb.register_uri url, :string => 'Not what we want', :status => status
+            end
+          end
+          should "not succeed" do
+            assert !@update.store_http(*uris)
+          end
+        end
+      end
+
+    end    
+    
+  end
+  
+  #######
+  private
+  #######
+  
+  def full_urls(service)
+    full_uris(service).map(&:to_s)
+  end
+  
+  def full_uris(service)
+    @urls.map do |url|
+      uri = URI.parse(url)
+      uri.path = "/apps/123/#{service}.json"
+      uri
+    end
+  end
+
+  def uris
+    @urls.map { |url| URI.parse(url) }
+  end
+
+end