musora-content-services 1.0.116 → 1.0.118

package/src/services/config.js

@@ -19,6 +19,7 @@ let globalConfig = {
  * @param {string} config.sanityConfig.version - The API version to use.
  * @param {boolean} [config.sanityConfig.debug=false] - Optional flag to enable debug mode.
  * @param {boolean} [config.sanityConfig.useCachedAPI=true] - Optional flag to enable or disable the use of the cached API.
+ * @param {boolean} [config.sanityConfig.useDummyRailContentMethods=false] - Optional flag to use test harness for railcontent methods. Should only be used by jest tests.
  * @param {Object} config.railcontentConfig - Configuration for user services.
  * @param {string} config.railcontentConfig.token - The token for authenticating user-specific requests.
  * @param {string} config.railcontentConfig.userId - The user ID for fetching user-specific data.

package/src/services/railcontent.js

@@ -254,15 +254,6 @@ export async function fetchContentPageUserData(contentId) {
     }
 }
 
-function fetchAbsolute(url, params) { 
-    if(globalConfig.railcontentConfig.baseUrl) {
-        if (url.startsWith('/')) {
-            return fetch(globalConfig.railcontentConfig.baseUrl + url, params)
-        }
-    } 
-    return fetch(url, params);
-}
-
 export async function fetchUserContext() {
     let url = `/content/user_data_all`;
     const headers = {
@@ -270,7 +261,7 @@ export async function fetchUserContext() {
         'X-CSRF-TOKEN': globalConfig.railcontentConfig.token
     };
     try {
-        const response = await fetch(url, {headers});
+        const response = await fetchAbsolute(url, {headers});
         const result = await response.json();
         if (result) {
             console.log('fetchUserContext', result);
@@ -284,13 +275,25 @@ export async function fetchUserContext() {
     }
 }
 
+export async function fetchUserPermissions() {
+    //TODO: Should be investigate why throw 500 errors on MA
+    return [];
+    let url = `/content/user_data_permissions`;
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-CSRF-TOKEN': globalConfig.railcontentConfig.token
+    };
+    // in the case of an unauthorized user, we return empty permissions
+    return fetchHandler(url, 'get') ?? [];
+}
+
 export async function fetchHandler(url, method = "get") {
     const headers = {
         'Content-Type': 'application/json',
         'X-CSRF-TOKEN': globalConfig.railcontentConfig.token
     };
     try {
-        const response = await fetch(url, {method, headers});
+        const response = await fetchAbsolute(url, {method, headers});
         const result = await response.json();
         if (result) {
             return result;
@@ -299,8 +302,8 @@ export async function fetchHandler(url, method = "get") {
         }
     } catch (error) {
         console.error('Fetch error:', error);
-        return null;
     }
+    return null;
 }
 
 export async function fetchLikeContent(contentId) {
@@ -311,4 +314,13 @@ export async function fetchLikeContent(contentId) {
 export async function fetchUnlikeContent(contentId) {
     let url = `/content/${contentId}/unlike`;
     return await fetchHandler(url, "post");
+}
+
+function fetchAbsolute(url, params) {
+    if(globalConfig.railcontentConfig.baseUrl) {
+        if (url.startsWith('/')) {
+            return fetch(globalConfig.railcontentConfig.baseUrl + url, params)
+        }
+    }
+    return fetch(url, params);
 }

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,13 +594,14 @@ 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 ?
@@ -611,13 +609,16 @@ export async function fetchAllFilterOptions(
 
     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) ? metaData['allowableFilters'] : [];
+    const allowableFilters = metaData?.allowableFilters || [];
 
-    let dynamicFilterOptions = '';
-    allowableFilters.forEach(filter => {
-        const filterOption = getFilterOptions(filter, commonFilter, contentType);
-        dynamicFilterOptions += filterOption;
-    });
+    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 = `
         {
@@ -970,7 +971,7 @@ export async function fetchAllPacks(brand, sort = "-published_on", searchTerm =
   const query = buildQuery(
     filter,
     filterParams,
-    fields,
+    getFieldsForContentType('pack'),
     {
       logo_image_url: 'logo_image_url.asset->url',
       sortOrder: sortOrder,
@@ -1245,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}`;
@@ -1259,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;
@@ -1287,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');
       }
@@ -1297,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
@@ -1348,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.
@@ -1459,28 +1503,7 @@ function     buildEntityAndTotalQuery(
     }`;
     return query;
 }
-function processMetadata(brand, type, withFilters = false) {
-    const metadataElement = contentMetadata[brand]?.[type];
-    if (!metadataElement) {
-        return null;
-    }
-    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 processedData;
-}
 
 function getFilterOptions(option, commonFilter,contentType){
     let filterGroq = '';
@@ -1540,6 +1563,30 @@ function getFilterOptions(option, commonFilter,contentType){
     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 '';
+    }
+
+    // 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);
     });
 
@@ -518,7 +579,7 @@ describe('Filter Builder', function () {
     }
 
     test('fetchAllFilterOptions', async () => {
-        let response = await fetchAllFilterOptions('drumeo', '', '', '', 'song', '');
+        let response = await fetchAllFilterOptions('drumeo', [], '', '', 'song', '');
         log(response);
         expect(response.meta.filterOptions.difficulty).toBeDefined();
         expect(response.meta.filterOptions.genre).toBeDefined();
@@ -527,14 +588,14 @@ describe('Filter Builder', function () {
     });
 
     test('fetchAllFilterOptions-Rudiment', async () => {
-        let response = await fetchAllFilterOptions('drumeo', '', '', '', 'rudiment', '');
+        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', '');
+        let response = await fetchAllFilterOptions('drumeo', [], '', '', 'play-along', '');
         log(response);
         expect(response.meta.filterOptions.difficulty).toBeDefined();
         expect(response.meta.filterOptions.genre).toBeDefined();
@@ -542,11 +603,70 @@ describe('Filter Builder', function () {
     });
 
     test('fetchAllFilterOptions-Coaches', async () => {
-        let response = await fetchAllFilterOptions('drumeo', '', '', '', 'instructor', '');
+        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();
+    });
 });