barometer 0.8.0 → 0.9.0

data/spec/utils/payload_request_spec.rb

@@ -0,0 +1,69 @@
+require_relative '../spec_helper'
+
+module Barometer::Utils
+  describe PayloadRequest do
+    describe '#get' do
+      let(:api) { double(:api, url: nil, params: nil, unwrap_nodes: [], current_query: nil) }
+      let(:payload_request) { PayloadRequest.new(api) }
+
+      before { Get.stub(call: double(content: '<foo></foo>', headers: {})) }
+
+      it 'makes a GET request' do
+        url = double(:url)
+        params = double(:params)
+        api.stub(url: url, params: params)
+
+        payload_request.get
+
+        expect( Get ).to have_received(:call).with(url, params)
+      end
+
+      it 'XML parses the GET response by default' do
+        content = double(:content)
+        Get.stub(call: double(content: content, headers: {}))
+        unwrap_nodes = double(:unwrap_nodes)
+        api.stub(unwrap_nodes: unwrap_nodes)
+        XmlReader.stub(:parse)
+
+        payload_request.get
+
+        expect( XmlReader ).to have_received(:parse).with(content, unwrap_nodes)
+      end
+
+      it 'wraps the result as a payload' do
+        expect( payload_request.get ).to be_a Payload
+      end
+
+      it 'stores the query used to make the request' do
+        current_query = double(:query)
+        api.stub(current_query: current_query)
+
+        payload = payload_request.get
+
+        expect( payload.query ).to eq current_query
+      end
+
+      context 'when the returned content type is */xml' do
+        it 'uses the XmlReader' do
+          Get.stub(call: double(content: '', headers: {'Content-Type' => 'text/xml'}))
+          XmlReader.stub(:parse)
+
+          payload_request.get
+
+          expect( XmlReader ).to have_received(:parse)
+        end
+      end
+
+      context 'when the returned content type is */json' do
+        it 'uses the JsonReader' do
+          Get.stub(call: double(content: '', headers: {'Content-Type' => 'application/json'}))
+          JsonReader.stub(:parse)
+
+          payload_request.get
+
+          expect( JsonReader ).to have_received(:parse)
+        end
+      end
+    end
+  end
+end

data/spec/utils/payload_spec.rb

