barometer 0.8.0 → 0.9.0

data/spec/support/matchers/have_field.rb

@@ -0,0 +1,128 @@
+require 'rspec/expectations'
+
+module Barometer
+  module Matchers
+    def have_field(field)
+      HaveField.new(field)
+    end
+
+    class HaveField
+      def initialize(field)
+        @field = field
+      end
+
+      def matches?(subject)
+        @subject = subject
+        has_field? &&
+          type_casts_as_type? &&
+          sets_value?
+      end
+
+      def failure_message
+        "Expected #{expectation} (#{@problem})"
+      end
+
+      def description
+        "have data field \"#{@field}\""
+      end
+
+      def of_type(type)
+        @type = type
+        self
+      end
+
+      protected
+
+      def has_field?
+        assert @subject.respond_to?(@field), "does not have field '#{@field}'"
+      end
+
+      def type_casts_as_type?
+        if type_is_time?
+          set_value "2013-01-01 10:15:30 am"
+        elsif type_is_sun?
+          rise = Time.utc(2013,1,1,10,15,30)
+          set = Time.utc(2013,1,1,18,14,56)
+          set_value Data::Sun.new(rise: rise, set: set)
+        else
+          set_value 10
+        end
+        assert value.is_a?(@type), "#{@field} does not typecast as #{@type}"
+      end
+
+      def sets_value?
+        if type_is_time?
+          set_value "10 15 30 2013 01 01 am", "%H %M %S %Y %m %d %p"
+          assert value.to_i == Time.utc(2013,01,01,10,15,30).to_i, "expected value of '2013-01-01 10:15:30 am', got '#{print_value}'"
+        elsif type_is_sun?
+          rise = Time.utc(2013,1,1,10,15,30)
+          set = Time.utc(2013,1,1,18,14,56)
+          set_value Data::Sun.new(rise: rise, set: set)
+          assert print_value == "rise: 10:15, set: 18:14", "expected value of 'rise: 10:15, set: 18:14'', got '#{print_value}'"
+        else
+          set_value 10
+          assert value.to_i == 10, "expected value of '10', got '#{value.to_i}'"
+        end
+      end
+
+      private
+
+      def value
+        @subject.send(@field)
+      end
+
+      def set_value(*value)
+        if type_is_time?
+          @subject.send("#{@field}=", value)
+        else
+          @subject.send("#{@field}=", *value)
+        end
+      end
+
+      def print_value
+        value.to_s
+      end
+
+      def metric_units
+        @type.send(:new, true).units
+      end
+
+      def imperial_units
+        @type.send(:new, false).units
+      end
+
+      def expectation
+        "\"#{@field}\" to be a #{@type}"
+      end
+
+      def value_responds_to_metric?
+        if type_is_time?
+          false
+        elsif @type == Float
+          # rubinius does not like Float.new being called on the next line
+          # so avoid it
+          false
+        else
+          @type.respond_to?(:new) && @type.new.respond_to?(:metric)
+        end
+      end
+
+      def type_is_time?
+        @type == Time
+      end
+
+      def type_is_sun?
+        @type == Data::Sun
+      end
+
+      def assert(test, failure_message)
+        if test
+          true
+        else
+          @problem = failure_message
+          false
+        end
+      end
+    end
+  end
+end

data/spec/support/matchers/have_forecast.rb

@@ -0,0 +1,46 @@
+require_relative 'path'
+require_relative 'formats'
+
+module Barometer
+  module Matchers
+    def have_forecast(*paths)
+      HaveForecast.new(*paths)
+    end
+
+    class HaveForecast
+      include Barometer::Matchers::Formats
+
+      def initialize(*paths)
+        @paths = paths
+      end
+
+      def matches?(subject)
+        @result = Walker.new(subject.forecast[0]).follow(@paths)
+
+        if @format
+          is_of_format?(@format, @result)
+        else
+          @result == @value || @result.to_f == @value
+        end
+      end
+
+      def failure_message
+        "expected that '#{@result}' matches '#{@value || @format}'"
+      end
+
+      def description
+        "have correct forecast value for #{@paths.join('.')}"
+      end
+
+      def as_value(value)
+        @value = value
+        self
+      end
+
+      def as_format(format)
+        @format = format
+        self
+      end
+    end
+  end
+end

data/spec/support/matchers/path.rb

