@nx/angular 0.0.0-pr-22179-271588f

package/src/generators/ng-add/utilities/workspace.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteGitKeepFilesIfNotNeeded = exports.deleteAngularJson = exports.updateVsCodeRecommendedExtensions = exports.getWorkspaceRootFileTypesInfo = exports.createRootKarmaConfig = exports.createWorkspaceFiles = exports.cleanupEsLintPackages = exports.updateRootEsLintConfig = exports.updatePackageJson = exports.updateRootTsConfig = exports.updateWorkspaceConfigDefaults = exports.createNxJson = exports.validateWorkspace = void 0;
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const setup_root_eslint_1 = require("@nx/eslint/src/generators/lint-project/setup-root-eslint");
+const js_1 = require("@nx/js");
+const default_base_1 = require("nx/src/utils/default-base");
+const versions_1 = require("@nx/js/src/utils/versions");
+const angular_json_1 = require("nx/src/adapter/angular-json");
+const versions_2 = require("../../../utils/versions");
+const path_1 = require("path");
+function validateWorkspace(tree) {
+    const errors = [];
+    if (!tree.exists('package.json')) {
+        errors.push('The "package.json" file could not be found.');
+    }
+    if (!tree.exists('angular.json')) {
+        errors.push('The "angular.json" file could not be found.');
+    }
+    if (!errors.length) {
+        return;
+    }
+    throw new Error(`The workspace cannot be migrated because of the following issues:
+
+  - ${errors.join('\n  ')}`);
+}
+exports.validateWorkspace = validateWorkspace;
+function createNxJson(tree, options, defaultProject) {
+    const targets = getWorkspaceCommonTargets(tree);
+    (0, devkit_1.writeJson)(tree, 'nx.json', {
+        defaultBase: options.defaultBase ?? (0, default_base_1.deduceDefaultBase)(),
+        namedInputs: {
+            sharedGlobals: [],
+            default: ['{projectRoot}/**/*', 'sharedGlobals'],
+            production: [
+                'default',
+                ...(targets.test
+                    ? [
+                        '!{projectRoot}/tsconfig.spec.json',
+                        '!{projectRoot}/**/*.spec.[jt]s',
+                        '!{projectRoot}/karma.conf.js',
+                    ]
+                    : []),
+                ...(targets.lint
+                    ? ['!{projectRoot}/.eslintrc.json', '!{projectRoot}/eslint.config.js']
+                    : []),
+            ].filter(Boolean),
+        },
+        targetDefaults: {
+            build: {
+                dependsOn: ['^build'],
+                inputs: ['production', '^production'],
+                cache: true,
+            },
+            test: targets.test
+                ? {
+                    inputs: ['default', '^production', '{workspaceRoot}/karma.conf.js'],
+                    cache: true,
+                }
+                : undefined,
+            lint: targets.lint
+                ? {
+                    inputs: [
+                        'default',
+                        '{workspaceRoot}/.eslintrc.json',
+                        '{workspaceRoot}/eslint.config.js',
+                    ],
+                    cache: true,
+                }
+                : undefined,
+            e2e: targets.e2e
+                ? {
+                    inputs: ['default', '^production'],
+                    cache: true,
+                }
+                : undefined,
+        },
+        defaultProject,
+    });
+}
+exports.createNxJson = createNxJson;
+function getWorkspaceCommonTargets(tree) {
+    const targets = { e2e: false, lint: false, test: false };
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [, project] of projects) {
+        if (!targets.e2e && project.targets?.e2e) {
+            targets.e2e = true;
+        }
+        if (!targets.lint && project.targets?.lint) {
+            targets.lint = true;
+        }
+        if (!targets.test && project.targets?.test) {
+            targets.test = true;
+        }
+        if (targets.e2e && targets.lint && targets.test) {
+            return targets;
+        }
+    }
+    return targets;
+}
+function updateWorkspaceConfigDefaults(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    delete nxJson.newProjectRoot;
+    if (nxJson.cli) {
+        delete nxJson.defaultCollection;
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.updateWorkspaceConfigDefaults = updateWorkspaceConfigDefaults;
+function updateRootTsConfig(tree) {
+    const tsconfig = (0, devkit_1.readJson)(tree, (0, js_1.getRootTsConfigPathInTree)(tree));
+    tsconfig.compilerOptions.paths ??= {};
+    tsconfig.compilerOptions.baseUrl = '.';
+    tsconfig.compilerOptions.rootDir = '.';
+    tsconfig.exclude = Array.from(new Set([...(tsconfig.exclude ?? []), 'node_modules', 'tmp']));
+    (0, devkit_1.writeJson)(tree, 'tsconfig.base.json', tsconfig);
+    if (tree.exists('tsconfig.json')) {
+        tree.delete('tsconfig.json');
+    }
+}
+exports.updateRootTsConfig = updateRootTsConfig;
+function updatePackageJson(tree) {
+    (0, devkit_1.updateJson)(tree, 'package.json', (packageJson) => {
+        packageJson.scripts = packageJson.scripts ?? {};
+        Object.keys(packageJson.scripts).forEach((script) => {
+            packageJson.scripts[script] = packageJson.scripts[script]
+                .replace(/^ng /, 'nx ')
+                .replace(/ ng /, ' nx ');
+        });
+        packageJson.devDependencies = packageJson.devDependencies ?? {};
+        packageJson.dependencies = packageJson.dependencies ?? {};
+        if (!packageJson.devDependencies['@angular/cli']) {
+            packageJson.devDependencies['@angular/cli'] = versions_2.angularDevkitVersion;
+        }
+        if (!packageJson.devDependencies['@nx/workspace'] &&
+            !packageJson.devDependencies['@nrwl/workspace']) {
+            packageJson.devDependencies['@nx/workspace'] = versions_2.nxVersion;
+        }
+        if (!packageJson.devDependencies['nx']) {
+            packageJson.devDependencies['nx'] = versions_2.nxVersion;
+        }
+        if (!packageJson.devDependencies['prettier']) {
+            packageJson.devDependencies['prettier'] = versions_1.prettierVersion;
+        }
+        return packageJson;
+    });
+}
+exports.updatePackageJson = updatePackageJson;
+async function updateRootEsLintConfig(tree, existingEsLintConfig, unitTestRunner) {
+    await (0, eslint_1.lintInitGenerator)(tree, {
+        addPlugin: false,
+    });
+    if (!existingEsLintConfig) {
+        // There was no eslint config in the root, so we set it up and use it as-is
+        (0, setup_root_eslint_1.setupRootEsLint)(tree, { unitTestRunner });
+        return;
+    }
+    existingEsLintConfig.ignorePatterns = ['**/*'];
+    if (!(existingEsLintConfig.plugins ?? []).includes('@nx')) {
+        existingEsLintConfig.plugins = Array.from(new Set([...(existingEsLintConfig.plugins ?? []), '@nx']));
+    }
+    existingEsLintConfig.overrides?.forEach((override) => {
+        if (!override.parserOptions?.project) {
+            return;
+        }
+        delete override.parserOptions.project;
+    });
+    // add the @nx/enforce-module-boundaries rule
+    existingEsLintConfig.overrides = [
+        ...(existingEsLintConfig.overrides ?? []),
+        {
+            files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
+            rules: {
+                '@nx/enforce-module-boundaries': [
+                    'error',
+                    {
+                        enforceBuildableLibDependency: true,
+                        allow: [],
+                        depConstraints: [
+                            { sourceTag: '*', onlyDependOnLibsWithTags: ['*'] },
+                        ],
+                    },
+                ],
+            },
+        },
+    ];
+    (0, devkit_1.writeJson)(tree, '.eslintrc.json', existingEsLintConfig);
+}
+exports.updateRootEsLintConfig = updateRootEsLintConfig;
+function cleanupEsLintPackages(tree) {
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        if (json.devDependencies?.['@angular-eslint/builder']) {
+            delete json.devDependencies['@angular-eslint/builder'];
+        }
+        if (json.dependencies?.['@angular-eslint/builder']) {
+            delete json.dependencies['@angular-eslint/builder'];
+        }
+        if (json.devDependencies?.['@angular-eslint/schematics']) {
+            delete json.devDependencies['@angular-eslint/schematics'];
+        }
+        if (json.dependencies?.['@angular-eslint/schematics']) {
+            delete json.dependencies['@angular-eslint/schematics'];
+        }
+        return json;
+    });
+}
+exports.cleanupEsLintPackages = cleanupEsLintPackages;
+async function createWorkspaceFiles(tree) {
+    updateVsCodeRecommendedExtensions(tree);
+    await (0, js_1.initGenerator)(tree, { skipFormat: true });
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, '../files/root'), '.', {
+        tmpl: '',
+        dot: '.',
+        rootTsConfigPath: (0, js_1.getRootTsConfigPathInTree)(tree),
+    });
+}
+exports.createWorkspaceFiles = createWorkspaceFiles;
+function createRootKarmaConfig(tree) {
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/root-karma'), '.', {
+        tmpl: '',
+    });
+}
+exports.createRootKarmaConfig = createRootKarmaConfig;
+function getWorkspaceRootFileTypesInfo(tree, migrators) {
+    const workspaceRootFileTypesInfo = {
+        eslint: false,
+        karma: false,
+    };
+    if (tree.exists('.eslintrc.json')) {
+        workspaceRootFileTypesInfo.eslint = true;
+    }
+    if (tree.exists('karma.conf.js')) {
+        workspaceRootFileTypesInfo.karma = true;
+    }
+    if (workspaceRootFileTypesInfo.eslint && workspaceRootFileTypesInfo.karma) {
+        return workspaceRootFileTypesInfo;
+    }
+    for (const migrator of migrators) {
+        const projectInfo = migrator.getWorkspaceRootFileTypesInfo();
+        workspaceRootFileTypesInfo.eslint =
+            workspaceRootFileTypesInfo.eslint || projectInfo.eslint;
+        workspaceRootFileTypesInfo.karma =
+            workspaceRootFileTypesInfo.karma || projectInfo.karma;
+        if (workspaceRootFileTypesInfo.eslint && workspaceRootFileTypesInfo.karma) {
+            return workspaceRootFileTypesInfo;
+        }
+    }
+    return workspaceRootFileTypesInfo;
+}
+exports.getWorkspaceRootFileTypesInfo = getWorkspaceRootFileTypesInfo;
+function updateVsCodeRecommendedExtensions(tree) {
+    const recommendations = [
+        'nrwl.angular-console',
+        'angular.ng-template',
+        'dbaeumer.vscode-eslint',
+        'esbenp.prettier-vscode',
+    ];
+    if (tree.exists('.vscode/extensions.json')) {
+        (0, devkit_1.updateJson)(tree, '.vscode/extensions.json', (json) => {
+            json.recommendations = json.recommendations || [];
+            recommendations.forEach((extension) => {
+                if (!json.recommendations.includes(extension)) {
+                    json.recommendations.push(extension);
+                }
+            });
+            return json;
+        });
+    }
+    else {
+        (0, devkit_1.writeJson)(tree, '.vscode/extensions.json', {
+            recommendations,
+        });
+    }
+}
+exports.updateVsCodeRecommendedExtensions = updateVsCodeRecommendedExtensions;
+function deleteAngularJson(tree) {
+    const projects = (0, angular_json_1.toNewFormat)((0, devkit_1.readJson)(tree, 'angular.json')).projects;
+    if (!Object.keys(projects).length) {
+        tree.delete('angular.json');
+    }
+}
+exports.deleteAngularJson = deleteAngularJson;
+function deleteGitKeepFilesIfNotNeeded(tree) {
+    if (tree.children('apps').length > 1 && tree.exists('apps/.gitkeep')) {
+        tree.delete('apps/.gitkeep');
+    }
+    if (tree.children('libs').length > 1 && tree.exists('libs/.gitkeep')) {
+        tree.delete('libs/.gitkeep');
+    }
+}
+exports.deleteGitKeepFilesIfNotNeeded = deleteGitKeepFilesIfNotNeeded;

