Add unit tests for role middleware

node_modules/@jest/pattern/src/__tests__/TestPathPatterns.test.ts

@@ -0,0 +1,259 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import * as path from 'path';
+import {
+  TestPathPatterns,
+  TestPathPatternsExecutor,
+  type TestPathPatternsExecutorOptions,
+} from '../TestPathPatterns';
+
+const mockSep: jest.Mock<() => string> = jest.fn();
+const mockIsAbsolute: jest.Mock<(p: string) => boolean> = jest.fn();
+const mockRelative: jest.Mock<(from: string, to: string) => string> = jest.fn();
+jest.mock('path', () => {
+  const actualPath = jest.requireActual('path');
+  return {
+    ...actualPath,
+    isAbsolute(p) {
+      return mockIsAbsolute(p) || actualPath.isAbsolute(p);
+    },
+    relative(from, to) {
+      return mockRelative(from, to) || actualPath.relative(from, to);
+    },
+    get sep() {
+      return mockSep() || actualPath.sep;
+    },
+  } as typeof path;
+});
+const forcePosix = () => {
+  mockSep.mockReturnValue(path.posix.sep);
+  mockIsAbsolute.mockImplementation(path.posix.isAbsolute);
+  mockRelative.mockImplementation(path.posix.relative);
+};
+const forceWindows = () => {
+  mockSep.mockReturnValue(path.win32.sep);
+  mockIsAbsolute.mockImplementation(path.win32.isAbsolute);
+  mockRelative.mockImplementation(path.win32.relative);
+};
+beforeEach(() => {
+  jest.resetAllMocks();
+  forcePosix();
+});
+
+const config = {rootDir: ''};
+
+interface TestPathPatternsLike {
+  isSet(): boolean;
+  isValid(): boolean;
+  toPretty(): string;
+}
+
+const testPathPatternsLikeTests = (
+  makePatterns: (
+    patterns: Array<string>,
+    options: TestPathPatternsExecutorOptions,
+  ) => TestPathPatternsLike,
+) => {
+  describe('isSet', () => {
+    it('returns false if no patterns specified', () => {
+      const testPathPatterns = makePatterns([], config);
+      expect(testPathPatterns.isSet()).toBe(false);
+    });
+
+    it('returns true if patterns specified', () => {
+      const testPathPatterns = makePatterns(['a'], config);
+      expect(testPathPatterns.isSet()).toBe(true);
+    });
+  });
+
+  describe('isValid', () => {
+    it('succeeds for empty patterns', () => {
+      const testPathPatterns = makePatterns([], config);
+      expect(testPathPatterns.isValid()).toBe(true);
+    });
+
+    it('succeeds for valid patterns', () => {
+      const testPathPatterns = makePatterns(['abc+', 'z.*'], config);
+      expect(testPathPatterns.isValid()).toBe(true);
+    });
+
+    it('fails for at least one invalid pattern', () => {
+      const testPathPatterns = makePatterns(['abc+', '(', 'z.*'], config);
+      expect(testPathPatterns.isValid()).toBe(false);
+    });
+  });
+
+  describe('toPretty', () => {
+    it('renders a human-readable string', () => {
+      const testPathPatterns = makePatterns(['a/b', 'c/d'], config);
+      expect(testPathPatterns.toPretty()).toMatchSnapshot();
+    });
+  });
+};
+
+describe('TestPathPatterns', () => {
+  testPathPatternsLikeTests(
+    (patterns: Array<string>, _: TestPathPatternsExecutorOptions) =>
+      new TestPathPatterns(patterns),
+  );
+});
+
+describe('TestPathPatternsExecutor', () => {
+  const makeExecutor = (
+    patterns: Array<string>,
+    options: TestPathPatternsExecutorOptions,
+  ) => new TestPathPatternsExecutor(new TestPathPatterns(patterns), options);
+
+  testPathPatternsLikeTests(makeExecutor);
+
+  describe('isMatch', () => {
+    it('returns true with no patterns', () => {
+      const testPathPatterns = makeExecutor([], config);
+      expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+    });
+
+    it('returns true for same path', () => {
+      const testPathPatterns = makeExecutor(['/a/b'], config);
+      expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+    });
+
+    it('returns true for same path with case insensitive', () => {
+      const testPathPatternsUpper = makeExecutor(['/A/B'], config);
+      expect(testPathPatternsUpper.isMatch('/a/b')).toBe(true);
+      expect(testPathPatternsUpper.isMatch('/A/B')).toBe(true);
+
+      const testPathPatternsLower = makeExecutor(['/a/b'], config);
+      expect(testPathPatternsLower.isMatch('/A/B')).toBe(true);
+      expect(testPathPatternsLower.isMatch('/a/b')).toBe(true);
+    });
+
+    it('returns true for contained path', () => {
+      const testPathPatterns = makeExecutor(['b/c'], config);
+      expect(testPathPatterns.isMatch('/a/b/c/d')).toBe(true);
+    });
+
+    it('returns true for explicit relative path', () => {
+      const testPathPatterns = makeExecutor(['./b/c'], {
+        rootDir: '/a',
+      });
+      expect(testPathPatterns.isMatch('/a/b/c')).toBe(true);
+    });
+
+    it('returns true for explicit relative path for Windows with ./', () => {
+      forceWindows();
+      const testPathPatterns = makeExecutor(['./b/c'], {
+        rootDir: 'C:\\a',
+      });
+      expect(testPathPatterns.isMatch('C:\\a\\b\\c')).toBe(true);
+    });
+
+    it('returns true for explicit relative path for Windows with .\\', () => {
+      forceWindows();
+      const testPathPatterns = makeExecutor(['.\\b\\c'], {
+        rootDir: 'C:\\a',
+      });
+      expect(testPathPatterns.isMatch('C:\\a\\b\\c')).toBe(true);
+    });
+
+    it('returns true for partial file match', () => {
+      const testPathPatterns = makeExecutor(['aaa'], config);
+      expect(testPathPatterns.isMatch('/foo/..aaa..')).toBe(true);
+      expect(testPathPatterns.isMatch('/foo/..aaa')).toBe(true);
+      expect(testPathPatterns.isMatch('/foo/aaa..')).toBe(true);
+    });
+
+    it('returns true for path suffix', () => {
+      const testPathPatterns = makeExecutor(['c/d'], config);
+      expect(testPathPatterns.isMatch('/a/b/c/d')).toBe(true);
+    });
+
+    it('returns true if regex matches', () => {
+      const testPathPatterns = makeExecutor(['ab*c?'], config);
+
+      expect(testPathPatterns.isMatch('/foo/a')).toBe(true);
+      expect(testPathPatterns.isMatch('/foo/ab')).toBe(true);
+      expect(testPathPatterns.isMatch('/foo/abb')).toBe(true);
+      expect(testPathPatterns.isMatch('/foo/ac')).toBe(true);
+      expect(testPathPatterns.isMatch('/foo/abc')).toBe(true);
+      expect(testPathPatterns.isMatch('/foo/abbc')).toBe(true);
+
+      expect(testPathPatterns.isMatch('/foo/bc')).toBe(false);
+    });
+
+    it('returns true only if matches relative path', () => {
+      const rootDir = '/home/myuser/';
+
+      const testPathPatterns = makeExecutor(['home'], {
+        rootDir,
+      });
+      expect(
+        testPathPatterns.isMatch(
+          path.relative(rootDir, '/home/myuser/LoginPage.js'),
+        ),
+      ).toBe(false);
+      expect(
+        testPathPatterns.isMatch(
+          path.relative(rootDir, '/home/myuser/HomePage.js'),
+        ),
+      ).toBe(true);
+    });
+
+    it('matches absolute paths regardless of rootDir', () => {
+      forcePosix();
+      const testPathPatterns = makeExecutor(['/a/b'], {
+        rootDir: '/foo/bar',
+      });
+      expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+    });
+
+    it('matches absolute paths for Windows', () => {
+      forceWindows();
+      const testPathPatterns = makeExecutor(['C:\\a\\b'], {
+        rootDir: 'C:\\foo\\bar',
+      });
+      expect(testPathPatterns.isMatch('C:\\a\\b')).toBe(true);
+    });
+
+    it('returns true if match any paths', () => {
+      const testPathPatterns = makeExecutor(['a/b', 'c/d'], config);
+
+      expect(testPathPatterns.isMatch('/foo/a/b')).toBe(true);
+      expect(testPathPatterns.isMatch('/foo/c/d')).toBe(true);
+
+      expect(testPathPatterns.isMatch('/foo/a')).toBe(false);
+      expect(testPathPatterns.isMatch('/foo/b/c')).toBe(false);
+    });
+
+    it('does not normalize Windows paths on POSIX', () => {
+      forcePosix();
+      const testPathPatterns = makeExecutor(['a\\z', 'a\\\\z'], config);
+      expect(testPathPatterns.isMatch('/foo/a/z')).toBe(false);
+    });
+
+    it('normalizes paths for Windows', () => {
+      forceWindows();
+      const testPathPatterns = makeExecutor(['a/b'], config);
+      expect(testPathPatterns.isMatch('C:\\foo\\a\\b')).toBe(true);
+    });
+
+    it('matches absolute path with absPath', () => {
+      const pattern = '^/home/app/';
+      const rootDir = '/home/app';
+      const absolutePath = '/home/app/packages/';
+
+      const testPathPatterns = makeExecutor([pattern], {
+        rootDir,
+      });
+
+      const relativePath = path.relative(rootDir, absolutePath);
+
+      expect(testPathPatterns.isMatch(relativePath)).toBe(false);
+      expect(testPathPatterns.isMatch(absolutePath)).toBe(true);
+    });
+  });
+});

node_modules/@jest/pattern/src/__tests__/__snapshots__/TestPathPatterns.test.ts.snap

@@ -0,0 +1,5 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`TestPathPatterns toPretty renders a human-readable string 1`] = `"a/b|c/d"`;
+
+exports[`TestPathPatternsExecutor toPretty renders a human-readable string 1`] = `"a/b|c/d"`;