tm1npm 2.0.0 → 2.1.0

package/src/tests/user.issue61.test.ts

@@ -0,0 +1,206 @@
+import { User, UserType } from '../objects/User';
+import { CaseAndSpaceInsensitiveSet } from '../utils/Utils';
+
+describe('UserType — string enum (issue #61)', () => {
+    test('should produce correct string names from toString()', () => {
+        expect(UserType.User.toString()).toBe('User');
+        expect(UserType.SecurityAdmin.toString()).toBe('SecurityAdmin');
+        expect(UserType.DataAdmin.toString()).toBe('DataAdmin');
+        expect(UserType.Admin.toString()).toBe('Admin');
+        expect(UserType.OperationsAdmin.toString()).toBe('OperationsAdmin');
+    });
+
+    test('should serialize Type field as string name in body', () => {
+        const user = new User('Alice', [], undefined, undefined, UserType.Admin);
+        const body = JSON.parse(user.body);
+        expect(body.Type).toBe('Admin');
+    });
+
+    test('should serialize User type as "User" string in body', () => {
+        const user = new User('Alice', []);
+        const body = JSON.parse(user.body);
+        expect(body.Type).toBe('User');
+    });
+
+    test('should parse string value in userType setter', () => {
+        const user = new User('Alice', []);
+        user.userType = 'Admin';
+        expect(user.userType).toBe(UserType.Admin);
+    });
+
+    test('should parse case-insensitive string in userType setter', () => {
+        const user = new User('Alice', []);
+        user.userType = 'admin';
+        expect(user.userType).toBe(UserType.Admin);
+    });
+
+    test('should throw on invalid userType string', () => {
+        const user = new User('Alice', []);
+        expect(() => { user.userType = 'InvalidType'; }).toThrow();
+    });
+});
+
+describe('User — group auto-detection (issue #61)', () => {
+    test('should detect Admin type from groups', () => {
+        const user = new User('Alice', ['Admin']);
+        expect(user.userType).toBe(UserType.Admin);
+    });
+
+    test('should detect SecurityAdmin type from groups', () => {
+        const user = new User('Alice', ['SecurityAdmin']);
+        expect(user.userType).toBe(UserType.SecurityAdmin);
+    });
+
+    test('should detect DataAdmin type from groups', () => {
+        const user = new User('Alice', ['DataAdmin']);
+        expect(user.userType).toBe(UserType.DataAdmin);
+    });
+
+    test('should detect OperationsAdmin type from groups', () => {
+        const user = new User('Alice', ['OperationsAdmin']);
+        expect(user.userType).toBe(UserType.OperationsAdmin);
+    });
+
+    test('should default to User type when no special groups present', () => {
+        const user = new User('Alice', ['Everyone', 'SomeTeam']);
+        expect(user.userType).toBe(UserType.User);
+    });
+
+    test('should add correct string group when userType set to Admin', () => {
+        const user = new User('Alice', []);
+        user.userType = UserType.Admin;
+        expect(user.groups).toContain('Admin');
+    });
+
+    test('should not add a group when userType set to User', () => {
+        const user = new User('Alice', []);
+        user.userType = UserType.User;
+        expect(user.groups).toHaveLength(0);
+    });
+});
+
+describe('User — isXxxAdmin getters (issue #61)', () => {
+    test('should return true for isAdmin when Admin group present', () => {
+        const user = new User('Alice', ['Admin']);
+        expect(user.isAdmin).toBe(true);
+    });
+
+    test('should return false for isAdmin when Admin group absent', () => {
+        const user = new User('Alice', ['Everyone']);
+        expect(user.isAdmin).toBe(false);
+    });
+
+    test('should return true for isDataAdmin when Admin group present', () => {
+        const user = new User('Alice', ['Admin']);
+        expect(user.isDataAdmin).toBe(true);
+    });
+
+    test('should return true for isDataAdmin when DataAdmin group present', () => {
+        const user = new User('Alice', ['DataAdmin']);
+        expect(user.isDataAdmin).toBe(true);
+    });
+
+    test('should return true for isSecurityAdmin when SecurityAdmin group present', () => {
+        const user = new User('Alice', ['SecurityAdmin']);
+        expect(user.isSecurityAdmin).toBe(true);
+    });
+
+    test('should return true for isOpsAdmin when OperationsAdmin group present', () => {
+        const user = new User('Alice', ['OperationsAdmin']);
+        expect(user.isOpsAdmin).toBe(true);
+    });
+});
+
+describe('User.fromDict — Type field parsing (issue #61)', () => {
+    test('should parse Type string field from API response dict', () => {
+        const dict = {
+            Name: 'Alice',
+            FriendlyName: 'Alice',
+            Groups: [{ Name: 'Admin' }],
+            Type: 'Admin',
+            Enabled: true,
+        };
+        const user = User.fromDict(dict);
+        expect(user.userType).toBe(UserType.Admin);
+    });
+
+    test('should parse SecurityAdmin Type field from API response dict', () => {
+        const dict = {
+            Name: 'Bob',
+            FriendlyName: 'Bob',
+            Groups: [{ Name: 'SecurityAdmin' }],
+            Type: 'SecurityAdmin',
+            Enabled: true,
+        };
+        const user = User.fromDict(dict);
+        expect(user.userType).toBe(UserType.SecurityAdmin);
+    });
+});
+
+describe('CaseAndSpaceInsensitiveSet — casing preservation (issue #61)', () => {
+    test('should preserve original casing of first insertion', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('Admin');
+        set.add('ADMIN');
+        set.add('admin');
+        expect(set.size).toBe(1);
+        expect(Array.from(set)).toEqual(['Admin']);
+    });
+
+    test('should find by any casing variant', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('HelloWorld');
+        expect(set.has('helloworld')).toBe(true);
+        expect(set.has('HELLOWORLD')).toBe(true);
+        expect(set.has('Hello World')).toBe(true);
+        expect(set.has('hello world')).toBe(true);
+    });
+
+    test('should return first-inserted casing during iteration', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('MyGroup');
+        set.add('mygroup');
+        set.add('MYGROUP');
+        expect(Array.from(set)).toEqual(['MyGroup']);
+    });
+
+    test('should delete by any casing variant', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('Admin');
+        expect(set.delete('ADMIN')).toBe(true);
+        expect(set.size).toBe(0);
+        expect(set.has('Admin')).toBe(false);
+    });
+
+    test('should return false when deleting non-existent entry', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        expect(set.delete('NonExistent')).toBe(false);
+    });
+
+    test('should maintain correct size after operations', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('A');
+        set.add('B');
+        set.add('a'); // duplicate — ignored
+        expect(set.size).toBe(2);
+        set.delete('A');
+        expect(set.size).toBe(1);
+    });
+
+    test('should clear all entries', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('A');
+        set.add('B');
+        set.clear();
+        expect(set.size).toBe(0);
+        expect(set.has('A')).toBe(false);
+    });
+
+    test('should handle values with spaces', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('Data Admin');
+        expect(set.has('dataadmin')).toBe(true);
+        expect(set.has('DataAdmin')).toBe(true);
+        expect(Array.from(set)).toEqual(['Data Admin']);
+    });
+});

