barometer 0.8.0 → 0.9.0

data/spec/response/base_spec.rb

@@ -0,0 +1,103 @@
+require_relative '../spec_helper'
+require 'time'
+
+module Barometer::Response
+  describe Base do
+    let(:query) { build_query }
+    let(:response) { Base.new }
+
+    specify { expect( response ).to have_field(:query).of_type(String) }
+    specify { expect( response ).to have_field(:weight).of_type(Integer) }
+    specify { expect( response ).to have_field(:status_code).of_type(Integer) }
+
+    describe ".new" do
+      specify { expect( response.weight ).to eq 1 }
+      specify { expect( response.requested_at ).to be }
+    end
+
+    describe "#success?" do
+      it "returns true if :status_code == 200" do
+        response.status_code = 200
+        expect( response ).to be_success
+      end
+
+      it "returns false if :status_code does not == 200" do
+        response.status_code = nil
+        expect( response ).not_to be_success
+
+        response.status_code = 406
+        expect( response ).not_to be_success
+      end
+    end
+
+    describe "#complete?" do
+      before { response.current = Current.new }
+
+      it "returns true when current is complete" do
+        response.current.stub(complete?: true)
+        expect( response ).to be_complete
+      end
+
+      it "returns false when the is no current" do
+        response.current = nil
+        expect( response ).not_to be_complete
+      end
+
+      it "returns false when current is not complete" do
+        response.current.stub(complete?: false)
+        expect( response ).not_to be_complete
+      end
+    end
+
+    describe "#for" do
+      let(:date) { double(:date) }
+      let(:prediction_collection) { double(:prediction_collection) }
+
+      before do
+        prediction_collection.stub(:for)
+        response.forecast = prediction_collection
+      end
+
+      context "when a date is given" do
+        it "passes it along to the collection" do
+          response.for(date)
+          expect( response.forecast ).to have_received(:for).with(date)
+        end
+      end
+
+      context "when a date is not given" do
+        context "and the timezone is set" do
+          it "passes along timezone.today to the collection" do
+            timezone = Barometer::Data::Zone.new('EST')
+            timezone.stub(today: date)
+            response.timezone = timezone
+
+            response.for
+
+            expect( response.forecast ).to have_received(:for).with(date)
+          end
+        end
+
+        context "and the tiemzone is not set" do
+          it "passes along Date.today to the collection" do
+            Date.stub(today: date)
+            response.timezone = nil
+
+            response.for
+
+            expect( response.forecast ).to have_received(:for).with(date)
+          end
+        end
+      end
+    end
+
+    describe "#add_query" do
+      let(:query) { double(:query, to_s: 'foo', format: :unknown, metric?: true) }
+      before { response.add_query(query) }
+
+      specify { expect( response ).to be_metric }
+      specify { expect( response.format ).to eq :unknown }
+      specify { expect( response.query ).to eq 'foo' }
+    end
+  end
+end

data/spec/response/current_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+module Barometer::Response
+  describe Current do
+    it { should have_field(:observed_at).of_type(Time) }
+    it { should have_field(:stale_at).of_type(Time) }
+    it { should have_field(:temperature).of_type(Barometer::Data::Temperature) }
+    it { should have_field(:dew_point).of_type(Barometer::Data::Temperature) }
+    it { should have_field(:heat_index).of_type(Barometer::Data::Temperature) }
+    it { should have_field(:wind_chill).of_type(Barometer::Data::Temperature) }
+    it { should have_field(:wind).of_type(Barometer::Data::Vector) }
+    it { should have_field(:pressure).of_type(Barometer::Data::Pressure) }
+    it { should have_field(:visibility).of_type(Barometer::Data::Distance) }
+    it { should have_field(:humidity).of_type(Float) }
+    it { should have_field(:icon).of_type(String) }
+    it { should have_field(:condition).of_type(String) }
+    it { should have_field(:sun).of_type(Barometer::Data::Sun) }
+
+    describe '#complete?' do
+      let(:current) { Current.new }
+
+      it 'returns true when the temperature is present' do
+        current.temperature = 10
+        expect( current ).to be_complete
+      end
+
+      it 'returns false when there is no temperature' do
+        current.temperature = nil
+        expect( current ).not_to be_complete
+      end
+    end
+  end
+end