@@ -0,0 +1,168 @@
+require_relative '../spec_helper'
+
+describe Barometer::Utils::Payload do
+  describe "#fetch" do
+    it "returns the value for the key provided" do
+      hash = {one: 1}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.fetch(:one).should == 1
+    end
+
+    it "returns nil when the key cannot be found" do
+      hash = {}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.fetch(:one).should be_nil
+    end
+
+    it "traverses multiple levels to get the value" do
+      hash = {one: {two: {three: 3}}}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.fetch(:one, :two, :three).should == 3
+    end
+
+    it "returns nil when any level cannot be found" do
+      hash = {one: {two: {three: {four: 4}}}}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.fetch(:one, :too, :three).should be_nil
+    end
+
+    it "returns nil when the starting value is nil" do
+      hash = nil
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.fetch(:one).should be_nil
+    end
+
+    it "returns a stripped result" do
+      hash = {one: " one "}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.fetch(:one).should == "one"
+    end
+
+    it "returns nil when the value is NA" do
+      hash = {one: "NA"}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.fetch(:one).should be_nil
+    end
+
+    context "when the data is accessed via an attribute" do
+      it "returns the value of the key" do
+        hash = {one: {'@two' => 2}}
+        parser = Barometer::Utils::Payload.new(hash)
+        parser.fetch(:one, '@two').should == 2
+      end
+
+      it "returns the value accessed via :attributes" do
+        class StringWithAttributes < String
+          attr_accessor :attributes
+        end
+        value_with_attributes = StringWithAttributes.new('one')
+        value_with_attributes.attributes = {'two' => 2}
+        hash = {one: value_with_attributes}
+        parser = Barometer::Utils::Payload.new(hash)
+        parser.fetch(:one, '@two').should == 2
+      end
+    end
+
+    context "when the data is accessed via an index" do
+      it "returns the value at that index" do
+        hash = {one: [2]}
+        parser = Barometer::Utils::Payload.new(hash)
+        parser.fetch(:one, 0).should == 2
+      end
+    end
+  end
+
+  describe "#fetch_each" do
+    it "returns a payload for each result found at the key" do
+      hash = {one: [{two: 2}, {two: 2}]}
+      parser = Barometer::Utils::Payload.new(hash)
+
+      expect { |b|
+        parser.fetch_each(:one, &b)
+      }.to yield_successive_args(Barometer::Utils::Payload, Barometer::Utils::Payload)
+    end
+
+    it "returns a payload for each result found at the key" do
+      hash = {one: [{two: 2}, {two: 2}]}
+      parser = Barometer::Utils::Payload.new(hash)
+
+      parser.fetch_each(:one) do |each_parser|
+        each_parser.fetch(:two).should == 2
+      end
+    end
+
+    it "raises an error when result is not an array" do
+      hash = {one: 1}
+      parser = Barometer::Utils::Payload.new(hash)
+
+      expect {
+        parser.fetch_each(:one){ |p| nil }
+      }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "#fetch_each_with_index" do
+    it "returns a payload for each result found at the key" do
+      hash = {one: [{two: 2}, {two: 2}]}
+      parser = Barometer::Utils::Payload.new(hash)
+
+      i = 0
+      parser.fetch_each_with_index(:one) do |each_parser, index|
+        each_parser.fetch(:two).should == 2
+        index.should == i
+        i += 1
+      end
+    end
+
+    it "raises an error when result is not an array" do
+      hash = {one: 1}
+      parser = Barometer::Utils::Payload.new(hash)
+
+      expect {
+        parser.fetch_each_with_index(:one){ |p| nil }
+      }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "#using" do
+    it "applies the regex to the fetched result" do
+      hash = {one: 'two, three'}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.using(/^(.*),/).fetch(:one).should == 'two'
+    end
+
+    it "does nothing if valid regex does not exist" do
+      hash = {one: 'two, three'}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.using(:invalid_regex).fetch(:one).should == 'two, three'
+    end
+
+    it "does nothing if regex does not capture proper result" do
+      hash = {one: 'two, three'}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.using(/^.*,.*$/).fetch(:one).should == 'two, three'
+    end
+
+    it "forgets the regex" do
+      hash = {one: 'two, three'}
+      parser = Barometer::Utils::Payload.new(hash)
+      parser.using(/^(.*),/).fetch(:one).should == 'two'
+      parser.fetch(:one).should == 'two, three'
+    end
+  end
+
+  describe '#units' do
+    it 'returns the query units when the query is present' do
+      units = double(:units)
+      query = double(:query, units: units)
+      payload = Barometer::Utils::Payload.new({}, query)
+      expect( payload.units ).to eq units
+    end
+
+    it 'returns nil when the query is not present' do
+      payload = Barometer::Utils::Payload.new({}, nil)
+      expect( payload.units ).to be_nil
+    end
+  end
+end
+

data/spec/utils/post_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+
+describe Barometer::Utils::Post do
+  describe ".call" do
+    it "posts http content to a given address" do
+      stub_request(:post, "www.example.com").to_return(body: "Hello World")
+
+      content = Barometer::Utils::Post.call('www.example.com', foo: :bar)
+      content.should include('Hello World')
+    end
+
+    it "raises Barometer::TimeoutError when it times out" do
+      stub_request(:post, "www.example.com").to_timeout
+
+      expect {
+        Barometer::Utils::Post.call('www.example.com')
+      }.to raise_error(Barometer::TimeoutError)
+    end
+  end
+end

data/spec/utils/time_spec.rb

@@ -0,0 +1,93 @@
+require_relative '../spec_helper'
+
+module Barometer
+  describe Utils::Time do
+    describe ".parse" do
+      it "accepts nil, does nothing" do
+        time = Utils::Time.parse
+        time.should be_nil
+      end
+
+      it "parses a Time object" do
+        t = ::Time.now.utc
+        time = Utils::Time.parse(t)
+
+        assert_times_are_equal(time, t)
+      end
+
+      it "parses a DateTime object" do
+        dt = ::DateTime.now
+        time = Utils::Time.parse(dt)
+
+        assert_times_are_equal(time, ::Time.now)
+      end
+
+      it "parses a Date object" do
+        d = ::Date.today
+        time = Utils::Time.parse(d)
+
+        now = ::Time.now
+        start_of_local_day = ::Time.local(
+          now.year, now.month, now.day,
+          0, 0, 0
+        )
+
+        assert_times_are_equal(time, start_of_local_day)
+      end
+
+      it "parses a String (with no format), assumes UTC" do
+        t = "March 15, 10:36 AM 2013"
+
+        time = Utils::Time.parse(t)
+        assert_times_are_equal(time, ::Time.utc(2013, 3, 15, 10, 36, 0))
+      end
+
+      it "parses a String (with optional format), assumes UTC" do
+        format = "%B %e, %l:%M %p %Y"
+        t = "March 15, 10:36 AM 2013"
+
+        time = Utils::Time.parse(t, format)
+        assert_times_are_equal(time, ::Time.utc(2013, 3, 15, 10, 36, 0))
+      end
+
+      it "parses a timezoned String (with optional format)" do
+        format = "%B %e, %l:%M %p %z %Y"
+        t = "March 15, 10:36 AM -0800 2013"
+
+        time = Utils::Time.parse(t, format)
+        assert_times_are_equal(time, ::Time.utc(2013, 3, 15, 18, 36, 0))
+      end
+
+      it "accepts an array of values, creating a UTC time" do
+        time = Utils::Time.parse(2013, 3, 15, 18, 36, 0)
+        assert_times_are_equal(time, ::Time.utc(2013, 3, 15, 18, 36, 0))
+      end
+    end
+
+    describe ".strptime" do
+    end
+
+    describe ".strftime" do
+    end
+
+    describe ".utc_from_base_plus_local_time" do
+    end
+
+    describe ".utc_merge_base_plus_time" do
+    end
+
+    describe ".add_one_day" do
+    end
+
+    describe ".add_one_hour" do
+    end
+
+    def assert_times_are_equal(t1, t2)
+      if t1.to_i == t2.to_i
+        expect( t1.to_i ).to eq t2.to_i
+      else
+        expect( t1.to_i ).to be_within(2).of(t2.to_i)
+      end
+    end
+  end
+end

