1987

pending completion

Build # 1987

Build Type

Pull #766

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/<a class=hub.com/nemtech/symbol-sdk-typescript-javascript/commit/3cf4dc588e6b868aa455f2f4f51e489622cb0171">3cf4dc588<a href="https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/3cf4dc588e6b868aa455f2f4f51e489622cb0171">">Merge </a><a class="double-link" href="https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/<a class="double-link" href="https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/faab6b7297971bb844ea0571b25b65dfb8ca0e4d">faab6b729</a>">faab6b729</a><a href="https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/3cf4dc588e6b868aa455f2f4f51e489622cb0171"> into 334124515">334124515</a>

Pull Request Pull Request #766: Add node version model

Run Details

1759 of 2170 branches covered (81.06%)

Branch coverage included in aggregate %.

35 of 35 new or added lines in 2 files covered. (100.0%)

5248 of 5536 relevant lines covered (94.8%)

26129.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.83

/src/model/node/NodeVersion.ts

/*
 * Copyright 2021 NEM
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

export class NodeVersion {
    /**
     * Create a NodeVersion from a given raw version number.
     * @param {number} rawNodeVersion - Node version in number format.
     *                  ex: 655367
     * @returns {NodeVersion}
     */
    public static createFromRawNodeVersion(rawNodeVersion: number): NodeVersion {
        if (!NodeVersion.isValidRawNodeVersion(rawNodeVersion)) {
            throw new Error(`Invalid node version number '${rawNodeVersion}'`);
        }

        return new NodeVersion(rawNodeVersion);
    }

    /**
     * Create a NodeVersion from a given formatted version string.
     * @param {string} formattedNodeVersion - Node version in string format.
     *                  ex: 0.10.0.7
     * @returns {NodeVersion}
     */
    public static createFromFormattedNodeVersion(formattedNodeVersion: string): NodeVersion {
        if (!NodeVersion.isValidFormattedNodeVersion(formattedNodeVersion)) {
            throw new Error(`Invalid node version string '${formattedNodeVersion}'`);
        }

        const placeholderHex = '00';
        const hexVersionNumber = formattedNodeVersion
            .split('.')
            .map((value) => (placeholderHex + parseInt(value).toString(16)).slice(-2))
            .join('');

        const rawVersionNumber = parseInt(hexVersionNumber, 16);
        return new NodeVersion(rawVersionNumber);
    }

    /**
     * Determines the validity of a raw node version number.
     * @param {string} rawNodeVersion The raw node version number. Expected format 655367
     * @returns {boolean} true if the raw node version number is valid, false otherwise.
     */
    public static isValidRawNodeVersion = (rawNodeVersion: number): boolean => {
        const maxRawNodeVersion = 4294967295;
        const minRawNodeVersion = 0;

        return Number.isInteger(rawNodeVersion) && rawNodeVersion >= minRawNodeVersion && rawNodeVersion <= maxRawNodeVersion;
    };

    /**
     * Determines the validity of a formatted node version string.
     * @param {string} formattedNodeVersion The formatted node version string. Expected format: 0.10.0.7
     * @returns {boolean} true if the formatted node version string is valid, false otherwise.
     */
    public static isValidFormattedNodeVersion = (formattedNodeVersion: string): boolean => {
        const maxFormattedNodeVersionChunkValue = 255;
        const minFormattedNodeVersionChunkValue = 0;

        const versionChuncks = formattedNodeVersion.split('.').map((value) => parseInt(value));

        if (versionChuncks.length !== 4) {
            return false;
        }

        const isVersionChuncksValid = !versionChuncks.find(
            (value) => isNaN(value) || value < minFormattedNodeVersionChunkValue || value > maxFormattedNodeVersionChunkValue,
        );

        return isVersionChuncksValid;
    };

    /**
     * @internal
     * @param rawNodeVersion
     * @param formattedNodeVersion
     */
    private constructor(
        /**
         * The raw node version value.
         */
        private readonly nodeVersion: number,
    ) {}

    /**
     * Get node version in formatted format ex: 0.10.0.7
     * @returns {string}
     */
    public formatted(): string {
        const placeholderHex = '00000000';
        const hexNodeVersion = (placeholderHex + this.nodeVersion.toString(16)).slice(-8);
        const formattedNodeVersion = hexNodeVersion
            .match(/.{1,2}/g)!
            .map((hex) => parseInt(hex, 16))
            .join('.');

        return formattedNodeVersion;
    }

    /**
     * Get node version in the raw numeric format ex: 655367.
     * @returns {number}
     */
    public raw(): number {
        return this.nodeVersion;
    }

    /**
     * Compares node versions for equality
     * @param nodeVersion - Node version to compare
     * @returns {boolean}
     */
    public equals(nodeVersion: any): boolean {
        if (nodeVersion instanceof NodeVersion) {
            return this.nodeVersion === nodeVersion.raw();
        }

        return false;
    }
}

