rearview 1.1.2-jruby → 1.2.0-jruby

data/spec/helpers/application_helper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Rearview::ApplicationHelper do
+  context '#rearview_static_path' do
+    context 'development' do
+      it 'returns the non-compiled path' do
+        Rails.env.stubs(:development?).returns(true)
+        expect(helper.rearview_static_path).to eq('/rearview-src')
+      end
+    end
+    context 'non-development' do
+      it 'returns the compiled path' do
+        Rails.env.stubs(:development?).returns(false)
+        expect(helper.rearview_static_path).to eq('/rearview')
+      end
+    end
+    context 'segment' do
+      it 'prepends if present' do
+        expect(helper.rearview_static_path('/foo')).to eq('/rearview/foo')
+      end
+    end
+  end
+  context '#rearview_link_tag' do
+    it 'creates a link tag prepended with rearview_static_path' do
+      expect(helper.rearview_link_tag('/foo/bar.css')).to eq(%q{<link href="/rearview/foo/bar.css" />})
+    end
+  end
+  context '#rearview_img_tag' do
+    it 'creates a img tag prepended with rearview_static_path and img' do
+      expect(helper.rearview_img_tag('/foo/bar.gif')).to eq(%q{<img src="/rearview/img/foo/bar.gif" />})
+    end
+  end
+end

data/spec/lib/graphite/client_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe Graphite::Client do
+  context '.initialize' do
+    let(:default_client) { Graphite::Client.new }
+    context 'ca_file' do
+      it 'uses the cacerts in graphite lib by default' do
+        cacerts = File.expand_path("../../../../lib/graphite/cacerts.pem",__FILE__)
+        expect(default_client.connection.ssl.ca_file).to eq(cacerts)
+      end
+      it 'can be specified' do
+        expect(Graphite::Client.new({ssl: {ca_file: "cacerts.pem" }}).connection.ssl.ca_file).to eq("cacerts.pem")
+      end
+    end
+    context 'ssl_verify' do
+      it 'is true by default' do
+        expect(default_client.connection.ssl.verify).to be_true
+      end
+      it 'can be specified' do
+        expect(Graphite::Client.new({ssl: {verify: false}}).connection.ssl.verify).to be_false
+      end
+    end
+    context 'basic_auth' do
+      it 'is not enabled by default' do
+        expect(default_client.connection.headers['Authorization']).to be_nil
+      end
+      it 'can be specified' do
+        expect(Graphite::Client.new({basic_auth: {user: "foo", password: "bar"}}).connection.headers['Authorization']).not_to be_nil
+      end
+    end
+  end
+  context '#find_metric' do
+    before do
+      @client = Graphite::Client.new(url: 'http://graphite1.graphitehosting.com')
+      @connection = mock
+      @client.stubs(:connection).returns(@connection)
+    end
+    it 'makes the correct graphite API query' do
+      @connection.expects(:get).with('/metrics/find',{ query: 'stats.my_count' })
+      @client.find_metric('stats.my_count')
+    end
+  end
+  context '#render' do
+    before do
+      @client = Graphite::Client.new(url: 'http://graphite1.graphitehosting.com')
+      @connection = mock
+      @client.stubs(:connection).returns(@connection)
+    end
+    it 'makes the correct graphite API query' do
+      @connection.expects(:get).with('/render',{ foo: 'bar' })
+      @client.render({ foo: 'bar' })
+    end
+  end
+  context '#metric_exists?' do
+    before do
+      @client = Graphite::Client.new(url: 'http://graphite1.graphitehosting.com')
+      @request_stubs = Faraday::Adapter::Test::Stubs.new
+      @connection_stub = Faraday.new do |builder|
+        builder.adapter :test, @request_stubs
+      end
+      @client.stubs(:connection).returns(@connection_stub)
+    end
+    context 'true' do
+      it 'when response is 200, content-type is application/json, and json is a non-empty array' do
+        @request_stubs.get('/metrics/find?query=stats.my_count') {[ 200, { 'content-type' => 'application/json' }, '[ {"leaf": 1, "context": {}, "text": "my_count", "expandable": 0, "id": "stats.my_count", "allowChildren": 0} ]' ]}
+        expect(@client.metric_exists?('stats.my_count')).to be_true
+      end
+    end
+    context 'false' do
+      it 'when response is not 200' do
+        @request_stubs.get('/metrics/find?query=stats.my_count') {[ 406, { 'content-type' => 'application/json' }, '[ {"leaf": 1, "context": {}, "text": "my_count", "expandable": 0, "id": "stats.my_count", "allowChildren": 0} ]' ]}
+        expect(@client.metric_exists?('stats.my_count')).to be_false
+      end
+      it 'when content-type is not application/json' do
+        @request_stubs.get('/metrics/find?query=stats.my_count') {[ 200, { 'content-type' => 'image/png' }, '[ {"leaf": 1, "context": {}, "text": "my_count", "expandable": 0, "id": "stats.my_count", "allowChildren": 0} ]' ]}
+        expect(@client.metric_exists?('stats.my_count')).to be_false
+      end
+      it 'when json is an empty array' do
+        @request_stubs.get('/metrics/find?query=stats.my_count') {[ 200, { 'content-type' => 'application/json' }, '[ ]' ]}
+        expect(@client.metric_exists?('stats.my_count')).to be_false
+      end
+    end
+  end
+  context '#reachable?' do
+    before do
+      @client = Graphite::Client.new(url: 'http://graphite1.graphitehosting.com')
+      @request_stubs = Faraday::Adapter::Test::Stubs.new
+      @connection_stub = Faraday.new do |builder|
+        builder.adapter :test, @request_stubs
+      end
+      @client.stubs(:connection).returns(@connection_stub)
+    end
+    it 'is true when response is 200, content is image/png, and content-length > 0' do
+      @request_stubs.get('/render') {[ 200, { 'content-type' => 'image/png', 'content-length' => '123' }, '' ]}
+      expect(@client.reachable?).to be_true
+    end
+    it 'is false when response is not 200' do
+      @request_stubs.get('/render') {[ 500, { }, '' ]}
+      expect(@client.reachable?).to be_false
+    end
+    it 'is false when content-type is not image/png' do
+      @request_stubs.get('/render') {[ 200, { 'content-type' => 'text/html', 'content-length' => '123' }, '' ]}
+      expect(@client.reachable?).to be_false
+    end
+    it 'is false when content-length is 0' do
+      @request_stubs.get('/render') {[ 200, { 'content-type' => 'image/png', 'content-length' => '0' }, '' ]}
+      expect(@client.reachable?).to be_false
+    end
+  end
+  context 'forwardable' do
+    before do
+      @connection_stub = mock
+      Faraday.stubs(:new).returns(@connection_stub)
+      @client = Graphite::Client.new(url: 'http://graphite1.graphitehosting.com')
+    end
+    it 'to connection.get' do
+      @connection_stub.expects(:get).with('/render')
+      @client.get('/render')
+    end
+    it 'to connection.post' do
+      @connection_stub.expects(:post).with('/render')
+      @client.post('/render')
+    end
+  end
+end
+

