barometer 0.8.0 → 0.9.0

data/spec/weather_services/services_spec.rb

@@ -1,135 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::WeatherService, :vcr => {
-  :cassette_name => "WeatherService"
-} do
-  before(:each) do
-    query_term = "Calgary,AB"
-    @query = Barometer::Query.new(query_term)
-    @service = Barometer::WeatherService.source(:wunderground)
-    @time = Time.now
-  end
-
-  describe "and the class method" do
-    describe "source" do
-      it "responds" do
-        Barometer::WeatherService.respond_to?("source").should be_true
-      end
-
-      it "requires a Symbol or String" do
-        lambda { Barometer::WeatherService.source }.should raise_error(ArgumentError)
-        lambda { Barometer::WeatherService.source(1) }.should raise_error(ArgumentError)
-
-        lambda { Barometer::WeatherService.source("wunderground") }.should_not raise_error(ArgumentError)
-        lambda { Barometer::WeatherService.source(:wunderground) }.should_not raise_error(ArgumentError)
-      end
-
-      it "raises an error if source doesn't exist" do
-        lambda { Barometer::WeatherService.source(:not_valid) }.should raise_error(ArgumentError)
-        lambda { Barometer::WeatherService.source(:wunderground) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns the corresponding Service object" do
-        Barometer::WeatherService.source(:wunderground).should == Barometer::WeatherService::Wunderground
-        Barometer::WeatherService.source(:wunderground).superclass.should == Barometer::WeatherService
-      end
-
-      it "raises an error when retrieving the wrong class" do
-        lambda { Barometer::WeatherService.source(:temperature) }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "when initialized" do
-    before(:each) do
-      @service = Barometer::WeatherService.new
-      @measurement = Barometer::Measurement.new
-      @query = Barometer::Query.new("test")
-    end
-
-    it "defaults _meets_requirements?" do
-      Barometer::WeatherService.send("_meets_requirements?").should be_true
-    end
-
-    it "stubs _source_name" do
-      lambda { Barometer::WeatherService.send("_source_name") }.should raise_error(NotImplementedError)
-    end
-
-    it "stubs _accepted_formats" do
-      lambda { Barometer::WeatherService.send("_accepted_formats") }.should raise_error(NotImplementedError)
-    end
-
-    it "stubs _measure" do
-      Barometer::WeatherService._measure(@measurement,@query,true).is_a?(Barometer::Measurement).should be_true
-    end
-
-    it "stubs _build_extra" do
-      Barometer::WeatherService._build_extra.should be_nil
-    end
-
-    it "stubs _fetch" do
-      Barometer::WeatherService._fetch.should be_nil
-    end
-
-    it "stubs _build_current" do
-      Barometer::WeatherService._build_current.should be_nil
-    end
-
-    it "stubs _build_forecast" do
-      Barometer::WeatherService._build_forecast.should be_nil
-    end
-
-    it "stubs _build_location" do
-      Barometer::WeatherService._build_location.should be_nil
-    end
-
-    it "stubs _build_sun" do
-      Barometer::WeatherService._build_sun.should be_nil
-    end
-
-    it "stubs _build_links" do
-      Barometer::WeatherService._build_links.should == {}
-    end
-
-    it "defaults _supports_country?" do
-      Barometer::WeatherService._supports_country?.should be_true
-    end
-
-    it "defaults _requires_keys?" do
-      Barometer::WeatherService._requires_keys?.should be_false
-    end
-
-    it "defaults _has_keys?" do
-      lambda { Barometer::WeatherService._has_keys? }.should raise_error(NotImplementedError)
-    end
-  end
-
-  describe "when measuring," do
-    it "responds to measure" do
-      Barometer::WeatherService.respond_to?("measure").should be_true
-    end
-
-    # since Barometer::WeatherService defines the measure method, you could actually just
-    # call Barometer::WeatherService.measure ... but this will not invoke a specific
-    # weather API driver.  Make sure this usage raises an error.
-    it "requires an actuall driver" do
-      lambda { Barometer::WeatherService.measure(@query) }.should raise_error(NotImplementedError)
-    end
-
-    it "requires a Barometer::Query object" do
-      lambda { Barometer::WeatherService.measure("invalid") }.should raise_error(ArgumentError)
-      @query.is_a?(Barometer::Query).should be_true
-      lambda { Barometer::WeatherService.measure(@query) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns a Barometer::Measurement object" do
-      @service.measure(@query).is_a?(Barometer::Measurement).should be_true
-    end
-
-    it "returns current and future" do
-      measurement = @service.measure(@query)
-      measurement.current.is_a?(Barometer::Measurement::Result).should be_true
-      measurement.forecast.is_a?(Array).should be_true
-    end
-  end
-end

data/spec/weather_services/wunderground_spec.rb

@@ -1,179 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-include Barometer
-
-describe Barometer::WeatherService::Wunderground, :vcr => {
-  :cassette_name => "WeatherService::Wunderground"
-} do
-  before(:each) do
-    @accepted_formats = [:zipcode, :postalcode, :icao, :coordinates, :geocode]
-    @base_uri = "http://api.wunderground.com/auto/wui/geo"
-  end
-
-  describe "the class methods" do
-    it "defines accepted_formats" do
-      WeatherService::Wunderground._accepted_formats.should == @accepted_formats
-    end
-
-    it "defines source_name" do
-      WeatherService::Wunderground._source_name.should == :wunderground
-    end
-
-    it "defines fetch_current" do
-      WeatherService::Wunderground.respond_to?("_fetch_current").should be_true
-    end
-
-    it "defines fetch_forecast" do
-      WeatherService::Wunderground.respond_to?("_fetch_forecast").should be_true
-    end
-  end
-
-  describe "building the current data" do
-    it "defines the build method" do
-      WeatherService::Wunderground.respond_to?("_build_current").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Wunderground._build_current }.should raise_error(ArgumentError)
-      WeatherService::Wunderground._build_current({})
-      lambda { WeatherService::Wunderground._build_current({}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns Barometer::CurrentMeasurement object" do
-      current = WeatherService::Wunderground._build_current({})
-      current.is_a?(Measurement::Result).should be_true
-    end
-  end
-
-  describe "building the forecast data" do
-    it "defines the build method" do
-      WeatherService::Wunderground.respond_to?("_build_forecast").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Wunderground._build_forecast }.should raise_error(ArgumentError)
-      lambda { WeatherService::Wunderground._build_forecast({}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns Array object" do
-      current = WeatherService::Wunderground._build_forecast({})
-      current.is_a?(Array).should be_true
-    end
-  end
-
-  describe "building the station data" do
-    it "defines the build method" do
-      WeatherService::Wunderground.respond_to?("_build_station").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Wunderground._build_station }.should raise_error(ArgumentError)
-      lambda { WeatherService::Wunderground._build_station({}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns Barometer::Location object" do
-      station = WeatherService::Wunderground._build_station({})
-      station.is_a?(Data::Location).should be_true
-    end
-  end
-
-  describe "building the location data" do
-    it "defines the build method" do
-      WeatherService::Wunderground.respond_to?("_build_location").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Wunderground._build_location }.should raise_error(ArgumentError)
-      lambda { WeatherService::Wunderground._build_location({}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns Barometer::Location object" do
-      location = WeatherService::Wunderground._build_location({})
-      location.is_a?(Data::Location).should be_true
-    end
-  end
-
-  describe "building the timezone" do
-    it "defines the build method" do
-      WeatherService::Wunderground.respond_to?("_parse_full_timezone").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Wunderground._parse_full_timezone }.should raise_error(ArgumentError)
-      lambda { WeatherService::Wunderground._parse_full_timezone({}) }.should_not raise_error(ArgumentError)
-    end
-  end
-
-  describe "building the sun data" do
-    it "defines the build method" do
-      WeatherService::Wunderground.respond_to?("_build_sun").should be_true
-    end
-
-    it "requires Hash input" do
-      lambda { WeatherService::Wunderground._build_sun }.should raise_error(ArgumentError)
-      lambda { WeatherService::Wunderground._build_sun({}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "requires Barometer::Zone input" do
-      lambda { WeatherService::Wunderground._build_sun({}, "invalid") }.should raise_error(ArgumentError)
-      lambda { WeatherService::Wunderground._build_sun({}) }.should_not raise_error(ArgumentError)
-    end
-
-    it "returns Barometer::Sun object" do
-      sun = WeatherService::Wunderground._build_sun({})
-      sun.is_a?(Data::Sun).should be_true
-    end
-  end
-
-  describe "when measuring" do
-    before(:each) do
-      @query = Barometer::Query.new("Calgary,AB")
-      @measurement = Barometer::Measurement.new
-    end
-
-    describe "all" do
-      it "responds to _measure" do
-        WeatherService::Wunderground.respond_to?("_measure").should be_true
-      end
-
-      it "requires a Barometer::Measurement object" do
-        lambda { WeatherService::Wunderground._measure(nil, @query) }.should raise_error(ArgumentError)
-        lambda { WeatherService::Wunderground._measure("invlaid", @query) }.should raise_error(ArgumentError)
-
-        lambda { WeatherService::Wunderground._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
-      end
-
-      it "requires a Barometer::Query query" do
-        lambda { WeatherService::Wunderground._measure }.should raise_error(ArgumentError)
-        lambda { WeatherService::Wunderground._measure(@measurement, 1) }.should raise_error(ArgumentError)
-
-        lambda { WeatherService::Wunderground._measure(@measurement, @query) }.should_not raise_error(ArgumentError)
-      end
-
-      it "returns a Barometer::Measurement object" do
-        result = WeatherService::Wunderground._measure(@measurement, @query)
-        result.is_a?(Barometer::Measurement).should be_true
-        result.current.is_a?(Measurement::Result).should be_true
-        result.forecast.is_a?(Array).should be_true
-      end
-    end
-  end
-
-  describe "overall data correctness" do
-    before(:each) do
-      @query = Barometer::Query.new("Calgary,AB")
-      @measurement = Barometer::Measurement.new
-    end
-
-   it "should correctly build the data" do
-      result = WeatherService::Wunderground._measure(@measurement, @query)
-
-      # build timezone
-      @measurement.timezone.zone_full.should == "America/Edmonton"
-      @measurement.timezone.current.should == "America/Edmonton"
-
-      # build current
-      @measurement.current.sun.rise.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
-      @measurement.current.sun.set.to_s.should match(/^\d{1,2}:\d{1,2}[ ]?[apmAPM]{0,2}$/i)
-    end
-  end
-end

data/spec/web_services/geocode_spec.rb

@@ -1,31 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::WebService::Geocode, :vcr => {
-  :cassette_name => "WebService::Geocode"
-} do
-  before(:each) do
-    @zipcode = "90210"
-  end
-
-  describe "and the class methods" do
-    describe "fetch," do
-      it "requires a Query object" do
-        lambda { Barometer::WebService::Geocode.fetch }.should raise_error(ArgumentError)
-        lambda { Barometer::WebService::Geocode.fetch("invalid") }.should raise_error(ArgumentError)
-        query = Barometer::Query.new(@zipcode)
-        query.is_a?(Barometer::Query).should be_true
-        lambda { Barometer::WebService::Geocode.fetch(query) }.should_not raise_error(ArgumentError)
-      end
-
-      it "queries (key no longer required)" do
-        query = Barometer::Query.new(@zipcode)
-        Barometer::WebService::Geocode.fetch(query).should_not be_nil
-      end
-
-      it "returns a Geo object" do
-        query = Barometer::Query.new(@zipcode)
-        Barometer::WebService::Geocode.fetch(query).is_a?(Data::Geo).should be_true
-      end
-    end
-  end
-end

data/spec/web_services/noaa_station_id_spec.rb

@@ -1,33 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::WebService::NoaaStation, :vcr => {
-  :cassette_name => "WebService::NoaaStation"
-} do
-  before(:each) do
-    @latitude = "34.10"
-    @longitude = "-118.41"
-  end
-
-  describe "and the class methods" do
-    describe "fetch," do
-      it "requires latitude" do
-        Barometer::WebService::NoaaStation.should_receive("_fetch").never
-        Barometer::WebService::NoaaStation.fetch(nil,@longitude)
-      end
-
-      it "requires longitude" do
-        Barometer::WebService::NoaaStation.should_receive("_fetch").never
-        Barometer::WebService::NoaaStation.fetch(@latitude,nil)
-      end
-
-      it "queries" do
-        Barometer::WebService::NoaaStation.fetch(@latitude,@longitude).should_not be_nil
-      end
-
-      it "returns a string" do
-        Barometer::WebService::NoaaStation.fetch(@latitude,@longitude).is_a?(String).should be_true
-        Barometer::WebService::NoaaStation.fetch(@latitude,@longitude).should == "KSMO"
-      end
-    end
-  end
-end

data/spec/web_services/placemaker_spec.rb

@@ -1,41 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::WebService::Placemaker do
-  before(:each) do
-    @coordinates = "40.756054,-73.986951"
-    @geocode = "New York, NY"
-  end
-
-  describe "and the class methods" do
-    describe "fetch," do
-      it "requires a Query object" do
-        lambda { Barometer::WebService::Placemaker.fetch }.should raise_error(ArgumentError)
-        lambda { Barometer::WebService::Placemaker.fetch("invalid") }.should raise_error(ArgumentError)
-        query = Barometer::Query.new(@coordinates)
-        query.is_a?(Barometer::Query).should be_true
-        lambda { Barometer::WebService::Placemaker.fetch(query) }.should_not raise_error(ArgumentError)
-      end
-
-      # it "detects the key" do
-      #   query = Barometer::Query.new(@zipcode)
-      #   Barometer.google_geocode_key = nil
-      #   Barometer::WebService::Geocode.fetch(query).should be_nil
-      #   Barometer.google_geocode_key = KEY
-      #   Barometer::WebService::Geocode.fetch(query).should_not be_nil
-      # end
-      #
-      # it "returns a Geo object" do
-      #   query = Barometer::Query.new(@zipcode)
-      #   Barometer::WebService::Geocode.fetch(query).is_a?(Data::Geo).should be_true
-      # end
-
-    end
-
-    # it "detects the Google Geocode Key" do
-    #   Barometer.google_geocode_key = nil
-    #   Barometer::WebService::Geocode.send("_has_geocode_key?").should be_false
-    #   Barometer.google_geocode_key = KEY
-    #   Barometer::WebService::Geocode.send("_has_geocode_key?").should be_true
-    # end
-  end
-end

data/spec/web_services/web_services_spec.rb

@@ -1,20 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Barometer::WebService do
-  describe "and the class method" do
-    describe "source" do
-      it "stubs fetch" do
-        lambda { Barometer::WebService.fetch }.should raise_error(NotImplementedError)
-      end
-
-      it "detects a Query object" do
-        invalid = 1
-        Barometer::WebService.send("_is_a_query?").should be_false
-        Barometer::WebService.send("_is_a_query?", invalid).should be_false
-        valid = Barometer::Query.new
-        valid.is_a?(Barometer::Query).should be_true
-        Barometer::WebService.send("_is_a_query?", valid).should be_true
-      end
-    end
-  end
-end