@dugararchit/cdk 0.0.0-dugararchit

package/schematics/schematics/utils/build-component.ts

@@ -0,0 +1,252 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {strings, template as interpolateTemplate} from '@angular-devkit/core';
+import {
+  apply,
+  applyTemplates,
+  branchAndMerge,
+  chain,
+  filter,
+  mergeWith,
+  move,
+  noop,
+  Rule,
+  SchematicsException,
+  Tree,
+  url,
+} from '@angular-devkit/schematics';
+import {FileSystemSchematicContext} from '@angular-devkit/schematics/tools';
+import {Schema as ComponentOptions, Style} from '@schematics/angular/component/schema';
+import {InsertChange} from '@schematics/angular/utility/change';
+import {getWorkspace} from '@schematics/angular/utility/workspace';
+import {buildRelativePath, findModuleFromOptions} from '@schematics/angular/utility/find-module';
+import {parseName} from '@schematics/angular/utility/parse-name';
+import {validateHtmlSelector} from '@schematics/angular/utility/validation';
+import {ProjectType} from '@schematics/angular/utility/workspace-models';
+import {readFileSync, statSync} from 'fs';
+import {dirname, join, resolve} from 'path';
+import * as ts from 'typescript';
+import {addDeclarationToModule, addExportToModule} from '../utils/vendored-ast-utils';
+import {getProjectFromWorkspace} from './get-project';
+import {getDefaultComponentOptions} from './schematic-options';
+import {ProjectDefinition} from '@angular-devkit/core/src/workspace';
+
+/**
+ * Build a default project path for generating.
+ * @param project The project to build the path for.
+ */
+function buildDefaultPath(project: ProjectDefinition): string {
+  const root = project.sourceRoot ? `/${project.sourceRoot}/` : `/${project.root}/src/`;
+
+  const projectDirName = project.extensions.projectType === ProjectType.Application ? 'app' : 'lib';
+
+  return `${root}${projectDirName}`;
+}
+
+/**
+ * List of style extensions which are CSS compatible. All supported CLI style extensions can be
+ * found here: angular/angular-cli/main/packages/schematics/angular/ng-new/schema.json#L118-L122
+ */
+const supportedCssExtensions = ['css', 'scss', 'less'];
+
+function readIntoSourceFile(host: Tree, modulePath: string) {
+  const text = host.read(modulePath);
+  if (text === null) {
+    throw new SchematicsException(`File ${modulePath} does not exist.`);
+  }
+
+  return ts.createSourceFile(modulePath, text.toString('utf-8'), ts.ScriptTarget.Latest, true);
+}
+
+function addDeclarationToNgModule(options: ComponentOptions): Rule {
+  return (host: Tree) => {
+    if (options.skipImport || !options.module) {
+      return host;
+    }
+
+    const modulePath = options.module;
+    let source = readIntoSourceFile(host, modulePath);
+
+    const componentPath =
+      `/${options.path}/` +
+      (options.flat ? '' : strings.dasherize(options.name) + '/') +
+      strings.dasherize(options.name) +
+      '.component';
+    const relativePath = buildRelativePath(modulePath, componentPath);
+    const classifiedName = strings.classify(`${options.name}Component`);
+
+    const declarationChanges = addDeclarationToModule(
+      source,
+      modulePath,
+      classifiedName,
+      relativePath,
+    );
+
+    const declarationRecorder = host.beginUpdate(modulePath);
+    for (const change of declarationChanges) {
+      if (change instanceof InsertChange) {
+        declarationRecorder.insertLeft(change.pos, change.toAdd);
+      }
+    }
+    host.commitUpdate(declarationRecorder);
+
+    if (options.export) {
+      // Need to refresh the AST because we overwrote the file in the host.
+      source = readIntoSourceFile(host, modulePath);
+
+      const exportRecorder = host.beginUpdate(modulePath);
+      const exportChanges = addExportToModule(
+        source,
+        modulePath,
+        strings.classify(`${options.name}Component`),
+        relativePath,
+      );
+
+      for (const change of exportChanges) {
+        if (change instanceof InsertChange) {
+          exportRecorder.insertLeft(change.pos, change.toAdd);
+        }
+      }
+      host.commitUpdate(exportRecorder);
+    }
+
+    return host;
+  };
+}
+
+function buildSelector(options: ComponentOptions, projectPrefix?: string) {
+  let selector = strings.dasherize(options.name);
+  if (options.prefix) {
+    selector = `${options.prefix}-${selector}`;
+  } else if (options.prefix === undefined && projectPrefix) {
+    selector = `${projectPrefix}-${selector}`;
+  }
+
+  return selector;
+}
+
+/**
+ * Indents the text content with the amount of specified spaces. The spaces will be added after
+ * every line-break. This utility function can be used inside of EJS templates to properly
+ * include the additional files.
+ */
+function indentTextContent(text: string, numSpaces: number): string {
+  // In the Material project there should be only LF line-endings, but the schematic files
+  // are not being linted and therefore there can be also CRLF or just CR line-endings.
+  return text.replace(/(\r\n|\r|\n)/g, `$1${' '.repeat(numSpaces)}`);
+}
+
+/**
+ * Rule that copies and interpolates the files that belong to this schematic context. Additionally
+ * a list of file paths can be passed to this rule in order to expose them inside the EJS
+ * template context.
+ *
+ * This allows inlining the external template or stylesheet files in EJS without having
+ * to manually duplicate the file content.
+ */
+export function buildComponent(
+  options: ComponentOptions,
+  additionalFiles: {[key: string]: string} = {},
+): Rule {
+  return async (host, ctx) => {
+    const context = ctx as FileSystemSchematicContext;
+    const workspace = await getWorkspace(host);
+    const project = getProjectFromWorkspace(workspace, options.project);
+    const defaultComponentOptions = getDefaultComponentOptions(project);
+
+    // TODO(devversion): Remove if we drop support for older CLI versions.
+    // This handles an unreported breaking change from the @angular-devkit/schematics. Previously
+    // the description path resolved to the factory file, but starting from 6.2.0, it resolves
+    // to the factory directory.
+    const schematicPath = statSync(context.schematic.description.path).isDirectory()
+      ? context.schematic.description.path
+      : dirname(context.schematic.description.path);
+
+    const schematicFilesUrl = './files';
+    const schematicFilesPath = resolve(schematicPath, schematicFilesUrl);
+
+    // Add the default component option values to the options if an option is not explicitly
+    // specified but a default component option is available.
+    Object.keys(options)
+      .filter(
+        key =>
+          options[key as keyof ComponentOptions] == null &&
+          defaultComponentOptions[key as keyof ComponentOptions],
+      )
+      .forEach(
+        key =>
+          ((options as any)[key] = (defaultComponentOptions as ComponentOptions)[
+            key as keyof ComponentOptions
+          ]),
+      );
+
+    if (options.path === undefined) {
+      // TODO(jelbourn): figure out if the need for this `as any` is a bug due to two different
+      // incompatible `ProjectDefinition` classes in @angular-devkit
+      options.path = buildDefaultPath(project as any);
+    }
+
+    options.module = findModuleFromOptions(host, options);
+
+    const parsedPath = parseName(options.path!, options.name);
+
+    options.name = parsedPath.name;
+    options.path = parsedPath.path;
+    options.selector = options.selector || buildSelector(options, project.prefix);
+
+    validateHtmlSelector(options.selector!);
+
+    // In case the specified style extension is not part of the supported CSS supersets,
+    // we generate the stylesheets with the "css" extension. This ensures that we don't
+    // accidentally generate invalid stylesheets (e.g. drag-drop-comp.styl) which will
+    // break the Angular CLI project. See: https://github.com/angular/components/issues/15164
+    if (!supportedCssExtensions.includes(options.style!)) {
+      // TODO: Cast is necessary as we can't use the Style enum which has been introduced
+      // within CLI v7.3.0-rc.0. This would break the schematic for older CLI versions.
+      options.style = 'css' as Style;
+    }
+
+    // Object that will be used as context for the EJS templates.
+    const baseTemplateContext = {
+      ...strings,
+      'if-flat': (s: string) => (options.flat ? '' : s),
+      ...options,
+    };
+
+    // Key-value object that includes the specified additional files with their loaded content.
+    // The resolved contents can be used inside EJS templates.
+    const resolvedFiles: Record<string, string> = {};
+
+    for (let key in additionalFiles) {
+      if (additionalFiles[key]) {
+        const fileContent = readFileSync(join(schematicFilesPath, additionalFiles[key]), 'utf-8');
+
+        // Interpolate the additional files with the base EJS template context.
+        resolvedFiles[key] = interpolateTemplate(fileContent)(baseTemplateContext);
+      }
+    }
+
+    const templateSource = apply(url(schematicFilesUrl), [
+      options.skipTests ? filter(path => !path.endsWith('.spec.ts.template')) : noop(),
+      options.inlineStyle ? filter(path => !path.endsWith('.__style__.template')) : noop(),
+      options.inlineTemplate ? filter(path => !path.endsWith('.html.template')) : noop(),
+      // Treat the template options as any, because the type definition for the template options
+      // is made unnecessarily explicit. Every type of object can be used in the EJS template.
+      applyTemplates({indentTextContent, resolvedFiles, ...baseTemplateContext} as any),
+      // TODO(devversion): figure out why we cannot just remove the first parameter
+      // See for example: angular-cli#schematics/angular/component/index.ts#L160
+      move(null as any, parsedPath.path),
+    ]);
+
+    return () =>
+      chain([
+        branchAndMerge(chain([addDeclarationToNgModule(options), mergeWith(templateSource)])),
+      ])(host, context);
+  };
+}

