File: public/js/lib/director/test/browser/routes-test.js

createTest('Nested route with the many children as a tokens, callbacks should yield historic params', {
  '/a': {
    '/:id': {
      '/:id': function(a, b) {
        shared.fired.push(location.hash, a, b);
      }
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a/b/c', function() {
    deepEqual(shared.fired, ['#/a/b/c', 'b', 'c']);
    this.finish();
  });
});

createTest('Nested route with the first child as a token, callback should yield a param', {
  '/foo': {
    '/:id': {
      on: function(id) {
        shared.fired.push(location.hash, id);
      }
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/foo/a', function() {
    this.navigate('/foo/b/c', function() {
      deepEqual(shared.fired, ['#/foo/a', 'a']);
      this.finish();
    });
  });
});

createTest('Nested route with the first child as a regexp, callback should yield a param', {
  '/foo': {
    '/(\\w+)': {
      on: function(value) {
        shared.fired.push(location.hash, value);
      }
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/foo/a', function() {
    this.navigate('/foo/b/c', function() {
      deepEqual(shared.fired, ['#/foo/a', 'a']);
      this.finish();
    });
  });
});

createTest('Nested route with the several regular expressions, callback should yield a param', {
  '/a': {
    '/(\\w+)': {
      '/(\\w+)': function(a, b) {
        shared.fired.push(a, b);
      }
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a/b/c', function() {
    deepEqual(shared.fired, ['b', 'c']);
    this.finish();
  });
});



createTest('Single nested route with on member containing function value', {
  '/a': {
    '/b': {
      on: function() {
        shared.fired.push(location.hash);
      }
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a/b', function() {
      deepEqual(shared.fired, ['#/a/b']);
      this.finish();
  });
});

createTest('Single non-nested route with on member containing function value', {
  '/a/b': {
    on: function() {
      shared.fired.push(location.hash);
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a/b', function() {
    deepEqual(shared.fired, ['#/a/b']);
    this.finish();
  });
});

createTest('Single nested route with on member containing array of function values', {
  '/a': {
    '/b': {
      on: [function() { shared.fired.push(location.hash); },
        function() { shared.fired.push(location.hash); }]
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a/b', function() {
      deepEqual(shared.fired, ['#/a/b', '#/a/b']);
      this.finish();
  });
});

createTest('method should only fire once on the route.', {
  '/a': {
    '/b': {
      once: function() {
        shared.fired++;
      }
    }
  }
}, function() {
  shared.fired = 0;
  this.navigate('/a/b', function() {
    this.navigate('/a/b', function() {
      this.navigate('/a/b', function() {
        deepEqual(shared.fired, 1);
        this.finish();
      });
    });
  });
});

createTest('method should only fire once on the route, multiple nesting.', {
  '/a': {
    on: function() { shared.fired++; },
    once: function() { shared.fired++; }
  },
  '/b': {
    on: function() { shared.fired++; },
    once: function() { shared.fired++; }
  }
}, function() {
  shared.fired = 0;
  this.navigate('/a', function() {
    this.navigate('/b', function() {
      this.navigate('/a', function() {
        this.navigate('/b', function() {
          deepEqual(shared.fired, 6);
          this.finish();
        });
      });
    });
  });
});

createTest('overlapping routes with tokens.', {
  '/a/:b/c' : function() {
    shared.fired.push(location.hash);
  },
  '/a/:b/c/:d' : function() {
    shared.fired.push(location.hash);
  }
}, function() {
  shared.fired = [];
  this.navigate('/a/b/c', function() {

    this.navigate('/a/b/c/d', function() {
      deepEqual(shared.fired, ['#/a/b/c', '#/a/b/c/d']);
      this.finish();
    });
  });
});

// // //
// // // Recursion features
// // // ----------------------------------------------------------

createTest('Nested routes with no recursion', {
  '/a': {
    '/b': {
      '/c': {
        on: function c() {
          shared.fired.push('c');
        }
      },
      on: function b() {
        shared.fired.push('b');
      }
    },
    on: function a() {
      shared.fired.push('a');
    }
  }
}, function() {
  shared.fired = [];

  this.navigate('/a/b/c', function() {
    deepEqual(shared.fired, ['c']);
    this.finish();
  });
});

createTest('Nested routes with backward recursion', {
  '/a': {
    '/b': {
      '/c': {
        on: function c() {
          shared.fired.push('c');
        }
      },
      on: function b() {
        shared.fired.push('b');
      }
    },
    on: function a() {
      shared.fired.push('a');
    }
  }
}, {
  recurse: 'backward'
}, function() {
  shared.fired = [];

  this.navigate('/a/b/c', function() {
    deepEqual(shared.fired, ['c', 'b', 'a']);
    this.finish();
  });
});

