ydb-embedded-ui 4.17.0 → 4.19.0

package/dist/store/reducers/storage/utils.ts

@@ -3,13 +3,14 @@ import type {
     TStorageGroupInfo,
     TStorageGroupInfoV2,
     TStorageInfo,
+    TStoragePoolInfo,
 } from '../../../types/api/storage';
 import {EVDiskState, type TVDiskStateInfo} from '../../../types/api/vdisk';
 import {TPDiskState} from '../../../types/api/pdisk';
 import {EFlag} from '../../../types/api/enums';
 import {getPDiskType} from '../../../utils/pdisk';
 import {getUsage} from '../../../utils/storage';
-import {calcUptime} from '../../../utils';
+import {calcUptime} from '../../../utils/dataFormatters/dataFormatters';
 
 import type {PreparedStorageGroup, PreparedStorageNode, PreparedStorageResponse} from './types';
 
@@ -146,6 +147,24 @@ const prepareStorageGroupDataV2 = (group: TStorageGroupInfoV2): PreparedStorageG
     };
 };
 
+export const prepareStorageGroups = (
+    StorageGroups?: TStorageGroupInfoV2[],
+    StoragePools?: TStoragePoolInfo[],
+) => {
+    let preparedGroups: PreparedStorageGroup[] = [];
+    if (StorageGroups) {
+        preparedGroups = StorageGroups.map(prepareStorageGroupDataV2);
+    } else {
+        StoragePools?.forEach((pool) => {
+            pool.Groups?.forEach((group) => {
+                preparedGroups.push(prepareStorageGroupData(group, pool.Name));
+            });
+        });
+    }
+
+    return preparedGroups;
+};
+
 // ==== Prepare nodes ====
 
 const prepareStorageNodeData = (node: TNodeInfo): PreparedStorageNode => {
@@ -187,17 +206,7 @@ export const prepareStorageNodesResponse = (data: TNodesInfo): PreparedStorageRe
 export const prepareStorageGroupsResponse = (data: TStorageInfo): PreparedStorageResponse => {
     const {StoragePools, StorageGroups, TotalGroups, FoundGroups} = data;
 
-    let preparedGroups: PreparedStorageGroup[] = [];
-
-    if (StorageGroups) {
-        preparedGroups = StorageGroups.map(prepareStorageGroupDataV2);
-    } else {
-        StoragePools?.forEach((pool) => {
-            pool.Groups?.forEach((group) => {
-                preparedGroups.push(prepareStorageGroupData(group, pool.Name));
-            });
-        });
-    }
+    const preparedGroups = prepareStorageGroups(StorageGroups, StoragePools);
 
     return {
         groups: preparedGroups,

package/dist/store/reducers/tenantOverview/executeTopTables/executeTopTables.ts

@@ -0,0 +1,93 @@
+import type {Reducer} from 'redux';
+
+import {TENANT_OVERVIEW_TABLES_LIMIT} from '../../../../utils/constants';
+import {parseQueryAPIExecuteResponse} from '../../../../utils/query';
+import {createApiRequest, createRequestActionTypes} from '../../../utils';
+import type {TopTablesAction, TopTablesState} from './types';
+
+export const FETCH_TOP_TABLES = createRequestActionTypes('top-tables', 'FETCH_TOP_TABLES');
+const SET_DATA_WAS_NOT_LOADED = 'top-tables/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+const getQueryText = (path: string) => {
+    return `
+SELECT
+    Path, SUM(DataSize) as Size
+FROM \`${path}/.sys/partition_stats\`
+GROUP BY Path
+    ORDER BY Size DESC
+    LIMIT ${TENANT_OVERVIEW_TABLES_LIMIT}
+`;
+};
+
+const executeTopTables: Reducer<TopTablesState, TopTablesAction> = (
+    state = initialState,
+    action,
+) => {
+    switch (action.type) {
+        case FETCH_TOP_TABLES.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TOP_TABLES.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case FETCH_TOP_TABLES.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                loading: false,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED:
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        default:
+            return state;
+    }
+};
+
+export const fetchTopTables = (database: string) => {
+    return createApiRequest({
+        request: window.api.sendQuery(
+            {
+                schema: 'modern',
+                query: getQueryText(database),
+                database,
+                action: 'execute-scan',
+            },
+            {
+                concurrentId: 'executeTopTables',
+            },
+        ),
+        actions: FETCH_TOP_TABLES,
+        dataHandler: parseQueryAPIExecuteResponse,
+    });
+};
+
+export function setDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+}
+
+export default executeTopTables;

package/dist/store/reducers/tenantOverview/executeTopTables/types.ts

@@ -0,0 +1,14 @@
+import type {IQueryResult, QueryErrorResponse} from '../../../../types/store/query';
+import type {ApiRequestAction} from '../../../utils';
+import {FETCH_TOP_TABLES, setDataWasNotLoaded} from './executeTopTables';
+
+export interface TopTablesState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: IQueryResult;
+    error?: QueryErrorResponse;
+}
+
+export type TopTablesAction =
+    | ApiRequestAction<typeof FETCH_TOP_TABLES, IQueryResult, QueryErrorResponse>
+    | ReturnType<typeof setDataWasNotLoaded>;