@@ -0,0 +1,23 @@
+module Barometer
+  module Matchers
+    class Walker
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def follow(paths)
+        path_value = value
+        paths.each do |path|
+          path_value = path_value.send(path)
+        end
+        if path_value.respond_to?(:strftime)
+          path_value.strftime("%Y-%m-%d %H:%M:%S %z")
+        else
+          path_value.to_s
+        end
+      end
+    end
+  end
+end

data/spec/support/query_factory.rb

@@ -0,0 +1,20 @@
+module Barometer
+  module Support
+    module Factory
+      def build_query
+        double(
+          :query,
+          q: 'foo',
+          format: :unknown,
+          units: :metric,
+          geo: nil,
+          metric?: true
+        )
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Barometer::Support::Factory
+end

data/spec/utils/address_spec.rb

@@ -0,0 +1,67 @@
+require_relative '../spec_helper'
+
+describe Barometer::Utils::Address do
+  describe "#url" do
+    it "returns the initialized url" do
+      address = Barometer::Utils::Address.new("http://www.example.com")
+      address.url.should == "http://www.example.com"
+    end
+
+    it "ignores query params in the url" do
+      address = Barometer::Utils::Address.new("http://www.example.com?foo=bar")
+      address.url.should == "http://www.example.com"
+    end
+
+    it "ignores query params in the url" do
+      address = Barometer::Utils::Address.new("http://www.example.com", foo: :bar)
+      address.url.should == "http://www.example.com"
+    end
+  end
+
+  describe "#query" do
+    it "returns the initialized query" do
+      address = Barometer::Utils::Address.new("", {"foo" => "bar"})
+      address.query.should == {"foo" => "bar"}
+    end
+
+    it "returns the extracted query" do
+      address = Barometer::Utils::Address.new("http://www.example.com?foo=bar")
+      address.query.should == {"foo" => "bar"}
+    end
+
+    it "combines the extracted query and the provided query" do
+      address = Barometer::Utils::Address.new("http://www.example.com?foo=bar", foz: :baz)
+      address.query.should == {"foo" => "bar", "foz" => "baz"}
+    end
+
+    it "converts all keys to String" do
+      address = Barometer::Utils::Address.new("", {foo: :bar})
+      address.query.should == {"foo" => "bar"}
+    end
+  end
+
+  describe "#add" do
+    it "merges query params with existing params" do
+      address = Barometer::Utils::Address.new("", {"foo" => "bar"})
+      address.add(foz: :baz)
+      address.query.should == {"foo" => "bar", "foz" => "baz"}
+    end
+  end
+
+  describe "#to_s" do
+    it "formats the query params with the url" do
+      address = Barometer::Utils::Address.new("http://www.example.com", foo: :bar)
+      address.to_s.should == "http://www.example.com?foo=bar"
+    end
+
+    it "formats the query params with the url" do
+      address = Barometer::Utils::Address.new("http://www.example.com?foo=bar", foz: :baz)
+      address.to_s.should == "http://www.example.com?foo=bar&foz=baz"
+    end
+
+    it "formats just the url" do
+      address = Barometer::Utils::Address.new("http://www.example.com")
+      address.to_s.should == "http://www.example.com"
+    end
+  end
+end

data/spec/utils/config_reader_spec.rb

