support multiple featured tracks with versioning in raw YML, but only one featured track per version after processing

Author: sarahs

lib/process-learning-tracks.js

@@ -9,10 +9,13 @@ module.exports = async function processLearningTracks (rawLearningTracks, contex
   let featuredTrack
 
   for await (const rawTrackName of rawLearningTracks) {
-    // Track names in frontmatter may include Liquid conditionals
+    let isFeaturedTrack = false
+
+    // Track names in frontmatter may include Liquid conditionals.
     const renderedTrackName = await renderContent(rawTrackName, context, renderOpts)
     if (!renderedTrackName) continue
 
+    // Find the data for the current product and track name.
     const track = context.site.data['learning-tracks'][context.currentProduct][renderedTrackName]
     if (!track) continue
 
@@ -25,15 +28,22 @@ module.exports = async function processLearningTracks (rawLearningTracks, contex
       guides: await getLinkData(track.guides, context)
     }
 
+    // Determine if this is the featured track.
     if (track.featured_track) {
-      // Set the featured track, which is not included in the array of other learning tracks.
-      featuredTrack = learningTrack
-    } else {
-      // Only add the track to the array of tracks if there are guides in this version.
-      if (learningTrack.guides.length) {
-        learningTracks.push(learningTrack)
+      // Featured track properties may include Liquid conditionals with versioning, so we need to parse to
+      // determine if the featured track is relevant for this version.
+      const parsed = await renderContent(track.featured_track, context, renderOpts)
+      if (parsed === 'true') {
+        featuredTrack = learningTrack
+        isFeaturedTrack = true
       }
     }
+
+    // Only add the track to the array of tracks if there are guides in this version
+    // and it's not the featured track.
+    if (learningTrack.guides.length && !isFeaturedTrack) {
+      learningTracks.push(learningTrack)
+    }
   }
 
   return { featuredTrack, learningTracks }

tests/content/lint-files.js

@@ -14,6 +14,8 @@ const ghesReleaseNotesSchema = require('../helpers/schemas/release-notes-schema'
 const learningTracksSchema = require('../helpers/schemas/learning-tracks-schema')
 const renderContent = require('../../lib/render-content')
 const { execSync } = require('child_process')
+const allVersions = Object.keys(require('../../lib/all-versions'))
+const enterpriseServerVersions = allVersions.filter(v => v.startsWith('enterprise-server@'))
 
 const rootDir = path.join(__dirname, '../..')
 const contentDir = path.join(rootDir, 'content')
@@ -723,8 +725,25 @@ describe('lint learning tracks', () => {
         expect(errors.length, errorMessage).toBe(0)
       })
 
-      it('has at least one featured track', () => {
-        expect(Object.values(dictionary).filter(entry => entry.featured_track).length).toBe(1)
+      it.only('has one and only one featured track per version', async () => {
+        const featuredTracks = {}
+        const context = { enterpriseServerVersions }
+
+        await Promise.all(allVersions.map(async (version) => {
+          const featuredTracksPerVersion = (await Promise.all(Object.values(dictionary).map(async (entry) => {
+            if (!entry.featured_track) return
+            context.currentVersion = version
+            return renderContent(entry.featured_track, context, { textOnly: true, encodeEntities: true })
+          })))
+            .filter(val => val === 'true')
+
+          featuredTracks[version] = featuredTracksPerVersion
+        }))
+
+        Object.entries(featuredTracks).forEach(([version, arrayOfTracks]) => {
+          const errorMessage = `Featured learning track not found for ${version} in ${yamlAbsPath}`
+          expect(arrayOfTracks.length, errorMessage).toBe(1)
+        })
       })
 
       it('contains valid liquid', () => {

tests/unit/page.js

@@ -6,6 +6,7 @@ const allVersions = require('../../lib/all-versions')
 const enterpriseServerReleases = require('../../lib/enterprise-server-releases')
 const nonEnterpriseDefaultVersion = require('../../lib/non-enterprise-default-version')
 const { latest } = require('../../lib/enterprise-server-releases')
+const enterpriseServerVersions = Object.keys(allVersions).filter(v => v.startsWith('enterprise-server@'))
 
 const getLinkData = require('../../lib/get-link-data')
 jest.mock('../../lib/get-link-data')
@@ -168,7 +169,7 @@ describe('Page class', () => {
       const context = {
         currentVersion: `enterprise-server@${enterpriseServerReleases.latest}`,
         currentLanguage: 'en',
-        enterpriseServerVersions: Object.keys(allVersions).filter(id => id.startsWith('enterprise-server@'))
+        enterpriseServerVersions
       }
       let rendered = await page.render(context)
       let $ = cheerio.load(rendered)
@@ -353,19 +354,22 @@ describe('Page class', () => {
         currentLanguage: 'en',
         currentProduct: 'snowbird',
         currentVersion: nonEnterpriseDefaultVersion,
+        enterpriseServerVersions,
         site: {
           data: {
             'learning-tracks': {
               snowbird: {
                 track_1: {
                   title: 'title',
                   description: 'description',
-                  guides
+                  guides,
+                  featured_track: '{% if currentVersion == "free-pro-team@latest" %}true{% else %}false{% endif %}'
                 },
                 track_2: {
                   title: 'title',
                   description: 'description',
-                  guides
+                  guides,
+                  featured_track: '{% if enterpriseServerVersions contains currentVersion %}true{% else %}false{% endif %}'
                 },
                 dotcom_only_track: {
                   title: 'title',
@@ -382,19 +386,30 @@ describe('Page class', () => {
           }
         }
       }
+      // Test that Liquid versioning is respected during rendering.
+      // Start with Dotcom.
       await page.render(context)
       // To actually render the guides in this test, we would have to load context.pages and context.redirects;
       // To avoid that we can just test that the function was called with the expected data.
       expect(getLinkData).toHaveBeenCalledWith(guides, context)
-      expect(page.learningTracks).toHaveLength(3)
-      expect(page.learningTracks.find(track => track.trackName === 'dotcom_only_track')).toBeTruthy()
-
-      // Test that Liquid versioning is respected
+      // Tracks for dotcom should exclude enterprise_only_track and the featured track_1.
+      expect(page.learningTracks).toHaveLength(2)
+      const dotcomTrackNames = page.learningTracks.map(t => t.trackName)
+      expect(dotcomTrackNames.includes('track_2')).toBe(true)
+      expect(dotcomTrackNames.includes('dotcom_only_track')).toBe(true)
+      expect(page.featuredTrack.trackName === 'track_1').toBeTruthy()
+      expect(page.featuredTrack.trackName === 'track_2').toBeFalsy()
+
+      // Switch to Enterprise.
       context.currentVersion = `enterprise-server@${latest}`
       await page.render(context)
-      expect(page.learningTracks).toHaveLength(3)
-      expect(page.learningTracks.find(track => track.trackName === 'dotcom_only_track')).toBeFalsy()
-      expect(page.learningTracks.find(track => track.trackName === 'enterprise_only_track')).toBeTruthy()
+      // Tracks for enterprise should exclude dotcom_only_track and the featured track_2.
+      expect(page.learningTracks).toHaveLength(2)
+      const ghesTrackNames = page.learningTracks.map(t => t.trackName)
+      expect(ghesTrackNames.includes('track_1')).toBe(true)
+      expect(ghesTrackNames.includes('enterprise_only_track')).toBe(true)
+      expect(page.featuredTrack.trackName === 'track_1').toBeFalsy()
+      expect(page.featuredTrack.trackName === 'track_2').toBeTruthy()
     })
   })