devops-plugin-kit 0.1.0

package/@danieli-automation/devops-plugin-features/src/features/work-items/api/workItems.ts

@@ -0,0 +1,193 @@
+import { WorkItem, WorkItemErrorPolicy, WorkItemExpand } from "azure-devops-extension-api/WorkItemTracking";
+import { witClient } from "core/azureClients";
+import { AdoWorkItemType } from 'features/work-items/types/AdoWorkItemType';
+
+/**
+ * Fetches work items by their IDs within a project.
+ * 
+ * @param ids - Array of work item IDs to fetch
+ * @param projectId - Optional project ID to scope the query
+ * @param fields - Optional array of fields to retrieve for each work item
+ * @param expand - Optional expansion options for the work items
+ * @returns Promise resolving to an array of work items
+ */
+export async function fetchWorkItemsByIds(ids: number[], projectId?: string, fields?: string[], expand: WorkItemExpand = WorkItemExpand.All): Promise<AdoWorkItemType[]> {
+    if (!ids || ids.length === 0) return [];
+
+    const client = witClient();
+    const uniqueIds = Array.from(new Set(ids));
+    const BATCH_SIZE = 150;
+    const result: AdoWorkItemType[] = [];
+
+    const fieldsArg = expand !== WorkItemExpand.None ? undefined : fields;
+
+    for (let i = 0; i < uniqueIds.length; i += BATCH_SIZE) {
+        const slice = uniqueIds.slice(i, i + BATCH_SIZE);
+
+        try {
+            const batch = await client.getWorkItems(
+                slice,
+                projectId,
+                fieldsArg,
+                undefined,
+                expand,
+                WorkItemErrorPolicy.Omit
+            );
+
+            if (Array.isArray(batch)) {
+                const cleaned = batch.filter((wi): wi is WorkItem => !!wi && typeof wi.id === "number" && !!wi.fields)
+                result.push(...cleaned);
+            }
+
+        } catch (err) {
+            console.error("[fetchWorkItemsByIds] failed batch", { projectId, slice }, err);
+        }
+    }
+    return result;
+}
+
+/**
+ * Fetches work item details by given id and project id
+ * 
+ * @param id - the id of the work item
+ * @param project - the id of the related project
+ * @param fields - the work items to select
+ * @returns Promise resolving to the object of work item
+ */
+export async function fetchWorkItemById(id: number, project?: string, fields?: string[], expand: WorkItemExpand = WorkItemExpand.Relations) {
+    const wit = witClient();
+    const fieldsArg = expand !== WorkItemExpand.None ? undefined : fields;
+    const workItem = await wit.getWorkItem(id, project, fieldsArg, undefined, expand);
+    return workItem;
+}
+
+/**
+ * Fetches child work items for a given parent work item within a project.
+ * 
+ * @param projectId - The ID of the project
+ * @param parentId - The ID of the parent work item
+ * @param fields - Optional array of fields to retrieve for each child work item
+ * @param signal - Optional AbortSignal to cancel the request
+ * @returns Promise resolving to an array of child work items
+ * 
+ */
+export async function fetchChildren(projectId: string, parentId: number, fields?: string[], signal?: AbortSignal) {
+
+    if (signal?.aborted) return [];
+
+    const wit = witClient();
+    const parent = await wit.getWorkItem(parentId, projectId, undefined, undefined, WorkItemExpand.Relations);
+    const rels = parent.relations || [];
+    const childIdArray: number[] = [];
+
+    for (const r of rels) {
+        if (signal?.aborted) return [];
+        if (r.rel === "System.LinkTypes.Hierarchy-Forward") {
+            const m = r.url?.match(/(\d+)$/);
+            if (m) childIdArray.push(+m[1]);
+        }
+    }
+
+    if (childIdArray.length === 0) return [];
+
+    return fetchWorkItemsByIds(childIdArray, projectId, fields);
+}
+
+/**
+ * Updates a work item with the specified changes within a project.
+ *
+ * @param taskId - The ID of the work item to update
+ * @param changes - An array of change operations to apply to the work item
+ * @param project - The project ID where the work item resides
+ * @returns Promise resolving to the updated work item
+ * 
+ */
+export async function updateWorkItem(taskId: number, changes: any[], project: string) {
+
+    const wit = witClient();
+    const wi = await wit.getWorkItem(taskId, project, undefined, undefined, WorkItemExpand.Fields);
+    const currentRev = wi.rev;
+    return wit.updateWorkItem(
+        [
+            { op: "test", path: "/rev", value: currentRev },
+            ...changes
+        ],
+        taskId,
+        project,
+        false,
+        false
+    );
+}
+
+/**
+ * Creates a new work item within a project, optionally linking it to a parent work item.
+ * 
+ * @param project - The project ID where the work item will be created
+ * @param parentId - The ID of the parent work item, if any
+ * @param fields - A record of fields to set on the new work item
+ * @returns Promise resolving to the created work item
+ * 
+ */
+export async function createWorkItem(project: string, parentId: number, fields: Record<any, any>) {
+    const wit = witClient();
+    const { title, state, iterationPath, areaPath, workItemType, parent } = fields;
+
+    const patchDocument = [
+        { op: "add", path: "/fields/System.Title", value: title ?? "New Task" },
+        { op: "add", path: "/fields/System.State", value: state ?? "To Do" },
+        { op: "add", path: "/fields/System.AreaPath", value: areaPath },
+        { op: "add", path: "/fields/System.IterationPath", value: normalizeAndEscapeIterationPath(iterationPath) },
+        { op: "add", path: "/fields/System.Parent", value: parent },
+        //{ op: "add", path: "/fields/System.History", value: }
+    ];
+
+    if (parentId) {
+        patchDocument.push({
+            op: "add",
+            path: "/relations/-",
+            value: {
+                rel: "System.LinkTypes.Hierarchy-Reverse",
+                url: `vstfs:///WorkItemTracking/WorkItem/${parentId}`,
+            },
+        });
+    }
+
+    const result = await wit.createWorkItem(patchDocument, project, workItemType);
+
+    return result;
+}
+
+/**
+ * Deletes a work item within a project.
+ * 
+ * @param taskId - The ID of the work item to delete
+ * @param project - The project ID where the work item resides
+ * @returns Promise resolving to the deletion result
+ * 
+ */
+export async function deleteWorkItem(taskId: number, project: string) {
+    const wit = witClient();
+    return wit.deleteWorkItem(taskId, project);
+}
+
+//#region Private Functions
+
+/**
+ * Normalize then escape backslashes so result is safe for Azure DevOps JSON payloads.
+ * This is idempotent: calling it multiple times yields the same result.
+ *
+ * Examples at runtime (string contents):
+ *  "JOB_CLIENTE1\\Sprint 5" -> "JOB_CLIENTE1\\\\Sprint 5"
+ *  "JOB_CLIENTE1\Sprint 5"  -> "JOB_CLIENTE1\\\\Sprint 5"
+ *
+ * @param path Iteration path value.
+ * @returns Normalized and escaped iteration path.
+ */
+function normalizeAndEscapeIterationPath(path: string) {
+    if (path == null) return path;           // keep null/undefined as-is
+    // Collapse any run of backslashes to a single backslash
+    const collapsed = path.replace(/\\+/g, '\\');
+    // Escape single backslashes for JSON payload (double them)
+    return collapsed.replace(/\\/g, '\\\\');
+}
+//#endregion

