From e9db41735f7199d61f035061add72425593c9005 Mon Sep 17 00:00:00 2001
From: Julien Vannier <julien.vannier66@gmail.com>
Date: Tue, 3 Feb 2026 16:32:54 +0100
Subject: [PATCH 1/2] Add new autocomplete-handler service & tests

---
 .../services/autocomplete-handler.ts          | 14 ++++
 addon/modifiers/setup-autocomplete.ts         | 25 +++----
 addon/services/autocomplete-handler.ts        | 25 +++++++
 app/services/autocomplete-handler.js          |  1 +
 tests/dummy/config/environment.js             |  1 +
 .../components/http-errors-code-test.ts       |  1 -
 .../components/utils/address-form-test.ts     |  3 +
 .../components/utils/address-inline-test.ts   |  3 +
 .../modifiers/setup-autocomplete-test.ts      | 42 +++++------
 .../services/autocomplete-handler-test.ts     | 70 +++++++++++++++++++
 10 files changed, 146 insertions(+), 39 deletions(-)
 create mode 100644 addon-test-support/services/autocomplete-handler.ts
 create mode 100644 addon/services/autocomplete-handler.ts
 create mode 100644 app/services/autocomplete-handler.js
 create mode 100644 tests/unit/services/autocomplete-handler-test.ts

diff --git a/addon-test-support/services/autocomplete-handler.ts b/addon-test-support/services/autocomplete-handler.ts
new file mode 100644
index 00000000..100a4045
--- /dev/null
+++ b/addon-test-support/services/autocomplete-handler.ts
@@ -0,0 +1,14 @@
+import Service from '@ember/service';
+
+import { AutocompleteHandlerInterface } from '@upfluence/ember-upf-utils/services/autocomplete-handler';
+import { MockLoader } from '@upfluence/ember-upf-utils/utils/google-maps-mock';
+
+class AutocompleteHandlerServiceMock extends Service implements AutocompleteHandlerInterface {
+  private mockLoader: MockLoader = new MockLoader({ apiKey: 'test-key' });
+
+  getLoader(): MockLoader {
+    return this.mockLoader;
+  }
+}
+
+export { AutocompleteHandlerServiceMock };
diff --git a/addon/modifiers/setup-autocomplete.ts b/addon/modifiers/setup-autocomplete.ts
index 7537ba2c..a6151929 100644
--- a/addon/modifiers/setup-autocomplete.ts
+++ b/addon/modifiers/setup-autocomplete.ts
@@ -1,14 +1,13 @@
 import Modifier, { type ArgsFor, type PositionalArgs, type NamedArgs } from 'ember-modifier';
 import { registerDestructor } from '@ember/destroyable';
 import { assert } from '@ember/debug';
-import { getOwner } from '@ember/application';
-import { isTesting } from '@embroider/macros';
-
-import { Loader } from '@googlemaps/js-api-loader';
+import { inject as service } from '@ember/service';
 
 import { parseAddressComponents } from '@upfluence/ember-upf-utils/utils/address-parser';
-import { MockLoader } from '@upfluence/ember-upf-utils/utils/google-maps-mock';
 import { CountryData } from '@upfluence/oss-components/utils/country-codes';
+import type AutocompleteHandlerService from '@upfluence/ember-upf-utils/services/autocomplete-handler';
+
+import { Loader } from '@googlemaps/js-api-loader';
 
 type GooglePlaceResult = google.maps.places.PlaceResult;
 type GoogleAutocomplete = google.maps.places.Autocomplete;
@@ -28,7 +27,6 @@ interface SetupAutocompleteSignature {
   Args: {
     Named: {
       callback(result: AutocompletionAddress): void;
-      loader?: Loader;
     };
   };
 }
