@sentry/wizard 3.12.0 → 3.13.0

package/test/sourcemaps/tools/sentry-cli.test.ts

@@ -0,0 +1,51 @@
+import * as fs from 'fs';
+
+import { addSentryCommandToBuildCommand } from '../../../src/sourcemaps/tools/sentry-cli';
+
+import * as packageManagerHelpers from '../../../src/utils/package-manager';
+
+const writeFileSpy = jest
+  .spyOn(fs.promises, 'writeFile')
+  .mockImplementation(() => Promise.resolve());
+
+jest.mock('@clack/prompts', () => {
+  return {
+    log: {
+      info: jest.fn(),
+      success: jest.fn(),
+    },
+    confirm: jest.fn().mockResolvedValue(true),
+    isCancel: jest.fn().mockReturnValue(false),
+  };
+});
+
+describe('addSentryCommandToBuildCommand', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it.each([
+    [
+      packageManagerHelpers.NPM,
+      packageManagerHelpers.PNPM,
+      packageManagerHelpers.YARN,
+      packageManagerHelpers.BUN,
+    ],
+  ])('adds the cli command to the script command (%s)', async (_, pacMan) => {
+    jest
+      .spyOn(packageManagerHelpers, 'detectPackageManger')
+      .mockReturnValue(pacMan);
+    const packageJson = {
+      scripts: {
+        build: 'tsc',
+      },
+      version: '1.0.0',
+    };
+    await addSentryCommandToBuildCommand(packageJson);
+    expect(writeFileSpy).toHaveBeenCalledWith(
+      expect.stringContaining('package.json'),
+      expect.stringContaining(
+        `tsc && ${pacMan.runScriptCommand} sentry:sourcemaps`,
+      ),
+    );
+  });
+});

package/test/sourcemaps/tools/tsc.test.ts

@@ -0,0 +1,181 @@
+import * as fs from 'fs';
+import { enableSourcemaps } from '../../../src/sourcemaps/tools/tsc';
+
+function updateFileContent(content: string): void {
+  fileContent = content;
+}
+
+let fileContent = '';
+
+jest.mock('@clack/prompts', () => {
+  return {
+    log: {
+      info: jest.fn(),
+      success: jest.fn(),
+    },
+  };
+});
+
+jest
+  .spyOn(fs.promises, 'readFile')
+  .mockImplementation(() => Promise.resolve(fileContent));
+
+const writeFileSpy = jest
+  .spyOn(fs.promises, 'writeFile')
+  .mockImplementation(() => Promise.resolve(void 0));
+
+describe('enableSourcemaps', () => {
+  afterEach(() => {
+    fileContent = '';
+    jest.clearAllMocks();
+  });
+
+  it.each([
+    [
+      'no sourcemaps options',
+      `
+/**
+ * My TS config with comments
+ */
+{
+  "extends": "./tsconfig.build.json",
+
+  "compilerOptions": {
+    // line comment which should stay
+    "moduleResolution": "node16",
+    "outDir": "dist" // another inline comment
+  },
+
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}
+`,
+      `
+/**
+ * My TS config with comments
+ */
+{
+  "extends": "./tsconfig.build.json",
+
+  "compilerOptions": {
+    // line comment which should stay
+    "moduleResolution": "node16",
+
+    // another inline comment
+    "outDir": "dist",
+
+    "sourceMap": true,
+    "inlineSources": true,
+
+    // Set \`sourceRoot\` to  "/" to strip the build path prefix
+    // from generated source code references.
+    // This improves issue grouping in Sentry.
+    "sourceRoot": "/"
+  },
+
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}
+`,
+    ],
+    [
+      'a few sourcemaps options',
+      `
+/**
+ * My TS config with comments
+ */
+{
+  "extends": "./tsconfig.build.json",
+
+  "compilerOptions": {
+    // line comment which should stay
+    "moduleResolution": "node16",
+    "outDir": "dist", // another inline comment
+    "sourceMap": false,
+    "sourceRoot": "/src"
+  },
+
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}
+`,
+      `
+/**
+ * My TS config with comments
+ */
+{
+  "extends": "./tsconfig.build.json",
+
+  "compilerOptions": {
+    // line comment which should stay
+    "moduleResolution": "node16",
+
+    // another inline comment
+    "outDir": "dist",
+
+    "sourceMap": true,
+
+    // Set \`sourceRoot\` to  "/" to strip the build path prefix
+    // from generated source code references.
+    // This improves issue grouping in Sentry.
+    "sourceRoot": "/",
+
+    "inlineSources": true
+  },
+
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}
+`,
+    ],
+    [
+      'no compiler options',
+      `
+{
+    "include": [
+        "src/**/*",
+        "test/**/*"
+    ]
+}
+`,
+      `
+{
+    "include": [
+        "src/**/*",
+        "test/**/*"
+    ],
+
+    "compilerOptions": {
+        "sourceMap": true,
+        "inlineSources": true,
+
+        // Set \`sourceRoot\` to  "/" to strip the build path prefix
+        // from generated source code references.
+        // This improves issue grouping in Sentry.
+        "sourceRoot": "/"
+    }
+}
+`,
+    ],
+  ])(
+    'adds the plugin and enables source maps generation (%s)',
+    async (_, originalCode, expectedCode) => {
+      updateFileContent(originalCode);
+
+      const addedCode = await enableSourcemaps('');
+
+      expect(writeFileSpy).toHaveBeenCalledTimes(1);
+      const [[, fileContent]] = writeFileSpy.mock.calls;
+      expect(fileContent).toBe(expectedCode);
+      expect(addedCode).toBe(true);
+    },
+  );
+});