package/@danieli-automation/devops-plugin-features/src/features/work-items/constants/DefaultConsant.ts

@@ -0,0 +1,43 @@
+import StateConstant from "./StateConstant.js";
+import TypeConstant from "./TypeConstant.js";
+
+export const WORK_ITEM_TYPES = [TypeConstant.PRODUCT_BACKLOG_ITEM_TYPE, TypeConstant.BUG_TYPE, TypeConstant.TASK_TYPE];
+
+//@TODO: States should be fetched from the api
+export const WORK_ITEM_STATES = [
+    StateConstant.NEW_STATE,
+    StateConstant.TO_DO_STATE,
+    StateConstant.IN_PROGRESS_STATE,
+    StateConstant.DONE_STATE,
+    StateConstant.EXECUTING_STATE,
+    StateConstant.TERMINATED_STATE,
+    StateConstant.APPROVED_STATE,
+    StateConstant.REMOVED_STATE,
+    StateConstant.COMMITTED_STATE,
+    StateConstant.DEFAULT_STATE
+];
+
+//@TODO: Colors should be fetched from the api
+export const WORK_ITEM_STATE_COLORS: { [state: string]: string } = {
+    [StateConstant.NEW_STATE]: "rgb(178, 178, 178)",
+    [StateConstant.COMMITTED_STATE]: "#007acc",
+    [StateConstant.IN_PROGRESS_STATE]: "#007acc",
+    [StateConstant.EXECUTING_STATE]: "#A020F0",
+    [StateConstant.TERMINATED_STATE]: "#6BB700",
+    [StateConstant.APPROVED_STATE]: "rgb(178, 178, 178)",
+    [StateConstant.REMOVED_STATE]: "rgba(218, 213, 208, 0.5)",
+    [StateConstant.TO_DO_STATE]: "rgb(178, 178, 178)",
+    [StateConstant.DONE_STATE]: "#339933",
+    [StateConstant.DEFAULT_STATE]: "rgb(178, 178, 178)",
+    [StateConstant.BLOCKED_STATE]: "rgb(230, 0, 23);"
+};
+
+//@TODO: Icons should be fetched from the api
+export const WORK_ITEM_TYPE_ICON: { [type: string]: { iconName: string; color: string } } = {
+    [TypeConstant.EPIC_TYPE]: { iconName: "CrownSolid", color: "rgb(224,108,0)" },
+    [TypeConstant.FEATURE_TYPE]: { iconName: "Trophy", color: "rgb(119,59,147)" },
+    [TypeConstant.BUG_TYPE]: { iconName: "LadybugSolid", color: "rgb(204, 41, 6)" },
+    [TypeConstant.TASK_TYPE]: { iconName: "TaskSolid", color: "rgb(164, 136, 10)" },
+    [TypeConstant.PRODUCT_BACKLOG_ITEM_TYPE]: { iconName: "PageListSolid", color: "rgb(0, 152, 199)" },
+    "Default": { iconName: "WorkItem", color: "#605E5C" }
+};