package/src/generators/ngrx/files/__directory__/__fileName__.actions.ts__tmpl__

@@ -0,0 +1,16 @@
+import { createAction, props } from '@ngrx/store';
+import { <%= className %>Entity } from './<%= fileName %>.models';
+
+export const init<%= className %> = createAction(
+  '[<%= className %> Page] Init'
+);
+
+export const load<%= className %>Success = createAction(
+  '[<%= className %>/API] Load <%= className %> Success',
+  props<{ <%= propertyName %>: <%= className %>Entity[] }>()
+);
+
+export const load<%= className %>Failure = createAction(
+  '[<%= className %>/API] Load <%= className %> Failure',
+  props<{ error: any }>()
+);

package/src/generators/ngrx/files/__directory__/__fileName__.effects.spec.ts__tmpl__

@@ -0,0 +1,37 @@
+import { TestBed } from '@angular/core/testing';
+import { provideMockActions } from '@ngrx/effects/testing';
+import { Action } from '@ngrx/store';
+import { provideMockStore } from '@ngrx/store/testing';
+import { hot } from 'jasmine-marbles';
+import { Observable } from 'rxjs';
+
+import * as <%= className %>Actions from './<%= fileName %>.actions';
+import { <%= className %>Effects } from './<%= fileName %>.effects';
+
+describe('<%= className %>Effects', () => {
+  let actions: Observable<Action>;
+  let effects: <%= className %>Effects;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [],
+      providers: [
+        <%= className %>Effects,
+        provideMockActions(() => actions),
+        provideMockStore()
+      ],
+    });
+
+    effects = TestBed.inject(<%= className %>Effects);
+  });
+
+  describe('init$', () => {
+    it('should work', () => {
+      actions = hot('-a-|', { a: <%= className %>Actions.init<%= className %>() });
+
+      const expected = hot('-a-|', { a: <%= className %>Actions.load<%= className %>Success({ <%= propertyName %>: [] }) });
+
+      expect(effects.init$).toBeObservable(expected);
+    });
+  });
+});

