musora-content-services 2.121.2 → 2.122.0

package/test/logout.test.js

@@ -0,0 +1,199 @@
+import { initializeService, globalConfig } from '../src/services/config.js'
+import { LocalStorageMock } from './localStorageMock'
+import { logout } from '../src/services/user/sessions.js'
+import { clearAllCachedData } from '../src/services/dataContext.js'
+import { USER_PIN_PROGRESS_KEY } from '../src/services/progress-row/base.js'
+
+describe('logout cache clearing', function () {
+  let mockLocalStorage
+
+  beforeEach(() => {
+    // Create fresh localStorage for each test
+    mockLocalStorage = new LocalStorageMock()
+
+    // Simple initialization without SyncManager
+    const config = {
+      sanityConfig: {
+        token: 'test-token',
+        projectId: 'test-project',
+        dataset: 'test',
+        useCachedAPI: true,
+        version: '2021-06-07',
+        debug: false,
+        useDummyRailContentMethods: true,
+      },
+      railcontentConfig: {
+        baseUrl: 'https://test.musora.com',
+        token: 'test-token',
+        userId: 123,
+        authToken: 'test-token',
+      },
+      sessionConfig: { token: 'test-token', userId: 123, authToken: 'test-token' },
+      baseUrl: 'https://test.musora.com',
+      localStorage: mockLocalStorage,
+      isMA: false,
+    }
+    initializeService(config)
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  test('clearAllCachedData does NOT remove user_pin_progress_row keys', async () => {
+    const localStorage = globalConfig.localStorage
+    const userId = 123
+    const userPinKey = `user_pin_progress_row_${userId}`
+
+    // Add pinned progress data for user 123
+    localStorage.setItem(userPinKey, JSON.stringify({
+      drumeo: { id: 123, progressType: 'content', pinnedAt: '2025-01-01' },
+      pianote: { id: 456, progressType: 'playlist', pinnedAt: '2025-01-02' }
+    }))
+
+    // Add pinned progress data for another user
+    localStorage.setItem('user_pin_progress_row_456', JSON.stringify({
+      drumeo: { id: 789, progressType: 'content' }
+    }))
+
+    // Verify data exists
+    expect(localStorage.getItem(userPinKey)).not.toBeNull()
+    expect(localStorage.getItem('user_pin_progress_row_456')).not.toBeNull()
+
+    // Clear cached data
+    await clearAllCachedData()
+
+    // Verify user pin progress rows are NOT removed
+    expect(localStorage.getItem(userPinKey)).not.toBeNull()
+    expect(localStorage.getItem('user_pin_progress_row_456')).not.toBeNull()
+  })
+
+  test('clearAllCachedData removes dataContext keys', async () => {
+    const localStorage = globalConfig.localStorage
+
+    // Add some dataContext keys
+    localStorage.setItem('dataContext_test1', JSON.stringify({ data: 'test1' }))
+    localStorage.setItem('dataContext_test2', JSON.stringify({ data: 'test2' }))
+    localStorage.setItem('other_key', 'should_remain')
+
+    // Verify data exists
+    expect(localStorage.getItem('dataContext_test1')).not.toBeNull()
+    expect(localStorage.getItem('dataContext_test2')).not.toBeNull()
+    expect(localStorage.getItem('other_key')).not.toBeNull()
+
+    // Clear all cached data
+    await clearAllCachedData()
+
+    // Verify dataContext keys were removed but other key remains
+    expect(localStorage.getItem('dataContext_test1')).toBeNull()
+    expect(localStorage.getItem('dataContext_test2')).toBeNull()
+    expect(localStorage.getItem('other_key')).toBe('should_remain')
+  })
+
+  test('clearAllCachedData removes ONLY dataContext keys', async () => {
+    const localStorage = globalConfig.localStorage
+    const userId = 123
+    const userPinKey = `user_pin_progress_row_${userId}`
+
+    // Add various cached data
+    localStorage.setItem(userPinKey, JSON.stringify({ drumeo: { id: 123 } }))
+    localStorage.setItem('dataContext_progress', JSON.stringify({ data: 'progress' }))
+    localStorage.setItem('dataContext_likes', JSON.stringify({ data: 'likes' }))
+    localStorage.setItem('unrelated_key', 'preserved')
+    localStorage.setItem('user_pin_progress_row_999', JSON.stringify({ drumeo: { id: 999 } }))
+
+    // Verify all data exists
+    expect(localStorage.getItem(userPinKey)).not.toBeNull()
+    expect(localStorage.getItem('dataContext_progress')).not.toBeNull()
+    expect(localStorage.getItem('dataContext_likes')).not.toBeNull()
+    expect(localStorage.getItem('unrelated_key')).not.toBeNull()
+
+    // Clear cached data
+    await clearAllCachedData()
+
+    // Verify only dataContext keys were cleared
+    expect(localStorage.getItem(userPinKey)).not.toBeNull()
+    expect(localStorage.getItem('dataContext_progress')).toBeNull()
+    expect(localStorage.getItem('dataContext_likes')).toBeNull()
+    expect(localStorage.getItem('unrelated_key')).toBe('preserved')
+    // All user pinned data should remain
+    expect(localStorage.getItem('user_pin_progress_row_999')).not.toBeNull()
+  })
+
+  test('logout calls clearAllCachedData', async () => {
+    // Mock fetch to prevent actual API call
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ success: true })
+    })
+
+    const localStorage = globalConfig.localStorage
+    const userId = 123
+    const userPinKey = `user_pin_progress_row_${userId}`
+
+    // Add cached data
+    localStorage.setItem(userPinKey, JSON.stringify({ drumeo: { id: 123 } }))
+    localStorage.setItem('dataContext_test', JSON.stringify({ data: 'test' }))
+    localStorage.setItem('user_pin_progress_row_456', JSON.stringify({ drumeo: { id: 456 } }))
+
+    // Verify data exists before logout
+    expect(localStorage.getItem(userPinKey)).not.toBeNull()
+    expect(localStorage.getItem('dataContext_test')).not.toBeNull()
+
+    // Call logout
+    await logout()
+
+    // Verify only dataContext was cleared, pinned progress remains
+    expect(localStorage.getItem(userPinKey)).not.toBeNull()
+    expect(localStorage.getItem('dataContext_test')).toBeNull()
+    expect(localStorage.getItem('user_pin_progress_row_456')).not.toBeNull()
+
+    // Verify fetch was called (logout API endpoint)
+    expect(global.fetch).toHaveBeenCalledWith(
+      expect.stringContaining('/api/user-management-system/v1/sessions'),
+      expect.objectContaining({
+        method: 'DELETE'
+      })
+    )
+  })
+
+  test('logout prevents cross-account data leakage', async () => {
+    // Mock fetch to prevent actual API call
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ success: true })
+    })
+
+    const localStorage = globalConfig.localStorage
+    const user1Id = 123
+    const user2Id = 456
+    const user1PinKey = `user_pin_progress_row_${user1Id}`
+    const user2PinKey = `user_pin_progress_row_${user2Id}`
+
+    // Simulate user 1 (id: 123) with pinned content and dataContext
+    localStorage.setItem(user1PinKey, JSON.stringify({
+      drumeo: { id: 12345, progressType: 'content', pinnedAt: '2025-01-14' }
+    }))
+    localStorage.setItem('dataContext_progress', JSON.stringify({ userId: 1, data: 'user1' }))
+
+    // Simulate user 2 (id: 456) already has pinned content
+    localStorage.setItem(user2PinKey, JSON.stringify({
+      drumeo: { id: 67890, progressType: 'content', pinnedAt: '2025-01-13' }
+    }))
+
+    // User 1 logs out
+    await logout()
+
+    // Verify dataContext is cleared (prevents cross-account leakage)
+    expect(localStorage.getItem('dataContext_progress')).toBeNull()
+
+    // Verify user 1's pinned progress remains (user-specific key)
+    expect(localStorage.getItem(user1PinKey)).not.toBeNull()
+
+    // Verify user 2's pinned content is NOT affected by user 1's logout
+    const user2PinnedData = localStorage.getItem(user2PinKey)
+    expect(user2PinnedData).not.toBeNull()
+    const user2Data = JSON.parse(user2PinnedData)
+    expect(user2Data.drumeo.id).toBe(67890)
+  })
+})