package/@danieli-automation/devops-plugin-features/src/features/work-items/constants/FieldConstant.ts

@@ -0,0 +1,27 @@
+//Work Item Field Constants
+
+export default {
+    WORK_ITEM_FIELD_ID: "System.Id",
+    WORK_ITEM_FIELD_ASSIGNED_TO: "System.AssignedTo",
+    WORK_ITEM_FIELD_STATE: "System.State",
+    WORK_ITEM_FIELD_WORK_ITEM_TYPE: "System.WorkItemType",
+    WORK_ITEM_FIELD_PARENT: "System.Parent",
+    WORK_ITEM_FIELD_TITLE: "System.Title",
+    WORK_ITEM_FIELD_CREATED_DATE: "System.CreatedDate",
+    WORK_ITEM_FIELD_CHANGED_DATE: "System.ChangedDate",
+    WORK_ITEM_FIELD_AREA_PATH: "System.AreaPath",
+    WORK_ITEM_FIELD_ITERATION_LEVEL_1: "System.IterationLevel1",
+    WORK_ITEM_FIELD_ITERATION_LEVEL_2: "System.IterationLevel2",
+    WORK_ITEM_FIELD_ITERATION_PATH: "System.IterationPath",
+    WORK_ITEM_FIELD_ITERATION_ID: "System.IterationId",
+    WORK_ITEM_FIELD_TEAM_PROJECT: "System.TeamProject",
+    WORK_ITEM_FIELD_TAGS: "System.Tags",
+    WORK_ITEM_FIELD_CHANGED_BY: "System.ChangedBy",
+    WORK_ITEM_FIELD_EFFORT: "Microsoft.VSTS.Scheduling.Effort",
+    WORK_ITEM_FIELD_REMAINING_WORK: "Microsoft.VSTS.Scheduling.RemainingWork",
+    WORK_ITEM_FIELD_CLOSED_DATE: "Microsoft.VSTS.Common.ClosedDate",
+    WORK_ITEM_FIELD_PRIORITY: "Microsoft.VSTS.Common.Priority",
+    WORK_ITEM_FIELD_TIME_SPENT: "Custom.Timespent",
+    WORK_ITEM_FIELD_ITERATION_INFO: "Custom.IterationInfo",
+    WORK_ITEM_FIELD_ORDER: "order"
+}

