@algocare/react-native-code-push 9.0.0-beta.3

package/versioning/BaseVersioning.js

@@ -0,0 +1,126 @@
+/**
+ * @type {BaseVersioning}
+ */
+class BaseVersioning {
+  /**
+   * @param {ReleaseHistoryInterface} releaseHistory
+   * @param {SortingMethod} sortingMethod
+   */
+  constructor(releaseHistory, sortingMethod) {
+    if (this.constructor == BaseVersioning) {
+      throw new Error("Abstract classes can't be instantiated.");
+    }
+    if (releaseHistory == null || sortingMethod == null) {
+      throw new Error("param releaseHistory and sortingMethod is needed");
+    }
+
+    /** @type {SortingMethod} */
+    this.sortingMethod = sortingMethod;
+
+    /** @type {ReleaseHistoryInterface} */
+    this.originalReleaseHistory = releaseHistory;
+
+    /** @type {[ReleaseVersion, ReleaseInfo][]} */
+    this.sortedReleaseHistory = Object.entries(releaseHistory).sort(
+      ([a], [b]) => this.sortingMethod(a, b)
+    );
+  }
+
+  /**
+   * @return {[ReleaseVersion, ReleaseInfo][]}
+   */
+  get sortedEnabledReleaseHistory() {
+    return this.sortedReleaseHistory.filter(([_, bundle]) => bundle.enabled);
+  }
+
+  /**
+   * @return {[ReleaseVersion, ReleaseInfo][]}
+   */
+  get sortedMandatoryReleaseHistory() {
+    return this.sortedEnabledReleaseHistory.filter(
+      ([_, bundle]) => bundle.mandatory
+    );
+  }
+
+  /**
+   * find latest release in releaseHistory
+   * @return {[ReleaseVersion, ReleaseInfo]}
+   */
+  findLatestRelease() {
+    const latestReleaseInfo = this.sortedEnabledReleaseHistory.at(0);
+
+    if (!latestReleaseInfo) {
+      throw new Error("There is no latest release.");
+    }
+
+    return latestReleaseInfo;
+  }
+
+  /**
+   * check if the update is mandatory
+   * @param {ReleaseVersion|undefined} runtimeVersion
+   * @return {boolean}
+   */
+  checkIsMandatory(runtimeVersion) {
+    if (this.shouldRollback(runtimeVersion)) {
+      // rollback is always mandatory
+      return true;
+    }
+
+    if (this.sortedMandatoryReleaseHistory.length === 0) {
+      return false;
+    }
+
+    if (!runtimeVersion) {
+      // This means that there is at least one mandatory update, but the update has not been installed yet.
+      // So, the update is mandatory.
+      return true;
+    }
+
+    const [latestMandatoryVersion, _] = this.sortedMandatoryReleaseHistory[0];
+    const [larger] = [latestMandatoryVersion, runtimeVersion].sort(this.sortingMethod);
+
+    return runtimeVersion !== latestMandatoryVersion && larger === latestMandatoryVersion;
+  }
+
+  /**
+   * determine whether to rollback and execute it
+   * @param {ReleaseVersion|undefined} runtimeVersion
+   * @return {boolean}
+   */
+  shouldRollback(runtimeVersion) {
+    if (!runtimeVersion) {
+      // Rollback is not possible because no updates have been installed.
+      return false;
+    }
+
+    const [latestRelease] = this.findLatestRelease();
+    const [larger] = [latestRelease, runtimeVersion].sort(this.sortingMethod);
+
+    return runtimeVersion !== latestRelease && larger === runtimeVersion;
+  }
+
+  /**
+   * Determine whether to clear the currently running bundle.
+   * If it returns true, the CodePush bundle will be erased, and the app will restart.
+   * @param {ReleaseVersion} runtimeVersion
+   * @return {boolean}
+   */
+  shouldRollbackToBinary(runtimeVersion) {
+    if (!runtimeVersion) {
+      // Rollback is not possible because no updates have been installed.
+      return false;
+    }
+
+    const [latestReleaseVersion] = this.findLatestRelease();
+    const [binaryAppVersion] = this.sortedReleaseHistory.at(-1);
+
+    return (
+      runtimeVersion !== latestReleaseVersion &&
+      this.shouldRollback(runtimeVersion) &&
+      latestReleaseVersion === binaryAppVersion
+    );
+  }
+}
+
+module.exports = { BaseVersioning: BaseVersioning };

package/versioning/BaseVersioning.test.js