data/spec/response/predicition_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../spec_helper'
+
+describe Barometer::Response::Prediction do
+  it { should have_field(:starts_at).of_type(Time) }
+  it { should have_field(:ends_at).of_type(Time) }
+  it { should have_field(:high).of_type(Barometer::Data::Temperature) }
+  it { should have_field(:low).of_type(Barometer::Data::Temperature) }
+  it { should have_field(:pop).of_type(Float) }
+  it { should have_field(:icon).of_type(String) }
+  it { should have_field(:condition).of_type(String) }
+  it { should have_field(:sun).of_type(Barometer::Data::Sun) }
+
+  describe "#date=" do
+    it "raises an error if unable to make a Date" do
+      expect { subject.date = 'invalid' }.to raise_error(ArgumentError)
+    end
+
+    it "sets the date to a passed in Date" do
+      date = Date.new
+      subject.date = date
+      subject.date.should == date
+    end
+
+    it "sets the date to a passed in date string" do
+      subject.date = '2013-02-19'
+      subject.date.should == Date.new(2013, 02, 19)
+    end
+
+    it "sets :starts_at to 00:00:00 on given date" do
+      subject.starts_at.should be_nil
+
+      subject.date = Date.new(2013, 02, 19)
+      subject.starts_at.year.should == 2013
+      subject.starts_at.month.should == 2
+      subject.starts_at.day.should == 19
+      subject.starts_at.hour.should == 0
+      subject.starts_at.min.should == 0
+      subject.starts_at.sec.should == 0
+    end
+
+    it "sets :ends_at to 23:59:59 on given date" do
+      subject.ends_at.should be_nil
+
+      subject.date = Date.new(2013, 02, 19)
+      subject.ends_at.year.should == 2013
+      subject.ends_at.month.should == 2
+      subject.ends_at.day.should == 19
+      subject.ends_at.hour.should == 23
+      subject.ends_at.min.should == 59
+      subject.ends_at.sec.should == 59
+    end
+  end
+
+  describe "#covers?" do
+    it "returns true if the valid_date range includes the given date" do
+      subject.date = Date.new(2009,05,05)
+      subject.covers?(Time.utc(2009,5,5,12,0,0)).should be_true
+    end
+
+    it "returns false if the valid_date range excludes the given date" do
+      subject.date = Date.new(2009,05,05)
+      subject.covers?(Time.utc(2009,5,4,12,0,0)).should be_false
+    end
+  end
+end

data/spec/response/prediction_collection_spec.rb

@@ -0,0 +1,97 @@
+require_relative '../spec_helper'
+
+module Barometer::Response
+  describe PredictionCollection do
+    let(:prediction_collection) { PredictionCollection.new }
+
+    describe "#<<" do
+      it "adds Prediction" do
+        expect {
+          prediction_collection << Prediction.new
+        }.to change{ prediction_collection.count }.by(1)
+      end
+    end
+
+    describe "#[]" do
+      let(:prediction) { Prediction.new }
+      before { prediction_collection << prediction }
+
+      it "finds prediction by index when passed a number" do
+        expect( prediction_collection[0] ).to eq prediction
+      end
+
+      it "finds prediction by using #for when not passed a number" do
+        index = double(:index)
+        prediction_collection.stub(:for)
+
+        prediction_collection[index]
+
+        expect( prediction_collection ).to have_received(:for).with(index)
+      end
+    end
+
+    describe "#for" do
+      let(:tommorrow) { Date.today + 1 }
+
+      context "when there are no predictions" do
+        specify { expect( prediction_collection.for(tommorrow) ).to be_nil }
+      end
+
+      context "when there are predictions" do
+        before do
+          today = Date.today
+
+          0.upto(3) do |i|
+            prediction = Prediction.new
+            prediction.date = today + i
+            prediction_collection << prediction
+          end
+        end
+
+        it "finds the date using a String" do
+          expect( prediction_collection.for(tommorrow.to_s) ).to eq prediction_collection[1]
+        end
+
+        it "finds the date using a Date" do
+          expect( prediction_collection.for(tommorrow) ).to eq prediction_collection[1]
+        end
+
+        it "finds the date using a DateTime" do
+          # 1.8.7 - Date does not have to_datetime
+          datetime = DateTime.new(tommorrow.year, tommorrow.month, tommorrow.day)
+          expect( prediction_collection.for(datetime) ).to eq prediction_collection[1]
+        end
+
+        it "finds the date using a Time" do
+          # 1.8.7 - Date does not have to_time
+          time = Time.parse(tommorrow.to_s)
+          expect( prediction_collection.for(time) ).to eq prediction_collection[1]
+        end
+
+        it "finds the date using Data::Time" do
+          time = Barometer::Utils::Time.parse(tommorrow.to_s)
+          expect( prediction_collection.for(time) ).to eq prediction_collection[1]
+        end
+
+        it "finds nothing when there is not a match" do
+          expect( prediction_collection.for(Date.today - 1) ).to be_nil
+        end
+      end
+    end
+
+    describe "#build" do
+      it "yields a new response" do
+        expect { |b|
+          prediction_collection.build(&b)
+        }.to yield_with_args(Prediction)
+      end
+
+      it "adds the new response to forecast array" do
+        expect {
+          prediction_collection.build do
+          end
+        }.to change{ prediction_collection.count }.by(1)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,30 +1,30 @@
-require 'rubygems'
+require 'coveralls'
+Coveralls.wear!
+
 require 'rspec'
 require 'cgi'
 require 'pry'
 require 'vcr'
