223 lines
8.1 KiB
TypeScript
223 lines
8.1 KiB
TypeScript
import { strict as assert } from "assert";
|
|
import { Version } from "../src/version";
|
|
|
|
// Each row should be a list of compatible versions.
|
|
// Earlier entries in a row should be "greater than" later entries in the same row.
|
|
// Earlier rows should be "greater than" later rows.
|
|
// Rows should be incompatible with other rows.
|
|
const testMatrix = [
|
|
["3.6-pre1", "3.5.4", "3.2.3", "3"],
|
|
["2.5", "2.2.6", "2.2.4", "2.2.3"],
|
|
[
|
|
"1",
|
|
"1-rc.1",
|
|
"1-beta.11",
|
|
"1-beta.2",
|
|
"1-beta.01",
|
|
"1-beta",
|
|
"1-alpha.beta",
|
|
"1-alpha.1",
|
|
"1-alpha",
|
|
],
|
|
["0.1.2", "0.1.1-dev", "0.1"],
|
|
["0.0.2", "0.0.2-dev", "0.0.2+build"],
|
|
["0.0.1", "0.0.1-dev", "0.0.1-5", "0.0.1-2"],
|
|
];
|
|
|
|
function flatten<T>(arr: T[][]): T[] {
|
|
return arr.reduce((accumulator, value) => accumulator.concat(value), []);
|
|
}
|
|
|
|
describe("Version", function () {
|
|
describe("#from_semver()", function () {
|
|
it("should parse valid semver strings", function () {
|
|
assert.deepEqual(
|
|
Version.fromSemver("1.2"),
|
|
new Version(1, 2, 0, null, null)
|
|
);
|
|
assert.deepEqual(
|
|
Version.fromSemver("1.2.3"),
|
|
new Version(1, 2, 3, null, null)
|
|
);
|
|
assert.deepEqual(
|
|
Version.fromSemver("1.09.3"),
|
|
new Version(1, 9, 3, null, null)
|
|
);
|
|
assert.deepEqual(
|
|
Version.fromSemver("1.2.3-pr"),
|
|
new Version(1, 2, 3, ["pr"], null)
|
|
);
|
|
assert.deepEqual(
|
|
Version.fromSemver("1.2.3-pr1.pr2"),
|
|
new Version(1, 2, 3, ["pr1", "pr2"], null)
|
|
);
|
|
assert.deepEqual(
|
|
Version.fromSemver("1.2.3+build"),
|
|
new Version(1, 2, 3, null, ["build"])
|
|
);
|
|
assert.deepEqual(
|
|
Version.fromSemver("1.2.3+build1.build2"),
|
|
new Version(1, 2, 3, null, ["build1", "build2"])
|
|
);
|
|
assert.deepEqual(
|
|
Version.fromSemver("1-pr1.pr2+build1.build2"),
|
|
new Version(1, 0, 0, ["pr1", "pr2"], ["build1", "build2"])
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("#is_compatible_with()", function () {
|
|
it("is compatible with similar versions", function () {
|
|
for (const test of testMatrix) {
|
|
for (const a of test) {
|
|
for (const b of test) {
|
|
assert(
|
|
Version.fromSemver(a).isCompatibleWith(
|
|
Version.fromSemver(b)
|
|
),
|
|
`${a} is compatible with ${b}`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
it("is not compatible with other versions", function () {
|
|
for (const test of testMatrix) {
|
|
for (const a of test) {
|
|
for (const otherTest of testMatrix) {
|
|
if (test === otherTest) continue;
|
|
for (const b of otherTest) {
|
|
assert(
|
|
!Version.fromSemver(a).isCompatibleWith(
|
|
Version.fromSemver(b)
|
|
),
|
|
`${a} is not compatible with ${b}`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("#has_precedence_over()", function () {
|
|
it("returns true when it should", function () {
|
|
const tests = flatten(testMatrix);
|
|
for (let a = 0; a < tests.length; a++) {
|
|
for (let b = a + 1; b < tests.length; b++) {
|
|
if (
|
|
tests[a].indexOf("+") > -1 ||
|
|
tests[b].indexOf("+") > -1
|
|
) {
|
|
// Skip "builds" for purposes of this test.
|
|
continue;
|
|
}
|
|
assert(
|
|
Version.fromSemver(tests[a]).hasPrecedenceOver(
|
|
Version.fromSemver(tests[b])
|
|
),
|
|
`${tests[a]} has precedence over ${tests[b]}`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
it("returns false when it should", function () {
|
|
const tests = flatten(testMatrix).reverse();
|
|
for (let a = 0; a < tests.length; a++) {
|
|
for (let b = a + 1; b < tests.length; b++) {
|
|
if (
|
|
tests[a].indexOf("+") > -1 ||
|
|
tests[b].indexOf("+") > -1
|
|
) {
|
|
// Skip "builds" for purposes of this test.
|
|
continue;
|
|
}
|
|
assert(
|
|
!Version.fromSemver(tests[a]).hasPrecedenceOver(
|
|
Version.fromSemver(tests[b])
|
|
),
|
|
`${tests[a]} doesn't have precedence over ${tests[b]}`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("#is_equal()", function () {
|
|
it("returns true when it should", function () {
|
|
const tests = flatten(testMatrix);
|
|
for (const version of tests) {
|
|
assert(
|
|
Version.fromSemver(version).isEqual(
|
|
Version.fromSemver(version)
|
|
),
|
|
`${version} is equal to itself`
|
|
);
|
|
}
|
|
});
|
|
it("returns false when it should", function () {
|
|
const tests = flatten(testMatrix).reverse();
|
|
for (let a = 0; a < tests.length; a++) {
|
|
for (let b = a + 1; b < tests.length; b++) {
|
|
if (
|
|
tests[a].indexOf("+") > -1 ||
|
|
tests[b].indexOf("+") > -1 ||
|
|
tests[a].indexOf("-") > -1 ||
|
|
tests[b].indexOf("-") > -1
|
|
) {
|
|
// Skip "builds" and "identifiers" for purposes of this test.
|
|
continue;
|
|
}
|
|
assert(
|
|
!Version.fromSemver(tests[a]).isEqual(
|
|
Version.fromSemver(tests[b])
|
|
),
|
|
`${tests[a]} does not equal ${tests[b]}`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("#is_stable_or_compatible_prerelease()", function () {
|
|
it("returns true for own versions", function () {
|
|
const tests = flatten(testMatrix);
|
|
for (const version of tests) {
|
|
assert(
|
|
Version.fromSemver(version).isStableOrCompatiblePrerelease(
|
|
Version.fromSemver(version)
|
|
),
|
|
`${version} is compatible with itself`
|
|
);
|
|
}
|
|
});
|
|
it("returns true for compatible pre-releases", function () {
|
|
const tests = ["1.2.3", "1.2.3-alpha", "1.2.3-beta1.build2"];
|
|
for (const a of tests) {
|
|
for (const b of tests) {
|
|
assert(
|
|
Version.fromSemver(a).isStableOrCompatiblePrerelease(
|
|
Version.fromSemver(b)
|
|
),
|
|
`${a} is compatible with ${b}`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
it("returns false for incompatible pre-releases", function () {
|
|
const tests = ["1-dev", "1.2-alpha", "1.2.3-beta1.build2"];
|
|
for (const a of tests) {
|
|
for (const b of tests) {
|
|
if (a === b) continue;
|
|
assert(
|
|
!Version.fromSemver(a).isStableOrCompatiblePrerelease(
|
|
Version.fromSemver(b)
|
|
),
|
|
`${a} is not compatible with ${b}`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
});
|