package/schematics/schematics/utils/get-project.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ProjectDefinition, WorkspaceDefinition} from '@angular-devkit/core/src/workspace';
+import {SchematicsException} from '@angular-devkit/schematics';
+
+/**
+ * Finds the specified project configuration in the workspace. Throws an error if the project
+ * couldn't be found.
+ */
+export function getProjectFromWorkspace(
+  workspace: WorkspaceDefinition,
+  projectName = workspace.extensions.defaultProject as string,
+): ProjectDefinition {
+  const project = workspace.projects.get(projectName);
+
+  if (!project) {
+    throw new SchematicsException(`Could not find project in workspace: ${projectName}`);
+  }
+
+  return project;
+}

package/schematics/schematics/utils/html-manipulation.ts

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {SchematicsException, Tree} from '@angular-devkit/schematics';
+import {getChildElementIndentation} from './parse5-element';
+import {Element, parse as parseHtml} from 'parse5';
+
+/** Appends the given element HTML fragment to the `<head>` element of the specified HTML file. */
+export function appendHtmlElementToHead(host: Tree, htmlFilePath: string, elementHtml: string) {
+  const htmlFileBuffer = host.read(htmlFilePath);
+
+  if (!htmlFileBuffer) {
+    throw new SchematicsException(`Could not read file for path: ${htmlFilePath}`);
+  }
+
+  const htmlContent = htmlFileBuffer.toString();
+
+  if (htmlContent.includes(elementHtml)) {
+    return;
+  }
+
+  const headTag = getHtmlHeadTagElement(htmlContent);
+
+  if (!headTag) {
+    throw Error(`Could not find '<head>' element in HTML file: ${htmlFileBuffer}`);
+  }
+
+  // We always have access to the source code location here because the `getHeadTagElement`
+  // function explicitly has the `sourceCodeLocationInfo` option enabled.
+  const endTagOffset = headTag.sourceCodeLocation!.endTag.startOffset;
+  const indentationOffset = getChildElementIndentation(headTag);
+  const insertion = `${' '.repeat(indentationOffset)}${elementHtml}`;
+
+  const recordedChange = host.beginUpdate(htmlFilePath).insertRight(endTagOffset, `${insertion}\n`);
+
+  host.commitUpdate(recordedChange);
+}
+
+/** Parses the given HTML file and returns the head element if available. */
+export function getHtmlHeadTagElement(htmlContent: string): Element | null {
+  return getElementByTagName('head', htmlContent);
+}
+
+/** Adds a class to the body of the document. */
+export function addBodyClass(host: Tree, htmlFilePath: string, className: string): void {
+  const htmlFileBuffer = host.read(htmlFilePath);
+
+  if (!htmlFileBuffer) {
+    throw new SchematicsException(`Could not read file for path: ${htmlFilePath}`);
+  }
+
+  const htmlContent = htmlFileBuffer.toString();
+  const body = getElementByTagName('body', htmlContent);
+
+  if (!body) {
+    throw Error(`Could not find <body> element in HTML file: ${htmlFileBuffer}`);
+  }
+
+  const classAttribute = body.attrs.find(attribute => attribute.name === 'class');
+
+  if (classAttribute) {
+    const hasClass = classAttribute.value
+      .split(' ')
+      .map(part => part.trim())
+      .includes(className);
+
+    if (!hasClass) {
+      // We have source code location info enabled, and we pre-checked that the element
+      // has attributes, specifically the `class` attribute.
+      const classAttributeLocation = body.sourceCodeLocation!.attrs!.class;
+      const recordedChange = host
+        .beginUpdate(htmlFilePath)
+        .insertRight(classAttributeLocation.endOffset - 1, ` ${className}`);
+      host.commitUpdate(recordedChange);
+    }
+  } else {
+    const recordedChange = host
+      .beginUpdate(htmlFilePath)
+      .insertRight(body.sourceCodeLocation!.startTag.endOffset - 1, ` class="${className}"`);
+    host.commitUpdate(recordedChange);
+  }
+}
+
+/** Finds an element by its tag name. */
+function getElementByTagName(tagName: string, htmlContent: string): Element | null {
+  const document = parseHtml(htmlContent, {sourceCodeLocationInfo: true});
+  const nodeQueue = [...document.childNodes];
+
+  while (nodeQueue.length) {
+    const node = nodeQueue.shift() as Element;
+
+    if (node.nodeName.toLowerCase() === tagName) {
+      return node;
+    } else if (node.childNodes) {
+      nodeQueue.push(...node.childNodes);
+    }
+  }
+
+  return null;
+}

