Rebuilt Bolivia countryData and added a test for the postal code handler function

CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+### Fixed
+
+- Bolivia province and municipality list aligned with INE 2024 Census data.
+
+### Changed
+
+- Geolocation postal code lookup for BOL, COL, CRI, PER, and CHL now uses shared `createPostalCodeFromHierarchyHandler` transform.
+
+### Added
+
+- Test for the postal code handler function.
+
 ## [4.28.0] - 2025-12-09
 
 ### Added

react/__tests__/geolocationPostalCodeHandler.test.js

@@ -0,0 +1,68 @@
+import BOL from '../country/BOL'
+import {
+  buildAddress,
+  getAlternateHierarchySample,
+  getHierarchySample,
+} from './helpers/geolocationPostalCodeHandler'
+
+describe('BOL geolocation postalCode handler', () => {
+  const rules = BOL
+  const handler = rules.geolocation.postalCode.handler
+  const sample = getHierarchySample(rules)
+  const levels = rules.postalCodeLevels
+  const lastLevel = levels[levels.length - 1]
+
+  it('sets postalCode from the selected administrative hierarchy', () => {
+    const address = buildAddress(sample.values)
+    const result = handler(address, {}, 0)
+
+    expect(result.postalCode).toEqual({ value: sample.expectedPostal })
+  })
+
+  it('returns the address unchanged when a required hierarchy field is empty', () => {
+    const address = buildAddress(sample.values, lastLevel)
+    const result = handler(address, {}, 0)
+
+    expect(result).toBe(address)
+    expect(result.postalCode).toBeUndefined()
+  })
+
+  it('returns the address unchanged when the deepest level is not in countryData', () => {
+    const invalidValues = {
+      ...sample.values,
+      [lastLevel]: 'Unknown Administrative Unit',
+    }
+    const address = buildAddress(invalidValues)
+    const result = handler(address, {}, 0)
+
+    expect(result).toBe(address)
+    expect(result.postalCode).toBeUndefined()
+  })
+
+  const alternateSample = getAlternateHierarchySample(rules)
+
+  it('resolves postalCode using the full hierarchy path', () => {
+    expect(alternateSample).not.toBeNull()
+
+    const firstResult = handler(
+      buildAddress(alternateSample.first.values),
+      {},
+      0
+    )
+    const secondResult = handler(
+      buildAddress(alternateSample.second.values),
+      {},
+      0
+    )
+
+    expect(firstResult.postalCode).toEqual({
+      value: alternateSample.first.expectedPostal,
+    })
+    expect(secondResult.postalCode).toEqual({
+      value: alternateSample.second.expectedPostal,
+    })
+    expect(firstResult.postalCode.value).not.toBe(
+      secondResult.postalCode.value
+    )
+  })
+})

react/__tests__/helpers/geolocationPostalCodeHandler.js

@@ -0,0 +1,143 @@
+export function buildAddress(values, emptyField) {
+  const address = {}
+
+  Object.keys(values).forEach((field) => {
+    const value = values[field]
+
+    if (field === emptyField || value == null) {
+      address[field] = {}
+
+      return
+    }
+
+    address[field] = { value }
+  })
+
+  return address
+}
+
+export function getHierarchySample(rules) {
+  const levels = rules.postalCodeLevels
+
+  if (!levels || !levels.length) {
+    return null
+  }
+
+  if (rules.thirdLevelPostalCodes) {
+    const [firstLevel, secondLevels] =
+      Object.entries(rules.thirdLevelPostalCodes)[0] || []
+
+    if (!firstLevel || !secondLevels) {
+      return null
+    }
+
+    const [secondLevel, entries] = Object.entries(secondLevels)[0] || []
+    const entry = entries && entries[0]
+
+    if (!secondLevel || !entry) {
+      return null
+    }
+
+    return {
+      values: {
+        [levels[0]]: firstLevel,
+        [levels[1]]: secondLevel,
+        [levels[2]]: entry.label,
+      },
+      expectedPostal: entry.postalCode,
+    }
+  }
+
+  if (rules.secondLevelPostalCodes) {
+    const [firstLevel, entries] =
+      Object.entries(rules.secondLevelPostalCodes)[0] || []
+    const entry = entries && entries[0]
+
+    if (!firstLevel || !entry || levels.length !== 2) {
+      return null
+    }
+
+    return {
+      values: {
+        [levels[0]]: firstLevel,
+        [levels[1]]: entry.label,
+      },
+      expectedPostal: entry.postalCode,
+    }
+  }
+
+  return null
+}
+
+export function getAlternateHierarchySample(rules) {
+  const levels = rules.postalCodeLevels
+
+  if (!rules.thirdLevelPostalCodes || !levels || levels.length !== 3) {
+    return null
+  }
+
+  const [firstLevel, secondLevels] =
+    Object.entries(rules.thirdLevelPostalCodes)[0] || []
+
+  if (!firstLevel || !secondLevels) {
+    return null
+  }
+
+  const provinceEntries = Object.entries(secondLevels)
+
+  const toSample = (province, entry) => ({
+    values: {
+      [levels[0]]: firstLevel,
+      [levels[1]]: province,
+      [levels[2]]: entry.label,
+    },
+    expectedPostal: entry.postalCode,
+  })
+
+  for (let p = 0; p < provinceEntries.length; p++) {
+    for (let q = p + 1; q < provinceEntries.length; q++) {
+      const [firstProvince, firstEntries] = provinceEntries[p]
+      const [secondProvince, secondEntries] = provinceEntries[q]
+
+      for (let i = 0; i < firstEntries.length; i++) {
+        for (let j = 0; j < secondEntries.length; j++) {
+          const firstEntry = firstEntries[i]
+          const secondEntry = secondEntries[j]
+
+          if (firstEntry.postalCode !== secondEntry.postalCode) {
+            return {
+              first: toSample(firstProvince, firstEntry),
+              second: toSample(secondProvince, secondEntry),
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const candidates = []
+
+  for (let p = 0; p < provinceEntries.length; p++) {
+    const [province, entries] = provinceEntries[p]
+
+    for (let i = 0; i < entries.length; i++) {
+      candidates.push({ province, entry: entries[i] })
+    }
+  }
+
+  for (let i = 0; i < candidates.length; i++) {
+    for (let j = i + 1; j < candidates.length; j++) {
+      const first = candidates[i]
+      const second = candidates[j]
+
+      if (first.entry.postalCode !== second.entry.postalCode) {
+        return {
+          first: toSample(first.province, first.entry),
+          second: toSample(second.province, second.entry),
+        }
+      }
+    }
+  }
+
+  return null
+}