package/@danieli-automation/devops-plugin-features/src/features/work-items/constants/StateConstant.ts

@@ -0,0 +1,16 @@
+export default {
+    NEW_STATE: "New",
+    COMMITTED_STATE: "Committed",
+    IN_PROGRESS_STATE: "In Progress",
+    EXECUTING_STATE: "Executing",
+    TERMINATED_STATE: "Terminated",
+    APPROVED_STATE: "Approved",
+    REMOVED_STATE: "Removed",
+    TO_DO_STATE: "To Do",
+    DONE_STATE: "Done",
+    DEFAULT_STATE: "Default",
+    COMPLETED_STATE: "Completed",
+    CLOSED_STATE: "Closed",
+    RESOLVED_STATE: "Resolved",
+    BLOCKED_STATE: "Blocked"
+}

package/@danieli-automation/devops-plugin-features/src/features/work-items/constants/TypeConstant.ts

@@ -0,0 +1,8 @@
+//Work Item Type Constants
+export default {
+    EPIC_TYPE: "Epic",
+    FEATURE_TYPE: "Feature",
+    PRODUCT_BACKLOG_ITEM_TYPE: "Product Backlog Item",
+    BUG_TYPE: "Bug",
+    TASK_TYPE: "Task"
+}

package/@danieli-automation/devops-plugin-features/src/features/work-items/services/WIQLService.ts

@@ -0,0 +1,101 @@
+import { witClient } from "core/azureClients";
+import { AreaGroup } from "features/teams/services/ProjectService";
+import { wiqlForMultipleIterations, wiqlForParentWorkItems, wiqlForSingleIteration } from "features/work-items/api/wiql";
+import { fetchWorkItemsByIds } from "features/work-items/api/workItems";
+import { AdoWorkItemType } from "features/work-items/types/AdoWorkItemType";
+
+export const WIQLService = {
+
+    /**
+     * Fetches parent work items (PBIs and Bugs) for the given child work item IDs across projects.
+     * 
+     * @param workItemIds 
+     * @param projectId 
+     * @returns Promise resolving to an array of parent work items
+     * 
+     */
+    getParentWorkItemsForPbisAndBugs: async (workItemIds: number[], projectId?: string): Promise<AdoWorkItemType[]> => {
+
+        const wiql = wiqlForParentWorkItems(workItemIds);
+        if (!wiql) return [];
+
+        const wit = witClient();
+        const res = await wit.queryByWiql({ query: wiql }, undefined, projectId ?? "");
+
+        const parentIds = new Set<number>();
+        const relations = res.workItemRelations || [];
+
+        for (const rel of relations) {
+            if (rel.source?.id) parentIds.add(rel.source.id);
+        }
+
+        if (parentIds.size === 0) return [];
+        const parentIdArray = Array.from(parentIds);
+        return fetchWorkItemsByIds(parentIdArray, projectId ?? "");
+    },
+
+    /**
+     * @description: Fetches Task IDs that belong to the selected iteration, per project area groups.
+     * @param areaGroups Project+area scoping.
+     * @param iterationPath Selected iteration path.
+     * @returns Promise resolving to a unique list of task IDs.
+     */
+    getTaskIdsForSelectedIteration: async (areaGroups: AreaGroup[], iterationPaths: string[]): Promise<number[]> => {
+        const out = new Set<number>();
+        const wit = witClient();
+
+        const results = await Promise.all(
+            areaGroups.map(async (g) => {
+                if (!g.areaPaths?.length) return [];
+
+                const { tasksQuery } = iterationPaths.length > 1
+                    ? wiqlForMultipleIterations(iterationPaths, g.areaPaths)
+                    : wiqlForSingleIteration(iterationPaths[0], g.areaPaths);
+                const res = await wit.queryByWiql({ query: tasksQuery }, undefined, g.projectId ?? "");
+                return (res.workItems ?? []).map(w => w.id).filter(Boolean) as number[];
+            })
+        );
+
+        for (const ids of results) {
+            for (const id of ids) out.add(id);
+        }
+
+        return Array.from(out);
+    },
+
+    /**
+     * @description: Fetches parent work item IDs (PBIs/Bugs) that belong to the selected iteration,
+     *               scoped by project area groups.
+     * @param areaGroups Project+area scoping.
+     * @param iterationPath Selected iteration path.
+     * @returns Promise resolving to a unique list of parent work item IDs.
+     */
+    getParentIdsForSelectedIteration: async (areaGroups: AreaGroup[], iterationPaths: string[]): Promise<number[]> => {
+        const out = new Set<number>();
+        const wit = witClient();
+
+        const results = await Promise.all(
+            areaGroups.map(async (g) => {
+                if (!g.areaPaths?.length) return [];
+
+                const { parentsQuery } = iterationPaths.length > 1
+                    ? wiqlForMultipleIterations(iterationPaths, g.areaPaths)
+                    : wiqlForSingleIteration(iterationPaths[0], g.areaPaths);
+                const res = await wit.queryByWiql({ query: parentsQuery }, undefined, g.projectId ?? "");
+                return (res.workItems ?? []).map(w => w.id).filter(Boolean) as number[];
+            })
+        );
+
+        for (const ids of results) {
+            for (const id of ids) out.add(id);
+        }
+
+        return Array.from(out);
+    }
+};
+
+
+
+
+
+