package/test/reporting.test.js

@@ -0,0 +1,132 @@
+/**
+ * Tests for Reporting Service
+ *
+ * Note: These tests use mocked HTTP calls. For integration tests,
+ * ensure the backend API is running at the configured baseUrl.
+ */
+
+import { initializeTestService } from './initializeTests.js'
+import {
+  reportContent,
+  reportForumPost,
+  submitReport
+} from '../src/services/reporting/reporting.ts'
+
+// Mock HttpClient to avoid actual API calls in tests
+jest.mock('../src/infrastructure/http/HttpClient', () => {
+  return {
+    HttpClient: jest.fn().mockImplementation(() => ({
+      post: jest.fn().mockResolvedValue({
+        report_id: 12345,
+        message: 'Report submitted successfully',
+        is_duplicate: false
+      })
+    }))
+  }
+})
+
+describe('Reporting Service', () => {
+  beforeEach(() => {
+    initializeTestService()
+  })
+
+  describe('reportContent', () => {
+    test('should submit a content report with video_not_working category', async () => {
+      const result = await reportContent({
+        contentId: 123,
+        category: 'video_not_working',
+        description: 'Video freezes at 2:30'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.report_id).toBe(12345)
+      expect(result.message).toBe('Report submitted successfully')
+      expect(result.is_duplicate).toBe(false)
+    })
+
+    test('should submit a content report without description', async () => {
+      const result = await reportContent({
+        contentId: 456,
+        category: 'incorrect_content'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.report_id).toBeDefined()
+    })
+
+    test('should submit a content report with other category and description', async () => {
+      const result = await reportContent({
+        contentId: 789,
+        category: 'other',
+        description: 'Audio quality is very poor'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.report_id).toBeDefined()
+      expect(result.message).toBeDefined()
+    })
+  })
+
+  describe('reportForumPost', () => {
+    test('should submit a forum post report with required brand', async () => {
+      const result = await reportForumPost({
+        postId: 555,
+        brand: 'drumeo',
+        category: 'spam'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.report_id).toBeDefined()
+    })
+
+    test('should submit a forum post report with description', async () => {
+      const result = await reportForumPost({
+        postId: 666,
+        brand: 'pianote',
+        category: 'harassment',
+        description: 'User is harassing other members'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.report_id).toBeDefined()
+      expect(result.message).toBeDefined()
+    })
+  })
+
+  describe('submitReport', () => {
+    test('should submit a generic report for content', async () => {
+      const result = await submitReport({
+        reportableType: 'content',
+        reportableId: 999,
+        category: 'technical_issue',
+        description: 'Page not loading'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.report_id).toBeDefined()
+    })
+
+    test('should submit a generic report for playlist', async () => {
+      const result = await submitReport({
+        reportableType: 'playlist',
+        reportableId: 777,
+        category: 'incorrect_content'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.report_id).toBeDefined()
+    })
+
+    test('should submit a generic report for comment', async () => {
+      const result = await submitReport({
+        reportableType: 'comment',
+        reportableId: 888,
+        category: 'inappropriate',
+        description: 'Comment contains offensive language'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.report_id).toBeDefined()
+    })
+  })
+})

package/test_owned_navigate.js

@@ -0,0 +1,74 @@
+import { initializeService } from './src/services/config.js'
+import { getOwnedContent } from './src/services/content.js'
+import dotenv from 'dotenv'
+
+dotenv.config()
+
+// Initialize service with credentials from .env
+initializeService({
+  sanityConfig: {
+    token: process.env.SANITY_API_TOKEN,
+    projectId: process.env.SANITY_PROJECT_ID,
+    dataset: process.env.SANITY_DATASET,
+    version: '2023-01-01',
+  },
+  railcontentConfig: {
+    email: process.env.RAILCONTENT_EMAIL,
+    password: process.env.RAILCONTENT_PASSWORD,
+    userId: parseInt(process.env.RAILCONTENT_USER_ID),
+    baseUrl: process.env.RAILCONTENT_BASE_URL,
+  },
+  localStorage: null,
+  isMA: false,
+})
+
+async function testOwnedContentNavigateTo() {
+  console.log('\n🧪 Testing owned content with navigateTo...\n')
+
+  try {
+    // Test for drumeo lessons
+    const result = await getOwnedContent('drumeo', {
+      type: ['course', 'guided-course', 'pack'],
+      limit: 5,
+    })
+
+    console.log('📊 Results:', {
+      total: result.total,
+      count: result.entity?.length || 0,
+    })
+
+    if (result.entity && result.entity.length > 0) {
+      result.entity.forEach((item, index) => {
+        console.log(`\n📦 Item ${index + 1}:`)
+        console.log(`  - ID: ${item.id}`)
+        console.log(`  - Title: ${item.title}`)
+        console.log(`  - Type: ${item.type}`)
+        console.log(`  - Has children: ${item.children ? '✅ YES' : '❌ NO'}`)
+        console.log(`  - Children count: ${item.children?.length || 0}`)
+        console.log(`  - Has navigateTo: ${item.navigateTo ? '✅ YES' : '❌ NO'}`)
+
+        if (item.navigateTo) {
+          console.log(`  - NavigateTo ID: ${item.navigateTo.id}`)
+          console.log(`  - NavigateTo Type: ${item.navigateTo.type}`)
+          console.log(`  - NavigateTo Title: ${item.children?.find(c => c.id === item.navigateTo.id)?.title || 'N/A'}`)
+        }
+
+        if (item.progressPercentage !== undefined) {
+          console.log(`  - Progress: ${item.progressPercentage}%`)
+        }
+        if (item.progressStatus) {
+          console.log(`  - Status: ${item.progressStatus}`)
+        }
+      })
+    } else {
+      console.log('\n⚠️  No owned content found for this user')
+    }
+
+    console.log('\n✅ Test completed successfully!')
+  } catch (error) {
+    console.error('\n❌ Test failed:', error.message)
+    console.error(error.stack)
+  }
+}
+
+testOwnedContentNavigateTo()

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": false,
+    "noImplicitAny": false,
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "checkJs": false
+  },
+  "include": ["src/**/*", "test/**/*"],
+  "exclude": ["node_modules", "dist"]
+}