maxmind-geoip2 0.1.0 → 0.2.0

data/lib/maxmind/geoip2/errors.rb

@@ -1,7 +1,48 @@
 # frozen_string_literal: true
 
-module MaxMind::GeoIP2
-  # An AddressNotFoundError means the IP address was not found in the database.
-  class AddressNotFoundError < RuntimeError
+# Disable this because I wish to ensure the MaxMind constant is defined,
+# which apparently must be done without using the compact syntax.
+#
+# rubocop:disable Style/ClassAndModuleChildren
+
+# A module for namespacing purposes.
+module MaxMind
+  module GeoIP2
+    # An AddressNotFoundError means the IP address was not found in the
+    # database or the web service said the IP address was not found.
+    class AddressNotFoundError < RuntimeError
+    end
+
+    # An HTTPError means there was an unexpected HTTP status or response.
+    class HTTPError < RuntimeError
+    end
+
+    # An AddressInvalidError means the IP address was invalid.
+    class AddressInvalidError < RuntimeError
+    end
+
+    # An AddressReservedError means the IP address is reserved.
+    class AddressReservedError < RuntimeError
+    end
+
+    # An AuthenticationError means there was a problem authenticating to the
+    # web service.
+    class AuthenticationError < RuntimeError
+    end
+
+    # An InsufficientFundsError means the account is out of credits.
+    class InsufficientFundsError < RuntimeError
+    end
+
+    # A PermissionRequiredError means the account does not have permission to
+    # use the requested service.
+    class PermissionRequiredError < RuntimeError
+    end
+
+    # An InvalidRequestError means the web service returned an error and there
+    # is no more specific error class.
+    class InvalidRequestError < RuntimeError
+    end
   end
 end
+# rubocop:enable Style/ClassAndModuleChildren

data/lib/maxmind/geoip2/model/anonymous_ip.rb

@@ -15,7 +15,7 @@ module MaxMind::GeoIP2::Model
     # This is true if the IP address is registered to an anonymous VPN
     # provider. If a VPN provider does not register subnets under names
     # associated with them, we will likely only flag their IP ranges using the
-    # is_hosting_provider attribute.
+    # hosting_provider? method.
     #
     # @return [Boolean]
     def anonymous_vpn?
@@ -23,7 +23,7 @@ module MaxMind::GeoIP2::Model
     end
 
     # This is true if the IP address belongs to a hosting or VPN provider (see
-    # description of the is_anonymous_vpn attribute).
+    # description of the anonymous_vpn? method).
     #
     # @return [Boolean]
     def hosting_provider?

data/lib/maxmind/geoip2/model/country.rb

@@ -2,6 +2,7 @@
 
 require 'maxmind/geoip2/record/continent'
 require 'maxmind/geoip2/record/country'
+require 'maxmind/geoip2/record/maxmind'
 require 'maxmind/geoip2/record/represented_country'
 require 'maxmind/geoip2/record/traits'
 
@@ -20,6 +21,11 @@ module MaxMind::GeoIP2::Model
     # @return [MaxMind::GeoIP2::Record::Country]
     attr_reader :country
 
+    # Data related to your MaxMind account.
+    #
+    # @return [MaxMind::GeoIP2::Record::MaxMind]
+    attr_reader :maxmind
+
     # Registered country data for the IP address. This record represents the
     # country where the ISP has registered a given IP block and may differ from
     # the user's country.
@@ -49,6 +55,7 @@ module MaxMind::GeoIP2::Model
         record['country'],
         locales,
       )
+      @maxmind = MaxMind::GeoIP2::Record::MaxMind.new(record['maxmind'])
       @registered_country = MaxMind::GeoIP2::Record::Country.new(
         record['registered_country'],
         locales,

data/lib/maxmind/geoip2/model/insights.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'maxmind/geoip2/model/city'
+
+module MaxMind::GeoIP2::Model
+  # Model class for the data returned by the GeoIP2 Precision Insights web
+  # service.
+  #
+  # The only difference between the City and Insights model classes is which
+  # fields in each record may be populated. See
+  # https://dev.maxmind.com/geoip/geoip2/web-services for more details.
+  class Insights < City
+  end
+end

data/lib/maxmind/geoip2/record/maxmind.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'maxmind/geoip2/record/abstract'
+
+module MaxMind::GeoIP2::Record
+  # Contains data about your account.
+  #
+  # This record is returned by all location services.
+  class MaxMind < Abstract
+    # The number of remaining queries you have for the service you are calling.
+    #
+    # @return [Integer, nil]
+    def queries_remaining
+      get('queries_remaining')
+    end
+  end
+end

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.2.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'
@@ -20,5 +20,6 @@ Gem::Specification.new do |s|
   }
   s.required_ruby_version = '>= 2.4.0'
 
+  s.add_runtime_dependency 'http', ['~> 4.3']
   s.add_runtime_dependency 'maxmind-db', ['~> 1.1']
 end

data/test/test_client.rb

@@ -0,0 +1,424 @@
+# 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',
+      '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('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