Allow tests to run in random order

spec/core/TreeProcessorSpec.js

@@ -690,4 +690,67 @@ describe("TreeProcessor", function() {
     queueableFns[10].fn();
     expect(leaf11.execute).toHaveBeenCalled();
   });
+
+  it("runs nodes in a custom order when orderChildren is overrided", function() {
+    var leaf1 = new Leaf(),
+        leaf2 = new Leaf(),
+        leaf3 = new Leaf(),
+        leaf4 = new Leaf(),
+        leaf5 = new Leaf(),
+        leaf6 = new Leaf(),
+        leaf7 = new Leaf(),
+        leaf8 = new Leaf(),
+        leaf9 = new Leaf(),
+        leaf10 = new Leaf(),
+        leaf11 = new Leaf(),
+        root = new Node({ children: [leaf1, leaf2, leaf3, leaf4, leaf5, leaf6, leaf7, leaf8, leaf9, leaf10, leaf11] }),
+        queueRunner = jasmine.createSpy('queueRunner'),
+        processor = new j$.TreeProcessor({
+          tree: root,
+          runnableIds: [root.id],
+          queueRunnerFactory: queueRunner,
+          orderChildren: function(node) {
+            var children = node.children.slice();
+            return children.reverse();
+          }
+        });
+
+    processor.execute();
+    var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
+    expect(queueableFns.length).toBe(11);
+
+    queueableFns[0].fn();
+    expect(leaf11.execute).toHaveBeenCalled();
+
+    queueableFns[1].fn();
+    expect(leaf10.execute).toHaveBeenCalled();
+
+    queueableFns[2].fn();
+    expect(leaf9.execute).toHaveBeenCalled();
+
+    queueableFns[3].fn();
+    expect(leaf8.execute).toHaveBeenCalled();
+
+    queueableFns[4].fn();
+    expect(leaf7.execute).toHaveBeenCalled();
+
+    queueableFns[5].fn();
+    expect(leaf6.execute).toHaveBeenCalled();
+
+    queueableFns[6].fn();
+    expect(leaf5.execute).toHaveBeenCalled();
+
+    queueableFns[7].fn();
+    expect(leaf4.execute).toHaveBeenCalled();
+
+    queueableFns[8].fn();
+    expect(leaf3.execute).toHaveBeenCalled();
+
+    queueableFns[9].fn();
+    expect(leaf2.execute).toHaveBeenCalled();
+
+    queueableFns[10].fn();
+    expect(leaf1.execute).toHaveBeenCalled();
+
+  });
 });

spec/core/integration/EnvSpec.js

@@ -207,7 +207,6 @@ describe("Env integration", function() {
     var env = new j$.Env();
 
     env.addReporter({jasmineDone: done});
-
     env.describe("tests", function() {
       var firstTimeThrough = true, firstSpecContext, secondSpecContext;
 

spec/core/integration/SpecRunningSpec.js

@@ -696,4 +696,103 @@ describe("jasmine spec running", function () {
       env.execute([spec2.id, spec3.id, spec1.id]);
     }).toThrowError(/afterAll/);
   });
+
+  it("should run the tests in a consistent order when a seed is supplied", function(done) {
+    var actions = [];
+    env.randomizeTests(true);
+    env.seed('123456');
+
+    env.beforeEach(function () {
+      actions.push('topSuite beforeEach');
+    });
+
+    env.afterEach(function () {
+      actions.push('topSuite afterEach');
+    });
+
+    env.describe('Something', function() {
+      env.beforeEach(function() {
+        actions.push('outer beforeEach');
+      });
+
+      env.afterEach(function() {
+        actions.push('outer afterEach');
+      });
+
+      env.it('does it 1', function() {
+        actions.push('outer it 1');
+      });
+
+      env.describe('Inner 1', function() {
+        env.beforeEach(function() {
+          actions.push('inner 1 beforeEach');
+        });
+
+        env.afterEach(function() {
+          actions.push('inner 1 afterEach');
+        });
+
+        env.it('does it 2', function() {
+          actions.push('inner 1 it');
+        });
+      });
+
+      env.it('does it 3', function() {
+        actions.push('outer it 2');
+      });
+
+      env.describe('Inner 2', function() {
+        env.beforeEach(function() {
+          actions.push('inner 2 beforeEach');
+        });
+
+        env.afterEach(function() {
+          actions.push('inner 2 afterEach');
+        });
+
+        env.it('does it 2', function() {
+          actions.push('inner 2 it');
+        });
+      });
+    });
+
+    var assertions = function() {
+      var expected = [
+        'topSuite beforeEach',
+        'outer beforeEach',
+        'outer it 2',
+        'outer afterEach',
+        'topSuite afterEach',
+
+        'topSuite beforeEach',
+        'outer beforeEach',
+        'inner 2 beforeEach',
+        'inner 2 it',
+        'inner 2 afterEach',
+        'outer afterEach',
+        'topSuite afterEach',
+
+        'topSuite beforeEach',
+        'outer beforeEach',
+        'inner 1 beforeEach',
+        'inner 1 it',
+        'inner 1 afterEach',
+        'outer afterEach',
+        'topSuite afterEach',
+
+        'topSuite beforeEach',
+        'outer beforeEach',
+        'outer it 1',
+        'outer afterEach',
+        'topSuite afterEach'
+      ];
+      expect(actions).toEqual(expected);
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
+  });
+
 });

spec/html/HtmlReporterSpec.js

@@ -556,6 +556,142 @@ describe("New HtmlReporter", function() {
       });
     });
 