package/src/generators/ngrx/files/__directory__/__fileName__.effects.ts__tmpl__

@@ -0,0 +1,22 @@
+import { Injectable, inject } from '@angular/core';
+import { createEffect, Actions, ofType } from '@ngrx/effects';<% if (!importFromOperators) { %>
+import { switchMap, catchError, of } from 'rxjs';<% } else { %>
+import { of } from 'rxjs';
+import { switchMap, catchError } from 'rxjs/operators';<% } %>
+import * as <%= className %>Actions from './<%= fileName %>.actions';
+import * as <%= className %>Feature from './<%= fileName %>.reducer';
+
+@Injectable()
+export class <%= className %>Effects {
+  private actions$ = inject(Actions);
+
+  init$ = createEffect(() => this.actions$.pipe(
+    ofType(<%= className %>Actions.init<%= className %>),
+    switchMap(() => of(<%= className %>Actions.load<%= className %>Success({ <%= propertyName %>: [] }))),
+    catchError((error) => {
+        console.error('Error', error);
+        return of(<%= className %>Actions.load<%= className %>Failure({ error }));
+      }
+    )
+  ));
+}

package/src/generators/ngrx/files/__directory__/__fileName__.facade.spec.ts__tmpl__

@@ -0,0 +1,99 @@
+import { NgModule } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { EffectsModule } from '@ngrx/effects';
+import { StoreModule, Store } from '@ngrx/store';
+import { readFirst } from '@nx/angular/testing';
+
+import * as <%= className %>Actions from './<%= fileName %>.actions';
+import { <%= className %>Effects } from './<%= fileName %>.effects';
+import { <%= className %>Facade } from './<%= fileName %>.facade';
+import { <%= className %>Entity } from './<%= fileName %>.models';
+import {
+  <%= constantName %>_FEATURE_KEY,
+  <%= className %>State,
+  initial<%= className %>State,
+  <%= propertyName %>Reducer
+} from './<%= fileName %>.reducer';
+import * as <%= className %>Selectors from './<%= fileName %>.selectors';
+
+interface TestSchema {
+  <%= propertyName %>: <%= className %>State;
+}
+
+describe('<%= className %>Facade', () => {
+  let facade: <%= className %>Facade;
+  let store: Store<TestSchema>;
+  const create<%= className %>Entity = (id: string, name = ''): <%= className %>Entity => ({
+    id,
+    name: name || `name-${id}`
+  });
+
+  describe('used in NgModule', () => {
+    beforeEach(() => {
+      @NgModule({
+        imports: [
+          StoreModule.forFeature(<%= constantName %>_FEATURE_KEY, <%= propertyName %>Reducer),
+          EffectsModule.forFeature([<%= className %>Effects])
+        ],
+        providers: [<%= className %>Facade]
+      })
+      class CustomFeatureModule {}
+
+      @NgModule({
+        imports: [
+          StoreModule.forRoot({}),
+          EffectsModule.forRoot([]),
+          CustomFeatureModule,
+        ]
+      })
+      class RootModule {}
+      TestBed.configureTestingModule({ imports: [RootModule] });
+
+      store = TestBed.inject(Store);
+      facade = TestBed.inject(<%= className %>Facade);
+    });
+
+    /**
+     * The initially generated facade::loadAll() returns empty array
+     */
+    it('loadAll() should return empty list with loaded == true', async () => {
+      let list = await readFirst(facade.all<%= className %>$);
+      let isLoaded = await readFirst(facade.loaded$);
+
+      expect(list.length).toBe(0);
+      expect(isLoaded).toBe(false);
+
+      facade.init();
+
+      list = await readFirst(facade.all<%= className %>$);
+      isLoaded = await readFirst(facade.loaded$);
+
+      expect(list.length).toBe(0);
+      expect(isLoaded).toBe(true);
+    });
+
+    /**
+     * Use `load<%= className %>Success` to manually update list
+     */
+    it('all<%= className %>$ should return the loaded list; and loaded flag == true', async () => {
+      let list = await readFirst(facade.all<%= className %>$);
+      let isLoaded = await readFirst(facade.loaded$);
+
+      expect(list.length).toBe(0);
+      expect(isLoaded).toBe(false);
+
+      store.dispatch(<%= className %>Actions.load<%= className %>Success({
+        <%= propertyName %>: [
+          create<%= className %>Entity('AAA'),
+          create<%= className %>Entity('BBB')
+        ]})
+      );
+
+      list = await readFirst(facade.all<%= className %>$);
+      isLoaded = await readFirst(facade.loaded$);
+
+      expect(list.length).toBe(2);
+      expect(isLoaded).toBe(true);
+    });
+  });
+});

