more tests

www/waterfall_view/src/module/data/data.service.coffee

@@ -37,4 +37,4 @@ class Data extends Service
             for build in builder.builds
                 latest ?= build
                 if build.number > latest.number then latest = build
-            builder.results = latest?.results
+            builder.results = latest?.results or 'pending'

www/waterfall_view/src/module/data/data.service.spec.coffee

@@ -0,0 +1,128 @@
+beforeEach ->
+    module 'waterfall_view'
+
+describe 'Scale service', ->
+
+    ###
+    # Test data
+    ###
+    builders = [
+        builderid: 1
+        name: 'builder1'
+    ,
+        builderid: 2
+        name: 'builder2'
+    ,
+        builderid: 3
+        name: 'builder3'
+    ,
+        builderid: 4
+        name: 'builder4'
+    ]
+
+    builds = [
+        buildid: 1
+        builderid: 1
+        started_at: 1403059709
+        complete_at: 1403059772
+        complete: true
+        results: 'success'
+    ,
+        buildid: 2
+        builderid: 2
+        buildrequestid: 1
+        started_at: 1403059802
+        complete_at: 1403060287
+        complete: true
+        results: 'success'
+    ,
+        buildid: 3
+        builderid: 4
+        buildrequestid: 2
+        started_at: 1403059710
+        complete_at: 1403060278
+        complete: true
+        results: 'failure'
+    ,
+        buildid: 4
+        builderid: 3
+        buildrequestid: 2
+        started_at: 1403060250
+        complete_at: 0
+        complete: false
+    ]
+
+    dataService = null
+
+    injected = ($injector) ->
+        $rootScope = $injector.get('$rootScope')
+        dataService = $injector.get('dataService')
+
+    beforeEach(inject(injected))
+
+    it 'should be defined', ->
+        expect(dataService).toBeDefined()
+        # getGroups is a function
+        expect(dataService.getGroups).toBeDefined()
+        expect(typeof dataService.getGroups).toBe('function')
+        # addStatus is a function
+        expect(dataService.addStatus).toBeDefined()
+        expect(typeof dataService.addStatus).toBe('function')
+
+    it 'should add builds to builders', ->
+        # Add builds to builders
+        dataService.getGroups(builders, builds, 0)
+        # Builders builds length should be equal to all builds length
+        buildsInBuilders = 0
+        for build in builds
+            buildsInBuilders += builders[build.builderid - 1].builds.length
+            # A builder should contain its build
+            expect(builders[build.builderid - 1].builds).toContain(build)
+        expect(buildsInBuilders).toEqual(builds.length)
+
+    it 'should create groups', ->
+        # Create groups with a bigger threshold
+        threshold = builds[1].started_at - builds[0].complete_at
+        groups = dataService.getGroups(builders, builds, threshold)
+        expect(groups.length).toBe(1)
+
+        # Create groups with a smaller threshold
+        threshold = builds[1].started_at - builds[0].complete_at
+        groups = dataService.getGroups(builders, builds, threshold - 1)
+        expect(groups.length).toBe(2)
+
+        # Add builds to groups, all build have to be in one group
+        buildsInGroups = 0
+        for build in builds
+            for group in groups
+                group.builds ?= []
+                if build.started_at <= group.min and build.complete_at <= group.max
+                    group.builds.push(build)
+                    buildsInGroups++
+        expect(buildsInGroups).toEqual(builds.length)
+
+        # If the time between two builds is less than the threshold, they should be in different groups
+        for build1, i in builds
+            for build2 in builds[i+1..]
+                # If build2 starts earlier than build1, swap them
+                if build2.buildid < build1.buildid
+                    [build1, build2] = [build2, build1]
+                if build2.started_at - build1.complete_at > threshold
+                    expect(build1.groupid).not.toBe(build2.groupid)
+
+    it 'should add complete_at to unfinished builds', ->
+        unfinishedBuilds = builds.filter (build) -> not build.complete
+        dataService.getGroups(builders, unfinishedBuilds, 0)
+        for build in unfinishedBuilds
+            expect(build.complete_at).toBeDefined()
+            # It should be a correct timestamp
+            expect(build.complete_at.toString().length).toBe(10)
+
+    it 'should add status to builders', ->
+        # Add builds to builders first
+        dataService.getGroups(builders, builds, 0)
+        dataService.addStatus(builders)
+        for builder in builders
+            expect(builder.results).toBeDefined()
+        # Working builder status is pending
+        expect(builders[2].results).toBe('pending')

