Ticket #2823: 2823.diff

1.0/index.php

@@ -147 +147 @@
 
         echo wp_json_encode( $response );
 }
 
 /**
  * Guess the location based on a city inside the given input
  *
  * @param string $location_name
  * @param string $timezone
  * @param string $country_code
  *
  * @return false|object false on failure; an object on success
  */
 function guess_location_from_city( $location_name, $timezone, $country_code ) {
         $guess = guess_location_from_geonames( $location_name, $timezone, $country_code );
-        $location_word_count = str_word_count( $location_name );
-        $location_name_parts = explode( ' ', $location_name );
+        if ( $guess ) {
+                return $guess;
+        }
 
         /*
          * Multi-word queries may contain cities, regions, and countries, so try to extract just the city
          *
          * This won't work for most ideographic languages, because they don't use the space character as a word
-         * delimiter. That's ok, though, because `guess_ideographic_location_from_geonames()` should cover those
-         * cases.
+         * delimiter.
          */
+        $location_name_parts = preg_split( '/\s+/u', $location_name );
+        $location_word_count = count( $location_name_parts );
+
         if ( ! $guess && $location_word_count >= 2 ) {
                 // Catch input like "Portland Maine"
-                $guess = guess_location_from_geonames( $location_name_parts[0], $timezone, $country_code );
+                $guess = guess_location_from_geonames( $location_name_parts[0], $timezone, $country_code, $wildcard = false );
         }
 
         if ( ! $guess && $location_word_count >= 3 ) {
                 // Catch input like "Sao Paulo Brazil"
                 $city_name = sprintf( '%s %s', $location_name_parts[0], $location_name_parts[1] );
-                $guess     = guess_location_from_geonames( $city_name, $timezone, $country_code );
-        }
-
-        // Normalize all errors to boolean false for consistency
-        if ( empty ( $guess ) ) {
-                $guess = false;
+                $guess     = guess_location_from_geonames( $city_name, $timezone, $country_code, $wildcard = false );
         }
 
         return $guess;
 }
 
 /**
  * Look for the given location in the Geonames database
  *
  * @param string $location_name
  * @param string $timezone
  * @param string $country
  *
  * @return stdClass|null
  */
