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