chore: stop building entire curriculum when testing subset (freeCodeCamp#59599)

Author: ojeytonwilliams

curriculum/get-challenges.js

@@ -4,6 +4,7 @@ const util = require('util');
 const yaml = require('js-yaml');
 const { findIndex } = require('lodash');
 const readDirP = require('readdirp');
+const stringSimilarity = require('string-similarity');
 
 const { curriculum: curriculumLangs } =
   require('../shared/config/i18n').availableLangs;
@@ -176,7 +177,10 @@ const walk = (root, target, options, cb) => {
   });
 };
 
-exports.getChallengesForLang = async function getChallengesForLang(lang) {
+exports.getChallengesForLang = async function getChallengesForLang(
+  lang,
+  filters
+) {
   const invalidLang = !curriculumLangs.includes(lang);
   if (invalidLang)
     throw Error(`${lang} is not a accepted language.
@@ -192,11 +196,86 @@ Accepted languages are ${curriculumLangs.join(', ')}`);
     { type: 'directories', depth: 0 },
     buildSuperBlocks
   );
-  const cb = (file, curriculum) => buildChallenges(file, curriculum, lang);
+
+  const superBlocks = Object.keys(curriculum);
+  const blocksWithParent = Object.entries(curriculum).flatMap(
+    ([key, superBlock]) => {
+      const blocks = Object.entries(superBlock.blocks);
+      return blocks.map(([block, blockData]) => ({
+        block,
+        blockData,
+        superBlock: key
+      }));
+    }
+  );
+
+  const blocks = blocksWithParent.map(({ block }) => block);
+
+  let filteredCurriculum = curriculum;
+  const updatedFilters = { ...filters };
+  if (filters?.superBlock) {
+    const target = stringSimilarity.findBestMatch(
+      filters.superBlock,
+      superBlocks
+    ).bestMatch.target;
+
+    console.log('superBlock being tested:', target);
+
+    filteredCurriculum = {
+      [target]: curriculum[target]
+    };
+    updatedFilters.superBlock = target;
+  } else if (filters?.block) {
+    const target = stringSimilarity.findBestMatch(filters.block, blocks)
+      .bestMatch.target;
+
+    console.log('block being tested:', target);
+    const targetBlock = blocksWithParent.find(({ block }) => block === target);
+
+    filteredCurriculum = {
+      [targetBlock.superBlock]: {
+        blocks: {
+          [targetBlock.block]: targetBlock.blockData
+        }
+      }
+    };
+    updatedFilters.block = targetBlock.block;
+  } else if (filters?.challengeId) {
+    const blocksWithMeta = blocksWithParent.filter(
+      ({ blockData }) => blockData.meta
+    );
+    const container = blocksWithMeta.filter(({ block, blockData }) => {
+      return blockData.meta.challengeOrder.some(
+        ({ id }) => id === filters.challengeId
+      );
+    });
+
+    if (container.length === 0) {
+      throw new Error(`No block found with challengeId ${filters.challengeId}`);
+    }
+    if (container.length > 1) {
+      throw new Error(
+        `Multiple blocks found with challengeId ${filters.challengeId}`
+      );
+    }
+    const targetBlock = container[0];
+    filteredCurriculum = {
+      [targetBlock.superBlock]: {
+        blocks: {
+          [targetBlock.block]: targetBlock.blockData
+        }
+      }
+    };
+    updatedFilters.block = targetBlock.block;
+    updatedFilters.superBlock = targetBlock.superBlock;
+  }
+
+  const cb = (file, curriculum) =>
+    buildChallenges(file, curriculum, lang, updatedFilters);
   // fill the scaffold with the challenges
   return walk(
     root,
-    curriculum,
+    filteredCurriculum,
     { type: 'files', fileFilter: ['*.md', '*.yml'] },
     cb
   );
@@ -250,11 +329,17 @@ async function buildSuperBlocks({ path, fullPath }, curriculum) {
   return walk(fullPath, curriculum, { depth: 1, type: 'directories' }, cb);
 }
 
-async function buildChallenges({ path: filePath }, curriculum, lang) {
+async function buildChallenges({ path: filePath }, curriculum, lang, filters) {
   // path is relative to getChallengesDirForLang(lang)
   const block = getBlockNameFromPath(filePath);
+  if (filters?.block && block !== filters.block) {
+    return;
+  }
   const superBlockDir = getBaseDir(filePath);
   const superBlock = getSuperBlockFromDir(superBlockDir);
+  if (filters?.superBlock && superBlock !== filters.superBlock) {
+    return;
+  }
   let challengeBlock;
 
   // TODO: this try block and process exit can all go once errors terminate the
@@ -286,6 +371,9 @@ async function buildChallenges({ path: filePath }, curriculum, lang) {
     ? await parseCert(englishPath)
     : await createChallenge(filePath, meta);
 
+  // this builds the entire block, even if we only want one challenge, which is
+  // inefficient, but finding the next challenge without building the whole
+  // block is fiddly.
   challengeBlock.challenges = [...challengeBlock.challenges, challenge];
 }
 

curriculum/test/test-challenges.js

@@ -60,6 +60,28 @@ const { sortChallenges } = require('./utils/sort-challenges');
 
 const { flatten, isEmpty, cloneDeep } = lodash;
 
+if (
+  [
+    process.env.FCC_BLOCK,
+    process.env.FCC_CHALLENGE_ID,
+    process.env.FCC_SUPERBLOCK
+  ].filter(Boolean).length > 1
+) {
+  throw new Error(
+    `Please use at most single input from: block, challenge id, superblock.`
+  );
+}
+
+const testFilter = {
+  block: process.env.FCC_BLOCK ? process.env.FCC_BLOCK.trim() : undefined,
+  challengeId: process.env.FCC_CHALLENGE_ID
+    ? process.env.FCC_CHALLENGE_ID.trim()
+    : undefined,
+  superBlock: process.env.FCC_SUPERBLOCK
+    ? process.env.FCC_SUPERBLOCK.trim()
+    : undefined
+};
+
 // rethrow unhandled rejections to make sure the tests exit with non-zero code
 process.on('unhandledRejection', err => handleRejection(err));
 // If an uncaught exception gets here, then mocha is in an unexpected state. All
@@ -122,18 +144,6 @@ setup()
   .catch(err => handleRejection(err));
 
 async function setup() {
-  if (
-    [
-      process.env.FCC_BLOCK,
-      process.env.FCC_CHALLENGE_ID,
-      process.env.FCC_SUPERBLOCK
-    ].filter(Boolean).length > 1
-  ) {
-    throw new Error(
-      `Please use at most single input from: block, challenge id, superblock.`
-    );
-  }
-
   // liveServer starts synchronously
   liveServer.start({
     host: '127.0.0.1',
@@ -165,59 +175,21 @@ async function setup() {
 
   const lang = testedLang();
 
-  let challenges = await getChallenges(lang);
+  let challenges = await getChallenges(lang, testFilter);
 
   // the next few statements create a list of all blocks and superblocks
   // as they appear in the list of challenges
-  const blocks = challenges.map(({ block }) => block);
   const superBlocks = challenges.map(({ superBlock }) => superBlock);
-  const targetBlockStrings = [...new Set(blocks.filter(el => Boolean(el)))];
   const targetSuperBlockStrings = [
     ...new Set(superBlocks.filter(el => Boolean(el)))
   ];
 
-  // the next few statements will filter challenges based on command variables
-  if (process.env.FCC_SUPERBLOCK) {
-    const filter = stringSimilarity.findBestMatch(
-      process.env.FCC_SUPERBLOCK,
-      targetSuperBlockStrings
-    ).bestMatch.target;
-
-    console.log(`\nsuperBlock being tested: ${filter}`);
-    challenges = challenges.filter(
-      challenge => challenge.superBlock === filter
-    );
-
-    if (!challenges.length) {
-      throw new Error(`No challenges found with superBlock "${filter}"`);
-    }
-  }
-
-  if (process.env.FCC_BLOCK) {
-    const filter = stringSimilarity.findBestMatch(
-      process.env.FCC_BLOCK,
-      targetBlockStrings
-    ).bestMatch.target;
-
-    console.log(`\nblock being tested: ${filter}`);
-    challenges = challenges.filter(challenge => challenge.block === filter);
-
-    if (!challenges.length) {
-      throw new Error(`No challenges found with block "${filter}"`);
-    }
-  }
-
-  if (process.env.FCC_CHALLENGE_ID) {
-    console.log(
-      `\nChallenge Id being tested: ${process.env.FCC_CHALLENGE_ID.trim()}`
-    );
+  if (testFilter.challengeId) {
     const challengeIndex = challenges.findIndex(
-      challenge => challenge.id === process.env.FCC_CHALLENGE_ID.trim()
+      challenge => challenge.id === testFilter.challengeId
     );
     if (challengeIndex === -1) {
-      throw new Error(
-        `No challenge found with id "${process.env.FCC_CHALLENGE_ID}"`
-      );
+      throw new Error(`No challenge found with id "${testFilter.challengeId}"`);
     }
     const { solutions = [] } = challenges[challengeIndex];
     if (isEmpty(solutions)) {
@@ -269,16 +241,17 @@ function runTests(challengeData) {
   run();
 }
 
-async function getChallenges(lang) {
-  const challenges = await getChallengesForLang(lang).then(curriculum =>
-    Object.keys(curriculum)
-      .map(key => curriculum[key].blocks)
-      .reduce((challengeArray, superBlock) => {
-        const challengesForBlock = Object.keys(superBlock).map(
-          key => superBlock[key].challenges
-        );
-        return [...challengeArray, ...flatten(challengesForBlock)];
-      }, [])
+async function getChallenges(lang, filters) {
+  const challenges = await getChallengesForLang(lang, filters).then(
+    curriculum =>
+      Object.keys(curriculum)
+        .map(key => curriculum[key].blocks)
+        .reduce((challengeArray, superBlock) => {
+          const challengesForBlock = Object.keys(superBlock).map(
+            key => superBlock[key].challenges
+          );
+          return [...challengeArray, ...flatten(challengesForBlock)];
+        }, [])
   );
   // This matches the order Gatsby uses (via a GraphQL query). Ideally both
   // should be sourced and sorted using a single query, but we're not there yet.