package/@danieli-automation/devops-plugin-features/src/features/work-items/services/WorkItemService.ts

@@ -0,0 +1,54 @@
+import { WorkItemExpand } from "azure-devops-extension-api/WorkItemTracking";
+import { fetchWorkItemById } from "features/work-items/api/workItems";
+import FieldConstant from "features/work-items/constants/FieldConstant";
+
+export const WorkItemService = {
+
+    /**
+     * Fetches a single work item including its relations (parent/child links, etc.).
+     * Used for traversing work item hierarchy via "System.LinkTypes.Hierarchy-Forward".
+     *
+     * @param id - Work item ID
+     * @param projectId - Project name or ID used by the client
+     * @returns Promise resolving to the work item including `relations`
+     */
+    collectDescendantWorkItemIds: async (rootId: number, project: string): Promise<number[]> => {
+        const visited = new Set<number>();
+        const result: number[] = [];
+
+        const stack: number[] = [rootId];
+
+        while (stack.length > 0) {
+            const id = stack.pop()!;
+            if (visited.has(id)) continue;
+            visited.add(id);
+
+            const wi = await fetchWorkItemById(id, project, [FieldConstant.WORK_ITEM_FIELD_ID]);
+            const relations = wi?.relations ?? [];
+
+            for (const r of relations) {
+                if (r.rel !== "System.LinkTypes.Hierarchy-Forward") continue;
+                const match = r.url?.match(/(\d+)$/);
+                if (!match) continue;
+                const childId = Number(match[1]);
+                if (!Number.isFinite(childId) || visited.has(childId)) continue;
+
+                result.push(childId);
+                stack.push(childId);
+            }
+        }
+        return result;
+    },
+
+    /**
+     * Fetches a single work item including its relations (parent/child links, etc.).
+     *
+     * @param id - Work item ID
+     * @param projectId - Project name or ID used by the client
+     * @returns Promise resolving to the work item including `relations`
+     */
+    getWorkItemById: async (workItemId: number, project?: string, fields?: string[], expand?: WorkItemExpand) => {
+        const workItem = await fetchWorkItemById(workItemId, project, fields, expand);
+        return workItem;
+    }
+}

