1101 lines
31 KiB
JavaScript
1101 lines
31 KiB
JavaScript
import test from 'tape';
|
|
import sinon from 'sinon';
|
|
import {
|
|
getNextChallenge,
|
|
getFirstChallengeOfNextBlock,
|
|
getFirstChallengeOfNextSuperBlock,
|
|
createMapUi,
|
|
traverseMapUi,
|
|
getNode,
|
|
updateSingleNode,
|
|
toggleThisPanel,
|
|
expandAllPanels,
|
|
collapseAllPanels,
|
|
applyFilterToMap,
|
|
unfilterMapUi
|
|
} from './utils.js';
|
|
|
|
|
|
test('common/app/routes/challenges/utils', function(t) {
|
|
t.test('getNextChallenge', t => {
|
|
t.plan(5);
|
|
t.test('should return falsey when current challenge is not found', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: {},
|
|
block: {}
|
|
};
|
|
t.notOk(
|
|
getNextChallenge('non-existent-challenge', entities),
|
|
'getNextChallenge did not return falsey when challenge is not found'
|
|
);
|
|
});
|
|
t.test('should return falsey when last challenge in block', t => {
|
|
t.plan(1);
|
|
const currentChallenge = {
|
|
dashedName: 'current-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const nextChallenge = {
|
|
dashedName: 'next-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const shouldBeNext = getNextChallenge(
|
|
'next-challenge',
|
|
{
|
|
challenge: {
|
|
'current-challenge': currentChallenge,
|
|
'next-challenge': nextChallenge
|
|
},
|
|
block: {
|
|
'current-block': {
|
|
challenges: [
|
|
'current-challenge',
|
|
'next-challenge'
|
|
]
|
|
}
|
|
}
|
|
}
|
|
);
|
|
t.false(
|
|
shouldBeNext,
|
|
'getNextChallenge should return null or undefined'
|
|
);
|
|
});
|
|
|
|
t.test('should return next challenge when it exists', t => {
|
|
t.plan(1);
|
|
const currentChallenge = {
|
|
dashedName: 'current-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const nextChallenge = {
|
|
dashedName: 'next-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const shouldBeNext = getNextChallenge(
|
|
'current-challenge',
|
|
{
|
|
challenge: {
|
|
'current-challenge': currentChallenge,
|
|
'next-challenge': nextChallenge
|
|
},
|
|
block: {
|
|
'current-block': {
|
|
challenges: [
|
|
'current-challenge',
|
|
'next-challenge'
|
|
]
|
|
}
|
|
}
|
|
}
|
|
);
|
|
t.isEqual(shouldBeNext, nextChallenge);
|
|
});
|
|
t.test('should skip isComingSoon challenge', t => {
|
|
t.plan(1);
|
|
const currentChallenge = {
|
|
dashedName: 'current-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const comingSoon = {
|
|
dashedName: 'coming-soon',
|
|
isComingSoon: true,
|
|
block: 'current-block'
|
|
};
|
|
const nextChallenge = {
|
|
dashedName: 'next-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const shouldBeNext = getNextChallenge(
|
|
'current-challenge',
|
|
{
|
|
challenge: {
|
|
'current-challenge': currentChallenge,
|
|
'next-challenge': nextChallenge,
|
|
'coming-soon': comingSoon,
|
|
'coming-soon2': comingSoon
|
|
},
|
|
block: {
|
|
'current-block': {
|
|
challenges: [
|
|
'current-challenge',
|
|
'coming-soon',
|
|
'coming-soon2',
|
|
'next-challenge'
|
|
]
|
|
}
|
|
}
|
|
}
|
|
);
|
|
t.isEqual(shouldBeNext, nextChallenge);
|
|
});
|
|
t.test('should not skip isComingSoon challenge in dev', t => {
|
|
t.plan(1);
|
|
const currentChallenge = {
|
|
dashedName: 'current-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const comingSoon = {
|
|
dashedName: 'coming-soon',
|
|
isComingSoon: true,
|
|
block: 'current-block'
|
|
};
|
|
const nextChallenge = {
|
|
dashedName: 'next-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
'current-challenge': currentChallenge,
|
|
'next-challenge': nextChallenge,
|
|
'coming-soon': comingSoon
|
|
},
|
|
block: {
|
|
'current-block': {
|
|
challenges: [
|
|
'current-challenge',
|
|
'coming-soon',
|
|
'next-challenge'
|
|
]
|
|
}
|
|
}
|
|
};
|
|
t.isEqual(
|
|
getNextChallenge('current-challenge', entities, { isDev: true }),
|
|
comingSoon
|
|
);
|
|
});
|
|
});
|
|
|
|
t.test('getFirstChallengeOfNextBlock', t => {
|
|
t.plan(8);
|
|
t.test('should return falsey when current challenge is not found', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: {},
|
|
block: {}
|
|
};
|
|
t.notOk(
|
|
getFirstChallengeOfNextBlock('non-existent-challenge', entities),
|
|
`
|
|
gitFirstChallengeOfNextBlock returned true value for non-existant
|
|
challenge
|
|
`
|
|
);
|
|
});
|
|
t.test('should return falsey when current block is not found', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: {
|
|
'current-challenge': {
|
|
block: 'non-existent-block'
|
|
}
|
|
},
|
|
block: {}
|
|
};
|
|
t.notOk(
|
|
getFirstChallengeOfNextBlock('current-challenge', entities),
|
|
`
|
|
getFirstChallengeOfNextBlock did not returned true value block
|
|
did non exist
|
|
`
|
|
);
|
|
});
|
|
t.test('should return falsey if no current superBlock found', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: { 'current-challenge': { block: 'current-block' } },
|
|
block: {
|
|
'current-block': {
|
|
dashedName: 'current-block',
|
|
superBlock: 'current-super-block'
|
|
}
|
|
},
|
|
superBlock: {}
|
|
};
|
|
t.notOk(
|
|
getFirstChallengeOfNextBlock('current-challenge', entities),
|
|
`
|
|
getFirstChallengeOfNextBlock returned a true value
|
|
when superBlock is undefined
|
|
`
|
|
);
|
|
});
|
|
t.test('should return falsey when no next block found', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: { 'current-challenge': { block: 'current-block' } },
|
|
block: {
|
|
'current-block': {
|
|
dashedName: 'current-block',
|
|
superBlock: 'current-super-block'
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': {
|
|
blocks: [
|
|
'current-block',
|
|
'non-exitent-block'
|
|
]
|
|
}
|
|
}
|
|
};
|
|
t.notOk(
|
|
getFirstChallengeOfNextBlock('current-challenge', entities),
|
|
`
|
|
getFirstChallengeOfNextBlock returned a value when next block
|
|
does not exist
|
|
`
|
|
);
|
|
});
|
|
t.test('should return first challenge of next block', t => {
|
|
t.plan(1);
|
|
const currentChallenge = {
|
|
dashedName: 'current-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
[currentChallenge.dashedName]: currentChallenge,
|
|
[firstChallenge.dashedName]: firstChallenge
|
|
},
|
|
block: {
|
|
'current-block': {
|
|
dashedName: 'current-block',
|
|
superBlock: 'current-super-block'
|
|
},
|
|
'next-block': {
|
|
dashedName: 'next-block',
|
|
superBlock: 'current-super-block',
|
|
challenges: [ 'first-challenge' ]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': {
|
|
dashedName: 'current-super-block',
|
|
blocks: [ 'current-block', 'next-block' ]
|
|
}
|
|
}
|
|
};
|
|
t.equal(
|
|
getFirstChallengeOfNextBlock(currentChallenge.dashedName, entities),
|
|
firstChallenge,
|
|
'getFirstChallengeOfNextBlock did not return the correct challenge'
|
|
);
|
|
});
|
|
t.test('should skip coming soon challenge of next block', t => {
|
|
t.plan(2);
|
|
const currentChallenge = {
|
|
dashedName: 'current-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const comingSoon = {
|
|
dashedName: 'coming-soon',
|
|
block: 'next-block',
|
|
isComingSoon: true
|
|
};
|
|
const comingSoon2 = {
|
|
dashedName: 'coming-soon2',
|
|
block: 'next-block',
|
|
isComingSoon: true
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
[currentChallenge.dashedName]: currentChallenge,
|
|
[firstChallenge.dashedName]: firstChallenge,
|
|
'coming-soon': comingSoon,
|
|
'coming-soon2': comingSoon2
|
|
},
|
|
block: {
|
|
'current-block': {
|
|
dashedName: 'current-block',
|
|
superBlock: 'current-super-block'
|
|
},
|
|
'next-block': {
|
|
dashedName: 'next-block',
|
|
superBlock: 'current-super-block',
|
|
challenges: [
|
|
'coming-soon',
|
|
'coming-soon2',
|
|
'first-challenge'
|
|
]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': {
|
|
dashedName: 'current-super-block',
|
|
blocks: [ 'current-block', 'next-block' ]
|
|
}
|
|
}
|
|
};
|
|
t.notEqual(
|
|
getFirstChallengeOfNextBlock(currentChallenge.dashedName, entities),
|
|
comingSoon,
|
|
'getFirstChallengeOfNextBlock returned isComingSoon challenge'
|
|
);
|
|
t.equal(
|
|
getFirstChallengeOfNextBlock(currentChallenge.dashedName, entities),
|
|
firstChallenge,
|
|
'getFirstChallengeOfNextBlock did not return the correct challenge'
|
|
);
|
|
});
|
|
t.test('should not skip coming soon in dev mode', t => {
|
|
t.plan(1);
|
|
const currentChallenge = {
|
|
dashedName: 'current-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const comingSoon = {
|
|
dashedName: 'coming-soon',
|
|
block: 'next-block',
|
|
isComingSoon: true
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
[currentChallenge.dashedName]: currentChallenge,
|
|
[firstChallenge.dashedName]: firstChallenge,
|
|
'coming-soon': comingSoon
|
|
},
|
|
block: {
|
|
'current-block': {
|
|
dashedName: 'current-block',
|
|
superBlock: 'current-super-block'
|
|
},
|
|
'next-block': {
|
|
dashedName: 'next-block',
|
|
superBlock: 'current-super-block',
|
|
challenges: [
|
|
'coming-soon',
|
|
'first-challenge'
|
|
]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': {
|
|
dashedName: 'current-super-block',
|
|
blocks: [ 'current-block', 'next-block' ]
|
|
}
|
|
}
|
|
};
|
|
t.equal(
|
|
getFirstChallengeOfNextBlock(
|
|
currentChallenge.dashedName,
|
|
entities,
|
|
{ isDev: true }
|
|
),
|
|
comingSoon,
|
|
'getFirstChallengeOfNextBlock returned isComingSoon challenge'
|
|
);
|
|
});
|
|
t.test('should skip block if all challenges are coming soon', t => {
|
|
t.plan(2);
|
|
const currentChallenge = {
|
|
dashedName: 'current-challenge',
|
|
block: 'current-block'
|
|
};
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const comingSoon = {
|
|
dashedName: 'coming-soon',
|
|
block: 'coming-soon-block',
|
|
isComingSoon: true
|
|
};
|
|
const comingSoon2 = {
|
|
dashedName: 'coming-soon2',
|
|
block: 'coming-soon-block',
|
|
isComingSoon: true
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
[currentChallenge.dashedName]: currentChallenge,
|
|
[firstChallenge.dashedName]: firstChallenge,
|
|
[comingSoon.dashedName]: comingSoon,
|
|
[comingSoon2.dashedName]: comingSoon2
|
|
},
|
|
block: {
|
|
'current-block': {
|
|
dashedName: 'current-block',
|
|
superBlock: 'current-super-block'
|
|
},
|
|
'coming-soon-block': {
|
|
dashedName: 'coming-soon-block',
|
|
superBlock: 'current-super-block',
|
|
challenges: [
|
|
'coming-soon',
|
|
'coming-soon2'
|
|
]
|
|
},
|
|
'next-block': {
|
|
dashedName: 'next-block',
|
|
superBlock: 'current-super-block',
|
|
challenges: [
|
|
'first-challenge'
|
|
]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': {
|
|
dashedName: 'current-super-block',
|
|
blocks: [
|
|
'current-block',
|
|
'coming-soon-block',
|
|
'next-block'
|
|
]
|
|
}
|
|
}
|
|
};
|
|
t.notEqual(
|
|
getFirstChallengeOfNextBlock(currentChallenge.dashedName, entities),
|
|
comingSoon,
|
|
'getFirstChallengeOfNextBlock returned isComingSoon challenge'
|
|
);
|
|
t.equal(
|
|
getFirstChallengeOfNextBlock(currentChallenge.dashedName, entities),
|
|
firstChallenge,
|
|
'getFirstChallengeOfNextBlock did not return the correct challenge'
|
|
);
|
|
});
|
|
});
|
|
|
|
t.test('getFirstChallengeOfNextBlock', t => {
|
|
t.plan(10);
|
|
t.test('should return falsey if current challenge not found', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: {}
|
|
};
|
|
t.notOk(
|
|
getFirstChallengeOfNextSuperBlock('current-challenge', entities),
|
|
);
|
|
});
|
|
t.test('should return falsey if current block not found', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: { 'current-challenge': { block: 'current-block' } },
|
|
block: {}
|
|
};
|
|
t.notOk(
|
|
getFirstChallengeOfNextSuperBlock('current-challenge', entities)
|
|
);
|
|
});
|
|
t.test('should return falsey if current superBlock is not found', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: { 'current-challenge': { block: 'current-block' } },
|
|
block: { 'current-block': { superBlock: 'current-super-block' } },
|
|
superBlock: {}
|
|
};
|
|
t.notOk(
|
|
getFirstChallengeOfNextSuperBlock('current-challenge', entities)
|
|
);
|
|
});
|
|
t.test('should return falsey when last superBlock', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: { 'current-challenge': { block: 'current-block' } },
|
|
block: { 'current-block': { superBlock: 'current-super-block' } },
|
|
superBlock: {
|
|
'current-super-block': { dashedName: 'current-super-block' }
|
|
}
|
|
};
|
|
const superBlocks = [ 'current-super-block' ];
|
|
t.notOk(getFirstChallengeOfNextSuperBlock(
|
|
'current-challenge',
|
|
entities,
|
|
superBlocks
|
|
));
|
|
});
|
|
t.test('should return falsey when last block of new superblock', t => {
|
|
t.plan(1);
|
|
const entities = {
|
|
challenge: { 'current-challenge': { block: 'current-block' } },
|
|
block: {
|
|
'current-block': {
|
|
superBlock: 'current-super-block'
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': { dashedName: 'current-super-block' },
|
|
'next-super-block': {
|
|
dashedName: 'next-super-block',
|
|
blocks: [
|
|
'first-block'
|
|
]
|
|
}
|
|
}
|
|
};
|
|
const superBlocks = [ 'current-super-block', 'next-super-block' ];
|
|
t.notOk(getFirstChallengeOfNextSuperBlock(
|
|
'current-challenge',
|
|
entities,
|
|
superBlocks
|
|
));
|
|
});
|
|
t.test('should return first challenge of next superBlock', t => {
|
|
t.plan(1);
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
'current-challenge': { block: 'current-block' },
|
|
[firstChallenge.dashedName]: firstChallenge
|
|
},
|
|
block: {
|
|
'current-block': { superBlock: 'current-super-block' },
|
|
'next-block': {
|
|
superBlock: 'next-super-block',
|
|
challenges: [ 'first-challenge' ]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': { dashedName: 'current-super-block' },
|
|
'next-super-block': {
|
|
dashedName: 'next-super-block',
|
|
blocks: [ 'next-block' ]
|
|
}
|
|
}
|
|
};
|
|
const superBlocks = [ 'current-super-block', 'next-super-block' ];
|
|
t.isEqual(
|
|
getFirstChallengeOfNextSuperBlock(
|
|
'current-challenge',
|
|
entities,
|
|
superBlocks
|
|
),
|
|
firstChallenge
|
|
);
|
|
});
|
|
t.test('should skip coming soon challenge', t => {
|
|
t.plan(1);
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
'current-challenge': { block: 'current-block' },
|
|
[firstChallenge.dashedName]: firstChallenge,
|
|
'coming-soon': {
|
|
dashedName: 'coming-soon',
|
|
block: 'next-block',
|
|
isComingSoon: true
|
|
}
|
|
},
|
|
block: {
|
|
'current-block': { superBlock: 'current-super-block' },
|
|
'next-block': {
|
|
dashedName: 'next-block',
|
|
superBlock: 'next-super-block',
|
|
challenges: [ 'coming-soon', 'first-challenge' ]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': { dashedName: 'current-super-block' },
|
|
'next-super-block': {
|
|
dashedName: 'next-super-block',
|
|
blocks: [ 'next-block' ]
|
|
}
|
|
}
|
|
};
|
|
const superBlocks = [
|
|
'current-super-block',
|
|
'next-super-block'
|
|
];
|
|
t.isEqual(
|
|
getFirstChallengeOfNextSuperBlock(
|
|
'current-challenge',
|
|
entities,
|
|
superBlocks
|
|
),
|
|
firstChallenge
|
|
);
|
|
});
|
|
t.test('should not skip coming soon in dev mode', t => {
|
|
t.plan(1);
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const comingSoon = {
|
|
dashedName: 'coming-soon',
|
|
block: 'next-block',
|
|
isComingSoon: true
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
'current-challenge': { block: 'current-block' },
|
|
[firstChallenge.dashedName]: firstChallenge,
|
|
'coming-soon': comingSoon
|
|
},
|
|
block: {
|
|
'current-block': { superBlock: 'current-super-block' },
|
|
'next-block': {
|
|
dashedName: 'next-block',
|
|
superBlock: 'next-super-block',
|
|
challenges: [ 'coming-soon', 'first-challenge' ]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': { dashedName: 'current-super-block' },
|
|
'next-super-block': {
|
|
dashedName: 'next-super-block',
|
|
blocks: [ 'next-block' ]
|
|
}
|
|
}
|
|
};
|
|
const superBlocks = [
|
|
'current-super-block',
|
|
'next-super-block'
|
|
];
|
|
t.isEqual(
|
|
getFirstChallengeOfNextSuperBlock(
|
|
'current-challenge',
|
|
entities,
|
|
superBlocks,
|
|
{ isDev: true }
|
|
),
|
|
comingSoon
|
|
);
|
|
});
|
|
t.test('should skip coming soon block', t => {
|
|
t.plan(1);
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
'current-challenge': { block: 'current-block' },
|
|
[firstChallenge.dashedName]: firstChallenge,
|
|
'coming-soon': {
|
|
dashedName: 'coming-soon',
|
|
block: 'coming-soon-block',
|
|
isComingSoon: true
|
|
}
|
|
},
|
|
block: {
|
|
'current-block': { superBlock: 'current-super-block' },
|
|
'coming-soon-block': {
|
|
dashedName: 'coming-soon-block',
|
|
superBlock: 'next-super-block',
|
|
challenges: [
|
|
'coming-soon'
|
|
]
|
|
},
|
|
'next-block': {
|
|
dashedName: 'next-block',
|
|
superBlock: 'next-super-block',
|
|
challenges: [ 'first-challenge' ]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': { dashedName: 'current-super-block' },
|
|
'next-super-block': {
|
|
dashedName: 'next-super-block',
|
|
blocks: [ 'coming-soon-block', 'next-block' ]
|
|
}
|
|
}
|
|
};
|
|
const superBlocks = [
|
|
'current-super-block',
|
|
'next-super-block'
|
|
];
|
|
t.isEqual(
|
|
getFirstChallengeOfNextSuperBlock(
|
|
'current-challenge',
|
|
entities,
|
|
superBlocks
|
|
),
|
|
firstChallenge
|
|
);
|
|
});
|
|
t.test('should skip coming soon super block', t => {
|
|
t.plan(1);
|
|
const firstChallenge = {
|
|
dashedName: 'first-challenge',
|
|
block: 'next-block'
|
|
};
|
|
const entities = {
|
|
challenge: {
|
|
'current-challenge': { block: 'current-block' },
|
|
[firstChallenge.dashedName]: firstChallenge,
|
|
'coming-soon': {
|
|
dashedName: 'coming-soon',
|
|
block: 'coming-soon-block',
|
|
isComingSoon: true
|
|
}
|
|
},
|
|
block: {
|
|
'current-block': { superBlock: 'current-super-block' },
|
|
'coming-soon-block': {
|
|
dashedName: 'coming-soon-block',
|
|
superBlock: 'coming-soon-super-block',
|
|
challenges: [
|
|
'coming-soon'
|
|
]
|
|
},
|
|
'next-block': {
|
|
superBlock: 'next-super-block',
|
|
dashedName: 'next-block',
|
|
challenges: [ 'first-challenge' ]
|
|
}
|
|
},
|
|
superBlock: {
|
|
'current-super-block': { dashedName: 'current-super-block' },
|
|
'coming-soon-super-block': {
|
|
dashedName: 'coming-soon-super-block',
|
|
blocks: [ 'coming-soon-block' ]
|
|
},
|
|
'next-super-block': {
|
|
dashedName: 'next-super-block',
|
|
blocks: [ 'next-block' ]
|
|
}
|
|
}
|
|
};
|
|
const superBlocks = [
|
|
'current-super-block',
|
|
'coming-soon-super-block',
|
|
'next-super-block'
|
|
];
|
|
t.isEqual(
|
|
getFirstChallengeOfNextSuperBlock(
|
|
'current-challenge',
|
|
entities,
|
|
superBlocks
|
|
),
|
|
firstChallenge
|
|
);
|
|
});
|
|
});
|
|
t.test('createMapUi', t => {
|
|
t.plan(3);
|
|
t.test('should return an `{}` when proper args not supplied', t => {
|
|
t.plan(3);
|
|
t.equal(
|
|
Object.keys(createMapUi()).length,
|
|
0
|
|
);
|
|
t.equal(
|
|
Object.keys(createMapUi({}, [])).length,
|
|
0
|
|
);
|
|
t.equal(
|
|
Object.keys(createMapUi({ superBlock: {} }, [])).length,
|
|
0
|
|
);
|
|
});
|
|
t.test('should return a map tree', t => {
|
|
const expected = {
|
|
children: [{
|
|
name: 'superBlockA',
|
|
children: [{
|
|
name: 'blockA',
|
|
children: [{
|
|
name: 'challengeA'
|
|
}]
|
|
}]
|
|
}]
|
|
};
|
|
const actual = createMapUi({
|
|
superBlock: {
|
|
superBlockA: {
|
|
blocks: [
|
|
'blockA'
|
|
]
|
|
}
|
|
},
|
|
block: {
|
|
blockA: {
|
|
challenges: [
|
|
'challengeA'
|
|
]
|
|
}
|
|
}
|
|
}, ['superBlockA']);
|
|
t.plan(3);
|
|
t.equal(actual.children[0].name, expected.children[0].name);
|
|
t.equal(
|
|
actual.children[0].children[0].name,
|
|
expected.children[0].children[0].name
|
|
);
|
|
t.equal(
|
|
actual.children[0].children[0].children[0].name,
|
|
expected.children[0].children[0].children[0].name
|
|
);
|
|
});
|
|
t.test('should protect against malformed data', t => {
|
|
t.plan(2);
|
|
t.equal(
|
|
createMapUi({
|
|
superBlock: {},
|
|
block: {
|
|
blockA: {
|
|
challenges: [
|
|
'challengeA'
|
|
]
|
|
}
|
|
}
|
|
}, ['superBlockA']).children[0].children.length,
|
|
0
|
|
);
|
|
t.equal(
|
|
createMapUi({
|
|
superBlock: {
|
|
superBlockA: {
|
|
blocks: [
|
|
'blockA'
|
|
]
|
|
}
|
|
},
|
|
block: {}
|
|
}, ['superBlockA']).children[0].children[0].children.length,
|
|
0
|
|
);
|
|
});
|
|
});
|
|
t.test('traverseMapUi', t => {
|
|
t.test('should return tree', t => {
|
|
t.plan(2);
|
|
const expectedTree = {};
|
|
const actaulTree = traverseMapUi(expectedTree, tree => {
|
|
t.equal(tree, expectedTree);
|
|
return tree;
|
|
});
|
|
t.equal(actaulTree, expectedTree);
|
|
});
|
|
t.test('should hit every node', t => {
|
|
t.plan(4);
|
|
const expected = { children: [{ children: [{}] }] };
|
|
const spy = sinon.spy(t => t);
|
|
spy.withArgs(expected);
|
|
spy.withArgs(expected.children[0]);
|
|
spy.withArgs(expected.children[0].children[0]);
|
|
traverseMapUi(expected, spy);
|
|
t.equal(spy.callCount, 3);
|
|
t.ok(spy.withArgs(expected).calledOnce, 'foo');
|
|
t.ok(spy.withArgs(expected.children[0]).calledOnce, 'bar');
|
|
t.ok(spy.withArgs(expected.children[0].children[0]).calledOnce, 'baz');
|
|
});
|
|
t.test('should create new object when children change', t => {
|
|
t.plan(9);
|
|
const expected = { children: [{ bar: true }, {}] };
|
|
const actual = traverseMapUi(expected, node => ({ ...node, foo: true }));
|
|
t.notEqual(actual, expected);
|
|
t.notEqual(actual.children, expected.children);
|
|
t.notEqual(actual.children[0], expected.children[0]);
|
|
t.notEqual(actual.children[1], expected.children[1]);
|
|
t.equal(actual.children[0].bar, expected.children[0].bar);
|
|
t.notOk(expected.children[0].foo);
|
|
t.notOk(expected.children[1].foo);
|
|
t.true(actual.children[0].foo);
|
|
t.true(actual.children[1].foo);
|
|
});
|
|
});
|
|
t.test('getNode', t => {
|
|
t.test('should return node', t => {
|
|
t.plan(1);
|
|
const expected = { name: 'foo' };
|
|
const tree = { children: [{ name: 'notfoo' }, expected ] };
|
|
const actual = getNode(tree, 'foo');
|
|
t.equal(expected, actual);
|
|
});
|
|
t.test('should returned undefined if not found', t => {
|
|
t.plan(1);
|
|
const tree = {
|
|
children: [ { name: 'foo' }, { children: [ { name: 'bar' } ] } ]
|
|
};
|
|
const actual = getNode(tree, 'baz');
|
|
t.notOk(actual);
|
|
});
|
|
});
|
|
t.test('updateSingleNode', t => {
|
|
t.test('should update single node', t => {
|
|
const expected = { name: 'foo' };
|
|
const untouched = { name: 'notFoo' };
|
|
const actual = updateSingleNode(
|
|
{ children: [ untouched, expected ] },
|
|
'foo',
|
|
node => ({ ...node, tag: true })
|
|
);
|
|
t.plan(4);
|
|
t.ok(actual.children[1].tag);
|
|
t.equal(actual.children[1].name, expected.name);
|
|
t.notEqual(actual.children[1], expected);
|
|
t.equal(actual.children[0], untouched);
|
|
});
|
|
});
|
|
t.test('toggleThisPanel', t => {
|
|
t.test('should update single node', t => {
|
|
const expected = { name: 'foo', isOpen: true };
|
|
const actual = toggleThisPanel(
|
|
{ children: [ { name: 'foo', isOpen: false }] },
|
|
'foo'
|
|
);
|
|
t.plan(1);
|
|
t.deepLooseEqual(actual.children[0], expected);
|
|
});
|
|
});
|
|
t.test('toggleAllPanels', t => {
|
|
t.test('should add `isOpen: true` to every node without children', t => {
|
|
const expected = {
|
|
isOpen: true,
|
|
children: [{
|
|
isOpen: true,
|
|
children: [{}, {}]
|
|
}]
|
|
};
|
|
const actual = expandAllPanels({ children: [{ children: [{}, {}] }] });
|
|
t.plan(1);
|
|
t.deepLooseEqual(actual, expected);
|
|
});
|
|
t.test('should add `isOpen: false` to every node without children', t => {
|
|
const leaf = {};
|
|
const expected = {
|
|
isOpen: false,
|
|
children: [{
|
|
isOpen: false,
|
|
children: [{}, leaf]
|
|
}]
|
|
};
|
|
const actual = collapseAllPanels(
|
|
{ isOpen: true, children: [{ children: [{}, leaf]}]},
|
|
);
|
|
t.plan(2);
|
|
t.deepLooseEqual(actual, expected);
|
|
t.equal(actual.children[0].children[1], leaf);
|
|
});
|
|
});
|
|
t.test('applyFilterToMap', t => {
|
|
t.test('should not touch child that is already hidden', t => {
|
|
t.plan(1);
|
|
const expected = { name: 'bar', isHidden: true };
|
|
const actual = applyFilterToMap(
|
|
expected,
|
|
/foo/
|
|
);
|
|
t.equal(actual, expected);
|
|
});
|
|
t.test('should update child that is hidden', t => {
|
|
t.plan(1);
|
|
const expected = { name: 'bar', isHidden: false };
|
|
const input = { name: 'bar', isHidden: true };
|
|
const actual = applyFilterToMap(input, /bar/);
|
|
t.deepLooseEqual(actual, expected);
|
|
});
|
|
t.test('should unhide child that matches filter regex', t => {
|
|
t.plan(1);
|
|
const expected = { name: 'foo' };
|
|
const actual = applyFilterToMap({ name: 'foo' }, /foo/);
|
|
t.deepLooseEqual(actual, expected);
|
|
});
|
|
t.test('should hide child that does not match filter', t => {
|
|
t.plan(1);
|
|
const expected = { name: 'bar', isHidden: true };
|
|
const actual = applyFilterToMap({ name: 'bar' }, /foo/);
|
|
t.deepLooseEqual(actual, expected);
|
|
});
|
|
t.test('should not touch node that is already hidden', t => {
|
|
t.plan(1);
|
|
const expected = {
|
|
name: 'bar',
|
|
isHidden: true,
|
|
children: [
|
|
{ name: 'baz', isHidden: true },
|
|
{ name: 'baz2', isHidden: true }
|
|
]
|
|
};
|
|
const actual = applyFilterToMap(expected, /foo/);
|
|
t.equal(actual, expected);
|
|
});
|
|
t.test('should not touch node that is unhidden', t => {
|
|
t.plan(1);
|
|
const expected = {
|
|
name: 'bar',
|
|
isHidden: false,
|
|
children: [
|
|
{ name: 'baz', isHidden: true },
|
|
{ name: 'foo', isHidden: false }
|
|
]
|
|
};
|
|
const actual = applyFilterToMap(expected, /foo/);
|
|
t.equal(actual, expected);
|
|
});
|
|
t.test('should hide node if all children are hidden', t => {
|
|
t.plan(1);
|
|
const input = {
|
|
name: 'bar',
|
|
isHidden: false,
|
|
children: [
|
|
{ name: 'baz' },
|
|
{ name: 'baz2', isHidden: false }
|
|
]
|
|
};
|
|
const expected = {
|
|
name: 'bar',
|
|
isHidden: true,
|
|
children: [
|
|
{ name: 'baz', isHidden: true },
|
|
{ name: 'baz2', isHidden: true }
|
|
]
|
|
};
|
|
const actual = applyFilterToMap(input, /foo/);
|
|
t.deepLooseEqual(actual, expected);
|
|
});
|
|
t.test('should unhide node some children unhidden', t => {
|
|
t.plan(1);
|
|
const input = {
|
|
name: 'bar',
|
|
isHidden: true,
|
|
children: [
|
|
{ name: 'baz', isHidden: true },
|
|
{ name: 'foo', isHidden: false }
|
|
]
|
|
};
|
|
const expected = {
|
|
name: 'bar',
|
|
isHidden: false,
|
|
children: [
|
|
{ name: 'baz', isHidden: true },
|
|
{ name: 'foo', isHidden: false }
|
|
]
|
|
};
|
|
const actual = applyFilterToMap(input, /foo/);
|
|
t.deepLooseEqual(actual, expected);
|
|
});
|
|
});
|
|
t.test('unfilterMapUi', t => {
|
|
t.test('should not touch node that is already hidden', t => {
|
|
const expected = { isHidden: false };
|
|
const actual = unfilterMapUi(expected);
|
|
t.plan(1);
|
|
t.equal(actual, expected);
|
|
});
|
|
t.test('should update node that is not hidden', t => {
|
|
const expected = { isHidden: false };
|
|
const input = { isHidden: true };
|
|
const actual = unfilterMapUi(input);
|
|
t.plan(2);
|
|
t.notEqual(actual, input);
|
|
t.deepLooseEqual(actual, expected);
|
|
});
|
|
});
|
|
});
|
|
|