maxmind-geoip2 0.0.1

data/test/test_model_names.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'maxmind/geoip2'
+require 'minitest/autorun'
+
+class ModelNameTest < Minitest::Test # :nodoc:
+  RAW = {
+    'continent' => {
+      'code' => 'NA',
+      'geoname_id' => 42,
+      'names' => {
+        'en' => 'North America',
+        'zh-CN' => '北美洲',
+      },
+    },
+    'country' => {
+      'geoname_id' => 1,
+      'iso_code' => 'US',
+      'names' => {
+        'en' => 'United States of America',
+        'ru' => 'объединяет государства',
+        'zh-CN' => '美国',
+      },
+    },
+    'traits' => {
+      'ip_address' => '1.2.3.4',
+    },
+  }.freeze
+
+  def test_fallback
+    model = MaxMind::GeoIP2::Model::Country.new(RAW, %w[ru zh-CN en])
+    assert_equal('北美洲', model.continent.name)
+    assert_equal('объединяет государства', model.country.name)
+  end
+
+  def test_two_fallbacks
+    model = MaxMind::GeoIP2::Model::Country.new(RAW, %w[ru jp])
+    assert_nil(model.continent.name)
+    assert_equal('объединяет государства', model.country.name)
+  end
+
+  def test_no_fallbacks
+    model = MaxMind::GeoIP2::Model::Country.new(RAW, %w[jp])
+    assert_nil(model.continent.name)
+    assert_nil(model.country.name)
+  end
+end

data/test/test_reader.rb

