musora-content-services 1.0.99 → 1.0.101

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.0.101](https://github.com/railroadmedia/musora-content-services/compare/v1.0.100...v1.0.101) (2024-09-17)
+
+### [1.0.100](https://github.com/railroadmedia/musora-content-services/compare/v1.0.99...v1.0.100) (2024-09-16)
+
 ### [1.0.99](https://github.com/railroadmedia/musora-content-services/compare/v1.0.98...v1.0.99) (2024-09-12)
 
 ### [1.0.98](https://github.com/railroadmedia/musora-content-services/compare/v1.0.97...v1.0.98) (2024-09-12)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "1.0.99",
+  "version": "1.0.101",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "scripts": {

package/src/contentTypeConfig.js

@@ -46,6 +46,7 @@ const contentWithSortField = {
 let contentTypeConfig = {
     'song': {
         'fields': [
+            'album',
             'soundslice',
             'instrumentless',
         ],
@@ -78,13 +79,15 @@ let contentTypeConfig = {
             '"instructors": instructor[]->name',
             `"description": ${descriptionField}`,
             'resource',
+            'xp',
+            'total_xp',
             `"lessons": child[]->{
                 "id": railcontent_id,
                 title,
                 "image": thumbnail.asset->url,
                 "instructors": instructor[]->name,
                 length_in_seconds,
-            }`, 
+            }`,
         ]
     },
     'method': {
@@ -182,9 +185,19 @@ let contentTypeConfig = {
     },
     'instructor': {
         'fields': [
-            'name',
+            '"coach_top_banner_image": coach_top_banner_image.asset->url',
+            '"coach_bottom_banner_image": coach_bottom_banner_image.asset->url',
             '"coach_card_image": coach_card_image.asset->url',
-            'focus'
+            '"coach_featured_image": coach_featured_image.asset->url',
+            '"coach_top_banner_image": coach_top_banner_image.asset->url',
+            'focus',
+            'focus_text',
+            'forum_thread_id',
+            'long_bio',
+            'name',
+            'short_bio',
+            'bands',
+            'endorsements',
         ]
     },
     // content with just the added 'instructors' Field
@@ -215,6 +228,34 @@ let contentTypeConfig = {
     'exploring-beats': contentWithSortField,
 }
 
+function getNewReleasesTypes(brand) {
+    const baseNewTypes = ["student-review", "student-reviews", "student-focus", "coach-stream", "live", "question-and-answer", "boot-camps", "quick-tips", "workout", "challenge", "challenge-part", "podcasts", "pack", "song", "learning-path-level", "play-along", "course", "unit"];
+    switch(brand) {        
+        case 'drumeo':
+            return [...baseNewTypes, "drum-fest-international-2022", "spotlight", "the-history-of-electronic-drums", "backstage-secrets", "student-collaborations", "live-streams", "solos", "gear-guides", "performances", "in-rhythm", "challenges", "on-the-road", "diy-drum-experiments", "rhythmic-adventures-of-captain-carson", "study-the-greats", "rhythms-from-another-planet", "tama-drums", "paiste-cymbals", "behind-the-scenes", "exploring-beats", "sonor-drums"];
+        case 'guitareo': 
+            return [...baseNewTypes, "archives", "recording", "chords-and-scales"];
+        case 'pianote':    
+        case 'singeo':
+        default:
+            return baseNewTypes
+        }
+}
+
+function getUpcomingEventsTypes(brand) {
+    const baseLiveTypes = ["student-review", "student-reviews", "student-focus", "coach-stream", "live", "question-and-answer", "boot-camps", "quick-tips", "recording", "pack-bundle-lesson"];
+    switch(brand) {
+        case 'drumeo': 
+            return [...baseLiveTypes, "drum-fest-international-2022", "spotlight", "the-history-of-electronic-drums", "backstage-secrets", "student-collaborations", "live-streams", "podcasts", "solos", "gear-guides", "performances", "in-rhythm", "challenges", "on-the-road", "diy-drum-experiments", "rhythmic-adventures-of-captain-carson", "study-the-greats", "rhythms-from-another-planet", "tama-drums", "paiste-cymbals", "behind-the-scenes", "exploring-beats", "sonor-drums"];
+        case 'guitareo':
+            return [...baseLiveTypes, "archives"];
+        case 'pianote':
+        case 'singeo':
+        default:
+            return baseLiveTypes;
+  }
+}
+
 function artistOrInstructorName(key='artist_name') {
     return `'${key}': coalesce(artist->name, instructor[0]->name)`;
 }
@@ -264,4 +305,6 @@ module.exports = {
     DEFAULT_FIELDS,
     assignmentsField,
     filtersToGroq,
+    getNewReleasesTypes,
+    getUpcomingEventsTypes,
 }

package/src/index.d.ts

@@ -28,17 +28,19 @@ import {
     fetchLessonContent,
     fetchCourseOverview,
     fetchChallengeOverview,
+    fetchScheduledReleases,
     fetchArtistLessons,
     fetchGenreLessons,
   } from './services/sanity.js';
 
-import {
+import { 
     fetchCompletedState, 
     fetchAllCompletedStates,
     fetchContentInProgress,
+    fetchCompletedContent,
     fetchVimeoData,
     fetchContentPageUserData,
-} from "./services/railcontent";
+} from './services/railcontent.js';
 
 import { initializeService } from './services/config.js';
 
@@ -79,7 +81,9 @@ declare module 'musora-content-services' {
         fetchCompletedState, 
         fetchAllCompletedStates,
         fetchContentInProgress,
+        fetchCompletedContent,
         fetchContentPageUserData,
+        fetchScheduledReleases,
         fetchArtistLessons,
         fetchGenreLessons,
     }

package/src/index.js

@@ -35,6 +35,7 @@ import {
   fetchChallengeOverview,
   fetchCoachLessons,
   fetchByReference,
+  fetchScheduledReleases,
   fetchArtistLessons,
   fetchGenreLessons,
 } from './services/sanity.js';
@@ -91,6 +92,7 @@ export {
     fetchContentPageUserData,
     fetchCoachLessons,
     fetchByReference,
+    fetchScheduledReleases,
     fetchArtistLessons,
     fetchGenreLessons,
 }

package/src/services/railcontent.js

@@ -261,4 +261,54 @@ function fetchAbsolute(url, params) {
         }
     } 
     return fetch(url, params);
+}
+
+export async function fetchUserContext() {
+    let url = `/content/user_data_all`;
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-CSRF-TOKEN': globalConfig.railcontentConfig.token
+    };
+    try {
+        const response = await fetch(url, {headers});
+        const result = await response.json();
+        if (result) {
+            console.log('fetchUserContext', result);
+            return result;
+        } else {
+            console.log('result not json');
+        }
+    } catch (error) {
+        console.error('Fetch error:', error);
+        return null;
+    }
+}
+
+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 result = await response.json();
+        if (result) {
+            return result;
+        } else {
+            console.log('result not json');
+        }
+    } catch (error) {
+        console.error('Fetch error:', error);
+        return null;
+    }
+}
+
+export async function fetchLikeContent(contentId) {
+    let url = `/content/${contentId}/like`;
+    return await fetchHandler(url, "post");
+}
+
+export async function fetchUnlikeContent(contentId) {
+    let url = `/content/${contentId}/unlike`;
+    return await fetchHandler(url, "post");
 }

package/src/services/sanity.js

@@ -9,7 +9,9 @@ import {
     contentTypeConfig,
     DEFAULT_FIELDS,
     getFieldsForContentType,
-    filtersToGroq
+    filtersToGroq,
+    getUpcomingEventsTypes,
+    getNewReleasesTypes,
 } from "../contentTypeConfig";
 import {globalConfig} from "./config";
 
@@ -238,7 +240,7 @@ export async function fetchSongCount(brand) {
  * @example
  * fetchWorkouts('drumeo')
  *   .then(workouts => console.log(workouts))
- *   .catch(error => console.error(error));
+ *   .catch(error => console.error(error)); 
  */
 export async function fetchWorkouts(brand) {
   const fields = getFieldsForContentType('workout');
@@ -254,14 +256,8 @@ export async function fetchWorkouts(brand) {
 * @returns {Promise<Object|null>} - The fetched new releases data or null if not found.
 */
 export async function fetchNewReleases(brand, { page = 1, limit = 10, sort="-published_on" } = {}) {
-  const newTypes = {
-      'drumeo': ["drum-fest-international-2022", "spotlight", "the-history-of-electronic-drums", "backstage-secrets", "quick-tips", "question-and-answer", "student-collaborations", "live-streams", "live", "podcasts", "solos", "boot-camps", "gear-guides", "performances", "in-rhythm", "challenges", "on-the-road", "diy-drum-experiments", "rhythmic-adventures-of-captain-carson", "study-the-greats", "rhythms-from-another-planet", "tama-drums", "paiste-cymbals", "behind-the-scenes", "exploring-beats", "sonor-drums", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"],
-      'pianote': ["student-review", "student-reviews", "question-and-answer", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"],
-      'guitareo': ["student-review", "student-reviews", "question-and-answer", "archives", "recording", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"],
-      'singeo': ["student-review", "student-reviews", "question-and-answer", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"],
-      'default': ["student-review", "student-reviews", "question-and-answer", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"]
-  };
-  const typesString = arrayJoinWithQuotes(newTypes[brand] ?? newTypes['default']);
+  const newTypes = getNewReleasesTypes(brand);
+  const typesString = arrayJoinWithQuotes(newTypes);
   const start = (page - 1) * limit;
   const end = start + limit;
   const sortOrder = getSortOrder(sort);
@@ -297,15 +293,8 @@ export async function fetchNewReleases(brand, { page = 1, limit = 10, sort="-pub
 *   .catch(error => console.error(error));
 */
 export async function fetchUpcomingEvents(brand, { page = 1, limit = 10 } = {}) {
-  const baseLiveTypes = ["student-review", "student-reviews", "student-focus", "coach-stream", "live", "question-and-answer", "student-review", "boot-camps", "recording", "pack-bundle-lesson"];
-  const liveTypes = {
-      'drumeo': [...baseLiveTypes, "drum-fest-international-2022", "spotlight", "the-history-of-electronic-drums", "backstage-secrets", "quick-tips", "student-collaborations", "live-streams", "podcasts", "solos", "gear-guides", "performances", "in-rhythm", "challenges", "on-the-road", "diy-drum-experiments", "rhythmic-adventures-of-captain-carson", "study-the-greats", "rhythms-from-another-planet", "tama-drums", "paiste-cymbals", "behind-the-scenes", "exploring-beats", "sonor-drums"],
-      'pianote': baseLiveTypes,
-      'guitareo': [...baseLiveTypes, "archives"],
-      'singeo': baseLiveTypes,
-      'default': baseLiveTypes
-  };
-  const typesString = arrayJoinWithQuotes(liveTypes[brand] ?? liveTypes['default']);
+  const liveTypes = getUpcomingEventsTypes(brand);
+  const typesString = arrayJoinWithQuotes(liveTypes);
   const now = getSanityDate(new Date());
   const start = (page - 1) * limit;
   const end = start + limit;
@@ -325,6 +314,45 @@ export async function fetchUpcomingEvents(brand, { page = 1, limit = 10 } = {})
   return fetchSanity(query, true);
 }
 
+/**
+ * Fetch scheduled releases for a specific brand.
+ *
+ * @param {string} brand - The brand for which to fetch scheduled releasess.
+ * @returns {Promise<Object|null>} - A promise that resolves to an array of scheduled release objects or null if not found.
+ *
+ * @example
+ * fetchScheduledReleases('drumeo', {
+ *   page: 2,
+ *   limit: 20,
+ * })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function fetchScheduledReleases(brand, { page = 1, limit = 10 }) {
+  const upcomingTypes = getUpcomingEventsTypes(brand);
+  const newTypes = getNewReleasesTypes(brand);
+
+  const scheduledTypes = merge(upcomingTypes, newTypes)
+  const typesString = arrayJoinWithQuotes(scheduledTypes);
+  const now = getSanityDate(new Date());
+  const start = (page - 1) * limit;
+  const end = start + limit;
+  const query = `*[_type in [${typesString}] && brand == '${brand}' && status in ['published','scheduled'] && published_on > '${now}']{
+      "id": railcontent_id,
+      title,
+      "image": thumbnail.asset->url,
+      "artist_name": instructor[0]->name,
+      "artists": instructor[]->name,
+      difficulty,
+      difficulty_string,
+      length_in_seconds,
+      published_on,
+      "type": _type,
+      web_url_path,
+  } | order(published_on asc)[${start}...${end}]`;
+  return fetchSanity(query, true);
+}
+
 /**
 * Fetch content by a specific Railcontent ID.
 *
@@ -415,7 +443,7 @@ export async function fetchAll(brand, type, {
     const searchFilter = searchTerm
         ? groupBy !== "" ?
           `&& (^.name match "${searchTerm}*" || title match "${searchTerm}*")`
-          : `&& (artist->name match "${searchTerm}*" || instructor[]->name match "${searchTerm}*" || title match "${searchTerm}*")`
+          : `&& (artist->name match "${searchTerm}*" || instructor[]->name match "${searchTerm}*" || title match "${searchTerm}*" || name match "${searchTerm}*")`
         : "";
 
     // Construct the included fields filter, replacing 'difficulty' with 'difficulty_string'
@@ -499,8 +527,9 @@ export function getSortOrder(sort= '-published_on', groupBy)
         case "slug":
             sortOrder = groupBy ? 'name' : "title";
             break;
+        case "name":
         case "popularity":
-            sortOrder = "popularity";
+            sortOrder = sort;
             break;
         case "published_on":
         default:
@@ -664,6 +693,7 @@ export async function fetchMethod(brand, slug) {
         "type": _type,
         "description": ${descriptionField},
         "url": web_url_path,
+        web_url_path,
         xp,
       }
   } | order(published_on asc)`
@@ -821,7 +851,13 @@ export async function fetchLessonContent(railContentId) {
             "coach_profile_image":thumbnail_url.asset->url
           },
           "instructors":instructor[]->name,
-          instructor[]->,
+          "instructor": instructor[]->{
+            "id":_id,
+            name,
+            short_bio,
+            web_url_path,
+            "coach_card_image": coach_card_image.asset->url,
+          },
           ${assignmentsField}
           video,
           length_in_seconds
@@ -851,6 +887,30 @@ export async function fetchRelatedLessons(railContentId, brand) {
   return fetchSanity(query, false);
 }
 
+/**
+* Fetch related method lessons for a specific lesson by RailContent ID and type.
+* @param {string} railContentId - The RailContent ID of the current lesson.
+* @param {string} brand - The current brand.
+* @returns {Promise<Object>|null>} - The fetched related lessons
+*/
+export async function fetchRelatedMethodLessons(railContentId, brand) {
+  const query = `*[railcontent_id == ${railContentId} && brand == "${brand}"]{
+      "id":_id,
+      "related_lessons": *[references(^._id)][0].child[]->{
+        "id": railcontent_id,
+        "type": _type,
+        title,
+        "description": description[0].children[0].text, // Extraer texto plano
+        "thumbnail_url": thumbnail.asset->url,
+        "url": web_url_path,
+        difficulty,
+        difficulty_string,
+      }
+    }
+  }`
+  return fetchSanity(query, false);
+}
+
 /**
 * Fetch all packs.
 * @param {string} brand - The brand for which to fetch packs.
@@ -1224,6 +1284,13 @@ function getSanityDate(date) {
   return date.toISOString();
 }
 
+const merge = (a, b, predicate = (a, b) => a === b) => {
+  const c = [...a]; // copy to avoid side effects
+  // add all items from B to copy C if they're not already present
+  b.forEach((bItem) => (c.some((cItem) => predicate(bItem, cItem)) ? null : c.push(bItem)))
+  return c;
+}
+
 function checkSanityConfig(config) {
   if (!config.sanityConfig.token) {
       console.warn('fetchSanity: The "token" property is missing in the config object.');

package/src/services/userContext.js

@@ -0,0 +1,105 @@
+import {fetchUserContext, fetchLikeContent, fetchUnlikeContent} from "./railcontent";
+
+const StorageKey = "userContext";
+let userContext = null;
+let cache = null;
+
+export function init(localCache) {
+    cache = localCache;
+}
+
+export function version() {
+    ensureLocalContextLoaded();
+    return userContext.version;
+}
+
+async function getUserContext() {
+    ensureLocalContextLoaded();
+    if (userContext) {
+        verifyContextIsValid();
+    }
+    if (!userContext) {
+        await fetchFromServer();
+    }
+    return userContext;
+}
+
+function verifyContextIsValid() {
+
+}
+
+function ensureLocalContextLoaded() {
+    if (userContext) return;
+    let localData = cache.getItem(StorageKey);
+    if (localData) {
+        userContext = JSON.parse(localData);
+    }
+}
+
+function updateLocalContext(contentId, updateFunction) {
+    ensureLocalContextLoaded();
+    if (userContext) {
+        let contentData = userContext.data[contentId] ?? [];
+        updateFunction(contentData);
+        userContext.data[contentId] = contentData;
+        userContext.version++;
+        let data = JSON.stringify(userContext);
+        cache.setItem(StorageKey, data);
+    }
+}
+
+async function fetchFromServer() {
+    let data = await fetchUserContext();
+    userContext = JSON.parse(data);
+    cache.setItem(StorageKey, data);
+}
+
+
+function transformData(data, contentId) {
+    let transformed = [];
+    transformed["contentId"] = contentId;
+    transformed["liked"] = (data && data.l) ?? 0;
+    return transformed;
+}
+
+export async function fetchContentData(contentId) {
+    let userContext = await getUserContext();
+    let data = userContext.data[contentId];
+    data = transformData(data, contentId);
+    return data;
+}
+
+export function clearCache() {
+    userContext = null;
+    cache.setItem(StorageKey, null);
+}
+
+export function testClearLocal() {
+    userContext = null;
+}
+
+export async function likeContent(contentId) {
+    updateLocalContext(contentId,
+        function (contentData) {
+            contentData.l = 1;
+        }
+    );
+
+    let result = await fetchLikeContent(contentId);
+    if (result.version !== userContext.version) {
+        clearCache();
+    }
+}
+
+export async function unlikeContent(contentId) {
+    updateLocalContext(contentId,
+        function (contentData) {
+            contentData.l = 0;
+        }
+    );
+
+    let result = await fetchUnlikeContent(contentId);
+    if (result.version !== userContext.version) {
+        clearCache();
+    }
+}

package/test/localStorageMock.js

@@ -0,0 +1,21 @@
+export class LocalStorageMock {
+    constructor() {
+        this.store = {};
+    }
+
+    clear() {
+        this.store = {};
+    }
+
+    getItem(key) {
+        return this.store[key] || null;
+    }
+
+    setItem(key, value) {
+        this.store[key] = String(value);
+    }
+
+    removeItem(key) {
+        delete this.store[key];
+    }
+}

package/test/sanityQueryService.test.js

@@ -32,6 +32,7 @@ const {
     fetchPacksAll,
     fetchCoachLessons,
     fetchByReference,
+    fetchScheduledReleases
 } = require('../src/services/sanity.js');
 
 describe('Sanity Queries', function () {
@@ -286,4 +287,9 @@ describe('Sanity Queries', function () {
         const response = await fetchByReference('drumeo', { includedFields: ['is_featured'] });
         expect(response.entity.length).toBeGreaterThan(0);
     });
+
+    test('fetchScheduledReleases', async () => {
+        const response = await fetchScheduledReleases('drumeo', {});
+        expect(response.length).toBeGreaterThan(0);
+    });
 });

package/test/userContext.test.js

@@ -0,0 +1,86 @@
+const railContentModule = require('../src/services/railcontent.js')
+const userContextModule = require('../src/services/userContext.js');
+import {LocalStorageMock} from "./localStorageMock";
+
+describe('userContext', function () {
+    let mock = null;
+    const testVersion = 1;
+    beforeEach(() => {
+        userContextModule.init(new LocalStorageMock());
+        mock = jest.spyOn(railContentModule, 'fetchUserContext');
+        var json = `{"version":${testVersion},"data":{"308516":{"l":1},"308515":{"p":100},"308514":{"p":13},"308518":{"p":100}}}`;
+        mock.mockImplementation(() => json);
+    });
+
+    test('contentLiked', async () => {
+        let contentData = await userContextModule.fetchContentData(308516);
+        expect(contentData.liked).toBe(1);
+    });
+
+    test('contentDoesNotExist', async () => {
+        //fetch content that does not exist
+        let contentData = await userContextModule.fetchContentData(121111);
+        expect(contentData.liked).toBe(0);
+    });
+
+    test('ensureOnlyOneServerFetchRequest', async () => {
+        userContextModule.clearCache();
+        await userContextModule.fetchContentData(308516);
+        await userContextModule.fetchContentData(308514);
+        expect(railContentModule.fetchUserContext).toHaveBeenCalledTimes(1);
+    });
+
+    test('ensureDataPulledFromLocalCache', async () => {
+        userContextModule.clearCache();
+        await userContextModule.fetchContentData(308516);
+        userContextModule.testClearLocal();
+        await userContextModule.fetchContentData(308514);
+        expect(railContentModule.fetchUserContext).toHaveBeenCalledTimes(1);
+    });
+
+    // test('hashExpiration', async () => {
+    //     userContextModule.clearCache();
+    //     await userContextModule.fetchContentData(testHash308516);
+    //     let newHash = "8g9qg5wn3e5s5oi69q6g22et9w6g34t5";
+    //     await userContextModule.fetchContentData(newHash, 308516);
+    //     expect(railContentModule.fetchUserContext).toHaveBeenCalledTimes(2);
+    // });
+
+    test('likeContent', async () => {
+        mock = jest.spyOn(railContentModule, 'fetchLikeContent');
+        var json = JSON.parse(`{"version":${testVersion + 1}}`);
+        mock.mockImplementation(() => json);
+
+        userContextModule.clearCache();
+        await userContextModule.fetchContentData(308515);
+        await userContextModule.likeContent(308515);
+        let contentData = await userContextModule.fetchContentData(308515);
+        expect(contentData.liked).toBe(1);
+
+        userContextModule.testClearLocal();
+        contentData = await userContextModule.fetchContentData(308515);
+        expect(contentData.liked).toBe(1);
+
+        expect(userContextModule.version()).toBe(testVersion + 1);
+    });
+
+
+    test('unlikeContent', async () => {
+        mock = jest.spyOn(railContentModule, 'fetchUnlikeContent');
+        var json = JSON.parse(`{"version":${testVersion + 1}}`);
+        mock.mockImplementation(() => json);
+
+        userContextModule.clearCache();
+        await userContextModule.fetchContentData(308516);
+        await userContextModule.unlikeContent(308516);
+        let contentData = await userContextModule.fetchContentData(308516);
+        expect(contentData.liked).toBe(0);
+
+        userContextModule.testClearLocal();
+        contentData = await userContextModule.fetchContentData(308516);
+        expect(contentData.liked).toBe(0);
+
+        expect(userContextModule.version()).toBe(testVersion + 1);
+    });
+
+});