genoverse 3.2.0

package/test/track-ordering.test.js

@@ -0,0 +1,514 @@
+const { Genoverse, afterTest } = require('./utils');
+
+// TODO: unsortable, particularly with unsortable order=9e99, then adding another track
+
+describe('Track ordering', () => {
+  afterAll(afterTest);
+
+  // Want saveable to be able to run resetConfig, but don't actually want to be able to save anything
+  window.sessionStorage = {
+    setItem    : () => {},
+    getItem    : () => {},
+    removeItem : () => {},
+  };
+
+  const newGenoverse = (tracks) => {
+    const g = new Genoverse({
+      start          : 1,
+      end            : 1,
+      chromosomeSize : 1,
+      isStatic       : true,
+      saveable       : true,
+      tracks         : tracks.map(t => Genoverse.Track.extend({ url: false, ...t })),
+      _initDeferred  : $.Deferred(),
+      saveConfig     : () => {},
+      loadGenome     : () => {},
+      loadPlugins    : () => {},
+    });
+
+    setTimeout(g._initDeferred.resolve, 1);
+
+    return g;
+  };
+
+  const doTest = (...args) => {
+    const [ g, expected ] = args;
+
+    let [ , , addTracks, after ] = args;
+
+    const msg       = args.length > 2 && typeof args[args.length - 1] === 'string' ? args[args.length - 1] : '';
+    const deferred  = $.Deferred();
+    const genoverse = g instanceof Genoverse ? g : newGenoverse(g);
+
+    if (addTracks === msg) addTracks = undefined;
+    if (after     === msg) after = undefined;
+
+    genoverse._initDeferred.done(() => {
+      if (Array.isArray(addTracks)) {
+        genoverse.addTracks(addTracks.map(t => Genoverse.Track.extend({ url: false, ...t })), after);
+      } else if (addTracks) {
+        genoverse.addTrack(Genoverse.Track.extend({ url: false, ...addTracks }), after);
+      }
+
+      setTimeout(() => {
+        const orderedIds = genoverse.tracks.map(t => t.id).join(' ');
+
+        if (addTracks) {
+          addTracks = [].concat(addTracks);
+          genoverse.removeTracks(addTracks.map(t => genoverse.tracksById[t.id]));
+        }
+
+        expect(orderedIds).toBe(expected); // Test must be after removing tracks, since if the test fails, nothing else executes
+
+        deferred.resolve();
+      }, 1);
+    });
+
+    return deferred;
+  };
+
+  const resetConfig = (g, reorder, expected) => {
+    let order = 0;
+
+    const newId     = reorder.length + 1;
+    const deferred  = $.Deferred();
+    const genoverse = newGenoverse(g);
+
+    genoverse._initDeferred.done(() => {
+      reorder.forEach((i) => { genoverse.tracksById[i].order = order++; });
+
+      genoverse.addTrack(Genoverse.Track.extend({ id: newId }));
+
+      setTimeout($.Deferred().done(() => {
+        doTest(genoverse, reorder.concat(newId).join(' ')).done(() => {
+          genoverse.resetConfig();
+
+          setTimeout($.Deferred().done(() => {
+            doTest(genoverse, expected).done(() => { deferred.resolve(); });
+          }).resolve, 1);
+        });
+      }).resolve, 1);
+    });
+
+    return deferred;
+  };
+
+  const moveTrack = (genoverse, id, afterId) => {
+    const track = genoverse.tracksById[id];
+
+    if (afterId) {
+      track.prop('label').insertAfter(genoverse.tracksById[afterId].prop('label'));
+    } else {
+      track.prop('label').prependTo(genoverse.labelContainer);
+    }
+
+    genoverse.updateTrackOrder({}, { item: track.prop('label') });
+  };
+
+  const legendTrack = (id, legendConf) => ({
+    id     : id,
+    legend : legendConf ? Genoverse.Track.Legend.extend(legendConf) : true,
+  });
+
+  describe('Simple tracks', () => {
+    describe('Without explicit order', () => {
+      const tracks = [{ id: 1 }, { id: 2 }, { id: 3 }];
+
+      it('initial track order', () => doTest(tracks, '1 2 3'));
+
+      describe('After adding a track', () => {
+        it('without an after argument', () => doTest(tracks, '1 2 3 4', { id: 4 }));
+        it('with an after argument',    () => doTest(tracks, '1 2 4 3', { id: 4 }, 2));
+      });
+
+      describe('After adding multiple tracks', () => {
+        it('without an after argument', () => doTest(tracks, '1 2 3 4 5 6', [{ id: 4 }, { id: 5 }, { id: 6 }]));
+        it('with an after argument',    () => doTest(tracks, '1 4 5 6 2 3', [{ id: 4 }, { id: 5 }, { id: 6 }], 1));
+      });
+
+      describe('After reset config', () => {
+        it('initial track order restored', () => resetConfig(tracks, [ 2, 3, 1 ], '1 2 3'));
+      });
+    });
+
+    describe('With explicit order', () => {
+      const tracks = [
+        { id: 1              },
+        { id: 2, order: 3    },
+        { id: 3, order: 2    },
+        { id: 4, order: 9e99 },
+        { id: 5              },
+        { id: 6, order: -1   },
+      ];
+
+      it('initial track order', () => doTest(tracks, '6 1 3 2 5 4'));
+
+      describe('After adding a track', () => {
+        it('without an after argument',                   () => doTest(tracks, '6 1 3 2 5 4 7', { id: 7           }));
+        it('without an after argument, with track.order', () => doTest(tracks, '6 1 3 2 7 5 4', { id: 7, order: 3 })); // order after initialization is used as a 0-based index, with the track being inserted after existing track [order + 1]
+        it('with an after argument',                      () => doTest(tracks, '6 1 3 7 2 5 4', { id: 7           }, 3));
+        it('with an after argument and track.order',      () => doTest(tracks, '6 1 3 2 5 7 4', { id: 7, order: 4 }, 2, 'Track order should take precedence over after argument'));
+      });
+
+      describe('After adding multiple tracks', () => {
+        it('without an after argument',                   () => doTest(tracks, '6 1 3 2 5 4 7 8', [{ id: 7           }, { id: 8           }]));
+        it('without an after argument, with track.order', () => doTest(tracks, '6 1 3 8 2 5 7 4', [{ id: 7, order: 4 }, { id: 8, order: 2 }]));
+        it('with an after argument',                      () => doTest(tracks, '6 1 3 2 7 8 5 4', [{ id: 7           }, { id: 8           }], 4));
+        it('with an after argument and track.order',      () => doTest(tracks, '6 1 7 3 2 5 8 4', [{ id: 7, order: 1 }, { id: 8, order: 4 }], 2, 'Track order should take precedence over after argument'));
+      });
+
+      describe('After reset config', () => {
+        it('initial track order restored', () => resetConfig(tracks, [ 4, 2, 5, 1, 3, 6 ], '6 1 3 2 5 4'));
+      });
+    });
+  });
+
+  describe('Tracks with legends', () => {
+    describe('Legend locked to track', () => {
+      describe('Legend unsortable', () => {
+        const tracks = [{ id: 1 }, legendTrack(2), { id: 3 }];
+
+        it('initial track order', () => doTest(tracks, '1 2 2Legend 3'));
+
+        describe('After adding a track', () => {
+          it('before the track with the legend', () => doTest(tracks, '1 4 2 2Legend 3',         { id: 4 },      1));
+          it('between the track and its legend', () => doTest(tracks, '1 2 2Legend 4 3',         { id: 4 },      2, 'The legend is locked to its track, so adding between 2 and 2Legend is impossible'));
+          it('after the legend',                 () => doTest(tracks, '1 2 2Legend 4 3',         { id: 4 },      3));
+          it('with a legend',                    () => doTest(tracks, '1 2 2Legend 4 4Legend 3', legendTrack(4), 3));
+        });
+
+        describe('After adding multiple tracks', () => {
+          it('before the track with the legend', () => doTest(tracks, '1 4 5 2 2Legend 3',                 [{ id: 4 }, { id: 5 }],             1));
+          it('between the track and its legend', () => doTest(tracks, '1 2 2Legend 4 5 3',                 [{ id: 4 }, { id: 5 }],             2, 'The legend is locked to its track, so adding between 2 and 2Legend is impossible'));
+          it('after the legend',                 () => doTest(tracks, '1 2 2Legend 4 5 3',                 [{ id: 4 }, { id: 5 }],             3));
+          it('with legends',                     () => doTest(tracks, '1 2 2Legend 4 4Legend 5 5Legend 3', [ legendTrack(4), legendTrack(5) ], 3)); // FIXME track 5 gets added before track 4
+        });
+
+        describe('After sorting tracks', () => {
+          it('moving the track with the legend', () => {
+            const genoverse = newGenoverse.call(this, tracks);
+            const deferred  = $.Deferred();
+
+            genoverse._initDeferred.done(() => {
+              moveTrack(genoverse, 3, 2);
+
+              doTest(genoverse, '1 2 2Legend 3', 'The legend is locked to its track, so moving a track between 2 and 2Legend is impossible').done(() => {
+                moveTrack(genoverse, 2);
+
+                doTest(genoverse, '2 2Legend 1 3', 'The legend should still be after its track').done(() => {
+                  doTest(genoverse, '2 2Legend 4 1 3', { id: 4 }, 1, 'Adding a new track between 2 and 2Legend should still be impossible').done(deferred.resolve);
+                });
+              });
+            });
+
+            return deferred;
+          });
+
+          it('moving the legend', () => {
+            const genoverse = newGenoverse.call(this, tracks);
+            const deferred  = $.Deferred();
+
+            genoverse._initDeferred.done(() => {
+              moveTrack(genoverse, 3, 2);
+
+              doTest(genoverse, '1 2 2Legend 3', 'The legend is locked to its track, so moving a track between 2 and 2Legend is impossible').done(() => {
+                moveTrack(genoverse, '2Legend', 3);
+
+                doTest(genoverse, '1 2 2Legend 3', 'Trying to move an unsortable track should have no effect').done(() => {
+                  doTest(genoverse, '1 2 2Legend 4 3', { id: 4 }, 2, 'Adding a new track between 2 and 2Legend should still be impossible').done(deferred.resolve);
+                });
+              });
+            });
+
+            return deferred;
+          });
+        });
+
+        describe('After reset config', () => {
+          it('initial track order restored', () => resetConfig(tracks, [ 3, 1, 2, '2Legend' ], '1 2 2Legend 3'));
+        });
+
+        describe('Legend with order', () => {
+          it('initial track order', () => doTest([{ id: 1 }, legendTrack(2, { order: 9e99 }), { id: 3 }], '1 2 2Legend 3', 'Legend order property should be ignored'));
+        });
+      });
+
+      describe('Legend sortable', () => {
+        const tracks = [{ id: 1 }, legendTrack(2, { unsortable: false }), { id: 3 }];
+
+        it('initial track order', () => doTest(tracks, '1 2 2Legend 3'));
+
+        describe('After adding a track', () => {
+          it('before the track with the legend', () => doTest(tracks, '1 4 2 2Legend 3', { id: 4 }, 1));
+          it('between the track and its legend', () => doTest(tracks, '1 2 2Legend 4 3', { id: 4 }, 2, 'The legend is locked to its track, so adding between 2 and 2Legend is impossible'));
+          it('after the legend',                 () => doTest(tracks, '1 2 2Legend 4 3', { id: 4 }, 3));
+        });
+
+        describe('After adding multiple tracks', () => {
+          it('before the track with the legend', () => doTest(tracks, '1 4 5 2 2Legend 3', [{ id: 4 }, { id: 5 }], 1));
+          it('between the track and its legend', () => doTest(tracks, '1 2 2Legend 4 5 3', [{ id: 4 }, { id: 5 }], 2, 'The legend is locked to its track, so adding between 2 and 2Legend is impossible'));
+          it('after the legend',                 () => doTest(tracks, '1 2 2Legend 4 5 3', [{ id: 4 }, { id: 5 }], 3));
+        });
+
+        describe('After sorting tracks', () => {
+          it('moving the track with the legend', () => {
+            const genoverse = newGenoverse.call(this, tracks);
+            const deferred  = $.Deferred();
+
+            genoverse._initDeferred.done(() => {
+              moveTrack(genoverse, 3, 2);
+
+              doTest(genoverse, '1 2 2Legend 3', 'The legend is locked to its track, so moving a track between 2 and 2Legend is impossible').done(() => {
+                moveTrack(genoverse, 2);
+
+                doTest(genoverse, '2 1 2Legend 3', 'Once the track has been moved, its legend is no longer locked to it, and should be unaffected').done(() => {
+                  doTest(genoverse, '2 1 4 2Legend 3', { id: 4 }, 2, 'Adding a new track between 2 and 2Legend should now be possible').done(deferred.resolve);
+                });
+              });
+            });
+
+            return deferred;
+          });
+
+          it('moving the legend', () => {
+            const genoverse = newGenoverse.call(this, tracks);
+            const deferred  = $.Deferred();
+
+            genoverse._initDeferred.done(() => {
+              moveTrack(genoverse, 3, 2);
+
+              doTest(genoverse, '1 2 2Legend 3', 'The legend is locked to its track, so moving a track between 2 and 2Legend is impossible').done(() => {
+                moveTrack(genoverse, '2Legend', 3);
+
+                doTest(genoverse, '1 2 3 2Legend', 'The legend should be movable').done(() => {
+                  moveTrack(genoverse, 2);
+
+                  doTest(genoverse, '2 1 3 2Legend', 'Once the legend has been moved, it is no longer locked to its track, and should be unaffected by moving its track').done(() => {
+                    doTest(genoverse, '2 1 4 3 2Legend', { id: 4 }, 2, 'Adding a new track between 2 and 2Legend should now be possible').done(deferred.resolve);
+                  });
+                });
+              });
+            });
+
+            return deferred;
+          });
+        });
+
+        describe('After reset config', () => {
+          it('initial track order restored', () => resetConfig(tracks, [ 3, 1, 2, '2Legend' ], '1 2 2Legend 3'));
+        });
+
+        describe('Legend with order', () => {
+          it('initial track order', () => doTest([{ id: 1 }, legendTrack(2, { unsortable: false, order: 9e99 }), { id: 3 }], '1 2 2Legend 3', 'Legend order property should be ignored'));
+        });
+      });
+    });
+
+    describe('Legend not locked to track', () => {
+      describe('Legend unsortable', () => {
+        const tracks = [{ id: 1 }, legendTrack(2, { lockToTrack: false }), { id: 3 }];
+
+        it('initial track order', () => doTest(tracks, '1 2 3 2Legend'));
+
+        describe('After adding a track', () => {
+          it('before the track with the legend', () => doTest(tracks, '1 4 2 3 2Legend', { id: 4 }, 1));
+          it('between the track and its legend', () => doTest(tracks, '1 2 4 3 2Legend', { id: 4 }, 2));
+          it('after the legend',                 () => doTest(tracks, '1 2 3 2Legend 4', { id: 4 }, 4));
+
+          it('with an ordered legend', () => doTest(tracks, '4Legend 1 2 3 4 2Legend', legendTrack(4, { lockToTrack: false, order: -1 }), 3));
+        });
+
+        describe('After adding multiple tracks', () => {
+          it('before the track with the legend', () => doTest(tracks, '1 4 5 2 3 2Legend', [{ id: 4 }, { id: 5 }], 1));
+          it('between the track and its legend', () => doTest(tracks, '1 2 4 5 3 2Legend', [{ id: 4 }, { id: 5 }], 2));
+          it('after the legend',                 () => doTest(tracks, '1 2 3 2Legend 4 5', [{ id: 4 }, { id: 5 }], 4));
+
+          it('with ordered legends', () => doTest(tracks, '4Legend 1 2 4 5 3 2Legend 5Legend', [
+            legendTrack(4, { lockToTrack: false, order: -1 }),
+            legendTrack(5, { lockToTrack: false, order: 9e99 }),
+          ], 2, 'New tracks should be added between 2Legend and 3, new legends at the start and end'));
+        });
+
+        describe('After sorting tracks', () => {
+          it('moving the track with the legend', () => {
+            const genoverse = newGenoverse.call(this, tracks);
+            const deferred  = $.Deferred();
+
+            genoverse._initDeferred.done(() => {
+              moveTrack(genoverse, 1, 2);
+
+              doTest(genoverse, '2 1 3 2Legend', 'The legend is not locked to its track, so moving a track between 2 and 2Legend is possible').done(() => {
+                moveTrack(genoverse, 2, 1);
+
+                doTest(genoverse, '1 2 3 2Legend', 'The legend should be unaffected by moving its track').done(() => {
+                  doTest(genoverse, '1 2 4 3 2Legend', { id: 4 }, 2, 'Adding a new track between 2 and 2Legend should be possible').done(deferred.resolve);
+                });
+              });
+            });
+
+            return deferred;
+          });
+
+          it('moving the legend', () => {
+            const genoverse = newGenoverse.call(this, tracks);
+            const deferred  = $.Deferred();
+
+            genoverse._initDeferred.done(() => {
+              moveTrack(genoverse, 1, 2);
+
+              doTest(genoverse, '2 1 3 2Legend', 'The legend is not locked to its track, so moving a track between 2 and 2Legend is possible').done(() => {
+                moveTrack(genoverse, '2Legend', 1);
+
+                doTest(genoverse, '2 1 3 2Legend', 'Trying to move an unsortable track should have no effect').done(() => {
+                  doTest(genoverse, '2 4 1 3 2Legend', { id: 4 }, 1, 'Adding a new track between 2 and 2Legend should be possible').done(deferred.resolve);
+                });
+              });
+            });
+
+            return deferred;
+          });
+        });
+
+        describe('After reset config', () => {
+          it('initial track order restored', () => resetConfig(tracks, [ 3, '2Legend', 1, 2 ], '1 2 3 2Legend'));
+        });
+
+        describe('Legend with order', () => {
+          it('initial track order', () => doTest([{ id: 1 }, legendTrack(2, { lockToTrack: false, order: -1 }), { id: 3 }], '2Legend 1 2 3', 'Legend should be at the start'));
+        });
+      });
+
+      describe('Legend sortable', () => {
+        const tracks = [{ id: 1 }, legendTrack(2, { lockToTrack: false, unsortable: false }), { id: 3 }];
+
+        it('initial track order', () => doTest(tracks, '1 2 3 2Legend'));
+
+        describe('After adding a track', () => {
+          it('before the track with the legend', () => doTest(tracks, '1 4 2 3 2Legend', { id: 4 }, 1));
+          it('between the track and its legend', () => doTest(tracks, '1 2 4 3 2Legend', { id: 4 }, 2));
+          it('after the legend',                 () => doTest(tracks, '1 2 3 2Legend 4', { id: 4 }, 4));
+        });
+
+        describe('After adding multiple tracks', () => {
+          it('before the track with the legend', () => doTest(tracks, '1 4 5 2 3 2Legend', [{ id: 4 }, { id: 5 }], 1));
+          it('between the track and its legend', () => doTest(tracks, '1 2 4 5 3 2Legend', [{ id: 4 }, { id: 5 }], 2));
+          it('after the legend',                 () => doTest(tracks, '1 2 3 2Legend 4 5', [{ id: 4 }, { id: 5 }], 4));
+        });
+
+        describe('After sorting tracks', () => {
+          it('moving the track with the legend', () => {
+            const genoverse = newGenoverse.call(this, tracks);
+            const deferred  = $.Deferred();
+
+            genoverse._initDeferred.done(() => {
+              moveTrack(genoverse, 1, 2);
+
+              doTest(genoverse, '2 1 3 2Legend', 'The legend is not locked to its track, so moving a track between 2 and 2Legend is possible').done(() => {
+                moveTrack(genoverse, 2, 1);
+
+                doTest(genoverse, '1 2 3 2Legend', 'The legend should be unaffected by moving its track').done(() => {
+                  doTest(genoverse, '1 2 4 3 2Legend', { id: 4 }, 2, 'Adding a new track between 2 and 2Legend should be possible').done(deferred.resolve);
+                });
+              });
+            });
+
+            return deferred;
+          });
+
+          it('moving the legend', () => {
+            const genoverse = newGenoverse.call(this, tracks);
+            const deferred  = $.Deferred();
+
+            genoverse._initDeferred.done(() => {
+              moveTrack(genoverse, 1, 2);
+
+              doTest(genoverse, '2 1 3 2Legend', 'The legend is not locked to its track, so moving a track between 2 and 2Legend is possible').done(() => {
+                moveTrack(genoverse, '2Legend', 1);
+
+                doTest(genoverse, '2 1 2Legend 3', 'Legend should be between 1 and 3').done(() => {
+                  doTest(genoverse, '2 4 1 2Legend 3', { id: 4 }, 1, 'Adding a new track between 2 and 2Legend should be possible').done(deferred.resolve);
+                });
+              });
+            });
+
+            return deferred;
+          });
+        });
+
+        describe('After reset config', () => {
+          it('initial track order restored', () => resetConfig(tracks, [ 3, '2Legend', 1, 2 ], '1 2 3 2Legend'));
+        });
+
+        describe('Legend with order', () => {
+          it('initial track order', () => doTest([{ id: 1 }, legendTrack(2, { lockToTrack: false, unsortable: false, order: -1 }), { id: 3 }], '2Legend 1 2 3', 'Legend should be at the start'));
+        });
+      });
+    });
+  });
+
+  describe('Stranded tracks', () => {
+    describe('Without explicit order', () => {
+      const tracks = [{ id: 1 }, { id: 2, stranded: true }, { id: 3 }];
+
+      it('initial track order', () => doTest(tracks, '1 2 2Reverse 3'));
+
+      describe('After adding a track', () => {
+        it('without an after argument', () => doTest(tracks, '1 2 2Reverse 3 4 4Reverse', { id: 4, stranded: true }));
+        it('with an after argument',    () => doTest(tracks, '1 2 4 4Reverse 2Reverse 3', { id: 4, stranded: true }, 2));
+      });
+
+      describe('After adding multiple tracks', () => {
+        it('without an after argument', () => doTest(tracks, '1 2 2Reverse 3 4 4Reverse 5 5Reverse', [{ id: 4, stranded: true }, { id: 5, stranded: true }]));
+        it('with an after argument',    () => doTest(tracks, '1 2 4 4Reverse 5 5Reverse 2Reverse 3', [{ id: 4, stranded: true }, { id: 5, stranded: true }], 2));
+      });
+
+      describe('After reset config', () => {
+        it('initial track order restored', () => resetConfig(tracks, [ 2, 3, 1, '2Reverse' ], '1 2 2Reverse 3'));
+      });
+    });
+
+    describe('With explicit order', () => {
+      const tracks = [{ id: 1 }, { id: 2, stranded: true, order: -1 }, { id: 3 }];
+
+      it('initial track order', () => doTest(tracks, '2 2Reverse 1 3'));
+
+      describe('After adding a track', () => {
+        it('without an after argument', () => doTest(tracks, '2 2Reverse 1 4 4Reverse 3', { id: 4, stranded: true, order: 2 }));
+        it('with an after argument',    () => doTest(tracks, '2 2Reverse 1 4 4Reverse 3', { id: 4, stranded: true, order: 2 }, 1, 'Track order should take precedence over after argument'));
+      });
+
+      describe('After adding multiple tracks', () => {
+        const add = [{ id: 4, stranded: true, order: 2 }, { id: 5, stranded: true, order: -1 }];
+
+        it('without an after argument', () => doTest(tracks, '5 5Reverse 2 2Reverse 1 4 4Reverse 3', add));
+        it('with an after argument',    () => doTest(tracks, '5 5Reverse 2 2Reverse 1 4 4Reverse 3', add, 1, 'Track order should take precedence over after argument'));
+      });
+
+      describe('After reset config', () => {
+        it('initial track order restored', () => resetConfig(tracks, [ 3, 2, 1, '2Reverse' ], '2 2Reverse 1 3'));
+      });
+    });
+
+    describe('With explicit order and orderReverse', () => {
+      const tracks = [{ id: 1 }, { id: 2, stranded: true, order: -1, orderReverse: 9e99 }, { id: 3 }];
+
+      it('initial track order', () => doTest(tracks, '2 1 3 2Reverse'));
+
+      describe('After adding a track', () => {
+        it('without an after argument', () => doTest(tracks, '2 1 4Reverse 3 4 2Reverse', { id: 4, stranded: true, order: 2, orderReverse: 1 }));
+        it('with an after argument',    () => doTest(tracks, '2 1 4Reverse 3 4 2Reverse', { id: 4, stranded: true, order: 2, orderReverse: 1 }, 1, 'Track order should take precedence over after argument'));
+      });
+
+      describe('After adding multiple tracks', () => {
+        const add = [{ id: 4, stranded: true, order: 2, orderReverse: 9e99 }, { id: 5, stranded: true, order: -1, orderReverse: 1 }];
+
+        it('without an after argument', () => doTest(tracks, '5 2 5Reverse 1 3 4 2Reverse 4Reverse', add));
+        it('with an after argument',    () => doTest(tracks, '5 2 5Reverse 1 3 4 2Reverse 4Reverse', add, 1, 'Track order should take precedence over after argument'));
+      });
+
+      describe('After reset config', () => {
+        it('initial track order restored', () => resetConfig(tracks, [ 3, 2, 1, '2Reverse' ], '2 1 3 2Reverse'));
+      });
+    });
+  });
+});

