tm1npm 2.0.0 → 2.1.0

package/lib/tests/objectModelParity.test.js

@@ -11,6 +11,10 @@ const MDXView_1 = require("../objects/MDXView");
 const Hierarchy_1 = require("../objects/Hierarchy");
 const Element_1 = require("../objects/Element");
 const ElementAttribute_1 = require("../objects/ElementAttribute");
+const Chore_1 = require("../objects/Chore");
+const ChoreFrequency_1 = require("../objects/ChoreFrequency");
+const ChoreStartTime_1 = require("../objects/ChoreStartTime");
+const Utils_1 = require("../utils/Utils");
 // ---------------------------------------------------------------------------
 // Bug 1 & 2 (Axis.ts): ViewAxisSelection.fromDict and ViewTitleSelection.fromDict
 // ---------------------------------------------------------------------------
@@ -257,6 +261,116 @@ 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_1.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_1.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_1.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_1.NativeView('Cube', 'View');
+        view.addColumn(new Axis_1.ViewAxisSelection('Region', new Subset_1.AnonymousSubset('Region', 'Region', undefined, ['North'])));
+        view.addColumn(new Axis_1.ViewAxisSelection('Region', new Subset_1.AnonymousSubset('Region', 'Region', undefined, ['South'])));
+        view.addColumn(new Axis_1.ViewAxisSelection('Month', new Subset_1.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_1.NativeView('Cube', 'View');
+        view.addRow(new Axis_1.ViewAxisSelection('Region', new Subset_1.AnonymousSubset('Region', 'Region', undefined, ['North'])));
+        view.addRow(new Axis_1.ViewAxisSelection('Region', new Subset_1.AnonymousSubset('Region', 'Region', undefined, ['South'])));
+        view.addRow(new Axis_1.ViewAxisSelection('Month', new Subset_1.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_1.NativeView('Cube', 'View');
+        const sub = new Subset_1.AnonymousSubset('Region', 'Region', undefined, ['North']);
+        view.addTitle(new Axis_1.ViewTitleSelection('Region', sub, 'North'));
+        view.addTitle(new Axis_1.ViewTitleSelection('Region', sub, 'South'));
+        view.addTitle(new Axis_1.ViewTitleSelection('Month', new Subset_1.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_1.NativeView('Cube', 'View');
+        view.addColumn(new Axis_1.ViewAxisSelection('Region', new Subset_1.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_1.NativeView('Cube', 'View');
+        view.addTitle(new Axis_1.ViewTitleSelection('Region', new Subset_1.AnonymousSubset('Region', 'Region', undefined, ['North', 'South']), 'North'));
+        view.substituteTitle('Region', 'South');
+        expect(view.titles[0].selected).toBe('South');
+        const newSubset = view.titles[0].subset;
+        expect(newSubset).toBeInstanceOf(Subset_1.AnonymousSubset);
+        expect(newSubset.elements).toEqual(['South']);
+    });
+    test('new subset uses caller-provided dimension as both dimension and hierarchy', () => {
+        const view = new NativeView_1.NativeView('Cube', 'View');
+        view.addTitle(new Axis_1.ViewTitleSelection('Region', new Subset_1.AnonymousSubset('Region', 'AltHierarchy', undefined, ['North']), 'North'));
+        view.substituteTitle('Region', 'South');
+        const newSubset = view.titles[0].subset;
+        expect(newSubset.dimensionName).toBe('Region');
+        expect(newSubset.hierarchyName).toBe('Region');
+    });
+    test("throws \"Dimension '...' not found in titles\" when dimension missing", () => {
+        const view = new NativeView_1.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
 // ---------------------------------------------------------------------------
 describe('Hierarchy edges (Map<string, Map<string, number>>)', () => {
@@ -447,28 +561,84 @@ describe('MDXView.dynamicProperties', () => {
         const view = new MDXView_1.MDXView('Cube', 'View', 'SELECT ...', props);
         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_1.MDXView.fromDict(dict, 'Cube');
-        expect(view.dynamicProperties).toEqual({ Aliases: ['Default'] });
+        const view = MDXView_1.MDXView.fromDict(dict);
+        expect(view.dynamicProperties).toEqual({ Aliases: ['Default'], Meta: { foo: 1 } });
     });
-    test('fromDict handles missing Properties gracefully', () => {
-        const view = MDXView_1.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_1.MDXView.fromDict(dict);
         expect(view.dynamicProperties).toEqual({});
     });
-    test('body includes Properties when dynamicProperties is non-empty', () => {
-        const view = new MDXView_1.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_1.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_1.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_1.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_1.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 = {
+            Cube: { Name: 'C' },
+            Name: 'V',
+            MDX: 'SELECT ...',
+            Foo: 1,
+        };
+        dict[excludedKey] = 'should-be-stripped';
+        const view = MDXView_1.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_1.MDXView('Cube', 'View', 'SELECT ...', { ContextSets: [], Meta: 1 });
         const body = JSON.parse(view.body);
-        expect(body.Properties).toEqual({ ContextSets: [] });
+        expect(body.ContextSets).toEqual([]);
+        expect(body.Meta).toBe(1);
+        expect(body.Properties).toBeUndefined();
     });
-    test('body omits Properties when dynamicProperties is empty', () => {
+    test('body strips excluded keys from dynamicProperties before serializing', () => {
+        const view = new MDXView_1.MDXView('Cube', 'View', 'SELECT ...', { Name: 'IgnoreMe', Foo: 'bar' });
+        const body = JSON.parse(view.body);
+        expect(body.Name).toBe('View');
+        expect(body.Foo).toBe('bar');
+    });
+    test('body omits dynamicProperties keys when empty', () => {
         const view = new MDXView_1.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', () => {
         const props = { Meta: true, Aliases: ['Default'] };
@@ -508,4 +678,185 @@ describe('ElementAttribute.equals', () => {
         expect(a.equals(b)).toBe(false);
     });
 });
+describe('ChoreStartTime.add (Issue #73)', () => {
+    const buildStartTime = () => new ChoreStartTime_1.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_1.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_1.Chore('TestChore', new ChoreStartTime_1.ChoreStartTime(2020, 1, 1, 0, 0, 0), false, true, Chore_1.Chore.SINGLE_COMMIT, new ChoreFrequency_1.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_1.Chore('TestChore', new ChoreStartTime_1.ChoreStartTime(2020, 1, 2, 0, 0, 0), false, true, Chore_1.Chore.SINGLE_COMMIT, new ChoreFrequency_1.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_1.Chore('TestChore', new ChoreStartTime_1.ChoreStartTime(2020, 1, 1, 0, 0, 0), false, true, Chore_1.Chore.SINGLE_COMMIT, new ChoreFrequency_1.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_1.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_1.ChoreFrequency(5, 6, 7, 8);
+        const newStart = new ChoreStartTime_1.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 = Subset_1.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 = Subset_1.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 = Subset_1.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(() => Subset_1.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(() => Subset_1.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(() => Subset_1.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 = Subset_1.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 = Axis_1.ViewAxisSelection.fromDict(dict);
+        expect(sel.dimensionName).toBe('Region');
+        const anon = sel.subset;
+        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 = (0, Utils_1.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 = (0, Utils_1.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 = (0, Utils_1.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 = (0, Utils_1.readObjectNameFromUrl)("Dimensions('Region')");
+        expect(result).toBe('Region');
+    });
+    test('without pattern: returns empty string on no match (backward compat)', () => {
+        const result = (0, Utils_1.readObjectNameFromUrl)('');
+        expect(result).toBe('');
+    });
+});
 //# sourceMappingURL=objectModelParity.test.js.map

package/lib/tests/objects.improved.test.js

@@ -76,7 +76,7 @@ describe('Object Model - Improved Coverage', () => {
             const elements = [element1, element2];
             const hierarchy = new Hierarchy_1.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', () => {
             const hierarchy = new Hierarchy_1.Hierarchy('TestHierarchy', 'TestDimension', []);
@@ -198,6 +198,18 @@ describe('Object Model - Improved Coverage', () => {
             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_1.Process('TestProcess', false, '', [], [], [entry, 'no-euro-here', '€€€']);
+            expect(process.variablesUiData).toEqual([
+                'A\fB\fC\fD',
+                'no-euro-here',
+                '\f\f\f',
+            ]);
+        });
     });
     describe('Cube Object', () => {
         test('should create basic cube', () => {
@@ -212,7 +224,18 @@ describe('Object Model - Improved Coverage', () => {
             const cube = new Cube_1.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_1.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', () => {
             const cubeDict = {
@@ -246,7 +269,7 @@ describe('Object Model - Improved Coverage', () => {
         test('should add user to group', () => {
             const user = new User_1.User('TestUser', []);
             user.addGroup('NewGroup');
-            expect(user.groups).toContain('newgroup'); // lowercase due to CaseAndSpaceInsensitiveSet
+            expect(user.groups).toContain('NewGroup');
         });
     });
     describe('View Object', () => {
@@ -289,13 +312,13 @@ describe('Object Model - Improved Coverage', () => {
             const user = new User_1.User('BusinessUser', []);
             // 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');
         });
     });
 });

package/lib/tests/user.issue61.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=user.issue61.test.d.ts.map

package/lib/tests/user.issue61.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.issue61.test.d.ts","sourceRoot":"","sources":["../../src/tests/user.issue61.test.ts"],"names":[],"mappings":""}