maxmind-geoip2 0.1.0 → 0.6.0

data/maxmind-geoip2.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |s|
   s.files       = Dir['**/*']
   s.name        = 'maxmind-geoip2'
   s.summary     = 'A gem for interacting with the GeoIP2 webservices and databases.'
-  s.version     = '0.1.0'
+  s.version     = '0.6.0'
 
   s.description = 'A gem for interacting with the GeoIP2 webservices and databases. MaxMind provides geolocation data as downloadable databases as well as through a webservice.'
   s.email = 'support@maxmind.com'
@@ -13,12 +13,20 @@ Gem::Specification.new do |s|
   s.licenses    = ['Apache-2.0', 'MIT']
   s.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',
+    'changelog_uri' => 'https://github.com/maxmind/GeoIP2-ruby/blob/main/CHANGELOG.md',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/maxmind-geoip2',
     'homepage_uri' => 'https://github.com/maxmind/GeoIP2-ruby',
     'source_code_uri' => 'https://github.com/maxmind/GeoIP2-ruby',
   }
   s.required_ruby_version = '>= 2.4.0'
 
+  s.add_runtime_dependency 'connection_pool', ['~> 2.2']
+  s.add_runtime_dependency 'http', ['~> 4.3']
   s.add_runtime_dependency 'maxmind-db', ['~> 1.1']
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop-performance'
+  s.add_development_dependency 'webmock'
 end

data/test/data/source-data/GeoIP2-Anonymous-IP-Test.json

@@ -18,6 +18,7 @@
          "is_anonymous_vpn" : true,
          "is_hosting_provider" : true,
          "is_public_proxy" : true,
+         "is_residential_proxy" : true,
          "is_tor_exit_node" : true
       }
    },

data/test/data/source-data/GeoIP2-ISP-Test.json

@@ -12587,7 +12587,9 @@
    {
       "2c0f:ff80::/25" : {
          "autonomous_system_number" : 237,
-         "autonomous_system_organization" : "Merit Network Inc."
+         "autonomous_system_organization" : "Merit Network Inc.",
+         "isp" : "Merit Network Inc.",
+         "organization" : "Merit Network Inc."
       }
    }
 ]

data/test/data/source-data/GeoIP2-Precision-Enterprise-Test.json

@@ -2057,5 +2057,92 @@
             "user_type" : "government"
          }
       }
+   },
+   {
+      "::2.20.32.110/127" : {
+         "city" : {
+            "confidence" : 60,
+            "geoname_id" : 315808,
+            "names" : {
+               "de" : "Elazığ",
+               "en" : "Elâzığ",
+               "fr" : "Elazığ",
+               "ja" : "エラズー",
+               "ru" : "Элязыг",
+               "zh-CN" : "埃拉泽"
+            }
+         },
+         "continent" : {
+            "code" : "AS",
+            "geoname_id" : 6255147,
+            "names" : {
+               "de" : "Asien",
+               "en" : "Asia",
+               "es" : "Asia",
+               "fr" : "Asie",
+               "ja" : "アジア",
+               "pt-BR" : "Ásia",
+               "ru" : "Азия",
+               "zh-CN" : "亚洲"
+            }
+         },
+         "country" : {
+            "confidence" : 90,
+            "geoname_id" : 298795,
+            "iso_code" : "TR",
+            "names" : {
+               "de" : "Türkei",
+               "en" : "Turkey",
+               "es" : "Turquía",
+               "fr" : "Turquie",
+               "ja" : "トルコ共和国",
+               "pt-BR" : "Turquia",
+               "ru" : "Турция",
+               "zh-CN" : "土耳其"
+            }
+         },
+         "location" : {
+            "accuracy_radius" : 50,
+            "latitude" : 38.6229,
+            "longitude" : 39.3217,
+            "time_zone" : "Europe/Istanbul"
+         },
+         "postal" : {
+            "code" : "23100",
+            "confidence" : 30
+         },
+         "registered_country" : {
+            "geoname_id" : 298795,
+            "iso_code" : "TR",
+            "names" : {
+               "de" : "Türkei",
+               "en" : "Turkey",
+               "es" : "Turquía",
+               "fr" : "Turquie",
+               "ja" : "トルコ共和国",
+               "pt-BR" : "Turquia",
+               "ru" : "Турция",
+               "zh-CN" : "土耳其"
+            }
+         },
+         "subdivisions" : [
+            {
+               "confidence" : 60,
+               "geoname_id" : 315807,
+               "iso_code" : "23",
+               "names" : {
+                  "en" : "Elazığ"
+               }
+            }
+         ],
+         "traits" : {
+            "autonomous_system_number" : 8517,
+            "autonomous_system_organization" : "National Academic Network and Information Center",
+            "connection_type" : "Cable/DSL",
+            "isp" : "National Academic Network and Information Center",
+            "organization" : "National Academic Network and Information Center",
+            "user_type" : "business"
+         }
+      }
    }
 ]

