regentanz 0.3.3 → 1.0.0

data/test/unit/callbacks_test.rb

@@ -1,27 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class CallbacksTest < ActiveSupport::TestCase
-
-  def setup
-    @object = Object.new
-    @object.extend Regentanz::Callbacks
-  end
-
-  def test_should_define_constant
-    assert Regentanz::Callbacks::CALLBACKS
-    expected_callbacks = [:api_failure_detected, :api_failure_resumed]
-    assert_equal expected_callbacks, Regentanz::Callbacks::CALLBACKS
-  end
-
-  def test_google_weather_should_include_callbacks
-    assert Regentanz::GoogleWeather.included_modules.include?(Regentanz::Callbacks)
-    assert Regentanz::GoogleWeather.included_modules.include?(ActiveSupport::Callbacks)
-  end
-
-  def test_should_define_each_callback_method
-    Regentanz::Callbacks::CALLBACKS.each do |callback_method|
-      assert @object.private_methods.include?(callback_method.to_s), "#{callback_method} not defined"
-    end
-  end
-
-end

data/test/unit/configuration_test.rb

@@ -1,57 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-require "tmpdir"
-
-class ConfigurationTest < ActiveSupport::TestCase
-
-  test "should configure Regentanz" do
-    assert_respond_to Regentanz, :configure
-    assert_respond_to Regentanz, :configuration
-    assert_not_nil Regentanz.configuration
-
-    Regentanz.configure do |config|
-      config.do_not_get_weather = true
-    end
-    assert_not_nil Regentanz.configuration
-    assert Regentanz.configuration.do_not_get_weather
-  end
-
-  test "should have configuration" do
-    configuration_options = [
-      :base_url,
-      :cache_backend,
-      :cache_dir,
-      :cache_prefix,
-      :cache_ttl,
-      :retry_marker,
-      :retry_ttl,
-      :do_not_get_weather,
-      :suppress_stderr_output
-    ]
-    assert_equal configuration_options, Regentanz::Configuration::OPTIONS, "Diff: #{configuration_options - Regentanz::Configuration::OPTIONS}"
-    obj = Regentanz::Configuration.new
-    configuration_options.each do |config_option|
-      assert_respond_to obj, config_option
-    end
-  end
-
-  test "every DEFAULT_OPTION should have a cattr_accessor" do
-    assert_not_nil Regentanz::Configuration::DEFAULT_OPTIONS
-    Regentanz::Configuration::DEFAULT_OPTIONS.each do |config_option|
-      assert_respond_to Regentanz::Configuration, :"default_#{config_option}"
-      assert_not_nil    Regentanz::Configuration.send(:"default_#{config_option}")
-    end
-
-  end
-
-  test "instance should have sane defaults" do
-    obj = Regentanz::Configuration.new
-    tmpdir = Dir.tmpdir
-    assert_equal "http://www.google.com/ig/api",               obj.base_url
-    assert_equal "#{tmpdir}",                                  obj.cache_dir
-    assert_equal "regentanz",                                  obj.cache_prefix
-    assert_equal 14400,                                        obj.cache_ttl
-    assert_equal 3600,                                         obj.retry_ttl
-    assert_equal "#{tmpdir}/regentanz_api_retry.txt",          obj.retry_marker
-  end
-
-end

data/test/unit/current_condition_test.rb

@@ -1,33 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class CurrentConditionTest < ActiveSupport::TestCase
-  
-  test "should define setters and getters" do
-    obj = Regentanz::Conditions::Current.new
-    [:condition, :style, :icon, :humidity, :wind_condition, :temp_c, :temp_f].each do |attr|
-      assert_respond_to obj, attr
-      assert_respond_to obj, :"#{attr}="
-    end
-  end
-
-  test "should initialize with attributes hash" do
-    attributes = {
-      "condition"      => "Klar",
-      "temp_f"         => "77",
-      "temp_c"         => "25",
-      "humidity"       => "Feuchtigkeit: 57 %",
-      "icon"           => "http://www.google.com/ig/images/weather/sunny.gif",
-      "style"          => "sunny",
-      "wind_condition" => "Wind: W mit 24 km/h"
-    }
-    obj = Regentanz::Conditions::Current.new(attributes)
-    assert_equal "Klar", obj.condition
-    assert_equal 77, obj.temp_f
-    assert_equal 25, obj.temp_c
-    assert_equal "Feuchtigkeit: 57 %", obj.humidity
-    assert_equal "http://www.google.com/ig/images/weather/sunny.gif", obj.icon
-    assert_equal "sunny", obj.style
-    assert_equal "Wind: W mit 24 km/h", obj.wind_condition
-  end
-
-end