@@ -0,0 +1,15 @@
+import { BaseVersioning } from "./BaseVersioning"
+
+describe('BaseVersioning', () => {
+    describe('constructor', () => {
+        it('should throw an error if it is directly instantiated', () => {
+            expect(() => new BaseVersioning({})).toThrow("Abstract classes can't be instantiated.")
+        })
+
+        it('should throw an error if releaseHistory is not defined', () => {
+            class TestVersioning extends BaseVersioning {}
+            expect(() => new TestVersioning()).toThrow("param releaseHistory and sortingMethod is needed")
+            expect(() => new TestVersioning({}, () => {})).not.toThrow("param releaseHistory and sortingMethod is needed")
+        })
+    })
+})

package/versioning/IncrementalVersioning.js

@@ -0,0 +1,9 @@
+const { BaseVersioning } = require("./BaseVersioning");
+
+class IncrementalVersioning extends BaseVersioning {
+  constructor(releaseHistory) {
+    super(releaseHistory, (v1, v2) => Number(v2) - Number(v1));
+  }
+}
+
+module.exports = { IncrementalVersioning };

package/versioning/IncrementalVersioning.test.js

@@ -0,0 +1,186 @@
+import { IncrementalVersioning } from "./IncrementalVersioning"
+
+describe('Incremental Versioning Test', () => {
+    const MOCK_INFOS = { downloadUrl: '', packageHash: '' }
+
+    // When major version is released, it must be considered like below
+    const FIRST_RELEASE_INFO = { enabled: true, mandatory: false, ...MOCK_INFOS };
+
+    describe('findLatestRelease', () => {
+        it('should throw error when there is no releases', () => {
+            const RELEASED_BUNDLES_1 = {}
+            const RELEASED_BUNDLES_2 = {'1': { enabled: false, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' }}
+            expect(() => new IncrementalVersioning(RELEASED_BUNDLES_1).findLatestRelease())
+                .toThrow("There is no latest release.")
+            expect(() => new IncrementalVersioning(RELEASED_BUNDLES_2).findLatestRelease())
+                .toThrow("There is no latest release.")
+        })
+
+        it('should return latest release', () => {
+            const RELEASED_BUNDLES = {
+                '1': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '2': { enabled: true, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+                '3': { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' },
+            };
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES).findLatestRelease()).toEqual([
+                '3',
+                { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' }
+            ])
+        })
+
+        it('should ignore not-enabled bundles and return latest release', () => {
+            const RELEASED_BUNDLES_1 = {
+                '1': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '2': { enabled: false, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+            };
+
+            const RELEASED_BUNDLES_2 = {
+                '1': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '2': { enabled: false, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+                '3': { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' },
+            };
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES_1).findLatestRelease()).toEqual([
+                '1',
+                { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' }
+            ])
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES_2).findLatestRelease()).toEqual([
+                '3',
+                { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' }
+            ])
+        })
+    })
+
+    describe('checkIsMandatory', () => {
+        describe('not-mandatory cases', () => {
+            it('should consider not-mandatory when the first major version is released', () => {
+                const RUNTIME_VERSION = '1';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+        
+            it('should consider not-mandatory when latest version is running', () => {
+                const RUNTIME_VERSION = '3';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                    '3': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+
+            it('should consider not-mandatory when only not-mandatory version is released', () => {
+                const RUNTIME_VERSION = '1';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+
+            it('should consider not-mandatory when only not-mandatory version is released after current runtime version', () => {
+                const RUNTIME_VERSION = '2';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '3': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+        })
+
+        describe('mandatory cases', () => {
+            it('should consider mandatory when mandatory release exists', () => {
+                const RUNTIME_VERSION = '1';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(true);
+            });
+
+            it("should consider mandatory if there's a mandatory release between the runtime version and the latest", () => {
+                const RUNTIME_VERSION = '1'
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '3': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                }
+
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(true);
+            })
+
+            it('should consider mandatory when latest version < current runtime version (ROLLBACK)', () => {
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                };
+                const currentVersion = '2'
+    
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).shouldRollback(currentVersion)).toBe(true)
+            })
+        })
+
+        describe('scenario test', () => {
+            it('Major Release > Mandatory > Not-mandatory > Mandatory > Not-mandatory', () => {
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '3': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                    '4': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '5': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('1')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('2')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('3')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('4')).toBe(false);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('5')).toBe(false);
+            });
+
+            it('When having not-enabled releases', () => {
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '3': { enabled: false, mandatory: false, ...MOCK_INFOS },
+                    '4': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '5': { enabled: false, mandatory: false, ...MOCK_INFOS },
+                };
+
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('1')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('2')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('3')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('4')).toBe(false);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('5')).toBe(true);
+            });
+        })
+    })
+
+    describe('shouldRollbackToBinary', () => {
+        it('should return true when destination version is the first major version', () => {
+            const RELEASED_BUNDLES = {
+                '1': FIRST_RELEASE_INFO,
+                '2': { enabled: false, mandatory: true, ...MOCK_INFOS },
+            };
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES).shouldRollbackToBinary('2')).toBe(true)
+        })
+
+        it('should return false when runtime version is the same as destination version', () => {
+            const RELEASED_BUNDLES = {
+                '1': FIRST_RELEASE_INFO,
+                '2': { enabled: false, mandatory: true, ...MOCK_INFOS },
+            };
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES).shouldRollbackToBinary('1')).toBe(false)
+        })
+    })
+})

