timezone 0.6.0 → 0.99.0

data/test/google_lookup_test.rb

@@ -6,10 +6,7 @@ require_relative 'http_test_client'
 
 class GoogleLookupTest < ::Minitest::Unit::TestCase
   def setup
-    Timezone::Configure.begin do |c|
-      c.http_client = HTTPTestClient
-      c.google_api_key = 'MTIzYWJj'
-    end
+    config { |c| c.google_api_key = 'MTIzYWJj' }
   end
 
   def coordinates
@@ -17,50 +14,63 @@ class GoogleLookupTest < ::Minitest::Unit::TestCase
   end
 
   def lookup
-    ::Timezone::Lookup::Google.new(Timezone::Configure)
+    ::Timezone::Configure.lookup
   end
 
-  def test_missing_api_key
-    Timezone::Configure.begin{ |c| c.google_api_key = nil }
-    assert_raises(::Timezone::Error::InvalidConfig){ lookup }
-  ensure
-    Timezone::Configure.begin{ |c| c.google_api_key = 'MTIzYWJj' }
+  def config
+    Timezone::Configure.instance_variable_set(:@lookup, nil)
+    Timezone::Configure.instance_variable_set(:@geonames_lookup, nil)
+    Timezone::Configure.instance_variable_set(:@google_lookup, nil)
+
+    Timezone::Configure.begin do |c|
+      c.http_client = HTTPTestClient
+      yield(c)
+    end
   end
 
   def test_google_using_lat_lon_coordinates
-    HTTPTestClient.body = File.open(mock_path + '/google_lat_lon_coords.txt').read
+    lookup.client.body =
+      File.open(mock_path + '/google_lat_lon_coords.txt').read
 
     assert_equal 'Australia/Adelaide', lookup.lookup(*coordinates)
   end
 
   def test_google_request_denied_read_lat_lon_coordinates
-    HTTPTestClient.body = nil
-    assert_raises Timezone::Error::Google, 'The provided API key is invalid.' do
+    lookup.client.body = nil
+    assert_raises Timezone::Error::Google do
       lookup.lookup(*coordinates)
     end
   end
 
   def test_url_non_enterprise
-    Timecop.freeze(Time.at(1433347661)) do
+    Timecop.freeze(Time.at(1_433_347_661)) do
       result = lookup.send(:url, '123', '123')
-      assert_equal "/maps/api/timezone/json?location=123%2C123&timestamp=1433347661&key=MTIzYWJj", result
+      params = {
+        'location' => '123%2C123',
+        'timestamp' => '1433347661',
+        'key' => 'MTIzYWJj'
+      }.map { |k, v| "#{k}=#{v}" }
+
+      assert_equal "/maps/api/timezone/json?#{params.join('&')}", result
     end
   end
 
   def test_url_enterprise
-    Timezone::Configure.begin do |c|
-      c.google_client_id = '123&asdf'
-    end
+    config { |c| c.google_client_id = '123&asdf' }
 
-    Timecop.freeze(Time.at(1433347661)) do
+    Timecop.freeze(Time.at(1_433_347_661)) do
       result = lookup.send(:url, '123', '123')
-      assert_equal '/maps/api/timezone/json?location=123%2C123&timestamp=1433347661&client=123%26asdf&signature=B1TNSSvIw9Wvf_ZjjW5uRzGm4F4=', result
-    end
+      params = {
+        'location' => '123%2C123',
+        'timestamp' => '1433347661',
+        'client' => '123%26asdf',
+        'signature' => 'B1TNSSvIw9Wvf_ZjjW5uRzGm4F4='
+      }.map { |k, v| "#{k}=#{v}" }
 
-  ensure
-    Timezone::Configure.begin do |c|
-      c.google_client_id = nil
+      assert_equal "/maps/api/timezone/json?#{params.join('&')}", result
     end
+  ensure
+    config { |c| c.google_client_id = nil }
   end
 
   private

data/test/http_test_client.rb

@@ -1,14 +1,15 @@
 class HTTPTestClient
-  class << self ; attr_accessor :body ; end
-
   Response = Struct.new(:body) do
-    def code ; '200' ; end
+    def code; '200'; end
   end
 
-  def initialize(protocol, host)
+  attr_accessor :body
+
+  # TODO: Modify once on 1.0.0
+  def initialize(_protocol, _url = nil)
   end
 
