@nextsparkjs/theme-default 0.1.0-beta.22 → 0.1.0-beta.25

package/tests/jest/setup.ts

@@ -0,0 +1,170 @@
+/**
+ * Jest Setup for Default Theme
+ *
+ * This file provides complete Jest setup for npm mode.
+ * It includes all necessary polyfills and mocks.
+ */
+
+import '@testing-library/jest-dom'
+import { TextEncoder, TextDecoder } from 'util'
+
+// Polyfill TextEncoder/TextDecoder for jsdom
+global.TextEncoder = TextEncoder
+global.TextDecoder = TextDecoder as typeof global.TextDecoder
+
+// Polyfill Web APIs for Next.js server components testing
+class MockHeaders {
+  private _headers: Map<string, string> = new Map()
+
+  constructor(init?: HeadersInit) {
+    if (init) {
+      if (init instanceof MockHeaders) {
+        init._headers.forEach((value, key) => this._headers.set(key, value))
+      } else if (Array.isArray(init)) {
+        init.forEach(([key, value]) => this._headers.set(key.toLowerCase(), value))
+      } else {
+        Object.entries(init).forEach(([key, value]) => this._headers.set(key.toLowerCase(), value))
+      }
+    }
+  }
+
+  get(name: string) { return this._headers.get(name.toLowerCase()) || null }
+  set(name: string, value: string) { this._headers.set(name.toLowerCase(), value) }
+  has(name: string) { return this._headers.has(name.toLowerCase()) }
+  delete(name: string) { this._headers.delete(name.toLowerCase()) }
+  forEach(cb: (value: string, key: string) => void) { this._headers.forEach(cb) }
+  entries() { return this._headers.entries() }
+  keys() { return this._headers.keys() }
+  values() { return this._headers.values() }
+}
+
+class MockRequest {
+  url: string
+  method: string
+  headers: MockHeaders
+  private _body: any
+
+  constructor(input: string | URL, init?: RequestInit) {
+    this.url = typeof input === 'string' ? input : input.toString()
+    this.method = init?.method || 'GET'
+    this.headers = new MockHeaders(init?.headers as HeadersInit)
+    this._body = init?.body
+  }
+
+  async json() {
+    if (!this._body) return {}
+    return typeof this._body === 'string' ? JSON.parse(this._body) : this._body
+  }
+
+  async text() {
+    return this._body?.toString() || ''
+  }
+
+  clone() {
+    return new MockRequest(this.url, {
+      method: this.method,
+      headers: Object.fromEntries(this.headers.entries()),
+      body: this._body,
+    })
+  }
+}
+
+class MockResponse {
+  body: any
+  status: number
+  statusText: string
+  headers: MockHeaders
+  ok: boolean
+
+  constructor(body?: any, init?: ResponseInit) {
+    this.body = body
+    this.status = init?.status || 200
+    this.statusText = init?.statusText || 'OK'
+    this.headers = new MockHeaders(init?.headers as HeadersInit)
+    this.ok = this.status >= 200 && this.status < 300
+  }
+
+  async json() {
+    if (!this.body) return {}
+    return typeof this.body === 'string' ? JSON.parse(this.body) : this.body
+  }
+
+  async text() {
+    return this.body?.toString() || ''
+  }
+
+  clone() {
+    return new MockResponse(this.body, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: Object.fromEntries(this.headers.entries()),
+    })
+  }
+
+  static json(data: any, init?: ResponseInit) {
+    return new MockResponse(JSON.stringify(data), {
+      ...init,
+      headers: { 'Content-Type': 'application/json', ...(init?.headers || {}) as object },
+    })
+  }
+}
+
+// Assign to global scope
+global.Headers = MockHeaders as any
+global.Request = MockRequest as any
+global.Response = MockResponse as any
+
+// Mock fetch
+global.fetch = jest.fn().mockResolvedValue(new MockResponse('{}', { status: 200 }))
+
+// Mock Web Crypto API
+const crypto = require('crypto')
+Object.defineProperty(global, 'crypto', {
+  value: {
+    getRandomValues: (arr: Uint8Array) => crypto.randomFillSync(arr),
+    randomUUID: () => crypto.randomUUID(),
+    subtle: {
+      digest: async (algorithm: string, data: BufferSource) => {
+        const hash = crypto.createHash(algorithm.toLowerCase().replace('-', ''))
+        hash.update(Buffer.from(data as ArrayBuffer))
+        return hash.digest().buffer
+      },
+      encrypt: jest.fn(),
+      decrypt: jest.fn(),
+      sign: jest.fn(),
+      verify: jest.fn(),
+      generateKey: jest.fn(),
+      importKey: jest.fn(),
+      exportKey: jest.fn(),
+    },
+  },
+})
+
+// Mock matchMedia for component tests with media queries
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: jest.fn().mockImplementation((query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: jest.fn(),
+    removeListener: jest.fn(),
+    addEventListener: jest.fn(),
+    removeEventListener: jest.fn(),
+    dispatchEvent: jest.fn(),
+  })),
+})
+
+// Mock ResizeObserver
+global.ResizeObserver = jest.fn().mockImplementation(() => ({
+  observe: jest.fn(),
+  unobserve: jest.fn(),
+  disconnect: jest.fn(),
+}))
+
+// Mock IntersectionObserver
+global.IntersectionObserver = jest.fn().mockImplementation(() => ({
+  observe: jest.fn(),
+  unobserve: jest.fn(),
+  disconnect: jest.fn(),
+}))

