describe('NgTableParams', function () {
    var scope,
        NgTableParams,
        $rootScope;

    beforeEach(module("ngTable"));
    beforeEach(function(){
        module(function($provide){
            $provide.decorator('ngTableDefaultGetData', createSpy);


            createSpy.$inject = ['$delegate'];
            function createSpy(ngTableDefaultGetData){
                return jasmine.createSpy('ngTableDefaultGetDataSpy',ngTableDefaultGetData).and.callThrough();
            }
        });
    });

    beforeEach(inject(function ($controller, _$rootScope_, _NgTableParams_) {
        $rootScope = _$rootScope_;
        scope = $rootScope.$new();
        NgTableParams = _NgTableParams_;
    }));

    function createNgTableParams(settings) {
        var initialParams;
        if (arguments.length === 2){
            initialParams = arguments[0];
            settings = arguments[1];
        }

        settings = angular.extend({}, settings);
        settings.filterOptions = angular.extend({}, {
            filterDelay: 0
        }, settings.filterOptions);
        var tableParams = new NgTableParams(initialParams, settings);
        spyOn(tableParams.settings(), 'getData').and.callThrough();
        return tableParams;
    }

    it('NgTableParams should be defined', function () {
        expect(NgTableParams).toBeDefined();
    });

    describe('generatePagesArray', function(){
        it('should generate pages array using arguments supplied', function(){
            var params = new NgTableParams();
            expect(params.generatePagesArray(1, 30, 10)).toEqual([
                { type: 'prev', number: 1, active: false },
                { type: 'first', number: 1, active: false, current: true },
                { type: 'page', number: 2, active: true, current: false },
                { type: 'last', number: 3, active: true, current: false },
                { type: 'next', number: 2, active: true }
            ]);
            expect(params.generatePagesArray(2, 30, 10)).toEqual([
                { type: 'prev', number: 1, active: true },
                { type: 'first', number: 1, active: true, current: false },
                { type: 'page', number: 2, active: false, current: true },
                { type: 'last', number: 3, active: true, current: false },
                { type: 'next', number: 3, active: true }
            ]);
            expect(params.generatePagesArray(2, 100, 10)).toEqual([
                { type: 'prev', number: 1, active: true },
                { type: 'first', number: 1, active: true, current: false },
                { type: 'page', number: 2, active: false, current: true },
                { type: 'page', number: 3, active: true, current: false },
                { type: 'page', number: 4, active: true, current: false },
                { type: 'page', number: 5, active: true, current: false },
                { type: 'page', number: 6, active: true, current: false },
                { type: 'page', number: 7, active: true, current: false },
                { type: 'more', active: false },
                { type: 'last', number: 10, active: true, current: false },
                { type: 'next', number: 3, active: true }
            ]);
        });

        it('should use own parameter values to generate pages when no arguments supplied', function(){
            var params = new NgTableParams({ page: 2, count: 10 }, { total: 30 });

            expect(params.generatePagesArray()).toEqual([
                { type: 'prev', number: 1, active: true },
                { type: 'first', number: 1, active: true, current: false },
                { type: 'page', number: 2, active: false, current: true },
                { type: 'last', number: 3, active: true, current: false },
                { type: 'next', number: 3, active: true }
            ]);

        });
    });

    it('NgTableParams `page` parameter', function () {
        var params = new NgTableParams();

        expect(params.page()).toBe(1);
        expect(params.page(2)).toEqual(params);
        expect(params.page()).toBe(2);

        params = new NgTableParams({
            page: 3
        });
        expect(params.page()).toBe(3);
    });

    it('NgTableParams parse url parameters', function () {
        var params = new NgTableParams({
            'sorting[name]': 'asc',
            'sorting[age]': 'desc',
            'filter[name]': 'test',
            'filter[age]': '20',
            'group[name]' : 'asc',
            'group[age]' : 'desc',
            'group[surname]' : undefined
        });

        expect(params.filter()).toEqual({ 'name': 'test', 'age': 20 });
        expect(params.sorting()).toEqual({ 'age': 'desc' }); // sorting only by one column - todo: remove restriction
        expect(params.group()).toEqual({ 'name' : 'asc', 'age': 'desc', 'surname': undefined });
    });

    it('NgTableParams return url parameters', function () {
        var params = new NgTableParams({
            'sorting[name]': 'asc',
            'sorting[age]': 'desc',
            'filter[name]': 'test',
            'filter[age]': '20',
            'group[name]' : 'asc',
            'group[age]' : 'desc',
            'group[surname]' : ''
        });
        expect(params.url()).toEqual({
            'page': '1',
            'count': '10',
            'filter[name]': 'test',
            'filter[age]': '20',
            'sorting[age]': 'desc',  // sorting only by one column - todo: remove restriction
            'group[name]' : 'asc',
            'group[age]' : 'desc',
            'group[surname]' : ''
        });
        expect(params.url(true)).toEqual([
            'page=1',
            'count=10',
            'filter[name]=test',
            'filter[age]=20',
            'sorting[age]=desc',  // sorting only by one column - todo: remove restriction
            'group[name]=asc',
            'group[age]=desc',
            'group[surname]='
        ]);
    });

    it('orderBy', function () {
        var params = new NgTableParams({
            'sorting[name]': 'asc'
        });

        expect(params.orderBy()).toEqual([ '+name' ]); // for angular sorting function

        params.sorting({ name: 'desc', age: 'asc' });

        expect(params.orderBy()).toEqual([ '-name', '+age' ]);
    });

    describe('group', function(){
        it('one group', function () {
            var params = new NgTableParams({
                group: 'role'
            }, {
                groupOptions: { defaultSort: 'desc' }
            });

            expect(params.hasGroup()).toBe(true);
            expect(params.hasGroup('role')).toBe(true);
            expect(params.hasGroup('role', 'desc')).toBe(true);
            expect(params.group()).toEqual({ role: 'desc' });

            params.group('age');
            expect(params.hasGroup('age', 'desc')).toBe(true);
            expect(params.group()).toEqual({ age: 'desc' });

            params.group('age', 'asc');
            expect(params.hasGroup('age', 'asc')).toBe(true);
            expect(params.group()).toEqual({ age: 'asc' });
        });

        it('one group (nested property)', function () {
            var params = new NgTableParams({
                group: 'details.personal.age'
            }, {
                groupOptions: { defaultSort: 'desc' }
            });

            expect(params.hasGroup()).toBe(true);
            expect(params.hasGroup('details.personal.age')).toBe(true);
            expect(params.hasGroup('details.personal.age', 'desc')).toBe(true);
            expect(params.group()).toEqual({ 'details.personal.age': 'desc' });

            params.group('details.country');
            expect(params.hasGroup('details.country', 'desc')).toBe(true);
            expect(params.group()).toEqual({ 'details.country': 'desc' });

            params.group('details.country', 'asc');
            expect(params.hasGroup('details.country', 'asc')).toBe(true);
            expect(params.group()).toEqual({ 'details.country': 'asc' });
        });

        it('one group function', function () {
            var params = new NgTableParams({
                group: angular.identity
            });

            expect(params.hasGroup()).toBe(true);
            expect(params.hasGroup(angular.identity)).toBe(true);
            expect(params.hasGroup(angular.identity, params.settings().groupOptions.defaultSort)).toBe(true);
            expect(params.group()).toEqual(angular.identity);


            var fn = function(){ };
            fn.sortDirection = 'desc';
            params.group(fn);
            expect(params.hasGroup(fn)).toBe(true);
            expect(params.hasGroup(fn, 'desc')).toBe(true);
            expect(params.group()).toEqual(fn);
        });

        it('can clear group', function () {
            var params = new NgTableParams({
                group: 'role'
            });

            expect(params.hasGroup()).toBe(true); // checking assumptions

            params.group({});
            expect(params.hasGroup()).toBe(false);
            expect(params.group()).toEqual({});
        });

        it('multiple groups', function () {
            var params = new NgTableParams({
                group: 'role'
            }, {
                groupOptions: { defaultSort: 'desc' }
            });

            var newGroups = _.extend({}, params.group(), { age: 'desc'});
            params.group(newGroups);
            expect(params.hasGroup()).toBe(true);
            expect(params.hasGroup('role')).toBe(true);
            expect(params.hasGroup('role', 'desc')).toBe(true);
            expect(params.hasGroup('age')).toBe(true);
            expect(params.hasGroup('age', 'desc')).toBe(true);
            expect(params.group()).toEqual({ role: 'desc', age: 'desc' });

            params.group({ role: 'asc', age: 'asc'});
            expect(params.hasGroup('age', 'desc')).toBe(false);
            expect(params.hasGroup('age', 'asc')).toBe(true);
            expect(params.group()).toEqual({ role: 'asc', age: 'asc' });
        });

        it('should apply current defaultSort from groupOptions', function(){
            var params = new NgTableParams({
                group: 'role'
            }, {
                groupOptions: { defaultSort: 'desc' }
            });

            params.settings({ groupOptions: { defaultSort: 'asc' }});

            params.group('age');
            expect(params.group()).toEqual({ age: 'asc' });
        });

        it('should not apply defaultSort from groupOptions when explicitly set to empty string', function(){
            var params = new NgTableParams({
                group: 'role'
            }, {
                groupOptions: { defaultSort: 'desc' }
            });
            expect(params.group()).toEqual({ role: 'desc' }); // checking assumptions

            params.group({ role: ''});
            expect(params.group()).toEqual({ role: '' });

            params.group({ age: undefined});
            expect(params.group()).toEqual({ age: 'desc' });

            params.group({ role: null});
            expect(params.group()).toEqual({ role: 'desc' });
        });
    });

    describe('settings', function(){

        it('defaults', function () {
            var params = new NgTableParams();

            var expectedSettings = {
                $loading: false,
                dataset: null,
                total: 0,
                defaultSort: 'desc',
                counts: [10, 25, 50, 100],
                interceptors: [],
                paginationMaxBlocks: 11,
                paginationMinBlocks: 5,
                sortingIndicator: 'span',
                filterOptions: {
                    filterComparator: undefined,
                    filterDelay: 500,
                    filterDelayThreshold: 10000,
                    filterFilterName: undefined,
                    filterFn: undefined,
                    filterLayout: 'stack'
                },
                groupOptions: { defaultSort: 'asc', isExpanded: true }
            };
            expect(params.settings()).toEqual(jasmine.objectContaining(expectedSettings));
            expect(params.settings().getData).toEqual(jasmine.any(Function));
            expect(params.settings().getGroups).toEqual(jasmine.any(Function));

            params = new NgTableParams({}, {
                total: 100,
                counts: [1,2],
                groupOptions: { isExpanded: false } });

            expectedSettings.total = 100;
            expectedSettings.counts = [1,2];
            expectedSettings.groupOptions = { defaultSort: 'asc', isExpanded: false };
            expect(params.settings()).toEqual(jasmine.objectContaining(expectedSettings));
        });

        it('changing settings().dataset should reset page to 1', function(){
            // given
            var tableParams = createNgTableParams({ count: 1, page: 2 }, { dataset: [1,2,3]});
            tableParams.reload();
            scope.$digest();
            expect(tableParams.page()).toBe(2); // checking assumptions

            // when
            tableParams.settings({ dataset: [1,2,3, 4]});

            // then
            expect(tableParams.page()).toBe(1);
        });

        it('should not set filterDelay when working with synchronous dataset', function(){
            // given
            var tableParams = new NgTableParams({}, { dataset: [1,2,3]});
            expect(tableParams.settings().filterOptions.filterDelay).toBe(0);
        });

        it('should not set filterDelay when working with synchronous dataset (empty dataset)', function(){
            // given
            var tableParams = new NgTableParams({}, { dataset: []});
            expect(tableParams.settings().filterOptions.filterDelay).toBe(0);
        });

        it('should set filterDelay when not certain working with synchronous dataset', function(){
            // given
            var tableParams = new NgTableParams({}, { dataset: [1,2], getData: function(){
                // am I sync or async?
            }});
            expect(tableParams.settings().filterOptions.filterDelay).toBe(500);
        });

        it('should set filterDelay when dataset exceeds filterDelayThreshold', function(){
            // given
            var tableParams = new NgTableParams({}, { filterOptions: { filterDelayThreshold: 5 }, dataset: [,2,3,4,5,6] });
            expect(tableParams.settings().filterOptions.filterDelay).toBe(500);
        });

        it('should allow filterDelay to be set explicitly', function(){
            // given
            var tableParams = new NgTableParams({}, { filterOptions: { filterDelay: 100}, dataset: [1,2] });
            expect(tableParams.settings().filterOptions.filterDelay).toBe(100);
        });
    });

    describe('reload', function(){

        it('should call getData to retrieve data', function(){
            var tp = createNgTableParams();
            tp.reload();
            scope.$digest();
            expect(tp.settings().getData.calls.count()).toBe(1);
        });

        it('should add the results returned by getData to the data field', function(){
            var tp = createNgTableParams({ getData: function(){
                return [1,2,3];
            }});
            tp.reload();
            scope.$digest();
            expect(tp.data).toEqual([1,2,3]);
        });

        it('should use ngTableDefaultGetData function when NgTableParams not supplied a getData function', inject(function(ngTableDefaultGetData){
            // given
            var tp = createNgTableParams();

            // when
            tp.reload();
            scope.$digest();

            // then
            expect(ngTableDefaultGetData).toHaveBeenCalled();
        }));

        it('should propagate rejection reason from getData', inject(function($q){
            // given
            var tp = createNgTableParams({ getData: function(){
                return $q.reject('bad response')
            }});

            // when
            var actualRejection;
            tp.reload().catch(function(reason){
                actualRejection = reason;
            });
            scope.$digest();

            // then
            expect(actualRejection).toBe('bad response');
        }));
    });

    describe('getGroups', function(){

        var dataset;
        beforeEach(function(){
            dataset = [
                { 'name': 'Hanson', 'role': 'Accounting' },
                { 'name': 'Eaton', 'role': 'Customer Service' },
                { 'name': 'Perry', 'role': 'Customer Service' },
                { 'name': 'George', 'role': 'Accounting' },
                { 'name': 'Jennings', 'role': 'Asset Management' },
                { 'name': 'Whitney', 'role': 'Accounting' },
                { 'name': 'Weaver', 'role': 'Payroll' },
                { 'name': 'Gibson', 'role': 'Payroll' },
                { 'name': 'Wells', 'role': 'Media Relations' },
                { 'name': 'Willis', 'role': 'Finances' },
                { 'name': 'Donovan', 'role': 'Customer Relations' },
                { 'name': 'Mcdonald', 'role': 'Finances' },
                { 'name': 'Young', 'role': 'Asset Management' }
            ];
        });


        it('should group data then apply paging to groups', function () {
            var tp = createNgTableParams({ count: 2, group: { role: '' } }, { dataset: dataset });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Accounting',
                    data: [
                        { "name": 'Hanson', "role": 'Accounting' },
                        { "name": 'George', "role": 'Accounting' },
                        { "name": 'Whitney', "role": 'Accounting' }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Customer Service',
                    data: [
                        { "name": 'Eaton', "role": 'Customer Service' },
                        { "name": 'Perry', "role": 'Customer Service' }
                    ]
                }
            ]);
        });

        it('should sort data, then group, then page groups', function () {
            var tp = createNgTableParams({
                count: 2,
                sorting: { name: 'desc'},
                group: { role: '' }
            }, { dataset: dataset });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Asset Management',
                    data: [
                        { "name": 'Young', "role": 'Asset Management' },
                        { "name": 'Jennings', "role": 'Asset Management' }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Finances',
                    data: [
                        { "name": 'Willis', "role": 'Finances' },
                        { "name": 'Mcdonald', "role": 'Finances' }
                    ]
                }
            ]);
        });

        it('should use group function to group data', function () {
            var grouper = function (item) {
                return item.name[0];
            };
            grouper.sortDirection = '';
            var tp = createNgTableParams({
                count: 2,
                sorting: {name: 'desc'},
                group: grouper
            }, {dataset: dataset});

            var actualRoleGroups;
            tp.reload().then(function (groups) {
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Y',
                    data: [
                        { "name": "Young", "role": "Asset Management" }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'W',
                    data: [
                        { "name": "Willis", "role": "Finances" },
                        { "name": "Whitney", "role": "Accounting" },
                        { "name": "Wells", "role": "Media Relations" },
                        { "name": "Weaver", "role": "Payroll" }
                    ]
                }
            ]);
        });

        it('should filter and sort data, then group, then page groups', function () {
            var tp = createNgTableParams({
                count: 2,
                sorting: { name: 'desc' },
                filter: { name: 'e' },
                group: { role: '' }
            }, {
                dataset: dataset
            });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Accounting',
                    data: [
                        { 'name': 'Whitney', 'role': 'Accounting' },
                        { 'name': 'George', 'role': 'Accounting' }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Media Relations',
                    data: [
                        { 'name': 'Wells', 'role': 'Media Relations' }
                    ]
                }
            ]);
        });

        it('should filter and sort data, then group, then apply group sortDirection, and finally page groups', function () {
            var tp = createNgTableParams({
                count: 3,
                sorting: { name: 'desc' },
                filter: { name: 'e' },
                group: { role: 'desc' }
            }, {
                dataset: dataset,
                groupOptions: {
                    // this value will be overridden by group: { role: 'desc' }
                    defaultSort: undefined
                }
            });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Payroll',
                    data: [
                        { 'name': 'Weaver', 'role': 'Payroll' }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Media Relations',
                    data: [
                        { 'name': 'Wells', 'role': 'Media Relations' }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Customer Service',
                    data: [
                        { 'name': 'Perry', 'role': 'Customer Service' },
                        { 'name': 'Eaton', 'role': 'Customer Service' }
                    ]
                }
            ]);
        });

        it('should use sortDirection defined on group function to sort groups', function () {
            var groupFn = function(item){
                return item.role;
            };
            groupFn.sortDirection = 'desc';
            var tp = createNgTableParams({
                count: 3,
                sorting: { name: 'desc' },
                filter: { name: 'e' },
                group: groupFn
            }, {
                dataset: dataset,
                groupOptions: {
                    // this value will be overridden by groupFn.sortDirection
                    defaultSort: undefined
                }
            });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Payroll',
                    data: [
                        { 'name': 'Weaver', 'role': 'Payroll' }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Media Relations',
                    data: [
                        { 'name': 'Wells', 'role': 'Media Relations' }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Customer Service',
                    data: [
                        { 'name': 'Perry', 'role': 'Customer Service' },
                        { 'name': 'Eaton', 'role': 'Customer Service' }
                    ]
                }
            ]);
        });
    });

    describe('getGroups with nested property', function(){

        var dataset;
        beforeEach(function(){
            dataset = [
                { 'details': { 'name': 'Hanson', 'role': 'Accounting' } },
                { 'details': { 'name': 'Eaton', 'role': 'Customer Service' } },
                { 'details': { 'name': 'Perry', 'role': 'Customer Service' } },
                { 'details': { 'name': 'George', 'role': 'Accounting' } },
                { 'details': { 'name': 'Jennings', 'role': 'Asset Management' } },
                { 'details': { 'name': 'Whitney', 'role': 'Accounting' } },
                { 'details': { 'name': 'Weaver', 'role': 'Payroll' } },
                { 'details': { 'name': 'Gibson', 'role': 'Payroll' } },
                { 'details': { 'name': 'Wells', 'role': 'Media Relations' } },
                { 'details': { 'name': 'Willis', 'role': 'Finances' } },
                { 'details': { 'name': 'Donovan', 'role': 'Customer Relations' } },
                { 'details': { 'name': 'Mcdonald', 'role': 'Finances' } },
                { 'details': { 'name': 'Young', 'role': 'Asset Management' } }
            ];
        });


        it('should group data then apply paging to groups', function () {
            var tp = createNgTableParams({ count: 2, group: { 'details.role': '' } }, { dataset: dataset });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Accounting',
                    data: [
                        { 'details': { 'name': 'Hanson', 'role': 'Accounting' } },
                        { 'details': { 'name': 'George', 'role': 'Accounting' } },
                        { 'details': { 'name': 'Whitney', 'role': 'Accounting' } }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Customer Service',
                    data: [
                        { 'details': { 'name': 'Eaton', 'role': 'Customer Service' } },
                        { 'details': { 'name': 'Perry', 'role': 'Customer Service' } }
                    ]
                }
            ]);
        });

        it('should sort data, then group, then page groups', function () {
            var tp = createNgTableParams({
                count: 2,
                sorting: { 'details.name': 'desc'},
                group: { 'details.role': '' }
            }, { dataset: dataset });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Asset Management',
                    data: [
                        { 'details': { 'name': 'Young', 'role': 'Asset Management' } },
                        { 'details': { 'name': 'Jennings', 'role': 'Asset Management' } }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Finances',
                    data: [
                        { 'details': { 'name': 'Willis', 'role': 'Finances' } },
                        { 'details': { 'name': 'Mcdonald', 'role': 'Finances' } }
                    ]
                }
            ]);
        });

        it('should use group function to group data', function () {
            var grouper = function (item) {
                return item.details.name[0];
            };
            grouper.sortDirection = '';
            var tp = createNgTableParams({
                count: 2,
                sorting: {'details.name': 'desc'},
                group: grouper
            }, {dataset: dataset});

            var actualRoleGroups;
            tp.reload().then(function (groups) {
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Y',
                    data: [
                        { 'details': { 'name': 'Young', 'role': 'Asset Management' } }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'W',
                    data: [
                        { 'details': { 'name': 'Willis', 'role': 'Finances' } },
                        { 'details': { 'name': 'Whitney', 'role': 'Accounting' } },
                        { 'details': { 'name': 'Wells', 'role': 'Media Relations' } },
                        { 'details': { 'name': 'Weaver', 'role': 'Payroll' } }
                    ]
                }
            ]);
        });

        it('should filter and sort data, then group, then page groups', function () {
            var tp = createNgTableParams({
                count: 2,
                sorting: { 'details.name': 'desc' },
                filter: { 'details.name': 'e' },
                group: { 'details.role': '' }
            }, {
                dataset: dataset
            });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Accounting',
                    data: [
                        { 'details': { 'name': 'Whitney', 'role': 'Accounting' } },
                        { 'details': { 'name': 'George', 'role': 'Accounting' } }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Media Relations',
                    data: [
                        { 'details': { 'name': 'Wells', 'role': 'Media Relations' } }
                    ]
                }
            ]);
        });

        it('should filter and sort data, then group, then apply group sortDirection, and finally page groups', function () {
            var tp = createNgTableParams({
                count: 3,
                sorting: { 'details.name': 'desc' },
                filter: { 'details.name': 'e' },
                group: { 'details.role': 'desc' }
            }, {
                dataset: dataset,
                groupOptions: {
                    // this value will be overridden by group: { role: 'desc' }
                    defaultSort: undefined
                }
            });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Payroll',
                    data: [
                        { 'details': { 'name': 'Weaver', 'role': 'Payroll' } }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Media Relations',
                    data: [
                        { 'details': { 'name': 'Wells', 'role': 'Media Relations' } }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Customer Service',
                    data: [
                        { 'details': { 'name': 'Perry', 'role': 'Customer Service' } },
                        { 'details': { 'name': 'Eaton', 'role': 'Customer Service' } }
                    ]
                }
            ]);
        });

        it('should use sortDirection defined on group function to sort groups', function () {
            var groupFn = function(item){
                return item.details.role;
            };
            groupFn.sortDirection = 'desc';
            var tp = createNgTableParams({
                count: 3,
                sorting: { 'details.name': 'desc' },
                filter: { 'details.name': 'e' },
                group: groupFn
            }, {
                dataset: dataset,
                groupOptions: {
                    // this value will be overridden by groupFn.sortDirection
                    defaultSort: undefined
                }
            });

            var actualRoleGroups;
            tp.reload().then(function(groups){
                actualRoleGroups = groups;
            });
            $rootScope.$digest();

            expect(actualRoleGroups).toEqual([
                {
                    $hideRows: false,
                    value: 'Payroll',
                    data: [
                        { 'details': { 'name': 'Weaver', 'role': 'Payroll' } }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Media Relations',
                    data: [
                        { 'details': { 'name': 'Wells', 'role': 'Media Relations' } }
                    ]
                },
                {
                    $hideRows: false,
                    value: 'Customer Service',
                    data: [
                        { 'details': { 'name': 'Perry', 'role': 'Customer Service' } },
                        { 'details': { 'name': 'Eaton', 'role': 'Customer Service' } }
                    ]
                }
            ]);
        });
    });

    it('ngTableParams test defaults', inject(function ($q, ngTableDefaults) {
        ngTableDefaults.params.count = 2;
        ngTableDefaults.settings.counts = [];
        var tp = new NgTableParams();

        expect(tp.count()).toEqual(2);
        expect(tp.page()).toEqual(1);

        var settings = tp.settings();
        expect(settings.counts.length).toEqual(0);
        expect(settings.interceptors.length).toEqual(0);
        expect(settings.filterOptions.filterDelay).toEqual(500);

        ngTableDefaults.settings.interceptors = [ { response: angular.identity }];
        tp = new NgTableParams();
        expect(tp.settings().interceptors.length).toEqual(1);
    }));

    describe('hasFilter', function(){
        var tp;

        beforeEach(inject(function(){
            tp = new NgTableParams({}, {});
        }));

        it('should return false for an empty filter object', function(){
            tp.filter({});
            expect(tp.hasFilter()).toBe(false);
        });

        it('should return true for when filter has a field with a significant value', function(){
            tp.filter({ a: 'b' });
            expect(tp.hasFilter()).toBe(true);

            tp.filter({ a: 0 });
            expect(tp.hasFilter()).toBe(true);
        });

        it('should return false when filter only has insignificant field values', function(){
            tp.filter({ a: '' });
            expect(tp.hasFilter()).toBe(false);

            tp.filter({ a: null });
            expect(tp.hasFilter()).toBe(false);

            tp.filter({ a: undefined });
            expect(tp.hasFilter()).toBe(false);

            tp.filter({ a: undefined, b: '', c: undefined });
            expect(tp.hasFilter()).toBe(false);

            //tp.filter({ a: NaN });
            //expect(tp.hasFilter()).toBe(false);
        });
    });


    describe('isDataReloadRequired', function(){
        var tp;

        beforeEach(inject(function(){
            tp = createNgTableParams();
        }));

        it('should return true after construction', function(){
            expect(tp.isDataReloadRequired()).toBe(true);
        });

        it('should return false once reload called after construction', function(){
            tp.reload();
            // note: we don't have to wait for the getData promise to be resolved before considering reload
            // to be unnecessary - that's why we're not having to run a $digest
            expect(tp.isDataReloadRequired()).toBe(false);
        });

        it('should return false when getData fails', inject(function($q){
            tp.settings({ getData: function(){
                return $q.reject('bad response');
            }});
            tp.reload();
            scope.$digest();
            expect(tp.isDataReloadRequired()).toBe(false);
        }));

        it('should detect direct changes to parameters', inject(function($q){
            // given
            tp.reload();
            scope.$digest();
            expect(tp.isDataReloadRequired()).toBe(false); // checking assumptions

            // when
            tp.filter().newField = 99;
            expect(tp.isDataReloadRequired()).toBe(true);
        }));

        it('should return true until changed parameters have been reloaded', function(){
            // given
            tp.reload();
            scope.$digest();

            // when, then...
            verifyIsDataReloadRequired(function(){
                tp.filter({ age: 1});
            });
            verifyIsDataReloadRequired(function(){
                tp.page(55);
            });
            verifyIsDataReloadRequired(function(){
                tp.sorting({ age: 'desc'});
            });
            verifyIsDataReloadRequired(function(){
                tp.count(100);
            });
        });

        it('should return true when `$` field on `filter` changes', function(){
            // given
            tp.reload();
            scope.$digest();
            expect(tp.isDataReloadRequired()).toBe(false); // checking assumptions

            // when
            tp.filter().$ = 'cc';
            expect(tp.isDataReloadRequired()).toBe(true);
        });

        it('should return true when group function sort direction changes', function(){
            // given
            tp.reload();
            scope.$digest();
            expect(tp.isDataReloadRequired()).toBe(false); // checking assumptions

            // when, then...

            var grouper = function(){ };
            tp.group(grouper);
            expect(tp.isDataReloadRequired()).toBe(true);

            tp.reload();
            scope.$digest();
            expect(tp.isDataReloadRequired()).toBe(false);

            grouper.sortDirection = 'desc';
            expect(tp.isDataReloadRequired()).toBe(true);
        });

        it('should return false when parameters "touched" but not modified', function(){
            // given
            tp.filter({ age: 1});
            tp.reload();
            scope.$digest();

            // when, then...
            tp.filter({ age: 1});
            expect(tp.isDataReloadRequired()).toBe(false);
        });

        it('should return true when new settings dataset array supplied', function(){
            // given
            tp.reload();
            scope.$digest();

            verifyIsDataReloadRequired(function(){
                tp.settings({ dataset: [11,22,33]});
            });
        });

        it('should return true when existing settings dataset array is unset', function(){
            // given
            tp = createNgTableParams({ dataset: [1,2,3]});
            tp.reload();
            scope.$digest();

            verifyIsDataReloadRequired(function(){
                tp.settings({ dataset: null});
            });
        });

        it('status should not change when settings called without a dataset array', function(){
            // given
            tp = createNgTableParams({ dataset: [1,2,3]});
            tp.reload();
            scope.$digest();

            // when, then...
            tp.settings({ total : 100 });
            expect(tp.isDataReloadRequired()).toBe(false);
        });


        function verifyIsDataReloadRequired(modifer){
            modifer();
            expect(tp.isDataReloadRequired()).toBe(true);
            tp.reload();
            scope.$digest();
            expect(tp.isDataReloadRequired()).toBe(false);
        }
    });

    describe('hasFilterChanges', function(){
        var tp;

        beforeEach(inject(function(){
            tp = createNgTableParams();
        }));

        it('should return true after construction', function(){
            expect(tp.hasFilterChanges()).toBe(true);
        });

        it('should return false once reload called after construction', function(){
            tp.reload();
            // note: we don't have to wait for the getData promise to be resolved before considering reload
            // to be unnecessary - that's why we're not having to run a $digest
            expect(tp.hasFilterChanges()).toBe(false);
        });

        it('should return true when getData fails', inject(function($q){
            tp.settings({ getData: function(){
                return $q.reject('bad response');
            }});
            tp.reload();
            scope.$digest();
            expect(tp.hasFilterChanges()).toBe(false);
        }));

        it('should detect direct changes to filters', inject(function($q){
            // given
            tp.reload();
            scope.$digest();
            expect(tp.hasFilterChanges()).toBe(false); // checking assumptions

            // when
            tp.filter().newField = 99;
            expect(tp.hasFilterChanges()).toBe(true);
        }));

        it('should return true when `$` field on `filter` changes', function(){
            // given
            tp.reload();
            scope.$digest();
            expect(tp.hasFilterChanges()).toBe(false); // checking assumptions

            // when
            tp.filter().$ = 'cc';
            expect(tp.hasFilterChanges()).toBe(true);
        });

        it('should return true until changed filters have been reloaded', function(){
            // given
            tp.reload();
            scope.$digest();

            // when, then...
            tp.filter({ age: 1});
            expect(tp.hasFilterChanges()).toBe(true);
            tp.reload();
            scope.$digest();
            expect(tp.hasFilterChanges()).toBe(false);
        });

        it('should return false when filters "touched" but not modified', function(){
            // given
            tp.filter({ age: 1});
            tp.reload();
            scope.$digest();

            // when, then...
            tp.filter({ age: 1});
            expect(tp.hasFilterChanges()).toBe(false);
        });

        it('status should not change just because new settings dataset array supplied', function(){
            // given
            tp.reload();
            scope.$digest();

            // when, then...
            tp.settings({ dataset: [11,22,33]});
            expect(tp.hasFilterChanges()).toBe(false);
        });

    });

    describe('hasErrorState', function(){
        var tp;

        it('should return false until reload fails', inject(function($q){
            // given
            tp = createNgTableParams({ getData: function(){
                if (tp.settings().getData.calls.count() > 2){
                    return $q.reject('bad response');
                }
                return [1,2];
            }});

            // when, then
            tp.reload();
            scope.$digest();
            expect(tp.hasErrorState()).toBe(false);
            tp.reload();
            scope.$digest();
            expect(tp.hasErrorState()).toBe(false);
            tp.reload();
            scope.$digest();
            expect(tp.hasErrorState()).toBe(true);
        }));

        it('should return false once parameter values change', inject(function($q){
            // given
            tp = createNgTableParams({ getData: function(){
                return $q.reject('bad response');
            }});

            // when, then
            tp.reload();
            scope.$digest();
            expect(tp.hasErrorState()).toBe(true);
            tp.filter({ age: 598});
            expect(tp.hasErrorState()).toBe(false);
        }));
    });

    describe('backwards compatibility shim', function(){

        it('shim should supply getData original arguments', inject(function(ngTableGetDataBcShim){
            // given
            var callCount = 0;
            var adaptedFn = ngTableGetDataBcShim(originalGetDataFn);

            // when
            var tableParams = new NgTableParams({}, {});
            adaptedFn(tableParams);

            // then
            expect(callCount).toBe(1);

            function originalGetDataFn($defer, params){
                callCount++;
                expect($defer).toBeDefined();
                expect($defer.resolve).toBeDefined();
                expect(params).toBeDefined();
                expect(params).toEqual(jasmine.any(NgTableParams));
            }

        }));

        it('shim should return the getData "$defer" promise', inject(function(ngTableGetDataBcShim){
            // given
            var callCount = 0;
            var adaptedFn = ngTableGetDataBcShim(originalGetDataFn);

            // when
            var tableParams = new NgTableParams({}, {});
            var results = adaptedFn(tableParams);

            // then
            expect(results).toBeDefined();
            expect(results.then).toBeDefined();
            results.then(function(data){
                expect(data.length).toBe(3);
            });
            scope.$digest();

            function originalGetDataFn($defer/*, params*/){
                $defer.resolve([1,2,3]);
            }
        }));

        it('shim should return the data', inject(function(ngTableGetDataBcShim){
            // given
            var callCount = 0;
            var adaptedFn = ngTableGetDataBcShim(originalGetDataFn);

            // when
            var tableParams = new NgTableParams({}, {});
            var results = adaptedFn(tableParams);

            // then
            expect(results).toBeDefined();
            expect(results).toEqual([1,2,3]);

            function originalGetDataFn(/*$defer, params*/){
                return [1,2,3];
            }
        }));

        it('shim should be applied when getData function supplied has more than one parameter', function(){
            // given
            var tp = createNgTableParams({ getData: originalGetDataFn});

            // when
            var dataFetched = tp.reload();

            // then
            var actualData;
            dataFetched.then(function(data){
                actualData = data;
            });
            scope.$digest();
            expect(actualData).toEqual([1,2,3]);

            function originalGetDataFn($defer, params){
                params.total(3);
                $defer.resolve([1,2,3]);
            }
        });

        it('shim should NOT be applied when getData has new signature', function(){
            // given
            var tp = createNgTableParams({ getData: newGetDataFn});

            // when
            var dataFetched = tp.reload();

            // then
            var actualData;
            dataFetched.then(function(data){
                actualData = data;
            });
            scope.$digest();
            expect(actualData).toEqual([1,2,3]);

            function newGetDataFn(params){
                params.total(3);
                return [1,2,3];
            }
        });
    });

    describe('interceptors', function(){

        it('can register interceptor', function(){
            var interceptor = { response: angular.identity };
            var tp = createNgTableParams({ interceptors: [interceptor]});
            expect(tp.settings().interceptors).toEqual([interceptor]);
        });

        it('can register multiple interceptor', function(){
            var interceptors = [{ response: angular.identity }, { response: angular.identity }];
            var tp = createNgTableParams({ interceptors: interceptors});
            expect(tp.settings().interceptors).toEqual(interceptors);
        });

        it('can register interceptors after NgTableParams created', function(){
            var interceptor = { response: angular.identity };
            var interceptor2 = { response: angular.identity };
            var tp = createNgTableParams({ interceptors: [interceptor]});
            var interceptors = tp.settings().interceptors.concat([interceptor2]);
            tp.settings({ interceptors: interceptors});
            expect(tp.settings().interceptors).toEqual(interceptors);
        });

        describe('one response interceptor', function(){

            it('should receive response from call to getData', function(){
                // given
                var interceptor = {
                    response: function(/*data, params*/){
                        this.hasRun = true;
                    }
                };
                var tp = createNgTableParams({ interceptors: [interceptor]});

                // when
                tp.reload();
                scope.$digest();

                // then
                expect(interceptor.hasRun).toBeTruthy();
            });

            it('should be able to modify data returned by getData', function(){
                // given
                var interceptor = {
                    response: function(data/*, params*/){
                        data.forEach(function(item){
                            item.modified = true;
                        });
                        return data;
                    }
                };
                var tp = createNgTableParams({ interceptors: [interceptor], getData: function(){
                    return [{}, {}];
                }});

                // when
                var actualData;
                tp.reload().then(function(data){
                    actualData = data;
                });
                scope.$digest();

                // then
                expect(actualData).toEqual([{ modified: true }, { modified: true }]);
            });

            it('should be able to replace data returned by getData', function(){
                // given
                var interceptor = {
                    response: function(data/*, params*/){
                        return data.map(function(item){
                            return item * 2;
                        });
                    }
                };
                var tp = createNgTableParams({ interceptors: [interceptor], getData: function(){
                    return [2, 3];
                }});

                // when
                var actualData;
                tp.reload().then(function(data){
                    actualData = data;
                });
                scope.$digest();

                // then
                expect(actualData).toEqual([4, 6]);
            });

            it('should be able to access tableParams supplied to getData', function(){
                // given
                var interceptor = {
                    response: function(data, params){
                        params.total(data.total);
                        return data.results;
                    }
                };
                var tp = createNgTableParams({ interceptors: [interceptor], getData: function(){
                    return { results: [1,2,3], total: 3};
                }});

                // when
                var actualData;
                tp.reload().then(function(data){
                    actualData = data;
                });
                scope.$digest();

                // then
                expect(actualData).toEqual([1,2,3]);
                expect(tp.total()).toEqual(3);
            });
        });

        describe('one responseError interceptor', function(){

            it('should receive rejections from getData', inject(function($q){
                // given
                var interceptor = {
                    responseError: function(reason/*, params*/){
                        this.actualReason = reason;
                    }
                };
                var tp = createNgTableParams({
                    interceptors: [interceptor],
                    getData: function(/*params*/){
                        return $q.reject('BANG!');
                    }
                });

                // when
                tp.reload();
                scope.$digest();

                // then
                expect(interceptor.actualReason).toBe('BANG!');
            }));

            it('should NOT receive errors from getData', function(){
                // given
                var interceptor = {
                    responseError: function(/*reason, params*/){
                        this.hasRun = true;
                    }
                };
                var tp = createNgTableParams({
                    interceptors: [interceptor],
                    getData: function(/*params*/){
                        throw new Error('BANG!');
                    }
                });

                // when, then
                expect(tp.reload).toThrow();
                expect(interceptor.hasRun).toBeFalsy();
            });

            it('should be able to modify reason returned by getData', inject(function($q){
                // given
                var interceptor = {
                    responseError: function(reason/*, params*/){
                        reason.code = 400;
                        return $q.reject(reason);
                    }
                };
                var tp = createNgTableParams({
                    interceptors: [interceptor],
                    getData: function(/*params*/){
                        return $q.reject({ description: 'crappy data'});
                    }
                });

                // when
                var actualReason;
                tp.reload().catch(function(reason){
                    actualReason = reason;
                });
                scope.$digest();

                // then
                expect(actualReason.code).toBe(400);
                expect(actualReason.description).toBe('crappy data');
            }));

            it('should be able to replace reason returned by getData', inject(function($q){
                // given
                var interceptor = {
                    responseError: function(/*reason, params*/){
                        return $q.reject('Cancelled by user');
                    }
                };
                var tp = createNgTableParams({
                    interceptors: [interceptor],
                    getData: function(/*params*/){
                        return $q.reject('BANG!');
                    }
                });

                // when
                var actualReason;
                tp.reload().catch(function(reason){
                    actualReason = reason;
                });
                scope.$digest();

                // then
                expect(actualReason).toBe('Cancelled by user');
            }));

            it('should be able to access tableParams supplied to getData', function(){
                // given
                var interceptor = {
                    response: function(reason, params){
                        this.actualParams = params;
                    }
                };
                var tp = createNgTableParams({ interceptors: [interceptor]});

                // when
                var actualData;
                tp.reload();
                scope.$digest();

                // then
                expect(interceptor.actualParams).toBe(tp);
            });
        });

        describe('one response plus responseError interceptor', function(){

            it('should NOT call responseError on same interceptor whose response method fails', inject(function($q){
                // given
                var interceptor = {
                    response: function(/*data, params*/){
                        return $q.reject('BANG!');
                    },
                    responseError: function(reason/*, params*/){
                        this.hasRun = true;
                    }
                };
                var tp = createNgTableParams({
                    interceptors: [interceptor],
                    getData: function(/*params*/){
                        return [1,2,3];
                    }
                });

                // when
                tp.reload();
                scope.$digest();

                // then
                expect(interceptor.hasRun).toBeFalsy();
            }));
        });

        describe('multiple response interceptors', function(){

            it('should run interceptors in the order they were registered', function(){
                // given
                var callCount = 0;
                var interceptor = {
                    response: function(/*data, params*/){
                        this.sequence = callCount;
                        callCount++;
                    }
                };
                var interceptors = [interceptor, angular.copy(interceptor)];
                var tp = createNgTableParams({ interceptors: interceptors});

                // when
                tp.reload();
                scope.$digest();

                // then
                expect(interceptors[0].sequence).toBe(0);
                expect(interceptors[1].sequence).toBe(1);
            });

            it('results of one interceptor should be piped to the next validator', function(){
                // given
                var interceptor = {
                    response: function(data/*, params*/){
                        return data.map(function(item){
                            return item * 2;
                        });
                    }
                };
                var interceptor2 = {
                    response: function(data/*, params*/){
                        return data.map(function(item){
                            return item.toString() + '0';
                        });
                    }
                };
                var tp = createNgTableParams({ interceptors: [interceptor, interceptor2], getData: function(){
                    return [2, 3];
                }});

                // when
                var actualData;
                tp.reload().then(function(data){
                    actualData = data;
                });
                scope.$digest();

                // then
                expect(actualData).toEqual(['40', '60']);
            });
        });

        describe('multiple response and responseError interceptors', function(){

            it('responseError of next interceptor should receive failures from previous interceptor', inject(function($q){
                // given
                var badInterceptor = {
                    response: function(/*data, params*/){
                        return $q.reject('BANG!');
                    }
                };
                var nextInterceptor = {
                    responseError: function(/*reason, params*/){
                        this.hasRun = true;
                    }
                };
                var tp = createNgTableParams({ interceptors: [badInterceptor, nextInterceptor]});

                // when
                tp.reload();
                scope.$digest();

                // then
                expect(nextInterceptor.hasRun).toBe(true);
            }));

            it('should call next response interceptor when previous interceptor recovers from failure', inject(function($q){
                // given
                var badInterceptor = {
                    response: function(/*data, params*/){
                        return $q.reject('BANG!');
                    }
                };
                var recoveringInterceptor = {
                    responseError: function(/*reason, params*/){
                        return [8894,58];
                    }
                };
                var recoveredData;
                var nextInterceptor = {
                    response: function(data/*, params*/){
                        this.hasRun = true;
                        recoveredData = data;
                    }
                };
                var tp = createNgTableParams({ interceptors: [badInterceptor, recoveringInterceptor, nextInterceptor]});

                // when
                tp.reload();
                scope.$digest();

                // then
                expect(nextInterceptor.hasRun).toBe(true);
                expect(recoveredData).toEqual([8894,58]);
            }));
        });
    });

    describe('events', function(){

        var actualEventArgs,
            actualPublisher,
            fakeTableParams,
            ngTableEventsChannel;

        beforeEach(inject(function(_ngTableEventsChannel_){
            ngTableEventsChannel = _ngTableEventsChannel_;
            fakeTableParams = {};
            actualPublisher = undefined;
            actualEventArgs = undefined;
        }));

        function getSubscriberCount(){
            var allEventNames = Object.keys($rootScope.$$listenerCount);
            var ngTableEvents = allEventNames.filter(function(event){
                return event.indexOf('ngTable:') === 0;
            });
            return ngTableEvents.reduce(function(result, event){
                result += $rootScope.$$listenerCount[event];
                return result;
            }, 0);
        }

        describe('general pub/sub mechanics', function(){

            var supportedEvents = ['DatasetChanged', 'AfterReloadData', 'PagesChanged', 'AfterCreated'];

            it('should be safe to publish event when no subscribers', function () {

                function test(event) {
                    ngTableEventsChannel['publish' + event](fakeTableParams);
                }

                supportedEvents.forEach(test);
            });

            it('publishing event should notify registered subscribers (one)', function(){

                function test(event){
                    // given
                    var cbCount = 0;
                    ngTableEventsChannel['on' + event](function(){
                        cbCount++;
                    });

                    // when
                    ngTableEventsChannel['publish' + event](fakeTableParams);

                    // then
                    expect(cbCount).toBe(1);
                }

                supportedEvents.forEach(test);
            });

            it('publishing event should notify registered subscribers (multiple)', function(){

                function test(event){
                    // given
                    var cb1Count = 0;
                    ngTableEventsChannel['on' + event](function(){
                        cb1Count++;
                    });
                    var cb2Count = 0;
                    ngTableEventsChannel['on' + event](function(){
                        cb2Count++;
                    });

                    // when
                    ngTableEventsChannel['publish' + event](fakeTableParams);

                    // then
                    expect(cb1Count).toBe(1);
                    expect(cb2Count).toBe(1);
                }

                supportedEvents.forEach(test);
            });

            it('subscriber should be able to unregister their callback', function(){

                function test(event){
                    // given
                    var cbCount = 0;
                    var subscription = ngTableEventsChannel['on' + event](function(){
                        cbCount++;
                    });
                    ngTableEventsChannel['publish' + event](fakeTableParams);
                    expect(cbCount).toBe(1); // checking assumptions
                    expect(getSubscriberCount()).toBe(1); // checking assumptions
                    cbCount = 0; // reset

                    // when
                    subscription(); // unsubscribe
                    ngTableEventsChannel['publish' + event](fakeTableParams);

                    // then
                    expect(cbCount).toBe(0);
                    expect(getSubscriberCount()).toBe(0);
                }

                supportedEvents.forEach(test);
            });

            it('subscriber should be able specify the scope to receive events', function(){

                // this is useful as it allows all subscriptions to be removed by calling $destroy on that scope

                function test(event){
                    // given
                    var childScope = $rootScope.$new();
                    var cbCount = 0;
                    ngTableEventsChannel['on' + event](function(){
                        cbCount++;
                    }, childScope);

                    // when, then
                    ngTableEventsChannel['publish' + event](fakeTableParams);
                    expect(cbCount).toBe(1);

                    cbCount = 0; // reset

                    // when, then
                    childScope.$destroy();
                    ngTableEventsChannel['publish' + event](fakeTableParams);

                    // then
                    expect(cbCount).toBe(0);
                }

                supportedEvents.forEach(test);
            });

            it('should not notify subscribers who have filter out the publisher', function(){

                function test(event){
                    // given
                    var cbCount = 0;
                    ngTableEventsChannel['on' + event](function(){
                        cbCount++;
                    }, function(publisher){
                        return publisher === fakeTableParams;
                    });

                    // when
                    ngTableEventsChannel['publish' + event](fakeTableParams);
                    var anoParams = {};
                    ngTableEventsChannel['publish' + event](anoParams);

                    // then
                    expect(cbCount).toBe(1);
                }

                supportedEvents.forEach(test);
            });

            it('should not notify subscribers who have filter not to receive event based on arg values', function(){

                function test(event){
                    // given
                    var cbCount = 0;
                    ngTableEventsChannel['on' + event](function(){
                        cbCount++;
                    }, function(publisher, arg1){
                        return arg1 === 1;
                    });

                    // when
                    ngTableEventsChannel['publish' + event](fakeTableParams, 'cc');
                    ngTableEventsChannel['publish' + event](fakeTableParams, 1);

                    // then
                    expect(cbCount).toBe(1);
                }

                supportedEvents.forEach(test);
            });

            it('should support a shorthand for subscribers to receive events from specific NgTableParams instance', function () {

                function test(event) {
                    // given
                    var cbCount = 0;
                    ngTableEventsChannel['on' + event](function () {
                        cbCount++;
                    }, fakeTableParams);

                    // when
                    ngTableEventsChannel['publish' + event](fakeTableParams);
                    var anoParams = {};
                    ngTableEventsChannel['publish' + event](anoParams);

                    // then
                    expect(cbCount).toBe(1);
                }

                supportedEvents.forEach(test);
            });

            it('publisher should be supplied to subscriber callback', function(){

                function test(event){
                    // given
                    var cbCount = 0;
                    ngTableEventsChannel['on' + event](function(params){
                        actualPublisher = params;
                    });

                    // when
                    ngTableEventsChannel['publish' + event](fakeTableParams);

                    // then
                    expect(actualPublisher).toBe(fakeTableParams);
                }

                supportedEvents.forEach(test);
            });

            it('remaining event args should be supplied to subscriber callback', function(){

                function test(event){
                    // given
                    ngTableEventsChannel['on' + event](function(params/*, ...args*/){
                        actualPublisher = params;
                        actualEventArgs = _.rest(arguments);
                    });

                    // when
                    var arg1 = [1, 2];
                    var arg2 = [1];
                    ngTableEventsChannel['publish' + event](fakeTableParams, arg1, arg2);

                    // then
                    expect(actualEventArgs).toEqual([arg1, arg2]);
                }

                supportedEvents.forEach(test);
            });

            it('subscribers should never receive events from null instance of tableParams', function(){

                function test(event){
                    // given
                    var cbCount = 0;
                    ngTableEventsChannel['on' + event](function(params/*, ...args*/){
                        cbCount++;
                    });

                    // when
                    fakeTableParams.isNullInstance = true;
                    ngTableEventsChannel['publish' + event](fakeTableParams);

                    // then
                    expect(cbCount).toEqual(0);
                }

                supportedEvents.forEach(test);
            });

        });

        describe('afterCreated', function(){

            it('should fire when a new NgTableParams has been constructed', function(){
                // given
                ngTableEventsChannel.onAfterCreated(function(params){
                    actualPublisher = params;
                });

                // when
                var params = createNgTableParams();

                // then
                expect(actualPublisher).toBe(params);
            });
        });

        describe('afterReloadData', function(){

            it('should fire when a reload completes', function(){
                // given
                ngTableEventsChannel.onAfterReloadData(function(params, newVal, oldVal){
                    actualPublisher = params;
                    actualEventArgs = [newVal, oldVal];
                });
                var newDatapage = [1, 5, 6];
                var params = createNgTableParams({ getData: function(){
                    return newDatapage;
                }});

                // when
                params.reload();
                scope.$digest();

                // then
                expect(actualPublisher).toBe(params);
                expect(actualEventArgs).toEqual([newDatapage, []]);
            });

            it('should fire on reload even if datapage remains the same array', function(){
                // given
                var callCount = 0;
                ngTableEventsChannel.onAfterReloadData(function(/*params, newVal, oldVal*/){
                    callCount++;
                });
                var dataPage = [1,2,3];
                var params = createNgTableParams({ getData: function(){
                    return dataPage;
                }});

                // when
                params.reload();
                scope.$digest();
                params.reload();
                scope.$digest();

                // then
                expect(callCount).toBe(2);
            });

            it('should fire after afterCreated event', function(){
                // given
                var events = [];
                ngTableEventsChannel.onAfterReloadData(function(/*params, newVal, oldVal*/){
                    events.push('afterReloadData');
                });
                ngTableEventsChannel.onAfterCreated(function(/*params*/){
                    events.push('afterCreated');
                });

                // when
                var params = createNgTableParams({}, {dataset: [1,2,3,4,5,6]});
                params.reload();
                scope.$digest();

                // then
                expect(events[0]).toEqual('afterCreated');
                expect(events[1]).toEqual('afterReloadData');
            });

        });

        describe('pagesChanged', function(){

            it('should fire when a reload completes', function(){
                // given
                ngTableEventsChannel.onPagesChanged(function(params, newVal, oldVal){
                    actualPublisher = params;
                    actualEventArgs = [newVal, oldVal];
                });
                var params = createNgTableParams({ count: 5 }, { counts: [5,10], dataset: [1,2,3,4,5,6]});

                // when
                params.reload();
                scope.$digest();

                // then
                var expectedPages = params.generatePagesArray(params.page(), params.total(), params.count());
                expect(expectedPages.length).toBeGreaterThan(0); // checking assumptions
                expect(actualEventArgs).toEqual([expectedPages, undefined]);
            });

            it('should fire when a reload completes - no data', function(){
                // given
                ngTableEventsChannel.onPagesChanged(function(params, newVal, oldVal){
                    actualPublisher = params;
                    actualEventArgs = [newVal, oldVal];
                });
                var params = createNgTableParams({ count: 5 }, { counts: [5,10], dataset: []});

                // when
                params.reload();
                scope.$digest();

                // then
                expect(actualEventArgs).toEqual([[], undefined]);
            });

            it('should fire when a reload completes (multiple)', function(){
                // given
                var callCount = 0;
                ngTableEventsChannel.onPagesChanged(function(/*params, newVal, oldVal*/){
                    callCount++;
                });
                var params = createNgTableParams({ count: 5 }, { counts: [5,10], dataset: [1,2,3,4,5,6]});

                // when
                params.reload();
                scope.$digest();
                params.page(2); // trigger a change to pages data structure
                params.reload();
                scope.$digest();

                // then
                expect(callCount).toBe(2);
            });

            it('should not fire on reload when pages remain the same', function(){
                // given
                var callCount = 0;
                ngTableEventsChannel.onPagesChanged(function(/*params, newVal, oldVal*/){
                    callCount++;
                });
                var params = createNgTableParams({ count: 5 }, { counts: [5,10], dataset: [1,2,3,4,5,6]});
                params.reload();
                scope.$digest();

                // when
                params.reload();
                scope.$digest();

                // then
                expect(callCount).toBe(1);
            });

            it('should fire after afterCreated event', function(){
                // given
                var events = [];
                ngTableEventsChannel.onPagesChanged(function(/*params, newVal, oldVal*/){
                    events.push('pagesChanged');
                });
                ngTableEventsChannel.onAfterCreated(function(/*params*/){
                    events.push('afterCreated');
                });

                // when
                var params = createNgTableParams({ count: 5 }, { counts: [5,10], dataset: [1,2,3,4,5,6]});
                params.reload();
                scope.$digest();

                // then
                expect(events[0]).toEqual('afterCreated');
                expect(events[1]).toEqual('pagesChanged');
            });
        });

        describe('datasetChanged', function(){

            it('should fire when a initial dataset is supplied as a settings value', function(){
                // given
                ngTableEventsChannel.onDatasetChanged(function(params, newVal, oldVal){
                    actualPublisher = params;
                    actualEventArgs = [newVal, oldVal];
                });

                // when
                var initialDs = [5, 10];
                var params = createNgTableParams({ dataset: initialDs});

                // then
                expect(actualPublisher).toBe(params);
                expect(actualEventArgs).toEqual([initialDs, null]);
            });

            it('should fire when a new dataset is supplied as a settings value', function(){
                // given
                var initialDs = [1, 2];
                ngTableEventsChannel.onDatasetChanged(function(params, newVal, oldVal){
                    actualPublisher = params;
                    actualEventArgs = [newVal, oldVal];
                });
                var params = createNgTableParams({ dataset: initialDs});

                // when
                var newDs = [5, 10];
                params.settings({ dataset: newDs});

                // then
                expect(actualPublisher).toBe(params);
                expect(actualEventArgs).toEqual([newDs, initialDs]);
            });

            it('should fire when a dataset is removed from settings value', function(){
                // given
                var initialDs = [1, 2];
                ngTableEventsChannel.onDatasetChanged(function(params, newVal, oldVal){
                    actualPublisher = params;
                    actualEventArgs = [newVal, oldVal];
                });
                var params = createNgTableParams({ dataset: initialDs});

                // when
                var newDs = null;
                params.settings({ dataset: newDs});

                // then
                expect(actualPublisher).toBe(params);
                expect(actualEventArgs).toEqual([newDs, initialDs]);
            });

            it('should NOT fire when the same dataset array is supplied as a new settings value', function(){
                // given
                var callCount = 0;
                var initialDs = [1, 2];
                ngTableEventsChannel.onDatasetChanged(function(/*params, newVal, oldVal*/){
                    callCount++;
                });
                var params = createNgTableParams({ dataset: initialDs});

                // when
                params.settings({ dataset: initialDs});

                // then
                expect(callCount).toBe(1);
            });

            it('settings().dataset on publisher should reference the new dataset', function(){
                var initialDs = [1, 2];
                var newDs = [1, 2, 3];
                var params = createNgTableParams({ dataset: initialDs});
                ngTableEventsChannel.onDatasetChanged(function(params, newVal/*, oldVal*/){
                    expect(params.settings().dataset).toBe(newVal);
                });
                params.settings({ dataset: newDs});
            });

            it('should fire after afterCreated event', function(){
                // given
                var events = [];
                var initialDs = [1, 2];
                ngTableEventsChannel.onDatasetChanged(function(/*params, newVal, oldVal*/){
                    events.push('datasetChanged');
                });
                ngTableEventsChannel.onAfterCreated(function(/*params*/){
                    events.push('afterCreated');
                });

                // when
                var params = createNgTableParams({ dataset: initialDs});

                // then
                expect(events[0]).toEqual('afterCreated');
                expect(events[1]).toEqual('datasetChanged');
            });
        });
    })
});