musora-content-services 1.0.105 → 1.0.108

package/test/sanityQueryService.test.js

@@ -9,33 +9,36 @@ const {
     fetchAllSongs,
     fetchSongFilterOptions,
     fetchSongCount,
-    fetchWorkouts,
     fetchNewReleases,
     fetchUpcomingEvents,
     fetchByRailContentId,
     fetchByRailContentIds,
     fetchAll,
     fetchAllFilterOptions,
-    fetchMethodNextLesson,
-    fetchMethodChildrenIds,
-    fetchNextPreviousLesson,
+    fetchFoundation,
+    fetchMethods,
+    fetchMethod,
     fetchRelatedLessons,
+    fetchAllPacks,
     fetchPackAll,
-    fetchPackChildren,
     fetchLessonContent,
-    getSortOrder,
-    fetchParentByRailContentId,
+    fetchCourseOverview,
     fetchChildren,
-    fetchMethod,
-    fetchMethods,
-    fetchFoundation,
-    fetchAllPacks,
-    fetchPacksAll,
+    fetchParentByRailContentId,
+    fetchLiveEvent,
+    fetchChallengeOverview,
     fetchCoachLessons,
     fetchByReference,
-    fetchScheduledReleases
+    fetchScheduledReleases,
+    getSortOrder,
+    fetchShowsData,
+    fetchMetadata
 } = require('../src/services/sanity.js');
 