data/spec/lib/graphite/graph_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Graphite::Graph do
+
+  context '.with_url' do
+    it 'should create a graph from the url' do
+      url = '/render?width=600&from=-1days&until=now&height=400&target=alias(summarize(stats_counts.deals.payment.sale.sent%2C%221min%22)%2C%22Sent%22)&target=alias(summarize(stats_counts.deals.payment.sale.notification_received%2C%221min%22)%2C%22Received%22)&target=alias(diffSeries(summarize(stats_counts.deals.payment.sale.notification_received%2C%221min%22)%2Csummarize(stats_counts.deals.payment.sale.sent%2C%221min%22))%2C%22Difference%22)&title=Payment_Sale_Per_Minute&yMin=&yMax=&_uniq=0.8545389957472919'
+      graph = Graphite::Graph.from_url(url)
+      expect(graph.targets.size).to eq(3)
+      expect(graph.from).to eq('-1days')
+      expect(graph.until).to eq('now')
+      expect(graph.title).to eq('Payment_Sale_Per_Minute')
+    end
+  end
+
+end
+

data/spec/lib/graphite/graphite_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Graphite do
+end

data/spec/lib/{rearview/graphite_parser_spec.rb → graphite/raw_parser.rb}

@@ -1,24 +1,25 @@
 require 'spec_helper'
 
-describe Rearview::GraphiteParser do
+describe Graphite::RawParser do
 
   artifact   = open("spec/data/test.dat").read
   nanPayload = open("spec/data/nan.dat").read
 
-  describe 'GraphiteParser' do
+  describe '.parse' do
     it "handles graphite data" do
