musora-content-services 2.167.2 → 2.167.3

package/test/unit/progress-row/content-card.test.ts

@@ -1,314 +0,0 @@
-import {
-  getSubtitle,
-  getDefaultCTATextForContent,
-} from '../../../src/services/progress-row/rows/content-card.js'
-
-describe('getSubtitle', () => {
-  describe('parent lesson types', () => {
-    test.each([
-      'course',
-      'guided-course',
-      'course-collection',
-      'song-tutorial',
-      'learning-path-v2',
-      'skill-pack',
-    ])('returns "X of Y Lessons Complete" for type %s', (type) => {
-      const content = {
-        type,
-        completed_children: 3,
-        all_children: 10,
-      }
-      expect(getSubtitle(content, 'course', false)).toBe('3 of 10 Lessons Complete')
-    })
-
-    test('uses 0 when completed_children is missing', () => {
-      const content = { type: 'course', all_children: 8 }
-      expect(getSubtitle(content, 'course', false)).toBe('0 of 8 Lessons Complete')
-    })
-
-    test('falls back to lesson_count when all_children missing', () => {
-      const content = { type: 'course', completed_children: 2, lesson_count: 5 }
-      expect(getSubtitle(content, 'course', false)).toBe('2 of 5 Lessons Complete')
-    })
-
-    test('falls back to child_count when all_children and lesson_count missing', () => {
-      const content = { type: 'course', completed_children: 1, child_count: 4 }
-      expect(getSubtitle(content, 'course', false)).toBe('1 of 4 Lessons Complete')
-    })
-
-    test('prefers all_children over lesson_count and child_count', () => {
-      const content = {
-        type: 'course',
-        completed_children: 1,
-        all_children: 9,
-        lesson_count: 5,
-        child_count: 7,
-      }
-      expect(getSubtitle(content, 'course', false)).toBe('1 of 9 Lessons Complete')
-    })
-
-    test('returns null when all count fields missing', () => {
-      const content = { type: 'course', completed_children: 2 }
-      expect(getSubtitle(content, 'course', false)).toBeNull()
-    })
-  })
-
-  describe('lesson_count > 1', () => {
-    test('returns "X of Y Lessons Complete" when lesson_count > 1 even for non-parent type', () => {
-      const content = {
-        type: 'song',
-        completed_children: 2,
-        all_children: 6,
-        lesson_count: 6,
-      }
-      expect(getSubtitle(content, 'song', false)).toBe('2 of 6 Lessons Complete')
-    })
-
-    test('does not trigger when lesson_count is 1', () => {
-      const content = {
-        type: 'song',
-        lesson_count: 1,
-        difficulty_string: 'Beginner',
-        artist_name: 'Artist',
-      }
-      expect(getSubtitle(content, 'song', false)).toBe('Beginner • Artist')
-    })
-
-    test('does not trigger when lesson_count is 0', () => {
-      const content = {
-        type: 'song',
-        lesson_count: 0,
-        difficulty_string: 'Intermediate',
-        artist_name: 'Band',
-      }
-      expect(getSubtitle(content, 'song', false)).toBe('Intermediate • Band')
-    })
-  })
-
-  describe('lesson and show contentType', () => {
-    test('returns "X% Complete" for lesson when not live', () => {
-      const content = { type: 'course-lesson', progressPercentage: 42 }
-      expect(getSubtitle(content, 'lesson', false)).toBe('42% Complete')
-    })
-
-    test('returns "X% Complete" for show when not live', () => {
-      const content = { type: 'show', progressPercentage: 75 }
-      expect(getSubtitle(content, 'show', false)).toBe('75% Complete')
-    })
-
-    test('returns "0% Complete" when progressPercentage is 0', () => {
-      const content = { type: 'course-lesson', progressPercentage: 0 }
-      expect(getSubtitle(content, 'lesson', false)).toBe('0% Complete')
-    })
-
-    test('returns null when progressPercentage missing for lesson', () => {
-      const content = { type: 'course-lesson' }
-      expect(getSubtitle(content, 'lesson', false)).toBeNull()
-    })
-
-    test('returns null when progressPercentage missing for show', () => {
-      const content = { type: 'show' }
-      expect(getSubtitle(content, 'show', false)).toBeNull()
-    })
-
-    test('falls through to difficulty/artist when lesson isLive=true', () => {
-      const content = {
-        type: 'course-lesson',
-        progressPercentage: 80,
-        difficulty_string: 'Advanced',
-        artist_name: 'Live Artist',
-      }
-      expect(getSubtitle(content, 'lesson', true)).toBe('Advanced • Live Artist')
-    })
-
-    test('falls through to difficulty/artist when show isLive=true', () => {
-      const content = {
-        type: 'show',
-        progressPercentage: 50,
-        difficulty_string: 'Beginner',
-        artist_name: 'Live Show',
-      }
-      expect(getSubtitle(content, 'show', true)).toBe('Beginner • Live Show')
-    })
-  })
-
-  describe('default difficulty/artist subtitle', () => {
-    test('returns "difficulty • artist" for song', () => {
-      const content = {
-        type: 'song',
-        difficulty_string: 'Intermediate',
-        artist_name: 'The Beatles',
-      }
-      expect(getSubtitle(content, 'song', false)).toBe('Intermediate • The Beatles')
-    })
-
-    test('returns null when both difficulty and artist missing', () => {
-      const content = { type: 'song' }
-      expect(getSubtitle(content, 'song', false)).toBeNull()
-    })
-
-    test('returns difficulty only when artist missing', () => {
-      const content = { type: 'song', difficulty_string: 'Beginner' }
-      expect(getSubtitle(content, 'song', false)).toBe('Beginner')
-    })
-
-    test('returns artist only when difficulty missing', () => {
-      const content = { type: 'song', artist_name: 'The Beatles' }
-      expect(getSubtitle(content, 'song', false)).toBe('The Beatles')
-    })
-  })
-
-  describe('priority ordering', () => {
-    test('parent-type rule wins over lesson contentType', () => {
-      const content = {
-        type: 'course',
-        completed_children: 4,
-        all_children: 12,
-        progressPercentage: 33,
-      }
-      expect(getSubtitle(content, 'lesson', false)).toBe('4 of 12 Lessons Complete')
-    })
-
-    test('lesson_count>1 rule wins over lesson contentType', () => {
-      const content = {
-        type: 'song',
-        lesson_count: 3,
-        completed_children: 1,
-        all_children: 3,
-        progressPercentage: 33,
-      }
-      expect(getSubtitle(content, 'lesson', false)).toBe('1 of 3 Lessons Complete')
-    })
-  })
-})
-
-describe('getDefaultCTATextForContent', () => {
-  describe('guided-course not started', () => {
-    test('returns "Start Course" when progressStatus is undefined', () => {
-      const content = { type: 'guided-course' }
-      expect(getDefaultCTATextForContent(content, 'guided course')).toBe('Start Course')
-    })
-
-    test('returns "Start Course" when progressStatus is "not-started"', () => {
-      const content = { type: 'guided-course', progressStatus: 'not-started' }
-      expect(getDefaultCTATextForContent(content, 'guided course')).toBe('Start Course')
-    })
-
-    test('returns "Start Course" when progressPercentage is 0', () => {
-      const content = {
-        type: 'guided-course',
-        progressStatus: 'started',
-        progressPercentage: 0,
-      }
-      expect(getDefaultCTATextForContent(content, 'guided course')).toBe('Start Course')
-    })
-
-    test('returns "Continue" when guided-course is in-progress', () => {
-      const content = {
-        type: 'guided-course',
-        progressStatus: 'started',
-        progressPercentage: 25,
-      }
-      expect(getDefaultCTATextForContent(content, 'guided course')).toBe('Continue')
-    })
-  })
-
-  describe('completed - song variants', () => {
-    test.each([
-      ['drumeo', 'transcription'],
-      ['guitareo', 'tab'],
-      ['pianote', 'sheet music'],
-      ['singeo', 'sheet music'],
-      ['playbass', 'tab'],
-    ])('returns "Replay Song" when completed for brand %s with song contentType %s', (brand, contentType) => {
-      const content = { type: 'song', brand, progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, contentType)).toBe('Replay Song')
-    })
-
-    test('returns "Replay Song" when completed and contentType is "play along"', () => {
-      const content = { type: 'play-along', brand: 'drumeo', progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'play along')).toBe('Replay Song')
-    })
-
-    test('returns "Replay Song" when completed and contentType is "jam track"', () => {
-      const content = { type: 'jam-track', brand: 'drumeo', progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'jam track')).toBe('Replay Song')
-    })
-
-    test('does not return "Replay Song" when brand song contentType mismatches', () => {
-      const content = { type: 'song', brand: 'drumeo', progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'tab')).toBe('Continue')
-    })
-  })
-
-  describe('completed - lesson/show', () => {
-    test('returns "Revisit Lesson" when completed lesson', () => {
-      const content = { type: 'course-lesson', progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Revisit Lesson')
-    })
-
-    test('returns "Revisit Lesson" when completed show', () => {
-      const content = { type: 'show', progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'show')).toBe('Revisit Lesson')
-    })
-  })
-
-  describe('completed - parent lesson types', () => {
-    test.each([
-      'course',
-      'guided-course',
-      'course-collection',
-      'song-tutorial',
-      'learning-path-v2',
-      'skill-pack',
-    ])('returns "Revisit Lessons" when completed for type %s', (type) => {
-      const content = { type, progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'course')).toBe('Revisit Lessons')
-    })
-  })
-
-  describe('completed - other', () => {
-    test('returns "Continue" when completed and no rule matches', () => {
-      const content = { type: 'some-type', progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'unknown')).toBe('Continue')
-    })
-  })
-
-  describe('default fallback', () => {
-    test('returns "Continue" when no progressStatus for non-guided-course', () => {
-      const content = { type: 'song' }
-      expect(getDefaultCTATextForContent(content, 'song')).toBe('Continue')
-    })
-
-    test('returns "Continue" when progressStatus is "started"', () => {
-      const content = {
-        type: 'course-lesson',
-        progressStatus: 'started',
-        progressPercentage: 50,
-      }
-      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Continue')
-    })
-
-    test('returns "Continue" when not-started and not guided-course', () => {
-      const content = { type: 'course-lesson', progressStatus: 'not-started' }
-      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Continue')
-    })
-  })
-
-  describe('priority ordering', () => {
-    test('guided-course not-started wins even when contentType is lesson', () => {
-      const content = { type: 'guided-course', progressPercentage: 0 }
-      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Start Course')
-    })
-
-    test('completed song-match wins over completed lesson contentType', () => {
-      const content = { type: 'song', brand: 'drumeo', progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'transcription')).toBe('Replay Song')
-    })
-
-    test('completed lesson contentType wins over parent-type rule', () => {
-      const content = { type: 'course', progressStatus: 'completed' }
-      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Revisit Lesson')
-    })
-  })
-})

