@platformos/platformos-check-common 0.0.2

package/src/test/chai-suggest-assertion.ts

@@ -0,0 +1,62 @@
+import { chai } from 'vitest';
+import { createCorrector, flattenFixes } from '../fixes';
+import { Offense, Fix } from '../types';
+
+const { util } = chai;
+
+declare module 'vitest' {
+  interface Assertion {
+    /**
+     * @param source {string} - the source to correct
+     * @param message {string} - the suggestion message
+     * @param fix {Fix} - the Fix suggested
+     *
+     * @example
+     * expect(offense).to.suggest(file, 'Use an HTML script tag with the defer attribute instead', {
+     *   startIndex: 0,
+     *   endIndex: file.length,
+     *   insert: '<script ... defer></script>'
+     * });
+     */
+    suggest: (source: string, message: string, suggestion?: Fix) => void;
+  }
+}
+
+export const SuggestAssertion = {
+  name: 'suggest',
+  fn: function (this: Chai.AssertionPrototype, ...args: any[]) {
+    const offense: Offense = this._obj;
+    const source: string = args.at(0);
+    const expectedMessage: string = args.at(1);
+    const expectedFix: Fix | undefined = args.at(2);
+
+    const suggestions = offense.suggest?.map((suggestion) => {
+      const corrector = createCorrector(offense.type, source);
+      suggestion.fix(corrector as any);
+      return {
+        message: suggestion.message,
+        fix: flattenFixes(corrector.fix),
+      };
+    });
+
+    const hasSuggestion = !!suggestions?.some(
+      (appliedSuggestion) =>
+        util.eql(appliedSuggestion.message, expectedMessage) &&
+        (!expectedFix || util.eql(appliedSuggestion.fix, flattenFixes(expectedFix))),
+    );
+
+    const ok = !!offense.suggest && offense.suggest.length > 0 && hasSuggestion;
+    const expectedAppliedSuggestion = { message: expectedMessage, fix: [expectedFix] };
+
+    this.assert(
+      ok,
+      `expected ${util.inspect(suggestions)} to include ${util.inspect(expectedAppliedSuggestion)}`,
+      `expected ${util.inspect(suggestions)} not to include ${util.inspect(
+        expectedAppliedSuggestion,
+      )}`,
+      Array(suggestions?.length).fill(expectedAppliedSuggestion),
+      suggestions,
+      true, // show diff
+    );
+  },
+};

package/src/test/contain-offense.spec.ts

@@ -0,0 +1,74 @@
+import { expect, describe, it } from 'vitest';
+import { Offense, SourceCodeType } from '../types';
+import { path } from '..';
+
+const rootUri = 'file:///';
+
+describe('Module: containOffense', () => {
+  const offenses: Offense[] = [
+    buildOffense(`The translation for 'hello.world' is missing`, 'locales/en.json'),
+    buildOffense(`'app/views/partials/missing.liquid' does not exist`, 'layout/theme.liquid'),
+  ];
+
+  describe('with string assertions', () => {
+    it(`should contain the "The translation for 'hello.world' is missing" string`, () => {
+      expect(offenses).to.containOffense(`The translation for 'hello.world' is missing`);
+    });
+
+    it(`should not contain the "!!!" string`, () => {
+      expect(offenses).to.not.containOffense('!!!');
+    });
+  });
+
+  describe('with `Offense` assertions', () => {
+    it(`should contain the Offense when their messages and absolute paths match`, () => {
+      expect(offenses).to.containOffense(
+        buildOffense(`The translation for 'hello.world' is missing`, 'locales/en.json'),
+      );
+    });
+
+    it(`should not contain the Offense when their messages match but absolute paths don't match`, () => {
+      expect(offenses).to.not.containOffense(
+        buildOffense(`The translation for 'hello.world' is missing`, 'layout/password.liquid'),
+      );
+    });
+
+    it(`should not contain the Offense when their absolute paths match but messages don't match`, () => {
+      expect(offenses).to.not.containOffense(buildOffense('!!!', 'layout/theme.liquid'));
+    });
+
+    it(`should not contain the Offense when their absolute paths and messages don't match`, () => {
+      expect(offenses).to.not.containOffense(buildOffense('!!!', '!!!.liquid'));
+    });
+
+    describe('with `Offense` optional properties', () => {
+      it(`should contain the Offense when their all properties match`, () => {
+        expect(offenses).to.containOffense({
+          message: `The translation for 'hello.world' is missing`,
+          uri: 'file:///locales/en.json',
+          severity: 0,
+        });
+      });
+
+      it(`should not contain the Offense when their messages and absolute paths match, but severity doesn't match`, () => {
+        expect(offenses).to.not.containOffense({
+          message: `The translation for 'hello.world' is missing`,
+          uri: 'file:///locales/en.json',
+          severity: 1,
+        });
+      });
+    });
+  });
+
+  function buildOffense(message: string, relativePath: string): Offense {
+    return {
+      type: SourceCodeType.LiquidHtml,
+      message,
+      uri: path.join(rootUri, relativePath),
+      check: '',
+      severity: 0,
+      start: { index: 0, line: 0, character: 0 },
+      end: { index: 0, line: 0, character: 0 },
+    };
+  }
+});

