export async function updateItemForDocument()

in src/controller/utils.ts [192:235]
37 lines of code
10 McCabe index (conditional complexity)

export async function updateItemForDocument(uri: Uri, testTypes?: IJavaTestItem[]): Promise<TestItem[]> {
    testTypes = testTypes ?? await findTestTypesAndMethods(uri.toString());

    let belongingPackage: TestItem | undefined;
    if (testTypes.length === 0) {
        belongingPackage = await resolveBelongingPackage(uri);
    } else {
        belongingPackage = findBelongingPackageItem(testTypes[0]) || await resolveBelongingPackage(uri);
    }
    if (!belongingPackage) {
        sendError(new Error('Failed to find the belonging package'));
        return [];
    }

    const tests: TestItem[] = [];
    if (testTypes.length === 0) {
        // Remove the children with the same uri when no test items is found
        belongingPackage.children.forEach((typeItem: TestItem) => {
            if (path.relative(typeItem.uri?.fsPath || '', uri.fsPath) === '') {
                belongingPackage!.children.delete(typeItem.id);
            }
        });
    } else {
        for (const testType of testTypes) {
            // here we do not directly call synchronizeItemsRecursively() because testTypes here are just part of the
            // children of the belonging package, we don't want to delete other children unexpectedly.
            let testTypeItem: TestItem | undefined = belongingPackage.children.get(testType.id);
            if (!testTypeItem) {
                testTypeItem = createTestItem(testType, belongingPackage);
                testTypeItem.canResolveChildren = true;
            } else {
                updateTestItem(testTypeItem, testType);
            }
            tests.push(testTypeItem);
            synchronizeItemsRecursively(testTypeItem, testType.children);
        }
    }

    if (belongingPackage.children.size === 0) {
        belongingPackage.parent?.children.delete(belongingPackage.id);
    }

    return tests;
}