-function guess_location_from_geonames( $location_name, $timezone, $country ) {
+function guess_location_from_geonames( $location_name, $timezone, $country, $wildcard = true ) {
         global $wpdb;
         // Look for a location that matches the name.
         // The FIELD() orderings give preference to rows that match the country and/or timezone, without excluding rows that don't match.
         // And we sort by population desc, assuming that the biggest matching location is the most likely one.
 
-        // Strip all quotes from the search query, and then enclose it in double quotes, to force an exact literal search
-        $quoted_location_name = sprintf(
-                '"%s"',
-                strtr( $location_name, [ '"' => '', "'" => '' ] )
-        );
-
+        // Exact match
         $row = $wpdb->get_row( $wpdb->prepare( "
                 SELECT name, latitude, longitude, country
-                FROM geoname
+                FROM geoname_summary
                 WHERE
-                        MATCH( name, asciiname, alternatenames )
-                        AGAINST( %s IN BOOLEAN MODE )
+                        name = %s
                 ORDER BY
                         FIELD( %s, country  ) DESC,
                         FIELD( %s, timezone ) DESC,
                         population DESC
                 LIMIT 1",
-                $quoted_location_name,
+                $location_name,
                 $country,
                 $timezone
         ) );
 
-        if ( ! is_a( $row, 'stdClass' ) && 'ASCII' !== mb_detect_encoding( $location_name ) ) {
-                $row = guess_location_from_geonames_fallback( $location_name, $country, $timezone, 'exact', 'ideographic' );
-        }
+        // Wildcard match
+        if ( ! $row && $wildcard && 'ASCII' !== mb_detect_encoding( $location_name ) ) {
+                $row = $wpdb->get_row( $wpdb->prepare( "
+                        SELECT name, latitude, longitude, country
+                        FROM geoname_summary
+                        WHERE
+                                name LIKE %s
+                        ORDER BY
+                                FIELD( %s, country  ) DESC,
+                                FIELD( %s, timezone ) DESC,
+                                population DESC
+                        LIMIT 1",
+                        $location_name . '%',
+                        $country,
+                        $timezone
+                ) );
+        }
+
+        // Suffix the "State", good in some countries (western countries) horrible in others (where geonames data is not as complete, or  region names are similar (but not quite the same) to city names)
+        // LEFT JOIN admin1codes ac ON gs.statecode = ac.code
+        // if ( $row->state && $row->state != $row->name && $row->name NOT CONTAINED WITHIN $row->state? ) {
+        //      $row->name .= ', ' . $row->state;
+        // }
 
         return $row;
 }
 
 /**
- * Look for the given location in the Geonames database using a LIKE query
- *
- * This is a fallback for situations where the full-text search in `guess_location_from_geonames()` resulted
- * in a false-negative.
- *
- * One situation where this happens is with queries in ideographic languages, because MySQL < 5.7.6 doesn't
- * support full-text searches for them, because it can't determine where the word boundaries are.
- * See https://dev.mysql.com/doc/refman/5.7/en/fulltext-restrictions.html
- *
- * There are also edge cases where the exact query doesn't exist in the database, but a loose LIKE query will find
- * a similar alternate, like `Osakashi`.
- *
- * @param string $location_name
- * @param string $country
- * @param string $timezone
- * @param string $mode          'exact' to only return exact matches from the database;
- *                              'loose' to return any match. This has a high chance of false positives.
- * @param string $restrict_counties 'ideographic' to only search in countries where ideographic languages are common;
- *                                  'none' to search all countries
- *
- * @return stdClass|null
- */
-function guess_location_from_geonames_fallback( $location_name, $country, $timezone, $mode = 'exact', $restrict_counties = 'ideographic' ) {
-        global $wpdb;
-
-        $where = $ideographic_countries = $ideographic_country_placeholders = '';
-
-        /*
-         * The name is wrapped in commas in order to ensure that we're only matching the exact location, which is
-         * delimited by commas. Otherwise, there would be false positives in situations where `$location_name`
-         * appears in other rows, which happens sometimes.
-         *
-         * Because this will only match entries that are prefixed _and_ postfixed with a comma, it will never match the
-         * first and last entries in the column. That's ok, though, because the first entry is often an airport code
-         * in English, which is shorter than `ft_min_word_len` anyway. The last entry is often ideographic, so it'd be nice
-         * to match it, but this is good enough for now.
-         */
-        $escaped_location_name = sprintf(
-                'loose' === $mode ? '%%%s%%' : '%%,%s,%%',
-                $wpdb->esc_like( $location_name )
-        );
-
-        $prepare_args = array( $escaped_location_name, $country, $timezone );
-
-        if ( 'ideographic' == $restrict_counties ) {
-                $ideographic_countries            = get_ideographic_counties();
-                $ideographic_country_placeholders = get_prepare_placeholders( count( $ideographic_countries ), '%s' );
-
-                $where .= "country IN ( $ideographic_country_placeholders ) AND";
-
-                $prepare_args = array_merge( $ideographic_countries, $prepare_args );
-        }
-
-        /*
-         * REPLACE() is used because sometimes the `alternatenames` column contains entries where the `asciiname` is
-         * prefixed to an ideographic name; for example: `,Karachi - كراچى,`
-         *
-         * If that prefix is not removed, then the LIKE query will fail in those cases, because
-         * `$escaped_location_name` is wrapped in commas.
-         *
-         * The query is restricted to countries where ideographic languages are common, in order to avoid a full-table
-         * scan.
-         */
-        $query = "
-                SELECT name, latitude, longitude, country
-                FROM `geoname`
-                WHERE
-                        $where
-                        REPLACE( alternatenames, CONCAT( asciiname, ' - ' ), '' ) LIKE %s
-                ORDER BY
-                        FIELD( %s, country  ) DESC,
-                        FIELD( %s, timezone ) DESC,
-                        population DESC
-                LIMIT 1";
-
-        $prepared_query = $wpdb->prepare( $query, $prepare_args );
-
-        return $wpdb->get_row( $prepared_query );
-}
-
-/**
- * Get an array of countries where ideographic languages are common
- *
- * Derived from https://en.wikipedia.org/wiki/List_of_writing_systems#List_of_writing_scripts_by_adoption
- *
- * @todo Some of these individual countries may be able to be removed, to further narrow the rows that need to be
- *       scanned by `guess_ideographic_location_from_geonames()`. Some of the entire categories could possibly be
- *       removed too, but let's err on the side of caution for now.
- */
-function get_ideographic_counties() {
-        $middle_east  = array( 'AE', 'BH', 'CY', 'EG', 'IL', 'IR', 'IQ', 'JO', 'KW', 'LB', 'OM', 'PS', 'QA', 'SA', 'SY', 'TR', 'YE' );
-        $north_africa = array( 'DZ', 'EH', 'EG', 'LY', 'MA', 'SD', 'SS', 'TN' );
-
-        $abjad_countries       = array_merge( $middle_east, $north_africa, array( 'CN', 'IL', 'IN', 'MY', 'PK' ) );
-        $abugida_countries     = array( 'BD', 'BT', 'ER', 'ET', 'ID', 'IN', 'KH', 'LA', 'LK', 'MV', 'MY', 'MU', 'MM', 'NP', 'PK', 'SG', 'TH' );
-        $logographic_countries = array( 'CN', 'JP', 'KR', 'MY', 'SG');
-
-        $all_ideographic_countries = array_merge( $abjad_countries, $abugida_countries, $logographic_countries );
-
-        return array_unique( $all_ideographic_countries );
-}
-
-/**
- * Build a string of placeholders to pass to `WPDB::prepare()`
- *
- * Sometimes it's convenient to be able to generate placeholders for `prepare()` dynamically. For example, when
- * looping through a multi-dimensional array where the sub-arrays have distinct counts; or when the total
- * number of items is too large to conveniently count by hand.
- *
- * See https://iandunn.name/2016/03/31/generating-dynamic-placeholders-for-wpdb-prepare/
- *
- * @param int    $number The number of placeholders needed
- * @param string $format An sprintf()-like format accepted by WPDB::prepare()
- *
- * @return string
- */
-function get_prepare_placeholders( $number, $format ) {
-        return implode( ', ', array_fill( 0, $number, $format ) );
-}
-
-/**
  * Determine a location for the given IPv4 address
  *
  * NOTE: The location that is found here cannot be returned to the client.
  *       See `rebuild_location_from_geonames()`.
  *
  * @todo - Add support for IPv6 addresses. Otherwise, this will quickly lose effectiveness. As of March 2017, IPv6
  *         adoption is at 16% globally and rising relatively fast. Some countries are as high as 30%.
  *         See https://www.google.com/intl/en/ipv6/statistics.html#tab=ipv6-adoption for current stats.
  *
  * @todo - Core sends anonymized IPs like `2a03:2880:2110:df07::`, so make sure those work when implementing IPv6
  *
  * @param string $dotted_ip
  *
  * @return null|object `null` on failure; an object on success
  */
 function guess_location_from_ip( $dotted_ip ) {
         global $wpdb;
 
         $long_ip = ip2long( $dotted_ip );
-        if ( $long_ip === false )
-                return;
+        if ( $long_ip === false ) {
+                return false;
+        }
 
         $row = $wpdb->get_row( $wpdb->prepare( "
                 SELECT ip_city, ip_latitude, ip_longitude, country_short
                 FROM ip2location
                 WHERE ip_to >= %d
                 ORDER BY ip_to ASC
                 LIMIT 1",
                 $long_ip
         ) );
 
         // Unknown location:
         if ( ! $row || '-' == $row->country_short ) {
-                return;
+                return false;
         }
 
         return $row;
 }
 
 /**
  * Rebuild the location given to the client from the event source data
  *
  * We cannot publicly expose location data that we retrieve from the `ip2location` database, because that would
  * violate their licensing terms. We can only use the information internally, for the purposes of completing the
  * program's business logic (determining nearby events).
  *
  * Once we have nearby events, though, we can take advantage of the data that's available in the `wporg_events` table.
  * That table contains the locations details for the event's venue, which was sourced from the respective APIs
  * (WordCamp.org, Meetup.com, etc). We can return the venue's location data without violating any terms.
@@ -447 +339 @@
         if ( isset( $args['country'] ) ) {
                 $location = array(
                         'country' => $args['country'],
                 );
         }
 
         $country_code = get_country_code_from_locale( $args['locale'] ?? '' );
 
         // Coordinates provided
         if (
                 ! $location && (
                         ! empty( $args['latitude'] )  && is_numeric( $args['latitude'] ) &&
                         ! empty( $args['longitude'] ) && is_numeric( $args['longitude'] )
                 )
         ) {
-                $city = get_city_from_coordinates( $args['latitude'], $args['longitude'] );
-
                 $location = array(
-                        'description' => $city ? $city : "{$args['latitude']}, {$args['longitude']}",
+                        'description' => false,
                         'latitude'    => $args['latitude'],
                         'longitude'   => $args['longitude']
                 );
         }
 
         // City was provided by the user:
         if ( ! $location && isset( $args['location_name'] ) ) {
                 $guess = guess_location_from_city( $args['location_name'], $args['timezone'] ?? '', $country_code  );
 
                 if ( $guess ) {
                         $location = array(
                                 'description' => $guess->name,
                                 'latitude' => $guess->latitude,
                                 'longitude' => $guess->longitude,
                                 'country' => $guess->country,
                         );
                 } else {
                         $guess = guess_location_from_country( $args['location_name'] );
 
-                        if ( ! $location && $guess ) {
+                        if ( $guess ) {
                                 $location = array(
                                         'country'     => $guess['country_short'],
                                         'description' => $guess['country_long'],
                                 );
                         }
                 }
         }
 
-        /*
-         * If all else fails, cast a wide net and try to find something before giving up, even
-         * if the chance of success if lower than normal. Returning false is guaranteed failure, so this improves things
-         * even if it only works 10% of the time.
-         *
-         * This must be done as the very last thing before giving up, because the likelihood of false positives is high.
-         */
-        if ( ! $location && isset( $args['location_name'] ) ) {
-                if ( 'ASCII' === mb_detect_encoding( $args['location_name'] ) ) {
-                        $guess = guess_location_from_geonames_fallback( $args['location_name'], $country_code, $args['timezone'] ?? '', 'loose', 'none' );
-                } else {
-                        $guess = guess_location_from_geonames_fallback( $args['location_name'], $country_code, $args['timezone'] ?? '', 'loose', 'ideographic' );
-                }
-
-                if ( $guess ) {
-                        $location = array(
-                                'description' => $guess->name,
-                                'latitude'    => $guess->latitude,
-                                'longitude'   => $guess->longitude,
-                                'country'     => $guess->country,
-                        );
-                }
-        }
-
         if ( ! $location ) {
                 if ( isset( $args['location_name'] ) || isset( $args['ip'] ) || ! empty( $args['latitude'] ) || ! empty( $args['longitude'] ) ) {
                         // If any of these are specified, and no localitity was guessed based on the above checks, bail with no location.
                         $location = false;
                 } else {
                         // No specific location details.
                         $location = array();
                 }
         }
 
         // IP:
         if ( ! $location && isset( $args['ip'] ) && ! isset( $args['location_name'] ) ) {
                 $guess = guess_location_from_ip( $args['ip'] );
 
                 if ( $guess ) {
@@ -572 +438 @@
  *
  * This isn't perfect because some of the country names in the database are in a format that regular
  * people wouldn't type -- e.g., "Venezuela, Bolvarian Republic Of" -- but this will still match a
  * majority of them.
  *
  * Currently, this only works with English names because that's the only data we have.
  *
  * @param string $location_name
  *
  * @return false|array false on failure; an array with country details on success
  */
 function guess_location_from_country( $location_name ) {
         // Check if they entered only the country name, e.g. "Germany" or "New Zealand"
         $country             = get_country_from_name( $location_name );
         $location_word_count = str_word_count( $location_name );
-        $location_name_parts = explode( ' ', $location_name );
-        $valid_country_codes = get_valid_country_codes();
+        $location_name_parts = preg_split( '/\s+/u', $location_name );
 
         /*
          * Multi-word queries may contain cities, regions, and countries, so try to extract just the country
          */
         if ( ! $country && $location_word_count >= 2 ) {
                 // Catch input like "Vancouver Canada"
                 $country_id   = $location_name_parts[ $location_word_count - 1 ];
                 $country      = get_country_from_name( $country_id );
         }
 
         if ( ! $country && $location_word_count >= 3 ) {
                 // Catch input like "Santiago De Los Caballeros, Dominican Republic"
                 $country_name = sprintf(
                         '%s %s',
                         $location_name_parts[ $location_word_count - 2 ],
@@ -609 +474 @@
         if ( ! $country && $location_word_count >= 4 ) {
                 // Catch input like "Kaga-Bandoro, Central African Republic"
                 $country_name = sprintf(
                         '%s %s %s',
                         $location_name_parts[ $location_word_count - 3 ],
                         $location_name_parts[ $location_word_count - 2 ],
                         $location_name_parts[ $location_word_count - 1 ]
                 );
                 $country = get_country_from_name( $country_name );
         }
 
         return $country;
 }
 
 /**
- * Get a list of valid country codes
- *
- * @return array
- */
-function get_valid_country_codes() {
-        global $wpdb;
-
-        return $wpdb->get_col( "SELECT DISTINCT country FROM geoname" );
-}
-
-/**
  * Get the country that corresponds to the given country name
  *
  * @param string $country_name
  *
  * @return false|array false on failure; an array with country details on success
  */
 function get_country_from_name( $country_name ) {
         global $wpdb;
 
-        $country = $wpdb->get_row( $wpdb->prepare( "
-                SELECT country_short, country_long
-                FROM ip2location
-                WHERE
-                        country_long  = %s OR
-                        country_short = %s
-                LIMIT 1",
-                $country_name,
-                $country_name
-        ), 'ARRAY_A' );
-
-        // Convert all errors to boolean false for consistency
-        if ( empty( $country ) ) {
-                $country = false;
+        $field = 'name';
+        if ( strlen( $country_name ) == 2 ) {
+                $field = 'country';
         }
 
-        return $country;
-}
-
-/**
- * Get the name of the city that's closest to the given coordinates
- *
- * @todo - This can probably be optimized by SELECT'ing from a derived table of the closest rows, instead of the
- *         entire table, similar to the technique described at
- *         http://www.techfounder.net/2009/02/02/selecting-closest-values-in-mysql/
- *         There's only 140k rows in the table, though, so this is performant for now.
- *
- * NOTE: If this causes any performance issues, it's possible that it could be removed entirely. The Core client
- *       saves the location locally, so it could display that instead of using this. However, there were some
- *       edge cases early in development that caused us to add this. I don't remember what they were, though, and
- *       didn't properly document them in r5128. So, if we ever want to attempt removing this, we'll need to test
- *       for unintended side effects. The Core client would need to be updated to display the saved location, so
- *       removing this would probably require creating a new version of the endpoint, and leaving this version for
- *       older installs.
- *
- * @param float $latitude
- * @param float $longitude
- *
- * @return false|string
- */
-function get_city_from_coordinates( $latitude, $longitude ) {
-        global $wpdb;
-
-        $results = $wpdb->get_col( $wpdb->prepare( "
+        return $wpdb->get_row( $wpdb->prepare( "
                 SELECT
-                        name,
-                        ABS( %f - latitude  ) AS latitude_distance,
-                        ABS( %f - longitude ) AS longitude_distance
-                FROM geoname
-                HAVING
-                        latitude_distance  < 0.3 AND    -- 0.3 degrees is about 30 miles
-                        longitude_distance < 0.3
-                ORDER by latitude_distance ASC, longitude_distance ASC
+                        country as country_short,
+                        name as country_long
+                FROM countrycodes
+                WHERE
+                        $field = %s
                 LIMIT 1",
-                $latitude,
-                $longitude
-        ) );
-
-        return isset( $results[0] ) ? $results[0] : false;
+                $country_name
+        ), 'ARRAY_A' );
 }
 
 function get_events( $args = array() ) {
         global $wpdb, $cache_life, $cache_group;
 
         // Sort to ensure consistent cache keys.
         ksort( $args );
 
         // number should be between 0 and 100, with a default of 10.
         $args['number'] = $args['number'] ?? 10;
         $args['number'] = max( 0, min( $args['number'], 100 ) );
 
         $cache_key = 'events:' . md5( serialize( $args ) );
         if ( false !== ( $data = wp_cache_get( $cache_key, $cache_group ) ) ) {
                 return $data;

1.0/tests/test-index.php

@@ -1 +1 @@
 <?php
 
 namespace Dotorg\API\Events;
 
 if ( 'cli' !== php_sapi_name() ) {
         die();
 }
 
+// For query time stats
+define( 'SAVEQUERIES', true );
+
 /**
  * Main entry point
  */
 function run_tests() {
+        global $wpdb;
         define( 'RUNNING_TESTS', true );
         require_once( dirname( __DIR__ ) . '/index.php' );
 
         $failed = 0;
         $failed += test_get_location();
-        $failed += test_get_city_from_coordinates();
 
+        printf(
+                "\nTook %f seconds for %d queries (%f/q)",
+                $sum = array_sum( array_column( $wpdb->queries, 1 ) ),
+                $count = count( $wpdb->queries ),
+                $sum/$count
+        );
         printf( "\n\nFinished running all tests. %d failed.\n", $failed );
+
 }
 
 /**
  * Output the results of an individual test
  *
  * @param int   $case_id
  * @param bool  $passed
  * @param mixed $expected_result
  * @param mixed $actual_result
  */
 function output_results( $case_id, $passed, $expected_result, $actual_result ) {
         printf(
                 "\n* %s: %s",
                 $case_id,
                 $passed ? 'PASSED' : '_FAILED_'
@@ -131 +141 @@
                 /*
                  * The country name, locale, and timezone are given
                  */
                 'country-exonym-1-word' => array(
                         'input' => array(
                                 'location_name' => 'Indonesia',
                                 'locale'        => 'id_ID',
                                 'timezone'      => 'Asia/Jakarta',
                         ),
                         'expected' => array(
                                 'country' => 'ID',
                                 'description' => 'indonesia',
                         ),
                 ),
 
-                /*
-                 * This is matching a city inside the country before it the country searches run, but that's ok since it's
-                 * good enough for our use cases
-                 */
                 'country-exonym-2-words' => array(
                         'input' => array(
                                 'location_name' => 'Bosnia and Herzegovina',
                                 'locale'        => 'bs_BA',
                                 'timezone'      => 'Europe/Sarajevo',
                         ),
                         'expected' => array(
-                                'description' => 'pale',
-                                'latitude'    => '43.817',
-                                'longitude'   => '18.569',
-                                'country'     => 'BA'
+                                'country' => 'BA',
+                                'description' => 'bosnia and herzegovina',
                         ),
                 ),
 
 
                 /*
                  * A location couldn't be found
                  */
                 'city-invalid-private-ip' => array(
                         'input' => array(
                                 'location_name' => 'Rivendell',
                                 'ip'            => '127.0.0.1'
                         ),
                         'expected' => false,
                 ),
 
@@ -265 +269 @@
                         'expected' => array(
                                 'description' => 'sydney',
                                 'latitude'    => '-33.868',
                                 'longitude'   => '151.207',
                                 'country'     => 'AU',
                         ),
                 ),
 
                 'city-south-america' => array(
                         'input' => array(
                                 'location_name' => 'Sao Paulo',
                                 'locale'        => 'pt_BR',
                                 'timezone'      => 'America/Sao_Paulo',
                         ),
                         'expected' => array(
-                                'description' => 'são paulo',
+                                'description' => 'sao paulo',
                                 'latitude'    => '-23.548',
                                 'longitude'   => '-46.636',
                                 'country'     => 'BR',
                         ),
                 ),
 
                 // Users will often type them without the dash, bypassing an exact match
                 'city-with-dashes-in-formal-name' => array(
                         'input' => array(
                                 'location_name' => 'Osakashi',
                                 'locale'        => 'ja',
                                 'timezone'      => 'Asia/Tokyo',
                         ),
                         'expected' => array(
-                                'description' => 'osaka',
+                                'description' => 'osakashi',
                                 'latitude'    => '34.694',
                                 'longitude'   => '135.502',
                                 'country'     => 'JP',
                         ),
                 ),
 
                 // If a location is provided, the fallback search should be attempted before an IP search
                 'fallback-with-public-ip' => array(
                         'input' => array(
                                 'location_name' => 'Osakashi',
                                 'locale'        => 'ja',
                                 'timezone'      => 'Asia/Tokyo',
                                 'ip'            => '153.163.68.148', // Tokyo
                         ),
                         'expected' => array(
-                                'description' => 'osaka',
+                                'description' => 'osakashi',
                                 'latitude'    => '34.694',
                                 'longitude'   => '135.502',
                                 'country'     => 'JP',
                         ),
                 ),
 
                 'city-with-apostrophe-in-formal-name' => array(
                         'input' => array(
                                 'location_name' => "Coeur d'Alene",
                                 'locale'        => 'en_US',
                                 'timezone'      => 'America/Los_Angeles',
                         ),
                         'expected' => array(
                                 'description' => "coeur d'alene",
                                 'latitude'    => '47.678',
@@ -343 +347 @@
                         'expected' => array(
                                 'description' => "doña ana",
                                 'latitude'    => '32.390',
                                 'longitude'   => '-106.814',
                                 'country'     => 'US',
                         ),
                 ),
 
                 'city-with-diacritics-in-formal-name-but-not-in-query' => array(
                         'input' => array(
                                 'location_name' => "Dona Ana",
                                 'locale'        => 'en_US',
                                 'timezone'      => 'America/Denver',
                         ),
                         'expected' => array(
-                                'description' => "doña ana",
+                                'description' => "dona ana",
                                 'latitude'    => '32.390',
                                 'longitude'   => '-106.814',
                                 'country'     => 'US',
                         ),
                 ),
 
                 'city-with-period-in-query' => array(
                         'input' => array(
                                 'location_name' => "St. Louis",
                                 'locale'        => 'en_US',
                                 'timezone'      => 'America/Chicago',
                         ),
                         'expected' => array(
                                 'description' => "st. louis",
                                 'latitude'    => '38.627',
                                 'longitude'   => '-90.198',
                                 'country'     => 'US',
                         ),
                 ),
 
                 'city-with-period-in-formal-name-but-not-in-query' => array(
                         'input' => array(
                                 'location_name' => "St Louis",
                                 'locale'        => 'en_US',
                                 'timezone'      => 'America/Chicago',
                         ),
                         'expected' => array(
-                                'description' => "st. louis",
+                                'description' => "st louis",
                                 'latitude'    => '38.627',
                                 'longitude'   => '-90.198',
                                 'country'     => 'US',
                         ),
                 ),
 
                 /*
                  * The city endonym, locale, and timezone are given
                  *
                  * @todo
                  * This is currently failling. A query from PHP shows row id 2220957 has "Yaound?" instead of
                  * "Yaoundé", but it's correct in the database itself.
                  */
                  'city-endonym-accents-africa' => array(
                         'input' => array(
@@ -406 +410 @@
                         'expected' => array(
                                 'description' => 'yaoundé',
                                 'latitude'    => '3.867',
                                 'longitude'   => '11.517',
                                 'country'     => 'CM',
                         ),
                 ),
 
                 'city-endonym-non-latin-africa' => array(
                         'input' => array(
                                 'location_name' => 'አዲስ አበ',
                                 'locale'        => 'am',
                                 'timezone'      => 'Africa/Addis_Ababa',
                         ),
                         'expected' => array(
-                                'description' => 'addis ababa',
+                                'description' => 'አዲስ አበባ',
                                 'latitude'    => '9.025',
                                 'longitude'   => '38.747',
                                 'country'     => 'ET',
                         ),
                 ),
 
                 'city-endonym-ideographic-asia1' => array(
                         'input' => array(
                                 'location_name' => '白浜町宇佐崎南',
                                 'locale'        => 'ja',
                                 'timezone'      => 'Asia/Tokyo',
                         ),
                         'expected' => array(
-                                'description' => 'shirahamachō-usazakiminami',
+                                'description' => '白浜町宇佐崎南',
                                 'latitude'    => '34.783',
                                 'longitude'   => '134.717',
                                 'country'     => 'JP',
                         ),
                 ),
 
                 'city-endonym-ideographic-asia2' => array(
                         'input' => array(
                                 'location_name' => 'تهران',
                                 'locale'        => 'fa_IR',
                                 'timezone'      => 'Asia/Tehran',
                         ),
                         'expected' => array(
-                                'description' => 'tehran',
+                                'description' => 'تهران',
                                 'latitude'    => '35.694',
                                 'longitude'   => '51.422',
                                 'country'     => 'IR',
                         ),
                 ),
 
                 'city-endonym-ideographic-asia3' => array(
                         'input' => array(
                                 'location_name' => 'كراچى',
                                 'locale'        => 'ur',
                                 'timezone'      => 'Asia/Karachi',
                         ),
                         'expected' => array(
-                                'description' => 'karachi',
+                                'description' => 'كراچى',
                                 'latitude'    => '24.906',
                                 'longitude'   => '67.082',
                                 'country'     => 'PK',
                         ),
                 ),
 
                 'city-endonym-ideographic-asia4' => array(
                         'input' => array(
                                 'location_name' => '京都',
                                 'locale'        => 'ja',
                                 'timezone'      => 'Asia/Tokyo',
                         ),
                         'expected' => array(
-                                'description' => 'kyoto',
+                                'description' => '京都',
                                 'latitude'    => '35.021',
                                 'longitude'   => '135.754',
                                 'country'     => 'JP',
                         ),
                 ),
 
                 'city-endonym-ideographic-asia5' => array(
                         'input' => array(
                                 'location_name' => '東京',
                                 'locale'        => 'ja',
                                 'timezone'      => 'Asia/Tokyo',
                         ),
                         'expected' => array(
-                                'description' => 'tokyo',
+                                'description' => '東京',
                                 'latitude'    => '35.690',
                                 'longitude'   => '139.692',
                                 'country'     => 'JP',
                         ),
                 ),
 
                 // The database only has 大阪市 ("Osaka-shi"), not 大阪 ("Osaka"), so an exact match will for 大阪 will fail
                 'city-endonym-ideographic-municipal-unit-asia' => array(
                         'input' => array(
                                 'location_name' => '大阪',
                                 'locale'        => 'ja',
                                 'timezone'      => 'Asia/Tokyo',
                         ),
                         'expected' => array(
-                                'description' => 'osaka',
+                                'description' => '大阪市',
                                 'latitude'    => '34.694',
                                 'longitude'   => '135.502',
                                 'country'     => 'JP',
                         ),
                 ),
 
                 'city-endonym-europe' => array(
                         'input' => array(
                                 'location_name' => 'Wien',
                                 'locale'        => 'de_DE',
                                 'timezone'      => 'Europe/Berlin',
                         ),
                         'expected' => array(
-                                'description' => 'vienna',
+                                'description' => 'wien',
                                 'latitude'    => '48.208',
                                 'longitude'   => '16.372',
                                 'country'     => 'AT',
                         ),
                 ),
 
                 'city-endonym-europe2' => array(
                         'input' => array(
                                 'location_name' => 'Москва',
                                 'locale'        => 'ru_RU',
                                 'timezone'      => 'Europe/Moscow',
                         ),
                         'expected' => array(
-                                'description' => 'moscow',
+                                'description' => 'Москва',
                                 'latitude'    => '55.752',
                                 'longitude'   => '37.616',
                                 'country'     => 'RU',
                         ),
                 ),
 
                 'city-endonym-accents-north-america' => array(
                         'input' => array(
                                 'location_name' => 'Ciudad de México',
                                 'locale'        => 'en_MX',
                                 'timezone'      => 'America/Mexico_City',
                         ),
                         'expected' => array(
-                                'description' => 'mexico city',
+                                'description' => 'ciudad de méxico',
                                 'latitude'    => '19.428',
                                 'longitude'   => '-99.128',
                                 'country'     => 'MX',
                         ),
                 ),
 
                 'city-endonym-accents-oceania' => array(
                         'input' => array(
                                 'location_name' => 'Hagåtña',
                                 'locale'        => 'en_US',
                                 'timezone'      => 'Pacific/Guam',
                         ),
                         'expected' => array(
                                 'description' => 'hagåtña',
                                 'latitude'    => '13.476',
@@ -674 +678 @@
                         ),
                 ),
 
                 /*
                  * Coordinates should take precedence over IP addresses
                  */
                 'coordinates-over-ip-us' => array(
                         'input' => array(
                                 'latitude'  => '47.6062100',
                                 'longitude' => '-122.3320700',
                                 'ip'        => '192.0.70.251',  // San Francisco, USA
                                 'timezone'  => 'America/Los_Angeles',
                                 'locale'    => 'en_US',
                         ),
                         'expected' => array(
-                                'description' => 'seattle',
+                                'description' => false,
                                 'latitude'    => '47.606',
                                 'longitude'   => '-122.332',
                         ),
                 ),
 
                 'coordinates-over-ip-africa' => array(
                         'input' => array(
                                 'latitude'  => '-19.634233',
                                 'longitude' => '17.331767',
                                 'ip'        => '41.190.96.5',   // Tsumeb, Namibia
                                 'timezone'  => 'Africa/Windhoek',
                                 'locale'    => 'af',
                         ),
                         'expected' => array(
-                                'description' => 'otavi',
+                                'description' => false,
                                 'latitude'    => '-19.634',
                                 'longitude'   => '17.332',
                         ),
                 ),
 
                 /*
                  * Only the IP is given
                  */
                 'ip-africa' => array(
                         'input' => array( 'ip' => '41.191.232.22' ),
                         'expected' => array(
                                 'description' => 'harare',
                                 'latitude'    => '-17.829',
                                 'longitude'   => '31.054',
                                 'country'     => 'ZW',
@@ -768 +772 @@
                 'ip-south-america' => array(
                         'input' => array( 'ip' => '181.66.32.136' ),
                         'expected' => array(
                                 'description' => 'lima',
                                 'latitude'    => '-12.043',
                                 'longitude'   => '-77.028',
                                 'country'     => 'PE',
                                 'internal'    => true,
                         ),
                 ),
         );
 
          return $cases;
 }
 
-/**
- * Test `get_city_from_coordinates()`
- *
- * @todo This can probably be refactored along with test_get_location() into a more abstract/DRY general-purpose
- *       test runner.
- *
- * @return bool The number of failures
- */
-function test_get_city_from_coordinates() {
-        $failed = 0;
-        $cases  = get_city_from_coordinates_test_cases();
-
-        printf( "\n\nRunning %d city from coordinate tests\n", count( $cases ) );
-
-        foreach ( $cases as $case_id => $case ) {
-                $case['input'] = add_cachebusting_parameter( $case['input'] );
-                $actual_result = get_city_from_coordinates( $case['input']['latitude'], $case['input']['longitude'] );
-                $passed        = $case['expected'] === $actual_result;
-
-                output_results( $case_id, $passed, $case['expected'], $actual_result );
-
-                if ( ! $passed ) {
-                        $failed++;
-                }
-        }
-
-        return $failed;
-}
-
-/**
- * Get the cases for testing `get_city_from_coordinates()`
- *
- * @return array
- */
-function get_city_from_coordinates_test_cases() {
-         $cases = array(
-                'lower-latitude-higher-longitude' => array(
-                        'input' => array(
-                                'latitude'  => '60.199',
-                                'longitude' => '24.660'
-                        ),
-                        'expected' => 'Espoo',
-                ),
-
-                'higher-latitude-lower-longitude' => array(
-                        'input' => array(
-                                'latitude'  => '22.000',
-                                'longitude' => '95.900'
-                        ),
-                        'expected' => 'Mandalay',
-                ),
-
-                'middle-of-no-and-where' => array(
-                        'input' => array(
-                                'latitude'  => '-23.121',
-                                'longitude' => '125.071'
-                        ),
-                        'expected' => false,
-                ),
-        );
-
-        return $cases;
-}
-
 run_tests();