1 // Copyright (C) 2014 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 "validation_task.h" 16 17 #include <libaddressinput/address_data.h> 18 #include <libaddressinput/address_field.h> 19 #include <libaddressinput/address_problem.h> 20 #include <libaddressinput/address_validator.h> 21 #include <libaddressinput/callback.h> 22 #include <libaddressinput/supplier.h> 23 #include <libaddressinput/util/basictypes.h> 24 #include <libaddressinput/util/scoped_ptr.h> 25 26 #include <cstddef> 27 #include <utility> 28 29 #include <gtest/gtest.h> 30 31 #include "lookup_key.h" 32 #include "rule.h" 33 34 namespace i18n { 35 namespace addressinput { 36 37 class ValidationTaskTest : public testing::Test { 38 protected: 39 ValidationTaskTest() 40 : json_(), 41 success_(true), 42 address_(), 43 allow_postal_(false), 44 require_name_(false), 45 filter_(), 46 problems_(), 47 expected_(), 48 called_(false), 49 validated_(BuildCallback(this, &ValidationTaskTest::Validated)) { 50 // Add all problems to the filter except those affected by the metadata 51 // in region_data_constants.cc. 52 static const AddressField kFields[] = { 53 COUNTRY, 54 ADMIN_AREA, 55 LOCALITY, 56 DEPENDENT_LOCALITY, 57 SORTING_CODE, 58 POSTAL_CODE, 59 STREET_ADDRESS, 60 ORGANIZATION, 61 RECIPIENT 62 }; 63 64 static const AddressProblem kProblems[] = { 65 // UNEXPECTED_FIELD is validated using IsFieldUsed(). 66 // MISSING_REQUIRED_FIELD is validated using IsFieldRequired(). 67 UNKNOWN_VALUE, 68 INVALID_FORMAT, 69 MISMATCHING_VALUE, 70 USES_P_O_BOX 71 }; 72 73 for (size_t i = 0; i < arraysize(kFields); ++i) { 74 AddressField field = kFields[i]; 75 for (size_t j = 0; j < arraysize(kProblems); ++j) { 76 AddressProblem problem = kProblems[j]; 77 filter_.insert(std::make_pair(field, problem)); 78 } 79 } 80 81 filter_.insert(std::make_pair(COUNTRY, UNEXPECTED_FIELD)); 82 filter_.insert(std::make_pair(COUNTRY, MISSING_REQUIRED_FIELD)); 83 filter_.insert(std::make_pair(RECIPIENT, UNEXPECTED_FIELD)); 84 filter_.insert(std::make_pair(RECIPIENT, MISSING_REQUIRED_FIELD)); 85 } 86 87 void Validate() { 88 Rule rule[arraysize(json_)]; 89 90 ValidationTask* task = new ValidationTask( 91 address_, 92 allow_postal_, 93 require_name_, 94 &filter_, 95 &problems_, 96 *validated_); 97 98 Supplier::RuleHierarchy hierarchy; 99 100 for (size_t i = 0; i < arraysize(json_) && json_[i] != NULL; ++i) { 101 ASSERT_TRUE(rule[i].ParseSerializedRule(json_[i])); 102 hierarchy.rule[i] = &rule[i]; 103 } 104 105 (*task->supplied_)(success_, *task->lookup_key_, hierarchy); 106 } 107 108 const char* json_[arraysize(LookupKey::kHierarchy)]; 109 bool success_; 110 AddressData address_; 111 bool allow_postal_; 112 bool require_name_; 113 FieldProblemMap filter_; 114 FieldProblemMap problems_; 115 FieldProblemMap expected_; 116 bool called_; 117 118 private: 119 void Validated(bool success, 120 const AddressData& address, 121 const FieldProblemMap& problems) { 122 ASSERT_EQ(success_, success); 123 ASSERT_EQ(&address_, &address); 124 ASSERT_EQ(&problems_, &problems); 125 called_ = true; 126 } 127 128 const scoped_ptr<const AddressValidator::Callback> validated_; 129 130 DISALLOW_COPY_AND_ASSIGN(ValidationTaskTest); 131 }; 132 133 namespace { 134 135 TEST_F(ValidationTaskTest, FailureCountryRuleNull) { 136 success_ = false; 137 138 ASSERT_NO_FATAL_FAILURE(Validate()); 139 ASSERT_TRUE(called_); 140 EXPECT_EQ(expected_, problems_); 141 } 142 143 TEST_F(ValidationTaskTest, FailureCountryRuleEmpty) { 144 json_[0] = "{}"; 145 success_ = false; 146 147 ASSERT_NO_FATAL_FAILURE(Validate()); 148 ASSERT_TRUE(called_); 149 EXPECT_EQ(expected_, problems_); 150 } 151 152 TEST_F(ValidationTaskTest, SuccessCountryRuleNullNameEmpty) { 153 expected_.insert(std::make_pair(COUNTRY, MISSING_REQUIRED_FIELD)); 154 155 ASSERT_NO_FATAL_FAILURE(Validate()); 156 ASSERT_TRUE(called_); 157 EXPECT_EQ(expected_, problems_); 158 } 159 160 TEST_F(ValidationTaskTest, SuccessCountryRuleNullNameNotEmpty) { 161 address_.region_code = "rrr"; 162 163 expected_.insert(std::make_pair(COUNTRY, UNKNOWN_VALUE)); 164 165 ASSERT_NO_FATAL_FAILURE(Validate()); 166 ASSERT_TRUE(called_); 167 EXPECT_EQ(expected_, problems_); 168 } 169 170 TEST_F(ValidationTaskTest, SuccessCountryRuleEmptyNameEmpty) { 171 json_[0] = "{}"; 172 173 expected_.insert(std::make_pair(COUNTRY, MISSING_REQUIRED_FIELD)); 174 175 ASSERT_NO_FATAL_FAILURE(Validate()); 176 ASSERT_TRUE(called_); 177 EXPECT_EQ(expected_, problems_); 178 } 179 180 TEST_F(ValidationTaskTest, SuccessCountryRuleEmptyNameNotEmpty) { 181 json_[0] = "{}"; 182 183 address_.region_code = "rrr"; 184 185 ASSERT_NO_FATAL_FAILURE(Validate()); 186 ASSERT_TRUE(called_); 187 EXPECT_EQ(expected_, problems_); 188 } 189 190 TEST_F(ValidationTaskTest, MissingRequiredFieldsUS) { 191 json_[0] = "{}"; 192 193 address_.region_code = "US"; 194 195 filter_.insert(std::make_pair(ADMIN_AREA, MISSING_REQUIRED_FIELD)); 196 filter_.insert(std::make_pair(LOCALITY, MISSING_REQUIRED_FIELD)); 197 filter_.insert(std::make_pair(POSTAL_CODE, MISSING_REQUIRED_FIELD)); 198 filter_.insert(std::make_pair(STREET_ADDRESS, MISSING_REQUIRED_FIELD)); 199 expected_.insert(std::make_pair(ADMIN_AREA, MISSING_REQUIRED_FIELD)); 200 expected_.insert(std::make_pair(LOCALITY, MISSING_REQUIRED_FIELD)); 201 expected_.insert(std::make_pair(POSTAL_CODE, MISSING_REQUIRED_FIELD)); 202 expected_.insert(std::make_pair(STREET_ADDRESS, MISSING_REQUIRED_FIELD)); 203 204 ASSERT_NO_FATAL_FAILURE(Validate()); 205 ASSERT_TRUE(called_); 206 EXPECT_EQ(expected_, problems_); 207 } 208 209 TEST_F(ValidationTaskTest, MissingNoRequiredFieldsUS) { 210 json_[0] = "{}"; 211 212 address_.region_code = "US"; 213 address_.administrative_area = "sss"; 214 address_.locality = "ccc"; 215 address_.postal_code = "zzz"; 216 address_.address_line.push_back("aaa"); 217 address_.organization = "ooo"; 218 address_.recipient = "nnn"; 219 220 filter_.insert(std::make_pair(ADMIN_AREA, MISSING_REQUIRED_FIELD)); 221 filter_.insert(std::make_pair(LOCALITY, MISSING_REQUIRED_FIELD)); 222 filter_.insert(std::make_pair(POSTAL_CODE, MISSING_REQUIRED_FIELD)); 223 filter_.insert(std::make_pair(STREET_ADDRESS, MISSING_REQUIRED_FIELD)); 224 filter_.insert(std::make_pair(ORGANIZATION, MISSING_REQUIRED_FIELD)); 225 226 ASSERT_NO_FATAL_FAILURE(Validate()); 227 ASSERT_TRUE(called_); 228 EXPECT_EQ(expected_, problems_); 229 } 230 231 TEST_F(ValidationTaskTest, UnexpectedFieldUS) { 232 json_[0] = "{}"; 233 234 address_.region_code = "US"; 235 address_.dependent_locality = "ddd"; 236 237 filter_.insert(std::make_pair(DEPENDENT_LOCALITY, UNEXPECTED_FIELD)); 238 expected_.insert(std::make_pair(DEPENDENT_LOCALITY, UNEXPECTED_FIELD)); 239 240 ASSERT_NO_FATAL_FAILURE(Validate()); 241 ASSERT_TRUE(called_); 242 EXPECT_EQ(expected_, problems_); 243 } 244 245 TEST_F(ValidationTaskTest, MissingRequiredFieldRequireName) { 246 json_[0] = "{}"; 247 248 address_.region_code = "rrr"; 249 250 require_name_ = true; 251 252 expected_.insert(std::make_pair(RECIPIENT, MISSING_REQUIRED_FIELD)); 253 254 ASSERT_NO_FATAL_FAILURE(Validate()); 255 ASSERT_TRUE(called_); 256 EXPECT_EQ(expected_, problems_); 257 } 258 259 TEST_F(ValidationTaskTest, UnknownValueRuleNull) { 260 json_[0] = "{\"fmt\":\"%R%S\",\"require\":\"RS\",\"sub_keys\":\"aa~bb\"}"; 261 262 address_.region_code = "rrr"; 263 address_.administrative_area = "sss"; 264 265 expected_.insert(std::make_pair(ADMIN_AREA, UNKNOWN_VALUE)); 266 267 ASSERT_NO_FATAL_FAILURE(Validate()); 268 ASSERT_TRUE(called_); 269 EXPECT_EQ(expected_, problems_); 270 } 271 272 TEST_F(ValidationTaskTest, NoUnknownValueRuleNotNull) { 273 json_[0] = "{\"fmt\":\"%R%S\",\"require\":\"RS\",\"sub_keys\":\"aa~bb\"}"; 274 json_[1] = "{}"; 275 276 address_.region_code = "rrr"; 277 address_.administrative_area = "sss"; 278 279 ASSERT_NO_FATAL_FAILURE(Validate()); 280 ASSERT_TRUE(called_); 281 EXPECT_EQ(expected_, problems_); 282 } 283 284 TEST_F(ValidationTaskTest, PostalCodeUnrecognizedFormatTooShort) { 285 json_[0] = "{\"fmt\":\"%Z\",\"zip\":\"\\\\d{3}\"}"; 286 287 address_.region_code = "rrr"; 288 address_.postal_code = "12"; 289 290 expected_.insert(std::make_pair(POSTAL_CODE, INVALID_FORMAT)); 291 292 ASSERT_NO_FATAL_FAILURE(Validate()); 293 ASSERT_TRUE(called_); 294 EXPECT_EQ(expected_, problems_); 295 } 296 297 TEST_F(ValidationTaskTest, PostalCodeUnrecognizedFormatTooLong) { 298 json_[0] = "{\"fmt\":\"%Z\",\"zip\":\"\\\\d{3}\"}"; 299 300 address_.region_code = "rrr"; 301 address_.postal_code = "1234"; 302 303 expected_.insert(std::make_pair(POSTAL_CODE, INVALID_FORMAT)); 304 305 ASSERT_NO_FATAL_FAILURE(Validate()); 306 ASSERT_TRUE(called_); 307 EXPECT_EQ(expected_, problems_); 308 } 309 310 TEST_F(ValidationTaskTest, PostalCodeRecognizedFormat) { 311 json_[0] = "{\"fmt\":\"%Z\",\"zip\":\"\\\\d{3}\"}"; 312 313 address_.region_code = "rrr"; 314 address_.postal_code = "123"; 315 316 ASSERT_NO_FATAL_FAILURE(Validate()); 317 ASSERT_TRUE(called_); 318 EXPECT_EQ(expected_, problems_); 319 } 320 321 TEST_F(ValidationTaskTest, PostalCodeMismatchingValue1) { 322 json_[0] = "{\"fmt\":\"%Z\",\"zip\":\"\\\\d{3}\"}"; 323 json_[1] = "{\"zip\":\"1\"}"; 324 325 address_.region_code = "rrr"; 326 address_.postal_code = "000"; 327 328 expected_.insert(std::make_pair(POSTAL_CODE, MISMATCHING_VALUE)); 329 330 ASSERT_NO_FATAL_FAILURE(Validate()); 331 ASSERT_TRUE(called_); 332 EXPECT_EQ(expected_, problems_); 333 } 334 335 TEST_F(ValidationTaskTest, PostalCodeMismatchingValue2) { 336 json_[0] = "{\"fmt\":\"%Z\",\"zip\":\"\\\\d{3}\"}"; 337 json_[1] = "{\"zip\":\"1\"}"; 338 json_[2] = "{\"zip\":\"12\"}"; 339 340 address_.region_code = "rrr"; 341 address_.postal_code = "100"; 342 343 expected_.insert(std::make_pair(POSTAL_CODE, MISMATCHING_VALUE)); 344 345 ASSERT_NO_FATAL_FAILURE(Validate()); 346 ASSERT_TRUE(called_); 347 EXPECT_EQ(expected_, problems_); 348 } 349 350 TEST_F(ValidationTaskTest, PostalCodeMismatchingValue3) { 351 json_[0] = "{\"fmt\":\"%Z\",\"zip\":\"\\\\d{3}\"}"; 352 json_[1] = "{\"zip\":\"1\"}"; 353 json_[2] = "{\"zip\":\"12\"}"; 354 json_[3] = "{\"zip\":\"123\"}"; 355 356 address_.region_code = "rrr"; 357 address_.postal_code = "120"; 358 359 expected_.insert(std::make_pair(POSTAL_CODE, MISMATCHING_VALUE)); 360 361 ASSERT_NO_FATAL_FAILURE(Validate()); 362 ASSERT_TRUE(called_); 363 EXPECT_EQ(expected_, problems_); 364 } 365 366 TEST_F(ValidationTaskTest, PostalCodeMatchingValue) { 367 json_[0] = "{\"fmt\":\"%Z\",\"zip\":\"\\\\d{3}\"}"; 368 json_[1] = "{\"zip\":\"1\"}"; 369 json_[2] = "{\"zip\":\"12\"}"; 370 json_[3] = "{\"zip\":\"123\"}"; 371 372 address_.region_code = "rrr"; 373 address_.postal_code = "123"; 374 375 ASSERT_NO_FATAL_FAILURE(Validate()); 376 ASSERT_TRUE(called_); 377 EXPECT_EQ(expected_, problems_); 378 } 379 380 TEST_F(ValidationTaskTest, PostalCodePrefixMismatchingValue) { 381 json_[0] = "{\"fmt\":\"%Z\",\"zip\":\"\\\\d{5}\"}"; 382 json_[1] = "{\"zip\":\"9[0-5]|96[01]\"}"; 383 384 address_.region_code = "rrr"; 385 address_.postal_code = "10960"; 386 387 expected_.insert(std::make_pair(POSTAL_CODE, MISMATCHING_VALUE)); 388 389 ASSERT_NO_FATAL_FAILURE(Validate()); 390 ASSERT_TRUE(called_); 391 EXPECT_EQ(expected_, problems_); 392 } 393 394 TEST_F(ValidationTaskTest, PostalCodeFilterIgnoresMismatching) { 395 json_[0] = "{\"zip\":\"\\\\d{3}\"}"; 396 json_[1] = "{\"zip\":\"1\"}"; 397 398 address_.region_code = "rrr"; 399 address_.postal_code = "000"; 400 401 filter_.erase(POSTAL_CODE); 402 filter_.insert(std::make_pair(POSTAL_CODE, INVALID_FORMAT)); 403 404 // (POSTAL_CODE, MISMATCHING_VALUE) should not be reported. 405 406 ASSERT_NO_FATAL_FAILURE(Validate()); 407 ASSERT_TRUE(called_); 408 EXPECT_EQ(expected_, problems_); 409 } 410 411 TEST_F(ValidationTaskTest, UsesPoBoxLanguageUnd) { 412 json_[0] = "{\"fmt\":\"%A\"}"; 413 414 address_.region_code = "rrr"; 415 address_.address_line.push_back("aaa"); 416 address_.address_line.push_back("P.O. Box"); 417 address_.address_line.push_back("aaa"); 418 419 expected_.insert(std::make_pair(STREET_ADDRESS, USES_P_O_BOX)); 420 421 ASSERT_NO_FATAL_FAILURE(Validate()); 422 ASSERT_TRUE(called_); 423 EXPECT_EQ(expected_, problems_); 424 } 425 426 TEST_F(ValidationTaskTest, UsesPoBoxLanguageDa) { 427 json_[0] = "{\"fmt\":\"%A\",\"languages\":\"da\"}"; 428 429 address_.region_code = "rrr"; 430 address_.address_line.push_back("aaa"); 431 address_.address_line.push_back("Postboks"); 432 address_.address_line.push_back("aaa"); 433 434 expected_.insert(std::make_pair(STREET_ADDRESS, USES_P_O_BOX)); 435 436 ASSERT_NO_FATAL_FAILURE(Validate()); 437 ASSERT_TRUE(called_); 438 EXPECT_EQ(expected_, problems_); 439 } 440 441 TEST_F(ValidationTaskTest, UsesPoBoxLanguageDaNotMatchDe) { 442 json_[0] = "{\"fmt\":\"%A\",\"languages\":\"da\"}"; 443 444 address_.region_code = "rrr"; 445 address_.address_line.push_back("aaa"); 446 address_.address_line.push_back("Postfach"); 447 address_.address_line.push_back("aaa"); 448 449 ASSERT_NO_FATAL_FAILURE(Validate()); 450 ASSERT_TRUE(called_); 451 EXPECT_EQ(expected_, problems_); 452 } 453 454 TEST_F(ValidationTaskTest, UsesPoBoxAllowPostal) { 455 json_[0] = "{\"fmt\":\"%A\"}"; 456 457 address_.region_code = "rrr"; 458 address_.address_line.push_back("aaa"); 459 address_.address_line.push_back("P.O. Box"); 460 address_.address_line.push_back("aaa"); 461 462 allow_postal_ = true; 463 464 ASSERT_NO_FATAL_FAILURE(Validate()); 465 ASSERT_TRUE(called_); 466 EXPECT_EQ(expected_, problems_); 467 } 468 469 } // namespace 470 } // namespace addressinput 471 } // namespace i18n 472