package/src/generators/ngrx/files/__directory__/__fileName__.facade.ts__tmpl__

@@ -0,0 +1,27 @@
+import { Injectable, inject } from '@angular/core';
+import { select, Store, Action } from '@ngrx/store';
+
+import * as <%= className %>Actions from './<%= fileName %>.actions';
+import * as <%= className %>Feature from './<%= fileName %>.reducer';
+import * as <%= className %>Selectors from './<%= fileName %>.selectors';
+
+@Injectable()
+export class <%= className %>Facade {
+  private readonly store = inject(Store);
+
+  /**
+   * Combine pieces of state using createSelector,
+   * and expose them as observables through the facade.
+   */
+  loaded$ = this.store.pipe(select(<%= className %>Selectors.select<%= className %>Loaded));
+  all<%= className %>$ = this.store.pipe(select(<%= className %>Selectors.selectAll<%= className %>));
+  selected<%= className %>$ = this.store.pipe(select(<%= className %>Selectors.selectEntity));
+
+  /**
+   * Use the initialization action to perform one
+   * or more tasks in your Effects.
+   */
+  init() {
+    this.store.dispatch(<%= className %>Actions.init<%= className %>());
+  }
+}

package/src/generators/ngrx/files/__directory__/__fileName__.models.ts__tmpl__

