@skyux/forms 11.27.0 → 11.28.0

package/esm2022/testing/modules/file-attachment/file-attachment/file-attachment-harness.mjs

@@ -0,0 +1,193 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+import { SkyHelpInlineHarness } from '@skyux/help-inline/testing';
+import { SkyFormErrorsHarness } from '../../form-error/form-errors-harness';
+/**
+ * Harness for interacting with a file attachment component in tests.
+ */
+export class SkyFileAttachmentHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-file-attachment'; }
+    #getButton = this.locatorFor('button.sky-file-attachment-btn');
+    #getLabel = this.locatorFor('.sky-control-label');
+    #input = this.locatorFor('input[type="file"]');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyFileAttachmentHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyFileAttachmentHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Clicks the attach file button if it is visible.
+     */
+    async clickAttachFileButton() {
+        try {
+            const button = await this.#getButton();
+            if ((await button.text()).trim() === 'Replace file') {
+                throw new Error();
+            }
+            return await button.click();
+        }
+        catch {
+            throw new Error('Cannot click Attach file button, there is currently a file attached.');
+        }
+    }
+    /**
+     * Clicks the help inline button.
+     */
+    async clickHelpInline() {
+        return await (await this.#getHelpInline()).click();
+    }
+    /**
+     * Clicks the replace file button in default theme.
+     */
+    async clickReplaceFileButton() {
+        try {
+            const button = await this.#getButton();
+            if ((await button.text()).trim() !== 'Replace file') {
+                throw new Error();
+            }
+            return await button.click();
+        }
+        catch {
+            throw new Error('Cannot click Replace file button, it is not visible.');
+        }
+    }
+    /**
+     * Clicks the attached file to download it.
+     */
+    async clickAttachedFile() {
+        try {
+            const file = await this.locatorFor('a')();
+            return await file.click();
+        }
+        catch {
+            throw new Error('Unable to find the attached file.');
+        }
+    }
+    /**
+     * Clicks the attached file's delete button.
+     */
+    async clickAttachedFileDeleteButton() {
+        try {
+            const deleteButton = await this.locatorFor('button.sky-file-attachment-delete')();
+            return await deleteButton.click();
+        }
+        catch {
+            throw new Error("Unable to find attached file's delete button. Check if a file is attached.");
+        }
+    }
+    /**
+     * Gets the accepted file types.
+     */
+    async getAcceptedTypes() {
+        return await (await this.#input()).getAttribute('accept');
+    }
+    /**
+     * Gets the help inline popover content.
+     */
+    async getHelpPopoverContent() {
+        const content = await (await this.#getHelpInline()).getPopoverContent();
+        return content;
+    }
+    /**
+     * Gets the help inline popover title.
+     */
+    async getHelpPopoverTitle() {
+        return await (await this.#getHelpInline()).getPopoverTitle();
+    }
+    /**
+     * Gets the hint text.
+     */
+    async getHintText() {
+        return (await (await this.locatorFor('.sky-file-attachment-hint-text')()).text()).trim();
+    }
+    /**
+     * Gets the file attachment label.
+     */
+    async getLabelText() {
+        return (await (await this.#getLabel()).text()).trim();
+    }
+    /**
+     * Whether a custom error has fired.
+     */
+    async hasCustomError(errorName) {
+        return await (await this.#getFormErrors())?.hasError(errorName);
+    }
+    /**
+     * Whether the wrong file type error has fired.
+     */
+    async hasFileTypeError() {
+        return await (await this.#getFormErrors())?.hasError('fileType');
+    }
+    /**
+     * Whether the max file size error has fired.
+     */
+    async hasMaxFileSizeError() {
+        return await (await this.#getFormErrors())?.hasError('maxFileSize');
+    }
+    /**
+     * Whether the min file size error has fired.
+     */
+    async hasMinFileSizeError() {
+        return await (await this.#getFormErrors())?.hasError('minFileSize');
+    }
+    /**
+     * Whether the required error has fired.
+     */
+    async hasRequiredError() {
+        return await (await this.#getFormErrors())?.hasError('required');
+    }
+    /**
+     * Whether file attachment is disabled.
+     */
+    async isDisabled() {
+        return (await (await this.#getButton()).getAttribute('disabled')) !== null;
+    }
+    /**
+     * Whether file attachment is required.
+     */
+    async isRequired() {
+        return await (await this.#getLabel()).hasClass('sky-control-label-required');
+    }
+    /**
+     * Whether file attachment has stacked enabled.
+     */
+    async isStacked() {
+        return await (await this.host()).hasClass('sky-form-field-stacked');
+    }
+    /**
+     * Attaches a file.
+     * Be sure to include `provideSkyFileReaderTesting` as a provider when calling this function in tests.
+     *  @example
+     * ```typescript
+     * TestBed.configureTestingModule({
+     *   providers: [provideSkyFileReaderTesting()]
+     * });
+     * ```
+     */
+    async attachFile(file) {
+        return await this.#dropFile(file);
+    }
+    async #dropFile(file) {
+        const attachLocation = await this.locatorFor('.sky-file-attachment-upload')();
+        const dataTransfer = new DataTransfer();
+        dataTransfer.items.add(file);
+        return await attachLocation.dispatchEvent('drop', {
+            dataTransfer,
+        });
+    }
+    async #getFormErrors() {
+        return await this.locatorFor(SkyFormErrorsHarness)();
+    }
+    async #getHelpInline() {
+        const harness = await this.locatorForOptional(SkyHelpInlineHarness)();
+        if (harness) {
+            return harness;
+        }
+        throw Error('No help inline found.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-attachment-harness.js","sourceRoot":"","sources":["../../../../../../../../../libs/components/forms/testing/src/modules/file-attachment/file-attachment/file-attachment-harness.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventData, HarnessPredicate } from '@angular/cdk/testing';\nimport { SkyComponentHarness } from '@skyux/core/testing';\nimport { SkyHelpInlineHarness } from '@skyux/help-inline/testing';\n\nimport { SkyFormErrorsHarness } from '../../form-error/form-errors-harness';\n\nimport { SkyFileAttachmentHarnessFilters } from './file-attachment-harness-filters';\n\ntype TestDataTransfer = DataTransfer & { [key: string]: EventData };\n\n/**\n * Harness for interacting with a file attachment component in tests.\n */\nexport class SkyFileAttachmentHarness extends SkyComponentHarness {\n  /**\n   * @internal\n   */\n  public static hostSelector = 'sky-file-attachment';\n\n  #getButton = this.locatorFor('button.sky-file-attachment-btn');\n  #getLabel = this.locatorFor('.sky-control-label');\n  #input = this.locatorFor('input[type=\"file\"]');\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a\n   * `SkyFileAttachmentHarness` that meets certain criteria.\n   */\n  public static with(\n    filters: SkyFileAttachmentHarnessFilters,\n  ): HarnessPredicate<SkyFileAttachmentHarness> {\n    return SkyFileAttachmentHarness.getDataSkyIdPredicate(filters);\n  }\n\n  /**\n   * Clicks the attach file button if it is visible.\n   */\n  public async clickAttachFileButton(): Promise<void> {\n    try {\n      const button = await this.#getButton();\n      if ((await button.text()).trim() === 'Replace file') {\n        throw new Error();\n      }\n      return await button.click();\n    } catch {\n      throw new Error(\n        'Cannot click Attach file button, there is currently a file attached.',\n      );\n    }\n  }\n\n  /**\n   * Clicks the help inline button.\n   */\n  public async clickHelpInline(): Promise<void> {\n    return await (await this.#getHelpInline()).click();\n  }\n\n  /**\n   * Clicks the replace file button in default theme.\n   */\n  public async clickReplaceFileButton(): Promise<void> {\n    try {\n      const button = await this.#getButton();\n      if ((await button.text()).trim() !== 'Replace file') {\n        throw new Error();\n      }\n      return await button.click();\n    } catch {\n      throw new Error('Cannot click Replace file button, it is not visible.');\n    }\n  }\n\n  /**\n   * Clicks the attached file to download it.\n   */\n  public async clickAttachedFile(): Promise<void> {\n    try {\n      const file = await this.locatorFor('a')();\n      return await file.click();\n    } catch {\n      throw new Error('Unable to find the attached file.');\n    }\n  }\n\n  /**\n   * Clicks the attached file's delete button.\n   */\n  public async clickAttachedFileDeleteButton(): Promise<void> {\n    try {\n      const deleteButton = await this.locatorFor(\n        'button.sky-file-attachment-delete',\n      )();\n      return await deleteButton.click();\n    } catch {\n      throw new Error(\n        \"Unable to find attached file's delete button. Check if a file is attached.\",\n      );\n    }\n  }\n\n  /**\n   * Gets the accepted file types.\n   */\n  public async getAcceptedTypes(): Promise<string | null> {\n    return await (await this.#input()).getAttribute('accept');\n  }\n\n  /**\n   * Gets the help inline popover content.\n   */\n  public async getHelpPopoverContent(): Promise<string | undefined> {\n    const content = await (await this.#getHelpInline()).getPopoverContent();\n\n    return content as string | undefined;\n  }\n\n  /**\n   * Gets the help inline popover title.\n   */\n  public async getHelpPopoverTitle(): Promise<string | undefined> {\n    return await (await this.#getHelpInline()).getPopoverTitle();\n  }\n\n  /**\n   * Gets the hint text.\n   */\n  public async getHintText(): Promise<string> {\n    return (\n      await (await this.locatorFor('.sky-file-attachment-hint-text')()).text()\n    ).trim();\n  }\n\n  /**\n   * Gets the file attachment label.\n   */\n  public async getLabelText(): Promise<string> {\n    return (await (await this.#getLabel()).text()).trim();\n  }\n\n  /**\n   * Whether a custom error has fired.\n   */\n  public async hasCustomError(errorName: string): Promise<boolean> {\n    return await (await this.#getFormErrors())?.hasError(errorName);\n  }\n\n  /**\n   * Whether the wrong file type error has fired.\n   */\n  public async hasFileTypeError(): Promise<boolean> {\n    return await (await this.#getFormErrors())?.hasError('fileType');\n  }\n\n  /**\n   * Whether the max file size error has fired.\n   */\n  public async hasMaxFileSizeError(): Promise<boolean> {\n    return await (await this.#getFormErrors())?.hasError('maxFileSize');\n  }\n\n  /**\n   * Whether the min file size error has fired.\n   */\n  public async hasMinFileSizeError(): Promise<boolean> {\n    return await (await this.#getFormErrors())?.hasError('minFileSize');\n  }\n\n  /**\n   * Whether the required error has fired.\n   */\n  public async hasRequiredError(): Promise<boolean> {\n    return await (await this.#getFormErrors())?.hasError('required');\n  }\n\n  /**\n   * Whether file attachment is disabled.\n   */\n  public async isDisabled(): Promise<boolean> {\n    return (await (await this.#getButton()).getAttribute('disabled')) !== null;\n  }\n\n  /**\n   * Whether file attachment is required.\n   */\n  public async isRequired(): Promise<boolean> {\n    return await (\n      await this.#getLabel()\n    ).hasClass('sky-control-label-required');\n  }\n\n  /**\n   * Whether file attachment has stacked enabled.\n   */\n  public async isStacked(): Promise<boolean> {\n    return await (await this.host()).hasClass('sky-form-field-stacked');\n  }\n\n  /**\n   * Attaches a file.\n   * Be sure to include `provideSkyFileReaderTesting` as a provider when calling this function in tests.\n   *  @example\n   * ```typescript\n   * TestBed.configureTestingModule({\n   *   providers: [provideSkyFileReaderTesting()]\n   * });\n   * ```\n   */\n  public async attachFile(file: File): Promise<void> {\n    return await this.#dropFile(file);\n  }\n\n  async #dropFile(file: File): Promise<void> {\n    const attachLocation = await this.locatorFor(\n      '.sky-file-attachment-upload',\n    )();\n\n    const dataTransfer = new DataTransfer() as TestDataTransfer;\n    dataTransfer.items.add(file);\n\n    return await attachLocation.dispatchEvent('drop', {\n      dataTransfer,\n    });\n  }\n\n  async #getFormErrors(): Promise<SkyFormErrorsHarness> {\n    return await this.locatorFor(SkyFormErrorsHarness)();\n  }\n\n  async #getHelpInline(): Promise<SkyHelpInlineHarness> {\n    const harness = await this.locatorForOptional(SkyHelpInlineHarness)();\n\n    if (harness) {\n      return harness;\n    }\n\n    throw Error('No help inline found.');\n  }\n}\n"]}

package/esm2022/testing/modules/file-attachment/file-drop/file-drop-harness.mjs

@@ -29,17 +29,11 @@ export class SkyFileDropHarness extends SkyComponentHarness {
             item: (index) => files[index],
             length: files.length,
         };
-        dropTarget.dispatchEvent('drop', {
+        await dropTarget.dispatchEvent('drop', {
             dataTransfer: {
                 files: fileList,
             },
         });
-        // The file drop component's `filesChanged` event happens asynchronously as the
-        // result of an event handler which is outside of the test harness async logic,
-        // so get in the queue after the event handler, then resolve.
-        return await new Promise((resolve) => {
-            setTimeout(() => resolve(), 100);
-        });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/modules/file-attachment/shared/provide-file-attachment-testing.mjs

@@ -0,0 +1,14 @@
+import { provideSkyFileReaderTesting } from '@skyux/core/testing';
+/**
+ * Provides mocks for file attachment testing.
+ * @example
+ * ```typescript
+ * TestBed.configureTestingModule({
+ *   providers: [provideSkyFileAttachmentTesting()]
+ * });
+ * ```
+ */
+export function provideSkyFileAttachmentTesting() {
+    return [provideSkyFileReaderTesting()];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZS1maWxlLWF0dGFjaG1lbnQtdGVzdGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9mb3Jtcy90ZXN0aW5nL3NyYy9tb2R1bGVzL2ZpbGUtYXR0YWNobWVudC9zaGFyZWQvcHJvdmlkZS1maWxlLWF0dGFjaG1lbnQtdGVzdGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVsRTs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sVUFBVSwrQkFBK0I7SUFDN0MsT0FBTyxDQUFDLDJCQUEyQixFQUFFLENBQUMsQ0FBQztBQUN6QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHJvdmlkZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IHByb3ZpZGVTa3lGaWxlUmVhZGVyVGVzdGluZyB9IGZyb20gJ0Bza3l1eC9jb3JlL3Rlc3RpbmcnO1xuXG4vKipcbiAqIFByb3ZpZGVzIG1vY2tzIGZvciBmaWxlIGF0dGFjaG1lbnQgdGVzdGluZy5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBUZXN0QmVkLmNvbmZpZ3VyZVRlc3RpbmdNb2R1bGUoe1xuICogICBwcm92aWRlcnM6IFtwcm92aWRlU2t5RmlsZUF0dGFjaG1lbnRUZXN0aW5nKCldXG4gKiB9KTtcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZVNreUZpbGVBdHRhY2htZW50VGVzdGluZygpOiBQcm92aWRlcltdIHtcbiAgcmV0dXJuIFtwcm92aWRlU2t5RmlsZVJlYWRlclRlc3RpbmcoKV07XG59XG4iXX0=

package/esm2022/testing/public-api.mjs

@@ -4,7 +4,9 @@ export { SkyCheckboxFixture } from './legacy/checkbox-fixture';
 export { SkyCheckboxGroupHarness } from './modules/checkbox/checkbox-group-harness';
 export { SkyCheckboxHarness } from './modules/checkbox/checkbox-harness';
 export { SkyCheckboxLabelHarness } from './modules/checkbox/checkbox-label-harness';
+export { SkyFileAttachmentHarness } from './modules/file-attachment/file-attachment/file-attachment-harness';
 export { SkyFileDropHarness } from './modules/file-attachment/file-drop/file-drop-harness';
+export { provideSkyFileAttachmentTesting } from './modules/file-attachment/shared/provide-file-attachment-testing';
 export { SkyFormErrorsHarness } from './modules/form-error/form-errors-harness';
 export { SkyFormErrorHarness } from './modules/form-error/form-error-harness';
 export { SkyFieldGroupHarness } from './modules/field-group/field-group-harness';
@@ -12,4 +14,4 @@ export { SkyRadioFixture } from './legacy/radio-fixture';
 export { SkyRadioGroupHarness } from './modules/radio/radio-group-harness';
 export { SkyRadioHarness } from './modules/radio/radio-harness';
 export { SkyRadioLabelHarness } from './modules/radio/radio-label-harness';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/skyux-forms-testing.mjs

@@ -1,5 +1,5 @@
 import { HarnessPredicate, ComponentHarness } from '@angular/cdk/testing';
-import { SkyComponentHarness, SkyQueryableComponentHarness } from '@skyux/core/testing';
+import { SkyComponentHarness, SkyQueryableComponentHarness, provideSkyFileReaderTesting } from '@skyux/core/testing';
 import { SkyHelpInlineHarness } from '@skyux/help-inline/testing';
 import { SkyStatusIndicatorHarness } from '@skyux/indicators/testing';
 import { SkyPopoverHarness } from '@skyux/popovers/testing';
@@ -762,6 +762,196 @@ class SkyCheckboxGroupHarness extends SkyComponentHarness {
     }
 }
 
+/**
+ * Harness for interacting with a file attachment component in tests.
+ */
+class SkyFileAttachmentHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-file-attachment'; }
+    #getButton = this.locatorFor('button.sky-file-attachment-btn');
+    #getLabel = this.locatorFor('.sky-control-label');
+    #input = this.locatorFor('input[type="file"]');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyFileAttachmentHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyFileAttachmentHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Clicks the attach file button if it is visible.
+     */
+    async clickAttachFileButton() {
+        try {
+            const button = await this.#getButton();
+            if ((await button.text()).trim() === 'Replace file') {
+                throw new Error();
+            }
+            return await button.click();
+        }
+        catch {
+            throw new Error('Cannot click Attach file button, there is currently a file attached.');
+        }
+    }
+    /**
+     * Clicks the help inline button.
+     */
+    async clickHelpInline() {
+        return await (await this.#getHelpInline()).click();
+    }
+    /**
+     * Clicks the replace file button in default theme.
+     */
+    async clickReplaceFileButton() {
+        try {
+            const button = await this.#getButton();
+            if ((await button.text()).trim() !== 'Replace file') {
+                throw new Error();
+            }
+            return await button.click();
+        }
+        catch {
+            throw new Error('Cannot click Replace file button, it is not visible.');
+        }
+    }
+    /**
+     * Clicks the attached file to download it.
+     */
+    async clickAttachedFile() {
+        try {
+            const file = await this.locatorFor('a')();
+            return await file.click();
+        }
+        catch {
+            throw new Error('Unable to find the attached file.');
+        }
+    }
+    /**
+     * Clicks the attached file's delete button.
+     */
+    async clickAttachedFileDeleteButton() {
+        try {
+            const deleteButton = await this.locatorFor('button.sky-file-attachment-delete')();
+            return await deleteButton.click();
+        }
+        catch {
+            throw new Error("Unable to find attached file's delete button. Check if a file is attached.");
+        }
+    }
+    /**
+     * Gets the accepted file types.
+     */
+    async getAcceptedTypes() {
+        return await (await this.#input()).getAttribute('accept');
+    }
+    /**
+     * Gets the help inline popover content.
+     */
+    async getHelpPopoverContent() {
+        const content = await (await this.#getHelpInline()).getPopoverContent();
+        return content;
+    }
+    /**
+     * Gets the help inline popover title.
+     */
+    async getHelpPopoverTitle() {
+        return await (await this.#getHelpInline()).getPopoverTitle();
+    }
+    /**
+     * Gets the hint text.
+     */
+    async getHintText() {
+        return (await (await this.locatorFor('.sky-file-attachment-hint-text')()).text()).trim();
+    }
+    /**
+     * Gets the file attachment label.
+     */
+    async getLabelText() {
+        return (await (await this.#getLabel()).text()).trim();
+    }
+    /**
+     * Whether a custom error has fired.
+     */
+    async hasCustomError(errorName) {
+        return await (await this.#getFormErrors())?.hasError(errorName);
+    }
+    /**
+     * Whether the wrong file type error has fired.
+     */
+    async hasFileTypeError() {
+        return await (await this.#getFormErrors())?.hasError('fileType');
+    }
+    /**
+     * Whether the max file size error has fired.
+     */
+    async hasMaxFileSizeError() {
+        return await (await this.#getFormErrors())?.hasError('maxFileSize');
+    }
+    /**
+     * Whether the min file size error has fired.
+     */
+    async hasMinFileSizeError() {
+        return await (await this.#getFormErrors())?.hasError('minFileSize');
+    }
+    /**
+     * Whether the required error has fired.
+     */
+    async hasRequiredError() {
+        return await (await this.#getFormErrors())?.hasError('required');
+    }
+    /**
+     * Whether file attachment is disabled.
+     */
+    async isDisabled() {
+        return (await (await this.#getButton()).getAttribute('disabled')) !== null;
+    }
+    /**
+     * Whether file attachment is required.
+     */
+    async isRequired() {
+        return await (await this.#getLabel()).hasClass('sky-control-label-required');
+    }
+    /**
+     * Whether file attachment has stacked enabled.
+     */
+    async isStacked() {
+        return await (await this.host()).hasClass('sky-form-field-stacked');
+    }
+    /**
+     * Attaches a file.
+     * Be sure to include `provideSkyFileReaderTesting` as a provider when calling this function in tests.
+     *  @example
+     * ```typescript
+     * TestBed.configureTestingModule({
+     *   providers: [provideSkyFileReaderTesting()]
+     * });
+     * ```
+     */
+    async attachFile(file) {
+        return await this.#dropFile(file);
+    }
+    async #dropFile(file) {
+        const attachLocation = await this.locatorFor('.sky-file-attachment-upload')();
+        const dataTransfer = new DataTransfer();
+        dataTransfer.items.add(file);
+        return await attachLocation.dispatchEvent('drop', {
+            dataTransfer,
+        });
+    }
+    async #getFormErrors() {
+        return await this.locatorFor(SkyFormErrorsHarness)();
+    }
+    async #getHelpInline() {
+        const harness = await this.locatorForOptional(SkyHelpInlineHarness)();
+        if (harness) {
+            return harness;
+        }
+        throw Error('No help inline found.');
+    }
+}
+
 /**
  * Harness for interacting with a file drop component in tests.
  * @internal
@@ -792,20 +982,27 @@ class SkyFileDropHarness extends SkyComponentHarness {
             item: (index) => files[index],
             length: files.length,
         };
-        dropTarget.dispatchEvent('drop', {
+        await dropTarget.dispatchEvent('drop', {
             dataTransfer: {
                 files: fileList,
             },
         });
-        // The file drop component's `filesChanged` event happens asynchronously as the
-        // result of an event handler which is outside of the test harness async logic,
-        // so get in the queue after the event handler, then resolve.
-        return await new Promise((resolve) => {
-            setTimeout(() => resolve(), 100);
-        });
     }
 }
 
+/**
+ * Provides mocks for file attachment testing.
+ * @example
+ * ```typescript
+ * TestBed.configureTestingModule({
+ *   providers: [provideSkyFileAttachmentTesting()]
+ * });
+ * ```
+ */
+function provideSkyFileAttachmentTesting() {
+    return [provideSkyFileReaderTesting()];
+}
+
 /**
  * Harness for interacting with a field group component in tests.
  */
@@ -1297,5 +1494,5 @@ class SkyRadioGroupHarness extends SkyComponentHarness {
  * Generated bundle index. Do not edit.
  */
 
-export { SkyCharacterCounterIndicatorHarness, SkyCheckboxFixture, SkyCheckboxGroupHarness, SkyCheckboxHarness, SkyCheckboxLabelHarness, SkyFieldGroupHarness, SkyFileDropHarness, SkyFormErrorHarness, SkyFormErrorsHarness, SkyInputBoxHarness, SkyRadioFixture, SkyRadioGroupHarness, SkyRadioHarness, SkyRadioLabelHarness };
+export { SkyCharacterCounterIndicatorHarness, SkyCheckboxFixture, SkyCheckboxGroupHarness, SkyCheckboxHarness, SkyCheckboxLabelHarness, SkyFieldGroupHarness, SkyFileAttachmentHarness, SkyFileDropHarness, SkyFormErrorHarness, SkyFormErrorsHarness, SkyInputBoxHarness, SkyRadioFixture, SkyRadioGroupHarness, SkyRadioHarness, SkyRadioLabelHarness, provideSkyFileAttachmentTesting };
 //# sourceMappingURL=skyux-forms-testing.mjs.map