@sankhyalabs/core 6.1.0 → 6.2.0-dev.1

package/src/dataunit/DataUnitHelper.ts

@@ -1,4 +1,5 @@
-import DataUnit, { Record } from './DataUnit.js';
+import DataUnit from './DataUnit.js';
+import { Record } from './interfaces/dataUnit.js';
 import { DataType } from './metadata/DataType.js';
 import { LoadDataRequest, LoadDataResponse, PaginationInfo, Sort, SortMode, StringUtils } from '../index.js';
 

package/src/dataunit/SelectionInfo.ts

@@ -0,0 +1,55 @@
+import { Record, SelectionMode } from "./interfaces/dataUnit.js";
+import { Filter, Sort } from "./metadata/UnitMetadata.js";
+
+export class SelectionInfo {
+
+    public mode: SelectionMode;
+    public filters?: Array<Filter>;
+    public sort?: Array<Sort>;
+    public getAllRecords?: () => Array<Record>;
+    private _records: Array<Record>;
+    private _total?: number;
+
+    constructor(records: Array<Record>, mode: SelectionMode = SelectionMode.SOME_RECORDS, total?: number, filters?: Array<Filter>, sort?: Array<Sort>) {
+        this._records = records;
+        this._total = total;
+        this.mode = mode;
+        this.filters = filters;
+        this.sort = sort;
+    }
+
+    public get records(): Array<Record> {
+        if (this.isAllRecords()) {
+            if (this.getAllRecords != undefined) {
+                return this.getAllRecords();
+            }
+            throw new Error("Erro interno: Impossível retornar os registros selecionados numa seleção virtual.");
+        }
+        return this._records;
+    }
+
+    public get recordIds(): Array<string> | undefined {
+
+        const records = this.records;
+
+        if (records == undefined) {
+            return undefined;
+        }
+        return records.map(record => record.__record__id__);
+    }
+
+    public get length(): number {
+        if (this.isAllRecords()) {
+            return this._total || 0;
+        }
+        return this.records == undefined ? 0 : (this.records as Array<Record>).length;
+    }
+
+    public isAllRecords(): boolean {
+        return this.mode === SelectionMode.ALL_RECORDS;
+    }
+
+    public isEmpty(): boolean {
+        return this.length === 0;
+    }
+}

package/src/dataunit/formatting/PrettyFormatter.ts

@@ -7,7 +7,7 @@ import { FieldDescriptor, UserInterface } from '../metadata/UnitMetadata.js';
 
 export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     if(descriptor?.userInterface === UserInterface.FILE){
-        return getFileFotmat(value);
+        return getFileFormat(value);
     }
 
     if(descriptor?.dataType === DataType.OBJECT){
@@ -131,10 +131,9 @@ const getMask = (value: string, descriptor: FieldDescriptor | undefined): string
     return mask;
 }
 