package/test/track_config/__snapshots__/config-settings.test.js.snap

@@ -0,0 +1,23 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Config settings Features are drawn correctly when squish = false, colorscheme = green 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAABKUlEQVRoge3XvStFYRwH8M+9rnQnYfM2sMhqsjL6T9hMBvEkxUTKzCQyYTKYMPgLZJHBxGAQ6UoYvFwlZdA5N+f3Gc/z1PPtfHtOv0MI4WelvANkLnn55b5c3k05j0PDz6KQBhOFNJgopMFEISGEEMI/UcQ/9QoecfH+5F7ZhBlH5vV4so4B1LAsWc0yXlGnrJqkX9KPGc8Wv6zNSboxjCnJYJbBilpIXUkVN2DapeQQJNc4Q2eWcSpZHtZAWiTnaPaiFaPfdrzdjD6cZBmsqDfk45PVizFs2Nb0ubqgDZsYl9xlGayohdQlx+hwqgssqarZwYpkP+s4UcicITRrdyWpuLWlZF+ylkecoo+9ZTx4m6b2JCM4UB+JKZk0azePqCGEEEII4a+8Ajr+OQqmnqEWAAAAAElFTkSuQmCC"`;
+
+exports[`Config settings Features are drawn correctly when squish = true 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAOCAYAAADZjbloAAAABmJLR0QA/wD/AP+gvaeTAAAAMUlEQVRYhe3QsQ0AIBACQHTy31xXMBa+xV1NAiHhK6N7wGuVWoe5lm9mRykAAAAAXNhqIQMEUroGNQAAAABJRU5ErkJggg=="`;
+
+exports[`Config settings Features are drawn correctly when squish = true, colorscheme = red 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAOCAYAAADZjbloAAAABmJLR0QA/wD/AP+gvaeTAAAAMklEQVRYhe3QsQ0AIAwDsJT/fy4vIAbKYM+REiXhKzU94LVO+iRXQ9+siVIAAAAAuLABJtwCBO+3j10AAAAASUVORK5CYII="`;
+
+exports[`Config settings Features are drawn correctly when type = a, subtype = 1 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAAA3UlEQVRoge3XIU4DQRQG4I/6Kg5ACCXBYzkAwVCBqeQAnAeDIpg9ARLDDXAQaCCpqidBgdht0hYQJDC7Yf/PzGR2xZ+8vLezRMT3NvD+g3fjjw3aDhCrUpCOSUE6JgXpmBQkIiLiHxqr/9r31s6vMMdd8UQ9tHzLmuC2WZdd4KhYogBDzLCL+y+ej6RDilh0yDGu8aAeT/utJeq5RUEmqJp95fPYioI28YopHvGMF6vfl4ysQgY4wSW2sYMtPOGgxVy9doPDtbMznDf7St0xb+oOOi0XLSIiIiLiN3wASXQc9dTYvxkAAAAASUVORK5CYII="`;
+
+exports[`Config settings Features are drawn correctly when type = a, subtype = 2 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAABDklEQVRoge3XLUsEURiG4Xs1CRYRbFsMIlvtBlGwrb/BYnG71W7Xv2CwWYQFFYvVJoKIotFq9DbsiOsufgR3Z2SeCwYO7xzmPPBy5nAgIr7W+PtP6i+XHsHa/99E2QHiszSkYtKQiklDKiYNiYiIiJ+40bu1u9hXa4Jd8BG8BbfLy1c7HoIX4G5frQkuF+O5ojGtcvLVitPgE7gAXn8zrwuuji9X9Y3qHtIGTqBxAzyDS8NTbAHzwOWIMsQHj8G1YtwB9wbez4BX4Pr4s9WOs+ALeFcc3PfgA1jsRqfAc3Cz3Jy14RZ4MFA76x3mToJH4E452WrJ0+FfkR1wH1wBX4ud8/60y8kZEREREfXxBqGPXOs0NnobAAAAAElFTkSuQmCC"`;
+
+exports[`Config settings Features are drawn correctly when type = a, subtype = all 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAABgUlEQVRoge3XMWsUQRgG4OdMJWgRAnZpREXSim0QsbC7tFdqExDT2/orkh8gmCtSixBIJI29jURCSDCV2EkgjZ/FzsFljcdtNuCx+R5YdnZ2eXeWj5llSCn9Ww/R4NkpxJR5vSnzrpcb/3sA6bwsyIzJgsyYLMiMyYKklFJKHbSi2rU/rPW/ww98aRYXK9WuPcbyYpHYJr4TB8TrViPuuCH28LbW/wSPNS/IkNgjxvJikVgu7TulMEuXHnGH3cYJ7mP/gvv3NCpI3CJOiAfE1wnPbRPPGo2040b7kD4+4JtqeXrUMrePj/T28ZO4IC+WcBefW76rU0YFGaiWLOU8aJk7wPvS3vw7L+bL/Vf0frV8V+cs4BSHOMARjp3fxTdYsmKBOCUOy4/7iDgmSl7cJD4RL6/uE7plFRu1vl0sj103KcgqUcuL3epnHnPEFvHm0qO9BnbwvNa3hvXSHqpmzJlqBr2YHBc7RC0v1oh14inxu8yc0dFv/wkppZRSSilN8gcDVXYqnpp7DQAAAABJRU5ErkJggg=="`;
+
+exports[`Config settings Features are drawn correctly when type = all, subtype = 1 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAABiElEQVRoge3Xv2vUYBjA8c8brxQHcaiboMhBQcGpq4s4CHXQwcH2uEFXd0dn/4hO2ggniG5utWBXd0HOgoNUBJ0E63CvQ3P2tBUV75Igz2dJ8ibDFx7yixDCryXkv7i2drn8s77Ua6Zv2oqmA8KPYiAtEwNpmRhIy8RAQgghhP/E5N/tNTzBWbyaWF/HZezgfH1pe/JzHe98xXa19NnI7dT3AnJZ9SU7abX+vmmb/MpawVa1nbSG5dqKDreberqppyu5K7n3/czImtx439SMB3IMF3DLwYFs4lOdUb9xVPJxfJD6NuVW9f2TTrW9imd4jQ9Ywsumog4xn0tDzMmOK1xqOmhWxnfICgbV/sDBu6Rp40fWKckVI2V+5EjTUbPQwQIu4hxG1VrCneq4VdKqrVxa8MVJvG26Z9oKXMd9nEEXp/HG3juldXJpCXNOeN90yywUuIGnP60/tv/YGmADixjiZm11++ZzaZhL27IHRvpp2S7kdQOFDdliLg3zw0b6QgghhBBCq30D6/ZWOtSjL1sAAAAASUVORK5CYII="`;
+
+exports[`Config settings Features are drawn correctly when type = all, subtype = all, colorscheme = default 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAAC2ElEQVRoge3XP4gcVQCA8d/b3BEOlGBOEIyJxG30wOqqgI2xEEwRC1Hujmu00mATLVKEy+M4SGwiASsJCpLF3FkY0ySCkJBcYWMbRDktIpIoKgQlroR9Fju7mbtjz9k/4Cnva2aYWb79dt+8mTdkMpneBKQ+PluBVNEXKvlSo1pfmKvWF8VKvihW/L2jpfZvfGmmN3lAthl5QLYZeUC2GXlAMplMJpP5n1B+G30Rn+IpfF06fg7P4xaerq5OJV8ofGkvPsSTaOJdwntbWq4Y86O/8H1x6A8tR8K865AaRV9wK8z+c18Ux1jvq6kdWbBwfcnS3nvureuL4pZ9o6a8yprBarEtcxYvDODu5VskPIYDOEaaquBqhjn1MKcuWBCc6p5pOSv13deMYj2KdSy0tE6Vzi1GsdsXxSp9I6MzIA/iGbxq8x94Fb/1p00PFL7X8Mr94+Em4Vqx/5P2THy0z+YJwa9d47yrUr99pSJhgrbvuOM3o3gNojho31CMFdvDuIRv8TOm8dUQ3sP4nPAN6RfSNGGDL03hCXxZwbczNaxhXLJLzXNDtMHOKK5hPEm72OwrZkbVvpHRmSEzWC72l22eJf0yg4+L/fObfemh4vwbhN8r+Dq3rH2CQ1oaacWOIfo6t6x9OITGipWu76ST3b4oVukbGTVM4lm8jzW8hZcN/BafJnGw7UtreLvtS4UvTeACzhAu92sPs1Yx6U97ButbTxRXMXnDjT1w2umJpuYFnIli333DUsNL+Aj7Ucfj+E77GTAIhS/sJ9QJJV/aob1qu0T4YBB5apjGuIfdHrBvHYsWpzG+2+7bURy74875IFyO4kB9wxJwBe+gfDW8iSm8rn0LO4BH8AOWtJeuPUiFr3z1p47vE3zh/pITjhI+28JWXvbWJHclx8K8i5DOWRZKfcFSmO3dt2HZW8Nd7dXUxSge3NgXhKMnnOjZl8lkMplMJpP5L/A3+PfT6KCa/bcAAAAASUVORK5CYII="`;
+
+exports[`Config settings Features are drawn correctly when type = b, subtype = 1 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAABFElEQVRoge3XsUrDUBiG4fePLdLJQcFBcOns5OTsINQ7SMgVeA9ODl6E4NIz6E1U0NsobqKLTqJ1yO9iiw5ihoRzjnzP1qTDGz6StCAiv7PYAX/xgLf5nlXpX0sbRewA+UmDJEaDJEaDJEaDiIiI/BPJ/7v1GQMe+ADuvw690nBiNbcAHpgCRxiPVrIXLbQjufzKWljF2CrGGKcY56szDRc4k4htncplkO9GGM/LD1Zzg/MSM6hLg9gBLa17YA4McTYoOIwd1Jdc7pDlI2sX45iG4NesxY7qQy6DrFjJHbDJOzuxW/qQ3SAe2AeGbPEUu6UPub1DCpw3nNomLAB8yhXGAc62B+YYZ1ZyGblXRERERJLyCTOxNkzPojUJAAAAAElFTkSuQmCC"`;
+
+exports[`Config settings Features are drawn correctly when type = b, subtype = 2 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAABRUlEQVRoge3Xr0tDURjG8e+5bsiSOJu/gitiNVk1+p9oMxnG9jAGM00EsyZRltS0YFKDf8GwiMGkwTAUuTI2g9sUYWCQcy+e9xPvOXAe7sO5vBeMMaO5pAP4JtT75b5E3k2UxKFmNCskZayQlLFCUsYKMcYYY/6JEP/UM8A7cN9/9BoRbZYoXVWpznXoHAKLQAzsCu37zBfqlBULFYQKQKlLd+fbWkVoFlgBtoWWfAYLtZAhh8sBzwBFig9ClwBCT8AtMO0zT8bnYSkyLnQHZHv0JoC1nxv6N2MBuPEZLNQbMvhkzQPrwFGDxthgsUZtEjgGNoRefAYLtZAhoWtgqkVrBqBOPRcTnwJ7Qk3feYIvpEJlGcjmyT8KZdq0TxyuKXSQRJ7Qx94IeONzmjoXWgUu+BqJcbitMuWzRMIaY4wxxpg/8gEQ8k4ZTEcv+AAAAABJRU5ErkJggg=="`;
+
+exports[`Config settings Features are drawn correctly when type = b, subtype = all 1`] = `"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAABmJLR0QA/wD/AP+gvaeTAAAB5UlEQVRoge3Xv0uVURgH8M+5KeEkaRBkOeQSQZOTaw1B/QeK/0BuTQ6iDyLoZASNkYuXyqmcHIIiHfoLpEUaisiGAinMkPs2+CMrzHu7N/XG+Wzve16+55z34bw8L1mW7S8d9QIOUpQV1TyXBqrbS4iq8kIcybspHcWk2f5yQY6ZXJBjJhfkmMkFybIsy7L/xPH/U3+mxTvf8Hr71hcVQ2nQIhRls7gmeZ/6XT4oL0QLP+eVlIZGjS5OmDi/aXMGF7GB2yHuNnxTf9AsXdZGGtCTBvRIRiVTuyMV9xSu15oXoidED0YrKlN7xsZDnEMfhkNcqn/51WuWguzVJvm4c5EGPVf49LdhSWpjK2/EyJsQLyDEB7zC2TrXW5OWw5ysDieLshW0KrQruVpvXogVtBaKdn7P2z4ZF/Cyzrlq0iwnZOeT1S25oaJczDlRT972J6sbN1CeM7ebN2nyFB7gZojPda69Js1SkF2p3xI6fdXViLwQS+hcttwF06bbNmw8xp0QC42YoxZNV5CirBetTlttRN648V60duhYDdGyZu1hkhZC3G9Efq2are0tKawrDKdB81DMeiTpwxm8lUykfjP75f3S9pawbqubmg9xBU/9aIkl6daYsSf/bINZlmVZlmXZIfgOYVyDipGMt8MAAAAASUVORK5CYII="`;