createTest('Breaking out of nested routes with backward recursion', {
  '/a': {
    '/:b': {
      '/c': {
        on: function c() {
          shared.fired.push('c');
        }
      },
      on: function b() {
        shared.fired.push('b');
        return false;
      }
    },
    on: function a() {
      shared.fired.push('a');
    }
  }
}, {
  recurse: 'backward'
}, function() {
  shared.fired = [];

  this.navigate('/a/b/c', function() {
    deepEqual(shared.fired, ['c', 'b']);
    this.finish();
  });
});

createTest('Nested routes with forward recursion', {
  '/a': {
    '/b': {
      '/c': {
        on: function c() {
          shared.fired.push('c');
        }
      },
      on: function b() {
        shared.fired.push('b');
      }
    },
    on: function a() {
      shared.fired.push('a');
    }
  }
}, {
  recurse: 'forward'
}, function() {
  shared.fired = [];

  this.navigate('/a/b/c', function() {
    deepEqual(shared.fired, ['a', 'b', 'c']);
    this.finish();
  });
});

createTest('Nested routes with forward recursion, single route with an after event.', {
  '/a': {
    '/b': {
      '/c': {
        on: function c() {
          shared.fired.push('c');
        },
        after: function() {
          shared.fired.push('c-after');
        }
      },
      on: function b() {
        shared.fired.push('b');
      }
    },
    on: function a() {
      shared.fired.push('a');
    }
  }
}, {
  recurse: 'forward'
}, function() {
  shared.fired = [];

  this.navigate('/a/b/c', function() {
    this.navigate('/a/b', function() {
      deepEqual(shared.fired, ['a', 'b', 'c', 'c-after', 'a', 'b']);
      this.finish();
    });
  });
});

createTest('Breaking out of nested routes with forward recursion', {
  '/a': {
    '/b': {
      '/c': {
        on: function c() {
          shared.fired.push('c');
        }
      },
      on: function b() {
        shared.fired.push('b');
        return false;
      }
    },
    on: function a() {
      shared.fired.push('a');
    }
  }
}, {
  recurse: 'forward'
}, function() {
  shared.fired = [];

  this.navigate('/a/b/c', function() {
    deepEqual(shared.fired, ['a', 'b']);
    this.finish();
  });
});

//
// ABOVE IS WORKING
//

// //
// // Special Events
// // ----------------------------------------------------------

createTest('All global event should fire after every route', {
  '/a': {
    on: function a() {
      shared.fired.push('a');
    }
  },
  '/b': {
    '/c': {
      on: function a() {
        shared.fired.push('a');
      }
    }
  },
  '/d': {
    '/:e': {
      on: function a() {
        shared.fired.push('a');
      }
    }
  }
}, {
  after: function() {
    shared.fired.push('b');
  }
}, function() {
  shared.fired = [];

  this.navigate('/a', function() {
    this.navigate('/b/c', function() {
      this.navigate('/d/e', function() {
        deepEqual(shared.fired, ['a', 'b', 'a', 'b', 'a']);
        this.finish();
      });
    });
  });

});

createTest('Not found.', {
  '/a': {
    on: function a() {
      shared.fired.push('a');
    }
  },
  '/b': {
    on: function a() {
      shared.fired.push('b');
    }
  }
}, {
  notfound: function() {
    shared.fired.push('notfound');
  }
}, function() {
  shared.fired = [];

  this.navigate('/c', function() {
    this.navigate('/d', function() {
      deepEqual(shared.fired, ['notfound', 'notfound']);
      this.finish();
    });
  });
});

createTest('On all.', {
  '/a': {
    on: function a() {
      shared.fired.push('a');
    }
  },
  '/b': {
    on: function a() {
      shared.fired.push('b');
    }
  }
}, {
  on: function() {
    shared.fired.push('c');
  }
}, function() {
  shared.fired = [];

  this.navigate('/a', function() {
    this.navigate('/b', function() {
      deepEqual(shared.fired, ['a', 'c', 'b', 'c']);
      this.finish();
    });
  });
});


createTest('After all.', {
  '/a': {
    on: function a() {
      shared.fired.push('a');
    }
  },
  '/b': {
    on: function a() {
      shared.fired.push('b');
    }
  }
}, {
  after: function() {
    shared.fired.push('c');
  }
}, function() {
  shared.fired = [];

  this.navigate('/a', function() {
    this.navigate('/b', function() {
      deepEqual(shared.fired, ['a', 'c', 'b']);
      this.finish();
    });
  });
});

createTest('resource object.', {
  '/a': {
    '/b/:c': {
      on: 'f1'
    },
    on: 'f2'
  },
  '/d': {
    on: ['f1', 'f2']
  }
},
{
  resource: {
    f1: function (name){
        shared.fired.push("f1-" + name);
    },
    f2: function (name){
        shared.fired.push("f2");
    }
  }
}, function() {
  shared.fired = [];

  this.navigate('/a/b/c', function() {
    this.navigate('/d', function() {
      deepEqual(shared.fired, ['f1-c', 'f1-undefined', 'f2']);
      this.finish();
    });
  });
});