package/src/test/contain-offense.ts

@@ -0,0 +1,54 @@
+import { ExpectationResult, MatcherState, RawMatcherFn } from '@vitest/expect';
+import { Offense } from '../types';
+
+interface CustomMatchers<R = unknown> {
+  containOffense(offense: any): R;
+}
+
+declare module 'vitest' {
+  interface Assertion<T = any> extends CustomMatchers<T> {}
+  interface AsymmetricMatchersContaining extends CustomMatchers {}
+}
+
+export const containOffense: RawMatcherFn<MatcherState> = function (
+  this: MatcherState,
+  offenses: Offense[],
+  expected: any,
+): ExpectationResult {
+  const { isNot, equals } = this;
+
+  const isExpectingString = typeof expected === 'string';
+  if (isExpectingString) {
+    const containsMessage = offenses.some((offense) => offense.message === expected);
+
+    return {
+      pass: containsMessage,
+      message: () =>
+        `expected offenses to ${isNot ? 'not ' : ''}contain offense with message ${expected}`,
+      actual: offenses.map((offense) => offense.message),
+      expected: [expected],
+    };
+  }
+
+  // Verify that the offenses contains an offense with the subset of expected keys specified.
+  const containsOffense = offenses.some((offense) => {
+    // For each offense, we need to systematically check each expected value satisfies the value in the actual offense.
+    return Object.entries(expected).every(([expectedKey, expectedValue]) => {
+      if (expectedKey in offense) {
+        // @ts-ignore - typescript doesn't like dynamic key traversal
+        const actualValue = offense[expectedKey];
+
+        return equals(actualValue, expectedValue);
+      }
+
+      return false;
+    });
+  });
+
+  return {
+    pass: containsOffense,
+    message: () => `expected offenses to${isNot ? ' not' : ''} include the specified offense`,
+    actual: offenses,
+    expected: expected,
+  };
+};

package/src/test/index.ts

@@ -0,0 +1,3 @@
+export * from './MockFileSystem';
+export * from './MockTheme';
+export * from './test-helper';

package/src/test/test-helper.ts