-  def get(url)
-    HTTPTestClient::Response.new(self.class.body)
+  def get(_url)
+    HTTPTestClient::Response.new(body)
   end
 end

data/test/test_lookup_test.rb

@@ -34,6 +34,8 @@ class TestLookupTest < ::Minitest::Unit::TestCase
   end
 
   def teardown
-    Timezone::Configure.begin{ |c| c.lookup = nil }
+    Timezone::Configure.instance_variable_set(:@lookup, nil)
+    Timezone::Configure.instance_variable_set(:@google_lookup, nil)
+    Timezone::Configure.instance_variable_set(:@geonames_lookup, nil)
   end
 end

data/test/test_timezone.rb

@@ -0,0 +1,59 @@
+require 'timezone'
+require 'minitest/autorun'
+
+class TestTimezone < ::Minitest::Test
+  parallelize_me!
+
+  def test_names
+    assert Timezone.names.is_a?(Array)
+    refute Timezone.names.empty?
+    assert Timezone.names.include?('Australia/Sydney')
+    assert Timezone.names.include?('America/Los_Angeles')
+  end
+
+  def test_get
+    assert Timezone['Australia/Sydney'].valid?
+    refute Timezone['foo/bar'].valid?
+  end
+
+  def test_fetch
+    assert Timezone.fetch('Australia/Sydney').valid?
+    assert_equal 'foo', Timezone.fetch('foo/bar') { 'foo' }
+    assert_raises Timezone::Error::InvalidZone do
+      Timezone.fetch('foo/bar')
+    end
+    assert_equal 'foo', Timezone.fetch('foo/bar', 'foo')
+
+    Timezone.stub(:warn, nil) do
+      assert_equal 'b', Timezone.fetch('foo/bar', 'a') { 'b' }
+    end
+  end
+
+  def test_fetch_warning
+    warning = false
+
+    Timezone.stub(:warn, ->(_) { warning = true }) do
+      Timezone.fetch('foo/bar', 'a') { 'b' }
+    end
+
+    assert warning, 'warning was not issued'
+  end
+
+  def test_lookup
+    Timezone::Lookup.config(:test)
+
+    Timezone::Lookup.lookup.stub(-10, 10, 'America/Los_Angeles')
+    Timezone::Lookup.lookup.stub(-20, 20, 'foos')
+
+    assert_equal Timezone['America/Los_Angeles'], Timezone.lookup(-10, 10)
+    assert_equal 'foo', Timezone.lookup(-20, 20) { 'foo' }
+    assert_raises Timezone::Error::InvalidZone do
+      Timezone.lookup(-20, 20)
+    end
+    assert_equal 'foo', Timezone.lookup(-20, 20, 'foo')
+
+    Timezone.stub(:warn, nil) do
+      assert_equal 'b', Timezone.lookup(-20, 20, 'a') { 'b' }
+    end
+  end
+end

data/test/timezone/lookup/test_geonames.rb

@@ -0,0 +1,59 @@
+require 'timezone/lookup/geonames'
+require 'minitest/autorun'
+require_relative '../../http_test_client'
+
+class TestGeonames < ::Minitest::Test
+  parallelize_me!
+
+  def coordinates
+    [-34.92771808058, 138.477041423321]
+  end
+
+  def lookup
+    config = OpenStruct.new
+    config.username = 'timezone'
+    config.request_handler = HTTPTestClient
+
+    Timezone::Lookup::Geonames.new(config)
+  end
+
+  def test_default_config
+    assert_equal 'http', lookup.config.protocol
+    assert_equal 'api.geonames.org', lookup.config.url
+  end
+
+  def test_missing_username
+    assert_raises(::Timezone::Error::InvalidConfig) do
+      Timezone::Lookup::Geonames.new(OpenStruct.new)
+    end
+  end
+
+  def test_lookup
+    mine = lookup
+    mine.client.body = File.open(mock_path + '/lat_lon_coords.txt').read
+
+    assert_equal 'Australia/Adelaide', mine.lookup(*coordinates)
+  end
+
+  def test_api_limit
+    mine = lookup
+    mine.client.body = File.open(mock_path + '/api_limit_reached.txt').read
+
+    assert_raises Timezone::Error::GeoNames, 'api limit reached' do
+      mine.lookup(*coordinates)
+    end
+  end
+
+  private
+
+  def mock_path
+    File.expand_path(
+      File.join(
+        File.dirname(__FILE__),
+        '..',
+        '..',
+        'mocks'
+      )
+    )
+  end
+end