www/waterfall_view/src/module/main.module.spec.coffee

@@ -2,7 +2,7 @@ beforeEach ->
     module 'waterfall_view'
 
 describe 'Waterfall view controller', ->
-    createController = scope = $rootScope = $state = elem = $document = null
+    $rootScope = $state = elem = w = $document = null
 
     injected = ($injector) ->
         $rootScope = $injector.get('$rootScope')
@@ -12,20 +12,29 @@ describe 'Waterfall view controller', ->
         $state = $injector.get('$state')
         $document = $injector.get('$document')
         elem = angular.element('<div></div>')
-        $document.find("body").append(elem)
+        $document.find('body').append(elem)
         elem.append($compile('<ui-view></ui-view>')(scope))
 
+        $state.transitionTo('waterfall')
+        $rootScope.$digest()
+        w = $document.find('.waterfall').scope().w
 
     beforeEach(inject(injected))
 
     # make sure we remove the element from the dom
     afterEach ->
         elem.remove()
-        expect($document.find("svg").length).toEqual(0)
+        expect($document.find('svg').length).toEqual(0)
 
     it 'should be defined', ->
-        $state.transitionTo('waterfall')
-        $rootScope.$digest()
-        # make sure the whole stuff created lots of graphics data
-        expect(elem.find("svg").length).toBeGreaterThan(1)
-        expect(elem.find("g").length).toBeGreaterThan(10)
+        expect(w).toBeDefined()
+
+    it 'should bind the builds and builders to scope', ->
+        expect(w.builds).toBeDefined()
+        expect(w.builds.length).not.toBe(0)
+        expect(w.builders).toBeDefined()
+        expect(w.builders.length).not.toBe(0)
+
+    it 'should create 2 svg elements and a lot of svg groups', ->
+        expect(elem.find('svg').length).toBeGreaterThan(1)
+        expect(elem.find('g').length).toBeGreaterThan(10)

www/waterfall_view/src/module/scale/scale.service.coffee

@@ -28,7 +28,7 @@ class ScaleService extends Factory
                                 sum += period for period in periods
                                 return H - (I / T) * sum - id * gap
                             else periods.push(group.max - group.min)
-                        return 0
+                        return undefined
 
                     # coordinate to date
                     @invert: (coordinate) ->

www/waterfall_view/src/module/scale/scale.service.spec.coffee

@@ -20,46 +20,72 @@ describe 'Scale service', ->
         name: 'builder4'
     ]
 