-const getFileFotmat = (value: any) =>{
-    if (!value || !Array.isArray(value)) return '';
-
+const getFileFormat = (value: any) => {
+    if (value == undefined) return '';
+    if (!value || !Array.isArray(value)) return value;
     if (value.length === 1) return value[0].name;
-
     return `${value.length} arquivos`;
 }

package/src/dataunit/interfaces/dataUnit.ts

@@ -0,0 +1,71 @@
+import { Filter } from "../metadata/UnitMetadata.js";
+import { DataUnitAction, ExecutionContext } from "../state/action/DataUnitAction.js";
+
+export interface LoadDataParams {
+    quickFilter?: QuickFilter;
+    executionCtx?: ExecutionContext;
+    checkLastFilter?: boolean;
+    source?: string;
+    selectFirstRecord?: boolean;
+    keepSelection?: boolean
+}
+
+export interface DUActionInterceptor {
+    interceptAction(action: DataUnitAction): DataUnitAction | Promise<DataUnitAction>;
+}
+
+export interface Record {
+    __record__id__: string;
+    __record__label__?: string;
+    __parent__record__id__?: string;
+    __owner__dataunit__name__?: string;
+    [key: string]: any;
+}
+
+export interface SavedRecord extends Record {
+    __old__id__?: string;
+}
+
+export enum ChangeOperation {
+    INSERT = "INSERT",
+    COPY = "COPY",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+}
+
+export interface WaitingChange {
+    waitmessage: string;
+    blocking: boolean;
+    promise?: Promise<any>;
+}
+
+export interface PageRequest {
+    limit: number;
+    offset: number;
+    quickFilter?: QuickFilter;
+}
+
+export interface QuickFilter {
+    term: string;
+    fields?: Array<string>;
+    filter?: Filter;
+}
+
+export interface PageResponse {
+    limit: number;
+    offset: number;
+    total: number;
+    hasMore: boolean;
+    records: Array<Record>;
+}
+
+export enum SelectionMode {
+    ALL_RECORDS = "ALL_RECORDS",
+    SOME_RECORDS = "SOME_RECORDS"
+}
+
+export type DataUnitEventOptions = { [key: string]: any };
+
+export type HideFieldOptions = {
+    visibleOnConfig: boolean
+};

package/src/dataunit/loader/utils/dataUnitLoaderUtils.ts

@@ -1,4 +1,5 @@
-import DataUnit, { Record } from '../../DataUnit.js';
+import DataUnit from '../../DataUnit.js';
+import { Record } from '../../interfaces/dataUnit.js';
 import { Filter, Sort } from '../../metadata/UnitMetadata.js';
 import { LoadDataRequest } from '../../loading/LoadDataRequest.js';
 import { PaginationInfo } from '../../loading/PaginationInfo.js';

package/src/dataunit/loading/LoadDataRequest.ts

@@ -1,4 +1,4 @@
-import { QuickFilter } from "../DataUnit.js";
+import { QuickFilter } from '../interfaces/dataUnit.js';
 import { Filter, Sort } from "../metadata/UnitMetadata.js";
 
 /** Atributos enviados na requisição de carregamento dos registros */

package/src/dataunit/loading/LoadDataResponse.ts

@@ -1,4 +1,4 @@
-import { Record } from "../DataUnit.js";
+import { Record } from "../interfaces/dataUnit.js";
 import { PaginationInfo } from "./PaginationInfo.js";
 
 /** Retorno dos registros da requisição de carregamento de dados */

package/src/dataunit/sorting/FieldComparator.ts

@@ -1,4 +1,4 @@
-import { Record } from '../DataUnit.js';
+import { Record } from "../interfaces/dataUnit.js";
 import { compareValues } from '../metadata/DataType.js';
 import { FieldDescriptor } from '../metadata/UnitMetadata.js';
 

package/src/dataunit/state/slice/AddedRecordsSlice.ts

@@ -2,7 +2,7 @@
 import { ActionReducer, StateAction } from "../StateManager.js";
 import { Action } from "../action/DataUnitAction.js";
 import StateManager from "../StateManager.js";
-import { Record } from "../../DataUnit.js";
+import { Record } from "../../interfaces/dataUnit.js";
 
 class AddedRecordsReducerImpl implements ActionReducer{
     

package/src/dataunit/state/slice/ChangesSlice.ts

@@ -6,7 +6,8 @@ import { getSelection } from "./SelectionSlice.js";
 import { getRecords } from "./RecordsSlice.js";
 import { getRemovedRecords } from "./RemovedRecordsSlice.js";
 import { getAddedRecords, isAddedRecord } from "./AddedRecordsSlice.js";
-import { Change, ChangeOperation, Record } from "../../DataUnit.js";
+import { ChangeOperation, Record } from "../../interfaces/dataUnit.js";
+import { Change } from "../../Changes.js";
 import { getWaitingChanges } from "./WaitingChangesSlice.js";
 import { getSelectionRecords } from "./SnapshotSlice.js";
 

package/src/dataunit/state/slice/LoadingControlSlice.ts

@@ -1,5 +1,4 @@
-
-import { ChangeOperation } from "../../DataUnit.js";
+import { ChangeOperation } from "../../interfaces/dataUnit.js";
 import { LoadDataRequest } from "../../loading/LoadDataRequest.js";
 import { PaginationInfo } from "../../loading/PaginationInfo.js";
 import { Action } from "../action/DataUnitAction.js";

package/src/dataunit/state/slice/RecordsSlice.ts

@@ -2,7 +2,8 @@ import { ActionReducer, StateAction } from "../StateManager.js";
 import StateManager from "../StateManager.js";
 import { getRemovedRecords } from "./RemovedRecordsSlice.js";
 import { Action } from "../action/DataUnitAction.js";
-import { Record, SavedRecord } from "../../DataUnit.js";
+import { Record, SavedRecord } from "../../interfaces/dataUnit.js";
+
 
 class RecordsReducerImpl implements ActionReducer {
 
@@ -12,7 +13,7 @@ class RecordsReducerImpl implements ActionReducer {
         switch (action.type) {
 
             case Action.DATA_LOADED:
-                return action.payload ? action.payload.records : undefined;
+                return action.payload ? action.payload.records : [];
             case Action.RECORDS_REMOVED:
                 
                 const {records, buffered} = action.payload;

package/src/dataunit/state/slice/SelectionSlice.ts

@@ -2,7 +2,8 @@ import { ActionReducer, StateAction } from "../StateManager.js";
 import { Action } from "../action/DataUnitAction.js";
 import StateManager from "../StateManager.js";
 import { getCurrentRecords, getSelectionRecords } from "./SnapshotSlice.js";
-import { Record, SavedRecord, SelectionInfo, SelectionMode } from "../../DataUnit.js";
+import { Record, SavedRecord, SelectionMode } from "../../interfaces/dataUnit.js";
+import { SelectionInfo } from "../../SelectionInfo.js";
 import { getCurrentRequest, getPaginationInfo } from "./LoadingControlSlice.js";
 import { PaginationInfo } from "../../loading/PaginationInfo.js";
 

package/src/dataunit/state/slice/SnapshotSlice.ts

@@ -1,7 +1,7 @@
 
 import { ActionReducer } from "../StateManager.js";
 import StateManager from "../StateManager.js";
-import { Record } from "../../DataUnit.js";
+import { Record } from "../../interfaces/dataUnit.js";
 import { getRecords } from "./RecordsSlice.js";
 import { getSelection } from "./SelectionSlice.js";
 import { getChangedFieldValue, getChanges } from "./ChangesSlice.js";

package/src/dataunit/state/slice/WaitingChangesSlice.ts

@@ -1,5 +1,5 @@
 
-import { WaitingChange } from "../../DataUnit.js";
+import { WaitingChange } from "../../interfaces/dataUnit.js";
 import { Action } from "../action/DataUnitAction.js";
 import StateManager, { ActionReducer, StateAction } from "../StateManager.js";
 

package/src/dataunit/state/slice/test/RecordsSlice.spec.ts

@@ -1,7 +1,7 @@
 
 import * as RecordsReducerModule from '../RecordsSlice';
 import StateManager from '../../StateManager';
-import { Record } from '../../../DataUnit';
+import { Record } from '../../../interfaces/dataUnit';
 import { Action } from '../../action/DataUnitAction';
 
 jest.spyOn(RecordsReducerModule, "getRecords").mockImplementation(() => [

package/src/index.ts

@@ -9,7 +9,10 @@ import { HttpProvider } from "./http/HttpProvider.js";
 import { SkwHttpProvider } from "./http/SkwHttpProvider.js";
 import { RequestMetadata } from "./http/RequestMetadata.js";
 import { AuthorizedServiceCaller } from "./http/AuthorizedServiceCaller.js";
-import DataUnit, {SavedRecord, Record, Change, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter, SelectionMode, SelectionInfo, DataUnitEventOptions} from "./dataunit/DataUnit.js";
+import DataUnit from "./dataunit/DataUnit.js";
+import {SavedRecord, Record, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter, SelectionMode, DataUnitEventOptions} from "./dataunit/interfaces/dataUnit.js";
+import { Change } from "./dataunit/Changes.js";
+import { SelectionInfo } from "./dataunit/SelectionInfo.js";
 import { DataType } from "./dataunit/metadata/DataType.js";
 import { UnitMetadata, FieldDescriptor, UserInterface, Sort, SortMode, SortingProvider, Filter, DependencyType, ChildDescriptor, ChildLink } from "./dataunit/metadata/UnitMetadata.js";
 import { DataUnitAction, Action, ExecutionContext } from "./dataunit/state/action/DataUnitAction.js";
@@ -50,6 +53,7 @@ import { DataUnitLoaderUtils, PaginationInfoBuilderParams } from "./dataunit/loa
 import { ColumnFilterManager } from "./utils/ColumnFilterManager.js";
 import { DataUnitInMemoryLoaderConfig, RECORD_DATE_FORMAT } from "./dataunit/loader/DataUnitInMemoryLoaderConfig.js";
 import Base64Utils from "./utils/Base64Utils.js";
+import { LangUtils} from './utils/LangUtils.js';
 
 /*Classes públicas no pacote*/
 export {
@@ -136,5 +140,5 @@ export {
     DataUnitInMemoryLoaderConfig,
     RECORD_DATE_FORMAT,
     Base64Utils,
-
+    LangUtils, 
 };

package/src/utils/ColumnFilterManager.ts

@@ -1,5 +1,6 @@
 import { Filter } from '../dataunit/metadata/UnitMetadata.js';
-import DataUnit, { Record } from '../dataunit/DataUnit.js';
+import DataUnit from '../dataunit/DataUnit.js';
+import { Record } from '../dataunit/interfaces/dataUnit.js';
 import { FieldComparator } from '../dataunit/sorting/FieldComparator.js';
 import { LoadDataRequest } from '../dataunit/loading/LoadDataRequest.js';
 

package/src/utils/LangUtils.ts

@@ -0,0 +1,129 @@
+
+/**
+ * A classe `LangUtils` fornece métodos utilitários para gerenciar configurações de 
+ * idioma, incluindo recuperar, definir e aplicar preferências de idioma.
+ */
+export class LangUtils {
+    /**
+     * Classe estática contendo os códigos de idioma predefinidos.
+     * 
+     * @property PT_BR - Português (Brasil)
+     * @property EN_US - Inglês (Estados Unidos)
+     * @property ES_ES - Espanhol (Espanha)
+     */
+    public static ELanguages = class {
+        static PT_BR = "pt_BR";
+        static EN_US = "en_US";
+        static ES_ES = "es_ES";
+    };
+
+    /**
+     * Converte o idioma fornecido para um dos códigos predefinidos.
+     * 
+     * @param lang - O idioma a ser convertido (ex.: "en", "es", "pt-BR").
+     * @returns O código de idioma correspondente (ex.: "en_US", "es_ES").
+     * 
+     * @example
+     * LangUtils.convertLanguage("en"); // Retorna "en_US"
+     * LangUtils.convertLanguage("es-es"); // Retorna "es_ES"
+     */
+    private static convertLanguage(lang: string): string {
+        switch (lang.toLocaleLowerCase()) {
+            case "en":
+            case "en_us":
+            case "en-us":
+                return LangUtils.ELanguages.EN_US;
+            case "es":
+            case "es_es":
+            case "es-es":
+                return LangUtils.ELanguages.ES_ES;
+            default:
+                return LangUtils.ELanguages.PT_BR;
+        }
+    }
+
+    /**
+     * Captura o idioma atualmente definido. Primeiro verifica se há um idioma 
+     * armazenado nos cookies. Caso contrário, utiliza o idioma definido no elemento 
+     * `<html>`. Se nenhum valor for encontrado nos cookies ou no elemento `<html>`, 
+     * é utilizada a configuração do navegador. Caso o navegador também não forneça 
+     * um idioma, o padrão será `"pt_BR"`.
+     * 
+     * @returns O idioma definido (ex.: "pt_BR", "en_US").
+     * 
+     * @example
+     * LangUtils.getLanguage(); // Retorna o idioma atual
+     */
+    public static getLanguage(): string {
+        const cookieLanguage = this.getLanguageFromCookie();
+
+        if (cookieLanguage) {
+            return this.convertLanguage(cookieLanguage);
+        }
+
+        return this.getHtmlLanguage();
+    }
+
+    /**
+     * Recupera o valor do atributo `lang` do elemento `<html>`. Se o ambiente 
+     * estiver em modo de desenvolvimento, o idioma padrão será `"pt_BR"`. Caso 
+     * contrário, utiliza o idioma do navegador ou `"pt-BR"` como padrão.
+     * 
+     * @returns O idioma definido no elemento `<html>` ou o padrão.
+     * 
+     * @example
+     * LangUtils.getHtmlLanguage(); // Retorna "pt_BR" no modo desenvolvimento
+     */
+    public static getHtmlLanguage(): string {
+        if (process.env.NODE_ENV === 'development') {
+            return LangUtils.ELanguages.PT_BR;
+        }
+
+        const lang = document.documentElement.lang || navigator.language || "pt-BR";
+
+        return this.convertLanguage(lang);
+    }
+
+    /**
+     * Define o atributo `lang` no elemento `<html>` e atualiza o cookie de idioma.
+     * 
+     * @param language - O idioma a ser definido (ex.: "pt_BR", "en_US").
+     * 
+     * > **Nota:** Definir o idioma no elemento `<html>` é essencial para garantir que o conteúdo 
+     * da página seja interpretado corretamente por navegadores, leitores de tela e mecanismos de 
+     * busca, melhorando a acessibilidade e a indexação.
+     * 
+     * @example
+     * LangUtils.setHtmlLanguage("en_US"); // Define o idioma como "en_US"
+     */
+    public static setHtmlLanguage(language: string): void {
+        document.documentElement.lang = language;
+        document.cookie = `lang=${language}; path=/;`;
+    }
+
+    /**
+     * Recupera o valor do cookie de idioma.
+     * 
+     * @returns O valor do cookie de idioma ou `null` se não existir.
+     * 
+     * @example
+     * LangUtils.getLanguageFromCookie(); // Retorna "pt_BR" se o cookie existir
+     */
+    public static getLanguageFromCookie(): string | null {
+        const match = document.cookie.match(new RegExp('(^| )lang=([^;]+)'));
+        return match ? match[2] : null;
+    }
+
+    /**
+     * Define o atributo `lang` no elemento `<html>` com base no cookie de idioma, se existir.
+     * 
+     * @example
+     * LangUtils.applyLanguageFromCookie(); // Aplica o idioma do cookie ao elemento `<html>`
+     */
+    public static applyLanguageFromCookie(): void {
+        const langFromCookie = this.getLanguageFromCookie();
+        if (langFromCookie) {
+            this.setHtmlLanguage(langFromCookie);
+        }
+    }
+}

package/src/utils/SortingUtils.ts

@@ -1,7 +1,7 @@
 import DataUnit from "../dataunit/DataUnit.js";
 import { FieldDescriptor, Sort, SortMode } from "../dataunit/metadata/UnitMetadata.js";
 import { FieldComparator } from "../dataunit/sorting/FieldComparator.js";
-import { Record } from '../dataunit/DataUnit.js';
+import { Record } from '../dataunit/interfaces/dataUnit.js';
 
 /**
  * `SortingUtils`: Utilizado para auxiliar na ordenacao de registros.

package/test/dataunit/AccessParentsDataUnit.spec.ts

@@ -0,0 +1,69 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+import { metadata } from "./resources/metadata";
+
+describe('Access parent dataUnits', () => {
+    let dataUnit: DataUnit;
+    let metadataLoaderMock = jest.fn();
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit, metadataLoaderMock } = createDataUnitMock());
+    });
+
+    describe('getChildInfo', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should return metadata children data', () => {
+            const name = dataUnit.getChildInfo('child');
+            expect(name).toStrictEqual(metadata.children![0]);
+        });
+
+        it('should return undefined when dont has metadata', async () => {
+            metadataLoaderMock.mockResolvedValue(undefined);
+            await dataUnit.loadMetadata();
+            const name = dataUnit.getChildInfo('child');
+            expect(name).toBeUndefined();
+        });
+
+        it('should return undefined when dont has metadata children data', async () => {
+            metadataLoaderMock.mockResolvedValue({ ...metadata, children: undefined });
+            await dataUnit.loadMetadata();
+            const name = dataUnit.getChildInfo('child');
+            expect(name).toBeUndefined();
+        });
+    });
+
+    describe('getParentDataUnit', () => {
+        it('should return parent dataUnit', () => {
+            const childDataUnit = new DataUnit('child', dataUnit);
+            const parentDataUnit = childDataUnit.getParentDataUnit();
+            expect(parentDataUnit).toStrictEqual(dataUnit);
+        });
+    });
+
+    describe('isParentDirty', () => {
+        it('should return true when parent is dirty', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            const childDataUnit = new DataUnit('child', dataUnit);
+            const parentIsDirty = childDataUnit.isParentDirty();
+            expect(parentIsDirty).toBeTruthy();
+        });
+
+        it('should return false when parent is not dirty', () => {
+            const childDataUnit = new DataUnit('child', dataUnit);
+            const parentIsDirty = childDataUnit.isParentDirty();
+            expect(parentIsDirty).toBeFalsy();
+        });
+
+        it('should return false when dont has parent', () => {
+            const parentIsDirty = dataUnit.isParentDirty();
+            expect(parentIsDirty).toBeFalsy();
+        });
+    });
+});

package/test/dataunit/Actions.spec.ts

@@ -0,0 +1,74 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { Action, DataUnitAction } from "../../src/dataunit/state/action/DataUnitAction";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+import { recordsTest } from "./resources/records";
+
+describe('Actions', () => {
+    let dataUnit: DataUnit;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit } = createDataUnitMock());
+    });
+
+    describe('savingCanceled', () => {
+        it('should emit event savingCanceled', async () => {
+            const savingCanceled = jest.fn();
+            const observer = async (action: DataUnitAction) => {
+                if (action.type === Action.SAVING_CANCELED) {
+                    savingCanceled();
+                }
+                return;
+            }
+            dataUnit.subscribe(observer);
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            dataUnit.savingCanceled([{ name: 'column_name_1', message: 'cancel_saving' }], 'test_1');
+            expect(savingCanceled).toHaveBeenCalled();
+        });
+    });
+
+    describe('clearInvalid', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should emit event savingCanceled', async () => {
+            const invalidateClean = jest.fn();
+            const observer = async (action: DataUnitAction) => {
+                if (action.type === Action.INVALIDATE_CLEAN) {
+                    invalidateClean();
+                }
+                return;
+            }
+            dataUnit.subscribe(observer);
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            dataUnit.clearInvalid('test_1', 'column_name_1');
+            expect(invalidateClean).toHaveBeenCalled();
+        });
+    });
+
+    describe('redo', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
+            dataUnit.saveLoader = saveLoaderMock;
+        });
+
+
+        it('should return true when field value changes can redo', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            dataUnit.undo();
+            let fieldValue = dataUnit.getFieldValue('column_name_1');
+            expect(fieldValue).toBe('column_value_1');
+            dataUnit.redo();
+            fieldValue = dataUnit.getFieldValue('column_name_1');
+            expect(fieldValue).toBe('new_value');
+        });
+    });
+});

package/test/dataunit/Change.spec.ts

@@ -0,0 +1,66 @@
+import { Change } from "../../src/dataunit/Changes";
+import { ChangeOperation } from "../../src/dataunit/interfaces/dataUnit";
+
+describe('Change', () => {
+    let change: Change;
+    beforeEach(() => {
+        change = new Change(
+            'test',
+            { __record__id__: 'test_1' },
+            undefined,
+            ChangeOperation.COPY,
+            'source_id',
+        );
+    });
+
+    it('should return operation', () => {
+        const response = change.operation;
+        expect(response).toBe('COPY');
+    });
+
+    it('should return false when operation is not insert', () => {
+        const response = change.isInsert();
+        expect(response).toBeFalsy();
+    });
+
+    it('should return true when operation is insert', () => {
+        change = new Change(
+            'test',
+            { __record__id__: 'test_1' },
+            undefined,
+            ChangeOperation.INSERT,
+            'source_id',
+        );
+        const response = change.isInsert();
+        expect(response).toBeTruthy();
+    });
+
+    it('should return true when operation is copy', () => {
+        const response = change.isCopy();
+        expect(response).toBeTruthy();
+    });
+
+    it('should return true when operation is delete', () => {
+        change = new Change(
+            'test',
+            { __record__id__: 'test_1' },
+            undefined,
+            ChangeOperation.DELETE,
+            'source_id',
+        );
+        const response = change.isDelete();
+        expect(response).toBeTruthy();
+    });
+
+    it('should return true when operation is update', () => {
+        change = new Change(
+            'test',
+            { __record__id__: 'test_1' },
+            undefined,
+            ChangeOperation.UPDATE,
+            'source_id',
+        );
+        const response = change.isUpdate();
+        expect(response).toBeTruthy();
+    });
+});