data/test/timezone/lookup/test_google.rb

@@ -0,0 +1,94 @@
+require 'timezone/lookup/google'
+require 'minitest/autorun'
+require 'timecop'
+require_relative '../../http_test_client'
+
+class TestGoogle < ::Minitest::Test
+  parallelize_me!
+
+  def coordinates
+    [-34.92771808058, 138.477041423321]
+  end
+
+  def config
+    config = OpenStruct.new
+    config.request_handler = HTTPTestClient
+    config.api_key = 'MTIzYWJj'
+    config
+  end
+
+  def lookup
+    Timezone::Lookup::Google.new(config)
+  end
+
+  def test_default_config
+    assert_equal 'https', lookup.config.protocol
+    assert_equal 'maps.googleapis.com', lookup.config.url
+  end
+
+  def test_missing_api_key
+    assert_raises(::Timezone::Error::InvalidConfig) do
+      Timezone::Lookup::Google.new(OpenStruct.new)
+    end
+  end
+
+  def test_google_using_lat_long_coordinates
+    mine = lookup
+    mine.client.body = File.open(mock_path + '/google_lat_lon_coords.txt').read
+
+    assert_equal 'Australia/Adelaide', mine.lookup(*coordinates)
+  end
+
+  def test_google_request_denied_read_lat_long_coordinates
+    mine = lookup
+    mine.client.body = nil
+    assert_raises Timezone::Error::Google, 'The provided API key is invalid.' do
+      mine.lookup(*coordinates)
+    end
+  end
+
+  def test_url_non_enterprise
+    Timecop.freeze(Time.at(1_433_347_661)) do
+      result = lookup.send(:url, '123', '123')
+      params = {
+        'location' => '123%2C123',
+        'timestamp' => '1433347661',
+        'key' => 'MTIzYWJj'
+      }.map { |k, v| "#{k}=#{v}" }
+
+      assert_equal "/maps/api/timezone/json?#{params.join('&')}", result
+    end
+  end
+
+  def test_url_enterprise
+    econfig = config
+    econfig.client_id = '123&asdf'
+
+    enterprise = Timezone::Lookup::Google.new(econfig)
+
+    Timecop.freeze(Time.at(1_433_347_661)) do
+      result = enterprise.send(:url, '123', '123')
+      params = {
+        'location' => '123%2C123',
+        'timestamp' => '1433347661',
+        'client' => '123%26asdf',
+        'signature' => 'B1TNSSvIw9Wvf_ZjjW5uRzGm4F4='
+      }.map { |k, v| "#{k}=#{v}" }
+
+      assert_equal "/maps/api/timezone/json?#{params.join('&')}", result
+    end
+  end
+
+  private
+
+  def mock_path
+    File.expand_path(
+      File.join(
+        File.dirname(__FILE__),
+        '..',
+        '..',
+        'mocks'
+      )
+    )
+  end
+end

data/test/timezone/lookup/test_test.rb

@@ -0,0 +1,24 @@
+require 'timezone/lookup/test'
+require 'timezone'
+require 'minitest/autorun'
+
+class TestTest < ::Minitest::Test
+  parallelize_me!
+
+  def lookup
+    Timezone::Lookup::Test.new(OpenStruct.new)
+  end
+
+  def test_simple_stub
+    mine = lookup
+    mine.stub(-10, 10, 'America/Los_Angeles')
+
+    assert_equal 'America/Los_Angeles', mine.lookup(-10, 10)
+  end
+
+  def test_missing_stub
+    assert_raises(::Timezone::Error::Test) do
+      lookup.lookup(100, 100)
+    end
+  end
+end

data/test/timezone/test_deprecate.rb

@@ -0,0 +1,20 @@
+require 'timezone/deprecate'
+require 'minitest/autorun'
+
+class TestDeprecate < ::Minitest::Test
+  # This test should not be parallelized because it tests the result
+  # of a single class-level attribute.
+  def test_callback
+    values = []
+
+    Timezone::Deprecate.callback = lambda do |klass, method, message|
+      values = [klass, method, message]
+    end
+
+    Timezone::Deprecate.call(self, :test_message, 'foo')
+
+    assert_equal [self, :test_message, 'foo'], values
+  ensure
+    Timezone::Deprecate.callback = nil
+  end
+end

data/test/timezone/test_loader.rb