+const {
+    FilterBuilder,
+} = require('../src/filterBuilder.js');
+
 describe('Sanity Queries', function () {
     beforeEach(() => {
         const config = {
@@ -73,7 +76,14 @@ describe('Sanity Queries', function () {
 
     test('fetchByRailContentId', async () => {
         const id = 380094;
-        const response = await fetchByRailContentId(id);
+        const response = await fetchByRailContentId(id, "song");
+        expect(response.id).toBe(id);
+    });
+
+    test('fetchChallengeOverview', async () => {
+        const id = 402197;
+        const response = await fetchChallengeOverview(id);
+        expect(response.lessons).toBeDefined();
         expect(response.id).toBe(id);
     });
 
@@ -88,12 +98,36 @@ describe('Sanity Queries', function () {
 
     });
 
+    test('fetchUpcomingEvents', async () => {
+        const response = await fetchUpcomingEvents('drumeo', {});
+        expect(response.length).toBeGreaterThan(0);
+    });
+
+    test('fetchUpcomingNewReleases', async () => {
+        const response = await fetchNewReleases('drumeo');
+        expect(response.length).toBeGreaterThan(0);
+    });
+
+
     test('fetchLessonContent', async () => {
         const id = 380094;
         const response = await fetchLessonContent(id);
         expect(response.id).toBe(id);
     });
 
+
+    test('fetchCourseOverview', async () => {
+        const id = 310414;
+        const response = await fetchCourseOverview(id);
+        expect(response.id).toBe(id);
+        expect(response.type).toBe('course');
+    });
+
+    test('fetchSongCount', async () => {
+        const response = await fetchSongCount('drumeo');
+        expect(response).toBeGreaterThan(1000);
+    });
+
     test('fetchAllSongs', async () => {
         const response = await fetchAllSongs('drumeo', {});
         log(response);
@@ -102,6 +136,13 @@ describe('Sanity Queries', function () {
         expect(response.entity[0].instrumentless).toBeDefined();
     });
 
+    test('fetchSongFilterOptions', async () => {
+        const response = await fetchSongFilterOptions('drumeo', {});
+        log(response);
+        expect(response.genre).toBeDefined();
+        expect(response.difficulty).toBeDefined();
+    });
+
     test('fetchAllSongsGroupByArtist', async () => {
         const response = await fetchAllSongs('drumeo', {groupBy:"artist"});
         expect(response.entity[0].lessons[0].soundslice).toBeDefined();
@@ -110,6 +151,12 @@ describe('Sanity Queries', function () {
     }, 100000);
 
 
+    test('fetchNewReleases', async () => {
+        const response = await fetchNewReleases('drumeo');
+        log(response);
+        expect(response[0].id).toBeDefined();
+    });
+
     test('fetchAllWorkouts', async () => {
         const response = await fetchAll('drumeo', 'workout',{});
         log(response);
@@ -159,10 +206,10 @@ describe('Sanity Queries', function () {
 
     test('fetchRelatedLessons', async () => {
         const id = 380094;
-        const document = await fetchByRailContentId(id);
+        const document = await fetchByRailContentId(id, 'song');
         let artist = document.artist.name;
         const response = await fetchRelatedLessons(id, 'singeo');
-        let relatedDoc = await fetchByRailContentId(response.related_lessons[0].id);
+        let relatedDoc = await fetchByRailContentId(response.related_lessons[0].id, 'song');
         // match on artist or any genre
         let isMatch = artist === relatedDoc.artist.name;
         isMatch = isMatch || document.genre.some((genre) => {
@@ -274,7 +321,7 @@ describe('Sanity Queries', function () {
     });
 
     test('fetchCoachLessons', async () => {
-        const response = await fetchCoachLessons('drumeo',233797);
+        const response = await fetchCoachLessons('drumeo',411493, {});
         expect(response.entity.length).toBeGreaterThan(0);
     });
 
@@ -310,4 +357,162 @@ describe('Sanity Queries', function () {
         log(response);
         expect(response.entity[0].web_url_path).toContain('/drumeo/coaches/');
     });
+
+    test('fetchShowsData', async () => {
+        const response = await fetchShowsData('singeo');
+        log(response);
+        expect(response.length).toBeGreaterThan(0);
+    });
+
+    test('fetchMetadata', async () => {
+        const response = await fetchMetadata('drumeo','song');
+        log(response);
+        expect(response.tabs.length).toBeGreaterThan(0);
+    });
+
+});
+
+describe('Filter Builder', function () {
+
+    test('baseConstructor', async () => {
+        const filter = 'railcontent_id = 111'
+        let builder = new FilterBuilder(filter);
+        let finalFilter = builder.buildFilter(filter);
+        let clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+        expect(clauses[1].field).toBe('published_on');
+
+        builder = new FilterBuilder();
+        finalFilter = builder.buildFilter(filter);
+        clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].field).toBe('published_on');
+        expect(clauses[0].operator).toBe('<=');
+    });
+
+    test('withOnlyFilterAvailableStatuses', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder =  FilterBuilder.withOnlyFilterAvailableStatuses(filter,['published', 'unlisted']);
+        const finalFilter = builder.buildFilter();
+        const clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+        expect(clauses[1].field).toBe('status');
+        expect(clauses[1].operator).toBe('in');
+        // not sure I like this
+        expect(clauses[1].condition).toBe("['published','unlisted']");
+        expect(clauses[2].field).toBe('published_on');
+    });
+
+    test('withContentStatusAndFutureScheduledContent', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder =  new FilterBuilder(filter,{
+            availableContentStatuses: ['published', 'unlisted', 'scheduled'],
+            getFutureScheduledContentsOnly: true});
+        const finalFilter = builder.buildFilter();
+        const clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+        expect(clauses[1].field).toBe('(status'); // extra ( because it's a multi part filter
+        expect(clauses[1].operator).toBe('in');
+        // getFutureScheduledContentsOnly doesn't make a filter that's splicable, so we match on the more static string
+        const expected = "['published','unlisted'] || (status == 'scheduled' && published_on >=";
+        console.log(clauses[1].condition);
+        console.log(expected)
+        const isMatch = finalFilter.includes(expected);
+        expect(isMatch).toBeTruthy();
+    });
+
+    test('withUserPermissions', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder = new FilterBuilder(filter,
+            { user: {
+                    user: {},
+                    permissions: [91, 92],
+                }});
+        const finalFilter = builder.buildFilter();
+        const expected = "references(*[_type == 'permission' && railcontent_id in [91,92]]._id)"
+        const isMatch = finalFilter.includes(expected);
+        expect(isMatch).toBeTruthy();
+    });
+
+    test('withUserPermissionsForPlusUser', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder = new FilterBuilder(filter,
+            {
+                user: getPlusUser()
+            });
+        const finalFilter = builder.buildFilter();
+        const expected = "references(*[_type == 'permission' && railcontent_id in [91,92]]._id)"
+        const isMatch = finalFilter.includes(expected);
+        expect(isMatch).toBeTruthy();
+    });
+
+    test('withPermissionBypass', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder = new FilterBuilder(filter,
+            {
+                user: getPlusUser(),
+                bypassPermissions:true
+            });
+        const finalFilter = builder.buildFilter();
+        const expected = "references(*[_type == 'permission' && railcontent_id in [91,92]]._id)"
+        const isMatch = finalFilter.includes(expected);
+        expect(isMatch).toBeFalsy();
+        const clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].field).toBe('railcontent_id');
+        expect(clauses[1].field).toBe('published_on');
+    });
+
+
+    test('withPublishOnRestrictions', async () => {
+        // testing dates is a pain more frustration than I'm willing to deal with, so I'm just testing operators.
+
+        const filter = 'railcontent_id = 111'
+        let builder =  new FilterBuilder(filter, {
+            user: {},
+            pullFutureContent: true,
+        });
+
+        let finalFilter = builder.buildFilter();
+        let clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+
+        expect(clauses[1].field).toBe('published_on');
+        expect(clauses[1].operator).toBe('<=');
+        const restrictionDate = new Date(clauses[1].condition)
+        const now = new Date();
+        expect(now.getTime()).toBeLessThan(restrictionDate.getTime());
+
+        builder = new FilterBuilder(filter,
+            {
+                user: {},
+                getFutureContentOnly: true,
+        });
+        finalFilter = builder.buildFilter();
+        clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+        expect(clauses[1].field).toBe('published_on');
+        expect(clauses[1].operator).toBe('>=');
+    });
+
+    function getPlusUser() {
+        return {
+            permissions: [91,92],
+        }
+    }
+
+    function spliceFilterForAnds(filter) {
+        // this will not correctly split complex filters with && and || conditions.
+        let phrases = filter.split(' && ');
+        let clauses= [];
+        phrases.forEach((phrase) => {
+            let  field = phrase.substring(0, phrase.indexOf(' '));
+            //if(field.charAt(0) === '(' ) field = field.substring(1);
+            const temp = phrase.substring(phrase.indexOf(' ') + 1);
+            const operator = temp.substring(0, temp.indexOf(' '));
+            let condition = temp.substring(temp.indexOf(' ') + 1);
+            //if(condition.charAt(condition.length) === ')') condition = condition.slice(-1);
+            clauses.push({phrase, field, operator, condition});
+        });
+        return clauses;
+    }
+
 });