maxmind-geoip2 0.1.0

data/test/data/tidyall.ini

@@ -0,0 +1,5 @@
+[PerlTidy]
+select = **/*.{pl,pm,t}
+
+[JSON]
+select = **/*.json

data/test/test_model_country.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'maxmind/geoip2'
+require 'minitest/autorun'
+
+class CountryModelTest < Minitest::Test
+  RAW = {
+    'continent' => {
+      'code' => 'NA',
+      'geoname_id' => 42,
+      'names' => { 'en' => 'North America' },
+    },
+    'country' => {
+      'geoname_id' => 1,
+      'iso_code' => 'US',
+      'names' => { 'en' => 'United States of America' },
+    },
+    'registered_country' => {
+      'geoname_id' => 2,
+      'is_in_european_union' => true,
+      'iso_code' => 'DE',
+      'names' => { 'en' => 'Germany' },
+    },
+    'traits' => {
+      'ip_address' => '1.2.3.4',
+      'prefix_length' => 24,
+    },
+  }.freeze
+
+  def test_objects
+    model = MaxMind::GeoIP2::Model::Country.new(RAW, ['en'])
+    assert_equal(MaxMind::GeoIP2::Model::Country, model.class)
+    assert_equal(MaxMind::GeoIP2::Record::Continent, model.continent.class)
+    assert_equal(MaxMind::GeoIP2::Record::Country, model.country.class)
+    assert_equal(
+      MaxMind::GeoIP2::Record::Country,
+      model.registered_country.class,
+    )
+    assert_equal(
+      MaxMind::GeoIP2::Record::RepresentedCountry,
+      model.represented_country.class,
+    )
+    assert_equal(
+      MaxMind::GeoIP2::Record::Traits,
+      model.traits.class,
+    )
+  end
+
+  def test_values
+    model = MaxMind::GeoIP2::Model::Country.new(RAW, ['en'])
+
+    assert_equal(42, model.continent.geoname_id)
+    assert_equal('NA', model.continent.code)
+    assert_equal({ 'en' => 'North America' }, model.continent.names)
+    assert_equal('North America', model.continent.name)
+
+    assert_equal(1, model.country.geoname_id)
+    assert_equal(false, model.country.in_european_union?)
+    assert_equal('US', model.country.iso_code)
+    assert_equal({ 'en' => 'United States of America' }, model.country.names)
+    assert_equal('United States of America', model.country.name)
+    assert_nil(model.country.confidence)
+
+    assert_equal(2, model.registered_country.geoname_id)
+    assert_equal(true, model.registered_country.in_european_union?)
+    assert_equal('DE', model.registered_country.iso_code)
+    assert_equal({ 'en' => 'Germany' }, model.registered_country.names)
+    assert_equal('Germany', model.registered_country.name)
+  end
+
+  def test_unknown_record
+    model = MaxMind::GeoIP2::Model::Country.new(RAW, ['en'])
+    assert_raises(NoMethodError) { model.unknown_record }
+  end
+
+  def test_unknown_trait
+    model = MaxMind::GeoIP2::Model::Country.new(RAW, ['en'])
+    assert_raises(NoMethodError) { model.traits.unknown }
+  end
+end

data/test/test_model_names.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'maxmind/geoip2'
+require 'minitest/autorun'
+
+class ModelNameTest < Minitest::Test
+  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,459 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+require 'maxmind/geoip2'
+require 'minitest/autorun'
+
+class ReaderTest < Minitest::Test
+  def test_anonymous_ip
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Anonymous-IP-Test.mmdb',
+    )
+    ip = '1.2.0.1'
+    record = reader.anonymous_ip(ip)
+
+    assert_equal(true, record.anonymous?)
+    assert_equal(true, record.anonymous_vpn?)
+    assert_equal(false, record.hosting_provider?)
+    assert_equal(false, record.public_proxy?)
+    assert_equal(false, record.tor_exit_node?)
+    assert_equal(ip, record.ip_address)
+    assert_equal('1.2.0.0/16', record.network)
+
+    reader.close
+  end
+
+  def test_asn
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoLite2-ASN-Test.mmdb',
+    )
+    ip = '1.128.0.1'
+    record = reader.asn(ip)
+
+    assert_equal(1221, record.autonomous_system_number)
+    assert_equal('Telstra Pty Ltd', record.autonomous_system_organization)
+    assert_equal(ip, record.ip_address)
+    assert_equal('1.128.0.0/11', record.network)
+
+    reader.close
+  end
+
+  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_connection_type
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Connection-Type-Test.mmdb',
+    )
+    ip = '1.0.1.1'
+    record = reader.connection_type(ip)
+
+    assert_equal('Cable/DSL', record.connection_type)
+    assert_equal(ip, record.ip_address)
+    assert_equal('1.0.1.0/24', record.network)
+
+    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_domain
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-Domain-Test.mmdb',
+    )
+    ip = '1.2.0.1'
+    record = reader.domain(ip)
+
+    assert_equal('maxmind.com', record.domain)
+    assert_equal(ip, record.ip_address)
+    assert_equal('1.2.0.0/16', record.network)
+
+    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_isp
+    reader = MaxMind::GeoIP2::Reader.new(
+      'test/data/test-data/GeoIP2-ISP-Test.mmdb',
+    )
+    ip = '1.128.1.1'
+    record = reader.isp(ip)
+
+    assert_equal(1221, record.autonomous_system_number)
+    assert_equal('Telstra Pty Ltd', record.autonomous_system_organization)
+    assert_equal('Telstra Internet', record.isp)
+    assert_equal('Telstra Internet', record.organization)
+    assert_equal(ip, record.ip_address)
+    assert_equal('1.128.0.0/11', record.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