package/schematics/schematics/utils/index.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export * from './ast';
+export * from './ast/ng-module-imports';
+export * from './build-component';
+export * from './get-project';
+export * from './html-manipulation';
+export * from './parse5-element';
+export * from './project-index-file';
+export * from './project-main-file';
+export * from './project-style-file';
+export * from './project-targets';
+export * from './schematic-options';

package/schematics/schematics/utils/parse5-element.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {SchematicsException} from '@angular-devkit/schematics';
+import {Element} from 'parse5';
+
+/** Determines the indentation of child elements for the given Parse5 element. */
+export function getChildElementIndentation(element: Element) {
+  const childElement = element.childNodes.find(node => (node as Element).tagName) as Element | null;
+
+  if ((childElement && !childElement.sourceCodeLocation) || !element.sourceCodeLocation) {
+    throw new SchematicsException(
+      'Cannot determine child element indentation because the ' +
+        'specified Parse5 element does not have any source code location metadata.',
+    );
+  }
+
+  const startColumns = childElement
+    ? // In case there are child elements inside of the element, we assume that their
+      // indentation is also applicable for other child elements.
+      childElement.sourceCodeLocation!.startCol
+    : // In case there is no child element, we just assume that child elements should be indented
+      // by two spaces.
+      element.sourceCodeLocation!.startCol + 2;
+
+  // Since Parse5 does not set the `startCol` properties as zero-based, we need to subtract
+  // one column in order to have a proper zero-based offset for the indentation.
+  return startColumns - 1;
+}

