entry-editable.test.ts

import { addTags, getTag } from '../src/entry-editable'
import { entry_global_field, entry_global_field_multiple, entry_modular_block, entry_reference, entry_with_text, entry_with_applied_variants, entry_with_parent_path_variants } from './mock/entry-editable-mock'

describe('Entry editable test', () => {
    it('Entry with text test', done => {
        addTags(entry_with_text, 'entry_asset', false)        
        expect((entry_with_text as any)['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor')
        expect((entry_with_text as any)['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor_multiple')
        done()
    })

    it('Entry with text should return object test', done => {
        addTags(entry_with_text, 'entry_asset', true)        
        expect((entry_with_text as any)['$']['rich_text_editor']).toEqual({'data-cslp': 'entry_asset.entry_uid_1.en-us.rich_text_editor'})
        expect((entry_with_text as any)['$']['rich_text_editor_multiple']).toEqual({'data-cslp': 'entry_asset.entry_uid_1.en-us.rich_text_editor_multiple' })
        done()
    })

    it('Entry with Modular blocks test', done => {
        addTags(entry_modular_block, 'entry_multiple_content', false)        
        expect((entry_modular_block as any)['modular_blocks'][0]['rich_text_inmodular']['$']['rich_text_editor']).toEqual('data-cslp=entry_multiple_content.entry_uid_1.en-us.modular_blocks.0.rich_text_inmodular.rich_text_editor')
        expect((entry_modular_block as any)['modular_blocks'][0]['rich_text_inmodular']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_multiple_content.entry_uid_1.en-us.modular_blocks.0.rich_text_inmodular.rich_text_editor_multiple')

        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['$']['rich_text_editor']).toEqual('data-cslp=entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.rich_text_editor')
        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.rich_text_editor_multiple')

        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['group']['$']['rich_text_editor']).toEqual('data-cslp=entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.group.rich_text_editor')
        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['group']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.group.rich_text_editor_multiple')

        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor']).toEqual('data-cslp=entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.modular_blocks.0.rich_in_modular.rich_text_editor')
        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.modular_blocks.0.rich_in_modular.rich_text_editor_multiple')
        
        done()
    })
    it('Entry with Modular blocks test return object', done => {
        addTags(entry_modular_block, 'entry_multiple_content', true)        
        expect((entry_modular_block as any)['modular_blocks'][0]['rich_text_inmodular']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_multiple_content.entry_uid_1.en-us.modular_blocks.0.rich_text_inmodular.rich_text_editor'})
        expect((entry_modular_block as any)['modular_blocks'][0]['rich_text_inmodular']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_multiple_content.entry_uid_1.en-us.modular_blocks.0.rich_text_inmodular.rich_text_editor_multiple'})

        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.rich_text_editor'})
        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.rich_text_editor_multiple'})

        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['group']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.group.rich_text_editor'})
        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['group']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.group.rich_text_editor_multiple'})

        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.modular_blocks.0.rich_in_modular.rich_text_editor'})
        expect((entry_modular_block as any)['modular_blocks'][1]['global_modular']['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_multiple_content.entry_uid_1.en-us.modular_blocks.1.global_modular.modular_blocks.0.rich_in_modular.rich_text_editor_multiple'})
        
        done()
    })

    it('Entry with reference test', done => {
        addTags(entry_reference, 'entry_asset', false)        
        
        expect((entry_reference as any)['reference'][0]['$']['rich_text_editor']).toEqual('data-cslp=embed_entry.entry_uid_11.en-us.rich_text_editor')
        expect((entry_reference as any)['reference'][0]['$']['rich_text_editor_multiple']).toEqual('data-cslp=embed_entry.entry_uid_11.en-us.rich_text_editor_multiple')

        done()
    })

    it('Entry with reference should return object test', done => {
        addTags(entry_reference, 'entry_asset', true)        

        expect((entry_reference as any)['reference'][0]['$']['rich_text_editor']).toEqual({'data-cslp':'embed_entry.entry_uid_11.en-us.rich_text_editor'})
        expect((entry_reference as any)['reference'][0]['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'embed_entry.entry_uid_11.en-us.rich_text_editor_multiple'})

        done()
    })

    it('Entry with global fields test', done => {
        addTags(entry_global_field, 'entry_asset', false)        
        
        expect((entry_global_field as any)['global_rich']['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich.rich_text_editor')
        expect((entry_global_field as any)['global_rich']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich.rich_text_editor_multiple')

        expect((entry_global_field as any)['global_rich']['group']['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich.group.rich_text_editor')
        expect((entry_global_field as any)['global_rich']['group']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich.group.rich_text_editor_multiple')

        expect((entry_global_field as any)['global_rich']['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich.modular_blocks.0.rich_in_modular.rich_text_editor')
        expect((entry_global_field as any)['global_rich']['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich.modular_blocks.0.rich_in_modular.rich_text_editor_multiple')

        done()
    })

    it('Entry with reference should return object test', done => {
        addTags(entry_global_field, 'entry_asset', true)        

        expect((entry_global_field as any)['global_rich']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich.rich_text_editor'})
        expect((entry_global_field as any)['global_rich']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich.rich_text_editor_multiple'})

        expect((entry_global_field as any)['global_rich']['group']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich.group.rich_text_editor'})
        expect((entry_global_field as any)['global_rich']['group']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich.group.rich_text_editor_multiple'})

        expect((entry_global_field as any)['global_rich']['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich.modular_blocks.0.rich_in_modular.rich_text_editor'})
        expect((entry_global_field as any)['global_rich']['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich.modular_blocks.0.rich_in_modular.rich_text_editor_multiple'})

        done()
    })

    it('Entry with reference test', done => {
        addTags(entry_global_field_multiple, 'entry_asset', false)        
        
        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich_multiple.0.rich_text_editor')
        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich_multiple.0.rich_text_editor_multiple')

        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['group']['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich_multiple.0.group.rich_text_editor')
        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['group']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich_multiple.0.group.rich_text_editor_multiple')

        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich_multiple.0.modular_blocks.0.rich_in_modular.rich_text_editor')
        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.global_rich_multiple.0.modular_blocks.0.rich_in_modular.rich_text_editor_multiple')

        done()
    })

    it('Entry with reference should return object test', done => {
        addTags(entry_global_field_multiple, 'entry_asset', true)        

        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['$']['rich_text_editor']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich_multiple.0.rich_text_editor'})
        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich_multiple.0.rich_text_editor_multiple'})

        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['group']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich_multiple.0.group.rich_text_editor'})
        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['group']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich_multiple.0.group.rich_text_editor_multiple'})

        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich_multiple.0.modular_blocks.0.rich_in_modular.rich_text_editor'})
        expect((entry_global_field_multiple as any)['global_rich_multiple'][0]['modular_blocks'][0]['rich_in_modular']['$']['rich_text_editor_multiple']).toEqual({'data-cslp':'entry_asset.entry_uid_1.en-us.global_rich_multiple.0.modular_blocks.0.rich_in_modular.rich_text_editor_multiple'})

        done()
    })

    // Tests for applied variants functionality
    describe('Applied Variants Tests', () => {
        it('Entry with applied variants should generate v2 tags with variant suffix', done => {
            addTags(entry_with_applied_variants, 'entry_asset', false)

            // Field with direct variant match should get v2 prefix and variant suffix
            expect((entry_with_applied_variants as any)['$']['rich_text_editor']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_1.en-us.rich_text_editor')
            
            // Nested field with direct variant match
            expect((entry_with_applied_variants as any)['nested']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_2.en-us.nested.field')
            
            // Field without variant should not have v2 prefix
            expect((entry_with_applied_variants as any)['nested']['$']['other_field']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.nested.other_field')
            expect((entry_with_applied_variants as any)['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor_multiple')
            
            done()
        })

        it('Entry with applied variants should return v2 objects when tagsAsObject is true', done => {
            addTags(entry_with_applied_variants, 'entry_asset', true)
            
            // Field with direct variant match should get v2 prefix and variant suffix as object
            expect((entry_with_applied_variants as any)['$']['rich_text_editor']).toEqual({'data-cslp': 'v2:entry_asset.entry_uid_1_variant_1.en-us.rich_text_editor'})
            
            // Nested field with direct variant match
            expect((entry_with_applied_variants as any)['nested']['$']['field']).toEqual({'data-cslp': 'v2:entry_asset.entry_uid_1_variant_2.en-us.nested.field'})
            
            // Field without variant should not have v2 prefix
            expect((entry_with_applied_variants as any)['nested']['$']['other_field']).toEqual({'data-cslp': 'entry_asset.entry_uid_1.en-us.nested.other_field'})
            expect((entry_with_applied_variants as any)['$']['rich_text_editor_multiple']).toEqual({'data-cslp': 'entry_asset.entry_uid_1.en-us.rich_text_editor_multiple'})
            
            done()
        })

        it('Entry with parent path variants should find correct variant', done => {
            addTags(entry_with_parent_path_variants, 'entry_asset', false)

            // Group field should get parent variant
            expect((entry_with_parent_path_variants as any)['$']['group']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_parent_variant.en-us.group')
            // Field under 'group' parent should get parent variant
            expect((entry_with_parent_path_variants as any)['group']['$']['other']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_parent_variant.en-us.group.other')
            // Field under 'group.nested' should get parent variant (group is longer match)
            expect((entry_with_parent_path_variants as any)['group']['nested']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_parent_variant.en-us.group.nested.field')
            // Field with exact deep path match should get deep variant
            expect((entry_with_parent_path_variants as any)['group']['nested']['deep']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_deep_variant.en-us.group.nested.deep.field')
            
            // Field with the same starting path should not get parent variant
            expect((entry_with_parent_path_variants as any)['$']['group_multiple']).toEqual('data-cslp=entry_asset.entry_uid_3.en-us.group_multiple')

            // Modular block content with variant should get v2 prefix and variant suffix
            expect((entry_with_parent_path_variants as any)['modular_blocks'][0]['$']['content']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_parent_variant.en-us.modular_blocks.0.content')
            // Modular block field inside a variantised parent should get v2 prefix and variant suffix
            expect((entry_with_parent_path_variants as any)['modular_blocks'][0]['content']['$']['title']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_parent_variant.en-us.modular_blocks.0.content.title')

            // Modular block content without variant should not have v2 prefix and variant suffix
            expect((entry_with_parent_path_variants as any)['modular_blocks'][1]['$']['content']).toEqual('data-cslp=entry_asset.entry_uid_3.en-us.modular_blocks.1.content')
            // Modular block field inside a non variantised parent should not get v2 prefix and variant suffix
            expect((entry_with_parent_path_variants as any)['modular_blocks'][1]['content']['$']['title']).toEqual('data-cslp=entry_asset.entry_uid_3.en-us.modular_blocks.1.content.title')

            done()
        })

        it('Entry with modular block variants should apply variants correctly', done => {
            addTags(entry_with_applied_variants, 'entry_asset', false)

            // Modular block content with variant should get v2 prefix and variant suffix
            expect((entry_with_applied_variants as any)['modular_blocks'][1]['$']['content_from_variant']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_3.en-us.modular_blocks.1.content_from_variant')
            // Modular block field inside a variantised parent should get v2 prefix and variant suffix
            expect((entry_with_applied_variants as any)['modular_blocks'][1]['content_from_variant']['$']['title']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_3.en-us.modular_blocks.1.content_from_variant.title')
            // Field inside a variantised parent with a different variant should get v2 prefix and variant suffix of that variant
            expect((entry_with_applied_variants as any)['modular_blocks'][1]['content_from_variant']['$']['different_from_parent_variant']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_4.en-us.modular_blocks.1.content_from_variant.different_from_parent_variant')
            
            // Modular block content without variant should get v2 prefix and variant suffix
            expect((entry_with_applied_variants as any)['modular_blocks'][0]['$']['content']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.modular_blocks.0.content')
            // Modular block field without variant should not have v2 prefix and variant suffix
            expect((entry_with_applied_variants as any)['modular_blocks'][0]['content']['$']['title']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.modular_blocks.0.content.title')
            
            done()
        })

        it('Entry without applied variants should work normally', done => {
            addTags(entry_with_text, 'entry_asset', false)
            
            // Should not have v2 prefix when no variants are applied
            expect((entry_with_text as any)['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor')
            expect((entry_with_text as any)['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor_multiple')
            
            done()
        })

        it('Entry with empty applied variants should work normally', done => {
            const entryWithEmptyVariants = {
                ...entry_with_text,
                _applied_variants: {}
            }
            
            addTags(entryWithEmptyVariants, 'entry_asset', false)
            
            // Should not have v2 prefix when variants object is empty
            expect((entryWithEmptyVariants as any)['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor')
            expect((entryWithEmptyVariants as any)['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor_multiple')
            
            done()
        })

        it('Entry with array containing null values should skip null elements', done => {
            const entryWithNullInArray = {
                "locale": "en-us",
                "uid": "uid",
                "items": [
                    null,
                    { "title": "valid item" },
                    null
                ]
            }
            
            expect(() => addTags(entryWithNullInArray, 'content_type', false)).not.toThrow()
            expect((entryWithNullInArray as any)['items'][1]['$']['title']).toEqual('data-cslp=content_type.uid.en-us.items.1.title')
            
            done()
        })

        it('Entry with array containing undefined values should skip undefined elements', done => {
            const entryWithUndefinedInArray = {
                "locale": "en-us",
                "uid": "uid",
                "items": [
                    undefined,
                    { "title": "valid item" },
                    undefined
                ]
            }
            
            expect(() => addTags(entryWithUndefinedInArray, 'content_type', false)).not.toThrow()
            expect((entryWithUndefinedInArray as any)['items'][1]['$']['title']).toEqual('data-cslp=content_type.uid.en-us.items.1.title')
            
            done()
        })

        it('Entry with array containing mixed null and undefined values should skip both', done => {
            const entryWithMixedNullUndefined = {
                "locale": "en-us",
                "uid": "uid",
                "items": [
                    null,
                    undefined,
                    { "title": "valid item 1" },
                    null,
                    { "title": "valid item 2" },
                    undefined
                ]
            }
            
            expect(() => addTags(entryWithMixedNullUndefined, 'content_type', true)).not.toThrow()
            expect((entryWithMixedNullUndefined as any)['items'][2]['$']['title']).toEqual({'data-cslp': 'content_type.uid.en-us.items.2.title'})
            expect((entryWithMixedNullUndefined as any)['items'][4]['$']['title']).toEqual({'data-cslp': 'content_type.uid.en-us.items.4.title'})
            
            done()
        })

        it('Entry with _embedded_items containing null values should handle gracefully', done => {
            const entryWithEmbeddedNull: any = {
                "locale": "en-us",
                "uid": "uid",
                "blocks": [
                    {
                        "items": [
                            { "heading": "Item heading" }
                        ]
                    }
                ],
                "_embedded_items": {
                    "blocks.items.description": [null]
                }
            }
            
            expect(() => addTags(entryWithEmbeddedNull, 'content_type', false)).not.toThrow()
            expect((entryWithEmbeddedNull as any)['blocks'][0]['items'][0]['$']['heading']).toEqual('data-cslp=content_type.uid.en-us.blocks.0.items.0.heading')
            expect((entryWithEmbeddedNull as any)['_embedded_items']['blocks.items.description'][0]).toBeNull()
            
            done()
        })

        it('Entry with nested arrays containing nulls in complex structure should work', done => {
            const entryWithComplexNulls: any = {
                "locale": "en-us",
                "uid": "uid",
                "blocks": [
                    {
                        "hero": {
                            "title": "Hero title",
                            "items": [null, { "name": "Item name" }, undefined]
                        }
                    },
                    null,
                    {
                        "content": "Content text"
                    }
                ]
            }
            
            expect(() => addTags(entryWithComplexNulls, 'content_type', true)).not.toThrow()
            expect((entryWithComplexNulls as any)['blocks'][0]['hero']['$']['title']).toEqual({'data-cslp': 'content_type.uid.en-us.blocks.0.hero.title'})
            expect((entryWithComplexNulls as any)['blocks'][0]['hero']['items'][1]['$']['name']).toEqual({'data-cslp': 'content_type.uid.en-us.blocks.0.hero.items.1.name'})
            expect((entryWithComplexNulls as any)['blocks'][2]['$']['content']).toEqual({'data-cslp': 'content_type.uid.en-us.blocks.2.content'})
            
            done()
        })

        it('Variant path sorting should work correctly for nested paths', done => {
            const entryWithComplexVariants = {
                "_version": 10,
                "locale": "en-us",
                "uid": "entry_uid_test",
                "ACL": {},
                "_applied_variants": {
                    "a": "variant_a",
                    "a.b": "variant_ab", 
                    "a.b.c": "variant_abc",
                    "a.b.c.d": "variant_abcd"
                },
                "a": {
                    "b": {
                        "c": {
                            "d": {
                                "field": "deep field"
                            },
                            "field": "c field"
                        },
                        "field": "b field"
                    },
                    "field": "a field"
                }
            }
            
            addTags(entryWithComplexVariants, 'entry_asset', false)
            
            // Should use the longest matching path variant
            expect((entryWithComplexVariants as any)['a']['b']['c']['d']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_test_variant_abcd.en-us.a.b.c.d.field')
            expect((entryWithComplexVariants as any)['a']['b']['c']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_test_variant_abc.en-us.a.b.c.field')
            expect((entryWithComplexVariants as any)['a']['b']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_test_variant_ab.en-us.a.b.field')
            expect((entryWithComplexVariants as any)['a']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_test_variant_a.en-us.a.field')
            
            done()
        })

        it('Reference fields should not inherit parent variants when they have no applied_variants', done => {
            const entryWithReferenceAndVariants = {
                "title": "home",
                "url": "/data/all_test/first",
                "single_line": "ssd",
                "tags": ["hi"],
                "locale": "en-us",
                "uid": "blt827e0ad3608248be",
                "created_by": "bltf0d59057590e9b09",
                "updated_by": "bltf0d59057590e9b09",
                "created_at": "2025-08-25T09:43:49.935Z",
                "updated_at": "2025-10-09T11:45:19.967Z",
                "ACL": [] as any[],
                "_version": 40,
                "_in_progress": false,
                "json_rte": "<p>hisdassf</p>",
                "select": "1",
                "group": {
                    "single_line": ""
                },
                "non_single_line_textbox": "",
                "reference": [
                    {
                        "title": "base variant",
                        "single_line": "bases",
                        "tags": [] as any[],
                        "locale": "en-us",
                        "uid": "blt07a6c7258ddba844",
                        "created_by": "bltf0d59057590e9b09",
                        "updated_by": "bltf0d59057590e9b09",
                        "created_at": "2025-10-01T03:10:10.701Z",
                        "updated_at": "2025-10-09T11:44:44.981Z",
                        "_content_type_uid": "all_test_3",
                        "ACL": [] as any[],
                        "_version": 3,
                        "_in_progress": false,
                        "multi_line_reference": "hii\n"
                        // Note: This reference object has NO _applied_variants
                    }
                ],
                "taxonomies": [] as any[],
                "multi_line": "woek",
                "_applied_variants": {
                    "single_line": "csfff653e89df54e8c",
                    "tags": "csfff653e89df54e8c",
                    "multi_line": "csfff653e89df54e8c"
                }
            }
            
            addTags(entryWithReferenceAndVariants, 'all_test', false)
            
            // Parent entry fields with variants should get v2 prefix
            expect((entryWithReferenceAndVariants as any)['$']['single_line']).toEqual('data-cslp=v2:all_test.blt827e0ad3608248be_csfff653e89df54e8c.en-us.single_line')
            expect((entryWithReferenceAndVariants as any)['$']['tags']).toEqual('data-cslp=v2:all_test.blt827e0ad3608248be_csfff653e89df54e8c.en-us.tags')
            expect((entryWithReferenceAndVariants as any)['$']['multi_line']).toEqual('data-cslp=v2:all_test.blt827e0ad3608248be_csfff653e89df54e8c.en-us.multi_line')
            
            // Reference fields should NOT get v2 prefix since they have no _applied_variants
            expect((entryWithReferenceAndVariants as any)['reference'][0]['$']['title']).toEqual('data-cslp=all_test_3.blt07a6c7258ddba844.en-us.title')
            expect((entryWithReferenceAndVariants as any)['reference'][0]['$']['single_line']).toEqual('data-cslp=all_test_3.blt07a6c7258ddba844.en-us.single_line')
            expect((entryWithReferenceAndVariants as any)['reference'][0]['$']['tags']).toEqual('data-cslp=all_test_3.blt07a6c7258ddba844.en-us.tags')
            expect((entryWithReferenceAndVariants as any)['reference'][0]['$']['multi_line_reference']).toEqual('data-cslp=all_test_3.blt07a6c7258ddba844.en-us.multi_line_reference')
            
            done()
        })

        it('Reference fields with their own applied_variants should use their variants', done => {
            const entryWithReferenceHavingVariants = {
                "title": "home",
                "locale": "en-us",
                "uid": "blt827e0ad3608248be",
                "ACL": [] as any[],
                "_version": 40,
                "_in_progress": false,
                "single_line": "parent field",
                "reference": [
                    {
                        "title": "base variant",
                        "single_line": "reference field",
                        "locale": "en-us",
                        "uid": "blt07a6c7258ddba844",
                        "_content_type_uid": "all_test_3",
                        "ACL": [] as any[],
                        "_version": 3,
                        "_in_progress": false,
                        "_applied_variants": {
                            "single_line": "ref_variant_123"
                        }
                    }
                ],
                "_applied_variants": {
                    "single_line": "parent_variant_456"
                }
            }
            
            addTags(entryWithReferenceHavingVariants, 'all_test', false)
            
            // Parent entry field should get parent variant
            expect((entryWithReferenceHavingVariants as any)['$']['single_line']).toEqual('data-cslp=v2:all_test.blt827e0ad3608248be_parent_variant_456.en-us.single_line')
            
            // Reference field should get its own variant, not parent variant
            expect((entryWithReferenceHavingVariants as any)['reference'][0]['$']['title']).toEqual('data-cslp=all_test_3.blt07a6c7258ddba844.en-us.title')
            expect((entryWithReferenceHavingVariants as any)['reference'][0]['$']['single_line']).toEqual('data-cslp=v2:all_test_3.blt07a6c7258ddba844_ref_variant_123.en-us.single_line')
            
            done()
        })

        it('Reference fields should work correctly with tagsAsObject=true', done => {
            const entryWithReferenceAndVariants = {
                "title": "home",
                "single_line": "ssd",
                "locale": "en-us",
                "uid": "blt827e0ad3608248be",
                "ACL": [] as any[],
                "_version": 40,
                "_in_progress": false,
                "reference": [
                    {
                        "title": "base variant",
                        "single_line": "bases",
                        "locale": "en-us",
                        "uid": "blt07a6c7258ddba844",
                        "_content_type_uid": "all_test_3",
                        "ACL": [] as any[],
                        "_version": 3,
                        "_in_progress": false
                        // No _applied_variants
                    }
                ],
                "_applied_variants": {
                    "single_line": "csfff653e89df54e8c"
                }
            }
            
            addTags(entryWithReferenceAndVariants, 'all_test', true)
            
            // Parent entry field with variant should get v2 prefix as object
            expect((entryWithReferenceAndVariants as any)['$']['single_line']).toEqual({'data-cslp': 'v2:all_test.blt827e0ad3608248be_csfff653e89df54e8c.en-us.single_line'})
            
            // Reference fields should NOT get v2 prefix as objects
            expect((entryWithReferenceAndVariants as any)['reference'][0]['$']['title']).toEqual({'data-cslp': 'all_test_3.blt07a6c7258ddba844.en-us.title'})
            expect((entryWithReferenceAndVariants as any)['reference'][0]['$']['single_line']).toEqual({'data-cslp': 'all_test_3.blt07a6c7258ddba844.en-us.single_line'})
            
            done()
        })
    })

    describe('Null and undefined content handling (Issue #193)', () => {
        it('should not throw when entry has a null field value', done => {
            const entryWithNullField: any = {
                "uid": "entry_uid_null",
                "locale": "en-us",
                "title": "Valid title",
                "description": null
            }

            expect(() => addTags(entryWithNullField, 'content_type', false)).not.toThrow()
            expect((entryWithNullField as any)['$']['title']).toEqual('data-cslp=content_type.entry_uid_null.en-us.title')
            done()
        })

        it('should not throw when entry has an undefined field value', done => {
            const entryWithUndefinedField: any = {
                "uid": "entry_uid_undef",
                "locale": "en-us",
                "title": "Valid title",
                "description": undefined
            }

            expect(() => addTags(entryWithUndefinedField, 'content_type', false)).not.toThrow()
            expect((entryWithUndefinedField as any)['$']['title']).toEqual('data-cslp=content_type.entry_uid_undef.en-us.title')
            done()
        })

        it('should return empty tags for a null entry', done => {
            const nullEntry: any = null

            expect(() => addTags(nullEntry, 'content_type', false)).not.toThrow()
            done()
        })

        it('should return empty tags for an undefined entry', done => {
            const undefinedEntry: any = undefined

            expect(() => addTags(undefinedEntry, 'content_type', false)).not.toThrow()
            done()
        })

        it('should handle entry with multiple null field values', done => {
            const entryWithMultipleNulls: any = {
                "uid": "entry_uid_multi_null",
                "locale": "en-us",
                "title": "Valid title",
                "field_a": null,
                "field_b": null,
                "field_c": "valid"
            }

            expect(() => addTags(entryWithMultipleNulls, 'content_type', true)).not.toThrow()
            expect((entryWithMultipleNulls as any)['$']['title']).toEqual({'data-cslp': 'content_type.entry_uid_multi_null.en-us.title'})
            expect((entryWithMultipleNulls as any)['$']['field_c']).toEqual({'data-cslp': 'content_type.entry_uid_multi_null.en-us.field_c'})
            done()
        })

        it('should handle entry with nested null object', done => {
            const entryWithNestedNull: any = {
                "uid": "entry_uid_nested_null",
                "locale": "en-us",
                "title": "Valid title",
                "group": null
            }

            expect(() => addTags(entryWithNestedNull, 'content_type', false)).not.toThrow()
            expect((entryWithNestedNull as any)['$']['title']).toEqual('data-cslp=content_type.entry_uid_nested_null.en-us.title')
            done()
        })

        it('getTag with null content returns empty object (covers null guard)', done => {
            const appliedVariants = { _applied_variants: {}, shouldApplyVariant: false, metaKey: '' }
            const result = getTag(null as any, 'some.prefix', false, 'en-us', appliedVariants)
            expect(result).toEqual({})
            done()
        })

        it('getTag with undefined content returns empty object (covers null guard)', done => {
            const appliedVariants = { _applied_variants: {}, shouldApplyVariant: false, metaKey: '' }
            const result = getTag(undefined as any, 'some.prefix', true, 'en-us', appliedVariants)
            expect(result).toEqual({})
            done()
        })
    })

    describe('useLowerCaseLocale option', () => {
        it('should preserve locale casing when useLowerCaseLocale is false', done => {
            const entry = {
                "uid": "test_uid",
                "locale": "en-US",
                "title": "Test Entry"
            }
            
            addTags(entry, 'test_content_type', false, 'en-US', { useLowerCaseLocale: false })
            
            expect((entry as any)['$']['title']).toEqual('data-cslp=test_content_type.test_uid.en-US.title')
            done()
        })

        it('should lowercase locale when useLowerCaseLocale is explicitly true', done => {
            const entry = {
                "uid": "test_uid",
                "locale": "en-US",
                "title": "Test Entry"
            }
            
            addTags(entry, 'test_content_type', false, 'en-US', { useLowerCaseLocale: true })
            
            expect((entry as any)['$']['title']).toEqual('data-cslp=test_content_type.test_uid.en-us.title')
            done()
        })

        it('should lowercase locale by default when options is not provided', done => {
            const entry = {
                "uid": "test_uid",
                "locale": "en-US",
                "title": "Test Entry"
            }
            
            addTags(entry, 'test_content_type', false, 'en-US')
            
            expect((entry as any)['$']['title']).toEqual('data-cslp=test_content_type.test_uid.en-us.title')
            done()
        })
    })

    describe('Negative and corner cases', () => {
        it('addTags with empty entry object should not throw and should set $ with empty-like tags', done => {
            const emptyEntry = { uid: 'e1', locale: 'en-us' }
            expect(() => addTags(emptyEntry, 'ct', false)).not.toThrow()
            expect((emptyEntry as any).$).toBeDefined()
            expect(typeof (emptyEntry as any).$).toBe('object')
            done()
        })

        it('addTags with empty string contentTypeUid should normalize to lowercase', done => {
            const entry = { uid: 'u1', locale: 'en-us', title: 't' }
            addTags(entry, '', false)
            expect((entry as any)['$']['title']).toContain('.title')
            done()
        })

        it('addTags with options as undefined should not throw', done => {
            const entry = { uid: 'u1', locale: 'en-us', title: 't' }
            expect(() => addTags(entry, 'ct', false, 'en-us', undefined)).not.toThrow()
            expect((entry as any)['$']['title']).toBeDefined()
            done()
        })

        it('getTag with empty object content should return empty tags object', done => {
            const appliedVariants = { _applied_variants: {}, shouldApplyVariant: false, metaKey: '' }
            const result = getTag({}, 'prefix', false, 'en-us', appliedVariants)
            expect(result).toEqual({})
            done()
        })

        it('getTag with content that has only $ key should skip $ and return empty', done => {
            const appliedVariants = { _applied_variants: {}, shouldApplyVariant: false, metaKey: '' }
            const result = getTag({ $: 'ignored' }, 'prefix', false, 'en-us', appliedVariants)
            expect(result).toEqual({})
            done()
        })

        it('getTag with appliedVariants._applied_variants null should not throw (getParentVariantisedPath safety)', done => {
            const content = { field: 'value' }
            const appliedVariants = { _applied_variants: null as any, shouldApplyVariant: true, metaKey: 'field' }
            expect(() => getTag(content, 'prefix', false, 'en-us', appliedVariants)).not.toThrow()
            const result = getTag(content, 'prefix', false, 'en-us', appliedVariants)
            expect(result).toHaveProperty('field')
            done()
        })

        it('getTag with appliedVariants.metaKey empty and shouldApplyVariant true should still produce tags', done => {
            const content = { title: 'hello' }
            const appliedVariants = { _applied_variants: {}, shouldApplyVariant: true, metaKey: '' }
            const result = getTag(content, 'ct.uid.en-us', false, 'en-us', appliedVariants)
            expect(result).toHaveProperty('title')
            expect((result as any).title).toContain('title')
            done()
        })

        it('addTags with entry that has empty array field should not throw', done => {
            const entry: any = { uid: 'u1', locale: 'en-us', items: [] }
            expect(() => addTags(entry, 'ct', false)).not.toThrow()
            expect((entry as any)['$']['items']).toBeDefined()
            done()
        })

        it('addTags with entry that has nested null object value should not throw', done => {
            const entry: any = { uid: 'u1', locale: 'en-us', title: 't', nested: null }
            expect(() => addTags(entry, 'ct', true)).not.toThrow()
            expect((entry as any)['$']['title']).toEqual({ 'data-cslp': expect.stringContaining('title') })
            done()
        })
    })
})