musora-content-services 1.0.115 → 1.0.118

package/src/services/sanity.js

@@ -11,13 +11,17 @@ import {
     getFieldsForContentType,
     filtersToGroq,
     getUpcomingEventsTypes,
-    getNewReleasesTypes,
     showsTypes,
-    contentMetadata
+    getNewReleasesTypes,
 } from "../contentTypeConfig";
+
+import {
+    processMetadata,
+} from "../contentMetaData";
+
 import {globalConfig} from "./config";
 
-import { fetchAllCompletedStates, fetchCurrentSongComplete } from './railcontent.js';
+import { fetchUserPermissions, fetchAllCompletedStates, fetchCurrentSongComplete } from './railcontent.js';
 import {arrayToStringRepresentation, FilterBuilder} from "../filterBuilder";
 
 /**
@@ -495,58 +499,51 @@ export async function fetchAll(brand, type, {
 
     // Determine the group by clause
     let query = "";
+    let entityFieldsString = "";
+    let filter = "";
     if (groupBy !== "" && isGroupByOneToOne) {
-        let webUrlPath = 'artists';
-        query = `
-        {
-            "total": count(*[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id == ${groupBy}._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]),
-            "entity": *[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id == ${groupBy}._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]
-            {
+        const webUrlPath = 'artists';
+        const lessonsFilter = `_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}`;
+        entityFieldsString = `
                 'id': _id,
                 'type': _type,
                 name,
                 'head_shot_picture_url': thumbnail_url.asset->url,
                 'web_url_path': '/${brand}/${webUrlPath}/'+name+'?included_fieds[]=type,${type}',
-                'all_lessons_count': count(*[_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id),
-                'lessons': *[_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]{
+                'all_lessons_count': count(*[${lessonsFilter}]._id),
+                'lessons': *[${lessonsFilter}]{
                     ${fieldsString},
                     ${groupBy}
                 }[0...20]
-            }
-            |order(${sortOrder})
-            [${start}...${end}]
-        }`;
+        `;
+        filter = `_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id == ${groupBy}._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0`;
     } else if (groupBy !== "") {
-        let webUrlPath = (groupBy == 'genre')?'/genres':'';
-        query = `
-        {
-            "total": count(*[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]),
-            "entity": *[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]
-            {
+        const webUrlPath = (groupBy == 'genre')?'/genres':'';
+        const lessonsFilter = `brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}`;
+        entityFieldsString = `
                 'id': _id,
                 'type': _type,
                 name,
                 'head_shot_picture_url': thumbnail_url.asset->url,
                 'web_url_path': select(defined(web_url_path)=> web_url_path +'?included_fieds[]=type,${type}',!defined(web_url_path)=> '/${brand}${webUrlPath}/'+name+'/${webUrlPathType}'),
-                'all_lessons_count': count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id),
-                'lessons': *[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]{
+                'all_lessons_count': count(*[${lessonsFilter}]._id),
+                'lessons': *[${lessonsFilter}]{
                     ${fieldsString},
                     ${groupBy}
-                }[0...20]
-            }
-            |order(${sortOrder})
-            [${start}...${end}]
-        }`;
+                }[0...20]`;
+        filter = `_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0`;
     } else {
-        query = `
-        {
-            "entity": *[brand == "${brand}" ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}] | order(${sortOrder}) [${start}...${end}] {
-                ${fieldsString},
-            },
-            "total": count(*[brand == "${brand}" ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}])
-        }
-    `;
+        filter = `brand == "${brand}" ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}`
+        entityFieldsString = fieldsString;
     }
+    query = buildEntityAndTotalQuery(
+        filter,
+        entityFieldsString,
+        {
+            sortOrder: sortOrder,
+            start: start,
+            end: end,
+        });
 
     return fetchSanity(query, true);
 }
@@ -597,40 +594,39 @@ export function getSortOrder(sort= '-published_on', groupBy)
 */
 export async function fetchAllFilterOptions(
     brand,
-    filters,
+    filters = [],
     style,
     artist,
     contentType,
     term,
     progressIds = undefined
 ) {
+    filters = Array.isArray(filters) ? filters : [];
     const includedFieldsFilter = filters?.length > 0 ? filtersToGroq(filters) : undefined;
 
     const progressFilter = progressIds !== undefined ?
         `&& railcontent_id in [${progressIds.join(',')}]` : "";
 
     const commonFilter = `_type == '${contentType}' && brand == "${brand}"${style ? ` && '${style}' in genre[]->name` : ''}${artist ? ` && artist->name == '${artist}'` : ''} ${progressFilter} ${includedFieldsFilter ? includedFieldsFilter : ''}`;
+    const metaData = processMetadata(brand, contentType, true);
+    const allowableFilters = metaData?.allowableFilters || [];
+
+    const dynamicFilterOptions = allowableFilters.map(filter => {
+        // Create a modified common filter for each allowable filter
+        let includedFieldsFilterWithoutSelectedOption = filters?.length > 0 ? filtersToGroq(filters, filter) : undefined;
+        const commonFilterWithoutSelectedOption = `_type == '${contentType}' && brand == "${brand}"${(style && filter !== "style") ? ` && '${style}' in genre[]->name` : ''}${(artist && filter !== "artist") ? ` && artist->name == '${artist}'` : ''} ${includedFieldsFilterWithoutSelectedOption ? includedFieldsFilterWithoutSelectedOption : ''}`;
+
+        // Call getFilterOptions with the modified common filter
+        return getFilterOptions(filter, commonFilterWithoutSelectedOption,  contentType);
+    }).join(' ');
+
     const query = `
         {
           "meta": {
             "totalResults": count(*[${commonFilter}
               ${term ? ` && (title match "${term}" || album match "${term}" || artist->name match "${term}" || genre[]->name match "${term}")` : ''}]),
             "filterOptions": {
-              "difficulty": [
-                  {"type": "Introductory", "count": count(*[${commonFilter} && difficulty_string == "Introductory"])},
-                  {"type": "Beginner", "count": count(*[${commonFilter} && difficulty_string == "Beginner"])},
-                  {"type": "Intermediate", "count": count(*[${commonFilter} && difficulty_string == "Intermediate" ])},
-                  {"type": "Advanced", "count": count(*[${commonFilter} && difficulty_string == "Advanced" ])},
-                  {"type": "Expert", "count": count(*[${commonFilter} && difficulty_string == "Expert" ])}
-              ][count > 0],
-              "instrumentless": [
-                  {"type": "Full Song Only", "count": count(*[${commonFilter} && instrumentless == false ])},
-                  {"type": "Instrument Removed", "count": count(*[${commonFilter} && instrumentless == true ])}
-              ][count > 0],
-              "genre": *[_type == 'genre' && '${contentType}' in filter_types] {
-                "type": name,
-                "count": count(*[${commonFilter} && references(^._id)])
-              }[count > 0]
+              ${dynamicFilterOptions}
             }
         }
       }`;
@@ -971,10 +967,11 @@ export async function fetchAllPacks(brand, sort = "-published_on", searchTerm =
   const sortOrder = getSortOrder(sort);
   const filter = `_type == 'pack' && brand == '${brand}' && title match "${searchTerm}*"`
   const filterParams = {};
+  const fields = getFieldsForContentType('pack');
   const query = buildQuery(
     filter,
     filterParams,
-    fields,
+    getFieldsForContentType('pack'),
     {
       logo_image_url: 'logo_image_url.asset->url',
       sortOrder: sortOrder,
@@ -1249,13 +1246,13 @@ export async function fetchGenreLessons(brand, name, contentType, {
 }
 
 
-
 /**
- * Fetch data from the Sanity API based on a provided query.
  *
  * @param {string} query - The GROQ query to execute against the Sanity API.
  * @param {boolean} isList - Whether to return an array or a single result.
- * @returns {Promise<Object|null>} - A promise that resolves to the fetched data or null if an error occurs or no results are found.
+ * @param {Function} [customPostProcess=null] - custom post process callback
+ * @param {boolean} [processNeedAccess=true] - execute the needs_access callback
+ * @returns {Promise<*|null>} - A promise that resolves to the fetched data or null if an error occurs or no results are found.
  *
  * @example
  * const query = `*[_type == "song"]{title, artist->name}`;
@@ -1263,7 +1260,13 @@ export async function fetchGenreLessons(brand, name, contentType, {
  *   .then(data => console.log(data))
  *   .catch(error => console.error(error));
  */
-export async function fetchSanity(query, isList) {
+
+export async function fetchSanity(query,
+                                  isList,
+                                  { customPostProcess = null,
+                                    processNeedAccess = true,} = {}
+) {
+
   // Check the config object before proceeding
   if (!checkSanityConfig(globalConfig)) {
       return null;
@@ -1291,7 +1294,9 @@ export async function fetchSanity(query, isList) {
           if (globalConfig.sanityConfig.debug) {
               console.log("fetchSanity Results:", result);
           }
-          return isList ? result.result : result.result[0];
+          let results = isList ? result.result : result.result[0];
+          results = processNeedAccess ? await needsAccessDecorator(results) : results;
+          return customPostProcess ? customPostProcess(results) : results;
       } else {
           throw new Error('No results found');
       }
@@ -1301,6 +1306,41 @@ export async function fetchSanity(query, isList) {
   }
 }
 
+async function needsAccessDecorator(results)
+{
+    if (globalConfig.sanityConfig.useDummyRailContentMethods) return results;
+    let userPermissions = await getUserPermissions();
+    userPermissions = new Set(userPermissions);
+    if (Array.isArray(results)) {
+        results.forEach((result) => {
+            result['need_access'] = doesUserNeedAccessToContent(result, userPermissions);
+        });
+    } else {
+        results['need_access'] = doesUserNeedAccessToContent(results, userPermissions);
+    }
+    return results;
+}
+
+function doesUserNeedAccessToContent(result, userPermissions)
+{
+    const permissions =  new Set(result.permission_id ?? []);
+    if (permissions.length === 0) {
+        return false;
+    }
+    for (let permission of permissions) {
+        if (userPermissions.has(permission)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+async function getUserPermissions()
+{
+    return await fetchUserPermissions();
+}
+
+
 /**
  * Fetch CatalogueMetadata from Sanity. This information may be duplicated in the contentTypeConfig.js.
  * It's an ongoing discussion (Aug 2024), but it's been included here if necessary
@@ -1352,7 +1392,7 @@ export async function fetchShowsData(brand) {
 }
 
 /**
- * Fetch metadata from the contentTypeConfig.js based on brand and type.
+ * Fetch metadata from the contentMetaData.js based on brand and type.
  *
  * @param {string} brand - The brand for which to fetch metadata.
  * @param {string} type - The type for which to fetch metadata.
@@ -1463,27 +1503,88 @@ function     buildEntityAndTotalQuery(
     }`;
     return query;
 }
-function processMetadata(brand, type, withFilters = false) {
-    const metadataElement = contentMetadata[brand]?.[type];
-    if (!metadataElement) {
-        return null;
+
+
+function getFilterOptions(option, commonFilter,contentType){
+    let filterGroq = '';
+    switch (option) {
+        case "difficulty":
+            filterGroq = ` 
+                "difficulty": [
+        {"type": "Introductory", "count": count(*[${commonFilter} && difficulty_string == "Introductory"])},
+        {"type": "Beginner", "count": count(*[${commonFilter} && difficulty_string == "Beginner"])},
+        {"type": "Intermediate", "count": count(*[${commonFilter} && difficulty_string == "Intermediate" ])},
+        {"type": "Advanced", "count": count(*[${commonFilter} && difficulty_string == "Advanced" ])},
+        {"type": "Expert", "count": count(*[${commonFilter} && difficulty_string == "Expert" ])}
+        ][count > 0],`;
+            break;
+        case "genre":
+        case "essential":
+        case "focus":
+        case "theory":
+        case "topic":
+        case "lifestyle":
+        case "creativity":
+            filterGroq = `
+            "${option}": *[_type == '${option}' && '${contentType}' in filter_types] {
+            "type": name,
+                "count": count(*[${commonFilter} && references(^._id)])
+        }[count > 0],`;
+            break;
+        case "instrumentless":
+            filterGroq = `
+            "${option}":  [
+                  {"type": "Full Song Only", "count": count(*[${commonFilter} && instrumentless == false ])},
+                  {"type": "Instrument Removed", "count": count(*[${commonFilter} && instrumentless == true ])}
+              ][count > 0],`;
+            break;
+        case "gear":
+            filterGroq = `
+            "${option}":  [
+                  {"type": "Practice Pad", "count": count(*[${commonFilter} && gear match 'Practice Pad' ])},
+                  {"type": "Drum-Set", "count": count(*[${commonFilter} && gear match 'Drum-Set'])}
+              ][count > 0],`;
+            break;
+        case "bpm":
+            filterGroq = `
+            "${option}":  [
+                  {"type": "50-90", "count": count(*[${commonFilter} && bpm > 50 && bpm < 91])},
+                  {"type": "91-120", "count": count(*[${commonFilter} && bpm > 90 && bpm < 121])},
+                  {"type": "121-150", "count": count(*[${commonFilter} && bpm > 120 && bpm < 151])},
+                  {"type": "151-180", "count": count(*[${commonFilter} && bpm > 150 && bpm < 181])},
+                  {"type": "180+", "count": count(*[${commonFilter} && bpm > 180])},
+              ][count > 0],`;
+            break;
+        default:
+            filterGroq = "";
+            break;
     }
-    const processedData = {
-        type,
-        thumbnailUrl: metadataElement.thumbnailUrl || null,
-        name: metadataElement.name || null,
-        description: metadataElement.description || null
-    };
-
-    if (withFilters) {
-        Object.keys(metadataElement).forEach(key => {
-            if ( !['thumbnailUrl', 'name', 'description'].includes(key) ) {
-                processedData[key] = metadataElement[key];
-            }
-        });
+
+    return filterGroq;
+}
+
+function cleanUpGroq(query) {
+    // Split the query into clauses based on the logical operators
+    const clauses = query.split(/(\s*&&|\s*\|\|)/).map(clause => clause.trim());
+
+    // Filter out empty clauses
+    const filteredClauses = clauses.filter(clause => clause.length > 0);
+
+    // Check if there are valid conditions in the clauses
+    const hasConditions = filteredClauses.some(clause => !clause.match(/^\s*&&\s*|\s*\|\|\s*$/));
+
+    if (!hasConditions) {
+        // If no valid conditions, return an empty string or the original query
+        return '';
     }
 
-    return processedData;
+    // Remove occurrences of '&& ()'
+    const cleanedQuery = filteredClauses.join(' ')
+        .replace(/&&\s*\(\)/g, '')
+        .replace(/(\s*&&|\s*\|\|)(?=\s*[\s()]*$|(?=\s*&&|\s*\|\|))/g, '')
+        .trim();
+
+    return cleanedQuery;
 }
 
 

package/test/sanityQueryService.test.js

@@ -1,4 +1,6 @@
 import {initializeService} from '../src/services/config.js';
+import {getFieldsForContentType} from "../src/contentTypeConfig";
+import {fetchSanity} from "../src/services/sanity";
 import {log} from './log.js';
 
 const {
@@ -14,6 +16,7 @@ const {
     fetchByRailContentId,
     fetchByRailContentIds,
     fetchAll,
+    fetchAllOld,
     fetchAllFilterOptions,
     fetchFoundation,
     fetchMethods,
@@ -39,6 +42,10 @@ const {
     FilterBuilder,
 } = require('../src/filterBuilder.js');
 
+const {
+    processMetadata,
+} = require('../src/contentMetaData.js');
+
 describe('Sanity Queries', function () {
     beforeEach(() => {
         const config = {
@@ -48,7 +55,8 @@ describe('Sanity Queries', function () {
                 dataset: process.env.SANITY_DATASET,
                 useCachedAPI: process.env.SANITY_USE_CACHED_API === 'true' || true,
                 version: '2021-06-07',
-                debug: process.env.DEBUG === 'true' || false
+                debug: process.env.DEBUG === 'true' || false,
+                useDummyRailContentMethods: true,
             }
         };
         initializeService(config);
@@ -61,6 +69,7 @@ describe('Sanity Queries', function () {
 
     });
 
+
     test('fetchArtists', async () => {
         const response = await fetchArtists('drumeo');
         const artistNames = response.map((x) => x.name);
@@ -72,9 +81,29 @@ describe('Sanity Queries', function () {
         const response = await fetchSongArtistCount('drumeo');
         log(response);
         expect(response).toBeGreaterThan(1000);
+    }, 10000);
+
+    test('fetchSanity-WithPostProcess', async () => {
+        const id = 380094;
+        const query = `*[railcontent_id == ${id}]{
+        ${getFieldsForContentType('song')}
+          }`
+        const newSlug = 'keysmash1';
+        const newField = 1
+        const postProcess = (result) => {
+            result['new_field'] = newField;
+            result['slug'] = newSlug;
+            return result;
+        };
+        const response = await fetchSanity(query, false, {customPostProcess: postProcess});
+        log(response);
+        expect(response.id).toBe(id);
+        expect(response.new_field).toBe(newField);
+        expect(response.slug).toBe(newSlug);
     });
 
-    test('fetchByRailContentId', async () => {
+
+    test('fetchSanityPostProcess', async () => {
         const id = 380094;
         const response = await fetchByRailContentId(id, "song");
         expect(response.id).toBe(id);
@@ -85,6 +114,7 @@ describe('Sanity Queries', function () {
         const response = await fetchChallengeOverview(id);
         expect(response.lessons).toBeDefined();
         expect(response.id).toBe(id);
+
     });
 
     test('fetchByRailContentIds', async () => {
@@ -327,6 +357,37 @@ describe('Sanity Queries', function () {
 
     test('fetchAll-IncludedFields', async () => {
         let response = await fetchAll('drumeo', 'instructor',{includedFields: ['is_active']});
+        console.log(response);
+        expect(response.entity.length).toBeGreaterThan(0);
+    });
+
+    test('fetchAll-IncludedFields-multiple', async () => {
+        let response = await fetchAll('drumeo', 'course',{includedFields: ['essential,Dynamics','essential,Timing','difficulty,Beginner']});
+        log(response);
+        expect(response.entity.length).toBeGreaterThan(0);
+    });
+
+    test('fetchAll-IncludedFields-playalong-multiple', async () => {
+        let response = await fetchAll('drumeo', 'play-along',{includedFields: ['bpm,91-120','bpm,181+','genre,Blues']});
+        log(response);
+        expect(response.entity.length).toBeGreaterThan(0);
+    });
+
+    test('fetchAll-IncludedFields-rudiment-multiple-gear', async () => {
+        let response = await fetchAll('drumeo', 'rudiment',{includedFields: ['gear,Drum-Set','gear,Practice Pad']});
+        log(response);
+        expect(response.entity.length).toBeGreaterThan(0);
+    });
+
+    test('fetchAll-IncludedFields-coaches-multiple-focus', async () => {
+        let response = await fetchAll('drumeo', 'instructor',{includedFields: ['focus,drumline','focus,recording']});
+        log(response);
+        expect(response.entity.length).toBeGreaterThan(0);
+    });
+
+    test('fetchAll-IncludedFields-songs-multiple-instrumentless', async () => {
+        let response = await fetchAll('drumeo', 'song',{includedFields: ['instrumentless,true','instrumentless,false']});
+        log(response);
         expect(response.entity.length).toBeGreaterThan(0);
     });
 
@@ -517,4 +578,95 @@ describe('Filter Builder', function () {
         return clauses;
     }
 
+    test('fetchAllFilterOptions', async () => {
+        let response = await fetchAllFilterOptions('drumeo', [], '', '', 'song', '');
+        log(response);
+        expect(response.meta.filterOptions.difficulty).toBeDefined();
+        expect(response.meta.filterOptions.genre).toBeDefined();
+        expect(response.meta.filterOptions.lifestyle).toBeDefined();
+        expect(response.meta.filterOptions.instrumentless).toBeDefined();
+    });
+
+    test('fetchAllFilterOptions-Rudiment', async () => {
+        let response = await fetchAllFilterOptions('drumeo', [], '', '', 'rudiment', '');
+        log(response);
+        expect(response.meta.filterOptions.gear).toBeDefined();
+        expect(response.meta.filterOptions.genre).toBeDefined();
+        expect(response.meta.filterOptions.topic).toBeDefined();
+    });
+    test('fetchAllFilterOptions-PlayAlong', async () => {
+        let response = await fetchAllFilterOptions('drumeo', [], '', '', 'play-along', '');
+        log(response);
+        expect(response.meta.filterOptions.difficulty).toBeDefined();
+        expect(response.meta.filterOptions.genre).toBeDefined();
+        expect(response.meta.filterOptions.bpm).toBeDefined();
+    });
+
+    test('fetchAllFilterOptions-Coaches', async () => {
+        let response = await fetchAllFilterOptions('drumeo', [], '', '', 'instructor', '');
+        log(response);
+        expect(response.meta.filterOptions.focus).toBeDefined();
+        expect(response.meta.filterOptions.focus.length).toBeGreaterThan(0);
+        expect(response.meta.filterOptions.genre).toBeDefined();
+        expect(response.meta.filterOptions.genre.length).toBeGreaterThan(0);
+    });
+
+    test('fetchAllFilterOptions-filter-selected', async () => {
+        let response = await fetchAllFilterOptions('drumeo', ['theory,notation','theory,time signatures','creativity,Grooves','creativity,Fills & Chops','difficulty,Beginner','difficulty,Intermediate','difficulty,Expert'], '', '', 'course', '');
+        log(response);
+        expect(response.meta.filterOptions).toBeDefined();
+    });
+});
+
+describe('MetaData', function () {
+
+    test('customBrandTypeExists', async () => {
+        const metaData = processMetadata('guitareo', 'recording');
+        expect(metaData.type).toBe('recording');
+        expect(metaData.name).toBe('Archives');
+        expect(metaData.description).toBeDefined();
+    });
+
+    test('invalidContentType', async () => {
+        const metaData = processMetadata('guitareo', 'not a real type');
+        expect(metaData).toBeNull();
+    });
+
+    test('onlyCommon', async () => {
+        const guitareoMetaData = processMetadata('guitareo', 'challenge');
+        const drumeoMetaData = processMetadata('drumeo', 'challenge');
+        expect(guitareoMetaData).toStrictEqual(drumeoMetaData);
+        expect(guitareoMetaData.type).toBe('challenge');
+        expect(guitareoMetaData.name).toBe('Challenges');
+    });
+
+    test('withCommon', async () => {
+        const guitareoMetaData = processMetadata('guitareo', 'instructor');
+        const drumeoMetaData = processMetadata('drumeo', 'instructor');
+        expect(guitareoMetaData.description).not.toBe(drumeoMetaData.description);
+        guitareoMetaData.description = ''
+        drumeoMetaData.description = ''
+        expect(guitareoMetaData).toStrictEqual(drumeoMetaData);
+    });
+
+    test('withWithoutFilters', async () => {
+        let metaData = processMetadata('singeo', 'student-review', true);
+        expect(metaData.type).toBeDefined()
+        expect(metaData.name).toBeDefined()
+        expect(metaData.description).toBeDefined();
+        expect(metaData.thumbnailUrl).toBeDefined();
+        expect(metaData.tabs).toBeDefined();
+        metaData = processMetadata('singeo', 'student-review', false);
+        expect(metaData.type).toBeDefined()
+        expect(metaData.name).toBeDefined()
+        expect(metaData.description).toBeDefined();
+        expect(metaData.tabs).not.toBeDefined();
+    });
+
+    test('nulled', async () => {
+        let metaData = processMetadata('drumeo', 'student-review');
+        expect(metaData).toBeNull();
+        metaData = processMetadata('singeo', 'student-review');
+        expect(metaData).not.toBeNull();
+    });
 });