@@ -0,0 +1,32 @@
+require 'timezone/loader'
+require 'minitest/autorun'
+
+module Timezone
+  class TestLoader < ::Minitest::Test
+    parallelize_me!
+
+    def test_load
+      assert_equal(
+        [[1_435_708_800, 'GMT', false, 0]],
+        Loader.load('GMT')
+      )
+
+      assert_raises ::Timezone::Error::InvalidZone do
+        Loader.load('foo/bar')
+      end
+    end
+
+    def test_names
+      assert Loader.names.include?('GMT')
+      assert Loader.names.include?('Europe/Paris')
+      refute Loader.names.include?('foo/bar')
+    end
+
+    def test_valid?
+      assert Loader.valid?('America/Los_Angeles')
+      assert Loader.valid?('Europe/Paris')
+      refute Loader.valid?('foo/bar')
+      refute Loader.valid?(nil)
+    end
+  end
+end

data/test/timezone/test_lookup.rb

@@ -0,0 +1,53 @@
+require 'timezone/lookup'
+require 'minitest/autorun'
+
+class TestLookup < ::Minitest::Test
+  def test_test_config
+    Timezone::Lookup.config(:test)
+
+    assert_equal Timezone::Lookup::Test,
+      Timezone::Lookup.lookup.class
+  end
+
+  def test_geonames_config
+    Timezone::Lookup.config(:geonames) do |c|
+      c.username = 'foo'
+    end
+
+    assert_equal Timezone::Lookup::Geonames,
+      Timezone::Lookup.lookup.class
+
+    assert_equal Timezone::NetHTTPClient,
+      Timezone::Lookup.lookup.config.request_handler
+  end
+
+  def test_google_config
+    Timezone::Lookup.config(:google) do |c|
+      c.api_key = 'foo'
+    end
+
+    assert_equal Timezone::Lookup::Google,
+      Timezone::Lookup.lookup.class
+
+    assert_equal Timezone::NetHTTPClient,
+      Timezone::Lookup.lookup.config.request_handler
+  end
+
+  def test_custom_config
+    custom_lookup = Class.new do
+      def initialize(config); end
+    end
+
+    Timezone::Lookup.config(custom_lookup)
+
+    assert_equal custom_lookup, Timezone::Lookup.lookup.class
+  end
+
+  def test_missing_config
+    Timezone::Lookup.instance_variable_set(:@lookup, nil)
+
+    assert_raises Timezone::Error::InvalidConfig do
+      Timezone::Lookup.lookup
+    end
+  end
+end

data/test/timezone/test_nil_zone.rb

@@ -0,0 +1,26 @@
+require 'timezone/nil_zone'
+require 'minitest/autorun'
+
+class TestNilZone < ::Minitest::Test
+  parallelize_me!
+
+  def setup
+    @zone = Timezone::NilZone.new
+  end
+
+  def test_name
+    assert_equal nil, @zone.name
+  end
+
+  def test_to_s
+    assert_equal 'NilZone', @zone.to_s
+  end
+
+  def test_inspect
+    assert '#<Timezone::NilZone>', @zone.inspect
+  end
+
+  def test_valid?
+    refute @zone.valid?
+  end
+end

data/test/timezone/test_zone.rb

@@ -0,0 +1,49 @@
+require 'timezone/zone'
+require 'minitest/autorun'
+
+class TestZone < ::Minitest::Test
+  parallelize_me!
+
+  def la
+    @la ||= Timezone::Zone.new('America/Los_Angeles')
+  end
+
+  def paris
+    @paris ||= Timezone::Zone.new('Europe/Paris')
+  end
+
+  def test_name
+    assert_equal 'America/Los_Angeles', la.name
+    assert_equal 'Europe/Paris', paris.name
+  end
+
+  def test_valid?
+    assert la.valid?
+    assert paris.valid?
+  end
+
+  def test_to_s
+    assert_equal 'America/Los_Angeles', la.to_s
+    assert_equal 'Europe/Paris', paris.to_s
+  end
+
+  def test_inspect
+    assert_equal(
+      '#<Timezone::Zone name: "America/Los_Angeles">',
+      la.inspect
+    )
+
+    assert_equal(
+      '#<Timezone::Zone name: "Europe/Paris">',
+      paris.inspect
+    )
+  end
+
+  def test_comparable
+    assert paris > la
+    assert la < paris
+    assert la == Timezone::Zone.new('America/Los_Angeles')
+
+    assert_equal nil, paris <=> 8
+  end
+end