@@ -57,6 +55,8 @@ function cleanup(instance: SetupAutocompleteModifier): void {
 }
 
 export default class SetupAutocompleteModifier extends Modifier<SetupAutocompleteSignature> {
+  @service declare autocompleteHandler: AutocompleteHandlerService;
+
   targetElement: HTMLElement | null = null;
   targetInput: HTMLInputElement | null = null;
   result: AutocompletionAddress | null = null;
@@ -72,7 +72,7 @@ export default class SetupAutocompleteModifier extends Modifier<SetupAutocomplet
   modify(
     element: HTMLElement,
     _: PositionalArgs<SetupAutocompleteSignature>,
-    { callback, loader }: NamedArgs<SetupAutocompleteSignature>
+    { callback }: NamedArgs<SetupAutocompleteSignature>
   ): void {
     const input: HTMLInputElement | null = this.getInputElement(element);
     if (!input) return;
@@ -87,7 +87,7 @@ export default class SetupAutocompleteModifier extends Modifier<SetupAutocomplet
 
     if (!this.targetElement) {
       this.setupTargetElement(element, input);
-      this.setupAutoComplete(loader);
+      this.setupAutoComplete();
     }
   }
 
@@ -134,13 +134,8 @@ export default class SetupAutocompleteModifier extends Modifier<SetupAutocomplet
     return element.tagName === 'INPUT' && (element as HTMLInputElement).type === 'text';
   }
 
