Added condition property to do extra tests on route params, etc.

modules/__tests__/Router-test.js

@@ -276,6 +276,76 @@ describe('Router', function () {
 
   })
 
+
+  describe('conditions', function () {
+    it('matches route with condition match', function (done) {
+      class MyComponent extends Component {
+        render() {
+          return <div>{this.props.params.fruit}</div>
+        }
+      }
+
+
+      let conditionCalled = false
+      function condition(match, callback) {
+        conditionCalled = true
+        callback(null, true)
+      }
+
+      render((
+        <Router history={createHistory('/apple')}>
+          <Route path=":fruit" component={MyComponent} condition={condition} />
+        </Router>
+      ), node, function () {
+        expect(node.textContent).toEqual('apple')
+        expect(conditionCalled).toEqual(true)
+        done()
+      })
+    })
+
+
+    it('calls condition on both parent and child routes', function (done) {
+      class Parent extends Component {
+        render() {
+          return <div>{this.props.children}</div>
+        }
+      }
+
+      class Child extends Component {
+        render() {
+          return <h1>{this.props.params.name}</h1>
+        }
+      }
+
+
+      let conditionParentCalled = false
+      function conditionParent(match, callback) {
+        conditionParentCalled = true
+        callback(null, true)
+      }
+
+      let conditionChildCalled = false
+      function conditionChild(match, callback) {
+        conditionChildCalled = true
+        callback(null, true)
+      }
+
+      render((
+        <Router history={createHistory('/apple')}>
+          <Route component={Parent} condition={conditionParent}>
+            <Route path="/:name" component={Child} condition={conditionChild} />
+          </Route>
+        </Router>
+      ), node, function () {
+        expect(node.textContent).toEqual('apple')
+        expect(conditionParentCalled).toEqual(true)
+        expect(conditionChildCalled).toEqual(true)
+        done()
+      })
+    })
+
+  })
+
   describe('render prop', function () {
     it('renders with the render prop', function (done) {
       render((

modules/__tests__/matchRoutes-test.js

@@ -331,6 +331,107 @@ describe('matchRoutes', function () {
     })
   })
 
+  describe('routes with conditions', function () {
+    it('matches single route', function (done) {
+      let Condition, conditionCalled = 0
+
+      const routes = [
+        Condition = {
+          path: '/',
+          condition: (match, callback) => {
+            conditionCalled++
+            callback(null, true)
+          }
+        }
+      ]
+
+      matchRoutes(routes, createLocation('/'), function (error, match) {
+        expect(match).toExist()
+        expect(match.routes).toEqual([ Condition ])
+        expect(conditionCalled).toEqual(1)
+        done()
+      })
+    })
+
+    it('does not match single route', function (done) {
+      let conditionCalled = 0
+
+      const routes = [ {
+        path: '/',
+        condition: (match, callback) => {
+          conditionCalled++
+          callback(null, false)
+        }
+      } ]
+
+      matchRoutes(routes, createLocation('/'), function (error, match) {
+        expect(match).toNotExist()
+        expect(conditionCalled).toEqual(1)
+        done()
+      })
+    })
+
+    it('matches nested routes', function (done) {
+      let Parent, Child, parentConditionCalled = 0, childConditionCalled = 0
+
+      const routes = [
+        Parent = {
+          condition: (match, callback) => {
+            parentConditionCalled++
+            callback(null, true)
+          },
+          childRoutes: [
+            Child = {
+              path: '/',
+              condition: (match, callback) => {
+                childConditionCalled++
+                callback(null, true)
+              }
+            }
+          ]
+        }
+      ]
+
+      matchRoutes(routes, createLocation('/'), function (error, match) {
+        expect(match).toExist()
+        expect(match.routes).toEqual([ Parent, Child ])
+        expect(parentConditionCalled).toEqual(1)
+        expect(childConditionCalled).toEqual(1)
+        done()
+      })
+    })
+
+    it('does not match nested routes on parent condition failure', function (done) {
+      let parentConditionCalled = 0, childConditionCalled = 0
+
+      const routes = [
+        {
+          path: '/:food/',
+          condition: (match, callback) => {
+            parentConditionCalled++
+            callback(null, false)
+          },
+          childRoutes: [
+            {
+              path: ':color',
+              condition: (match, callback) => {
+                childConditionCalled++
+                callback(null, true)
+              }
+            }
+          ]
+        }
+      ]
+
+      matchRoutes(routes, createLocation('/apple/orange'), function (error, match) {
+        expect(match).toNotExist()
+        expect(parentConditionCalled).toEqual(1)
+        expect(childConditionCalled).toEqual(0)
+        done()
+      })
+    })
+  })
+
   describe('invalid route configs', function () {
     let invalidRoutes, errorSpy
 

modules/__tests__/serverRendering-test.js

@@ -56,6 +56,28 @@ describe('server rendering', function () {
     }
   }
 
+  class Category extends Component {
+    render() {
+      return (
+        <div className="Category">
+          <h1>Category</h1>
+          <div>{this.props.params.category}</div>
+        </div>
+      )
+    }
+  }
+
+  class Post extends Component {
+    render() {
+      return (
+        <div className="Post">
+          <h1>Post</h1>
+          <div>{this.props.params.slug}</div>
+        </div>
+      )
+    }
+  }
+
   const DashboardRoute = {
     path: '/dashboard',
     component: Dashboard
@@ -80,10 +102,23 @@ describe('server rendering', function () {
     }
   }
 
+  const CategoryRoute = {
+    path: '/food/:category',
+    condition(params, callback) {
+      callback(null, [ 'baking', 'bbq' ].indexOf(params.category) > -1)
+    },
+    component: Category
+  }
+
+  const PostRoute = {
+    path: '/food/:slug',
+    component: Post
+  }
+
   const routes = {
     path: '/',
     component: App,
-    childRoutes: [ DashboardRoute, AboutRoute, RedirectRoute, AsyncRoute ]
+    childRoutes: [ DashboardRoute, AboutRoute, RedirectRoute, AsyncRoute, CategoryRoute, PostRoute ]
   }
 
   it('works for synchronous route', function (done) {
@@ -200,4 +235,26 @@ describe('server rendering', function () {
       })
     })
   })
+
+  it('condition matches category route', function (done) {
+    match({ routes, location: '/food/bbq' }, function (error, redirectLocation, renderProps) {
+      const string = renderToString(
+        <RouterContext {...renderProps} />
+      )
+      expect(string).toMatch(/Category/)
+      expect(string).toMatch(/bbq/)
+      done()
+    })
+  })
+
+  it('condition does not match and moves to next mached route', function (done) {
+    match({ routes, location: '/food/pizza-hut' }, function (error, redirectLocation, renderProps) {
+      const string = renderToString(
+        <RouterContext {...renderProps} />
+      )
+      expect(string).toMatch(/Post/)
+      expect(string).toMatch(/pizza-hut/)
+      done()
+    })
+  })
 })