package/schematics/schematics/utils/project-index-file.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Path} from '@angular-devkit/core';
+import {ProjectDefinition} from '@angular-devkit/core/src/workspace';
+import {defaultTargetBuilders, getTargetsByBuilderName} from './project-targets';
+
+/** Gets the path of the index file in the given project. */
+export function getProjectIndexFiles(project: ProjectDefinition): Path[] {
+  const paths = getTargetsByBuilderName(project, defaultTargetBuilders.build)
+    .filter(t => t.options?.index)
+    .map(t => t.options!.index as Path);
+
+  // Use a set to remove duplicate index files referenced in multiple build targets of a project.
+  return Array.from(new Set(paths));
+}

package/schematics/schematics/utils/project-main-file.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Path} from '@angular-devkit/core';
+import {ProjectDefinition} from '@angular-devkit/core/src/workspace';
+import {SchematicsException} from '@angular-devkit/schematics';
+import {getProjectTargetOptions} from './project-targets';
+
+/** Looks for the main TypeScript file in the given project and returns its path. */
+export function getProjectMainFile(project: ProjectDefinition): Path {
+  const buildOptions = getProjectTargetOptions(project, 'build');
+
+  if (!buildOptions.main) {
+    throw new SchematicsException(
+      `Could not find the project main file inside of the ` +
+        `workspace config (${project.sourceRoot})`,
+    );
+  }
+
+  return buildOptions.main as Path;
+}