package/dist/store/reducers/tenantOverview/topStorageGroups/topStorageGroups.ts

@@ -0,0 +1,98 @@
+import type {Reducer} from 'redux';
+
+import {TENANT_OVERVIEW_TABLES_LIMIT} from '../../../../utils/constants';
+import {EVersion} from '../../../../types/api/storage';
+import {createApiRequest, createRequestActionTypes} from '../../../utils';
+import type {StorageApiRequestParams} from '../../storage/types';
+import type {
+    TopStorageGroupsAction,
+    TopStorageGroupsState,
+    TopStorageGroupsStateSlice,
+} from './types';
+import {prepareTopStorageGroupsResponse} from './utils';
+
+export const FETCH_TOP_STORAGE_GROUPS = createRequestActionTypes(
+    'topStorageGroups',
+    'FETCH_TOP_STORAGE_GROUPS',
+);
+
+const SET_DATA_WAS_NOT_LOADED = 'topStorageGroups/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: true,
+    wasLoaded: false,
+};
+
+const topStorageGroups: Reducer<TopStorageGroupsState, TopStorageGroupsAction> = (
+    state = initialState,
+    action,
+) => {
+    switch (action.type) {
+        case FETCH_TOP_STORAGE_GROUPS.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_TOP_STORAGE_GROUPS.SUCCESS: {
+            return {
+                ...state,
+                data: action.data.groups,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TOP_STORAGE_GROUPS.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+                wasLoaded: true,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const getTopStorageGroups = ({
+    tenant,
+    visibleEntities = 'all',
+    nodeId,
+    sortOrder = -1,
+    sortValue = 'Usage',
+    limit = TENANT_OVERVIEW_TABLES_LIMIT,
+    version = EVersion.v2,
+    ...params
+}: StorageApiRequestParams) => {
+    return createApiRequest({
+        request: window.api.getStorageInfo(
+            {tenant, visibleEntities, nodeId, version, sortOrder, sortValue, limit, ...params},
+            {concurrentId: 'getTopStorageGroups'},
+        ),
+        actions: FETCH_TOP_STORAGE_GROUPS,
+        dataHandler: prepareTopStorageGroupsResponse,
+    });
+};
+
+export const selectTopStorageGroups = (state: TopStorageGroupsStateSlice) =>
+    state.topStorageGroups.data;
+
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+};
+
+export default topStorageGroups;

package/dist/store/reducers/tenantOverview/topStorageGroups/types.ts

@@ -0,0 +1,29 @@
+import type {IResponseError} from '../../../../types/api/error';
+import type {ApiRequestAction} from '../../../utils';
+import type {PreparedStorageGroup} from '../../storage/types';
+import {FETCH_TOP_STORAGE_GROUPS, setDataWasNotLoaded} from './topStorageGroups';
+
+export interface TopStorageGroupsState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: PreparedStorageGroup[];
+    error?: IResponseError;
+}
+
+export interface PreparedTopStorageGroupsResponse {
+    groups?: PreparedStorageGroup[];
+}
+
+type GetTopStorageGroupApiRequestAction = ApiRequestAction<
+    typeof FETCH_TOP_STORAGE_GROUPS,
+    PreparedTopStorageGroupsResponse,
+    IResponseError
+>;
+
+export type TopStorageGroupsAction =
+    | GetTopStorageGroupApiRequestAction
+    | ReturnType<typeof setDataWasNotLoaded>;
+
+export interface TopStorageGroupsStateSlice {
+    topStorageGroups: TopStorageGroupsState;
+}

package/dist/store/reducers/tenantOverview/topStorageGroups/utils.ts

@@ -0,0 +1,20 @@
+import {TENANT_OVERVIEW_TABLES_LIMIT} from '../../../../utils/constants';
+import type {TStorageInfo} from '../../../../types/api/storage';
+import {prepareStorageGroups} from '../../storage/utils';
+import type {PreparedTopStorageGroupsResponse} from './types';
+
+export const prepareTopStorageGroupsResponse = (
+    data: TStorageInfo,
+): PreparedTopStorageGroupsResponse => {
+    const {StoragePools, StorageGroups} = data;
+
+    const preparedGroups = prepareStorageGroups(StorageGroups, StoragePools);
+
+    if (StoragePools) {
+        preparedGroups.sort((a, b) => b.Usage - a.Usage);
+    }
+
+    return {
+        groups: preparedGroups.slice(0, TENANT_OVERVIEW_TABLES_LIMIT),
+    };
+};

package/dist/store/reducers/tenants/utils.ts

@@ -1,6 +1,6 @@
 import type {TTenant} from '../../../types/api/tenant';
 import {formatBytes} from '../../../utils/bytesParsers';
-import {formatCPU} from '../../../utils/formatCPU/formatCPU';
+import {formatCPUWithLabel} from '../../../utils/dataFormatters/dataFormatters';
 import {isNumeric} from '../../../utils/utils';
 import {METRIC_STATUS} from './contants';
 
@@ -26,34 +26,44 @@ export const calculateTenantMetrics = (tenant?: TTenant) => {
         CoresUsed,
         MemoryUsed,
         StorageAllocatedSize,
-        CoresLimit,
         MemoryLimit,
-        StorageLimit,
+        StorageAllocatedLimit,
+        PoolStats,
         Metrics = {},
+        DatabaseQuotas = {},
     } = tenant || {};
 
-    const cpuFromCores = isNumeric(CoresUsed) ? Number(CoresUsed) * 1_000_000 : undefined;
-    const cpuFromMetrics = isNumeric(Metrics.CPU) ? Number(Metrics.CPU) : undefined;
+    const systemPoolUsage = PoolStats?.find(({Name}) => Name === 'System')?.Usage;
+    const userPoolUsage = PoolStats?.find(({Name}) => Name === 'User')?.Usage;
 
-    const cpu = cpuFromCores ?? cpuFromMetrics ?? undefined;
+    const cpu = isNumeric(CoresUsed) ? Number(CoresUsed) * 1_000_000 : undefined;
+    const memory = isNumeric(MemoryUsed) ? Number(MemoryUsed) : undefined;
+    const blobStorage = isNumeric(StorageAllocatedSize) ? Number(StorageAllocatedSize) : undefined;
+    const tableStorage = isNumeric(Metrics.Storage) ? Number(Metrics.Storage) : undefined;
 
-    const rawMemory = MemoryUsed ?? Metrics.Memory;
-
-    const memory = isNumeric(rawMemory) ? Number(rawMemory) : undefined;
-
-    // Blob storage - actual database size
-    const storage = isNumeric(StorageAllocatedSize) ? Number(StorageAllocatedSize) : undefined;
-    const cpuLimit = isNumeric(CoresLimit) ? Number(CoresLimit) : undefined;
+    // We use system pool usage and user pool usage to calculate cpu usage because
+    // only these pools directly indicate resources available to perform user queries
+    const cpuUsage =
+        isNumeric(systemPoolUsage) || isNumeric(userPoolUsage)
+            ? Math.max(Number(systemPoolUsage), Number(userPoolUsage)) * 100
+            : undefined;
     const memoryLimit = isNumeric(MemoryLimit) ? Number(MemoryLimit) : undefined;
-    const storageLimit = isNumeric(StorageLimit) ? Number(StorageLimit) : undefined;
+    const blobStorageLimit = isNumeric(StorageAllocatedLimit)
+        ? Number(StorageAllocatedLimit)
+        : undefined;
+    const tableStorageLimit = isNumeric(DatabaseQuotas.data_size_hard_quota)
+        ? Number(DatabaseQuotas.data_size_hard_quota)
+        : undefined;
 
     return {
         cpu,
         memory,
-        storage,
-        cpuLimit,
+        blobStorage,
+        tableStorage,
+        cpuUsage,
         memoryLimit,
-        storageLimit,
+        blobStorageLimit,
+        tableStorageLimit,
     };
 };
 
@@ -71,7 +81,7 @@ export const prepareTenants = (tenants: TTenant[], useNodeAsBackend: boolean) =>
         const backend = useNodeAsBackend ? getTenantBackend(tenant) : undefined;
         const sharedTenantName = tenants.find((item) => item.Id === tenant.ResourceId)?.Name;
         const controlPlaneName = getControlPlaneValue(tenant);
-        const {cpu, memory, storage} = calculateTenantMetrics(tenant);
+        const {cpu, memory, blobStorage} = calculateTenantMetrics(tenant);
         const {nodesCount, groupsCount} = calculateTenantEntities(tenant);
 
         return {
@@ -82,7 +92,7 @@ export const prepareTenants = (tenants: TTenant[], useNodeAsBackend: boolean) =>
             controlPlaneName,
             cpu,
             memory,
-            storage,
+            storage: blobStorage,
             nodesCount,
             groupsCount,
         };
@@ -158,7 +168,7 @@ export const formatTenantMetrics = ({
     storage?: number;
     memory?: number;
 }) => ({
-    cpu: formatCPU(cpu),
+    cpu: formatCPUWithLabel(cpu),
     storage: formatBytes({value: storage, significantDigits: 2}) || undefined,
     memory: formatBytes({value: memory, significantDigits: 2}) || undefined,
 });

package/dist/styles/constants.scss

@@ -2,4 +2,8 @@
     --tenant-object-info-max-value-width: 300px;
 
     --diagnostics-section-title-margin: 20px;
+
+    --diagnostics-section-margin: 16px;
+
+    --diagnostics-section-table-width: 872px;
 }