package/test/utils/ast-utils.test.ts

@@ -1,15 +1,22 @@
-import { hasSentryContent } from '../../src/utils/ast-utils';
+import {
+  getObjectProperty,
+  getOrSetObjectProperty,
+  hasSentryContent,
+  parseJsonC,
+  printJsonC,
+  setOrUpdateObjectProperty,
+} from '../../src/utils/ast-utils';
 
 import * as recast from 'recast';
+const b = recast.types.builders;
 
-describe('AST utils', () => {
-  describe('hasSentryContent', () => {
-    it.each([
-      `
+describe('hasSentryContent', () => {
+  it.each([
+    `
       const { sentryVitePlugin } = require("@sentry/vite-plugin");
       const somethingelse = require('gs');
     `,
-      `
+    `
         import { sentryVitePlugin } from "@sentry/vite-plugin";
         import * as somethingelse from 'gs';
 
@@ -17,47 +24,241 @@ describe('AST utils', () => {
             plugins: [sentryVitePlugin()]
         }
       `,
-    ])(
-      "returns true if a require('@sentry/') call was found in the parsed module",
-      (code) => {
-        // recast.parse returns a Program node (or fails) but it's badly typed as any
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        const program = recast.parse(code)
-          .program as recast.types.namedTypes.Program;
-        expect(hasSentryContent(program)).toBe(true);
-      },
-    );
+  ])(
+    "returns true if a require('@sentry/') call was found in the parsed module",
+    (code) => {
+      // recast.parse returns a Program node (or fails) but it's badly typed as any
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      const program = recast.parse(code)
+        .program as recast.types.namedTypes.Program;
+      expect(hasSentryContent(program)).toBe(true);
+    },
+  );
 
-    it.each([
-      `const whatever = require('something')`,
-      `// const {sentryWebpackPlugin} = require('@sentry/webpack-plugin')`,
-      `const {sAntryWebpackPlugin} = require('webpack-plugin-@sentry')`,
-      `
+  it.each([
+    `const whatever = require('something')`,
+    `// const {sentryWebpackPlugin} = require('@sentry/webpack-plugin')`,
+    `const {sAntryWebpackPlugin} = require('webpack-plugin-@sentry')`,
+    `
       import * as somethingelse from 'gs';
       export default {
           plugins: []
       }
       `,
-      `import * as somethingelse from 'gs';
+    `import * as somethingelse from 'gs';
        // import { sentryVitePlugin } from "@sentry/vite-plugin"
       export default {
           plugins: []
       }
       `,
-      `import * as thirdPartyVitePlugin from "vite-plugin-@sentry"
+    `import * as thirdPartyVitePlugin from "vite-plugin-@sentry"
       export default {
         plugins: [thirdPartyVitePlugin()]
       }
       `,
-    ])(
-      "returns false if the file doesn't contain any require('@sentry/') calls",
-      (code) => {
-        // recast.parse returns a Program node (or fails) but it's badly typed as any
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        const program = recast.parse(code)
-          .program as recast.types.namedTypes.Program;
-        expect(hasSentryContent(program)).toBe(false);
-      },
+  ])(
+    "returns false if the file doesn't contain any require('@sentry/') calls",
+    (code) => {
+      // recast.parse returns a Program node (or fails) but it's badly typed as any
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      const program = recast.parse(code)
+        .program as recast.types.namedTypes.Program;
+      expect(hasSentryContent(program)).toBe(false);
+    },
+  );
+});
+
+describe('getObjectProperty', () => {
+  it.each([
+    [
+      'literal',
+      b.objectExpression([
+        b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+        b.objectProperty(
+          b.stringLiteral('needle'),
+          b.stringLiteral('haystack'),
+        ),
+      ]),
+    ],
+    [
+      'stringLiteral',
+      b.objectExpression([
+        b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+        b.objectProperty(b.literal('needle'), b.stringLiteral('haystack')),
+      ]),
+    ],
+    [
+      'identifier',
+      b.objectExpression([
+        b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+        b.objectProperty(b.identifier('needle'), b.stringLiteral('haystack')),
+      ]),
+    ],
+  ])('returns the poperty (%s) if it exists', (_, object) => {
+    const property = getObjectProperty(object, 'needle');
+    expect(property).toBeDefined();
+    // @ts-expect-error we know it's defined due to the expect above
+    expect(recast.print(property).code).toEqual(
+      expect.stringContaining('needle'),
     );
   });
+
+  it('returns undefined if the property does not exist', () => {
+    const object = b.objectExpression([
+      b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+    ]);
+    const property = getObjectProperty(object, 'needle');
+    expect(property).toBeUndefined();
+  });
+
+  it('handles objects without simple properties', () => {
+    const object = b.objectExpression([b.spreadElement(b.identifier('foo'))]);
+    const property = getObjectProperty(object, 'needle');
+    expect(property).toBeUndefined();
+  });
+});
+
+describe('getOrSetObjectProperty', () => {
+  it('returns the property if it exists', () => {
+    const object = b.objectExpression([
+      b.objectProperty(b.identifier('needle'), b.stringLiteral('haystack')),
+    ]);
+
+    const property = getOrSetObjectProperty(
+      object,
+      'needle',
+      b.stringLiteral('nope'),
+    );
+
+    expect(property).toBeDefined();
+    expect(property.type).toBe('ObjectProperty');
+    // @ts-expect-error we know its type
+    expect(property.key.name).toBe('needle');
+    // @ts-expect-error we know its type
+    expect(property.value.value).toBe('haystack');
+  });
+
+  it('adds the property if it does not exist', () => {
+    const object = b.objectExpression([
+      b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+    ]);
+
+    const property = getOrSetObjectProperty(
+      object,
+      'needle',
+      b.stringLiteral('haystack'),
+    );
+
+    expect(property).toBeDefined();
+    expect(property.type).toBe('Property');
+    // @ts-expect-error we know its type
+    expect(property.key.value).toBe('needle');
+    // @ts-expect-error we know its type
+    expect(property.value.value).toBe('haystack');
+  });
+});
+
+describe('setOrUpdateObjectProperty', () => {
+  it('sets a new property if it does not exist yet', () => {
+    const object = b.objectExpression([
+      b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+    ]);
+
+    setOrUpdateObjectProperty(object, 'needle', b.stringLiteral('haystack'));
+
+    expect(getObjectProperty(object, 'needle')).toBeDefined();
+  });
+
+  it('updates an existing property if it exists', () => {
+    const object = b.objectExpression([
+      b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+      b.objectProperty(b.identifier('needle'), b.stringLiteral('haystack')),
+    ]);
+
+    setOrUpdateObjectProperty(object, 'needle', b.stringLiteral('haystack2'));
+
+    const property = getObjectProperty(object, 'needle');
+    // @ts-expect-error it must be defiend, otherwise we fail anyway
+    expect(property?.value.value).toBe('haystack2');
+  });
+
+  it('adds a comment to the existing property if provided', () => {
+    const object = b.objectExpression([
+      b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+    ]);
+
+    setOrUpdateObjectProperty(
+      object,
+      'needle',
+      b.stringLiteral('haystack'),
+      'This is a comment',
+    );
+
+    const property = getObjectProperty(object, 'needle');
+    expect(property?.comments).toHaveLength(1);
+    // @ts-expect-error it must be defiend, otherwise we fail anyway
+    expect(property?.comments[0].value).toBe(' This is a comment');
+  });
+
+  it('adds a comment to the new property if provided', () => {
+    const object = b.objectExpression([
+      b.objectProperty(b.identifier('foo'), b.stringLiteral('bar')),
+    ]);
+
+    setOrUpdateObjectProperty(
+      object,
+      'needle',
+      b.stringLiteral('haystack'),
+      'This is a comment',
+    );
+
+    const property = getObjectProperty(object, 'needle');
+    expect(property?.comments).toHaveLength(1);
+    // @ts-expect-error it must be defiend, otherwise we fail anyway
+    expect(property?.comments[0].value).toBe(' This is a comment');
+  });
+});
+
+describe('parse and print JSON-C', () => {
+  it.each([
+    ['simple JSON', "{'foo': 'bar'}"],
+    [
+      'JSON-C with inline comment',
+      `
+    {
+      "foo": "bar" // with an inline comment
+    }
+    `,
+    ],
+    [
+      'JSON-C with multiple comments',
+      `
+    /*
+     * let's throw in a block comment for good measure
+     */  
+    {
+      // one line comment
+      "foo": "bar", // another inline comment
+      /* one more here */
+      "dogs": /* and here */ "awesome",
+    }
+    /* and here */
+    `,
+    ],
+  ])(`parses and prints JSON-C (%s)`, (_, json) => {
+    const { ast, jsonObject } = parseJsonC(json);
+    expect(ast?.type).toBe('Program');
+    expect(jsonObject).toBeDefined();
+    expect(jsonObject?.type).toBe('ObjectExpression');
+    // @ts-expect-error we know it's defined due to the expect above
+    expect(printJsonC(ast)).toEqual(json);
+  });
+
+  it('returns undefined if the input is not valid JSON-C', () => {
+    const { ast, jsonObject } = parseJsonC(`{
+      "invalid": // "json"
+    }`);
+    expect(ast).toBeUndefined();
+    expect(jsonObject).toBeUndefined();
+  });
 });