-require 'fakefs/spec_helpers'
+require 'webmock/rspec'
+
+require_relative '../lib/barometer'
 
-$:.unshift((File.join(File.dirname(__FILE__), '..', 'lib')))
-require 'barometer'
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
 
-WEATHERBUG_CODE = Barometer::KeyFileParser.find(:weather_bug, :code) || 'weatherbug'
-YAHOO_KEY = Barometer::KeyFileParser.find(:yahoo, :app_id) || 'yahoo'
+WEATHERBUG_CODE = Barometer::Support::KeyFileParser.find(:weather_bug, :code) || 'weatherbug'
+FORECAST_IO_APIKEY = Barometer::Support::KeyFileParser.find(:forecast_io, :apikey) || 'forecastio'
 downcased_weatherbug_code = WEATHERBUG_CODE.to_s
 downcased_weatherbug_code[0] = WEATHERBUG_CODE.to_s[0..0].downcase
 
-# Barometer.debug!
-Barometer.yahoo_placemaker_app_id = 'placemaker'
-
 VCR.configure do |config|
   config.cassette_library_dir = 'spec/cassettes'
   config.hook_into :webmock
-  config.default_cassette_options = { :record => :none, :serialize_with => :json }
+  config.default_cassette_options = { record: :none, serialize_with: :json }
 
   config.filter_sensitive_data('WEATHERBUG_CODE') { WEATHERBUG_CODE.to_s }
+  # weather bug uses api as host name.  this is downcased when the request it made
   config.filter_sensitive_data('WEATHERBUG_CODE') { downcased_weatherbug_code }
-  config.filter_sensitive_data('<YAHOO_KEY>') { YAHOO_KEY.to_s }
-  config.filter_sensitive_data('<PLACEMAKER_KEY>') { Barometer.yahoo_placemaker_app_id.to_s }
+  config.filter_sensitive_data('FORECAST_IO_APIKEY') { FORECAST_IO_APIKEY.to_s }
 
   config.configure_rspec_metadata!
 end
@@ -32,3 +32,5 @@ end
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
 end
+
+include Barometer::Matchers

data/spec/support/key_file_parser.rb

@@ -0,0 +1,22 @@
+module Barometer
+  KEY_FILE = File.expand_path(File.join('~', '.barometer'))
+
+  module Support
+    class KeyFileParser
+      def self.find(*paths)
+        if File.exists?(KEY_FILE)
+          keys = YAML.load_file(KEY_FILE)
+
+          paths.each do |path|
+            if keys && keys.has_key?(path.to_s)
+              keys = keys.fetch(path.to_s)
+            else
+              keys = nil
+            end
+          end
+          keys
+        end
+      end
+    end
+  end
+end

data/spec/support/matchers/formats.rb

@@ -0,0 +1,36 @@
+require 'rspec/expectations'
+
+module Barometer
+  module Matchers
+    module Formats
+      def is_of_format?(format, value)
+        value.match(_find_regex(format))
+      end
+
+      def _find_regex(format)
+        case format
+        when :time
+          /^\d{1,4}-\d{1,2}-\d{1,2} \d{2}:\d{2}:\d{2} [\-\+\d]{5}$/i
+        when :optional_string
+          /^[\w \.-]*$/i
+        when :string
+          /^[\w \.-]{2,}$/i
+        when :number
+          /^\d{1,3}$/i
+        when :float
+          /^[\d\.]{1,5}$/i
+        when :temperature
+          /^-?[0-9\.]{1,5}[ ]?[cfCF]?$/i
+        when :pressure
+          /^[0-9\.]{1,7}[ ]?[a-zA-Z]{0,3}$/i
+        when :vector
+          /^[0-9\.]{1,5} (?:mph|kph) (?:[nesw]{1,3}(?:orth|outh|t|ast)?|@ [0-9\.]{1,5} degrees)$/i
+        when :distance
+          /^[0-9\.]{1,5}[ ]?k?m?$/i
+        when Regexp
+          format
+        end
+      end
+    end
+  end
+end

data/spec/support/matchers/have_data.rb

@@ -0,0 +1,46 @@
+require_relative 'path'
+require_relative 'formats'
+
+module Barometer
+  module Matchers
+    def have_data(*paths)
+      HaveData.new(*paths)
+    end
+
+    class HaveData
+      include Barometer::Matchers::Formats
+
+      def initialize(*paths)
+        @paths = paths
+      end
+
+      def matches?(subject)
+        @result = Walker.new(subject).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 value for #{@paths.join('.')}"
+      end
+
+      def as_value(value)
+        @value = value
+        self
+      end
+
+      def as_format(format)
+        @format = format
+        self
+      end
+    end
+  end
+end