-  private setupAutoComplete(loader?: Loader): Promise<void> {
-    const loaderInstance: Loader | MockLoader = isTesting()
-      ? loader ?? new MockLoader({ apiKey: 'test-key' })
-      : new Loader({
-          apiKey: getOwner(this).resolveRegistration('config:environment').google_map_api_key,
-          version: 'weekly'
-        });
+  private setupAutoComplete(): Promise<void> {
+    const loaderInstance: Loader = this.autocompleteHandler.getLoader();
 
     // @ts-ignore
     return loaderInstance.importLibrary('places').then(({ Autocomplete }: google.maps.PlacesLibrary) => {
diff --git a/addon/services/autocomplete-handler.ts b/addon/services/autocomplete-handler.ts
new file mode 100644
index 00000000..e0096c90
--- /dev/null
+++ b/addon/services/autocomplete-handler.ts
@@ -0,0 +1,25 @@
+import Service from '@ember/service';
+import { getOwner } from '@ember/application';
+
+import { MockLoader } from '@upfluence/ember-upf-utils/utils/google-maps-mock';
+
+import { Loader } from '@googlemaps/js-api-loader';
+
+export interface AutocompleteHandlerInterface {
+  getLoader(): Loader | MockLoader;
+}
+
+export default class AutocompleteHandler extends Service implements AutocompleteHandlerInterface {
+  getLoader(): Loader {
+    return new Loader({
+      apiKey: getOwner(this).resolveRegistration('config:environment').google_map_api_key,
+      version: 'weekly'
+    });
+  }
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    'autocomplete-handler': AutocompleteHandler;
+  }
+}
diff --git a/app/services/autocomplete-handler.js b/app/services/autocomplete-handler.js
new file mode 100644
index 00000000..4c6330c5
--- /dev/null
+++ b/app/services/autocomplete-handler.js
@@ -0,0 +1 @@
+export { default } from '@upfluence/ember-upf-utils/services/autocomplete-handler';
diff --git a/tests/dummy/config/environment.js b/tests/dummy/config/environment.js
index bd4ae7b8..5b04fd28 100644
--- a/tests/dummy/config/environment.js
+++ b/tests/dummy/config/environment.js
@@ -42,6 +42,7 @@ module.exports = function (environment) {
 
     ENV.APP.rootElement = '#ember-testing';
     ENV.APP.autoboot = false;
+    ENV.google_map_api_key = 'foobar';
   }
 
   if (environment === 'production') {
diff --git a/tests/integration/components/http-errors-code-test.ts b/tests/integration/components/http-errors-code-test.ts
index 09c6fe84..381abd8f 100644
--- a/tests/integration/components/http-errors-code-test.ts
+++ b/tests/integration/components/http-errors-code-test.ts
@@ -3,7 +3,6 @@ import { setupRenderingTest } from 'ember-qunit';
 import { click, render } from '@ember/test-helpers';
 import { hbs } from 'ember-cli-htmlbars';
 import Service from '@ember/service';
-// @ts-ignore
 import { setupIntl } from 'ember-intl/test-support';
 import sinon from 'sinon';
 
diff --git a/tests/integration/components/utils/address-form-test.ts b/tests/integration/components/utils/address-form-test.ts
index e8f4dbd2..1741d126 100644
--- a/tests/integration/components/utils/address-form-test.ts
+++ b/tests/integration/components/utils/address-form-test.ts
@@ -6,11 +6,14 @@ import EmberObject from '@ember/object';
 import { click, fillIn, findAll, render, typeIn } from '@ember/test-helpers';
 import sinon from 'sinon';
 
+import { AutocompleteHandlerServiceMock } from '@upfluence/ember-upf-utils/test-support/services/autocomplete-handler';
+
 module('Integration | Component | utils/address-form', function (hooks) {
   setupRenderingTest(hooks);
   setupIntl(hooks);
 
   hooks.beforeEach(function () {
+    this.owner.register('service:autocomplete-handler', AutocompleteHandlerServiceMock);
     this.address = EmberObject.create({
       firstName: 'iam',
       lastName: 'groot',
diff --git a/tests/integration/components/utils/address-inline-test.ts b/tests/integration/components/utils/address-inline-test.ts
index aba351b1..77949913 100644
--- a/tests/integration/components/utils/address-inline-test.ts
+++ b/tests/integration/components/utils/address-inline-test.ts
@@ -6,11 +6,14 @@ import EmberObject from '@ember/object';
 import { render, typeIn } from '@ember/test-helpers';
 import sinon from 'sinon';
 
+import { AutocompleteHandlerServiceMock } from '@upfluence/ember-upf-utils/test-support/services/autocomplete-handler';
+
 module('Integration | Component | utils/address-inline', function (hooks) {
   setupRenderingTest(hooks);
   setupIntl(hooks);
 
   hooks.beforeEach(function () {
+    this.owner.register('service:autocomplete-handler', AutocompleteHandlerServiceMock);
     this.address = EmberObject.create({
       address: '123 Main St',
       resolved_address: null
diff --git a/tests/integration/modifiers/setup-autocomplete-test.ts b/tests/integration/modifiers/setup-autocomplete-test.ts
index 852213c0..bf0b5462 100644
--- a/tests/integration/modifiers/setup-autocomplete-test.ts
+++ b/tests/integration/modifiers/setup-autocomplete-test.ts
@@ -6,22 +6,22 @@ import { type AutocompletionAddress } from '@upfluence/ember-upf-utils/modifiers
 
 import {
   createMockPlaceResult,
-  createSampleAddressComponents,
-  MockLoader
+  createSampleAddressComponents
 } from '@upfluence/ember-upf-utils/utils/google-maps-mock';
+import { AutocompleteHandlerServiceMock } from '@upfluence/ember-upf-utils/test-support/services/autocomplete-handler';
 
 module('Integration | Modifier | setup-autocomplete', function (hooks) {
   setupRenderingTest(hooks);
 
   hooks.beforeEach(function () {
-    this.mockLoader = new MockLoader({ apiKey: 'test-key' });
+    this.owner.register('service:autocomplete-handler', AutocompleteHandlerServiceMock);
+    const service = this.owner.lookup('service:autocomplete-handler');
+    this.mockLoader = service.getLoader();
   });
 
   module('Element setup', () => {
     test('it works with a text input element directly', async function (assert) {
-      await render(
-        hbs`<div><input type="text" {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}} /></div>`
-      );
+      await render(hbs`<div><input type="text" {{setup-autocomplete callback=(fn (mut this.result))}} /></div>`);
 
       assert.dom('input[type="text"]').exists();
       const input = find('input[type="text"]');
@@ -30,7 +30,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
 
     test('it works with input inside a container element', async function (assert) {
       await render(hbs`
-        <div {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}}>
+        <div {{setup-autocomplete callback=(fn (mut this.result))}}>
           <input type="text" />
         </div>
       `);
@@ -49,7 +49,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
       };
 
       await render(hbs`
-        <div><input type="text" {{setup-autocomplete callback=this.handleAddress loader=this.mockLoader}} /></div>
+        <div><input type="text" {{setup-autocomplete callback=this.handleAddress}} /></div>
       `);
 
       const mockAutocomplete = this.mockLoader.getMockAutocompleteInstance();
@@ -71,7 +71,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
       };
 
       await render(hbs`
-        <input type="text" {{setup-autocomplete callback=this.handleAddress loader=this.mockLoader}} />
+        <input type="text" {{setup-autocomplete callback=this.handleAddress}} />
       `);
 
       const mockAutocomplete = this.mockLoader.getMockAutocompleteInstance();
@@ -84,7 +84,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
   module('Cleanup', () => {
     test('pac-container is removed on teardown', async function (assert) {
       await render(hbs`
-        <input type="text" {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}} />
+        <input type="text" {{setup-autocomplete callback=(fn (mut this.result))}} />
       `);
 
       const pacContainer = document.createElement('div');
@@ -100,7 +100,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
 
     test('wrapper is properly unwrapped during cleanup', async function (assert) {
       await render(
-        hbs`<div><input type="text" id="test-input" {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}} /></div>`
+        hbs`<div><input type="text" id="test-input" {{setup-autocomplete callback=(fn (mut this.result))}} /></div>`
       );
 
       assert.dom('#test-input').exists();
@@ -117,9 +117,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
     });
 
     test('cleanup handles already removed elements gracefully', async function (assert) {
-      await render(
-        hbs`<div><input type="text" {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}} /></div>`
-      );
+      await render(hbs`<div><input type="text" {{setup-autocomplete callback=(fn (mut this.result))}} /></div>`);
 
       assert.dom('input[type="text"]').exists();
       const input = find('input[type="text"]');
@@ -135,7 +133,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
 
     test('wrapper is not created when modifier is on container element', async function (assert) {
       await render(hbs`
-        <div {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}}>
+        <div {{setup-autocomplete callback=(fn (mut this.result))}}>
           <input type="text" id="container-input" />
         </div>
       `);
@@ -156,7 +154,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
       this.value = '123 Main Street';
 
       await render(hbs`
-        <input type="text" value={{this.value}} {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}} />
+        <input type="text" value={{this.value}} {{setup-autocomplete callback=(fn (mut this.result))}} />
       `);
 
       assert.dom('input[type="text"]').hasValue('123 Main Street');
@@ -169,7 +167,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
           id="address-input"
           class="custom-input"
           placeholder="Enter address"
-          {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}} 
+          {{setup-autocomplete callback=(fn (mut this.result))}} 
         />
       `);
 
@@ -189,7 +187,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
       };
 
       await render(hbs`
-        <input type="text" {{setup-autocomplete callback=this.handleAddress loader=this.mockLoader}} />
+        <input type="text" {{setup-autocomplete callback=this.handleAddress}} />
       `);
 
       const mockAutocomplete = this.mockLoader.getMockAutocompleteInstance();
@@ -215,7 +213,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
           );
         });
 
-        await render(hbs`<div><input type="text" {{setup-autocomplete loader=this.mockLoader}} /></div>`);
+        await render(hbs`<div><input type="text" {{setup-autocomplete}} /></div>`);
       });
 
       test('handles missing input element gracefully', async function (assert) {
@@ -227,7 +225,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
           );
         });
 
-        await render(hbs`<div {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}}></div>`);
+        await render(hbs`<div {{setup-autocomplete callback=(fn (mut this.result))}}></div>`);
       });
 
       test('handles missing input element in its children gracefully', async function (assert) {
@@ -239,9 +237,7 @@ module('Integration | Modifier | setup-autocomplete', function (hooks) {
           );
         });
 
-        await render(
-          hbs`<div {{setup-autocomplete callback=(fn (mut this.result)) loader=this.mockLoader}}><div></div></div>`
-        );
+        await render(hbs`<div {{setup-autocomplete callback=(fn (mut this.result))}}><div></div></div>`);
       });
     });
   });
diff --git a/tests/unit/services/autocomplete-handler-test.ts b/tests/unit/services/autocomplete-handler-test.ts
new file mode 100644
index 00000000..ac44bc56
--- /dev/null
+++ b/tests/unit/services/autocomplete-handler-test.ts
@@ -0,0 +1,70 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+import AutocompleteHandlerService from '@upfluence/ember-upf-utils/services/autocomplete-handler';
+import { AutocompleteHandlerServiceMock } from '@upfluence/ember-upf-utils/test-support/services/autocomplete-handler';
+
+module('Unit | Service | autocomplete-handler', function (hooks) {
+  setupTest(hooks);
+
+  module('Production service', function () {
+    test('it exists', function (assert) {
+      const service = this.owner.lookup('service:autocomplete-handler');
+
+      assert.ok(service);
+      assert.true(service instanceof AutocompleteHandlerService);
+    });
+
+    test('getLoader returns a Loader instance', function (assert) {
+      const service = this.owner.lookup('service:autocomplete-handler') as AutocompleteHandlerService;
+      const loader = service.getLoader();
+
+      assert.ok(loader);
+    });
+
+    test('Loader is configured with API key from environment', function (assert) {
+      const service = this.owner.lookup('service:autocomplete-handler') as AutocompleteHandlerService;
+      const loader = service.getLoader();
+
+      assert.ok(loader);
+      assert.strictEqual((loader as any).options.version, 'weekly');
+      assert.strictEqual((loader as any).options.apiKey, 'foobar');
+    });
+  });
+
+  module('Test service', function (hooks) {
+    hooks.beforeEach(function () {
+      this.owner.register('service:autocomplete-handler', AutocompleteHandlerServiceMock);
+    });
+
+    test('it exists', function (assert) {
+      const service = this.owner.lookup('service:autocomplete-handler');
+
+      assert.ok(service);
+      assert.true(service instanceof AutocompleteHandlerServiceMock);
+    });
+
+    test('getLoader returns a MockLoader instance', function (assert) {
+      const service = this.owner.lookup('service:autocomplete-handler') as AutocompleteHandlerServiceMock;
+      const loader = service.getLoader();
+
+      assert.ok(loader);
+    });
+
+    test('MockLoader importLibrary returns places library', async function (assert) {
+      const service = this.owner.lookup('service:autocomplete-handler') as AutocompleteHandlerServiceMock;
+      const loader = service.getLoader();
+      const placesLib = await loader.importLibrary('places');
+
+      assert.ok(placesLib);
+      assert.ok(placesLib.Autocomplete);
+    });
+
+    test('MockLoader can be accessed for test assertions', function (assert) {
+      const service = this.owner.lookup('service:autocomplete-handler') as AutocompleteHandlerServiceMock;
+      const mockLoader = service.getLoader();
+
+      assert.ok(mockLoader.getMockAutocompleteInstance);
+    });
+  });
+});

From 0bf64f2594ef4ea5a4da74e1f761937796e50553 Mon Sep 17 00:00:00 2001
From: Julien Vannier <julien.vannier66@gmail.com>
Date: Thu, 5 Feb 2026 17:59:56 +0100
Subject: [PATCH 2/2] Move google-maps-mock classes and function into test
 support

---
 .../services/autocomplete-handler.ts          | 174 +++++++++++++++++-
 addon/services/autocomplete-handler.ts        |   8 +-
 addon/utils/google-maps-mock.ts               | 160 ----------------
 .../modifiers/setup-autocomplete-test.ts      |   2 +-
 tests/unit/utils/address-parser-test.ts       |   2 +-
 5 files changed, 175 insertions(+), 171 deletions(-)
 delete mode 100644 addon/utils/google-maps-mock.ts

diff --git a/addon-test-support/services/autocomplete-handler.ts b/addon-test-support/services/autocomplete-handler.ts
index 100a4045..929945dc 100644
--- a/addon-test-support/services/autocomplete-handler.ts
+++ b/addon-test-support/services/autocomplete-handler.ts
@@ -1,9 +1,19 @@
 import Service from '@ember/service';
 
-import { AutocompleteHandlerInterface } from '@upfluence/ember-upf-utils/services/autocomplete-handler';
-import { MockLoader } from '@upfluence/ember-upf-utils/utils/google-maps-mock';
+import { AutocompleteHandlerBase } from '@upfluence/ember-upf-utils/services/autocomplete-handler';
 
-class AutocompleteHandlerServiceMock extends Service implements AutocompleteHandlerInterface {
+type MockGoogleAddressComponent = {
+  types: string[];
+  long_name: string;
+  short_name: string;
+};
+
+type MockPlaceResult = {
+  address_components?: MockGoogleAddressComponent[];
+  formatted_address?: string;
+};
+
+class AutocompleteHandlerServiceMock extends Service implements AutocompleteHandlerBase<MockLoader> {
   private mockLoader: MockLoader = new MockLoader({ apiKey: 'test-key' });
 
   getLoader(): MockLoader {
@@ -11,4 +21,160 @@ class AutocompleteHandlerServiceMock extends Service implements AutocompleteHand
   }
 }
 
-export { AutocompleteHandlerServiceMock };
+class MockAutocomplete {
+  private listeners: Map<string, Function[]> = new Map();
+  private mockPlace: MockPlaceResult = {};
+
+  constructor(public input: HTMLInputElement, public options?: Record<string, any>) {}
+
+  addListener(eventName: string, handler: Function): void {
+    if (!this.listeners.has(eventName)) {
+      this.listeners.set(eventName, []);
+    }
+    this.listeners.get(eventName)!.push(handler);
+  }
+
+  getPlace(): MockPlaceResult {
+    return this.mockPlace;
+  }
+
+  setPlace(place: MockPlaceResult): void {
+    this.mockPlace = place;
+  }
+
+  triggerEvent(eventName: string): void {
+    const handlers = this.listeners.get(eventName) || [];
+    handlers.forEach((handler) => handler());
+  }
+
+  simulatePlaceSelection(place: MockPlaceResult): void {
+    this.setPlace(place);
+    this.triggerEvent('place_changed');
+  }
+}
+
+class MockLoader {
+  private mockAutocompleteInstance: MockAutocomplete | null = null;
+
+  constructor(public config?: Record<string, any>) {}
+
+  async importLibrary(libraryName: string): Promise<any> {
+    if (libraryName === 'places') {
+      const self = this;
+      return {
+        Autocomplete: class {
+          constructor(input: HTMLInputElement, options?: Record<string, any>) {
+            self.mockAutocompleteInstance = new MockAutocomplete(input, options);
+            return self.mockAutocompleteInstance;
+          }
+        }
+      };
+    }
+    return {};
+  }
+
+  getMockAutocompleteInstance(): MockAutocomplete | null {
+    return this.mockAutocompleteInstance;
+  }
+}
+
+function createSampleAddressComponents(
+  overrides: Partial<{
+    streetNumber: string;
+    route: string;
+    subpremise: string;
+    city: string;
+    state: string;
+    zipcode: string;
+    country: string;
+    countryCode: string;
+  }>
+): MockGoogleAddressComponent[] {
+  const defaults = {
+    streetNumber: '1600',
+    route: 'Amphitheatre Parkway',
+    subpremise: '',
+    city: 'Mountain View',
+    state: 'California',
+    zipcode: '94043',
+    country: 'United States',
+    countryCode: 'US'
+  };
+
+  const values = { ...defaults, ...overrides };
+  const components: MockGoogleAddressComponent[] = [];
+
+  if (values.streetNumber) {
+    components.push({
+      types: ['street_number'],
+      long_name: values.streetNumber,
+      short_name: values.streetNumber
+    });
+  }
+
+  if (values.route) {
+    components.push({
+      types: ['route'],
+      long_name: values.route,
+      short_name: values.route
+    });
+  }
+
+  if (values.subpremise) {
+    components.push({
+      types: ['subpremise'],
+      long_name: values.subpremise,
+      short_name: values.subpremise
+    });
+  }
+
+  if (values.city) {
+    components.push({
+      types: ['locality'],
+      long_name: values.city,
+      short_name: values.city
+    });
+  }
+
+  if (values.state) {
+    components.push({
+      types: ['administrative_area_level_1'],
+      long_name: values.state,
+      short_name: values.state
+    });
+  }
+
+  if (values.zipcode) {
+    components.push({
+      types: ['postal_code'],
+      long_name: values.zipcode,
+      short_name: values.zipcode
+    });
+  }
+
+  components.push({
+    types: ['country'],
+    long_name: values.country,
+    short_name: values.countryCode
+  });
+
+  return components;
+}
+
+function createMockPlaceResult(
+  addressComponents: MockGoogleAddressComponent[],
+  formattedAddress?: string
+): MockPlaceResult {
+  return {
+    address_components: addressComponents,
+    formatted_address: formattedAddress
+  };
+}
+
+export {
+  AutocompleteHandlerServiceMock,
+  MockAutocomplete,
+  MockLoader,
+  createSampleAddressComponents,
+  createMockPlaceResult
+};
diff --git a/addon/services/autocomplete-handler.ts b/addon/services/autocomplete-handler.ts
index e0096c90..7c663bbc 100644
--- a/addon/services/autocomplete-handler.ts
+++ b/addon/services/autocomplete-handler.ts
@@ -1,15 +1,13 @@
 import Service from '@ember/service';
 import { getOwner } from '@ember/application';
 
-import { MockLoader } from '@upfluence/ember-upf-utils/utils/google-maps-mock';
-
 import { Loader } from '@googlemaps/js-api-loader';
 
-export interface AutocompleteHandlerInterface {
-  getLoader(): Loader | MockLoader;
+export interface AutocompleteHandlerBase<T> {
+  getLoader(): T;
 }
 
-export default class AutocompleteHandler extends Service implements AutocompleteHandlerInterface {
+export default class AutocompleteHandler extends Service implements AutocompleteHandlerBase<Loader> {
   getLoader(): Loader {
     return new Loader({
       apiKey: getOwner(this).resolveRegistration('config:environment').google_map_api_key,
diff --git a/addon/utils/google-maps-mock.ts b/addon/utils/google-maps-mock.ts
deleted file mode 100644
index b654971a..00000000
--- a/addon/utils/google-maps-mock.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-export type MockGoogleAddressComponent = {
-  types: string[];
-  long_name: string;
-  short_name: string;
-};
-
-export type MockPlaceResult = {
-  address_components?: MockGoogleAddressComponent[];
-  formatted_address?: string;
-};
-
-export class MockAutocomplete {
-  private listeners: Map<string, Function[]> = new Map();
-  private mockPlace: MockPlaceResult = {};
-
-  constructor(public input: HTMLInputElement, public options?: Record<string, any>) {}
-
-  addListener(eventName: string, handler: Function): void {
-    if (!this.listeners.has(eventName)) {
-      this.listeners.set(eventName, []);
-    }
-    this.listeners.get(eventName)!.push(handler);
-  }
-
-  getPlace(): MockPlaceResult {
-    return this.mockPlace;
-  }
-
-  setPlace(place: MockPlaceResult): void {
-    this.mockPlace = place;
-  }
-
-  triggerEvent(eventName: string): void {
-    const handlers = this.listeners.get(eventName) || [];
-    handlers.forEach((handler) => handler());
-  }
-
-  simulatePlaceSelection(place: MockPlaceResult): void {
-    this.setPlace(place);
-    this.triggerEvent('place_changed');
-  }
-}
-
-export class MockLoader {
-  private mockAutocompleteInstance: MockAutocomplete | null = null;
-
-  constructor(public config?: Record<string, any>) {}
-
-  async importLibrary(libraryName: string): Promise<any> {
-    if (libraryName === 'places') {
-      const self = this;
-      return {
-        Autocomplete: class {
-          constructor(input: HTMLInputElement, options?: Record<string, any>) {
-            self.mockAutocompleteInstance = new MockAutocomplete(input, options);
-            return self.mockAutocompleteInstance;
-          }
-        }
-      };
-    }
-    return {};
-  }
-
-  getMockAutocompleteInstance(): MockAutocomplete | null {
-    return this.mockAutocompleteInstance;
-  }
-}
-
-export function createSampleAddressComponents(
-  overrides: Partial<{
-    streetNumber: string;
-    route: string;
-    subpremise: string;
-    city: string;
-    state: string;
-    zipcode: string;
-    country: string;
-    countryCode: string;
-  }>
-): MockGoogleAddressComponent[] {
-  const defaults = {
-    streetNumber: '1600',
-    route: 'Amphitheatre Parkway',
-    subpremise: '',
-    city: 'Mountain View',
-    state: 'California',
-    zipcode: '94043',
-    country: 'United States',
-    countryCode: 'US'
-  };
-
-  const values = { ...defaults, ...overrides };
-  const components: MockGoogleAddressComponent[] = [];
-
-  if (values.streetNumber) {
-    components.push({
-      types: ['street_number'],
-      long_name: values.streetNumber,
-      short_name: values.streetNumber
-    });
-  }
-
-  if (values.route) {
-    components.push({
-      types: ['route'],
-      long_name: values.route,
-      short_name: values.route
-    });
-  }
-
-  if (values.subpremise) {
-    components.push({
-      types: ['subpremise'],
-      long_name: values.subpremise,
-      short_name: values.subpremise
-    });
-  }
-
-  if (values.city) {
-    components.push({
-      types: ['locality'],
-      long_name: values.city,
-      short_name: values.city
-    });
-  }
-
-  if (values.state) {
-    components.push({
-      types: ['administrative_area_level_1'],
-      long_name: values.state,
-      short_name: values.state
-    });
-  }
-
-  if (values.zipcode) {
-    components.push({
-      types: ['postal_code'],
-      long_name: values.zipcode,
-      short_name: values.zipcode
-    });
-  }
-
-  components.push({
-    types: ['country'],
-    long_name: values.country,
-    short_name: values.countryCode
-  });
-
-  return components;
-}
-
-export function createMockPlaceResult(
-  addressComponents: MockGoogleAddressComponent[],
-  formattedAddress?: string
-): MockPlaceResult {
-  return {
-    address_components: addressComponents,
-    formatted_address: formattedAddress
-  };
-}
diff --git a/tests/integration/modifiers/setup-autocomplete-test.ts b/tests/integration/modifiers/setup-autocomplete-test.ts
index bf0b5462..4716a824 100644
--- a/tests/integration/modifiers/setup-autocomplete-test.ts
+++ b/tests/integration/modifiers/setup-autocomplete-test.ts
@@ -7,7 +7,7 @@ import { type AutocompletionAddress } from '@upfluence/ember-upf-utils/modifiers
 import {
   createMockPlaceResult,
   createSampleAddressComponents
-} from '@upfluence/ember-upf-utils/utils/google-maps-mock';
+} from '@upfluence/ember-upf-utils/test-support/services/autocomplete-handler';
 import { AutocompleteHandlerServiceMock } from '@upfluence/ember-upf-utils/test-support/services/autocomplete-handler';
 
 module('Integration | Modifier | setup-autocomplete', function (hooks) {
diff --git a/tests/unit/utils/address-parser-test.ts b/tests/unit/utils/address-parser-test.ts
index da43a375..a8edf5fe 100644
--- a/tests/unit/utils/address-parser-test.ts
+++ b/tests/unit/utils/address-parser-test.ts
@@ -1,7 +1,7 @@
 import { module, test } from 'qunit';
 import { setupTest } from 'ember-qunit';
 import { parseAddressComponents } from '@upfluence/ember-upf-utils/utils/address-parser';
-import { createSampleAddressComponents } from '@upfluence/ember-upf-utils/utils/google-maps-mock';
+import { createSampleAddressComponents } from '@upfluence/ember-upf-utils/test-support/services/autocomplete-handler';
 
 module('Unit | Utility | address-parser', function (hooks) {
   setupTest(hooks);