-      data = Rearview::GraphiteParser.parse(artifact)
+      data = Graphite::RawParser.parse(artifact)
       data.length.should == 3
     end
 
     it "handles NaN in graphite data" do
-      data = Rearview::GraphiteParser.parse(nanPayload)
+      data = Graphite::RawParser.parse(nanPayload)
       data.length.should === 3
     end
 
     it "handles no data" do
-      data = Rearview::GraphiteParser.parse("")
+      data = Graphite::RawParser.parse("")
       data.length.should === 0
     end
   end
+
 end

data/spec/lib/graphite/target_grammer_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Graphite::TargetGrammer do
+
+  example_targets = {
+    simple_method: %q[alias(stats.x.y,"processed")],
+    nested_method: %q[color(alias(stats.x.y,"processed"),"red")],
+    color_only: %q[color(stats.x.y,"blue")],
+    very_nested: %q[alias(color(summarize(sumSeries(stats.*.y),"1min"),"orange"),"processed")]
+  }
+
+  describe Graphite::TargetGrammer::Target do
+    context '#expressions' do
+      it 'should contain all the expressions' do
+        p = Graphite::TargetParser.parse(example_targets[:nested_method])
+        expect(p.tree.expressions.count).to eq(2)
+      end
+      it 'should be empty if there are no expressions' do
+        p = Graphite::TargetParser.parse("seg1_seg2.seg3")
+        expect(p.tree.expressions).to eq([])
+      end
+    end
+    context '#color' do
+      it 'should return the color when its present' do
+        p = Graphite::TargetParser.parse(example_targets[:nested_method])
+        expect(p.tree.color).to eq("red")
+      end
+      it 'should return nil if there is no color' do
+        p = Graphite::TargetParser.parse(example_targets[:simple_method])
+        expect(p.tree.color).to be_nil
+        p = Graphite::TargetParser.parse("seg1_seg2.seg3")
+        expect(p.tree.color).to be_nil
+      end
+    end
+    context '#alias' do
+      it 'should return the alias when its present' do
+        p = Graphite::TargetParser.parse(example_targets[:nested_method])
+        expect(p.tree.alias).to eq("processed")
+      end
+      it 'should return nil if there is no alias' do
+        p = Graphite::TargetParser.parse(example_targets[:color_only])
+        expect(p.tree.alias).to be_nil
+        p = Graphite::TargetParser.parse("seg1_seg2.seg3")
+        expect(p.tree.alias).to be_nil
+      end
+    end
+    context '#metric' do
+      it 'should return the metric for nested expressions' do
+        p = Graphite::TargetParser.parse(example_targets[:nested_method])
+        expect(p.tree.metric).to eq("stats.x.y")
+      end
+      it 'should return the metric for a path only target' do
+        p = Graphite::TargetParser.parse("seg1_seg2.seg3")
+        expect(p.tree.metric).to eq("seg1_seg2.seg3")
+      end
+      it 'should return the metric for very nested expressions' do
+        p = Graphite::TargetParser.parse(example_targets[:very_nested])
+        expect(p.tree.metric).to eq("stats.*.y")
+      end
+    end
+    context '#functions' do
+      it 'should return all functions when present' do
+        p = Graphite::TargetParser.parse(example_targets[:nested_method])
+        expect(p.tree.functions).to include("color")
+        expect(p.tree.functions).to include("alias")
+      end
+      it 'should be empty if there are no functions' do
+        p = Graphite::TargetParser.parse("seg1_seg2.seg3")
+        expect(p.tree.functions).to eq([])
+      end
+    end
+    context '#path?' do
+      it 'should be true if the target is a path' do
+        p = Graphite::TargetParser.parse("seg1_seg2.seg3")
+        expect(p.tree.path?).to be_true
+      end
+      it 'should be false if the target is not a path' do
+        p = Graphite::TargetParser.parse(example_targets[:nested_method])
+        expect(p.tree.path?).to be_false
+      end
+    end
+    context '#expression?' do
+      it 'should be true if the target is an expression' do
+        p = Graphite::TargetParser.parse(example_targets[:nested_method])
+        expect(p.tree.expression?).to be_true
+      end
+      it 'should be false if the target is not an expression' do
+        p = Graphite::TargetParser.parse("seg1_seg2.seg3")
+        expect(p.tree.expression?).to be_false
+      end
+    end
+    context '#to_model' do
+      it 'should create a model from a target' do
+        p = Graphite::TargetParser.parse(example_targets[:nested_method])
+        model = p.tree.to_model
+        expect(model.color).to eq("red")
+        expect(model.alias).to eq("processed")
+        expect(model.metric).to eq("stats.x.y")
+        expect(model.functions).to include("color")
+        expect(model.functions).to include("alias")
+      end
+    end
+  end
+
+end
+