@@ -0,0 +1,381 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+require 'maxmind/geoip2'
+require 'minitest/autorun'
+
+class ReaderTest < Minitest::Test # :nodoc:
+  def test_city
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-City-Test.mmdb',
+    )
+    record = reader.city('2.125.160.216')
+
+    assert_equal('EU', record.continent.code)
+
+    assert_equal(2_655_045, record.city.geoname_id)
+    assert_equal({ 'en' => 'Boxford' }, record.city.names)
+    assert_equal('Boxford', record.city.name)
+    assert_nil(record.city.confidence)
+
+    assert_equal(100, record.location.accuracy_radius)
+    assert_equal(51.75, record.location.latitude)
+    assert_equal(-1.25, record.location.longitude)
+    assert_equal('Europe/London', record.location.time_zone)
+
+    assert_equal(2, record.subdivisions.size)
+    assert_equal('England', record.subdivisions[0].name)
+    assert_equal('West Berkshire', record.subdivisions[1].name)
+    assert_equal('West Berkshire', record.most_specific_subdivision.name)
+
+    record = reader.city('216.160.83.56')
+
+    assert_equal(819, record.location.metro_code)
+
+    assert_equal('98354', record.postal.code)
+
+    assert_equal(1, record.subdivisions.size)
+    assert_equal(5_815_135, record.subdivisions[0].geoname_id)
+    assert_equal('WA', record.subdivisions[0].iso_code)
+    assert_equal(
+      {
+        'en' => 'Washington',
+        'es' => 'Washington',
+        'fr' => 'État de Washington',
+        'ja' => 'ワシントン州',
+        'ru' => 'Вашингтон',
+        'zh-CN' => '华盛顿州',
+      },
+      record.subdivisions[0].names,
+      assert_equal('WA', record.most_specific_subdivision.iso_code)
+    )
+
+    reader.close
+  end
+
+  def test_city_no_subdivisions
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-City-Test.mmdb',
+    )
+    record = reader.city('2001:218::')
+
+    assert_equal([], record.subdivisions)
+    assert_nil(record.most_specific_subdivision)
+
+    reader.close
+  end
+
+  def test_country
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Country-Test.mmdb',
+    )
+    record = reader.country('2.125.160.216')
+
+    assert_equal('EU', record.continent.code)
+    assert_equal(6_255_148, record.continent.geoname_id)
+    assert_equal(
+      {
+        'de' => 'Europa',
+        'en' => 'Europe',
+        'es' => 'Europa',
+        'fr' => 'Europe',
+        'ja' => 'ヨーロッパ',
+        'pt-BR' => 'Europa',
+        'ru' => 'Европа',
+        'zh-CN' => '欧洲',
+      },
+      record.continent.names,
+    )
+    assert_equal('Europe', record.continent.name)
+
+    assert_equal(2_635_167, record.country.geoname_id)
+    assert_equal(true, record.country.in_european_union?)
+    assert_equal('GB', record.country.iso_code)
+    assert_equal(
+      {
+        'de' => 'Vereinigtes Königreich',
+        'en' => 'United Kingdom',
+        'es' => 'Reino Unido',
+        'fr' => 'Royaume-Uni',
+        'ja' => 'イギリス',
+        'pt-BR' => 'Reino Unido',
+        'ru' => 'Великобритания',
+        'zh-CN' => '英国',
+      },
+      record.country.names,
+    )
+    assert_equal('United Kingdom', record.country.name)
+
+    assert_equal(3_017_382, record.registered_country.geoname_id)
+    assert_equal(true, record.registered_country.in_european_union?)
+    assert_equal('FR', record.registered_country.iso_code)
+    assert_equal(
+      {
+        'de' => 'Frankreich',
+        'en' => 'France',
+        'es' => 'Francia',
+        'fr' => 'France',
+        'ja' => 'フランス共和国',
+        'pt-BR' => 'França',
+        'ru' => 'Франция',
+        'zh-CN' => '法国',
+      },
+      record.registered_country.names,
+    )
+    assert_equal('France', record.registered_country.name)
+
+    record = reader.country('202.196.224.0')
+
+    assert_equal(6_252_001, record.represented_country.geoname_id)
+    assert_equal('US', record.represented_country.iso_code)
+    assert_equal(
+      {
+        'de' => 'USA',
+        'en' => 'United States',
+        'es' => 'Estados Unidos',
+        'fr' => 'États-Unis',
+        'ja' => 'アメリカ合衆国',
+        'pt-BR' => 'Estados Unidos',
+        'ru' => 'США',
+        'zh-CN' => '美国',
+      },
+      record.represented_country.names,
+    )
+    assert_equal('United States', record.represented_country.name)
+    assert_equal('military', record.represented_country.type)
+
+    record = reader.country('81.2.69.163')
+    assert_equal('81.2.69.163', record.traits.ip_address)
+    assert_equal('81.2.69.160/27', record.traits.network)
+
+    assert_raises(NoMethodError) { record.foo }
+    reader.close
+  end
+
+  def test_is_method_returns_false
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Country-Test.mmdb',
+    )
+    record = reader.country('74.209.24.0')
+    assert_equal(false, record.country.in_european_union?)
+
+    reader.close
+  end
+
+  def test_enterprise
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Enterprise-Test.mmdb',
+    )
+    record = reader.enterprise('2.125.160.216')
+
+    assert_equal(50, record.city.confidence)
+    assert_equal(2_655_045, record.city.geoname_id)
+    assert_equal({ 'en' => 'Boxford' }, record.city.names)
+    assert_equal('Boxford', record.city.name)
+
+    ip_address = '74.209.24.0'
+    record = reader.enterprise(ip_address)
+
+    assert_equal(11, record.city.confidence)
+    assert_equal(99, record.country.confidence)
+    assert_equal(6_252_001, record.country.geoname_id)
+    assert_equal(false, record.country.in_european_union?)
+
+    assert_equal(27, record.location.accuracy_radius)
+
+    assert_equal(false, record.registered_country.in_european_union?)
+
+    assert_equal('Cable/DSL', record.traits.connection_type)
+    assert_equal(true, record.traits.legitimate_proxy?)
+
+    assert_equal(ip_address, record.traits.ip_address)
+    assert_equal('74.209.16.0/20', record.traits.network)
+
+    reader.close
+  end
+
+  def test_no_traits
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Enterprise-Test.mmdb',
+    )
+    record = reader.enterprise('2.125.160.216')
+
+    assert_equal('2.125.160.216', record.traits.ip_address)
+    assert_equal('2.125.160.216/29', record.traits.network)
+    assert_nil(record.traits.autonomous_system_number)
+    assert_equal(false, record.traits.anonymous?)
+
+    reader.close
+  end
+
+  def test_no_location
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Enterprise-Test.mmdb',
+    )
+    record = reader.enterprise('212.47.235.81')
+
+    assert_nil(record.location.accuracy_radius)
+
+    reader.close
+  end
+
+  def test_no_postal
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Enterprise-Test.mmdb',
+    )
+    record = reader.enterprise('212.47.235.81')
+
+    assert_nil(record.postal.code)
+
+    reader.close
+  end
+
+  def test_no_city
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Enterprise-Test.mmdb',
+    )
+    record = reader.enterprise('212.47.235.81')
+
+    assert_nil(record.city.confidence)
+    assert_nil(record.city.name)
+    assert_nil(record.city.names)
+
+    reader.close
+  end
+
+  def test_no_continent
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Enterprise-Test.mmdb',
+    )
+    record = reader.enterprise('212.47.235.81')
+
+    assert_nil(record.continent.code)
+
+    reader.close
+  end
+
+  def test_no_country
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Enterprise-Test.mmdb',
+    )
+    record = reader.enterprise('212.47.235.81')
+
+    assert_nil(record.country.confidence)
+
+    reader.close
+  end
+
+  def test_no_represented_country
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Enterprise-Test.mmdb',
+    )
+    record = reader.enterprise('212.47.235.81')
+
+    assert_nil(record.represented_country.type)
+
+    reader.close
+  end
+
+  def database_types
+    [
+      { 'file' => 'City', 'method' => 'city' },
+      { 'file' => 'Country', 'method' => 'country' },
+    ]
+  end
+
+  def test_default_locale
+    database_types.each do |t|
+      reader = MaxMind::GeoIP2::Reader.new(
+        "test/data/test-data/GeoIP2-#{t['file']}-Test.mmdb",
+      )
+      record = reader.send(t['method'], '81.2.69.160')
+      assert_equal('United Kingdom', record.country.name)
+      reader.close
+    end
+  end
+
+  def test_locale_list
+    database_types.each do |t|
+      reader = MaxMind::GeoIP2::Reader.new(
+        "test/data/test-data/GeoIP2-#{t['file']}-Test.mmdb",
+        %w[xx ru pt-BR es en],
+      )
+      record = reader.send(t['method'], '81.2.69.160')
+      assert_equal('Великобритания', record.country.name)
+      reader.close
+    end
+  end
+
+  def test_has_ip_address_and_network
+    database_types.each do |t|
+      reader = MaxMind::GeoIP2::Reader.new(
+        "test/data/test-data/GeoIP2-#{t['file']}-Test.mmdb",
+      )
+      record = reader.send(t['method'], '81.2.69.163')
+      assert_equal('81.2.69.163', record.traits.ip_address)
+      assert_equal('81.2.69.160/27', record.traits.network)
+      reader.close
+    end
+  end
+
+  def test_is_in_european_union
+    database_types.each do |t|
+      reader = MaxMind::GeoIP2::Reader.new(
+        "test/data/test-data/GeoIP2-#{t['file']}-Test.mmdb",
+      )
+      record = reader.send(t['method'], '81.2.69.160')
+      assert_equal(true, record.country.in_european_union?)
+      assert_equal(false, record.registered_country.in_european_union?)
+      reader.close
+    end
+  end
+
+  def test_unknown_address
+    database_types.each do |t|
+      reader = MaxMind::GeoIP2::Reader.new(
+        "test/data/test-data/GeoIP2-#{t['file']}-Test.mmdb",
+      )
+      error = assert_raises(
+        MaxMind::GeoIP2::AddressNotFoundError,
+      ) { reader.send(t['method'], '10.10.10.0') }
+      assert_equal(
+        'The address 10.10.10.0 is not in the database.',
+        error.message,
+      )
+      reader.close
+    end
+  end
+
+  def test_incorrect_database
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-City-Test.mmdb',
+    )
+    error = assert_raises(ArgumentError) { reader.country('10.10.10.10') }
+    assert_equal(
+      'The country method cannot be used with the GeoIP2-City database.',
+      error.message,
+    )
+    reader.close
+  end
+
+  def test_invalid_address
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-City-Test.mmdb',
+    )
+    error = assert_raises(
+      IPAddr::InvalidAddressError,
+    ) { reader.city('invalid') }
+    # Ruby 2.5 says just 'invalid address'. Ruby 2.6+ says 'invalid address:
+    # invalid'.
+    assert_match('invalid address', error.message)
+    reader.close
+  end
+
+  def test_metadata
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-City-Test.mmdb',
+    )
+    assert_equal('GeoIP2-City', reader.metadata.database_type)
+    reader.close
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: maxmind-geoip2
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- William Storey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-09 00:00:00.000000000 Z
+dependencies: []
+description: A gem for interacting with the GeoIP2 webservices and databases. MaxMind
+  provides geolocation data as downloadable databases as well as through a webservice.
+email: support@maxmind.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE-APACHE
+- LICENSE-MIT
+- README.dev.md
+- README.md
+- Rakefile
+- lib/maxmind/geoip2.rb
+- lib/maxmind/geoip2/errors.rb
+- lib/maxmind/geoip2/model/city.rb
+- lib/maxmind/geoip2/model/country.rb
+- lib/maxmind/geoip2/model/enterprise.rb
+- lib/maxmind/geoip2/reader.rb
+- lib/maxmind/geoip2/record/abstract.rb
+- lib/maxmind/geoip2/record/city.rb
+- lib/maxmind/geoip2/record/continent.rb
+- lib/maxmind/geoip2/record/country.rb
+- lib/maxmind/geoip2/record/location.rb
+- lib/maxmind/geoip2/record/place.rb
+- lib/maxmind/geoip2/record/postal.rb
+- lib/maxmind/geoip2/record/represented_country.rb
+- lib/maxmind/geoip2/record/subdivision.rb
+- lib/maxmind/geoip2/record/traits.rb
+- maxmind-geoip2.gemspec
+- test/test_model_country.rb
+- test/test_model_names.rb
+- test/test_reader.rb
+homepage: https://github.com/maxmind/GeoIP2-ruby
+licenses:
+- Apache-2.0
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/maxmind/GeoIP2-ruby/issues
+  changelog_uri: https://github.com/maxmind/GeoIP2-ruby/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/maxmind/GeoIP2-ruby
+  homepage_uri: https://github.com/maxmind/GeoIP2-ruby
+  source_code_uri: https://github.com/maxmind/GeoIP2-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: A gem for interacting with the GeoIP2 webservices and databases.
+test_files: []