@@ -0,0 +1,7 @@
+/**
+ * Interface for the '<%= className %>' data
+ */
+export interface <%= className %>Entity {
+  id: string | number; // Primary ID
+  name: string;
+}

package/src/generators/ngrx/files/__directory__/__fileName__.reducer.spec.ts__tmpl__

@@ -0,0 +1,37 @@
+import { Action } from '@ngrx/store';
+
+import * as <%= className %>Actions from './<%= fileName %>.actions';
+import { <%= className %>Entity } from './<%= fileName %>.models';
+import { <%= className %>State, initial<%= className %>State, <%= propertyName %>Reducer } from './<%= fileName %>.reducer';
+
+describe('<%= className %> Reducer', () => {
+  const create<%= className %>Entity = (id: string, name = ''): <%= className %>Entity => ({
+    id,
+    name: name || `name-${id}`
+  });
+
+  describe('valid <%= className %> actions', () => {
+    it('load<%= className %>Success should return the list of known <%= className %>', () => {
+      const <%= propertyName %> = [
+        create<%= className %>Entity('PRODUCT-AAA'),
+        create<%= className %>Entity('PRODUCT-zzz')
+      ];
+      const action = <%= className %>Actions.load<%= className %>Success({ <%= propertyName %> });
+
+      const result: <%= className %>State = <%= propertyName %>Reducer(initial<%= className %>State, action);
+
+      expect(result.loaded).toBe(true);
+      expect(result.ids.length).toBe(2);
+    });
+  });
+
+  describe('unknown action', () => {
+    it('should return the previous state', () => {
+      const action = {} as Action;
+
+      const result = <%= propertyName %>Reducer(initial<%= className %>State, action);
+
+      expect(result).toBe(initial<%= className %>State);
+    });
+  });
+});

