Fix(challenges): Only show beta on map in dev

common/app/routes/challenges/redux/fetch-challenges-saga.js

@@ -1,4 +1,5 @@
 import { Observable } from 'rx';
+import debug from 'debug';
 import { challengeSelector } from './selectors';
 import types from './types';
 import {
@@ -7,13 +8,18 @@ import {
   updateCurrentChallenge,
   initMap
 } from './actions';
-import { createMapUi } from '../utils';
+import {
+  createMapUi,
+  filterComingSoonBetaFromEntities
+} from '../utils';
 import {
   delayedRedirect,
   createErrorObservable
 } from '../../../redux/actions';
 import createNameIdMap from '../../../../utils/create-name-id-map';
 
+const isDev = debug.enabled('fcc:*');
+
 const { fetchChallenge, fetchChallenges, replaceChallenge } = types;
 
 export default function fetchChallengesSaga(action$, getState, { services }) {
@@ -58,12 +64,16 @@ export default function fetchChallengesSaga(action$, getState, { services }) {
               redirect ? delayedRedirect(redirect) : null
             );
           }
+          const filteredEntities = filterComingSoonBetaFromEntities(
+            entities,
+            isDev
+          );
           return Observable.of(
             fetchChallengesCompleted(
-              createNameIdMap(entities),
+              createNameIdMap(filteredEntities),
               result
             ),
-            initMap(createMapUi(entities, result)),
+            initMap(createMapUi(filteredEntities, result)),
           );
         })
         .catch(createErrorObservable);

common/app/routes/challenges/utils.js

@@ -252,6 +252,31 @@ export function getMouse(e, [dx, dy]) {
   return [pageX - dx, pageY - dy];
 }
 
+export function filterCommingSoonBetaChallenge(
+  isDev = false,
+  { isComingSoon, isBeta }
+) {
+  return !(isComingSoon || isBeta) ||
+    isDev;
+}
+
+export function filterComingSoonBetaFromEntities(
+  { challenge: challengeMap, ...rest },
+  isDev = false
+) {
+  const filter = filterCommingSoonBetaChallenge.bind(null, isDev);
+  return {
+    ...rest,
+    challenge: Object.keys(challengeMap)
+      .map(dashedName => challengeMap[dashedName])
+      .filter(filter)
+      .reduce((challengeMap, challenge) => {
+        challengeMap[challenge.dashedName] = challenge;
+        return challengeMap;
+      }, {})
+  };
+}
+
 // interface Node {
 //   isHidden: Boolean,
 //   children: Void|[ ...Node ],

common/app/routes/challenges/utils.test.js

@@ -4,6 +4,8 @@ import {
   getNextChallenge,
   getFirstChallengeOfNextBlock,
   getFirstChallengeOfNextSuperBlock,
+  filterCommingSoonBetaChallenge,
+  filterComingSoonBetaFromEntities,
   createMapUi,
   traverseMapUi,
   getNode,
@@ -858,6 +860,91 @@ test('common/app/routes/challenges/utils', function(t) {
       );
     });
   });
+  t.test('filterCommingSoonBetaChallenge', t => {
+    t.plan(4);
+    t.test('should return true when not coming-soon/beta', t => {
+      let isDev;
+      t.ok(filterCommingSoonBetaChallenge(isDev, {}));
+      t.ok(filterCommingSoonBetaChallenge(true, {}));
+      t.end();
+    });
+    t.test('should return false when isComingSoon', t => {
+      let isDev;
+      t.notOk(filterCommingSoonBetaChallenge(isDev, { isComingSoon: true }));
+      t.end();
+    });
+    t.test('should return false when isBeta', t => {
+      let isDev;
+      t.notOk(filterCommingSoonBetaChallenge(isDev, { isBeta: true }));
+      t.end();
+    });
+    t.test('should always return true when in dev', t => {
+      let isDev = true;
+      t.ok(filterCommingSoonBetaChallenge(isDev, { isBeta: true }));
+      t.ok(filterCommingSoonBetaChallenge(isDev, { isComingSoon: true }));
+      t.ok(filterCommingSoonBetaChallenge(
+        isDev,
+        { isBeta: true, isCompleted: true }
+      ));
+      t.end();
+    });
+  });
+  t.test('filterComingSoonBetaFromEntities', t => {
+    t.plan(2);
+    t.test('should filter isBeta|coming-soon by default', t => {
+      t.plan(2);
+      const normalChallenge = { dashedName: 'normal-challenge' };
+      const entities = {
+        challenge: {
+          'coming-soon': {
+            isComingSoon: true
+          },
+          'is-beta': {
+            isBeta: true
+          },
+          [normalChallenge.dashedName]: normalChallenge
+        }
+      };
+      const actual = filterComingSoonBetaFromEntities(entities);
+      t.isEqual(
+        Object.keys(actual.challenge).length,
+        1,
+        'did not filter the correct amount of challenges'
+      );
+      t.isEqual(
+        actual.challenge[normalChallenge.dashedName],
+        normalChallenge,
+        'did not return the correct challenge'
+      );
+    });
+    t.test('should not filter isBeta|coming-soon when isDev', t => {
+      t.plan(1);
+      const normalChallenge = { dashedName: 'normal-challenge' };
+      const entities = {
+        challenge: {
+          'coming-soon': {
+            dashedName: 'coming-soon',
+            isComingSoon: true
+          },
+          'is-beta': {
+            dashedName: 'is-beta',
+            isBeta: true
+          },
+          'is-both': {
+            dashedName: 'is-both',
+            isBeta: true
+          },
+          [normalChallenge.dashedName]: normalChallenge
+        }
+      };
+      const actual = filterComingSoonBetaFromEntities(entities, true);
+      t.isEqual(
+        Object.keys(actual.challenge).length,
+        4,
+        'filtered challenges'
+      );
+    });
+  });
   t.test('createMapUi', t => {
     t.plan(3);
     t.test('should return an `{}` when proper args not supplied', t => {