data/test/unit/forecast_condition_test.rb

@@ -1,35 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class ForecastConditionTest < ActiveSupport::TestCase
-  
-  def setup
-    @object = Regentanz::Conditions::Forecast.new
-  end
-
-  test "should define setters and getters" do
-    [:condition, :style, :icon, :day_of_week, :high, :low].each do |attr|
-      assert_respond_to @object, attr
-      assert_respond_to @object, :"#{attr}="
-    end
-  end
-
-  test "should initialize with attributes hash" do
-    attributes = {
-      "high"        => "31",
-      "condition"   => "Vereinzelt Regen",
-      "icon"        => "http://www.google.com/ig/images/weather/chance_of_rain.gif",
-      "day_of_week" =>"Do.",
-      "low"         => "16",
-      "style"       => "chance-of-rain"
-    }
-
-    obj = Regentanz::Conditions::Forecast.new(attributes)
-    assert_equal 31, obj.high
-    assert_equal "Vereinzelt Regen", obj.condition
-    assert_equal "http://www.google.com/ig/images/weather/chance_of_rain.gif", obj.icon
-    assert_equal "Do.", obj.day_of_week
-    assert_equal 16, obj.low
-    assert_equal "chance-of-rain", obj.style
-  end
-
-end

data/test/unit/google_weather_test.rb

@@ -1,125 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class GoogleWeatherTest < ActiveSupport::TestCase
-
-  TEST_CACHE_FILE_NAME = File.join(Regentanz.configuration.cache_dir, "regentanz_test.xml")
-
-  def setup
-    setup_regentanz_test_configuration!
-  end
-
-  def teardown
-    Dir.glob(File.join(Regentanz.configuration.cache_dir, "**", "*")).each { |file| File.delete(file) }
-  end
-
-  test "should initialize with options hash" do
-    Regentanz::GoogleWeather.any_instance.expects(:get_weather).never()
-    options = { :location => "Test Valley", :lang => "es" }
-    obj = Regentanz::GoogleWeather.new(options)
-    assert_equal "Test Valley", obj.location
-    assert_equal "es", obj.lang
-  end
-
-  test "should be compatible with old constructor" do
-    Regentanz::GoogleWeather.any_instance.expects(:get_weather).never()
-    obj = Factory(:google_weather, :location => "Test Valley")
-    assert_equal "Test Valley", obj.location
-    assert_equal "de", obj.lang
-  end
-
-  test "should have cache instance" do
-    obj = Factory(:google_weather)
-    assert_respond_to obj, :cache
-    assert_kind_of Regentanz.configuration.cache_backend, obj.cache
-  end
-
-  test "should enter retry state if invalid xml file has been found" do
-    stub_valid_xml_api_response!
-    Regentanz::GoogleWeather.any_instance.expects(:api_failure_detected) # callback
-
-    weather = Factory(:google_weather)
-    assert !weather.waiting_for_retry?
-    create_invalid_xml_response(TEST_CACHE_FILE_NAME)
-
-    weather.get_weather!
-    assert weather.waiting_for_retry?
-  end
-
-  test "should leave retry state remove invalid cache file when retry_ttl waittime is over" do
-    File.new(Regentanz.configuration.retry_marker, "w+").close
-    assert File.exists?(Regentanz.configuration.retry_marker) # ensure test setup
-    Regentanz.configuration.retry_ttl = 0; sleep 0.1
-    Regentanz::GoogleWeather.any_instance.expects(:api_failure_resumed) # callback
-
-    create_invalid_xml_response(TEST_CACHE_FILE_NAME)
-    weather = Factory(:google_weather)
-
-    weather.get_weather!
-    assert !weather.waiting_for_retry?
-  end
-
-  test "should have lang option" do
-    weather = Factory(:google_weather, :lang => :es)
-    assert_equal "es", weather.lang
-  end
-
-  def test_should_calculate_sunrise_and_sunset_based_on_geodata
-    weather = Regentanz::GoogleWeather.new("Berlin", weather_options(:geo_location => nil) )
-    assert weather.respond_to? :sunrise
-    assert weather.respond_to? :sunset
-    assert_nil weather.sunrise
-    assert_nil weather.sunset
-
-    lat = 52.5163253260716
-    lng = 13.3780860900879
-
-    weather = Regentanz::GoogleWeather.new("Berlin", weather_options(:geodata => {:lat => lat, :lng => lng}) )
-    assert weather.sunrise.is_a? Time
-    assert weather.sunset.is_a? Time
-  end
-
-  test "should set default cache_id by location" do
-    obj = Regentanz::GoogleWeather.new(:location => "Test Valley", :cache_id => nil)
-    assert_not_nil obj.cache_id
-  end
-
-  test "should work with caching disabled" do
-    Regentanz.configuration.cache_backend = nil
-    stub_valid_xml_api_response!
-    obj = Factory(:google_weather, :cache_id => nil)
-    assert_nil obj.cache
-    obj.get_weather!
-  end
-
-  test "should delegate retry state to cache instance" do
-    obj = Factory(:google_weather)
-    assert_respond_to obj, :waiting_for_retry?
-    assert_not_nil obj.cache
-    assert !obj.waiting_for_retry?
-    obj.cache.expects(:waiting_for_retry?).returns(true)
-    assert obj.waiting_for_retry?
-  end
-
-  test "should respond_to present?" do
-    obj = Factory(:google_weather)
-    assert_respond_to obj, :present?
-
-    Regentanz::GoogleWeather.any_instance.expects(:current).returns(nil)
-    Regentanz::GoogleWeather.any_instance.expects(:forecast).returns(nil)
-    assert_equal false, obj.present?
-
-    Regentanz::GoogleWeather.any_instance.expects(:current).returns(nil)
-    Regentanz::GoogleWeather.any_instance.expects(:forecast).returns(true)
-    assert_equal true, obj.present?
-    Regentanz::GoogleWeather.any_instance.expects(:current).returns(true)
-    assert_equal true, obj.present?
-  end
-
-  private
-
-  # Return a few default options for the test environment
-  def weather_options(options = {})
-    {:cache_id => "test"}.merge(options.symbolize_keys!)
-  end
-
-end

