@jahia/cypress 8.0.0 → 8.1.1

package/tests/cypress/e2e/modSince.spec.ts

@@ -0,0 +1,334 @@
+import '../../../src/support/apollo/apollo';
+import '../../../src/support/apollo/apolloClient';
+import {modSince, initializeVersionSupport, JAHIA_VERSION_ENV_VAR} from '../../../src/support/modSince';
+
+type ItSinceCall = (requiredVersion: string, title: string, fn?: (...args: unknown[]) => unknown) => Mocha.Test;
+type DescribeSinceCall = (requiredVersion: string, title: string, fn: (this: Mocha.Suite) => void) => Mocha.Suite;
+
+// Enable version gating
+modSince.enable();
+
+// Stub apollo command
+Cypress.Commands.add('apolloClient', (() => {
+    return cy.wrap({} as unknown);
+}) as Cypress.CommandFn<'apolloClient'>);
+
+Cypress.Commands.add('apollo', (() => {
+    return cy.wrap({
+        data: {
+            admin: {
+                jahia: {
+                    version: {
+                        release: '8.2.0-SNAPSHOT'
+                    }
+                }
+            }
+        }
+    });
+}) as Cypress.CommandFn<'apollo'>);
+
+describe('itSince support', () => {
+    describe('registration', () => {
+        it('attaches the since helper to it and it.only', () => {
+            expect(it.since).to.be.a('function');
+            expect(it.only.since).to.be.a('function');
+        });
+
+        it('attaches the since helper to describe and describe.only', () => {
+            expect(describe.since).to.be.a('function');
+            expect(describe.only.since).to.be.a('function');
+        });
+
+        it('attaches the since helper to it.skip and describe.skip', () => {
+            expect(it.skip.since).to.be.a('function');
+            expect(describe.skip.since).to.be.a('function');
+        });
+
+        it('throws clear error when it.since args are swapped', () => {
+            expect(() => {
+                (it.since as unknown as ItSinceCall)(
+                    'my test title',
+                    '8.2.0',
+                    () => {
+                        // no-op
+                    }
+                );
+            }).to.throw('[it.since] Invalid version: "my test title" (arguments appear swapped).');
+        });
+
+        it('throws clear error when describe.since args are swapped', () => {
+            expect(() => {
+                (describe.since as unknown as (requiredVersion: string, title: string, fn: (this: Mocha.Suite) => void) => Mocha.Suite)(
+                    'my suite title',
+                    '8.2.0',
+                    () => {
+                        // no-op
+                    }
+                );
+            }).to.throw('[describe.since] Invalid version: "my suite title" (arguments appear swapped).');
+        });
+    });
+
+    describe('skip.since proper title usage', () => {
+        const skippedItTitle = 'keeps it.skip.since description as title';
+        const skippedSuiteTitle = 'keeps describe.skip.since description as title';
+        let skippedItRan = false;
+        let skippedDescribeRan = false;
+
+        const skippedIt = it.skip.since('8.2.0', skippedItTitle, () => {
+            skippedItRan = true;
+        });
+
+        const skippedSuite = describe.skip.since('8.2.0', skippedSuiteTitle, () => {
+            it('never runs in skipped describe.since suite', () => {
+                skippedDescribeRan = true;
+            });
+        });
+
+        it('keeps user-provided title for it.skip.since', () => {
+            expect(skippedIt.title).to.equal(skippedItTitle);
+        });
+
+        it('keeps user-provided title for describe.skip.since', () => {
+            expect(skippedSuite.title).to.equal(skippedSuiteTitle);
+        });
+
+        it('does not execute callback for it.skip.since', () => {
+            expect(skippedItRan).to.equal(false);
+        });
+
+        it('does not execute tests inside describe.skip.since', () => {
+            expect(skippedDescribeRan).to.equal(false);
+        });
+    });
+
+    describe('skip backward compatibility', () => {
+        const compatItTitle = 'uses title for accidental it.skip(version, title, fn)';
+        const compatDescribeTitle = 'uses title for accidental describe.skip(version, title, fn)';
+        let compatItRan = false;
+        let compatDescribeRan = false;
+
+        const compatIt = (it.skip as unknown as ItSinceCall)(
+            '8.3.5.0',
+            compatItTitle,
+            () => {
+                compatItRan = true;
+            }
+        );
+
+        const compatDescribe = (describe.skip as unknown as DescribeSinceCall)(
+            '8.3.5.0',
+            compatDescribeTitle,
+            () => {
+                it('must not run inside compat skipped describe', () => {
+                    compatDescribeRan = true;
+                });
+            }
+        );
+
+        it('keeps title for accidental it.skip(version, title, fn)', () => {
+            expect(compatIt.title).to.equal(compatItTitle);
+        });
+
+        it('keeps title for accidental describe.skip(version, title, fn)', () => {
+            expect(compatDescribe.title).to.equal(compatDescribeTitle);
+        });
+
+        it('does not execute callback for accidental it.skip(version, title, fn)', () => {
+            expect(compatItRan).to.equal(false);
+        });
+
+        it('does not execute tests for accidental describe.skip(version, title, fn)', () => {
+            expect(compatDescribeRan).to.equal(false);
+        });
+    });
+
+    describe('version initialization', () => {
+        beforeEach(() => {
+            Cypress.env(JAHIA_VERSION_ENV_VAR, '');
+        });
+
+        it('returns cached env version without fetching from GraphQL', () => {
+            Cypress.env(JAHIA_VERSION_ENV_VAR, '9.9.9');
+            // Use `any` here because custom commands are not part of Cypress's typed EventEmitter keys.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const cyAny = cy as any;
+            const apolloClientSpy = cy.spy(cyAny, 'apolloClient').as('apolloClientSpy');
+            const apolloSpy = cy.spy(cyAny, 'apollo').as('apolloSpy');
+
+            return initializeVersionSupport().then(version => {
+                expect(version).to.equal('9.9.9');
+                expect(Cypress.env(JAHIA_VERSION_ENV_VAR)).to.equal('9.9.9');
+                expect(apolloClientSpy).to.not.have.been.called;
+                expect(apolloSpy).to.not.have.been.called;
+            });
+        });
+
+        it('stores normalized Jahia version in Cypress.env', () => {
+            return initializeVersionSupport().then(version => {
+                expect(version).to.equal('8.2.0');
+                expect(Cypress.env(JAHIA_VERSION_ENV_VAR)).to.equal('8.2.0');
+            });
+        });
+    });
+
+    describe('runtime gating', () => {
+        describe('it.since title handling', () => {
+            const supportedTitle = 'keeps title for supported it.since test';
+            const skippedTitle = 'keeps title for skipped it.since test';
+            let supportedRan = false;
+            let skippedRan = false;
+
+            beforeEach(() => {
+                Cypress.env(JAHIA_VERSION_ENV_VAR, '8.1.0');
+            });
+
+            const supportedTest = it.since('8.1.0', supportedTitle, () => {
+                supportedRan = true;
+            });
+
+            const skippedTest = it.since('8.2.0', skippedTitle, () => {
+                skippedRan = true;
+            });
+
+            it('keeps user-provided title for supported it.since', () => {
+                expect(supportedTest.title).to.equal(supportedTitle);
+            });
+
+            it('keeps user-provided title for skipped it.since', () => {
+                expect(skippedTest.title).to.equal(skippedTitle);
+            });
+
+            it('executes callback for supported it.since', () => {
+                expect(supportedRan).to.equal(true);
+            });
+
+            it('does not execute callback for skipped it.since', () => {
+                expect(skippedRan).to.equal(false);
+            });
+        });
+
+        describe('supported version', () => {
+            let ran = false;
+
+            beforeEach(() => {
+                Cypress.env(JAHIA_VERSION_ENV_VAR, '8.2.0');
+            });
+
+            it.since('8.2.0', 'runs test callback when current version matches requirement', () => {
+                ran = true;
+            });
+
+            it('executes callback for matching version', () => {
+                expect(ran).to.equal(true);
+            });
+        });
+
+        describe('unsupported version', () => {
+            let ran = false;
+
+            beforeEach(() => {
+                Cypress.env(JAHIA_VERSION_ENV_VAR, '8.1.0');
+            });
+
+            it.since('8.2.0', 'skips test callback when current version is lower than requirement', () => {
+                ran = true;
+            });
+
+            it('does not execute callback for lower version', () => {
+                expect(ran).to.equal(false);
+            });
+        });
+
+        describe('missing version', () => {
+            let ran = false;
+
+            beforeEach(() => {
+                Cypress.env(JAHIA_VERSION_ENV_VAR, '');
+            });
+
+            it.since('8.2.0', 'skips test callback when version is missing', () => {
+                ran = true;
+            });
+
+            it('does not execute callback when version is empty', () => {
+                expect(ran).to.equal(false);
+            });
+        });
+
+        describe('config overload', () => {
+            let ran = false;
+
+            beforeEach(() => {
+                Cypress.env(JAHIA_VERSION_ENV_VAR, '8.2.0');
+            });
+
+            it.since(
+                '8.2.0',
+                'supports Cypress config overload',
+                {defaultCommandTimeout: 10000},
+                () => {
+                    ran = true;
+                }
+            );
+
+            it('executes callback for config overload form', () => {
+                expect(ran).to.equal(true);
+            });
+        });
+
+        describe('describe.since supported version', () => {
+            let suiteRan = false;
+
+            before(() => {
+                Cypress.env(JAHIA_VERSION_ENV_VAR, '8.2.0');
+            });
+
+            describe.since('8.2.0', 'runs suite when current version matches requirement', () => {
+                it('executes suite tests for matching version', () => {
+                    suiteRan = true;
+                });
+
+                it('executes suite callback for matching version', () => {
+                    expect(suiteRan).to.equal(true);
+                });
+            });
+        });
+
+        describe('describe.since unsupported version', () => {
+            let suiteRan = false;
+
+            before(() => {
+                Cypress.env(JAHIA_VERSION_ENV_VAR, '8.1.0');
+            });
+
+            describe.since('8.2.0', 'skips suite when current version is lower than requirement', () => {
+                it('does not execute suite tests for lower version', () => {
+                    suiteRan = true;
+                });
+            });
+
+            it('does not execute suite callback for lower version', () => {
+                expect(suiteRan).to.equal(false);
+            });
+        });
+
+        describe('describe.since missing version', () => {
+            let suiteRan = false;
+
+            before(() => {
+                Cypress.env(JAHIA_VERSION_ENV_VAR, '');
+            });
+
+            describe.since('8.2.0', 'skips suite when version is missing', () => {
+                it('does not execute suite tests when version is empty', () => {
+                    suiteRan = true;
+                });
+            });
+
+            it('does not execute suite callback when version is missing', () => {
+                expect(suiteRan).to.equal(false);
+            });
+        });
+    });
+});

