add refreshOptions.enabled

Author: Eskibear

src/AzureAppConfigurationImpl.ts

@@ -15,7 +15,7 @@ import { DefaultRefreshIntervalInMs, MinimumRefreshIntervalInMs } from "./Refres
 import { LinkedList } from "./common/linkedList";
 import { Disposable } from "./common/disposable";
 
-export class AzureAppConfigurationImpl extends Map<string, unknown> implements AzureAppConfiguration {
+export class AzureAppConfigurationImpl extends Map<string, any> implements AzureAppConfiguration {
     private adapters: IKeyValueAdapter[] = [];
     /**
      * Trim key prefixes sorted in descending order.
@@ -25,7 +25,7 @@ export class AzureAppConfigurationImpl extends Map<string, unknown> implements A
     private readonly requestTracingEnabled: boolean;
     // Refresh
     private refreshIntervalInMs: number | undefined;
-    private onRefreshListeners: LinkedList<() => any> | undefined;
+    private onRefreshListeners: LinkedList<() => any> = new LinkedList();
     private lastUpdateTimestamp: number;
     private sentinels: ConfigurationSettingId[] | undefined;
 
@@ -41,26 +41,29 @@ export class AzureAppConfigurationImpl extends Map<string, unknown> implements A
             this.sortedTrimKeyPrefixes = [...options.trimKeyPrefixes].sort((a, b) => b.localeCompare(a));
         }
 
-        if (options?.refreshOptions) {
-            this.onRefreshListeners = new LinkedList();
-            this.refreshIntervalInMs = DefaultRefreshIntervalInMs;
+        if (options?.refreshOptions?.enabled) {
+            const { watchedSettings, refreshIntervalInMs } = options.refreshOptions;
+            // validate watched settings
+            if (watchedSettings === undefined || watchedSettings.length === 0) {
+                throw new Error("Refresh is enabled but no watched settings are specified.");
+            }
 
-            const refreshIntervalInMs = this.options?.refreshOptions?.refreshIntervalInMs;
+            // process refresh interval
             if (refreshIntervalInMs !== undefined) {
                 if (refreshIntervalInMs < MinimumRefreshIntervalInMs) {
                     throw new Error(`The refresh interval time cannot be less than ${MinimumRefreshIntervalInMs} milliseconds.`);
                 } else {
                     this.refreshIntervalInMs = refreshIntervalInMs;
                 }
+            } else {
+                this.refreshIntervalInMs = DefaultRefreshIntervalInMs;
             }
 
-            this.sentinels = options.refreshOptions.watchedSettings?.map(setting => {
-                const key = setting.key;
-                const label = setting.label;
-                if (key.includes("*") || label?.includes("*")) {
-                    throw new Error("Wildcard key or label filters are not supported for refresh.");
+            this.sentinels = watchedSettings.map(setting => {
+                if (setting.key.includes("*") || setting.label?.includes("*")) {
+                    throw new Error("The character '*' is not supported in key or label.");
                 }
-                return { key, label };
+                return { ...setting };
             });
         }
 
@@ -70,6 +73,11 @@ export class AzureAppConfigurationImpl extends Map<string, unknown> implements A
         this.adapters.push(new JsonKeyValueAdapter());
     }
 
+
+    get _refreshEnabled(): boolean {
+        return !!this.options?.refreshOptions?.enabled;
+    }
+
     public async load(requestType: RequestType = RequestType.Startup) {
         const keyValues: [key: string, value: unknown][] = [];
 
@@ -144,10 +152,10 @@ export class AzureAppConfigurationImpl extends Map<string, unknown> implements A
     }
 
     public onRefresh(listener: () => any, thisArg?: any): Disposable {
-        if (this.onRefreshListeners === undefined) {
-            // TODO: Add unit tests
-            throw new Error("Illegal operation because refreshOptions is not provided on loading.");
+        if (!this._refreshEnabled) {
+            throw new Error("Refresh is not enabled.");
         }
+
         const boundedListener = listener.bind(thisArg);
         const remove = this.onRefreshListeners.push(boundedListener);
         return new Disposable(remove);

src/RefreshOptions.ts

@@ -7,6 +7,11 @@ export const DefaultRefreshIntervalInMs = 30 * 1000;
 export const MinimumRefreshIntervalInMs = 1 * 1000;
 
 export interface RefreshOptions {
+    /**
+     * Specifies whether the provider should automatically refresh when the configuration is changed.
+     */
+    enabled: boolean;
+
     /**
      * Specifies the interval for refresh to really update the values.
      * Default value is 30 seconds. Must be greater than 1 second.
@@ -15,7 +20,8 @@ export interface RefreshOptions {
     refreshIntervalInMs?: number;
 
     /**
-     * Specifies settings to be watched, to determine whether the provider triggers a refresh.
+     * Specifies settings to be watched.
+     * Only if any of the settings is updated, the refresh will acutally update loaded configuration settings.
      */
-    watchedSettings: WatchedSetting[];
+    watchedSettings?: WatchedSetting[];
 }

test/refresh.test.ts

@@ -38,10 +38,36 @@ describe("dynamic refresh", function () {
         restoreMocks();
     })
 
+    it("should only allow non-empty list of watched settings when refresh is enabled", async () => {
+        const connectionString = createMockedConnectionString();
+        const loadWithEmptyWatchedSettings = load(connectionString, {
+            refreshOptions: {
+                enabled: true,
+                watchedSettings: []
+            }
+        });
+        const loadWithUndefinedWatchedSettings = load(connectionString, {
+            refreshOptions: {
+                enabled: true
+            }
+        });
+        return Promise.all([
+            expect(loadWithEmptyWatchedSettings).eventually.rejectedWith("Refresh is enabled but no watched settings are specified."),
+            expect(loadWithUndefinedWatchedSettings).eventually.rejectedWith("Refresh is enabled but no watched settings are specified.")
+        ]);
+    });
+
+    it("should throw error when calling onRefresh when refresh is not enabled", async () => {
+        const connectionString = createMockedConnectionString();
+        const settings = await load(connectionString);
+        expect(() => settings.onRefresh(() => { })).throws("Refresh is not enabled.");
+    });
+
     it("should only udpate values after refreshInterval", async () => {
         const connectionString = createMockedConnectionString();
         const settings = await load(connectionString, {
             refreshOptions: {
+                enabled: true,
                 refreshIntervalInMs: 2000,
                 watchedSettings: [
                     { key: "app.settings.fontColor" }
@@ -69,6 +95,7 @@ describe("dynamic refresh", function () {
         const connectionString = createMockedConnectionString();
         const settings = await load(connectionString, {
             refreshOptions: {
+                enabled: true,
                 refreshIntervalInMs: 2000,
                 watchedSettings: [
                     { key: "app.settings.fontColor" }
@@ -89,6 +116,7 @@ describe("dynamic refresh", function () {
         const connectionString = createMockedConnectionString();
         const settings = await load(connectionString, {
             refreshOptions: {
+                enabled: true,
                 refreshIntervalInMs: 2000,
                 watchedSettings: [
                     { key: "app.settings.fontColor" },
@@ -113,6 +141,7 @@ describe("dynamic refresh", function () {
         const connectionString = createMockedConnectionString();
         const settings = await load(connectionString, {
             refreshOptions: {
+                enabled: true,
                 refreshIntervalInMs: 2000,
                 watchedSettings: [
                     { key: "app.settings.fontColor" }