data/test/unit/parser/google_weather_parser_test.rb

@@ -1,71 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class GoogleWeatherParserTest < ActiveSupport::TestCase
-
-  def setup
-    setup_regentanz_test_configuration!
-  end
-
-  test "should have parser instance" do
-    obj = Regentanz::GoogleWeather.new
-    assert_respond_to obj, :parser
-    assert_not_nil obj.parser
-    assert_kind_of Regentanz::Parser::GoogleWeather, obj.parser
-  end
-
-  test "should convert encoding" do
-    obj = Regentanz::Parser::GoogleWeather.new
-    assert_respond_to obj, :convert_encoding
-    assert_nil obj.convert_encoding(nil)
-    assert_nil obj.convert_encoding("")
-    # FIXME test actual conversion
-  end
-
-  test "should parse xml for current condition" do
-    obj = Regentanz::Parser::GoogleWeather.new
-    assert_respond_to obj, :parse_current!
-    assert_nil obj.parse_current!(nil)
-    assert_nil obj.parse_current!("")
-
-    xml = valid_xml_response
-    parsed = obj.parse_current!(xml)
-    assert_kind_of Regentanz::Conditions::Current, parsed
-    assert_equal "Feuchtigkeit: 57 %", parsed.humidity
-    assert_equal "Wind: W mit 24 km/h", parsed.wind_condition
-    assert_equal 25, parsed.temp_c
-    assert_equal 77, parsed.temp_f
-    assert_equal "http://www.google.com/ig/images/weather/sunny.gif", parsed.icon
-    assert_equal "Klar", parsed.condition
-  end
-
-  test "should rescue current condition parsing from parse erros" do
-    obj = Regentanz::Parser::GoogleWeather.new
-    xml = invalid_xml_response
-    assert_nothing_raised { assert_nil obj.parse_current!(xml) }
-  end
-
-  test "should parse xml for forecast" do
-    obj = Regentanz::Parser::GoogleWeather.new
-    assert_respond_to obj, :parse_forecast!
-    assert_nil obj.parse_forecast!(nil)
-    assert_nil obj.parse_forecast!("")
-
-    xml = valid_xml_response
-    parsed = obj.parse_forecast!(xml)
-    assert_kind_of Array, parsed
-    assert_equal 1, parsed.size
-    assert_kind_of Regentanz::Conditions::Forecast, parsed.first
-    assert_equal "Do.", parsed.first.day_of_week
-    assert_equal 31, parsed.first.high
-    assert_equal 16, parsed.first.low
-    assert_equal "http://www.google.com/ig/images/weather/chance_of_rain.gif", parsed.first.icon
-    assert_equal "Vereinzelt Regen", parsed.first.condition
-  end
-  
-  test "should rescue forecast parsing from parse erros" do
-    obj = Regentanz::Parser::GoogleWeather.new
-    xml = invalid_xml_response
-    assert_nothing_raised { assert_nil obj.parse_forecast!(xml) }
-  end
-
-end