createTest('argument matching should be case agnostic', {
  '/fooBar/:name': {
      on: function(name) {
        shared.fired.push("fooBar-" + name);
      }
    }
}, function() {
  shared.fired = [];
  this.navigate('/fooBar/tesTing', function() {
    deepEqual(shared.fired, ['fooBar-tesTing']);
    this.finish();
  });
});

createTest('sanity test', {
  '/is/:this/:sane': {
    on: function(a, b) {
      shared.fired.push('yes ' + a + ' is ' + b);
    }
  },
  '/': {
    on: function() {
      shared.fired.push('is there sanity?');
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/is/there/sanity', function() {
    deepEqual(shared.fired, ['yes there is sanity']);
    this.finish();
  });
});

createTest('`/` route should be navigable from the routing table', {
  '/': {
    on: function root() {
      shared.fired.push('/');
    }
  },
  '/:username': {
    on: function afunc(username) {
      shared.fired.push('/' + username);
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/', function root() {
    deepEqual(shared.fired, ['/']);
    this.finish();
  });
});

createTest('`/` route should not override a `/:token` route', {
  '/': {
    on: function root() {
      shared.fired.push('/');
    }
  },
  '/:username': {
    on: function afunc(username) {
      shared.fired.push('/' + username);
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a', function afunc() {
    deepEqual(shared.fired, ['/a']);
    this.finish();
  });
});

createTest('should accept the root as a token.', {
  '/:a': {
    on: function root() {
      shared.fired.push(location.hash);
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a', function root() {
    deepEqual(shared.fired, ['#/a']);
    this.finish();
  });
});

createTest('routes should allow wildcards.', {
  '/:a/b*d': {
    on: function() {
      shared.fired.push(location.hash);
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a/bcd', function root() {
    deepEqual(shared.fired, ['#/a/bcd']);
    this.finish();
  });
});

createTest('functions should have |this| context of the router instance.', {
  '/': {
    on: function root() {
      shared.fired.push(!!this.routes);
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/', function root() {
    deepEqual(shared.fired, [true]);
    this.finish();
  });
});

createTest('setRoute with a single parameter should change location correctly', {
  '/bonk': {
    on: function() {
      shared.fired.push(window.location.hash);
    }
  }
}, function() {
  var self = this;
  shared.fired = [];
  this.router.setRoute('/bonk');
  setTimeout(function() {
    deepEqual(shared.fired, ['#/bonk']);
    self.finish();
  }, 14)
});

createTest('route should accept _ and . within parameters', {
  '/:a': {
    on: function root() {
      shared.fired.push(location.hash);
    }
  }
}, function() {
  shared.fired = [];
  this.navigate('/a_complex_route.co.uk', function root() {
    deepEqual(shared.fired, ['#/a_complex_route.co.uk']);
    this.finish();
  });
});

createTest('initializing with a default route should only result in one route handling', {
    '/': {
      on: function root() {
        if (!shared.init){
            shared.init = 0;
        }
        shared.init++;
      }
    },
    '/test': {
      on: function root() {
        if (!shared.test){
            shared.test = 0;
        }
        shared.test++;
      }
    }
  }, function() {
    this.navigate('/test', function root() {
      equal(shared.init, 1);
      equal(shared.test, 1);
      this.finish();
    });
  },
  null,
  '/');

createTest('changing the hash twice should call each route once', {
    '/hash1': {
      on: function root() {
          shared.fired.push('hash1');
      }
    },
    '/hash2': {
        on: function root() {
            shared.fired.push('hash2');
        }
      }
  }, function() {
    shared.fired = [];
    this.navigate('/hash1', function(){});
    this.navigate('/hash2', function(){
      deepEqual(shared.fired, ['hash1', 'hash2']);
      this.finish();
    });
  }
);

// This test doesn't use the createTest since createTest runs init on the router before
// running the test, which is what we want to test.
test('fire the correct route when initializing the router', function(){
  window.location.hash = 'initial';
  var fired = [];
  var router = new (window.Router || window.RouterAlias)({
    '/initial': function(){
      fired.push('/initial');
    },
    'initial': function(){
      fired.push('initial');
    }
  });
  router.init();
  deepEqual(fired, ['/initial', 'initial']);
  router.destroy();
});

test('do not combine hash if convert_hash_in_init is false', function(){
  window.location.hash = 'initial';
  var fired = [];
  var initialPath = window.location.pathname;
  var routes = {
    '/initial': function(){
      fired.push('/initial');
    },
    'initial': function(){
      fired.push('initial');
    }
  };
  routes[initialPath] = function(){
    fired.push('*');
  };

  var router = new (window.Router || window.RouterAlias)(routes);

  router.configure({
    html5history: true,
    convert_hash_in_init: false
  });
  router.init();
  deepEqual(fired, ['*']);
  router.destroy();
});