           birth_date: moment([1961, 6, 7]).valueOf()
           scan_sets:
             t1:
-              modeling:
+              modeling: [
                 results: [
                   delta_k_trans:
                     average: 2.6
                 ]
+              ]
             t2:
-              modeling:
+              modeling: [
                 results: [
                   delta_k_trans:
                     average: 2.4
                 ]
+              ]
           registration_configurations:
             reg_01:
-              modeling:
+              modeling: [
                 results: [
                   delta_k_trans:
                     average: 2.3
                 ]
+              ]
             reg_02:
-              modeling:
+              modeling: [
                 results: [
                   delta_k_trans:
                     average: 2.1
                 ]
+              ]
           sessions: [
             number: 1
             acquisition_date: moment('July 1, 2013').valueOf()

            .to.deep.eql(mock_reg.intensity)

        beforeEach ->
          mock_session = mock.subject_detail.sessions[0]
          # The session subject reference is set in the routes
          # session resolution.
          mock_session.subject = mock.subject

        it 'should fetch the session detail', ->
          session = _.clone(mock_session)
          Router.getSessionDetail(session).then ->
            validate(session)
          # Dispatch the backend request.
          $httpBackend.flush()

      describe 'Scan', ->
        mock_session = null

        beforeEach ->
          mock_session = _.clone(mock.subject_detail.sessions[0])
          # The session subject reference is set in the routes
          # session resolution.
          mock_session.subject = mock.subject

        it 'should find the scan container in a fetched session', ->
          session = _.clone(mock_session)
          session.scans = mock.session_detail.scans
          mock_scan = mock.session_detail.scans.t1
          actual = Router.getScan(session, mock_scan.name)
          expect(actual, 'Image container missing').to.exist
          expect(actual, 'Image container incorrect')
            .to.equal(mock.session_detail.scans.t1)

        it 'should fetch a session if necessary to obtain the scan', ->
          session = _.clone(mock_session)
          mock_scan = mock.session_detail.scans.t1
          Router.getScan(session, mock_scan.name).then (container) ->
            expect(container, 'Image container missing').to.exist
            expect(container.intensity, 'Image container intensity incorrect').
              to.eql(mock_scan.intensity)

          # Dispatch the backend request.
          $httpBackend.flush()

          # The first modeling is for the T1 scan.
          mdl = subject.modeling[0]
          expect(mdl.source, "Modeling is missing a source").to.exist
          expect(mdl.source.key, "Modeling source is missing the key")
            .to.exist
          expect(mdl.source.key, "Modeling source key is incorrect")
            .to.equal('t1')
          mockMdl = mock.subject_detail.scan_sets.t1.modeling[0]
          expect(mdl.results, "Modeling is missing results").to.exist
          expect(mdl.results.length, "Modeling results count is incorrect").
            to.equal(1)