data/test/data/test-data/write-test-data.pl

@@ -19,7 +19,7 @@ use Test::MaxMind::DB::Common::Util qw( standard_test_metadata );
 my $Dir = dirname( abs_path($0) );
 
 sub main {
-    my @sizes      = ( 24,        28, 32 );
+    my @sizes = ( 24, 28, 32 );
     my @ipv4_range = ( '1.1.1.1', '1.1.1.32' );
 
     my @ipv4_subnets = Net::Works::Network->range_as_subnets(@ipv4_range);
@@ -71,6 +71,7 @@ sub main {
     }
 
     write_decoder_test_db();
+    write_pointer_decoder_test_db();
     write_deeply_nested_structures_db();
 
     write_geoip2_dbs();
@@ -231,23 +232,7 @@ sub write_test_db {
     );
 
     sub write_decoder_test_db {
-        my $writer = MaxMind::DB::Writer::Tree->new(
-            ip_version    => 6,
-            record_size   => 24,
-            database_type => 'MaxMind DB Decoder Test',
-            languages     => ['en'],
-            description   => {
-                en =>
-                    'MaxMind DB Decoder Test database - contains every MaxMind DB data type',
-            },
-            alias_ipv6_to_ipv4       => 1,
-            remove_reserved_networks => 0,
-            map_key_type_callback    => sub {
-                my $key = $_[0];
-                $key =~ s/X$//;
-                return $key eq 'array' ? [ 'array', 'uint32' ] : $key;
-            },
-        );
+        my $writer = _decoder_writer();
 
         my @subnets
             = map { Net::Works::Network->new_from_string( string => $_ ) }
@@ -285,6 +270,70 @@ sub write_test_db {
 
         return;
     }
+
+    sub write_pointer_decoder_test_db {
+
+        # We want to create a database where most values are pointers
+        no warnings 'redefine';
+        local *MaxMind::DB::Writer::Serializer::_should_cache_value
+            = sub { 1 };
+        my $writer = _decoder_writer();
+
+        # We add these slightly different records so that we end up with
+        # pointers for the individual values in the maps, not just pointers
+        # to the map
+        $writer->insert_network(
+            '1.0.0.0/32',
+            {
+                %all_types,
+                booleanX => 0,
+                arrayX   => [ 1, 2, 3, 4, ],
+                mapXX    => {
+                    utf8_stringX => 'hello',
+                    arrayX       => [ 7, 8, 9, 10 ],
+                    booleanX     => 0,
+                },
+            },
+        );
+
+        $writer->insert_network(
+            '1.1.1.0/32',
+            {
+                %all_types,
+
+                # This has to be 0 rather than 1 as otherwise the buggy
+                # Perl writer will think it is the same as an uint32 value of
+                # 1 and make a pointer to a value of a different type.
+                boolean => 0,
+            },
+        );
+
+        open my $fh, '>', "$Dir/MaxMind-DB-test-pointer-decoder.mmdb";
+        $writer->write_tree($fh);
+        close $fh;
+
+        return;
+    }
+
+    sub _decoder_writer {
+        return MaxMind::DB::Writer::Tree->new(
+            ip_version    => 6,
+            record_size   => 24,
+            database_type => 'MaxMind DB Decoder Test',
+            languages     => ['en'],
+            description   => {
+                en =>
+                    'MaxMind DB Decoder Test database - contains every MaxMind DB data type',
+            },
+            alias_ipv6_to_ipv4       => 1,
+            remove_reserved_networks => 0,
+            map_key_type_callback    => sub {
+                my $key = $_[0];
+                $key =~ s/X*$//;
+                return $key eq 'array' ? [ 'array', 'uint32' ] : $key;
+            },
+        );
+    }
 }
 
 {
@@ -427,6 +476,7 @@ sub _universal_map_key_type_callback {
         is_in_european_union           => 'boolean',
         is_legitimate_proxy            => 'boolean',
         is_public_proxy                => 'boolean',
+        is_residential_proxy           => 'boolean',
         is_satellite_provider          => 'boolean',
         is_tor_exit_node               => 'boolean',
         iso_code                       => 'utf8_string',

data/test/test_client.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'maxmind/geoip2'
+require 'minitest/autorun'
+require 'webmock/minitest'
+
+class ClientTest < Minitest::Test
+  COUNTRY = {
+    'continent' => {
+      'code' => 'NA',
+      'geoname_id' => 42,
+      'names' => { 'en' => 'North America' },
+    },
+    'country' => {
+      'geoname_id' => 1,
+      'iso_code' => 'US',
+      'names' => { 'en' => 'United States of America' },
+    },
+    'maxmind' => {
+      'queries_remaining' => 11,
+    },
+    'traits' => {
+      'ip_address' => '1.2.3.4',
+      'network' => '1.2.3.0/24',
+    },
+  }.freeze
+
+  INSIGHTS = {
+    'continent' => {
+      'code' => 'NA',
+      'geoname_id' => 42,
+      'names' => { 'en' => 'North America' },
+    },
+    'country' => {
+      'geoname_id' => 1,
+      'iso_code' => 'US',
+      'names' => { 'en' => 'United States of America' },
+    },
+    'maxmind' => {
+      'queries_remaining' => 11,
+    },
+    'traits' => {
+      'ip_address' => '1.2.3.40',
+      'is_residential_proxy' => true,
+      'network' => '1.2.3.0/24',
+      'static_ip_score' => 1.3,
+      'user_count' => 2,
+    },
+  }.freeze
+
+  CONTENT_TYPES = {
+    country: 'application/vnd.maxmind.com-country+json; charset=UTF-8; version=2.1',
+  }.freeze
+
+  def test_country
+    record = request(:country, '1.2.3.4')
+
+    assert_instance_of(MaxMind::GeoIP2::Model::Country, record)
+
+    assert_equal(42, record.continent.geoname_id)
+    assert_equal('NA', record.continent.code)
+    assert_equal({ 'en' => 'North America' }, record.continent.names)
+    assert_equal('North America', record.continent.name)
+
+    assert_equal(1, record.country.geoname_id)
+    assert_equal(false, record.country.in_european_union?)
+    assert_equal('US', record.country.iso_code)
+    assert_equal({ 'en' => 'United States of America' }, record.country.names)
+    assert_equal('United States of America', record.country.name)
+
+    assert_equal(11, record.maxmind.queries_remaining)
+
+    assert_equal(false, record.registered_country.in_european_union?)
+
+    assert_equal('1.2.3.0/24', record.traits.network)
+  end
+
+  def test_insights
+    record = request(:insights, '1.2.3.40')
+
+    assert_instance_of(MaxMind::GeoIP2::Model::Insights, record)
+
+    assert_equal(42, record.continent.geoname_id)
+
+    assert_equal(true, record.traits.residential_proxy?)
+    assert_equal('1.2.3.0/24', record.traits.network)
+    assert_equal(1.3, record.traits.static_ip_score)
+    assert_equal(2, record.traits.user_count)
+  end
+
+  def test_city
+    record = request(:city, '1.2.3.4')
+
+    assert_instance_of(MaxMind::GeoIP2::Model::City, record)
+
+    assert_equal('1.2.3.0/24', record.traits.network)
+  end
+
+  def test_me
+    record = request(:city, 'me')
+
+    assert_instance_of(MaxMind::GeoIP2::Model::City, record)
+  end
+
+  def test_no_body_error
+    assert_raises(
+      JSON::ParserError,
+    ) { request(:country, '1.2.3.5') }
+  end
+
+  def test_bad_body_error
+    assert_raises(
+      JSON::ParserError,
+    ) { request(:country, '2.2.3.5') }
+  end
+
+  def test_non_json_success_response
+    error = assert_raises(
+      MaxMind::GeoIP2::HTTPError,
+    ) { request(:country, '3.2.3.5') }
+
+    assert_equal(
+      'Received a success response for country but it is not JSON: extra bad body',
+      error.message,
+    )
+  end
+
+  def test_invalid_ip_error
+    error = assert_raises(
+      MaxMind::GeoIP2::AddressInvalidError,
+    ) { request(:country, '1.2.3.6') }
+
+    assert_equal(
+      'The value "1.2.3" is not a valid IP address',
+      error.message,
+    )
+  end
+
+  def test_no_error_body_ip_error
+    assert_raises(
+      JSON::ParserError,
+    ) { request(:country, '1.2.3.7') }
+  end
+
+  def test_missing_key_ip_error
+    error = assert_raises(
+      MaxMind::GeoIP2::HTTPError,
+    ) { request(:country, '1.2.3.71') }
+
+    assert_equal(
+      'Received client error response (400) that is JSON but does not specify code or error keys: {"code":"HI"}',
+      error.message,
+    )
+  end
+
+  def test_weird_error_body_ip_error
+    error = assert_raises(
+      MaxMind::GeoIP2::HTTPError,
+    ) { request(:country, '1.2.3.8') }
+
+    assert_equal(
+      'Received client error response (400) that is JSON but does not specify code or error keys: {"weird":42}',
+      error.message,
+    )
+  end
+
+  def test_500_error
+    error = assert_raises(
+      MaxMind::GeoIP2::HTTPError,
+    ) { request(:country, '1.2.3.10') }
+
+    assert_equal(
+      'Received server error response (500) for country with body foo',
+      error.message,
+    )
+  end
+
+  def test_300_response
+    error = assert_raises(
+      MaxMind::GeoIP2::HTTPError,
+    ) { request(:country, '1.2.3.11') }
+
+    assert_equal(
+      'Received unexpected response (300) for country with body bar',
+      error.message,
+    )
+  end
+
+  def test_406_error
+    error = assert_raises(
+      MaxMind::GeoIP2::HTTPError,
+    ) { request(:country, '1.2.3.12') }
+
+    assert_equal(
+      'Received client error response (406) for country but it is not JSON: Cannot satisfy your Accept-Charset requirements',
+      error.message,
+    )
+  end
+
+  def test_address_not_found_error
+    error = assert_raises(
+      MaxMind::GeoIP2::AddressNotFoundError,
+    ) { request(:country, '1.2.3.13') }
+
+    assert_equal(
+      'The address "1.2.3.13" is not in our database.',
+      error.message,
+    )
+  end
+
+  def test_address_reserved_error
+    error = assert_raises(
+      MaxMind::GeoIP2::AddressReservedError,
+    ) { request(:country, '1.2.3.14') }
+
+    assert_equal(
+      'The address "1.2.3.14" is a private address.',
+      error.message,
+    )
+  end
+
+  def test_authorization_error
+    error = assert_raises(
+      MaxMind::GeoIP2::AuthenticationError,
+    ) { request(:country, '1.2.3.15') }
+
+    assert_equal(
+      'An account ID and license key are required to use this service.',
+      error.message,
+    )
+  end
+
+  def test_missing_license_key_error
+    error = assert_raises(
+      MaxMind::GeoIP2::AuthenticationError,
+    ) { request(:country, '1.2.3.16') }
+
+    assert_equal(
+      'A license key is required to use this service.',
+      error.message,
+    )
+  end
+
+  def test_missing_account_id_error
+    error = assert_raises(
+      MaxMind::GeoIP2::AuthenticationError,
+    ) { request(:country, '1.2.3.17') }
+
+    assert_equal(
+      'An account ID is required to use this service.',
+      error.message,
+    )
+  end
+
+  def test_insufficient_funds_error
+    error = assert_raises(
+      MaxMind::GeoIP2::InsufficientFundsError,
+    ) { request(:country, '1.2.3.18') }
+
+    assert_equal(
+      'The license key you have provided is out of queries.',
+      error.message,
+    )
+  end
+
+  def test_unexpected_code_error
+    error = assert_raises(
+      MaxMind::GeoIP2::InvalidRequestError,
+    ) { request(:country, '1.2.3.19') }
+
+    assert_equal(
+      'Whoa!',
+      error.message,
+    )
+  end
+
+  def request(method, ip_address)
+    response = get_response(ip_address)
+
+    stub_request(:get, /geoip/)
+      .to_return(
+        body: response[:body],
+        headers: response[:headers],
+        status: response[:status],
+      )
+
+    client = MaxMind::GeoIP2::Client.new(
+      account_id: 42,
+      license_key: 'abcdef123456',
+    )
+
+    client.send(method, '1.2.3.4')
+  end
+
+  def get_response(ip_address)
+    responses = {
+      'me' => {
+        body: JSON.generate(COUNTRY),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 200,
+      },
+      '1.2.3.4' => {
+        body: JSON.generate(COUNTRY),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 200,
+      },
+      '1.2.3.5' => {
+        body: '',
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 200,
+      },
+      '2.2.3.5' => {
+        body: 'bad body',
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 200,
+      },
+      '3.2.3.5' => {
+        body: 'extra bad body',
+        headers: {},
+        status: 200,
+      },
+      '1.2.3.40' => {
+        body: JSON.generate(INSIGHTS),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 200,
+      },
+      '1.2.3.6' => {
+        body: JSON.generate({
+                              'code' => 'IP_ADDRESS_INVALID',
+                              'error' => 'The value "1.2.3" is not a valid IP address',
+                            }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 400,
+      },
+      '1.2.3.7' => {
+        body: '',
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 400,
+      },
+      '1.2.3.71' => {
+        body: JSON.generate({ code: 'HI' }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 400,
+      },
+      '1.2.3.8' => {
+        body: JSON.generate({ weird: 42 }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 400,
+      },
+      '1.2.3.10' => {
+        body: 'foo',
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 500,
+      },
+      '1.2.3.11' => {
+        body: 'bar',
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 300,
+      },
+      '1.2.3.12' => {
+        body: 'Cannot satisfy your Accept-Charset requirements',
+        headers: {},
+        status: 406,
+      },
+      '1.2.3.13' => {
+        body: JSON.generate({
+                              'code' => 'IP_ADDRESS_NOT_FOUND',
+                              'error' => 'The address "1.2.3.13" is not in our database.',
+                            }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 400,
+      },
+      '1.2.3.14' => {
+        body: JSON.generate({
+                              'code' => 'IP_ADDRESS_RESERVED',
+                              'error' => 'The address "1.2.3.14" is a private address.',
+                            }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 400,
+      },
+      '1.2.3.15' => {
+        body: JSON.generate({
+                              'code' => 'AUTHORIZATION_INVALID',
+                              'error' => 'An account ID and license key are required to use this service.',
+                            }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 401,
+      },
+      '1.2.3.16' => {
+        body: JSON.generate({
+                              'code' => 'LICENSE_KEY_REQUIRED',
+                              'error' => 'A license key is required to use this service.',
+                            }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 401,
+      },
+      '1.2.3.17' => {
+        body: JSON.generate({
+                              'code' => 'ACCOUNT_ID_REQUIRED',
+                              'error' => 'An account ID is required to use this service.',
+                            }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 401,
+      },
+      '1.2.3.18' => {
+        body: JSON.generate({
+                              'code' => 'INSUFFICIENT_FUNDS',
+                              'error' => 'The license key you have provided is out of queries.',
+                            }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 402,
+      },
+      '1.2.3.19' => {
+        body: JSON.generate({
+                              'code' => 'UNEXPECTED',
+                              'error' => 'Whoa!',
+                            }),
+        headers: { 'Content-Type': CONTENT_TYPES[:country] },
+        status: 400,
+      },
+    }
+
+    responses[ip_address]
+  end
+end