src/third_party/libaddressinput/src/cpp/test/rule_test.cc

   1 // Copyright (C) 2013 Google Inc.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 // http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "rule.h"
  16
  17 #include <libaddressinput/address_field.h>
  18 #include <libaddressinput/localization.h>
  19
  20 #include <cstddef>
  21 #include <string>
  22 #include <utility>
  23 #include <vector>
  24
  25 #include <gtest/gtest.h>
  26
  27 #include "address_field_util.h"
  28 #include "format_element.h"
  29 #include "grit.h"
  30 #include "messages.h"
  31 #include "region_data_constants.h"
  32 #include "util/json.h"
  33
  34 namespace {
  35
  36 using i18n::addressinput::AddressField;
  37 using i18n::addressinput::ADMIN_AREA;
  38 using i18n::addressinput::FormatElement;
  39 using i18n::addressinput::INVALID_MESSAGE_ID;
  40 using i18n::addressinput::Json;
  41 using i18n::addressinput::LOCALITY;
  42 using i18n::addressinput::Localization;
  43 using i18n::addressinput::RegionDataConstants;
  44 using i18n::addressinput::Rule;
  45 using i18n::addressinput::STREET_ADDRESS;
  46
  47 TEST(RuleTest, CopyOverwritesRule) {
  48   Rule rule;
  49   ASSERT_TRUE(rule.ParseSerializedRule("{"
  50                                        "\"fmt\":\"%S%Z\","
  51                                        "\"lfmt\":\"%Z%S\","
  52                                        "\"id\":\"data/XA\","
  53                                        "\"name\":\"Le Test\","
  54                                        "\"lname\":\"Testistan\","
  55                                        "\"require\":\"AC\","
  56                                        "\"sub_keys\":\"aa~bb~cc\","
  57                                        "\"languages\":\"en~fr\","
  58                                        "\"zip\":\"\\\\d{3}\","
  59                                        "\"state_name_type\":\"area\","
  60                                        "\"zip_name_type\":\"postal\","
  61                                        "\"zipex\":\"1234\","
  62                                        "\"posturl\":\"http://www.testpost.com\""
  63                                        "}"));
  64
  65   Rule copy;
  66   EXPECT_NE(rule.GetFormat(), copy.GetFormat());
  67   EXPECT_NE(rule.GetLatinFormat(), copy.GetLatinFormat());
  68   EXPECT_NE(rule.GetId(), copy.GetId());
  69   EXPECT_NE(rule.GetRequired(), copy.GetRequired());
  70   EXPECT_NE(rule.GetSubKeys(), copy.GetSubKeys());
  71   EXPECT_NE(rule.GetLanguages(), copy.GetLanguages());
  72   EXPECT_NE(rule.GetAdminAreaNameMessageId(),
  73             copy.GetAdminAreaNameMessageId());
  74   EXPECT_NE(rule.GetPostalCodeNameMessageId(),
  75             copy.GetPostalCodeNameMessageId());
  76   EXPECT_NE(rule.GetName(), copy.GetName());
  77   EXPECT_NE(rule.GetLatinName(), copy.GetLatinName());
  78   EXPECT_NE(rule.GetPostalCodeExample(), copy.GetPostalCodeExample());
  79   EXPECT_NE(rule.GetPostServiceUrl(), copy.GetPostServiceUrl());
  80
  81   EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL);
  82   EXPECT_TRUE(copy.GetPostalCodeMatcher() == NULL);
  83
  84   copy.CopyFrom(rule);
  85   EXPECT_EQ(rule.GetFormat(), copy.GetFormat());
  86   EXPECT_EQ(rule.GetLatinFormat(), copy.GetLatinFormat());
  87   EXPECT_EQ(rule.GetId(), copy.GetId());
  88   EXPECT_EQ(rule.GetRequired(), copy.GetRequired());
  89   EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys());
  90   EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages());
  91   EXPECT_EQ(rule.GetAdminAreaNameMessageId(),
  92             copy.GetAdminAreaNameMessageId());
  93   EXPECT_EQ(rule.GetPostalCodeNameMessageId(),
  94             copy.GetPostalCodeNameMessageId());
  95   EXPECT_EQ(rule.GetName(), copy.GetName());
  96   EXPECT_EQ(rule.GetLatinName(), copy.GetLatinName());
  97   EXPECT_EQ(rule.GetPostalCodeExample(), copy.GetPostalCodeExample());
  98   EXPECT_EQ(rule.GetPostServiceUrl(), copy.GetPostServiceUrl());
  99
 100   EXPECT_TRUE(copy.GetPostalCodeMatcher() != NULL);
 101 }
 102
 103 TEST(RuleTest, ParseOverwritesRule) {
 104   Rule rule;
 105   ASSERT_TRUE(rule.ParseSerializedRule("{"
 106                                        "\"fmt\":\"%S%Z\","
 107                                        "\"state_name_type\":\"area\","
 108                                        "\"zip\":\"1234\","
 109                                        "\"zip_name_type\":\"postal\","
 110                                        "\"zipex\":\"1234\","
 111                                        "\"posturl\":\"http://www.testpost.com\""
 112                                        "}"));
 113   EXPECT_FALSE(rule.GetFormat().empty());
 114   EXPECT_EQ(IDS_LIBADDRESSINPUT_AREA,
 115             rule.GetAdminAreaNameMessageId());
 116   EXPECT_EQ(IDS_LIBADDRESSINPUT_POSTAL_CODE_LABEL,
 117             rule.GetPostalCodeNameMessageId());
 118   EXPECT_EQ("1234", rule.GetSolePostalCode());
 119   EXPECT_EQ("1234", rule.GetPostalCodeExample());
 120   EXPECT_EQ("http://www.testpost.com", rule.GetPostServiceUrl());
 121
 122   ASSERT_TRUE(rule.ParseSerializedRule("{"
 123                                        "\"fmt\":\"\","
 124                                        "\"state_name_type\":\"do_si\","
 125                                        "\"zip_name_type\":\"zip\","
 126                                        "\"zipex\":\"5678\","
 127                                        "\"posturl\":\"http://www.fakepost.com\""
 128                                        "}"));
 129   EXPECT_TRUE(rule.GetFormat().empty());
 130   EXPECT_EQ(IDS_LIBADDRESSINPUT_DO_SI,
 131             rule.GetAdminAreaNameMessageId());
 132   EXPECT_EQ(IDS_LIBADDRESSINPUT_ZIP_CODE_LABEL,
 133             rule.GetPostalCodeNameMessageId());
 134   EXPECT_TRUE(rule.GetSolePostalCode().empty());
 135   EXPECT_EQ("5678", rule.GetPostalCodeExample());
 136   EXPECT_EQ("http://www.fakepost.com", rule.GetPostServiceUrl());
 137 }
 138
 139 TEST(RuleTest, ParsesFormatCorrectly) {
 140   std::vector<FormatElement> expected;
 141   expected.push_back(FormatElement(ADMIN_AREA));
 142   expected.push_back(FormatElement(LOCALITY));
 143   Rule rule;
 144   ASSERT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%S%C\"}"));
 145   EXPECT_EQ(expected, rule.GetFormat());
 146 }
 147
 148 TEST(RuleTest, ParsesNameCorrectly) {
 149   Rule rule;
 150   ASSERT_TRUE(rule.ParseSerializedRule("{\"name\":\"Le Test\"}"));
 151   EXPECT_EQ("Le Test", rule.GetName());
 152 }
 153
 154 TEST(RuleTest, ParsesLatinNameCorrectly) {
 155   Rule rule;
 156   ASSERT_TRUE(rule.ParseSerializedRule("{\"lname\":\"Testistan\"}"));
 157   EXPECT_EQ("Testistan", rule.GetLatinName());
 158 }
 159
 160 TEST(RuleTest, ParsesLatinFormatCorrectly) {
 161   std::vector<FormatElement> expected;
 162   expected.push_back(FormatElement(LOCALITY));
 163   expected.push_back(FormatElement(ADMIN_AREA));
 164   Rule rule;
 165   ASSERT_TRUE(rule.ParseSerializedRule("{\"lfmt\":\"%C%S\"}"));
 166   EXPECT_EQ(expected, rule.GetLatinFormat());
 167 }
 168
 169 TEST(RuleTest, ParsesRequiredCorrectly) {
 170   std::vector<AddressField> expected;
 171   expected.push_back(STREET_ADDRESS);
 172   expected.push_back(LOCALITY);
 173   Rule rule;
 174   ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"AC\"}"));
 175   EXPECT_EQ(expected, rule.GetRequired());
 176 }
 177
 178 TEST(RuleTest, ParsesSubKeysCorrectly) {
 179   std::vector<std::string> expected;
 180   expected.push_back("aa");
 181   expected.push_back("bb");
 182   expected.push_back("cc");
 183   Rule rule;
 184   ASSERT_TRUE(rule.ParseSerializedRule("{\"sub_keys\":\"aa~bb~cc\"}"));
 185   EXPECT_EQ(expected, rule.GetSubKeys());
 186 }
 187
 188 TEST(RuleTest, ParsesLanguagesCorrectly) {
 189   std::vector<std::string> expected;
 190   expected.push_back("de");
 191   expected.push_back("fr");
 192   expected.push_back("it");
 193   Rule rule;
 194   ASSERT_TRUE(rule.ParseSerializedRule("{\"languages\":\"de~fr~it\"}"));
 195   EXPECT_EQ(expected, rule.GetLanguages());
 196 }
 197
 198 TEST(RuleTest, ParsesPostalCodeExampleCorrectly) {
 199   Rule rule;
 200   ASSERT_TRUE(rule.ParseSerializedRule("{\"zipex\":\"1234,12345-6789\"}"));
 201   EXPECT_EQ("1234,12345-6789", rule.GetPostalCodeExample());
 202 }
 203
 204 TEST(RuleTest, ParsesPostServiceUrlCorrectly) {
 205   Rule rule;
 206   ASSERT_TRUE(
 207       rule.ParseSerializedRule("{\"posturl\":\"http://www.testpost.com\"}"));
 208   EXPECT_EQ("http://www.testpost.com", rule.GetPostServiceUrl());
 209 }
 210
 211 TEST(RuleTest, PostalCodeMatcher) {
 212   Rule rule;
 213   ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"\\\\d{3}\"}"));
 214   EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL);
 215 }
 216
 217 TEST(RuleTest, PostalCodeMatcherInvalidRegExp) {
 218   Rule rule;
 219   ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"(\"}"));
 220   EXPECT_TRUE(rule.GetPostalCodeMatcher() == NULL);
 221 }
 222
 223 TEST(RuleTest, ParsesJsonRuleCorrectly) {
 224   Json json;
 225   ASSERT_TRUE(json.ParseObject("{\"zip\":\"\\\\d{3}\"}"));
 226   Rule rule;
 227   rule.ParseJsonRule(json);
 228   EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL);
 229 }
 230
 231 TEST(RuleTest, EmptyStringIsNotValid) {
 232   Rule rule;
 233   EXPECT_FALSE(rule.ParseSerializedRule(std::string()));
 234 }
 235
 236 TEST(RuleTest, EmptyDictionaryIsValid) {
 237   Rule rule;
 238   EXPECT_TRUE(rule.ParseSerializedRule("{}"));
 239 }
 240
 241 // Tests for parsing the postal code name.
 242 class PostalCodeNameParseTest
 243     : public testing::TestWithParam<std::pair<std::string, int> > {
 244  protected:
 245   Rule rule_;
 246 };
 247
 248 // Verifies that a postal code name is parsed correctly.
 249 TEST_P(PostalCodeNameParseTest, ParsedCorrectly) {
 250   ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().first));
 251   EXPECT_EQ(GetParam().second, rule_.GetPostalCodeNameMessageId());
 252 }
 253
 254 // Test parsing all postal code names.
 255 INSTANTIATE_TEST_CASE_P(
 256     AllPostalCodeNames, PostalCodeNameParseTest,
 257     testing::Values(
 258         std::make_pair("{\"zip_name_type\":\"postal\"}",
 259                        IDS_LIBADDRESSINPUT_POSTAL_CODE_LABEL),
 260         std::make_pair("{\"zip_name_type\":\"zip\"}",
 261                        IDS_LIBADDRESSINPUT_ZIP_CODE_LABEL)));
 262
 263 // Tests for parsing the administrative area name.
 264 class AdminAreaNameParseTest
 265     : public testing::TestWithParam<std::pair<std::string, int> > {
 266  protected:
 267   Rule rule_;
 268 };
 269
 270 // Verifies that an administrative area name is parsed correctly.
 271 TEST_P(AdminAreaNameParseTest, ParsedCorrectly) {
 272   ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().first));
 273   EXPECT_EQ(GetParam().second, rule_.GetAdminAreaNameMessageId());
 274 }
 275
 276 // Test parsing all administrative area names.
 277 INSTANTIATE_TEST_CASE_P(
 278     AllAdminAreaNames, AdminAreaNameParseTest,
 279     testing::Values(
 280         std::make_pair("{\"state_name_type\":\"area\"}",
 281                        IDS_LIBADDRESSINPUT_AREA),
 282         std::make_pair("{\"state_name_type\":\"county\"}",
 283                        IDS_LIBADDRESSINPUT_COUNTY),
 284         std::make_pair("{\"state_name_type\":\"department\"}",
 285                        IDS_LIBADDRESSINPUT_DEPARTMENT),
 286         std::make_pair("{\"state_name_type\":\"district\"}",
 287                        IDS_LIBADDRESSINPUT_DISTRICT),
 288         std::make_pair("{\"state_name_type\":\"do_si\"}",
 289                        IDS_LIBADDRESSINPUT_DO_SI),
 290         std::make_pair("{\"state_name_type\":\"emirate\"}",
 291                        IDS_LIBADDRESSINPUT_EMIRATE),
 292         std::make_pair("{\"state_name_type\":\"island\"}",
 293                        IDS_LIBADDRESSINPUT_ISLAND),
 294         std::make_pair("{\"state_name_type\":\"parish\"}",
 295                        IDS_LIBADDRESSINPUT_PARISH),
 296         std::make_pair("{\"state_name_type\":\"prefecture\"}",
 297                        IDS_LIBADDRESSINPUT_PREFECTURE),
 298         std::make_pair("{\"state_name_type\":\"province\"}",
 299                        IDS_LIBADDRESSINPUT_PROVINCE),
 300         std::make_pair("{\"state_name_type\":\"state\"}",
 301                        IDS_LIBADDRESSINPUT_STATE)));
 302
 303 // Tests for rule parsing.
 304 class RuleParseTest : public testing::TestWithParam<std::string> {
 305  protected:
 306   const std::string& GetRegionData() const {
 307     // GetParam() is either a region code or the region data itself.
 308     // RegionDataContants::GetRegionData() returns an empty string for anything
 309     // that's not a region code.
 310     const std::string& data = RegionDataConstants::GetRegionData(GetParam());
 311     return !data.empty() ? data : GetParam();
 312   }
 313
 314   Rule rule_;
 315   Localization localization_;
 316 };
 317
 318 // Verifies that a region data can be parsed successfully.
 319 TEST_P(RuleParseTest, RegionDataParsedSuccessfully) {
 320   EXPECT_TRUE(rule_.ParseSerializedRule(GetRegionData()));
 321 }
 322
 323 // Verifies that the admin area name type corresponds to a UI string.
 324 TEST_P(RuleParseTest, AdminAreaNameTypeHasUiString) {
 325   const std::string& region_data = GetRegionData();
 326   rule_.ParseSerializedRule(region_data);
 327   if (region_data.find("state_name_type") != std::string::npos) {
 328     EXPECT_NE(INVALID_MESSAGE_ID, rule_.GetAdminAreaNameMessageId());
 329     EXPECT_FALSE(
 330         localization_.GetString(rule_.GetAdminAreaNameMessageId()).empty());
 331   }
 332 }
 333
 334 // Verifies that the postal code name type corresponds to a UI string.
 335 TEST_P(RuleParseTest, PostalCodeNameTypeHasUiString) {
 336   const std::string& region_data = GetRegionData();
 337   rule_.ParseSerializedRule(region_data);
 338   if (region_data.find("zip_name_type") != std::string::npos) {
 339     EXPECT_NE(INVALID_MESSAGE_ID, rule_.GetPostalCodeNameMessageId());
 340     EXPECT_FALSE(
 341         localization_.GetString(rule_.GetPostalCodeNameMessageId()).empty());
 342   }
 343 }
 344
 345 // Verifies that the sole postal code is correctly recognised and copied.
 346 TEST_P(RuleParseTest, SolePostalCode) {
 347   Rule rule;
 348   ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"1234\"}"));
 349   EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL);
 350   EXPECT_TRUE(rule.GetSolePostalCode() == "1234");
 351
 352   Rule copy;
 353   EXPECT_TRUE(copy.GetPostalCodeMatcher() == NULL);
 354   EXPECT_TRUE(copy.GetSolePostalCode().empty());
 355
 356   copy.CopyFrom(rule);
 357   EXPECT_TRUE(copy.GetPostalCodeMatcher() != NULL);
 358   EXPECT_EQ(rule.GetSolePostalCode(), copy.GetSolePostalCode());
 359 }
 360
 361 // Test parsing all region data.
 362 INSTANTIATE_TEST_CASE_P(
 363     AllRulesTest, RuleParseTest,
 364     testing::ValuesIn(RegionDataConstants::GetRegionCodes()));
 365
 366 // Test parsing the default rule.
 367 INSTANTIATE_TEST_CASE_P(
 368     DefaultRuleTest, RuleParseTest,
 369     testing::Values(RegionDataConstants::GetDefaultRegionData()));
 370
 371 }  // namespace