@@ -0,0 +1,157 @@
+require_relative '../spec_helper'
+
+describe Barometer::Base do
+  around do |example|
+    cached_config = Barometer.config
+    example.run
+    Barometer.config = cached_config
+  end
+
+  describe ".take_level_while" do
+    context "when multiple tiers are configured" do
+      before { Barometer.config = { 1 => :foo, 2 => :bar } }
+
+      context "and the first iteration returns false" do
+        it "only yields once" do
+          expect { |b|
+            m = Proc.new do |*args|
+              b.to_proc.call(*args)
+              false
+            end
+
+            Barometer::Utils::ConfigReader.take_level_while(&m)
+          }.to yield_successive_args(1)
+        end
+      end
+
+      context "and the first iterations returns true" do
+        it "yields multiple times" do
+          expect { |b|
+            m = Proc.new do |*args|
+              b.to_proc.call(*args)
+              true
+            end
+
+            Barometer::Utils::ConfigReader.take_level_while(&b)
+          }.to yield_successive_args(1, 2)
+        end
+      end
+    end
+
+    context "when only one tier is configured" do
+      before { Barometer.config = { 1 => :foo } }
+
+      context "and the first iteration returns false" do
+        it "only yields once" do
+          expect { |b|
+            Barometer::Utils::ConfigReader.take_level_while(&b)
+          }.to yield_successive_args(1)
+        end
+      end
+
+      context "and the first iterations returns true" do
+        it "only yields once" do
+          expect { |b|
+            Barometer::Utils::ConfigReader.take_level_while(&b)
+          }.to yield_successive_args(1)
+        end
+      end
+    end
+
+    context "when no tiers are configured" do
+      it "never yields" do
+        Barometer.config = {}
+
+        expect { |b|
+          Barometer::Utils::ConfigReader.take_level_while(&b)
+        }.not_to yield_control
+      end
+    end
+  end
+
+  describe ".services" do
+    context "when there is one service for the tier" do
+      context "and that service is just a symbol" do
+        it "calls the block with no config" do
+          Barometer.config = { 1 => :test }
+
+          expect { |b|
+            Barometer::Utils::ConfigReader.services(1, &b)
+          }.to yield_with_args(:test, {})
+        end
+      end
+
+      context "and that service is just a string" do
+        it "calls the block with no config" do
+          Barometer.config = { 1 => 'test' }
+
+          expect { |b|
+            Barometer::Utils::ConfigReader.services(1, &b)
+          }.to yield_with_args(:test, {})
+        end
+      end
+
+      context "and that service is in an array" do
+        it "calls the block with no config" do
+          Barometer.config = { 1 => [:test] }
+
+          expect { |b|
+            Barometer::Utils::ConfigReader.services(1, &b)
+          }.to yield_with_args(:test, {})
+        end
+      end
+
+      context "and that service is a hash with options" do
+        it "calls the block with the options" do
+          Barometer.config = { 1 => {test: {version: :v1} } }
+
+          expect { |b|
+            Barometer::Utils::ConfigReader.services(1, &b)
+          }.to yield_with_args(:test, {version: :v1})
+        end
+      end
+
+      context "and that service is a hash with options in an array" do
+        it "calls the block with the options" do
+          Barometer.config = { 1 => [{test: {version: :v1} }] }
+
+          expect { |b|
+            Barometer::Utils::ConfigReader.services(1, &b)
+          }.to yield_with_args(:test, {version: :v1})
+        end
+      end
+    end
+
+    context "when there are multiple services for the tier" do
+      context "and both services have no opitons" do
+        it "calls the block twice without options" do
+          Barometer.config = { 1 => [:foo, :bar] }
+
+          expect { |b|
+            Barometer::Utils::ConfigReader.services(1, &b)
+          }.to yield_successive_args([:foo, {}], [:bar, {}])
+        end
+      end
+
+      context "and one service has no options, one has options" do
+        it "calls the block twice with and without options" do
+          Barometer.config = { 1 => [:foo, {bar: {version: :v1}}] }
+
+          expect { |b|
+            Barometer::Utils::ConfigReader.services(1, &b)
+          }.to yield_successive_args([:foo, {}], [:bar, {version: :v1}])
+        end
+      end
+
+      context "and both services have opitons" do
+        it "calls the block twice with options" do
+          Barometer.config = { 1 => [{foo: {weight: 2}}, {bar: {version: :v1}}] }
+
+          expect { |b|
+            Barometer::Utils::ConfigReader.services(1, &b)
+          }.to yield_successive_args([:foo, {weight: 2}], [:bar, {version: :v1}])
+        end
+      end
+    end
+  end
+end

data/spec/utils/get_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../spec_helper'
+
+module Barometer
+  describe Utils::Get do
+    describe '.call' do
+      it 'gets http content from a given address' do
+        stub_request(:get, 'www.example.com?foo=bar').to_return(body: 'Hello World')
+
+        response = Utils::Get.call('www.example.com', foo: :bar)
+        expect( response.content ).to include('Hello World')
+      end
+
+      it 'raises Barometer::TimeoutError when it times out' do
+        stub_request(:get, 'www.example.com').to_timeout
+
+        expect {
+          Utils::Get.call('www.example.com')
+        }.to raise_error(Barometer::TimeoutError)
+      end
+    end
+  end
+end