package/src/utils/Utils.ts

@@ -65,20 +65,42 @@ export class CaseAndSpaceInsensitiveMap<T> extends Map<string, T> {
 }
 
 export class CaseAndSpaceInsensitiveSet extends Set<string> {
-    private normalizeValue(value: string): string {
-        return value.toLowerCase().replace(/\s+/g, '');
+    private _normalizedMap: Map<string, string>;
+
+    constructor(values?: Iterable<string>) {
+        super();
+        this._normalizedMap = new Map<string, string>();
+        if (values) {
+            for (const v of values) {
+                this.add(v);
+            }
+        }
     }
 
     add(value: string): this {
-        return super.add(this.normalizeValue(value));
+        const key = lowerAndDropSpaces(value);
+        if (!this._normalizedMap.has(key)) {
+            this._normalizedMap.set(key, value);
+            super.add(value);
+        }
+        return this;
     }
 
     has(value: string): boolean {
-        return super.has(this.normalizeValue(value));
+        return this._normalizedMap.has(lowerAndDropSpaces(value));
     }
 
     delete(value: string): boolean {
-        return super.delete(this.normalizeValue(value));
+        const key = lowerAndDropSpaces(value);
+        const original = this._normalizedMap.get(key);
+        if (original === undefined) return false;
+        this._normalizedMap.delete(key);
+        return super.delete(original);
+    }
+
+    clear(): void {
+        this._normalizedMap.clear();
+        super.clear();
     }
 }
 
@@ -98,6 +120,15 @@ export function escapeODataValue(str: string): string {
     return str.replace(/'/g, "''");
 }
 
+export function buildUrlFriendlyObjectName(objectName: string): string {
+    return objectName
+        .replace(/'/g, "''")
+        .replace(/%/g, "%25")
+        .replace(/#/g, "%23")
+        .replace(/\?/g, "%3F")
+        .replace(/&/g, "%26");
+}
+
 export function formatUrl(template: string, ...args: string[]): string {
     let url = template;
     for (const arg of args) {
@@ -336,8 +367,29 @@ export function verifyVersion(actualVersion: string, requiredVersion: string): b
     return true; // Equal versions
 }
 
-export function readObjectNameFromUrl(url: string): string {
-    // Extract object name from URL like "/Dimensions('DimName')" -> "DimName"
+// Overloads preserve the narrow `string` return for the existing no-pattern form
+// (published npm API — widening to `string | null` would break downstream consumers).
+export function readObjectNameFromUrl(url: string): string;
+export function readObjectNameFromUrl(url: string, pattern: string | RegExp): string | null;
+export function readObjectNameFromUrl(url: string, pattern?: string | RegExp): string | null {
+    // tm1py parity: when `pattern` is provided, behave like
+    // `re.match(pattern, url)` + `unquote(match.group(1))` — anchored at start,
+    // URL-decodes the first capture group, returns null on no match.
+    if (pattern !== undefined) {
+        const re = typeof pattern === 'string'
+            ? new RegExp(pattern.startsWith('^') ? pattern : '^' + pattern)
+            : pattern;
+        const m = url.match(re);
+        if (!m || m[1] === undefined) return null;
+        try {
+            return decodeURIComponent(m[1]);
+        } catch {
+            // tm1py parity: urllib.parse.unquote is permissive on malformed %XX
+            // (returns the original string). decodeURIComponent throws — fall back.
+            return m[1];
+        }
+    }
+    // Backward-compat: extract first ('name') segment, return '' on no match
     const match = url.match(/\('([^']+)'\)/);
     return match ? match[1] : '';
 }
@@ -395,6 +447,7 @@ export const Utils = {
     CaseAndSpaceInsensitiveSet,
     caseAndSpaceInsensitiveEquals,
     lowerAndDropSpaces,
+    buildUrlFriendlyObjectName,
     formatUrl,
     extractCellsetCells,
     buildMdxFromAxes,