package/@danieli-automation/devops-plugin-features/src/features/work-items/types/AdoWorkItemType.ts

@@ -0,0 +1,18 @@
+import { WorkItemRelation } from "azure-devops-extension-api/WorkItemTracking";
+
+export type AdoWorkItemType = {
+    id: any,
+    tempId?: string
+    fields: { [key: string]: any; }
+    _links?: any;
+    url?: string;
+    order?: number;
+    displayOrder?: string;
+    rev?: number;
+    multiLineFields?: { [k: string]: string[] };
+    relations?: WorkItemRelation[];
+    isNewTask?: boolean;
+    parentWorkItem?: AdoWorkItemType;
+    isFaded?: boolean | undefined;
+    _children?: AdoWorkItemType[];
+};

package/@danieli-automation/devops-plugin-features/src/features/work-items/utils/__tests__/filter.test.ts

@@ -0,0 +1,87 @@
+import FieldConstant from "features/work-items/constants/FieldConstant";
+import StateConstant from "features/work-items/constants/StateConstant";
+import TypeConstant from "features/work-items/constants/TypeConstant";
+import { AdoWorkItemType } from "features/work-items/types/AdoWorkItemType";
+import { describe, expect, it } from "vitest";
+import { filterEpics, filterFeatures, filterPbisAndBugs, filterTasks } from '../filter.js';
+
+describe("Utils: Filter Helper Tests", () => {
+
+    const epicTypeWorkItem: AdoWorkItemType = {
+        id: 1,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "1",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 1",
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.EPIC_TYPE
+        }
+    }
+
+    const featureTypeWorkItem: AdoWorkItemType = {
+        id: 2,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "2",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 2",
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.FEATURE_TYPE
+        }
+    }
+
+    const pbiTypeWorkItem: AdoWorkItemType = {
+        id: 3,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "3",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 3",
+            [FieldConstant.WORK_ITEM_FIELD_STATE]: StateConstant.EXECUTING_STATE,
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.PRODUCT_BACKLOG_ITEM_TYPE
+        }
+    }
+
+    const bugTypeWorkItem: AdoWorkItemType = {
+        id: 4,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "4",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 4",
+            [FieldConstant.WORK_ITEM_FIELD_STATE]: StateConstant.EXECUTING_STATE,
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.BUG_TYPE
+        }
+    }
+
+    const taskTypeWorkItem: AdoWorkItemType = {
+        id: 5,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "5",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 5",
+            [FieldConstant.WORK_ITEM_FIELD_STATE]: StateConstant.IN_PROGRESS_STATE,
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.TASK_TYPE
+        }
+    }
+
+    const workItems: AdoWorkItemType[] = [epicTypeWorkItem, featureTypeWorkItem, pbiTypeWorkItem, bugTypeWorkItem, taskTypeWorkItem];
+
+    //#region filterEpics
+    it("filterEpics: returns filtered epic type work items from given array of data", () => {
+        expect(filterEpics(workItems)).toEqual([{ ...epicTypeWorkItem }]);
+    });
+    //#endregion
+
+    //#region filterFeatures
+    it("filterFeatures: returns filtered feature type work items from given array of data", () => {
+        expect(filterFeatures(workItems)).toEqual([{ ...featureTypeWorkItem }]);
+    });
+    //#endregion
+
+    //#region filterPbisAndBugs
+    it("filterPbisAndBugs: returns filtered pbis and bug type work items from given array of data", () => {
+        const result = filterPbisAndBugs(workItems);
+
+        expect(result).toHaveLength(2);
+        expect(result).toEqual(expect.arrayContaining([bugTypeWorkItem, pbiTypeWorkItem]));
+    });
+    //#endregions
+
+    //#region filterTasks
+    it("filterTasks: returns filtered task type work items from given array of data", () => {
+        expect(filterTasks(workItems)).toEqual([{ ...taskTypeWorkItem }]);
+    });
+    //#endregions
+
+});