package/dist/types/additionalProps.ts

@@ -24,7 +24,7 @@ export interface AdditionalTenantsProps {
     getMonitoringLink?: (name?: string, type?: ETenantType) => ReactNode;
 }
 
-export type NodeAddress = Pick<TSystemStateInfo, 'Host' | 'Endpoints'>;
+export type NodeAddress = Pick<TSystemStateInfo, 'Host' | 'Endpoints' | 'NodeId'>;
 
 export interface AdditionalNodesProps extends Record<string, unknown> {
     getNodeRef?: (node?: NodeAddress) => string | null;

package/dist/types/api/storage.ts

@@ -16,7 +16,7 @@ export interface TStorageInfo {
     FoundGroups?: string;
 }
 
-interface TStoragePoolInfo {
+export interface TStoragePoolInfo {
     Overall?: EFlag;
     Name?: string;
     Kind?: string;

package/dist/types/api/tenant.ts

@@ -42,24 +42,24 @@ export interface TTenant {
     ResourceId?: string;
     Tablets?: TTabletStateInfo[];
     /** uint64 */
-    StorageAllocatedSize?: string;
+    StorageAllocatedSize?: string; // Actual database size
     /** uint64 */
     StorageMinAvailableSize?: string;
     Nodes?: TSystemStateInfo[];
     /** uint64 */
-    MemoryUsed?: string;
+    MemoryUsed?: string; // Actual memory consumption
     /** uint64 */
     MemoryLimit?: string;
     /** double */
-    CoresUsed?: number;
+    CoresUsed?: number; // Actual cpu consumption
     /** uint64 */
     StorageGroups?: string;
 
     MonitoringEndpoint?: string; // additional
     ControlPlane?: ControlPlane; // additional
 
-    CoresLimit?: string; // TODO: check correctness in backend protos when fully supported
-    StorageLimit?: string; // TODO: check correctness in backend protos when fully supported
+    StorageAllocatedLimit?: string;
+    DatabaseQuotas?: DatabaseQuotas;
 }
 
 interface THiveDomainStatsStateCount {
@@ -69,15 +69,15 @@ interface THiveDomainStatsStateCount {
 
 export interface TMetrics {
     /** uint64 */
-    CPU?: string;
+    CPU?: string; // Logical cpu consumption
     /** uint64 */
-    Memory?: string;
+    Memory?: string; // Logical memory consumption
     /** uint64 */
     Network?: string;
     /** uint64 */
     Counter?: string;
     /** uint64 */
-    Storage?: string;
+    Storage?: string; // Logical database size
     /** uint64 */
     ReadThroughput?: string;
     /** uint64 */
@@ -149,3 +149,16 @@ export enum ETabletVolatileState {
     'TABLET_VOLATILE_STATE_STARTING' = 'TABLET_VOLATILE_STATE_STARTING',
     'TABLET_VOLATILE_STATE_RUNNING' = 'TABLET_VOLATILE_STATE_RUNNING',
 }
+
+interface DatabaseQuotas {
+    /** uint64 */
+    data_size_hard_quota?: string;
+    /** uint64 */
+    data_size_soft_quota?: string;
+    /** uint64 */
+    data_stream_shards_quota?: string;
+    /** uint64 */
+    data_stream_reserved_storage_quota?: string;
+    /** uint32 */
+    ttl_min_run_internal_seconds?: string;
+}

package/dist/types/api/vdisk.ts

@@ -99,7 +99,7 @@ interface TVDiskSatisfactionRank {
     LevelRank?: TRank;
 }
 
-interface TVDiskID {
+export interface TVDiskID {
     GroupID?: number;
     GroupGeneration?: number;
     Ring?: number;

package/dist/utils/bytesParsers/__test__/formatBytes.test.ts

@@ -28,11 +28,20 @@ describe('formatBytes', () => {
         expect(formatBytes({value: 99_000_000_000_000, significantDigits: 2})).toEqual('99,000 GB');
         expect(formatBytes({value: 100_000_000_000_000, significantDigits: 2})).toEqual('100 TB');
     });
-    it('shoudl return empty string on invalid data', () => {
+    it('should return empty string on invalid data', () => {
         expect(formatBytes({value: undefined})).toEqual('');
         expect(formatBytes({value: null})).toEqual('');
         expect(formatBytes({value: ''})).toEqual('');
         expect(formatBytes({value: 'false'})).toEqual('');
         expect(formatBytes({value: '123qwe'})).toEqual('');
     });
+    it('should work with precision', () => {
+        expect(formatBytes({value: 123.123, precision: 2})).toBe('123 B');
+        expect(formatBytes({value: 12.123, precision: 2})).toBe('12 B');
+        expect(formatBytes({value: 1.123, precision: 2})).toBe('1.1 B');
+        expect(formatBytes({value: 0.123, precision: 2})).toBe('0.12 B');
+        expect(formatBytes({value: 0.012, precision: 2})).toBe('0.01 B');
+        expect(formatBytes({value: 0.001, precision: 2})).toBe('0 B');
+        expect(formatBytes({value: 0, precision: 2})).toBe('0 B');
+    });
 });

package/dist/utils/bytesParsers/formatBytes.ts

@@ -1,4 +1,4 @@
-import {formatNumber} from '..';
+import {formatNumber, roundToPrecision} from '../dataFormatters/dataFormatters';
 import {GIGABYTE, KILOBYTE, MEGABYTE, TERABYTE} from '../constants';
 import {isNumeric} from '../utils';
 
@@ -46,7 +46,7 @@ export type BytesSizes = keyof typeof sizes;
  *
  * significantDigits = 3 - 900 000 mb and 1000 gb
  */
-const getSizeWithSignificantDigits = (value: number, significantDigits: number) => {
+export const getSizeWithSignificantDigits = (value: number, significantDigits: number) => {
     const multiplier = 10 ** significantDigits;
 
     const tbLevel = sizes.tb.value * multiplier;
@@ -79,7 +79,7 @@ interface FormatToSizeArgs {
 }
 
 const formatToSize = ({value, size = 'mb', precision = 0}: FormatToSizeArgs) => {
-    const result = (Number(value) / sizes[size].value).toFixed(precision);
+    const result = roundToPrecision(Number(value) / sizes[size].value, precision);
 
     return formatNumber(result);
 };

package/dist/utils/constants.ts

@@ -77,6 +77,8 @@ export const COLORS_PRIORITY = {
     grey: 1,
 };
 
+export const TENANT_OVERVIEW_TABLES_LIMIT = 5;
+
 // ==== Titles ====
 export const DEVELOPER_UI_TITLE = 'Developer UI';
 export const CLUSTER_DEFAULT_TITLE = 'Cluster';
@@ -88,7 +90,8 @@ export const LANGUAGE_KEY = 'language';
 export const INVERTED_DISKS_KEY = 'invertedDisks';
 export const USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY = 'useNodesEndpointInDiagnostics';
 export const ENABLE_ADDITIONAL_QUERY_MODES = 'enableAdditionalQueryModes';
-export const ENABLE_NEW_TENANT_DIAGNOSTICS_DESIGN = 'enableNewTenantDiagnosticsDesign';
+// Remain key name "enableNewTenantDiagnosticsDesign" for backward compatibility
+export const DISPLAY_METRICS_CARDS_FOR_TENANT_DIAGNOSTICS = 'enableNewTenantDiagnosticsDesign';
 export const SAVED_QUERIES_KEY = 'saved_queries';
 export const ASIDE_HEADER_COMPACT_KEY = 'asideHeaderCompact';
 export const QUERIES_HISTORY_KEY = 'queries_history';
@@ -112,6 +115,12 @@ export const DEFAULT_TABLE_SETTINGS = {
     highlightRows: true,
 } as const;
 
+export const TENANT_OVERVIEW_TABLES_SETTINGS = {
+    ...DEFAULT_TABLE_SETTINGS,
+    stickyHead: 'fixed',
+    dynamicRender: false,
+} as const;
+
 export const QUERY_INITIAL_MODE_KEY = 'query_initial_mode';
 export const LAST_USED_QUERY_ACTION_KEY = 'last_used_query_action';
 

package/dist/utils/dataFormatters/__test__/roundToSignificant.test.ts

@@ -0,0 +1,22 @@
+import {roundToPrecision} from '../dataFormatters';
+
+describe('roundToSignificant', () => {
+    it('should work with only value', () => {
+        expect(roundToPrecision(123)).toBe(123);
+        expect(roundToPrecision(123.123)).toBe(123);
+        expect(roundToPrecision(12.123)).toBe(12);
+        expect(roundToPrecision(1.123)).toBe(1);
+        expect(roundToPrecision(0.123)).toBe(0);
+        expect(roundToPrecision(0)).toBe(0);
+    });
+    it('should work with precision', () => {
+        expect(roundToPrecision(123, 2)).toBe(123);
+        expect(roundToPrecision(123.123, 2)).toBe(123);
+        expect(roundToPrecision(12.123, 2)).toBe(12);
+        expect(roundToPrecision(1.123, 2)).toBe(1.1);
+        expect(roundToPrecision(0.123, 2)).toBe(0.12);
+        expect(roundToPrecision(0.012, 2)).toBe(0.01);
+        expect(roundToPrecision(0.001, 2)).toBe(0);
+        expect(roundToPrecision(0, 2)).toBe(0);
+    });
+});