tm1npm 2.0.0 → 2.1.0

package/src/tests/objectModelParity.test.ts

@@ -10,6 +10,10 @@ import { MDXView } from '../objects/MDXView';
 import { Hierarchy } from '../objects/Hierarchy';
 import { Element, ElementType } from '../objects/Element';
 import { ElementAttribute, ElementAttributeType } from '../objects/ElementAttribute';
+import { Chore } from '../objects/Chore';
+import { ChoreFrequency } from '../objects/ChoreFrequency';
+import { ChoreStartTime } from '../objects/ChoreStartTime';
+import { readObjectNameFromUrl } from '../utils/Utils';
 
 // ---------------------------------------------------------------------------
 // Bug 1 & 2 (Axis.ts): ViewAxisSelection.fromDict and ViewTitleSelection.fromDict
@@ -283,6 +287,139 @@ describe('NativeView.fromDict', () => {
     });
 });
 
+// ---------------------------------------------------------------------------
+// Issue #75: NativeView fromDict, remove methods, substituteTitle parity
+// ---------------------------------------------------------------------------
+
+describe('NativeView.fromDict — title validation (issue #75)', () => {
+    test("throws when title dict lacks both 'Selected' and 'Selected@odata.bind'", () => {
+        const dict = {
+            Name: 'V',
+            SuppressEmptyColumns: false,
+            SuppressEmptyRows: false,
+            FormatString: '0.#',
+            Titles: [
+                {
+                    'Subset@odata.bind': "Dimensions('Region')/Hierarchies('Region')/Subsets('All')"
+                }
+            ],
+            Columns: [],
+            Rows: []
+        };
+        expect(() => NativeView.fromDict(dict, 'Cube')).toThrow(
+            "View Title dict must contain 'Selected' or 'Selected@odata.bind' as key"
+        );
+    });
+});
+
+describe('NativeView.fromDict — cubeName from @odata.context (issue #75)', () => {
+    test('extracts cubeName from @odata.context when not provided', () => {
+        const dict = {
+            '@odata.context': "../$metadata#Cubes('SalesCube')/Views/$entity",
+            Name: 'V',
+            SuppressEmptyColumns: false,
+            SuppressEmptyRows: false,
+            FormatString: '0.#',
+            Titles: [],
+            Columns: [],
+            Rows: []
+        };
+        const view = NativeView.fromDict(dict);
+        expect(view.cube).toBe('SalesCube');
+    });
+
+    test('prefers explicit cubeName over @odata.context', () => {
+        const dict = {
+            '@odata.context': "../$metadata#Cubes('WrongCube')/Views/$entity",
+            Name: 'V',
+            SuppressEmptyColumns: false,
+            SuppressEmptyRows: false,
+            FormatString: '0.#',
+            Titles: [],
+            Columns: [],
+            Rows: []
+        };
+        const view = NativeView.fromDict(dict, 'CorrectCube');
+        expect(view.cube).toBe('CorrectCube');
+    });
+});
+
+describe('NativeView.removeColumn / removeRow / removeTitle — remove ALL matches (issue #75)', () => {
+    test('removeColumn removes all matching columns', () => {
+        const view = new NativeView('Cube', 'View');
+        view.addColumn(new ViewAxisSelection('Region', new AnonymousSubset('Region', 'Region', undefined, ['North'])));
+        view.addColumn(new ViewAxisSelection('Region', new AnonymousSubset('Region', 'Region', undefined, ['South'])));
+        view.addColumn(new ViewAxisSelection('Month', new AnonymousSubset('Month', 'Month', undefined, ['Jan'])));
+        view.removeColumn('Region');
+        expect(view.columns).toHaveLength(1);
+        expect(view.columns[0].dimensionName).toBe('Month');
+    });
+
+    test('removeRow removes all matching rows', () => {
+        const view = new NativeView('Cube', 'View');
+        view.addRow(new ViewAxisSelection('Region', new AnonymousSubset('Region', 'Region', undefined, ['North'])));
+        view.addRow(new ViewAxisSelection('Region', new AnonymousSubset('Region', 'Region', undefined, ['South'])));
+        view.addRow(new ViewAxisSelection('Month', new AnonymousSubset('Month', 'Month', undefined, ['Jan'])));
+        view.removeRow('Region');
+        expect(view.rows).toHaveLength(1);
+        expect(view.rows[0].dimensionName).toBe('Month');
+    });
+
+    test('removeTitle removes all matching titles', () => {
+        const view = new NativeView('Cube', 'View');
+        const sub = new AnonymousSubset('Region', 'Region', undefined, ['North']);
+        view.addTitle(new ViewTitleSelection('Region', sub, 'North'));
+        view.addTitle(new ViewTitleSelection('Region', sub, 'South'));
+        view.addTitle(new ViewTitleSelection('Month', new AnonymousSubset('Month', 'Month', undefined, ['Jan']), 'Jan'));
+        view.removeTitle('Region');
+        expect(view.titles).toHaveLength(1);
+        expect(view.titles[0].dimensionName).toBe('Month');
+    });
+
+    test('removeColumn is case and space insensitive', () => {
+        const view = new NativeView('Cube', 'View');
+        view.addColumn(new ViewAxisSelection('Region', new AnonymousSubset('Region', 'Region', undefined, ['North'])));
+        view.removeColumn(' region ');
+        expect(view.columns).toHaveLength(0);
+    });
+});
+
+describe('NativeView.substituteTitle — replaces subset and selected (issue #75)', () => {
+    test('replaces subset with AnonymousSubset(dim, dim, [element]) and updates selected', () => {
+        const view = new NativeView('Cube', 'View');
+        view.addTitle(new ViewTitleSelection(
+            'Region',
+            new AnonymousSubset('Region', 'Region', undefined, ['North', 'South']),
+            'North'
+        ));
+        view.substituteTitle('Region', 'South');
+        expect(view.titles[0].selected).toBe('South');
+        const newSubset = view.titles[0].subset as AnonymousSubset;
+        expect(newSubset).toBeInstanceOf(AnonymousSubset);
+        expect(newSubset.elements).toEqual(['South']);
+    });
+
+    test('new subset uses caller-provided dimension as both dimension and hierarchy', () => {
+        const view = new NativeView('Cube', 'View');
+        view.addTitle(new ViewTitleSelection(
+            'Region',
+            new AnonymousSubset('Region', 'AltHierarchy', undefined, ['North']),
+            'North'
+        ));
+        view.substituteTitle('Region', 'South');
+        const newSubset = view.titles[0].subset as AnonymousSubset;
+        expect(newSubset.dimensionName).toBe('Region');
+        expect(newSubset.hierarchyName).toBe('Region');
+    });
+
+    test("throws \"Dimension '...' not found in titles\" when dimension missing", () => {
+        const view = new NativeView('Cube', 'View');
+        expect(() => view.substituteTitle('NonExistent', 'Value')).toThrow(
+            "Dimension 'NonExistent' not found in titles"
+        );
+    });
+});
+
 // ---------------------------------------------------------------------------
 // Bug 4 & 5 (Hierarchy.ts): Edge key type + traversal methods
 // ---------------------------------------------------------------------------