package/schematics/schematics/utils/project-style-file.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isJsonArray, normalize} from '@angular-devkit/core';
+import {ProjectDefinition} from '@angular-devkit/core/src/workspace';
+import {getProjectTargetOptions} from './project-targets';
+
+/** Regular expression that matches all possible Angular CLI default style files. */
+const defaultStyleFileRegex = /styles\.(c|le|sc)ss/;
+
+/** Regular expression that matches all files that have a proper stylesheet extension. */
+const validStyleFileRegex = /\.(c|le|sc)ss/;
+
+/**
+ * Gets a style file with the given extension in a project and returns its path. If no
+ * extension is specified, any style file with a valid extension will be returned.
+ */
+export function getProjectStyleFile(project: ProjectDefinition, extension?: string): string | null {
+  const buildOptions = getProjectTargetOptions(project, 'build');
+  if (buildOptions.styles && isJsonArray(buildOptions.styles) && buildOptions.styles.length) {
+    const styles = buildOptions.styles.map(s =>
+      typeof s === 'string' ? s : (s as {input: string}).input,
+    );
+
+    // Look for the default style file that is generated for new projects by the Angular CLI. This
+    // default style file is usually called `styles.ext` unless it has been changed explicitly.
+    const defaultMainStylePath = styles.find(file =>
+      extension ? file === `styles.${extension}` : defaultStyleFileRegex.test(file),
+    );
+
+    if (defaultMainStylePath) {
+      return normalize(defaultMainStylePath);
+    }
+
+    // If no default style file could be found, use the first style file that matches the given
+    // extension. If no extension specified explicitly, we look for any file with a valid style
+    // file extension.
+    const fallbackStylePath = styles.find(file =>
+      extension ? file.endsWith(`.${extension}`) : validStyleFileRegex.test(file),
+    );
+
+    if (fallbackStylePath) {
+      return normalize(fallbackStylePath);
+    }
+  }
+
+  return null;
+}

package/schematics/schematics/utils/project-targets.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ProjectDefinition, TargetDefinition} from '@angular-devkit/core/src/workspace';
+import {JsonValue} from '@angular-devkit/core';
+import {SchematicsException} from '@angular-devkit/schematics';
+
+/** Object that maps a CLI target to its default builder name. */
+export const defaultTargetBuilders = {
+  build: '@angular-devkit/build-angular:browser',
+  test: '@angular-devkit/build-angular:karma',
+};
+
+/** Resolves the architect options for the build target of the given project. */
+export function getProjectTargetOptions(
+  project: ProjectDefinition,
+  buildTarget: string,
+): Record<string, JsonValue | undefined> {
+  const options = project.targets?.get(buildTarget)?.options;
+
+  if (!options) {
+    throw new SchematicsException(
+      `Cannot determine project target configuration for: ${buildTarget}.`,
+    );
+  }
+
+  return options;
+}
+
+/** Gets all targets from the given project that match the specified builder name. */
+export function getTargetsByBuilderName(
+  project: ProjectDefinition,
+  builderName: string,
+): TargetDefinition[] {
+  return Array.from(project.targets.keys())
+    .filter(name => project.targets.get(name)?.builder === builderName)
+    .map(name => project.targets.get(name)!);
+}