package/versioning/SemverVersioning.js

@@ -0,0 +1,10 @@
+const Semver = require("semver");
+const { BaseVersioning } = require("./BaseVersioning");
+
+class SemverVersioning extends BaseVersioning {
+  constructor(releaseHistory) {
+    super(releaseHistory, (v1, v2) => (Semver.gt(v1, v2) ? -1 : 1));
+  }
+}
+
+module.exports = { SemverVersioning };

package/versioning/SemverVersioning.test.js

@@ -0,0 +1,205 @@
+import { SemverVersioning } from "./SemverVersioning";
+
+describe('Semver Versioning Test', () => {
+    const MOCK_INFOS = { downloadUrl: '', packageHash: '' }
+
+    // When major version is released, it must be considered like below
+    const FIRST_RELEASE_INFO = { enabled: true, mandatory: false, ...MOCK_INFOS };
+
+    describe('findLatestRelease', () => {
+        it('should throw error when there is no releases', () => {
+            const RELEASED_BUNDLES = {}
+            expect(() => new SemverVersioning(RELEASED_BUNDLES).findLatestRelease())
+                .toThrow("There is no latest release.")
+        })
+
+        it('should return latest release', () => {
+            const RELEASED_BUNDLES = {
+                '1.0.0': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '1.1.0': { enabled: true, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+                '1.1.1': { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' },
+            };
+
+            expect(new SemverVersioning(RELEASED_BUNDLES).findLatestRelease()).toEqual([
+                '1.1.1',
+                { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' }
+            ])
+        })
+
+        it('should ignore not-enabled bundles and return latest release', () => {
+            const RELEASED_BUNDLES_1 = {
+                '1.0.0': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '1.1.0': { enabled: false, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+            };
+
+            const RELEASED_BUNDLES_2 = {
+                '1.0.0': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '1.1.0': { enabled: false, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+                '1.1.1': { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' },
+            };
+
+            expect(new SemverVersioning(RELEASED_BUNDLES_1).findLatestRelease()).toEqual([
+                '1.0.0',
+                { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' }
+            ])
+
+            expect(new SemverVersioning(RELEASED_BUNDLES_2).findLatestRelease()).toEqual([
+                '1.1.1',
+                { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' }
+            ])
+        })
+    })
+
+    describe('checkIsMandatory', () => {
+        describe('not-mandatory cases', () => {
+            it('should consider not-mandatory when the first major version is released', () => {
+                const RUNTIME_VERSION = '1.0.0';
+                const RELEASED_BUNDLES = {
+                    '1.0.0': FIRST_RELEASE_INFO,
+                };
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+
+            it('should consider not-mandatory when latest version is running', () => {
+                const RUNTIME_VERSION = '1.1.1';
+                const RELEASED_BUNDLES = {
+                    '1.0.0': FIRST_RELEASE_INFO,
+                    '1.1.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                    '1.1.1': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                };
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+
+            it('should consider not-mandatory when only not-mandatory version is released', () => {
+                const RUNTIME_VERSION = '1.0.0';
+                const RELEASED_BUNDLES = {
+                    '1.0.0': FIRST_RELEASE_INFO,
+                    '1.1.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+
+            it('should consider not-mandatory when only not-mandatory version is released after current runtime version', () => {
+                const RUNTIME_VERSION = '1.0.1';
+                const RELEASED_BUNDLES = {
+                    '1.0.0': FIRST_RELEASE_INFO,
+                    '1.0.1': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '1.1.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+        })
+
+        describe('mandatory cases', () => {
+            it('should consider mandatory when mandatory release exists', () => {
+                const RUNTIME_VERSION = '1.0.0';
+                const RELEASED_BUNDLES = {
+                    '1.0.0': FIRST_RELEASE_INFO,
+                    '1.0.1': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                };
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(true);
+            });
+
+            it("should consider mandatory if there's a mandatory release between the runtime version and the latest", () => {
+                const RUNTIME_VERSION = '1.0.0'
+                const RELEASED_BUNDLES = {
+                    '1.0.0': FIRST_RELEASE_INFO,
+                    '1.2.0': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '1.3.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                }
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(true);
+            })
+
+            it('should consider mandatory when latest version < current runtime version (ROLLBACK)', () => {
+                const RELEASED_BUNDLES = {
+                    '1.1.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+                const currentVersion = '1.2.0'
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).shouldRollback(currentVersion)).toBe(true)
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory(currentVersion)).toBe(true)
+            })
+        })
+
+        describe('scenario test', () => {
+            it('Major Release > Mandatory > Not-mandatory > Mandatory > Not-mandatory', () => {
+                const RELEASED_BUNDLES = {
+                    '1.0.0': FIRST_RELEASE_INFO,
+                    '1.0.1': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '1.1.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                    '1.1.1': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '1.2.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.0.0')).toBe(true);
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.0.1')).toBe(true);
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.1.0')).toBe(true);
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.1.1')).toBe(false);
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.2.0')).toBe(false);
+            });
+
+            it('When having not-enabled releases', () => {
+                const RELEASED_BUNDLES = {
+                    '1.0.0': FIRST_RELEASE_INFO,
+                    '1.0.1': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '1.1.0': { enabled: false, mandatory: false, ...MOCK_INFOS },
+                    '1.1.1': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '1.2.0': { enabled: false, mandatory: false, ...MOCK_INFOS },
+                };
+
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.0.0')).toBe(true);
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.0.1')).toBe(true);
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.1.0')).toBe(true);
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.1.1')).toBe(false);
+                expect(new SemverVersioning(RELEASED_BUNDLES).checkIsMandatory('1.2.0')).toBe(true);
+            });
+        })
+    })
+
+    describe('shouldRollbackToBinary', () => {
+        it('should return false if it is not required to rollback', () => {
+            const RELEASED_BUNDLES_1 = {
+                '1.0.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+            };
+            const RELEASED_BUNDLES_2 = {
+                '1.0.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                '1.1.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                '1.2.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+            };
+            expect(new SemverVersioning(RELEASED_BUNDLES_1).shouldRollbackToBinary('1.0.0')).toBe(false)
+            expect(new SemverVersioning(RELEASED_BUNDLES_2).shouldRollbackToBinary('1.1.0')).toBe(false)
+        })
+
+        it('should return true if the destination version is the latest major version', () => {
+            const RELEASED_BUNDLES_1 = {
+                '1.0.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                '1.1.0': { enabled: false, mandatory: false, ...MOCK_INFOS },
+                '1.2.0': { enabled: false, mandatory: false, ...MOCK_INFOS },
+            };
+            const RELEASED_BUNDLES_2 = {
+                '1.2.0-rc.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+            };
+            expect(new SemverVersioning(RELEASED_BUNDLES_1).shouldRollbackToBinary('1.2.0')).toBe(true)
+            expect(new SemverVersioning(RELEASED_BUNDLES_2).shouldRollbackToBinary('1.2.0-rc.2')).toBe(true)
+        })
+
+        it('should return false if the destination version is not the latest major version', () => {
+            const RELEASED_BUNDLES_1 = {
+                '1.0.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                '1.1.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+            };
+            const RELEASED_BUNDLES_2 = {
+                '1.2.0-rc.0': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                '1.2.0-rc.1': { enabled: true, mandatory: false, ...MOCK_INFOS },
+            };
+            expect(new SemverVersioning(RELEASED_BUNDLES_1).shouldRollbackToBinary('1.2.0')).toBe(false)
+            expect(new SemverVersioning(RELEASED_BUNDLES_2).shouldRollbackToBinary('1.2.0-rc.2')).toBe(false)
+        })
+    })
+})

package/versioning/index.js

@@ -0,0 +1,7 @@
+const { BaseVersioning } = require("./BaseVersioning");
+const { SemverVersioning } = require("./SemverVersioning");
+
+module.exports = {
+  SemverVersioning,
+  BaseVersioning,
+};