data/spec/lib/graphite/target_parser_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+RSpec::Matchers.define :be_parsed do |expected|
+
+  match do |actual|
+    !actual.error?
+  end
+
+  failure_message_for_should do |actual|
+    "expected that #{actual.data} would be parseable (#{actual.error})"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected that #{actual.data} would not be parseable"
+  end
+
+  description do
+    "be parseable"
+  end
+
+end
+
+describe Graphite::TargetParser do
+
+  context '.error?' do
+    let(:invalid_target) { %q[alias@(stats.x.y,"processed")] }
+    let(:valid_target) { %q[alias(stats.x.y,"processed")] }
+    it 'should be true if there is an error' do
+       p = Graphite::TargetParser.parse(invalid_target)
+       expect(p.error?).to be_true
+    end
+    it 'should be false if there is no error' do
+       p = Graphite::TargetParser.parse(valid_target)
+       expect(p.error?).to be_false
+    end
+  end
+
+  context '.error' do
+    let(:invalid_target) { %q[alias@(stats.x.y,"processed")] }
+    it 'should return the parsing failure message, line, and column' do
+       p = Graphite::TargetParser.parse(invalid_target)
+       expect(p.error[:message].present?).to be_true
+       expect(p.error[:line].present?).to be_true
+       expect(p.error[:column].present?).to be_true
+    end
+  end
+
+  context '.grammer' do
+    it 'should return a valid grammer file' do
+      grammer = Graphite::TargetParser.grammer
+      expect(grammer).not_to be_nil
+      expect(File.exists?(grammer)).to be_true
+    end
+  end
+
+  context '.parse!' do
+    let(:invalid_target) { %q[alias@(stats.x.y,"processed")] }
+    it 'should raise a typed exception when the text is unparseable' do
+       p = Graphite::TargetParser.new
+       expect { p.parse!(invalid_target) }.to raise_error(Graphite::TargetParser::TargetParserError)
+    end
+  end
+
+  context 'expression' do
+    context 'is parseable' do
+      it 'for all values in metrics.yml' do
+        metrics = YAML.load_file("spec/data/metrics.yml")
+        parser = Graphite::TargetParser.new
+        metrics.each do |m|
+          parser.parse(m)
+          expect(parser).to be_parsed
+        end
+      end
+    end
+  end
+
+  context 'string' do
+    context 'is valid' do
+      it 'with single quoted strings' do
+        p =  Graphite::TargetParser.parse(%q[alias(summarize(stats_counts.message_center.consumer_replies.created, '12h'), 'Consumer replies')])
+        expect(p).to be_parsed
+      end
+      it 'with double quoted strings' do
+        p =  Graphite::TargetParser.parse(%q[alias(summarize(stats_counts.message_center.consumer_replies.created, "12h"), "Consumer replies")])
+        expect(p).to be_parsed
+      end
+    end
+  end
+
+  context 'path' do
+    context 'is valid' do
+      it 'with seg1' do
+        p =  Graphite::TargetParser.parse("seg1")
+        expect(p).to be_parsed
+      end
+      it 'with seg1.*' do
+        p =  Graphite::TargetParser.parse("seg1.*")
+        expect(p).to be_parsed
+      end
+      it 'with seg1.seg2' do
+        p =  Graphite::TargetParser.parse("seg1.seg2")
+        expect(p).to be_parsed
+      end
+      it 'with seg1_seg2' do
+        p =  Graphite::TargetParser.parse("seg1_seg2")
+        expect(p).to be_parsed
+      end
+      it 'with seg1_seg2.seg3' do
+        p =  Graphite::TargetParser.parse("seg1_seg2.seg3")
+        expect(p).to be_parsed
+      end
+      it 'with *.seg3' do
+        p =  Graphite::TargetParser.parse("*.seg3")
+        expect(p).to be_parsed
+      end
+      it 'with *' do
+        p =  Graphite::TargetParser.parse("*")
+        expect(p).to be_parsed
+      end
+    end
+  end
+
+end
+