@@ -501,31 +638,93 @@ describe('MDXView.dynamicProperties', () => {
         expect(view.dynamicProperties).toEqual(props);
     });
 
-    test('fromDict parses Properties key', () => {
+    test('fromDict treats top-level non-excluded keys as dynamicProperties', () => {
         const dict = {
+            Cube: { Name: 'C' },
             Name: 'V',
             MDX: 'SELECT ...',
-            Properties: { Aliases: ['Default'] }
+            Aliases: ['Default'],
+            Meta: { foo: 1 },
         };
-        const view = MDXView.fromDict(dict, 'Cube');
-        expect(view.dynamicProperties).toEqual({ Aliases: ['Default'] });
+        const view = MDXView.fromDict(dict);
+        expect(view.dynamicProperties).toEqual({ Aliases: ['Default'], Meta: { foo: 1 } });
     });
 
-    test('fromDict handles missing Properties gracefully', () => {
-        const view = MDXView.fromDict({ Name: 'V', MDX: 'SELECT ...' }, 'Cube');
+    test('fromDict yields empty dynamicProperties when only excluded keys present', () => {
+        const dict = { Cube: { Name: 'C' }, Name: 'V', MDX: 'SELECT ...' };
+        const view = MDXView.fromDict(dict);
         expect(view.dynamicProperties).toEqual({});
     });
 
-    test('body includes Properties when dynamicProperties is non-empty', () => {
-        const view = new MDXView('Cube', 'View', 'SELECT ...', { ContextSets: [] });
+    test('fromDict prefers explicit cubeName over dict.Cube.Name', () => {
+        const dict = { Cube: { Name: 'FromDict' }, Name: 'V', MDX: 'SELECT ...' };
+        const view = MDXView.fromDict(dict, 'Explicit');
+        expect(view.cube).toBe('Explicit');
+    });
+
+    test('fromDict falls back to dict.Cube.Name when cubeName is not provided', () => {
+        const dict = { Cube: { Name: 'FromDict' }, Name: 'V', MDX: 'SELECT ...' };
+        const view = MDXView.fromDict(dict);
+        expect(view.cube).toBe('FromDict');
+    });
+
+    test('fromDict throws when no cubeName and no Cube field', () => {
+        const dict = { Name: 'V', MDX: 'SELECT ...' };
+        expect(() => MDXView.fromDict(dict)).toThrow();
+    });
+
+    test('fromDict preserves a top-level Properties key as dynamicProperties.Properties', () => {
+        const dict = {
+            Cube: { Name: 'C' },
+            Name: 'V',
+            MDX: 'SELECT ...',
+            Properties: { Aliases: ['Default'] },
+        };
+        const view = MDXView.fromDict(dict);
+        expect(view.dynamicProperties).toEqual({ Properties: { Aliases: ['Default'] } });
+    });
+
+    test.each([
+        '@odata.type',
+        '@odata.context',
+        '@odata.etag',
+        'Name',
+        'MDX',
+        'Cube',
+        'Attributes',
+        'LocalizedAttributes',
+    ])('fromDict filters excluded key %s', (excludedKey) => {
+        const dict: Record<string, any> = {
+            Cube: { Name: 'C' },
+            Name: 'V',
+            MDX: 'SELECT ...',
+            Foo: 1,
+        };
+        dict[excludedKey] = 'should-be-stripped';
+        const view = MDXView.fromDict(dict, 'Cube');
+        expect(view.dynamicProperties).not.toHaveProperty(excludedKey);
+        expect(view.dynamicProperties).toEqual({ Foo: 1 });
+    });
+
+    test('body merges dynamicProperties as top-level keys', () => {
+        const view = new MDXView('Cube', 'View', 'SELECT ...', { ContextSets: [], Meta: 1 });
+        const body = JSON.parse(view.body);
+        expect(body.ContextSets).toEqual([]);
+        expect(body.Meta).toBe(1);
+        expect(body.Properties).toBeUndefined();
+    });
+
+    test('body strips excluded keys from dynamicProperties before serializing', () => {
+        const view = new MDXView('Cube', 'View', 'SELECT ...', { Name: 'IgnoreMe', Foo: 'bar' });
         const body = JSON.parse(view.body);
-        expect(body.Properties).toEqual({ ContextSets: [] });
+        expect(body.Name).toBe('View');
+        expect(body.Foo).toBe('bar');
     });
 
-    test('body omits Properties when dynamicProperties is empty', () => {
+    test('body omits dynamicProperties keys when empty', () => {
         const view = new MDXView('Cube', 'View', 'SELECT ...');
         const body = JSON.parse(view.body);
-        expect(body).not.toHaveProperty('Properties');
+        expect(Object.keys(body).sort()).toEqual(['@odata.type', 'MDX', 'Name'].sort());
     });
 
     test('dynamicProperties round-trips through body and fromDict', () => {
@@ -572,3 +771,249 @@ describe('ElementAttribute.equals', () => {
         expect(a.equals(b)).toBe(false);
     });
 });
+
+describe('ChoreStartTime.add (Issue #73)', () => {
+    const buildStartTime = () =>
+        new ChoreStartTime(2020, 1, 1, 0, 0, 0);
+
+    test('adds positive days hours minutes seconds to start time', () => {
+        const st = buildStartTime();
+        st.add(1, 2, 3, 4);
+        expect(st.datetime.getFullYear()).toBe(2020);
+        expect(st.datetime.getMonth()).toBe(0);
+        expect(st.datetime.getDate()).toBe(2);
+        expect(st.datetime.getHours()).toBe(2);
+        expect(st.datetime.getMinutes()).toBe(3);
+        expect(st.datetime.getSeconds()).toBe(4);
+    });
+
+    test('default arguments are all zero (no mutation)', () => {
+        const st = buildStartTime();
+        const originalMs = st.datetime.getTime();
+        st.add();
+        expect(st.datetime.getTime()).toBe(originalMs);
+    });
+
+    test('negative values subtract time', () => {
+        const st = new ChoreStartTime(2020, 1, 2, 0, 0, 0);
+        st.add(-1, 0, 0, 0);
+        expect(st.datetime.getFullYear()).toBe(2020);
+        expect(st.datetime.getMonth()).toBe(0);
+        expect(st.datetime.getDate()).toBe(1);
+    });
+
+    test('hours overflow into days (parity with Python timedelta normalization)', () => {
+        const st = buildStartTime();
+        st.add(0, 25, 0, 0);
+        expect(st.datetime.getDate()).toBe(2);
+        expect(st.datetime.getHours()).toBe(1);
+    });
+
+    test('seconds overflow into minutes', () => {
+        const st = buildStartTime();
+        st.add(0, 0, 0, 75);
+        expect(st.datetime.getMinutes()).toBe(1);
+        expect(st.datetime.getSeconds()).toBe(15);
+    });
+});
+
+describe('Chore.reschedule (Issue #73)', () => {
+    const buildChore = () =>
+        new Chore(
+            'TestChore',
+            new ChoreStartTime(2020, 1, 1, 0, 0, 0),
+            false,
+            true,
+            Chore.SINGLE_COMMIT,
+            new ChoreFrequency(0, 0, 0, 0),
+            []
+        );
+
+    test('reschedule(days, hours, minutes, seconds) mutates start time and leaves frequency unchanged', () => {
+        const chore = buildChore();
+        const originalFrequency = chore.frequency;
+        chore.reschedule(1, 2, 3, 4);
+        expect(chore.startTime.datetime.getDate()).toBe(2);
+        expect(chore.startTime.datetime.getHours()).toBe(2);
+        expect(chore.startTime.datetime.getMinutes()).toBe(3);
+        expect(chore.startTime.datetime.getSeconds()).toBe(4);
+        expect(chore.frequency).toBe(originalFrequency);
+    });
+
+    test('reschedule defaults all components to 0 (no-op)', () => {
+        const chore = buildChore();
+        const originalMs = chore.startTime.datetime.getTime();
+        chore.reschedule();
+        expect(chore.startTime.datetime.getTime()).toBe(originalMs);
+    });
+
+    test('reschedule with negative values subtracts from start time', () => {
+        const chore = new Chore(
+            'TestChore',
+            new ChoreStartTime(2020, 1, 2, 0, 0, 0),
+            false,
+            true,
+            Chore.SINGLE_COMMIT,
+            new ChoreFrequency(0, 0, 0, 0),
+            []
+        );
+        chore.reschedule(-1, 0, 0, 0);
+        expect(chore.startTime.datetime.getDate()).toBe(1);
+    });
+});
+
+describe('Chore.setFrequency (tm1npm-only helper, Issue #73)', () => {
+    const buildChore = () =>
+        new Chore(
+            'TestChore',
+            new ChoreStartTime(2020, 1, 1, 0, 0, 0),
+            false,
+            true,
+            Chore.SINGLE_COMMIT,
+            new ChoreFrequency(1, 2, 3, 4),
+            []
+        );
+
+    test('replaces frequency without changing start time when startTime omitted', () => {
+        const chore = buildChore();
+        const originalStartMs = chore.startTime.datetime.getTime();
+        const newFreq = new ChoreFrequency(5, 6, 7, 8);
+        chore.setFrequency(newFreq);
+        expect(chore.frequency).toBe(newFreq);
+        expect(chore.startTime.datetime.getTime()).toBe(originalStartMs);
+    });
+
+    test('replaces both frequency and start time when startTime provided', () => {
+        const chore = buildChore();
+        const newFreq = new ChoreFrequency(5, 6, 7, 8);
+        const newStart = new ChoreStartTime(2025, 6, 15, 12, 0, 0);
+        chore.setFrequency(newFreq, newStart);
+        expect(chore.frequency).toBe(newFreq);
+        expect(chore.startTime).toBe(newStart);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Issue #70 (Subset.ts): AnonymousSubset.fromDict URL parsing
+//
+// These tests lock in tm1py's literal behavior — INCLUDING the latent bug
+// where read_object_name_from_url always returns match.group(1), causing both
+// segments to resolve to the dimension name. Do NOT "fix" these tests to
+// reflect more "correct" behavior — see CLAUDE.md "Strict tm1py Parity".
+// ---------------------------------------------------------------------------
+
+describe('AnonymousSubset.fromDict — Hierarchy@odata.bind parsing (#70)', () => {
+    test('parses dimension and hierarchy when names match', () => {
+        const sub = AnonymousSubset.fromDict({
+            'Hierarchy@odata.bind': "Dimensions('Region')/Hierarchies('Region')",
+            Elements: [{ Name: 'North' }]
+        });
+        expect(sub.dimensionName).toBe('Region');
+        expect(sub.hierarchyName).toBe('Region');
+    });
+
+    test('non-default hierarchy resolves to dimension name (tm1py bug parity)', () => {
+        // tm1py's read_object_name_from_url returns match.group(1) twice, both
+        // capturing the dimension. Hierarchy name in the URL is silently lost.
+        const sub = AnonymousSubset.fromDict({
+            'Hierarchy@odata.bind': "Dimensions('Region')/Hierarchies('Region_Alt')",
+            Expression: '{[Region].[Region_Alt].Members}'
+        });
+        expect(sub.dimensionName).toBe('Region');
+        expect(sub.hierarchyName).toBe('Region');
+    });
+
+    test('parses Hierarchy entity form correctly', () => {
+        const sub = AnonymousSubset.fromDict({
+            Hierarchy: { Name: 'Region_Alt', Dimension: { Name: 'Region' } },
+            Elements: [{ Name: 'North' }]
+        });
+        expect(sub.dimensionName).toBe('Region');
+        expect(sub.hierarchyName).toBe('Region_Alt');
+    });
+
+    test('throws for URL missing Hierarchies segment', () => {
+        expect(() => AnonymousSubset.fromDict({
+            'Hierarchy@odata.bind': "Dimensions('Region')"
+        })).toThrow(/Unexpected value for 'Hierarchy@odata.bind'/);
+    });
+
+    test('throws for non-Dimensions/Hierarchies URL shape (tm1py shape validation)', () => {
+        // tm1py's regex anchors on Dimensions(...)/Hierarchies(...) — other shapes fail.
+        expect(() => AnonymousSubset.fromDict({
+            'Hierarchy@odata.bind': "Foo('A')/Bar('B')"
+        })).toThrow(/Unexpected value for 'Hierarchy@odata.bind'/);
+    });
+
+    test('throws when neither Hierarchy nor Hierarchy@odata.bind present', () => {
+        expect(() => AnonymousSubset.fromDict({})).toThrow(/must contain 'Hierarchy'/);
+    });
+
+    test('round-trip: alt hierarchy in URL is dropped via tm1py-equivalent parsing', () => {
+        // Input has Hierarchies('Region_Alt') but tm1py's parsing collapses both
+        // to the dimension name, so bodyAsDict reflects Hierarchies('Region').
+        const sub = AnonymousSubset.fromDict({
+            'Hierarchy@odata.bind': "Dimensions('Region')/Hierarchies('Region_Alt')",
+            Elements: [{ Name: 'North' }]
+        });
+        const body = sub.bodyAsDict;
+        expect(body['Hierarchy@odata.bind']).toBe(
+            "Dimensions('Region')/Hierarchies('Region')"
+        );
+    });
+});
+
+describe('ViewAxisSelection.fromDict — anonymous subset with non-default hierarchy (#70)', () => {
+    test('hierarchy in URL collapses to dimension name (tm1py bug parity)', () => {
+        const dict = {
+            Subset: {
+                'Hierarchy@odata.bind': "Dimensions('Region')/Hierarchies('Region_Alt')",
+                Elements: [{ Name: 'North' }]
+            }
+        };
+        const sel = ViewAxisSelection.fromDict(dict);
+        expect(sel.dimensionName).toBe('Region');
+        const anon = sel.subset as AnonymousSubset;
+        expect(anon.dimensionName).toBe('Region');
+        expect(anon.hierarchyName).toBe('Region');
+    });
+});
+
+describe('readObjectNameFromUrl — tm1py parity (#70)', () => {
+    test('with pattern: URL-decodes percent-encoded names (mirrors urllib.parse.unquote)', () => {
+        const result = readObjectNameFromUrl(
+            "Dimensions('My%20Dim')/Hierarchies('H')",
+            /^Dimensions\('(.+?)'\)/
+        );
+        expect(result).toBe('My Dim');
+    });
+
+    test('with pattern: passes through malformed %XX (urllib.unquote permissive parity)', () => {
+        // Python: urllib.parse.unquote('Bad%ZZName') === 'Bad%ZZName'
+        // JS decodeURIComponent throws on malformed %XX — we catch and pass through.
+        const result = readObjectNameFromUrl(
+            "Dimensions('Bad%ZZName')/Hierarchies('H')",
+            /^Dimensions\('(.+?)'\)/
+        );
+        expect(result).toBe('Bad%ZZName');
+    });
+
+    test('with pattern: returns null on no match (mirrors re.match returning None)', () => {
+        const result = readObjectNameFromUrl(
+            "Foo('A')/Bar('B')",
+            /^Dimensions\('(.+?)'\)/
+        );
+        expect(result).toBeNull();
+    });
+
+    test('without pattern: preserves existing string return type (no API break)', () => {
+        // Type-level guarantee via overload — runtime check that result is still a string.
+        const result: string = readObjectNameFromUrl("Dimensions('Region')");
+        expect(result).toBe('Region');
+    });
+
+    test('without pattern: returns empty string on no match (backward compat)', () => {
+        const result: string = readObjectNameFromUrl('');
+        expect(result).toBe('');
+    });
+});

package/src/tests/objects.improved.test.ts

@@ -95,7 +95,7 @@ describe('Object Model - Improved Coverage', () => {
             const hierarchy = new Hierarchy('TestHierarchy', 'TestDimension', elements);
             
             expect(hierarchy.elements).toHaveLength(2);
-            expect(hierarchy.elementNames).toEqual(['element1', 'element2']);
+            expect(hierarchy.elementNames).toEqual(['Element1', 'Element2']);
         });
 
         test('should get hierarchy body', () => {
@@ -248,11 +248,31 @@ describe('Object Model - Improved Coverage', () => {
     describe('Process Object', () => {
         test('should create basic process', () => {
             const process = new Process('TestProcess');
-            
+
             expect(process.name).toBe('TestProcess');
             expect(process.hasSecurityAccess).toBe(false);
             // Process automatically adds generated statements to procedures
         });
+
+        test('replaces ALL € with \\f in variablesUiData entries (parity with Python str.replace)', () => {
+            // tm1py: each entry passes through entry.replace("€", "\f"), which is
+            // replace-all in Python. JS String.replace(stringPattern, ...) replaces
+            // only the first occurrence — must use a global regex for parity.
+            const entry = 'A€B€C€D';
+            const process = new Process(
+                'TestProcess',
+                false,
+                '',
+                [],
+                [],
+                [entry, 'no-euro-here', '€€€']
+            );
+            expect(process.variablesUiData).toEqual([
+                'A\fB\fC\fD',
+                'no-euro-here',
+                '\f\f\f',
+            ]);
+        });
     });
 
     describe('Cube Object', () => {
@@ -269,9 +289,21 @@ describe('Object Model - Improved Coverage', () => {
             const dimensions = ['Time', 'Account'];
             const cube = new Cube('TestCube', dimensions);
             const body = JSON.parse(cube.body);
-            
+
             expect(body.Name).toBe('TestCube');
-            expect(body.Dimensions).toHaveLength(2);
+            expect(body['Dimensions@odata.bind']).toHaveLength(2);
+            expect(body['Dimensions@odata.bind'][0]).toBe("Dimensions('Time')");
+            expect(body['Dimensions@odata.bind'][1]).toBe("Dimensions('Account')");
+        });
+
+        test('should escape special characters in dimension names (parity with tm1py format_url)', () => {
+            const cube = new Cube('TestCube', ["O'Brien", '50%', 'A#B', 'X?Y', 'M&N']);
+            const body = JSON.parse(cube.body);
+            expect(body['Dimensions@odata.bind'][0]).toBe("Dimensions('O''Brien')");
+            expect(body['Dimensions@odata.bind'][1]).toBe("Dimensions('50%25')");
+            expect(body['Dimensions@odata.bind'][2]).toBe("Dimensions('A%23B')");
+            expect(body['Dimensions@odata.bind'][3]).toBe("Dimensions('X%3FY')");
+            expect(body['Dimensions@odata.bind'][4]).toBe("Dimensions('M%26N')");
         });
 
         test('should create cube from dictionary', () => {
@@ -316,7 +348,7 @@ describe('Object Model - Improved Coverage', () => {
             const user = new User('TestUser', []);
             user.addGroup('NewGroup');
             
-            expect(user.groups).toContain('newgroup'); // lowercase due to CaseAndSpaceInsensitiveSet
+            expect(user.groups).toContain('NewGroup');
         });
     });
 
@@ -370,15 +402,15 @@ describe('Object Model - Improved Coverage', () => {
             
             // Add to basic group
             user.addGroup('Everyone');
-            expect(user.groups).toContain('everyone'); // lowercase
-            
+            expect(user.groups).toContain('Everyone');
+
             // Promote to power user
             user.addGroup('PowerUser');
             expect(user.groups.length).toBeGreaterThan(1);
-            
+
             // Remove from basic group
             user.removeGroup('Everyone');
-            expect(user.groups).toContain('poweruser'); // remaining group
+            expect(user.groups).toContain('PowerUser');
         });
     });
 });