package/test/unit/progress-row/playlist-card.test.ts

@@ -1,104 +0,0 @@
-import { processPlaylistItem, getRecentPlaylists, getPlaylistEngagedOnContent } from '../../../src/services/progress-row/rows/playlist-card.js'
-jest.mock('../../../src/services/content-org/playlists.js', () => ({
-  fetchUserPlaylists: jest.fn(),
-}))
-jest.mock('../../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../../src/services/sanity.js'),
-  fetchByRailContentIds: jest.fn(),
-}))
-jest.mock('../../../src/services/contentAggregator.js', () => ({
-  addContextToContent: jest.fn(),
-}))
-import { fetchUserPlaylists } from '../../../src/services/content-org/playlists.js'
-const mockPlaylistItem = {
-  pinned: false,
-  progressTimestamp: 1234567890,
-  playlist: {
-    id: 1,
-    name: 'My Playlist',
-    brand: 'drumeo',
-    duration_formated: '1h 30m',
-    total_items: 10,
-    likes: 5,
-    first_items_thumbnail_url: [
-    {
-        thumbnail: 'https://cdn.example.com/thumb.jpg',
-        type: 'song',
-        artist_name: 'Kiss',
-        title: "Mwaa"
-     }
-    ],
-    navigateTo: { id: 42, content_id: 99 },
-    user: { display_name: 'John Doe' },
-  },
-}
-describe('processPlaylistItem', () => {
-  test('returns correctly shaped object from playlist item', () => {
-    const result = processPlaylistItem(mockPlaylistItem)
-    expect(result).toMatchObject({
-      id: 1,
-      progressType: 'playlist',
-      header: 'playlist',
-      pinned: false,
-      progressTimestamp: 1234567890,
-      cta: {
-        text: 'Continue',
-        action: {
-          brand: 'drumeo',
-          item_id: 42,
-          content_id: 99,
-          type: 'playlists',
-          id: 1,
-        },
-      },
-    })
-  })
-  test('pinned defaults to false when not set', () => {
-    const item = { ...mockPlaylistItem, pinned: undefined }
-    const result = processPlaylistItem(item)
-    expect(result.pinned).toBe(false)
-  })
-  test('pinned is true when set', () => {
-    const item = { ...mockPlaylistItem, pinned: true }
-    const result = processPlaylistItem(item)
-    expect(result.pinned).toBe(true)
-  })
-  test('subtitle combines duration, total_items, likes and display_name', () => {
-    const result = processPlaylistItem(mockPlaylistItem)
-    expect(result.body.subtitle).toBe('1h 30m • 10 items • 5 likes • John Doe')
-  })
-})
-describe('getRecentPlaylists', () => {
-  test('filters out playlists with no last_progress', async () => {
-    (fetchUserPlaylists as jest.Mock).mockResolvedValue({
-      data: [
-        { id: 1, last_progress: '2024-01-01 10:00:00', last_engaged_on: 123 },
-        { id: 2, last_progress: null, last_engaged_on: 123 },
-      ]
-    })
-    const result = await getRecentPlaylists('drumeo', 10)
-    expect(result).toHaveLength(1)
-    expect(result[0].id).toBe(1)
-  })
-  test('converts last_progress date string to UTC timestamp', async () => {
-    (fetchUserPlaylists as jest.Mock).mockResolvedValue({
-      data: [
-        { id: 1, last_progress: '2024-01-01 10:00:00', last_engaged_on: 123 },
-      ]
-    })
-    const result = await getRecentPlaylists('drumeo', 10)
-    expect(typeof result[0].progressTimestamp).toBe('number')
-    expect(result[0].progressTimestamp).toBe(new Date('2024-01-01T10:00:00Z').getTime())
-  })
-  test('returns empty array when response has no data', async () => {
-    (fetchUserPlaylists as jest.Mock).mockResolvedValue({ data: [] })
-    const result = await getRecentPlaylists('drumeo', 10)
-    expect(result).toHaveLength(0)
-  })
-})
-describe('getPlaylistEngagedOnContent', () => {
-  test('returns empty array when recentPlaylists is empty', async () => {
-    const result = await getPlaylistEngagedOnContent([])
-    expect(result).toEqual([])
-  })
-})