+    describe("UI for running tests in random order", function() {
+      it("should be unchecked if not randomizing", function() {
+        var env = new j$.Env(),
+          container = document.createElement("div"),
+          getContainer = function() {
+            return container;
+          },
+          reporter = new j$.HtmlReporter({
+            env: env,
+            getContainer: getContainer,
+            createElement: function() {
+              return document.createElement.apply(document, arguments);
+            },
+            createTextNode: function() {
+              return document.createTextNode.apply(document, arguments);
+            }
+          });
+
+        reporter.initialize();
+        reporter.jasmineDone({});
+
+        var randomUI = container.querySelector(".jasmine-random");
+        expect(randomUI.checked).toBe(false);
+      });
+
+      it("should be checked if randomizing", function() {
+        var env = new j$.Env(),
+          container = document.createElement("div"),
+          getContainer = function() {
+            return container;
+          },
+          reporter = new j$.HtmlReporter({
+            env: env,
+            getContainer: getContainer,
+            createElement: function() {
+              return document.createElement.apply(document, arguments);
+            },
+            createTextNode: function() {
+              return document.createTextNode.apply(document, arguments);
+            }
+          });
+
+        env.randomizeTests(true);
+        reporter.initialize();
+        reporter.jasmineDone({});
+
+        var throwingExpectationsUI = container.querySelector(".jasmine-random");
+        expect(throwingExpectationsUI.checked).toBe(true);
+      });
+
+      it("should affect the query param for random tests", function() {
+        var env = new j$.Env(),
+          container = document.createElement("div"),
+          randomHandler = jasmine.createSpy('randomHandler'),
+          getContainer = function() {
+            return container;
+          },
+          reporter = new j$.HtmlReporter({
+            env: env,
+            getContainer: getContainer,
+            onRandomClick: randomHandler,
+            createElement: function() {
+              return document.createElement.apply(document, arguments);
+            },
+            createTextNode: function() {
+              return document.createTextNode.apply(document, arguments);
+            }
+          });
+
+        reporter.initialize();
+        reporter.jasmineDone({});
+
+        var randomUI = container.querySelector(".jasmine-random");
+        randomUI.click();
+
+        expect(randomHandler).toHaveBeenCalled();
+      });
+
+      it("should show the seed bar if randomizing", function() {
+        var env = new j$.Env(),
+            container = document.createElement("div"),
+            getContainer = function() {
+              return container;
+            },
+            reporter = new j$.HtmlReporter({
+              env: env,
+              getContainer: getContainer,
+              createElement: function() {
+                return document.createElement.apply(document, arguments);
+              },
+              createTextNode: function() {
+                return document.createTextNode.apply(document, arguments);
+              }
+            });
+
+        reporter.initialize();
+        reporter.jasmineDone({
+          order: {
+            random: true,
+            seed: '424242'
+          }
+        });
+
+        var seedBar = container.querySelector(".jasmine-seed-bar");
+        var seedBarText = 'textContent' in seedBar ? seedBar.textContent : seedBar.innerText;
+        expect(seedBarText).toBe(', randomized with seed 424242');
+        var seedLink = container.querySelector(".jasmine-seed-bar a");
+        expect(seedLink.getAttribute('href')).toBe('?seed=424242');
+      });
+
+      it("should not show the current seed bar if not randomizing", function() {
+        var env = new j$.Env(),
+            container = document.createElement("div"),
+            getContainer = function() {
+              return container;
+            },
+            reporter = new j$.HtmlReporter({
+              env: env,
+              getContainer: getContainer,
+              createElement: function() {
+                return document.createElement.apply(document, arguments);
+              },
+              createTextNode: function() {
+                return document.createTextNode.apply(document, arguments);
+              }
+            });
+
+        reporter.initialize();
+        reporter.jasmineDone();
+
+        var seedBar = container.querySelector(".jasmine-seed-bar");
+        expect(seedBar).toBeNull();
+      });
+
+    });
+
     it("shows a message if no specs are run", function(){
       var env, container, reporter;
       env = new j$.Env();