-    builds = [
-        buildid: 1
-        builderid: 1
-        started_at: 1403059709
-        complete_at: 1403059772
-        complete: true
-    ,
-        buildid: 2
-        builderid: 2
-        buildrequestid: 1
-        started_at: 1403059711
-        complete_at: 1403060287
-        complete: true
-    ,
-        buildid: 3
-        builderid: 4
-        buildrequestid: 2
-        started_at: 1403059710
-        complete_at: 1403060278
-        complete: true
+    groups = [
+                        # Y.M.D - h:m:s
+        min: 1325376000 # 2012.01.01 - 0:0:0
+        max: 1325548800 # 2012.01.03 - 0:0:0
     ,
-        buildid: 4
-        builderid: 3
-        buildrequestid: 2
-        started_at: 1403059710
-        complete_at: 0
-        complete: false
+        min: 1395104461 # 2014.03.18 - 1:1:1
+        max: 1396450952 # 2014.04.02 - 15:2:32
     ]
 
-    scaleService = null
+    scaleService = scale = null
 
     injected = ($injector) ->
         $rootScope = $injector.get('$rootScope')
-        d3Service = $injector.get('d3Service')
+        #d3Service = $injector.get('d3Service')
         scaleService = $injector.get('scaleService')
 
+        scale = new scaleService(window.d3)
+
     beforeEach(inject(injected))
 
     it 'should be defined', ->
         expect(scaleService).toBeDefined()
+        expect(scale).toBeDefined()
+        # getX is a function
+        expect(scale.getX).toBeDefined()
+        expect(typeof scale.getX).toBe('function')
+        # getY is a function
+        expect(scale.getY).toBeDefined()
+        expect(typeof scale.getY).toBe('function')
+        # getBuilderName is a function
+        expect(scale.getBuilderName).toBeDefined()
+        expect(typeof scale.getBuilderName).toBe('function')
+
+    it 'should return a builderid to X scale', ->
+        # Get new scale, range: 100
+        idToX = scale.getX(builders, 100)
+        # A build with smaller builderid should come first
+        for builder, i in builders by 2
+            a = idToX(builders[i].builderid)
+            b = idToX(builders[i+1].builderid) or 100
+            expect(a).toBeLessThan(b)
+        # Out of domain
+        expect(idToX(8)).toBeUndefined()
+
+    it 'should return a build lenght to height scale', ->
+        # gap: 5, range: 100
+        idToY = scale.getY(groups, 5, 100)
+        # Check gap size
+        expect(idToY(groups[0].max) - idToY(groups[1].min)).toBe(5)
+        # All dates are in domain
+        dates = [
+            1325376000 # 2012.01.01 - 0:0:0
+            1325386000 # 2012.01.01 - 2:46:40
+            1396328527 # 2014.04.01 - 5:2:7
+        ]
+        for date in dates
+            # date -> coordinate -> date, the starting and the ending date should be equal
+            expect(idToY.invert(idToY(date))).toEqual(date)
+        # Later times have greater Y coordinate
+        expect(idToY(date)).toBeGreaterThan(idToY(date + 10000))
+        # Out of domain
+        expect(idToY(1359731102)).toBeUndefined()
 
     it 'should return a builderid to name scale', ->
-        console.log scaleService
+        # Get new scale
+        idToName = scale.getBuilderName(builders)
+        # The return value should be the name of the builder
+        for builder in builders
+            expect(idToName(builder.builderid)).toEqual(builder.name)

www/waterfall_view/src/module/waterfall.route.spec.coffee

@@ -1,27 +1,26 @@
-if window.__karma__?
-    beforeEach ->
-        # Mock modalService
-        module ($provide) ->
-            $provide.service '$modal', ->
-            $provide.service '$modalInstance', ->
-            null
+beforeEach ->
+    # Mock modalService
+    module ($provide) ->
+        $provide.service '$modal', ->
+        $provide.service '$modalInstance', ->
+        null
 
-        module 'waterfall_view'
+    module 'waterfall_view'
 
-    describe 'Waterfall view', ->
-        $state = null
+describe 'Waterfall view', ->
+    $state = null
 
-        injected = ($injector) ->
-            $state = $injector.get('$state')
+    injected = ($injector) ->
+        $state = $injector.get('$state')
 
-        beforeEach(inject(injected))
+    beforeEach(inject(injected))
 
-        it 'should register a new state with the correct configuration', ->
-            name = 'waterfall'
-            state = $state.get().pop()
-            data = state.data
-            expect(state.name).toBe(name)
-            expect(state.controller).toBe("#{name}Controller")
-            expect(state.controllerAs).toBe('w')
-            expect(state.templateUrl).toBe("waterfall_view/views/#{name}.html")
-            expect(state.url).toBe("/#{name}")
+    it 'should register a new state with the correct configuration', ->
+        name = 'waterfall'
+        state = $state.get().pop()
+        data = state.data
+        expect(state.name).toBe(name)
+        expect(state.controller).toBe("#{name}Controller")
+        expect(state.controllerAs).toBe('w')
+        expect(state.templateUrl).toBe("waterfall_view/views/#{name}.html")
+        expect(state.url).toBe("/#{name}")