1	/*
2	* Copyright 2021 NEM
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	export class NodeVersion {	1✔
18	/**
19	* Create a NodeVersion from a given raw version number.
20	* @param {number} rawNodeVersion - Node version in number format.
21	* ex: 655367
22	* @returns {NodeVersion}
23	*/
24	public static createFromRawNodeVersion(rawNodeVersion: number): NodeVersion {
25	if (!NodeVersion.isValidRawNodeVersion(rawNodeVersion)) {	14✔
26	throw new Error(`Invalid node version number '${rawNodeVersion}'`);	4✔
27	}
28
29	return new NodeVersion(rawNodeVersion);	10✔
30	}
31
32	/**
33	* Create a NodeVersion from a given formatted version string.
34	* @param {string} formattedNodeVersion - Node version in string format.
35	* ex: 0.10.0.7
36	* @returns {NodeVersion}
37	*/
38	public static createFromFormattedNodeVersion(formattedNodeVersion: string): NodeVersion {
39	if (!NodeVersion.isValidFormattedNodeVersion(formattedNodeVersion)) {	8✔
40	throw new Error(`Invalid node version string '${formattedNodeVersion}'`);	5✔
41	}
42
43	const placeholderHex = '00';	3✔
44	const hexVersionNumber = formattedNodeVersion	3✔
45	.split('.')
46	.map((value) => (placeholderHex + parseInt(value).toString(16)).slice(-2))	12✔
47	.join('');
48
49	const rawVersionNumber = parseInt(hexVersionNumber, 16);	3✔
50	return new NodeVersion(rawVersionNumber);	3✔
51	}
52
53	/**
54	* Determines the validity of a raw node version number.
55	* @param {string} rawNodeVersion The raw node version number. Expected format 655367
56	* @returns {boolean} true if the raw node version number is valid, false otherwise.
57	*/
58	public static isValidRawNodeVersion = (rawNodeVersion: number): boolean => {	1✔
59	const maxRawNodeVersion = 4294967295;	14✔
60	const minRawNodeVersion = 0;	14✔
61
62	return Number.isInteger(rawNodeVersion) && rawNodeVersion >= minRawNodeVersion && rawNodeVersion <= maxRawNodeVersion;	14✔
63	};
64
65	/**
66	* Determines the validity of a formatted node version string.
67	* @param {string} formattedNodeVersion The formatted node version string. Expected format: 0.10.0.7
68	* @returns {boolean} true if the formatted node version string is valid, false otherwise.
69	*/
70	public static isValidFormattedNodeVersion = (formattedNodeVersion: string): boolean => {	1✔
71	const maxFormattedNodeVersionChunkValue = 255;	8✔
72	const minFormattedNodeVersionChunkValue = 0;	8✔
73
74	const versionChuncks = formattedNodeVersion.split('.').map((value) => parseInt(value));	27✔
75
76	if (versionChuncks.length !== 4) {	8✔
77	return false;	3✔
78	}
79
80	const isVersionChuncksValid = !versionChuncks.find(	5✔
81	(value) => isNaN(value) \|\| value < minFormattedNodeVersionChunkValue \|\| value > maxFormattedNodeVersionChunkValue,	17✔
82	);
83
84	return isVersionChuncksValid;	5✔
85	};
86
87	/**
88	* @internal
89	* @param rawNodeVersion
90	* @param formattedNodeVersion
91	*/
92	private constructor(
93	/**
94	* The raw node version value.
95	*/
96	private readonly nodeVersion: number,	13✔
97	) {}
98
99	/**
100	* Get node version in formatted format ex: 0.10.0.7
101	* @returns {string}
102	*/
103	public formatted(): string {
104	const placeholderHex = '00000000';	3✔
105	const hexNodeVersion = (placeholderHex + this.nodeVersion.toString(16)).slice(-8);	3✔
106	const formattedNodeVersion = hexNodeVersion	3✔
107	.match(/.{1,2}/g)!
108	.map((hex) => parseInt(hex, 16))	12✔
109	.join('.');
110
111	return formattedNodeVersion;	3✔
112	}
113
114	/**
115	* Get node version in the raw numeric format ex: 655367.
116	* @returns {number}
117	*/
118	public raw(): number {
119	return this.nodeVersion;	8✔
120	}
121
122	/**
123	* Compares node versions for equality
124	* @param nodeVersion - Node version to compare
125	* @returns {boolean}
126	*/
127	public equals(nodeVersion: any): boolean {
128	if (nodeVersion instanceof NodeVersion) {	2!
129	return this.nodeVersion === nodeVersion.raw();	2✔
130	}
131
132	return false;	×
133	}
134	}

nemtech / symbol-sdk-typescript-javascript / 1987

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous