@equinor/fusion-framework-module-bookmark 4.0.3 → 4.1.0-next.0

package/dist/types/BookmarkModuleConfigurator.d.ts

@@ -15,6 +15,7 @@ import type { BookmarkModuleConfig } from './types';
  */
 export declare class BookmarkModuleConfigurator extends BaseConfigBuilder<BookmarkModuleConfig> {
     #private;
+    /** Default expiration time, in milliseconds, for bookmarks. */
     defaultExpireTime: number;
     /**
      * Constructs a new `BookmarkModuleConfigurator`.

package/dist/types/__tests__/mock/bookmark-mock.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/mock/BookmarkMockClient.d.ts

@@ -0,0 +1,121 @@
+import { type ObservableInput } from 'rxjs';
+import type { BookmarkNew, BookmarksFilter, BookmarkUpdate, IBookmarkClient } from '../BookmarkClient.interface';
+import type { Bookmark, BookmarkData, BookmarkWithoutData } from '../types';
+/**
+ * In-memory {@link IBookmarkClient} backed by a `Map` of seeded bookmarks and a
+ * `Set` of favorite ids.
+ *
+ * @remarks
+ * Used by {@link BookmarkMockConfigurator} to swap out the real API client
+ * while leaving `BookmarkProvider` and the `bookmark-flows/` epics running
+ * unmodified — every create, update, delete, and favorite call still goes
+ * through the real flow logic, only the underlying data source is in-memory.
+ */
+export declare class BookmarkMockClient implements IBookmarkClient {
+    #private;
+    /**
+     * Replaces the seeded bookmarks with the given collection, keyed by `id`.
+     *
+     * @param items - The bookmarks to seed. Replaces any previously seeded bookmarks.
+     */
+    setBookmarks(items: Iterable<Bookmark>): void;
+    /**
+     * Marks a seeded bookmark as a favorite, or clears it.
+     *
+     * @param bookmarkId - The id of the bookmark to update.
+     * @param isFavorite - `true` to favorite the bookmark, `false` to clear it.
+     */
+    setFavorite(bookmarkId: string, isFavorite: boolean): void;
+    /**
+     * Looks up a seeded bookmark by id without going through the `ObservableInput` API.
+     *
+     * @param bookmarkId - The id of the bookmark to look up.
+     * @returns The seeded bookmark, or `undefined` when no bookmark was seeded for that id.
+     */
+    getBookmark(bookmarkId: string): Bookmark | undefined;
+    /**
+     * Returns every seeded bookmark that matches `filter`, without its payload.
+     *
+     * @remarks
+     * The real client strips payloads from list results (see `BookmarkClient.getAllBookmarks`),
+     * so the mock does the same here even though the interface's declared return type is `Bookmark[]`.
+     *
+     * @param filter - Optional constraints to narrow the returned bookmarks.
+     * @returns The matching bookmarks, without their payloads.
+     */
+    getAllBookmarks(filter?: BookmarksFilter): ObservableInput<Array<Bookmark>>;
+    /**
+     * Returns a seeded bookmark by id, without its payload.
+     *
+     * @param bookmarkId - The id of the bookmark to look up.
+     * @returns The bookmark without its payload.
+     * @throws {Error} When no bookmark was seeded for `bookmarkId`.
+     */
+    getBookmarkById(bookmarkId: string): ObservableInput<BookmarkWithoutData>;
+    /**
+     * Returns the payload data of a seeded bookmark.
+     *
+     * @template T - The shape of the bookmark's payload.
+     * @param bookmarkId - The id of the bookmark to look up.
+     * @returns The bookmark's payload.
+     * @throws {Error} When no bookmark was seeded for `bookmarkId`.
+     */
+    getBookmarkData<T extends BookmarkData>(bookmarkId: string): ObservableInput<T>;
+    /**
+     * Replaces the payload data of a seeded bookmark.
+     *
+     * @template T - The shape of the bookmark's payload.
+     * @param bookmarkId - The id of the bookmark to update.
+     * @param data - The new payload data.
+     * @returns The payload that was set.
+     * @throws {Error} When no bookmark was seeded for `bookmarkId`.
+     */
+    setBookmarkData<T extends BookmarkData | null>(bookmarkId: string, data: T): ObservableInput<T>;
+    /**
+     * Marks a seeded bookmark as a favorite.
+     *
+     * @param bookmarkId - The id of the bookmark to favorite.
+     * @returns `true` once the bookmark is marked as a favorite.
+     * @throws {Error} When no bookmark was seeded for `bookmarkId`.
+     */
+    addBookmarkToFavorites(bookmarkId: string): ObservableInput<boolean>;
+    /**
+     * Clears a seeded bookmark's favorite status.
+     *
+     * @param bookmarkId - The id of the bookmark to unfavorite.
+     * @returns `true` once the bookmark is no longer a favorite.
+     */
+    removeBookmarkFromFavorites(bookmarkId: string): ObservableInput<boolean>;
+    /**
+     * Checks whether a seeded bookmark is currently a favorite.
+     *
+     * @param bookmarkId - The id of the bookmark to check.
+     * @returns `true` when the bookmark is a favorite.
+     */
+    isBookmarkFavorite(bookmarkId: string): ObservableInput<boolean>;
+    /**
+     * Seeds a new bookmark from create input, generating its id and audit fields.
+     *
+     * @template T - The shape of the bookmark's payload.
+     * @param bookmark - The data to create the bookmark from.
+     * @returns The created bookmark.
+     */
+    createBookmark<T extends BookmarkData>(bookmark: BookmarkNew<T>): ObservableInput<Bookmark<T>>;
+    /**
+     * Applies updates to a seeded bookmark, stamping new audit fields.
+     *
+     * @template T - The shape of the bookmark's payload.
+     * @param bookmarkId - The id of the bookmark to update.
+     * @param updates - The fields to update.
+     * @returns The updated bookmark.
+     * @throws {Error} When no bookmark was seeded for `bookmarkId`.
+     */
+    updateBookmark<T extends BookmarkData>(bookmarkId: string, updates: BookmarkUpdate<T>): ObservableInput<Bookmark<T>>;
+    /**
+     * Removes a seeded bookmark and clears its favorite status.
+     *
+     * @param bookmarkId - The id of the bookmark to delete.
+     * @returns `true` when a bookmark was seeded for `bookmarkId` and was removed.
+     */
+    deleteBookmark(bookmarkId: string): ObservableInput<boolean>;
+}

package/dist/types/mock/BookmarkMockConfigurator.d.ts

@@ -0,0 +1,86 @@
+import type { ConfigBuilderCallbackArgs } from '@equinor/fusion-framework-module';
+import { BookmarkModuleConfigurator } from '../BookmarkModuleConfigurator';
+import type { Bookmark, BookmarkModuleConfig } from '../types';
+/**
+ * The real bookmark configurator, backed by an in-memory {@link BookmarkMockClient}.
+ *
+ * @remarks
+ * Extends {@link BookmarkModuleConfigurator} directly, so the whole builder API
+ * (source system, filters, resolvers, `setParent`) stays available. Only a
+ * default client is added — through the same
+ * {@link BookmarkModuleConfigurator.setClient | setClient} seam a caller would
+ * use to plug in their own client — so an explicit `setClient()` call still
+ * replaces it outright, exactly as it would on the real configurator.
+ *
+ * Seeded bookmarks and favorites flow through the real `BookmarkProvider` and
+ * `bookmark-flows/` epics unmodified: create, update, delete, and favorite
+ * calls all reach {@link BookmarkMockClient}, not a stand-in.
+ *
+ * @example Seed bookmarks and a current bookmark
+ * ```typescript
+ * enableBookmarkMock(configurator, (builder) => {
+ *   builder.setBookmarks([myBookmark]);
+ *   builder.setCurrentBookmark(myBookmark.id);
+ *   builder.setFavorite(myBookmark.id, true);
+ * });
+ * ```
+ *
+ * @example Take full control of the client
+ * ```typescript
+ * enableBookmarkMock(configurator, (builder) => {
+ *   builder.setClient(myOwnBookmarkClient);
+ * });
+ * ```
+ */
+export declare class BookmarkMockConfigurator extends BookmarkModuleConfigurator {
+    #private;
+    /**
+     * Seeds the bookmarks the mock client resolves through `getAllBookmarks`,
+     * `getBookmarkById`, and `getBookmarkData`.
+     *
+     * @param items - The bookmarks to seed. Replaces any previously seeded bookmarks.
+     * @returns `this`, for chaining.
+     */
+    setBookmarks(items: Iterable<Bookmark>): this;
+    /**
+     * Declares which seeded bookmark `IBookmarkProvider.currentBookmark` reports
+     * as active once the module initializes.
+     *
+     * @remarks
+     * `BookmarkProvider` only reads its initial current bookmark from a parent
+     * provider (see {@link BookmarkModuleConfigurator.setParent}), so this
+     * registers a synthetic parent exposing the seeded bookmark — the same seam
+     * a real nested-portal provider would use, just standing in for one.
+     *
+     * @param bookmarkId - The id of a bookmark previously passed to {@link setBookmarks},
+     *   or `undefined` to leave the current bookmark unset.
+     * @returns `this`, for chaining.
+     */
+    setCurrentBookmark(bookmarkId: string | undefined): this;
+    /**
+     * Marks a seeded bookmark as a favorite, or clears it, reflected through
+     * `IBookmarkClient.isBookmarkFavorite`.
+     *
+     * @param bookmarkId - The id of the bookmark to update.
+     * @param isFavorite - `true` to favorite the bookmark, `false` to clear it. Defaults to `true`.
+     * @returns `this`, for chaining.
+     */
+    setFavorite(bookmarkId: string, isFavorite?: boolean): this;
+    /**
+     * Installs the mock client and a synthetic current-bookmark parent before
+     * building the configuration, unless the caller already declared their own.
+     *
+     * @remarks
+     * Also falls back to trivial application/context resolvers when neither an
+     * `app` nor a `context` module is registered alongside this mock — both are
+     * required by {@link BookmarkModuleConfig}'s schema, but a standalone test
+     * has no reason to pull in either module just to satisfy it. Registering a
+     * real `app`/`context` module still wins, exactly as it does on the real
+     * configurator.
+     *
+     * @param init - The config builder callback arguments.
+     * @param initial - An optional initial config to merge into the returned config.
+     * @returns The observable configuration, produced by the real configurator.
+     */
+    protected _createConfig(init: ConfigBuilderCallbackArgs, initial?: Partial<BookmarkModuleConfig>): import("rxjs").ObservableInput<BookmarkModuleConfig>;
+}

package/dist/types/mock/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Mock bookmark module for tests: real provider, real configurator, in-memory client.
+ *
+ * @remarks
+ * Substituting `IBookmarkClient` is the smallest change that removes the
+ * Fusion Core Services backend from a test. Everything above it — the
+ * `BookmarkProvider` store, `bookmark-flows/` epics, payload generators, and
+ * events — is the production code path.
+ *
+ * @example
+ * ```typescript
+ * import { enableBookmarkMock } from '@equinor/fusion-framework-module-bookmark/mock';
+ *
+ * enableBookmarkMock(configurator, (builder) => {
+ *   builder.setBookmarks([myBookmark]);
+ *   builder.setCurrentBookmark(myBookmark.id);
+ *   builder.setFavorite(myBookmark.id, true);
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { BookmarkMockClient } from './BookmarkMockClient';
+export { BookmarkMockConfigurator } from './BookmarkMockConfigurator';
+export { enableBookmarkMock, bookmarkMockModule, type BookmarkMockConfigFn } from './module';

package/dist/types/mock/module.d.ts

@@ -0,0 +1,43 @@
+import type { AnyModule, IModulesConfigurator } from '@equinor/fusion-framework-module';
+import { type BookmarkModule } from '../bookmark-module';
+import { BookmarkMockConfigurator } from './BookmarkMockConfigurator';
+/**
+ * The bookmark module with a mock, in-memory client instead of a live
+ * `@equinor/fusion-framework-module-services` connection.
+ *
+ * @remarks
+ * Only `configure` differs from the real module. `initialize` is the
+ * production one, untouched, so the real `BookmarkProvider` and
+ * `bookmark-flows/` epics run exactly as they do in production — a test
+ * observes the real create/update/delete/favorite flow, not a rehearsal of it.
+ */
+export declare const bookmarkMockModule: BookmarkModule;
+/**
+ * Configuration callback for {@link enableBookmarkMock}.
+ *
+ * @template TRef - Reference type forwarded to the callback, inferred from the configurator.
+ */
+export type BookmarkMockConfigFn<TRef = unknown> = (configurator: BookmarkMockConfigurator, ref?: TRef) => void | Promise<void>;
+/**
+ * Enables the bookmark module against an in-memory mock client, so a test
+ * needs no network and no real Fusion Core Services backend.
+ *
+ * @remarks
+ * Registered last, this replaces whichever bookmark module the configurator
+ * already carries, so it works on a `FrameworkConfigurator` that pre-registers
+ * the real one.
+ *
+ * @param configurator - The modules configurator to register on.
+ * @param configure - Optional callback to seed bookmarks, the current bookmark, or favorites.
+ * @template TModules - The array of module descriptors managed by `configurator`.
+ * @template TRef - Reference type forwarded to `configure`, inferred from `configurator`.
+ *
+ * @example
+ * ```typescript
+ * enableBookmarkMock(configurator, (builder) => {
+ *   builder.setBookmarks([myBookmark]);
+ *   builder.setCurrentBookmark(myBookmark.id);
+ * });
+ * ```
+ */
+export declare const enableBookmarkMock: <TModules extends Array<AnyModule> = Array<AnyModule>, TRef = unknown>(configurator: IModulesConfigurator<TModules, TRef>, configure?: BookmarkMockConfigFn<TRef>) => void;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.0.3";
+export declare const version = "4.1.0-next.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-bookmark",
-  "version": "4.0.3",
+  "version": "4.1.0-next.0",
   "description": "",
   "main": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
@@ -13,6 +13,10 @@
     "./utils": {
       "import": "./dist/esm/utils/index.js",
       "types": "./dist/types/utils/index.d.ts"
+    },
+    "./mock": {
+      "import": "./dist/esm/mock/index.js",
+      "types": "./dist/types/mock/index.d.ts"
     }
   },
   "typesVersions": {
@@ -22,6 +26,9 @@
       ],
       "utils": [
         "dist/types/utils/index.d.ts"
+      ],
+      "mock": [
+        "dist/types/mock/index.d.ts"
       ]
     }
   },
@@ -41,21 +48,23 @@
     "immer": "^11.0.0",
     "rxjs": "^7.8.1",
     "uuid": "^14.0.0",
-    "@equinor/fusion-framework-module": "^6.1.1",
-    "@equinor/fusion-query": "^7.0.2",
-    "@equinor/fusion-observable": "^9.1.1",
-    "@equinor/fusion-log": "^2.0.1"
+    "@equinor/fusion-framework-module": "^6.1.3-next.0",
+    "@equinor/fusion-log": "^2.0.3-next.0",
+    "@equinor/fusion-query": "^7.0.4-next.0",
+    "@equinor/fusion-observable": "^9.1.2-next.0"
   },
   "devDependencies": {
     "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
     "zod": "^4.4.3",
-    "@equinor/fusion-framework-module-app": "^8.0.3",
-    "@equinor/fusion-framework-module-event": "^6.0.1",
-    "@equinor/fusion-framework-module-context": "^8.0.1",
-    "@equinor/fusion-framework-module-http": "^8.0.4",
-    "@equinor/fusion-framework-module-services": "^8.0.2"
+    "@equinor/fusion-framework-module-app": "^8.1.0-next.0",
+    "@equinor/fusion-framework-module-context": "^9.0.0-next.0",
+    "@equinor/fusion-framework-module-event": "^6.1.0-next.0",
+    "@equinor/fusion-framework-module-http": "^8.1.0-next.0",
+    "@equinor/fusion-framework-module-services": "^8.1.1-next.0"
   },
   "scripts": {
-    "build": "tsc -b"
+    "build": "tsc -b",
+    "test": "vitest run"
   }
 }

package/src/BookmarkModuleConfigurator.ts

@@ -43,7 +43,8 @@ const parseInitialBookmarkConfigConfig = (initial?: unknown): BookmarkModuleConf
  */
 export class BookmarkModuleConfigurator extends BaseConfigBuilder<BookmarkModuleConfig> {
   #log?: ILogger;
-  defaultExpireTime = 1 * 60 * 1000; // Default expiration time for bookmarks
+  /** Default expiration time, in milliseconds, for bookmarks. */
+  defaultExpireTime = 1 * 60 * 1000;
 
   /**
    * Constructs a new `BookmarkModuleConfigurator`.

package/src/__tests__/mock/bookmark-mock.test.ts

@@ -0,0 +1,199 @@
+import { firstValueFrom, from, type ObservableInput } from 'rxjs';
+import { describe, expect, it } from 'vitest';
+
+import { ModulesConfigurator } from '@equinor/fusion-framework-module';
+
+import { BookmarkModuleConfigurator } from '../../BookmarkModuleConfigurator';
+import { BookmarkProvider } from '../../BookmarkProvider';
+import type { IBookmarkProvider } from '../../BookmarkProvider.interface';
+import { module as realModule } from '../../bookmark-module';
+import type { Bookmark } from '../../types';
+
+import {
+  BookmarkMockClient,
+  BookmarkMockConfigurator,
+  bookmarkMockModule,
+  enableBookmarkMock,
+} from '../../mock';
+
+/** A fully-formed seeded bookmark, so tests only override what they care about. */
+const createBookmark = (overrides: Partial<Bookmark> = {}): Bookmark => ({
+  id: 'bookmark-1',
+  name: 'My Bookmark',
+  appKey: 'test-app',
+  created: new Date('2024-01-01T00:00:00.000Z'),
+  createdBy: { id: 'seed-user', name: 'Seed User' },
+  ...overrides,
+});
+
+/**
+ * Initializes the mock module through the real module system.
+ *
+ * @remarks
+ * Deliberately avoids hand-building initialization arguments — faking the
+ * module system is the very cost this mock removes.
+ *
+ * @param configure - Optional callback to seed bookmarks, current bookmark, or favorites.
+ * @returns The `IBookmarkProvider` the module produced.
+ */
+const initializeMockWith = async (
+  configure?: (builder: BookmarkMockConfigurator) => void,
+): Promise<IBookmarkProvider> => {
+  const configurator = new ModulesConfigurator([]);
+  enableBookmarkMock(configurator, configure);
+  const instances = await configurator.initialize();
+  return (instances as unknown as { bookmark: IBookmarkProvider }).bookmark;
+};
+
+/**
+ * Resolves the first value of an `IBookmarkProvider` call.
+ *
+ * @remarks
+ * `IBookmarkProvider`'s methods are typed as `ObservableInput`, not `Observable`,
+ * so this wraps with `from()` before handing off to `firstValueFrom`.
+ *
+ * @template T - The value the observable input emits.
+ * @param input - The observable input to resolve.
+ * @returns A promise resolving to the first emitted value.
+ */
+const firstValue = <T>(input: ObservableInput<T>): Promise<T> => firstValueFrom(from(input));
+
+describe('bookmarkMockModule', () => {
+  it('changes nothing but the configurator', () => {
+    expect(bookmarkMockModule.name).toBe(realModule.name);
+    expect(bookmarkMockModule.version).toBe(realModule.version);
+    // The production initializer, untouched — the mock has no lifecycle of its own
+    expect(bookmarkMockModule.initialize).toBe(realModule.initialize);
+  });
+
+  it('builds a real BookmarkModuleConfigurator, so the whole builder stays available', () => {
+    const configurator = bookmarkMockModule.configure?.();
+
+    expect(configurator).toBeInstanceOf(BookmarkModuleConfigurator);
+    expect(configurator).toBeInstanceOf(BookmarkMockConfigurator);
+  });
+});
+
+describe('enableBookmarkMock', () => {
+  it('produces the real BookmarkProvider, not a stand-in', async () => {
+    const provider = await initializeMockWith();
+
+    expect(provider).toBeInstanceOf(BookmarkProvider);
+  });
+
+  it('replaces a bookmark module that is already registered', async () => {
+    // A FrameworkConfigurator pre-registers the real bookmark module, so the
+    // mock is only useful if registering it afterwards wins
+    const configurator = new ModulesConfigurator([realModule]);
+    enableBookmarkMock(configurator, (builder) => {
+      builder.setBookmarks([createBookmark()]);
+    });
+
+    const instances = await configurator.initialize();
+    const provider = (instances as unknown as { bookmark: IBookmarkProvider }).bookmark;
+
+    const bookmarks = await firstValue(provider.getAllBookmarks());
+    expect(bookmarks).toHaveLength(1);
+  });
+
+  it('reflects seeded bookmarks with no real HTTP', async () => {
+    const seeded = createBookmark();
+    const provider = await initializeMockWith((builder) => {
+      builder.setBookmarks([seeded]);
+    });
+
+    const bookmarks = await firstValue(provider.getAllBookmarks());
+    expect(bookmarks.map((b) => b.id)).toEqual([seeded.id]);
+  });
+
+  it('reflects the seeded current bookmark', async () => {
+    const seeded = createBookmark();
+    const provider = await initializeMockWith((builder) => {
+      builder.setBookmarks([seeded]);
+      builder.setCurrentBookmark(seeded.id);
+    });
+
+    expect(provider.currentBookmark?.id).toBe(seeded.id);
+  });
+
+  it('leaves the current bookmark unset when none is seeded', async () => {
+    const provider = await initializeMockWith((builder) => {
+      builder.setBookmarks([createBookmark()]);
+    });
+
+    expect(provider.currentBookmark).toBeNull();
+  });
+
+  it('reflects a seeded favorite', async () => {
+    const seeded = createBookmark();
+    const provider = await initializeMockWith((builder) => {
+      builder.setBookmarks([seeded]);
+      builder.setFavorite(seeded.id, true);
+    });
+
+    await expect(firstValue(provider.isBookmarkInFavorites(seeded.id))).resolves.toBe(true);
+  });
+
+  it('creates a bookmark through the real create flow', async () => {
+    const provider = await initializeMockWith();
+    // without a payload generator, generatePayload() never emits and the create
+    // flow would hang forever waiting on it
+    provider.addPayloadGenerator(() => {});
+
+    const created = await firstValue(
+      provider.createBookmark({ name: 'New Bookmark', appKey: 'test-app' }),
+    );
+
+    expect(created.name).toBe('New Bookmark');
+    const bookmarks = await firstValue(provider.getAllBookmarks());
+    expect(bookmarks.map((b) => b.id)).toContain(created.id);
+  });
+
+  it('updates a bookmark through the real update flow', async () => {
+    const seeded = createBookmark();
+    const provider = await initializeMockWith((builder) => {
+      builder.setBookmarks([seeded]);
+    });
+    // the update reducer only applies to bookmarks already tracked in the store,
+    // so fetch once first to seed it
+    await firstValue(provider.getAllBookmarks());
+
+    const updated = await firstValue(
+      provider.updateBookmark(seeded.id, { name: 'Renamed' }, { excludePayloadGeneration: true }),
+    );
+
+    expect(updated.name).toBe('Renamed');
+  });
+
+  it('surfaces a missing bookmark as an observable error through the real fetch flow', async () => {
+    const provider = await initializeMockWith();
+
+    await expect(firstValue(provider.getBookmark('missing-bookmark'))).rejects.toThrow();
+  });
+
+  it('deletes a bookmark through the real delete flow', async () => {
+    const seeded = createBookmark();
+    const provider = await initializeMockWith((builder) => {
+      builder.setBookmarks([seeded]);
+    });
+
+    await firstValue(provider.deleteBookmark(seeded.id));
+
+    const bookmarks = await firstValue(provider.getAllBookmarks());
+    expect(bookmarks.map((b) => b.id)).not.toContain(seeded.id);
+  });
+
+  it('lets setClient() replace the mock client outright', async () => {
+    const ownClient = new BookmarkMockClient();
+    ownClient.setBookmarks([createBookmark({ id: 'own-bookmark' })]);
+
+    const provider = await initializeMockWith((builder) => {
+      // the escape hatch is inherited unchanged from BookmarkModuleConfigurator
+      builder.setBookmarks([createBookmark({ id: 'ignored-bookmark' })]);
+      builder.setClient(ownClient);
+    });
+
+    const bookmarks = await firstValue(provider.getAllBookmarks());
+    expect(bookmarks.map((b) => b.id)).toEqual(['own-bookmark']);
+  });
+});