@@ -0,0 +1,327 @@
+import { isLiquidHtmlNode } from '@platformos/liquid-html-parser';
+import {
+  applyFixToString,
+  CheckDefinition,
+  ChecksSettings,
+  Config,
+  autofix as coreAutofix,
+  check as coreCheck,
+  createCorrector,
+  Dependencies,
+  extractDocDefinition,
+  FixApplicator,
+  isBlock,
+  isSection,
+  JSONCorrector,
+  JSONSourceCode,
+  LiquidSourceCode,
+  Offense,
+  recommended,
+  SectionSchema,
+  SourceCodeType,
+  StringCorrector,
+  Theme,
+  ThemeBlockSchema,
+  toSchema,
+  toSourceCode,
+} from '../index';
+import * as path from '../path';
+import { MockFileSystem } from './MockFileSystem';
+import { MockTheme } from './MockTheme';
+
+export { JSONCorrector, StringCorrector };
+
+const rootUri = path.normalize('file:/');
+
+export function getTheme(themeDesc: MockTheme): Theme {
+  return Object.entries(themeDesc)
+    .map(([relativePath, source]) => toSourceCode(toUri(relativePath), source))
+    .filter((x): x is LiquidSourceCode | JSONSourceCode => x !== undefined);
+}
+
+export async function check(
+  themeDesc: MockTheme,
+  checks: CheckDefinition[] = recommended,
+  mockDependencies: Partial<Dependencies> = {},
+  checkSettings: ChecksSettings = {},
+): Promise<Offense[]> {
+  const theme = getTheme(themeDesc);
+  const config: Config = {
+    context: 'theme',
+    settings: { ...checkSettings },
+    checks,
+    rootUri,
+    onError: (err) => {
+      throw err;
+    },
+  };
+
+  const sections = new Map(
+    theme
+      .filter((source) => isSection(source.uri))
+      .map((source) => [path.basename(source.uri, '.liquid'), source]),
+  );
+  const blocks = new Map(
+    theme
+      .filter((source) => isBlock(source.uri))
+      .map((source) => [path.basename(source.uri, '.liquid'), source]),
+  );
+
+  /**
+   * Schemas are assumed to be valid in tests, hijack
+   * getBlockSchema/getSectionSchema with overrides when you want to test
+   * something otherwise
+   */
+  const isValidSchema = async () => true;
+
+  const defaultMockDependencies: Dependencies = {
+    fs: new MockFileSystem({ '.theme-check.yml': '', ...themeDesc }),
+    async getBlockSchema(name) {
+      const block = blocks.get(name);
+      if (!block) return undefined;
+      return toSchema(config.context, block.uri, block, isValidSchema) as Promise<
+        ThemeBlockSchema | undefined
+      >;
+    },
+    async getSectionSchema(name) {
+      const section = sections.get(name);
+      if (!section) return undefined;
+      return toSchema(config.context, section.uri, section, isValidSchema) as Promise<
+        SectionSchema | undefined
+      >;
+    },
+    async getDocDefinition(relativePath) {
+      const file = theme.find((file) => file.uri.endsWith(relativePath));
+      if (!file || !isLiquidHtmlNode(file.ast)) {
+        return undefined;
+      }
+      return extractDocDefinition(file.uri, file.ast);
+    },
+    themeDocset: {
+      async graphQL() {
+        return null;
+      },
+      async filters() {
+        return [
+          { name: 'item_count_for_variant' },
+          { name: 'link_to_type' },
+          { name: 'link_to_vendor' },
+          { name: 'append' },
+          { name: 'upcase' },
+          { name: 'downcase' },
+          { name: 'color_to_rgb' },
+          {
+            name: 'hex_to_rgba',
+            deprecated: true,
+            deprecation_reason: '`hex_to_rgba` has been replaced by [`color_to_rgb`](/do...',
+          },
+          {
+            name: 'currency_selector',
+            deprecated: true,
+            deprecation_reason: 'Deprecated without a direct replacement because the [cur...',
+          },
+          {
+            name: 'article_img_url',
+            deprecated: true,
+            deprecation_reason: '`article_img_url` has been replaced by [`image_url`](/d...',
+          },
+          {
+            name: 'collection_img_url',
+            deprecated: true,
+            deprecation_reason: '`collection_img_url` has been replaced by [`image_url`](...',
+          },
+          {
+            name: 'img_tag',
+            deprecated: true,
+            deprecation_reason: '`img_tag` has been replaced by [`image_tag`](/docs/api/...',
+          },
+          {
+            name: 'img_url',
+            deprecated: true,
+            deprecation_reason: '`img_url` has been replaced by [`image_url`](/docs/api/...',
+          },
+          {
+            name: 'product_img_url',
+            deprecated: true,
+            deprecation_reason: '`product_img_url` has been replaced by [`image_url`](/d...',
+          },
+        ];
+      },
+      async objects() {
+        return [
+          {
+            name: 'collections',
+          },
+          {
+            name: 'product',
+            access: {
+              global: false,
+              parents: [],
+              template: ['product'],
+            },
+          },
+          {
+            name: 'image',
+            access: {
+              global: false,
+              parents: [],
+              template: [],
+            },
+          },
+          {
+            name: 'section',
+            access: {
+              global: false,
+              parents: [],
+              template: [],
+            },
+          },
+          {
+            name: 'block',
+            access: {
+              global: false,
+              parents: [],
+              template: [],
+            },
+          },
+          {
+            name: 'app',
+            access: {
+              global: false,
+              parents: [],
+              template: [],
+            },
+          },
+          {
+            name: 'predictive_search',
+            access: {
+              global: false,
+              parents: [],
+              template: [],
+            },
+          },
+          {
+            name: 'recommendations',
+            access: {
+              global: false,
+              parents: [],
+              template: [],
+            },
+          },
+          {
+            name: 'comment',
+            access: {
+              global: false,
+              parents: [],
+              template: [],
+            },
+          },
+        ];
+      },
+      async liquidDrops() {
+        return this.objects();
+      },
+      async tags() {
+        return [];
+      },
+      async systemTranslations() {
+        return { 'shopify.sentence.words_connector': ', ' };
+      },
+    },
+  };
+
+  return coreCheck(theme, config, { ...defaultMockDependencies, ...mockDependencies });
+}
+
+export async function runLiquidCheck(
+  checkDef: CheckDefinition<SourceCodeType.LiquidHtml>,
+  sourceCode: string,
+  fileName: string = 'file.liquid',
+  mockDependencies: Partial<Dependencies> = {},
+  existingThemeFiles?: MockTheme,
+): Promise<Offense[]> {
+  const offenses = await check(
+    { ...existingThemeFiles, [fileName]: sourceCode },
+    [checkDef],
+    mockDependencies,
+  );
+  return offenses.filter((offense) => offense.uri === path.join(rootUri, fileName));
+}
+
+export async function runJSONCheck(
+  checkDef: CheckDefinition<SourceCodeType.JSON>,
+  sourceCode: string,
+  fileName: string = 'file.json',
+  mockDependencies: Partial<Dependencies> = {},
+): Promise<Offense[]> {
+  const offenses = await check({ [fileName]: sourceCode }, [checkDef], mockDependencies);
+  return offenses.filter((offense) => offense.uri === path.join(rootUri, fileName));
+}
+
+export async function autofix(themeDesc: MockTheme, offenses: Offense[]) {
+  const theme = getTheme(themeDesc);
+  const fixed = { ...themeDesc };
+
+  const stringApplicator: FixApplicator = async (sourceCode, fixes) => {
+    fixed[asRelative(sourceCode.uri)] = applyFixToString(sourceCode.source, fixes);
+  };
+
+  await coreAutofix(theme, offenses, stringApplicator);
+
+  return fixed;
+}
+
+export function applyFix(
+  themeDescOrSource: MockTheme | string,
+  offense: Offense,
+): string | undefined {
+  const source =
+    typeof themeDescOrSource === 'string'
+      ? themeDescOrSource
+      : themeDescOrSource[asRelative(offense.uri)];
+  const corrector = createCorrector(offense.type, source);
+  offense.fix?.(corrector as any);
+  return applyFixToString(source, corrector.fix);
+}
+
+export function applySuggestions(
+  themeDescOrSource: MockTheme | string,
+  offense: Offense,
+): undefined | string[] {
+  const source =
+    typeof themeDescOrSource === 'string'
+      ? themeDescOrSource
+      : themeDescOrSource[asRelative(offense.uri)];
+  return offense.suggest?.map((suggestion) => {
+    const corrector = createCorrector(offense.type, source);
+    suggestion.fix(corrector as any);
+    return applyFixToString(source, corrector.fix);
+  });
+}
+
+export function highlightedOffenses(themeOrSource: MockTheme | string, offenses: Offense[]) {
+  const theme =
+    typeof themeOrSource === 'string' ? { 'file.liquid': themeOrSource } : themeOrSource;
+  return offenses.map((offense) => {
+    const relativePath = path.relative(offense.uri, rootUri);
+    const source = theme[relativePath];
+    const {
+      start: { index: startIndex },
+      end: { index: endIndex },
+    } = offense;
+
+    return source.slice(startIndex, endIndex);
+  });
+}
+
+function toUri(relativePath: string) {
+  return path.join(rootUri, relativePath);
+}
+
+function asRelative(uri: string) {
+  return path.relative(path.normalize(uri), rootUri);
+}
+
+export function prettyJSON(obj: any): string {
+  return JSON.stringify(obj, null, 2);
+}

package/src/test/test-setup.ts

@@ -0,0 +1,36 @@
+import { chai, expect } from 'vitest';
+import { containOffense } from './contain-offense';
+import { OfferFixAssertion } from './chai-offer-fix-assertion';
+import { SuggestAssertion } from './chai-suggest-assertion';
+
+// Undocumented, but chai/utils has `.eql` for deep equality checks
+declare global {
+  export namespace Chai {
+    interface ChaiUtils {
+      /** deep equality */
+      eql: (a: any, b: any) => boolean;
+    }
+  }
+}
+
+/**
+ * Setup chai extensions
+ *
+ * These are deprecated in favor of vitest matchers.
+ */
+const chaiAssertions = [OfferFixAssertion, SuggestAssertion];
+chaiAssertions.forEach(({ name, fn }) => {
+  chai.Assertion.addMethod(name, fn);
+});
+
+/**
+ * Setup vitest matcher extensions
+ *
+ * All new matchers should be written this way.
+ */
+expect.extend({ containOffense });
+
+process.on('unhandledRejection', (reason) => {
+  console.error(reason);
+  debugger;
+});