package/@danieli-automation/devops-plugin-features/src/features/work-items/utils/__tests__/workItem.test.ts

@@ -0,0 +1,116 @@
+import FieldConstant from "features/work-items/constants/FieldConstant";
+import TypeConstant from "features/work-items/constants/TypeConstant";
+import { describe, expect, it } from "vitest";
+import { AdoWorkItemType } from "../../types/AdoWorkItemType.js";
+import { calculateTotalRemainingWorkByWorkItems, getEpicByWorkItem, getFeatureByWorkItem } from "../workItem.js";
+
+describe("Utils: WorkItem Helper Tests", () => {
+
+    const epic7420: AdoWorkItemType = {
+        id: 7420,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "7420",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 7420",
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.EPIC_TYPE,
+        },
+        relations: [
+            {
+                rel: "System.LinkTypes.Hierarchy-Forward",
+                url: "https://dev.azure.com/org/project/_apis/wit/workItems/7428", // child = feature 7428
+                attributes: {}
+            },
+        ],
+    };
+
+    const epic7421: AdoWorkItemType = {
+        id: 7421,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "7421",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 7421",
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.EPIC_TYPE,
+        },
+        relations: [],
+    };
+
+    const feature7428: AdoWorkItemType = {
+        id: 7428,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "7428",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 7428",
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.FEATURE_TYPE,
+        },
+        relations: [
+            {
+                rel: "System.LinkTypes.Hierarchy-Forward",
+                url: "https://dev.azure.com/org/project/_apis/wit/workItems/2", // child = PBI id 2
+                attributes: {}
+            },
+        ],
+    };
+
+    const pbi2: AdoWorkItemType = {
+        id: 2,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "2",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 2",
+            [FieldConstant.WORK_ITEM_FIELD_REMAINING_WORK]: 3,
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.PRODUCT_BACKLOG_ITEM_TYPE,
+        },
+    };
+
+    const pbi3: AdoWorkItemType = {
+        id: 3,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "3",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 3",
+            [FieldConstant.WORK_ITEM_FIELD_REMAINING_WORK]: 3,
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.PRODUCT_BACKLOG_ITEM_TYPE,
+        },
+    };
+
+    const pbi4: AdoWorkItemType = {
+        id: 4,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "4",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 4",
+            [FieldConstant.WORK_ITEM_FIELD_REMAINING_WORK]: 3,
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.PRODUCT_BACKLOG_ITEM_TYPE,
+        },
+    };
+
+    const pbi5: AdoWorkItemType = {
+        id: 5,
+        fields: {
+            [FieldConstant.WORK_ITEM_FIELD_ID]: "5",
+            [FieldConstant.WORK_ITEM_FIELD_TITLE]: "This is test work item 5",
+            [FieldConstant.WORK_ITEM_FIELD_REMAINING_WORK]: 3,
+            [FieldConstant.WORK_ITEM_FIELD_WORK_ITEM_TYPE]: TypeConstant.PRODUCT_BACKLOG_ITEM_TYPE,
+        },
+    };
+
+    const workItems: AdoWorkItemType[] = [epic7420, epic7421, feature7428, pbi2, pbi3, pbi4, pbi5];
+
+    //#region getEpicById
+    it("getEpicById: returns epic type work item by the id of child work item among the provided array of work items", () => {
+        const result = getEpicByWorkItem(pbi2, workItems);
+
+        expect(result).toEqual(epic7420);
+    });
+    //#endregion
+
+    //#region getFeatureById
+    it("getFeatureById: returns feature type work item by the id of child work item among the provided array of work items", () => {
+        const result = getFeatureByWorkItem(pbi2, workItems);
+
+        expect(result).toEqual(feature7428);
+    });
+    //#endregion
+
+    //#region calculateTotalRemainingWorkByWorkItems
+    it("calculateTotalRemainingWorkByWorkItems: returns total remaining work hours of the work items given", () => {
+        const result = calculateTotalRemainingWorkByWorkItems(workItems);
+
+        expect(result).toEqual(12);
+    });
+    //#endregion
+});