data/spec/utils/versioned_registration_spec.rb

@@ -0,0 +1,105 @@
+require_relative '../spec_helper'
+
+describe Barometer::Utils::VersionedRegistration do
+  describe "#register" do
+    let(:registrations) { Barometer::Utils::VersionedRegistration.new }
+
+    it "treats no version as nil" do
+      expect {
+        registrations.register(:foo, double(:bar))
+      }.to change{ registrations.size }.by(1)
+    end
+
+    it "will register for the given key" do
+      expect {
+        registrations.register(:foo, :v1, double(:bar))
+      }.to change{ registrations.size }.by(1)
+    end
+
+    it "will not register the same key/version combination" do
+      registrations.register(:foo, :v1, double(:bar))
+
+      expect {
+        registrations.register(:foo, :v1, double(:bar))
+      }.not_to change{ registrations.size }
+    end
+
+    it "will not register the same key with default version" do
+      registrations.register(:foo, nil, double(:bar))
+
+      expect {
+        registrations.register(:foo, nil, double(:bar))
+      }.not_to change{ registrations.size }
+    end
+
+    it "will register a the same key but unique version" do
+      registrations.register(:foo, :v1, double(:bar))
+
+      expect {
+        registrations.register(:foo, :v2, double(:bar))
+      }.to change{ registrations.size }.by(1)
+    end
+
+    it "registers a block without a version" do
+      registration = Proc.new do
+      end
+
+      registrations.register(:foo, &registration)
+      registrations.find(:foo).should == registration
+    end
+
+    it "registers a block with a version" do
+      registration = Proc.new do
+      end
+
+      registrations.register(:foo, :v1, &registration)
+      registrations.find(:foo, :v1).should == registration
+    end
+  end
+
+  describe "#find" do
+    let(:registrations) { Barometer::Utils::VersionedRegistration.new }
+
+    it "finds the registration with no version by default" do
+      registration = double(:bar)
+      registrations.register(:foo, nil, registration)
+
+      registrations.find(:foo).should == registration
+      registrations.find(:foo, :v1).should == registration
+    end
+
+    it "finds the matching registration" do
+      registration_default = double(:bar_default)
+      registration_v1 = double(:bar_v1)
+      registration_v2 = double(:bar_v2)
+      registrations.register(:foo, nil, registration_default)
+      registrations.register(:foo, :v1, registration_v1)
+      registrations.register(:foo, :v2, registration_v2)
+
+      registrations.find(:foo, :v1).should == registration_v1
+      registrations.find(:foo, :v2).should == registration_v2
+    end
+
+    it "returns nothing if requested key not found" do
+      registrations.register(:foo, nil, double(:bar))
+      registrations.find(:bar, :v1).should be_nil
+    end
+
+    it "returns nothing if requested version not found" do
+      registrations.register(:foo, :v1, double(:bar))
+      registrations.find(:foo, :v2).should be_nil
+    end
+  end
+
+  describe "#size" do
+    let(:registration) { double(:registration) }
+    let(:registrations) { Barometer::Utils::VersionedRegistration.new }
+
+    it "counts versions" do
+      registrations.register(:foo, nil, registration)
+      registrations.register(:foo, :v1, registration)
+      registrations.register(:bar, :v1, registration)
+      registrations.size.should == 3
+    end
+  end
+end