package/schematics/schematics/utils/project-tsconfig-paths.spec.ts

@@ -0,0 +1,91 @@
+import {HostTree} from '@angular-devkit/schematics';
+import {UnitTestTree} from '@angular-devkit/schematics/testing';
+import {WorkspacePath} from '../update-tool/file-system';
+import {getTargetTsconfigPath, getWorkspaceConfigGracefully} from './project-tsconfig-paths';
+
+describe('project tsconfig paths', () => {
+  let testTree: UnitTestTree;
+
+  beforeEach(() => {
+    testTree = new UnitTestTree(new HostTree());
+  });
+
+  it('should detect build tsconfig path inside of angular.json file', async () => {
+    testTree.create('/my-custom-config.json', '');
+    testTree.create(
+      '/angular.json',
+      JSON.stringify({
+        version: 1,
+        projects: {my_name: {architect: {build: {options: {tsConfig: './my-custom-config.json'}}}}},
+      }),
+    );
+
+    const config = await getWorkspaceConfigGracefully(testTree);
+    expect(config).not.toBeNull();
+    expect(getTargetTsconfigPath(config!.projects!.get('my_name')!, 'build')).toEqual(
+      'my-custom-config.json' as WorkspacePath,
+    );
+  });
+
+  it('should be able to read workspace configuration which is using JSON5 features', async () => {
+    testTree.create('/my-build-config.json', '');
+    testTree.create(
+      '/angular.json',
+      `{
+      // Comments, unquoted properties or trailing commas are only supported in JSON5.
+      version: 1,
+      projects: {
+        with_tests: {
+          targets: {
+            build: {
+              options: {
+                tsConfig: './my-build-config.json',
+              }
+            }
+          }
+        }
+      },
+    }`,
+    );
+
+    const config = await getWorkspaceConfigGracefully(testTree);
+    expect(config).not.toBeNull();
+    expect(getTargetTsconfigPath(config!.projects.get('with_tests')!, 'build')).toEqual(
+      'my-build-config.json' as WorkspacePath,
+    );
+  });
+
+  it('should detect test tsconfig path inside of angular.json file', async () => {
+    testTree.create('/my-test-config.json', '');
+    testTree.create(
+      '/angular.json',
+      JSON.stringify({
+        version: 1,
+        projects: {my_name: {architect: {test: {options: {tsConfig: './my-test-config.json'}}}}},
+      }),
+    );
+
+    const config = await getWorkspaceConfigGracefully(testTree);
+    expect(config).not.toBeNull();
+    expect(getTargetTsconfigPath(config!.projects.get('my_name')!, 'test')).toEqual(
+      'my-test-config.json' as WorkspacePath,
+    );
+  });
+
+  it('should detect test tsconfig path inside of .angular.json file', async () => {
+    testTree.create('/my-test-config.json', '');
+    testTree.create(
+      '/.angular.json',
+      JSON.stringify({
+        version: 1,
+        projects: {with_tests: {architect: {test: {options: {tsConfig: './my-test-config.json'}}}}},
+      }),
+    );
+
+    const config = await getWorkspaceConfigGracefully(testTree);
+    expect(config).not.toBeNull();
+    expect(getTargetTsconfigPath(config!.projects.get('with_tests')!, 'test')).toEqual(
+      'my-test-config.json' as WorkspacePath,
+    );
+  });
+});