package/tests/cypress.config.ts

@@ -0,0 +1,23 @@
+import {defineConfig} from 'cypress';
+
+export default defineConfig({
+    reporter: 'cypress-multi-reporters',
+
+    reporterOptions: {
+        configFile: 'reporter-config.json'
+    },
+
+    e2e: {
+        // No baseUrl needed for unit tests
+        // Spec pattern for test files
+        specPattern: 'cypress/e2e/**/*.spec.ts',
+        // Support file
+        supportFile: false,
+        // Video and screenshot settings
+        video: false,
+        screenshotOnRunFailure: false,
+        setupNodeEvents(on, config) {
+            return config;
+        }
+    }
+});

package/tests/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@jahia/cypress-tests",
+  "private": true,
+  "scripts": {
+    "e2e:ci": "cypress run",
+    "e2e:debug": "cypress open",
+    "report:merge": "mochawesome-merge results/reports/cypress*.json > results/reports/report.json && rm results/reports/cypress*.json",
+    "report:html": "marge --inline results/reports/report.json --reportDir results/reports/"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@jahia/eslint-config": "^2.2.0",
+    "@jahia/jahia-reporter": "^2.1.0",
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.1",
+    "@typescript-eslint/parser": "^8.57.1",
+    "cross-fetch": "^4.1.0",
+    "cypress": "^15.12.0",
+    "cypress-multi-reporters": "^2.0.5",
+    "cypress-wait-until": "^3.0.2",
+    "eslint": "^9.39.4",
+    "eslint-plugin-cypress": "^6.2.0",
+    "eslint-plugin-jest": "^29.15.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "mocha": "^11.7.5",
+    "mocha-junit-reporter": "^2.2.1",
+    "mochawesome": "^7.1.4",
+    "mochawesome-merge": "^5.1.1",
+    "mochawesome-report-generator": "^6.3.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@apollo/client": "^4.1.6",
+    "cypress-real-events": "^1.15.0",
+    "graphql": "^16.13.1",
+    "graphql-tag": "^2.12.6",
+    "rxjs": "^7.8.2"
+  },
+  "packageManager": "yarn@4.12.0"
+}

package/tests/reporter-config.json

@@ -0,0 +1,13 @@
+{
+  "reporterEnabled": "mochawesome, mocha-junit-reporter",
+  "mochaJunitReporterReporterOptions": {
+    "mochaFile": "./results/xml_reports/results-[hash].xml"
+  },
+  "mochawesomeReporterOptions": {
+    "reportDir": "./results/reports/",
+    "reportFilename": "cypress",
+    "overwrite": false,
+    "html": true,
+    "json": true
+  }
+}