package/tests/jest/tsconfig.jest.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../../apps/dev/tsconfig.json",
+  "compilerOptions": {
+    "jsx": "react-jsx"
+  }
+}

package/tests/jest/config/role-config.test.ts

@@ -1,529 +0,0 @@
-/**
- * Unit Tests - Role Configuration (app.config.ts)
- *
- * Tests role configuration for Developer Area feature:
- * - Developer role in availableRoles array
- * - Developer hierarchy value (100, highest)
- * - Developer displayName translation key
- * - Developer description
- * - Configuration completeness
- *
- * Focus on developer role configuration validation.
- */
-
-import { DEFAULT_APP_CONFIG } from '@nextsparkjs/core/lib/config/app.config'
-
-describe('Role Configuration - Developer Role', () => {
-  describe('availableRoles Array', () => {
-    it('should include developer role', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('developer')
-    })
-
-    it('should include superadmin role', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('superadmin')
-    })
-
-    it('should include member role', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('member')
-    })
-
-    it('should have exactly 3 roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles.length).toBe(3)
-    })
-
-    it('should have roles in correct order', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toEqual(['member', 'superadmin', 'developer'])
-    })
-
-    it('should have all roles as strings', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      roles.forEach(role => {
-        expect(typeof role).toBe('string')
-      })
-    })
-
-    it('should have all roles in lowercase', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      roles.forEach(role => {
-        expect(role).toBe(role.toLowerCase())
-      })
-    })
-
-    it('should not have duplicate roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const uniqueRoles = new Set(roles)
-
-      expect(uniqueRoles.size).toBe(roles.length)
-    })
-  })
-
-  describe('Role Hierarchy', () => {
-    it('should have developer at level 100', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.developer).toBe(100)
-    })
-
-    it('should have superadmin at level 99', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.superadmin).toBe(99)
-    })
-
-    it('should have member at level 1', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.member).toBe(1)
-    })
-
-    it('should have developer as highest hierarchy', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.developer).toBeGreaterThan(hierarchy.superadmin)
-      expect(hierarchy.developer).toBeGreaterThan(hierarchy.member)
-    })
-
-    it('should have superadmin higher than member', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.superadmin).toBeGreaterThan(hierarchy.member)
-    })
-
-    it('should have all hierarchy values as numbers', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(typeof hierarchy.developer).toBe('number')
-      expect(typeof hierarchy.superadmin).toBe('number')
-      expect(typeof hierarchy.member).toBe('number')
-    })
-
-    it('should have all hierarchy values as positive integers', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.developer).toBeGreaterThan(0)
-      expect(hierarchy.superadmin).toBeGreaterThan(0)
-      expect(hierarchy.member).toBeGreaterThan(0)
-
-      expect(Number.isInteger(hierarchy.developer)).toBe(true)
-      expect(Number.isInteger(hierarchy.superadmin)).toBe(true)
-      expect(Number.isInteger(hierarchy.member)).toBe(true)
-    })
-
-    it('should have correct hierarchy gap between developer and superadmin', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      // Developer (100) should be 1 level above superadmin (99)
-      expect(hierarchy.developer - hierarchy.superadmin).toBe(1)
-    })
-
-    it('should have large gap between superadmin and member', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      // Large gap indicates future extensibility
-      expect(hierarchy.superadmin - hierarchy.member).toBeGreaterThan(50)
-    })
-
-    it('should have hierarchy keys matching availableRoles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      roles.forEach(role => {
-        expect(hierarchy[role as keyof typeof hierarchy]).toBeDefined()
-        expect(typeof hierarchy[role as keyof typeof hierarchy]).toBe('number')
-      })
-    })
-  })
-
-  describe('Display Names (Translation Keys)', () => {
-    it('should have translation key for developer role', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      expect(displayNames.developer).toBe('common.userRoles.developer')
-    })
-
-    it('should have translation key for superadmin role', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      expect(displayNames.superadmin).toBe('common.userRoles.superadmin')
-    })
-
-    it('should have translation key for member role', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      expect(displayNames.member).toBe('common.userRoles.member')
-    })
-
-    it('should have translation keys in correct format', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      Object.values(displayNames).forEach(key => {
-        expect(key).toMatch(/^common\.userRoles\.\w+$/)
-      })
-    })
-
-    it('should have translation keys for all available roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      roles.forEach(role => {
-        expect(displayNames[role as keyof typeof displayNames]).toBeDefined()
-        expect(displayNames[role as keyof typeof displayNames]).toContain('common.userRoles.')
-      })
-    })
-
-    it('should use common namespace for all role names', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      Object.values(displayNames).forEach(key => {
-        expect(key).toMatch(/^common\./)
-      })
-    })
-  })
-
-  describe('Role Descriptions', () => {
-    it('should have description for developer role', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.developer).toBe('Ultimate access (platform developers only)')
-    })
-
-    it('should have description for superadmin role', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.superadmin).toBe('Full system access (product owners only)')
-    })
-
-    it('should have description for member role', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.member).toBe('Regular user with team-based permissions')
-    })
-
-    it('should have descriptions as non-empty strings', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      Object.values(descriptions).forEach(description => {
-        expect(typeof description).toBe('string')
-        expect(description.length).toBeGreaterThan(0)
-      })
-    })
-
-    it('should have descriptions for all available roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      roles.forEach(role => {
-        expect(descriptions[role as keyof typeof descriptions]).toBeDefined()
-        expect(descriptions[role as keyof typeof descriptions].length).toBeGreaterThan(0)
-      })
-    })
-
-    it('should have developer description indicating highest access', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.developer.toLowerCase()).toContain('ultimate')
-    })
-
-    it('should have developer description indicating platform developer usage', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.developer.toLowerCase()).toContain('developer')
-    })
-
-    it('should have superadmin description indicating product owner usage', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.superadmin.toLowerCase()).toContain('owner')
-    })
-  })
-
-  describe('Default Role', () => {
-    it('should have member as default role', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).toBe('member')
-    })
-
-    it('should have default role in availableRoles', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain(defaultRole)
-    })
-
-    it('should not have developer as default role', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).not.toBe('developer')
-    })
-
-    it('should not have superadmin as default role', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).not.toBe('superadmin')
-    })
-  })
-
-  describe('Configuration Completeness', () => {
-    it('should have all roles in hierarchy map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      roles.forEach(role => {
-        expect(hierarchy[role as keyof typeof hierarchy]).toBeDefined()
-      })
-    })
-
-    it('should have all roles in displayNames map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      roles.forEach(role => {
-        expect(displayNames[role as keyof typeof displayNames]).toBeDefined()
-      })
-    })
-
-    it('should have all roles in descriptions map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      roles.forEach(role => {
-        expect(descriptions[role as keyof typeof descriptions]).toBeDefined()
-      })
-    })
-
-    it('should have no extra keys in hierarchy map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      const hierarchyKeys = Object.keys(hierarchy)
-
-      expect(hierarchyKeys.length).toBe(roles.length)
-    })
-
-    it('should have no extra keys in displayNames map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      const displayNameKeys = Object.keys(displayNames)
-
-      expect(displayNameKeys.length).toBe(roles.length)
-    })
-
-    it('should have no extra keys in descriptions map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      const descriptionKeys = Object.keys(descriptions)
-
-      expect(descriptionKeys.length).toBe(roles.length)
-    })
-  })
-})
-
-describe('Role Configuration - Backwards Compatibility', () => {
-  describe('Existing Roles Preserved', () => {
-    it('should still have member role (Phase 1)', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('member')
-    })
-
-    it('should still have superadmin role (Phase 2)', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('superadmin')
-    })
-
-    it('should preserve member hierarchy value', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.member).toBe(1)
-    })
-
-    it('should preserve superadmin hierarchy value', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.superadmin).toBe(99)
-    })
-
-    it('should preserve default role as member', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).toBe('member')
-    })
-  })
-
-  describe('New Role Addition (Phase 3)', () => {
-    it('should add developer role without breaking existing config', () => {
-      const config = DEFAULT_APP_CONFIG.userRoles
-
-      // All Phase 1-2 features still work
-      expect(config.defaultRole).toBe('member')
-      expect(config.availableRoles).toContain('member')
-      expect(config.availableRoles).toContain('superadmin')
-
-      // Phase 3 addition
-      expect(config.availableRoles).toContain('developer')
-    })
-
-    it('should have developer hierarchy higher than existing roles', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.developer).toBeGreaterThan(hierarchy.superadmin)
-      expect(hierarchy.developer).toBeGreaterThan(hierarchy.member)
-    })
-
-    it('should not affect superadmin hierarchy relative to member', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.superadmin).toBeGreaterThan(hierarchy.member)
-    })
-  })
-})
-
-describe('Role Configuration - Edge Cases', () => {
-  describe('Type Safety', () => {
-    it('should have userRoles as an object', () => {
-      expect(typeof DEFAULT_APP_CONFIG.userRoles).toBe('object')
-      expect(DEFAULT_APP_CONFIG.userRoles).not.toBeNull()
-    })
-
-    it('should have availableRoles as readonly array', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(Array.isArray(roles)).toBe(true)
-    })
-
-    it('should have hierarchy as object with string keys', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(typeof hierarchy).toBe('object')
-      Object.keys(hierarchy).forEach(key => {
-        expect(typeof key).toBe('string')
-      })
-    })
-  })
-
-  describe('Invalid Data Protection', () => {
-    it('should not have empty string roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      roles.forEach(role => {
-        expect(role.length).toBeGreaterThan(0)
-      })
-    })
-
-    it('should not have negative hierarchy values', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      Object.values(hierarchy).forEach(value => {
-        expect(value).toBeGreaterThan(0)
-      })
-    })
-
-    it('should not have hierarchy values as floats', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      Object.values(hierarchy).forEach(value => {
-        expect(Number.isInteger(value)).toBe(true)
-      })
-    })
-
-    it('should not have empty translation keys', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      Object.values(displayNames).forEach(key => {
-        expect(key.length).toBeGreaterThan(0)
-      })
-    })
-
-    it('should not have empty descriptions', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      Object.values(descriptions).forEach(description => {
-        expect(description.length).toBeGreaterThan(0)
-      })
-    })
-  })
-})
-
-describe('Real-World Configuration Usage', () => {
-  describe('Guard Implementation Support', () => {
-    it('should support DeveloperGuard role check', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      // DeveloperGuard checks if role === 'developer'
-      expect(roles).toContain('developer')
-    })
-
-    it('should support SuperAdminGuard dual role check', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      // SuperAdminGuard allows both superadmin and developer
-      expect(roles).toContain('superadmin')
-      expect(roles).toContain('developer')
-    })
-
-    it('should support middleware role validation', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      // Middleware compares hierarchy levels
-      expect(hierarchy.developer).toBeDefined()
-      expect(hierarchy.superadmin).toBeDefined()
-      expect(hierarchy.member).toBeDefined()
-    })
-  })
-
-  describe('UI Display Support', () => {
-    it('should provide translation keys for role selection dropdown', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      const roles = ['developer', 'superadmin', 'member'] as const
-
-      roles.forEach(role => {
-        expect(displayNames[role]).toMatch(/^common\.userRoles\.\w+$/)
-      })
-    })
-
-    it('should provide descriptions for role info tooltips', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      const roles = ['developer', 'superadmin', 'member'] as const
-
-      roles.forEach(role => {
-        expect(descriptions[role].length).toBeGreaterThan(10) // Meaningful description
-      })
-    })
-  })
-
-  describe('Database Schema Support', () => {
-    it('should have role values compatible with database enum', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      // Database enum values should be lowercase strings
-      roles.forEach(role => {
-        expect(role).toMatch(/^[a-z]+$/)
-      })
-    })
-
-    it('should have default role for user creation', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).toBe('member')
-      expect(DEFAULT_APP_CONFIG.userRoles.availableRoles).toContain(defaultRole)
-    })
-  })
-})