package/test/unit/progressRows.test.ts

@@ -1,243 +0,0 @@
-import { getProgressRows } from '../../src/services/progress-row/base.js';
-import { fetchUserPlaylists } from '../../src/services/content-org/playlists.js';
-import { fetchByRailContentIds } from '../../src/services/sanity.js';
-import {getAllStartedOrCompleted, getProgressStateByIds} from '../../src/services/contentProgress.js';
-import { initializeTestService } from '../initializeTests.js';
-import mockData_progress_content from '../mockData/mockData_progress_content.json';
-import mockData_sanity_progress_content from "../mockData/mockData_sanity_progress_content.json";
-
-jest.mock('../../src/services/progress-row/rows/method-card.js', () => ({
-  getMethodCard: jest.fn().mockResolvedValue(null),
-}))
-
-jest.mock('../../src/services/sync/repository-proxy.ts', () => {
-  const mockFns = {
-    contentProgress: {
-      pull: jest.fn().mockResolvedValue(undefined),
-      getSomeProgressByContentIds: jest.fn().mockResolvedValue({ data: [] }),
-    }
-  }
-  return { default: mockFns, ...mockFns }
-})
-
-jest.mock('../../src/infrastructure/http/HttpClient.ts', () => ({
-  GET: jest.fn().mockResolvedValue(null),
-  PUT: jest.fn().mockResolvedValue(null),
-  POST: jest.fn().mockResolvedValue(null),
-  PATCH: jest.fn().mockResolvedValue(null),
-  DELETE: jest.fn().mockResolvedValue(null),
-  HttpClient: jest.fn(),
-}))
-
-jest.mock('../../src/services/content-org/playlists.js');
-jest.mock('../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../src/services/sanity'),
-  fetchByRailContentIds: jest.fn(),
-}));
-jest.mock('../../src/services/contentProgress.js', () => ({
-  ...jest.requireActual('../../src/services/contentProgress'),
-  getAllStartedOrCompleted: jest.fn(),
-  getProgressStateByIds: jest.fn(),
-}));
-
-describe('getProgressRows', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    initializeTestService();
-  });
-
-  it('returns progress rows successfully', async () => {
-    const mockPlaylists = [
-      {
-        id: 1,
-        name: 'Playlist 1',
-        last_progress: '2025-05-19 10:00:00',
-        last_engaged_on: 101,
-        items: [{ content_id: 201 }],
-        duration_formated: '10m',
-        total_items: 1,
-        likes: 100,
-        user: { display_name: 'User1' },
-        brand: 'brand1',
-        first_items_thumbnail_url: 'url1',
-        navigateTo: { id: null, content_id: null },
-      },
-    ];
-
-    const mockPlaylistContents = [
-      {
-        id: 201,
-        railcontent_id: 201,
-        parent_content_data: [],
-        type: 'play-along',
-        thumbnail: 'thumb1',
-        title: 'Lesson 1',
-        difficulty_string: 'Easy',
-        artist_name: 'Artist 1',
-        lesson_count: 1,
-        completed_children: 0,
-        brand: 'brand1',
-        slug: 'lesson-1',
-      },
-    ];
-
-    fetchUserPlaylists.mockResolvedValue({ data: mockPlaylists })
-    fetchByRailContentIds.mockResolvedValue(mockPlaylistContents)
-    getAllStartedOrCompleted.mockResolvedValue([201])
-    getProgressStateByIds.mockResolvedValue({ '201': 'in_progress' })
-
-    const result = await getProgressRows({ brand: 'brand1', limit: 8 })
-
-    expect(result).toHaveProperty('type', 'progress_rows')
-    expect(result).toHaveProperty('data');
-    expect(Array.isArray(result.data)).toBe(true)
-    expect(result.data.length).toBe(2)
-    expect(result.data[0]).toHaveProperty('id')
-    expect(result.data[0]).toHaveProperty('progressType')
-    expect(result.data[0]).toHaveProperty('header')
-    expect(result.data[0]).toHaveProperty('body')
-    expect(result.data[0]).toHaveProperty('cta')
-    expect(result.data[0].progressType).toBe('playlist')
-    expect(result.data[0].body).toHaveProperty('first_items_thumbnail_url')
-    expect(result.data[0].body).toHaveProperty('title')
-    expect(result.data[0].body).toHaveProperty('subtitle')
-    expect(result.data[0].cta).toHaveProperty('text')
-    expect(result.data[0].cta).toHaveProperty('action')
-
-  });
-
-  it('handles no progress', async () => {
-    fetchUserPlaylists.mockResolvedValue({ data: [] });
-    getAllStartedOrCompleted.mockResolvedValue([]);
-    fetchByRailContentIds.mockResolvedValue([]);
-    getProgressStateByIds.mockResolvedValue({});
-
-    const result = await getProgressRows({ brand: 'brand1', limit: 8 });
-    expect(result).toHaveProperty('type', 'progress_rows');
-    expect(result.data).toEqual([]);
-  });
-
-  it.skip('check progress rows logic', async () => {
-    // SKIPPED: Sanity mock data for course 280498 has empty children array.
-    // getNavigateTo returns null child — mock data needs children populated to test navigate-to logic.
-    fetchUserPlaylists.mockResolvedValue({ data: [] });
-    fetchByRailContentIds
-      .mockImplementationOnce(() => Promise.resolve(mockData_sanity_progress_content));
-    const sortedIds = Object.entries(mockData_progress_content)
-      .sort(([, a], [, b]) => b.last_update - a.last_update)
-      .map(([id]) => Number(id))
-    getAllStartedOrCompleted.mockResolvedValue(sortedIds)
-    getProgressStateByIds
-      .mockImplementationOnce(() => Promise.resolve({
-        "287853": "completed",
-        "287854": "completed",
-        "287855": "completed",
-        "287858": "completed",
-        "287859": ""
-      })) // course lessons
-       .mockImplementationOnce(() => Promise.resolve({
-         "257243": "started",
-         "257245": "started",
-         "257246": "",
-         "257247": "",
-         "257248": "",
-         "257249": "completed",
-         "257250": "completed",
-         "257251": "",
-         "257252": "",
-         "257253": "",
-         "257254": "",
-         "257255": "",
-         "257256": "",
-         "257257": "",
-         "257258": "",
-         "257259": "",
-         "257260": "",
-         "259235": "",
-         "259236": ""
-       })) //pack
-      .mockImplementationOnce(() => Promise.resolve({
-          "410479": "",
-          "410480": "completed",
-          "410481": "completed",
-          "410482": "",
-          "410483": "",
-          "410484": "",
-          "410485": "",
-          "410486": "",
-          "410487": ""
-        }) // challenge
-      );
-
-
-    const result = await getProgressRows({ brand: 'brand1', limit: 8 });
-    expect(fetchByRailContentIds).toHaveBeenCalledTimes(1);
-
-    expect(result).toHaveProperty('type', 'progress_rows');
-    expect(result.data.length).toBeGreaterThan(0);
-    expect(result.data.length).toBeLessThanOrEqual(8);
-    //course 280498
-    const lesson1Progress = result.data.find(row => row.id === 280498);
-    expect(lesson1Progress).toBeDefined();
-    expect(lesson1Progress.cta).toHaveProperty('text');
-    expect(lesson1Progress.cta.text.toLowerCase()).toContain('continue');
-    expect(lesson1Progress.cta.action).toHaveProperty('type');
-    expect(lesson1Progress.cta.action.type).toBe('course');
-    expect(lesson1Progress.cta.action.id).toBe(280498);
-    expect(lesson1Progress.cta.action.child).toBeDefined();
-    expect(lesson1Progress.cta.action.child.type).toBe('course-part');
-    expect(lesson1Progress.cta.action.child.id).toBe(287859);
-    //pack 257242
-    const lesson2Progress = result.data.find(row => row.id === 257242);
-    expect(lesson2Progress).toBeDefined();
-    expect(lesson2Progress.cta).toHaveProperty('text');
-    expect(lesson2Progress.cta.text.toLowerCase()).toContain('continue');
-    console.log(lesson2Progress.cta.action)
-    expect(lesson2Progress.cta.action).toHaveProperty('type');
-    expect(lesson2Progress.cta.action.type).toBe('pack');
-    expect(lesson2Progress.cta.action.id).toBe(257242);
-    expect(lesson2Progress.cta.action.child).toBeDefined();
-    expect(lesson2Progress.cta.action.child.type).toBe('pack-bundle');
-    expect(lesson2Progress.cta.action.child.child).toBeDefined();
-    expect(lesson2Progress.cta.action.child.child.type).toBe('pack-bundle-lesson');
-    expect(lesson2Progress.cta.action.child.child.id).toBe(257251);
-
-    //challenge 410478
-
-    const lesson3Progress = result.data.find(row => row.id === 410478);
-    expect(lesson3Progress).toBeDefined();
-    expect(lesson3Progress.cta).toHaveProperty('text');
-    expect(lesson3Progress.cta.text.toLowerCase()).toContain('continue');
-    expect(lesson3Progress.cta.action).toHaveProperty('type');
-    expect(lesson3Progress.cta.action.type).toBe('challenge');
-    expect(lesson3Progress.cta.action.id).toBe(410478);
-    expect(lesson3Progress.cta.action.child).toBeDefined();
-    expect(lesson3Progress.cta.action.child.type).toBe('challenge-part');
-    expect(lesson3Progress.cta.action.child.id).toBe(410479);
-
-    //completed play-along  316772
-    const lesson4Progress = result.data.find(row => row.id === 316772);
-    expect(lesson4Progress).toBeDefined();
-    expect(lesson4Progress.cta).toHaveProperty('text');
-    expect(lesson4Progress.cta.text).toContain('Replay Song');
-    expect(lesson4Progress.cta.action).toHaveProperty('type');
-    expect(lesson4Progress.cta.action.type).toBe('play-along');
-    expect(lesson4Progress.cta.action.id).toBe(316772);
-    expect(lesson4Progress.body.progressPercent).toBe(100);
-
-    //in progress quick-tips 325826
-    const lesson5Progress = result.data.find(row => row.id === 325826);
-    expect(lesson5Progress).toBeDefined();
-    expect(lesson5Progress.cta).toHaveProperty('text');
-    expect(lesson5Progress.cta.text).toContain('Continue');
-    expect(lesson5Progress.cta.action).toHaveProperty('type');
-    expect(lesson5Progress.cta.action.type).toBe('quick-tips');
-    expect(lesson5Progress.cta.action.id).toBe(325826);
-    expect(lesson5Progress.body.progressPercent).toBeLessThan(100);
-  });
-
-
-
-});
-
-