@xenterprises/fastify-xgeocode 1.0.1

package/test/xGeocode.test.js

@@ -0,0 +1,901 @@
+import { test } from "node:test";
+import assert from "node:assert";
+import Fastify from "fastify";
+import xGeocode from "../src/xGeocode.js";
+
+test("xGeocode Plugin - registers successfully with apiKey", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+    assert.ok(true, "Plugin registered successfully");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Plugin - throws error when apiKey is missing", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await assert.rejects(
+      async () => await fastify.register(xGeocode, {}),
+      { message: /apiKey is required/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Plugin - can be disabled with active: false", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      active: false,
+      apiKey: "test-api-key"
+    });
+    assert.ok(!fastify.geocode, "Geocode decorator not added when disabled");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Plugin - provides xGeocode decorator", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+    assert.ok(fastify.xGeocode, "xGeocode decorator is available");
+    assert.ok(typeof fastify.xGeocode.getLatLongByZip === "function", "getLatLongByZip method exists");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Validation - rejects invalid zip code (too short)", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.getLatLongByZip("123"),
+      { message: /Invalid zip code format/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Validation - rejects invalid zip code (letters)", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.getLatLongByZip("1000A"),
+      { message: /Invalid zip code format/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Validation - accepts 5-digit zip code format", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch to avoid actual API call
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7506, lng: -73.9972 },
+          formatted_address: "New York, NY 10001",
+          address_components: {
+            city: "New York",
+            county: "New York County",
+            state: "NY",
+            country: "US",
+            zip: "10001"
+          }
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.getLatLongByZip("10001");
+      assert.ok(result, "Accepts valid 5-digit zip code");
+      assert.equal(result.zip, "10001", "Returns original zip code");
+      assert.equal(result.lat, 40.7506, "Returns latitude");
+      assert.equal(result.lng, -73.9972, "Returns longitude");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Validation - accepts 9-digit zip code (ZIP+4) format", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7506, lng: -73.9972 },
+          formatted_address: "New York, NY 10001-1234",
+          address_components: {
+            city: "New York",
+            county: "New York County",
+            state: "NY",
+            country: "US",
+            zip: "10001-1234"
+          }
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.getLatLongByZip("10001-1234");
+      assert.ok(result, "Accepts valid 9-digit zip code");
+      assert.equal(result.zip, "10001-1234", "Returns original zip code format");
+      assert.equal(result.lat, 40.7506, "Returns latitude");
+      assert.equal(result.lng, -73.9972, "Returns longitude");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Validation - rejects null or undefined zip code", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.getLatLongByZip(null),
+      { message: /Invalid input/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Error Handling - handles API errors gracefully", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch to return error status
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: false,
+      status: 401
+    });
+
+    try {
+      await assert.rejects(
+        () => fastify.xGeocode.getLatLongByZip("10001"),
+        { message: /Geocoding/ }
+      );
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Error Handling - handles empty results", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch to return empty results
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({ results: [] })
+    });
+
+    try {
+      await assert.rejects(
+        () => fastify.xGeocode.getLatLongByZip("99999"),
+        { message: /No results found/ }
+      );
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Response - returns complete location object", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7506, lng: -73.9972 },
+          formatted_address: "New York, NY 10001",
+          address_components: {
+            city: "New York",
+            county: "New York County",
+            state: "NY",
+            country: "US",
+            zip: "10001"
+          }
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.getLatLongByZip("10001");
+
+      assert.equal(result.zip, "10001", "Contains zip");
+      assert.equal(result.lat, 40.7506, "Contains latitude");
+      assert.equal(result.lng, -73.9972, "Contains longitude");
+      assert.equal(result.city, "New York", "Contains city");
+      assert.equal(result.county, "New York County", "Contains county");
+      assert.equal(result.state, "NY", "Contains state");
+      assert.equal(result.country, "US", "Contains country");
+      assert.ok(result.addressComponents, "Contains full address components");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Response - handles null address components gracefully", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch with missing address components
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7506, lng: -73.9972 },
+          address_components: {
+            city: undefined,
+            county: undefined,
+            state: "NY",
+            country: "US"
+          }
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.getLatLongByZip("10001");
+
+      assert.equal(result.city, null, "Missing city becomes null");
+      assert.equal(result.county, null, "Missing county becomes null");
+      assert.equal(result.state, "NY", "Present values preserved");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode Trim - trims whitespace from zip codes", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7506, lng: -73.9972 },
+          formatted_address: "New York, NY 10001",
+          address_components: {
+            city: "New York",
+            county: "New York County",
+            state: "NY",
+            country: "US",
+            zip: "10001"
+          }
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.getLatLongByZip("  10001  ");
+      assert.equal(result.zip, "10001", "Whitespace trimmed from result");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+// getLatLongByAddress() Tests
+test("xGeocode getLatLongByAddress - accepts valid address", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7128, lng: -74.0060 },
+          formatted_address: "123 Main St, New York, NY 10001",
+          address_components: {
+            city: "New York",
+            county: "New York County",
+            state: "NY",
+            country: "US",
+            zip: "10001"
+          }
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.getLatLongByAddress("123 Main St, New York, NY");
+      assert.ok(result, "Returns result for valid address");
+      assert.equal(result.lat, 40.7128, "Contains latitude");
+      assert.equal(result.lng, -74.0060, "Contains longitude");
+      assert.equal(result.city, "New York", "Contains city");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getLatLongByAddress - rejects address with less than 3 characters", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.getLatLongByAddress("12"),
+      { message: /minimum 3 characters/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getLatLongByAddress - rejects null address", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.getLatLongByAddress(null),
+      { message: /Invalid input/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getLatLongByAddress - trims whitespace from address", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7128, lng: -74.0060 },
+          formatted_address: "123 Main St, New York, NY 10001",
+          address_components: {
+            city: "New York",
+            county: "New York County",
+            state: "NY",
+            country: "US",
+            zip: "10001"
+          }
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.getLatLongByAddress("  123 Main St  ");
+      assert.ok(result, "Successfully processes address with whitespace");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+// getReverseGeocode() Tests
+test("xGeocode getReverseGeocode - accepts valid coordinates", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7128, lng: -74.0060 },
+          formatted_address: "123 Main St, New York, NY 10001",
+          address_components: {
+            city: "New York",
+            county: "New York County",
+            state: "NY",
+            country: "US",
+            zip: "10001"
+          }
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.getReverseGeocode(40.7128, -74.0060);
+      assert.ok(result, "Returns result for valid coordinates");
+      assert.equal(result.city, "New York", "Contains city");
+      assert.equal(result.state, "NY", "Contains state");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getReverseGeocode - rejects invalid latitude", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.getReverseGeocode(95, -74.0060),
+      { message: /Invalid latitude/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getReverseGeocode - rejects invalid longitude", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.getReverseGeocode(40.7128, -185),
+      { message: /Invalid longitude/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getReverseGeocode - rejects non-numeric coordinates", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.getReverseGeocode("invalid", "coordinates"),
+      { message: /must be numbers/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+// getDistance() Tests
+test("xGeocode getDistance - calculates distance between two points", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    const result = fastify.xGeocode.getDistance(40.7128, -74.0060, 40.7614, -73.9776);
+    assert.ok(result, "Returns distance result");
+    assert.ok(result.kilometers, "Contains kilometers");
+    assert.ok(result.miles, "Contains miles");
+    assert.ok(result.meters, "Contains meters");
+    assert.ok(result.kilometers > 0, "Distance is greater than zero");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getDistance - validates coordinate ranges", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    assert.throws(
+      () => fastify.xGeocode.getDistance(100, -74.0060, 40.7614, -73.9776),
+      { message: /Invalid latitude/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getDistance - handles string coordinates as numbers", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    const result = fastify.xGeocode.getDistance("40.7128", "-74.0060", "40.7614", "-73.9776");
+    assert.ok(result, "Accepts string coordinates that parse as numbers");
+    assert.ok(result.kilometers > 0, "Calculates valid distance");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode getDistance - rejects non-numeric coordinates", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    assert.throws(
+      () => fastify.xGeocode.getDistance("invalid", "-74.0060", "40.7614", "-73.9776"),
+      { message: /must be numbers/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+// batchGeocode() Tests
+test("xGeocode batchGeocode - processes array of locations", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch
+    const originalFetch = global.fetch;
+    global.fetch = async (url) => {
+      if (url.includes("10001")) {
+        return {
+          ok: true,
+          json: async () => ({
+            results: [{
+              location: { lat: 40.7506, lng: -73.9972 },
+              address_components: {
+                city: "New York",
+                county: "New York County",
+                state: "NY",
+                country: "US"
+              }
+            }]
+          })
+        };
+      }
+      return {
+        ok: true,
+        json: async () => ({
+          results: [{
+            location: { lat: 40.7128, lng: -74.0060 },
+            formatted_address: "123 Main St, New York, NY",
+            address_components: {
+              city: "New York",
+              county: "New York County",
+              state: "NY",
+              country: "US"
+            }
+          }]
+        })
+      };
+    };
+
+    try {
+      const result = await fastify.xGeocode.batchGeocode(["10001", "123 Main St"]);
+      assert.ok(Array.isArray(result), "Returns array");
+      assert.equal(result.length, 2, "Returns correct number of results");
+      assert.ok(result[0].lat, "First result has coordinates");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode batchGeocode - rejects non-array input", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.batchGeocode("not an array"),
+      { message: /locations must be an array/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode batchGeocode - rejects empty array", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.batchGeocode([]),
+      { message: /cannot be empty/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode batchGeocode - rejects batch exceeding 100 locations", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    const locations = Array(101).fill("10001");
+    await assert.rejects(
+      () => fastify.xGeocode.batchGeocode(locations),
+      { message: /cannot exceed 100/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode batchGeocode - handles per-item errors gracefully", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch to fail for specific items
+    const originalFetch = global.fetch;
+    global.fetch = async (url) => {
+      if (url.includes("invalid")) {
+        return {
+          ok: true,
+          json: async () => ({ results: [] })
+        };
+      }
+      return {
+        ok: true,
+        json: async () => ({
+          results: [{
+            location: { lat: 40.7506, lng: -73.9972 },
+            address_components: {
+              city: "New York",
+              county: "New York County",
+              state: "NY",
+              country: "US"
+            }
+          }]
+        })
+      };
+    };
+
+    try {
+      const result = await fastify.xGeocode.batchGeocode(["10001", "invalid", "10001"]);
+      assert.ok(Array.isArray(result), "Returns array even with errors");
+      assert.equal(result.length, 3, "Returns result for all items");
+      assert.ok(result[0].lat, "Successful items have coordinates");
+      assert.equal(result[1].success, false, "Failed items marked with success: false");
+      assert.ok(result[1].error, "Failed items have error message");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+// validateAddress() Tests
+test("xGeocode validateAddress - validates and returns formatted address", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        results: [{
+          location: { lat: 40.7128, lng: -74.0060 },
+          formatted_address: "123 Main Street, New York, NY 10001, USA",
+          address_components: {
+            city: "New York",
+            county: "New York County",
+            state: "NY",
+            country: "US",
+            zip: "10001"
+          },
+          accuracy: "rooftop"
+        }]
+      })
+    });
+
+    try {
+      const result = await fastify.xGeocode.validateAddress("123 Main St");
+      assert.ok(result, "Returns validation result");
+      assert.equal(result.valid, true, "Marks valid address as valid");
+      assert.equal(result.input, "123 Main St", "Returns original input");
+      assert.ok(result.formatted, "Returns formatted address");
+      assert.ok(result.confidence, "Returns confidence/accuracy");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode validateAddress - returns invalid for unrecognized address", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch to return empty results
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({ results: [] })
+    });
+
+    try {
+      const result = await fastify.xGeocode.validateAddress("completely invalid address");
+      assert.equal(result.valid, false, "Marks unrecognized address as invalid");
+      assert.equal(result.input, "completely invalid address", "Returns original input");
+      assert.ok(result.error, "Returns error message");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode validateAddress - handles API errors gracefully", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    // Mock fetch to return error status
+    const originalFetch = global.fetch;
+    global.fetch = async () => ({
+      ok: false,
+      status: 500
+    });
+
+    try {
+      const result = await fastify.xGeocode.validateAddress("123 Main St");
+      assert.equal(result.valid, false, "Marks API errors as invalid");
+      assert.ok(result.error, "Returns error message");
+    } finally {
+      global.fetch = originalFetch;
+    }
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode validateAddress - rejects address with less than 3 characters", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.validateAddress("ab"),
+      { message: /minimum 3 characters/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xGeocode validateAddress - rejects null address", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xGeocode, {
+      apiKey: "test-api-key"
+    });
+
+    await assert.rejects(
+      () => fastify.xGeocode.validateAddress(null),
+      { message: /Invalid input/ }
+    );
+  } finally {
+    await fastify.close();
+  }
+});