package/src/generators/ngrx/files/__directory__/__fileName__.reducer.ts__tmpl__

@@ -0,0 +1,41 @@
+import { EntityState, EntityAdapter, createEntityAdapter } from '@ngrx/entity';
+import { createReducer, on, Action } from '@ngrx/store';
+
+import * as <%= className %>Actions from './<%= fileName %>.actions';
+import { <%= className %>Entity } from './<%= fileName %>.models';
+
+export const <%= constantName %>_FEATURE_KEY = '<%= propertyName %>';
+
+export interface <%= className %>State extends EntityState<<%= className %>Entity> {
+  selectedId?: string | number; // which <%= className %> record has been selected
+  loaded: boolean; // has the <%= className %> list been loaded
+  error?: string | null; // last known error (if any)
+}
+
+export interface <%= className %>PartialState {
+  readonly [<%= constantName %>_FEATURE_KEY]: <%= className %>State;
+}
+
+export const <%= propertyName %>Adapter: EntityAdapter<<%= className %>Entity> = createEntityAdapter<<%= className %>Entity>();
+
+export const initial<%= className %>State: <%= className %>State = <%= propertyName %>Adapter.getInitialState({
+  // set initial required properties
+  loaded: false
+});
+
+const reducer = createReducer(
+  initial<%= className %>State,
+  on(<%= className %>Actions.init<%= className %>,
+    state => ({ ...state, loaded: false, error: null })
+  ),
+  on(<%= className %>Actions.load<%= className %>Success,
+    (state, { <%= propertyName %> }) => <%= propertyName %>Adapter.setAll(<%= propertyName %>, { ...state, loaded: true })
+  ),
+  on(<%= className %>Actions.load<%= className %>Failure,
+    (state, { error }) => ({ ...state, error })
+  ),
+);
+
+export function <%= propertyName %>Reducer(state: <%= className %>State | undefined, action: Action) {
+  return reducer(state, action);
+}

package/src/generators/ngrx/files/__directory__/__fileName__.selectors.spec.ts__tmpl__

@@ -0,0 +1,58 @@
+import { <%= className %>Entity } from './<%= fileName %>.models';
+import { <%= propertyName %>Adapter, <%= className %>PartialState, initial<%= className %>State } from './<%= fileName %>.reducer';
+import * as <%= className %>Selectors from './<%= fileName %>.selectors';
+
+describe('<%= className %> Selectors', () => {
+  const ERROR_MSG = 'No Error Available';
+  const get<%= className %>Id = (it: <%= className %>Entity) => it.id;
+  const create<%= className %>Entity = (id: string, name = '') => ({
+    id,
+    name: name || `name-${id}`
+  }) as <%= className %>Entity;
+
+  let state: <%= className %>PartialState;
+
+  beforeEach(() => {
+    state = {
+      <%= propertyName %>: <%= propertyName %>Adapter.setAll([
+        create<%= className %>Entity('PRODUCT-AAA'),
+        create<%= className %>Entity('PRODUCT-BBB'),
+        create<%= className %>Entity('PRODUCT-CCC')
+      ], {
+        ...initial<%= className %>State,
+        selectedId: 'PRODUCT-BBB',
+        error: ERROR_MSG,
+        loaded: true
+      })
+    };
+  });
+
+  describe('<%= className %> Selectors', () => {
+    it('selectAll<%= className %>() should return the list of <%= className %>', () => {
+      const results = <%= className %>Selectors.selectAll<%= className %>(state);
+      const selId = get<%= className %>Id(results[1]);
+
+      expect(results.length).toBe(3);
+      expect(selId).toBe('PRODUCT-BBB');
+    });
+
+    it('selectEntity() should return the selected Entity', () => {
+      const result = <%= className %>Selectors.selectEntity(state) as <%= className %>Entity;
+      const selId = get<%= className %>Id(result);
+
+      expect(selId).toBe('PRODUCT-BBB');
+    });
+
+    it('select<%= className %>Loaded() should return the current "loaded" status', () => {
+      const result = <%= className %>Selectors.select<%= className %>Loaded(state);
+
+      expect(result).toBe(true);
+    });
+
+    it('select<%= className %>Error() should return the current "error" state', () => {
+      const result = <%= className %>Selectors.select<%= className %>Error(state);
+
+      expect(result).toBe(ERROR_MSG);
+    });
+  });
+});