Merge remote-tracking branch 'origin/open972'

platform/features/table/test/controllers/HistoricalTableControllerSpec.js

@@ -34,6 +34,8 @@ define(
                 mockDomainObject,
                 mockTable,
                 mockConfiguration,
+                mockAngularTimeout,
+                mockTimeoutHandle,
                 watches,
                 controller;
 
@@ -63,6 +65,11 @@ define(
                     watches[expression] = callback;
                 });
 
+                mockTimeoutHandle = jasmine.createSpy("timeoutHandle");
+                mockAngularTimeout = jasmine.createSpy("$timeout");
+                mockAngularTimeout.andReturn(mockTimeoutHandle);
+                mockAngularTimeout.cancel = jasmine.createSpy("cancelTimeout");
+
                 mockConfiguration = {
                     'range1': true,
                     'range2': true,
@@ -107,7 +114,7 @@ define(
                 ]);
                 mockTelemetryHandler.handle.andReturn(mockTelemetryHandle);
 
-                controller = new TableController(mockScope, mockTelemetryHandler, mockTelemetryFormatter);
+                controller = new TableController(mockScope, mockTelemetryHandler, mockTelemetryFormatter, mockAngularTimeout);
                 controller.table = mockTable;
                 controller.handle = mockTelemetryHandle;
             });
@@ -163,6 +170,13 @@ define(
 
                 controller.addHistoricalData(mockDomainObject, mockSeries);
 
+                // Angular timeout is called a minumum of twice, regardless
+                // of batch size used.
+                expect(mockAngularTimeout).toHaveBeenCalled();
+                mockAngularTimeout.mostRecentCall.args[0]();
+                expect(mockAngularTimeout.calls.length).toEqual(2);
+                mockAngularTimeout.mostRecentCall.args[0]();
+
                 expect(controller.$scope.rows.length).toBe(5);
                 expect(controller.$scope.rows[0]).toBe(mockRow);
             });
@@ -198,7 +212,7 @@ define(
                     ' object composition changes', function () {
                     controller.registerChangeListeners();
                     expect(watches['domainObject.getModel().composition']).toBeDefined();
-                    watches['domainObject.getModel().composition']();
+                    watches['domainObject.getModel().composition']([], []);
                     expect(controller.subscribe).toHaveBeenCalled();
                 });
 
@@ -219,6 +233,78 @@ define(
                 });
 
             });
+            describe('Yields thread', function () {
+                var mockSeries,
+                    mockRow;
+
+                beforeEach(function () {
+                    mockSeries = {
+                        getPointCount: function () {
+                            return 5;
+                        },
+                        getDomainValue: function () {
+                            return 'Domain Value';
+                        },
+                        getRangeValue: function () {
+                            return 'Range Value';
+                        }
+                    };
+                    mockRow = {'domain': 'Domain Value', 'range': 'Range Value'};
+
+                    mockTelemetryHandle.makeDatum.andCallFake(function () {
+                        return mockRow;
+                    });
+                    mockTable.getRowValues.andReturn(mockRow);
+                    mockTelemetryHandle.getTelemetryObjects.andReturn([mockDomainObject]);
+                    mockTelemetryHandle.getSeries.andReturn(mockSeries);
+                });
+                it('when row count exceeds batch size', function () {
+                    controller.batchSize = 3;
+                    controller.addHistoricalData(mockDomainObject, mockSeries);
+
+                    //Timeout is called a minimum of two times
+                    expect(mockAngularTimeout).toHaveBeenCalled();
+                    mockAngularTimeout.mostRecentCall.args[0]();
+
+                    expect(mockAngularTimeout.calls.length).toEqual(2);
+                    mockAngularTimeout.mostRecentCall.args[0]();
+
+                    //Because it yields, timeout will have been called a
+                    // third time for the batch.
+                    expect(mockAngularTimeout.calls.length).toEqual(3);
+                    mockAngularTimeout.mostRecentCall.args[0]();
+
+                    expect(controller.$scope.rows.length).toBe(5);
+                    expect(controller.$scope.rows[0]).toBe(mockRow);
+                });
+                it('cancelling any outstanding timeouts', function () {
+                    controller.batchSize = 3;
+                    controller.addHistoricalData(mockDomainObject, mockSeries);
+
+                    expect(mockAngularTimeout).toHaveBeenCalled();
+                    mockAngularTimeout.mostRecentCall.args[0]();
+
+                    controller.addHistoricalData(mockDomainObject, mockSeries);
+
+                    expect(mockAngularTimeout.cancel).toHaveBeenCalledWith(mockTimeoutHandle);
+                });
+                it('cancels timeout on scope destruction', function () {
+                    controller.batchSize = 3;
+                    controller.addHistoricalData(mockDomainObject, mockSeries);
+
+                    //Destroy is used by parent class as well, so multiple
+                    // calls are made to scope.$on
+                    var destroyCalls = mockScope.$on.calls.filter(function (call) {
+                        return call.args[0] === '$destroy';
+                    });
+                    //Call destroy function
+                    expect(destroyCalls.length).toEqual(2);
+
+                    destroyCalls[0].args[1]();
+                    expect(mockAngularTimeout.cancel).toHaveBeenCalledWith(mockTimeoutHandle);
+
+                });
+            });
         });
     }
 );