~andreserl/maas/refactor_debconf_selections_preseed

/* Copyright 2015-2016 Canonical Ltd.  This software is licensed under the

 * GNU Affero General Public License version 3 (see the file LICENSE).

 *

 * Unit tests for NodeDetailsController.

 */

// Make a fake user.

var userId = 0;

function makeUser() {

    return {

        id: userId++,

        username: makeName("username"),

        first_name: makeName("first_name"),

        last_name: makeName("last_name"),

        email: makeName("email"),

        is_superuser: false,

        sshkeys_count: 0

    };

}

describe("NodeDetailsController", function() {

    // Load the MAAS module.

    beforeEach(module("MAAS"));

    // Grab the needed angular pieces.

    var $controller, $rootScope, $location, $scope, $q;

    beforeEach(inject(function($injector) {

        $controller = $injector.get("$controller");

        $rootScope = $injector.get("$rootScope");

        $location = $injector.get("$location");

        $scope = $rootScope.$new();

        $q = $injector.get("$q");

    }));

    // Load the required dependencies for the NodeDetails controller and

    // mock the websocket connection.

    var MachinesManager, ControllersManager, ServicesManager;

    var DevicesManager, GeneralManager, UsersManager, DomainsManager;

    var TagsManager, RegionConnection, ManagerHelperService, ErrorService;

    var webSocket;

    beforeEach(inject(function($injector) {

        MachinesManager = $injector.get("MachinesManager");

        ControllersManager = $injector.get("ControllersManager");

        ZonesManager = $injector.get("ZonesManager");

        GeneralManager = $injector.get("GeneralManager");

        UsersManager = $injector.get("UsersManager");

        TagsManager = $injector.get("TagsManager");

        DomainsManager = $injector.get("DomainsManager");

        RegionConnection = $injector.get("RegionConnection");

        ManagerHelperService = $injector.get("ManagerHelperService");

        ServicesManager = $injector.get("ServicesManager");

        ErrorService = $injector.get("ErrorService");

        // Mock buildSocket so an actual connection is not made.

        webSocket = new MockWebSocket();

        spyOn(RegionConnection, "buildSocket").and.returnValue(webSocket);

    }));

    // Make a fake zone.

    function makeZone() {

        var zone = {

            id: makeInteger(0, 10000),

            name: makeName("zone")

        };

        ZonesManager._items.push(zone);

        return zone;

    }

    // Make a fake node.

    function makeNode() {

        var zone = makeZone();

        var node = {

            system_id: makeName("system_id"),

            hostname: makeName("hostname"),

            fqdn: makeName("fqdn"),

            actions: [],

            architecture: "amd64/generic",

            zone: angular.copy(zone),

            power_type: "",

            power_parameters: null,

            summary_xml: null,

            summary_yaml: null,

            commissioning_results: [],

            testing_results: [],

            installation_results: [],

            events: [],

            interfaces: [],

            extra_macs: []

        };

        MachinesManager._items.push(node);

        return node;

    }

    // Make a fake event.

    function makeEvent() {

        return {

            type: {

                description: makeName("type")

            },

            description: makeName("description")

        };

    }

    // Create the node that will be used and set the routeParams.

    var node, $routeParams;

    beforeEach(function() {

        node = makeNode();

        $routeParams = {

            system_id: node.system_id

        };

    });

    // Makes the NodeDetailsController

    function makeController(loadManagersDefer) {

        var loadManagers = spyOn(ManagerHelperService, "loadManagers");

        if(angular.isObject(loadManagersDefer)) {

            loadManagers.and.returnValue(loadManagersDefer.promise);

        } else {

            loadManagers.and.returnValue($q.defer().promise);

        }

        // Start the connection so a valid websocket is created in the

        // RegionConnection.

        RegionConnection.connect("");

        // Set the authenticated user, and by default make them superuser.

        UsersManager._authUser = {

            is_superuser: true

        };

        // Create the controller.

        var controller = $controller("NodeDetailsController", {

            $scope: $scope,

            $rootScope: $rootScope,

            $routeParams: $routeParams,

            $location: $location,

            MachinesManager: MachinesManager,

            ControllersManager: ControllersManager,

            ZonesManager: ZonesManager,

            GeneralManager: GeneralManager,

            UsersManager: UsersManager,

            TagsManager: TagsManager,

            DomainsManager: DomainsManager,

            ManagerHelperService: ManagerHelperService,

            ServicesManager: ServicesManager,

            ErrorService: ErrorService

        });

        $scope.nodesManager = MachinesManager;

        // Since the osSelection directive is not used in this test the

        // osSelection item on the model needs to have $reset function added

        // because it will be called throughout many of the tests.

        $scope.osSelection.$reset = jasmine.createSpy("$reset");

        return controller;

    }

    // Make the controller and resolve the setActiveItem call.

    function makeControllerResolveSetActiveItem() {

        var setActiveDefer = $q.defer();

        spyOn(MachinesManager, "setActiveItem").and.returnValue(

            setActiveDefer.promise);

        var defer = $q.defer();

        var controller = makeController(defer);

        defer.resolve();

        $rootScope.$digest();

        setActiveDefer.resolve(node);

        $rootScope.$digest();

        return controller;

    }

    it("sets title to loading and page to nodes", function() {

        var controller = makeController();

        expect($rootScope.title).toBe("Loading...");

        expect($rootScope.page).toBe("nodes");

    });

    it("sets the initial $scope values", function() {

        var controller = makeController();

        expect($scope.loaded).toBe(false);

        expect($scope.node).toBeNull();

        expect($scope.actionOption).toBeNull();

        expect($scope.allActionOptions).toBeNull();

        expect($scope.availableActionOptions).toEqual([]);

        expect($scope.actionError).toBeNull();

        expect($scope.osinfo).toBe(GeneralManager.getData("osinfo"));

        expect($scope.power_types).toBe(GeneralManager.getData("power_types"));

        expect($scope.osSelection.osystem).toBeNull();

        expect($scope.osSelection.release).toBeNull();

        expect($scope.commissionOptions).toEqual({

            enableSSH: false,

            skipNetworking: false,

            skipStorage: false

        });

        expect($scope.releaseOptions).toEqual({});

        expect($scope.checkingPower).toBe(false);

        expect($scope.devices).toEqual([]);

        expect($scope.services).toEqual({});

    });

    it("sets initial values for summary section", function() {

        var controller = makeController();

        expect($scope.summary).toEqual({

            editing: false,

            architecture: {

                selected: null,

                options: GeneralManager.getData("architectures")

            },

            min_hwe_kernel: {

                selected: null,

                options: GeneralManager.getData("min_hwe_kernels")

            },

            zone: {

                selected: null,

                options: ZonesManager.getItems()

            },

            tags: []

        });

        expect($scope.summary.architecture.options).toBe(

            GeneralManager.getData("architectures"));

        expect($scope.summary.min_hwe_kernel.options).toBe(

            GeneralManager.getData("min_hwe_kernels"));

        expect($scope.summary.zone.options).toBe(

            ZonesManager.getItems());

    });

    it("sets initial values for power section", function() {

        var controller = makeController();

        expect($scope.power).toEqual({

            editing: false,

            type: null,

            bmc_node_count: 0,

            parameters: {}

        });

    });

    it("sets initial values for events section", function() {

        var controller = makeController();

        expect($scope.events).toEqual({

            limit: 10

        });

    });

    it("sets initial values for machine output section", function() {

        var controller = makeController();

        expect($scope.machine_output).toEqual({

            viewable: false,

            selectedView: null,

            views: [],

            showSummaryToggle: true,

            summaryType: 'yaml'

        });

    });

    it("calls loadManagers with all needed managers", function() {

        var controller = makeController();

        expect(ManagerHelperService.loadManagers).toHaveBeenCalledWith(

            $scope, [

                MachinesManager, ControllersManager, ZonesManager,

                GeneralManager, UsersManager, TagsManager, DomainsManager,

                ServicesManager]);

    });

    it("doesnt call setActiveItem if node is loaded", function() {

        spyOn(MachinesManager, "setActiveItem").and.returnValue(

            $q.defer().promise);

        var defer = $q.defer();

        var controller = makeController(defer);

        MachinesManager._activeItem = node;

        defer.resolve();

        $rootScope.$digest();

        expect($scope.node).toBe(node);

        expect($scope.loaded).toBe(true);

        expect(MachinesManager.setActiveItem).not.toHaveBeenCalled();

    });

    it("calls setActiveItem if node is not active", function() {

        spyOn(MachinesManager, "setActiveItem").and.returnValue(

            $q.defer().promise);

        var defer = $q.defer();

        var controller = makeController(defer);

        defer.resolve();

        $rootScope.$digest();

        expect(MachinesManager.setActiveItem).toHaveBeenCalledWith(

            node.system_id);

    });

    it("sets node and loaded once setActiveItem resolves", function() {

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.node).toBe(node);

        expect($scope.loaded).toBe(true);

    });

    it("sets machine values on load", function () {

        spyOn(MachinesManager, "setActiveItem").and.returnValue(

            $q.defer().promise);

        var defer = $q.defer();

        var controller = makeController(defer);

        defer.resolve();

        $rootScope.$digest();

        expect($scope.nodesManager).toBe(MachinesManager);

        expect($scope.isController).toBe(false);

        expect($scope.type_name).toBe('machine');

        expect($scope.type_name_title).toBe('Machine');

    });

    it("sets controller values on load", function () {

        $routeParams.type = 'controller';

        spyOn(MachinesManager, "setActiveItem").and.returnValue(

            $q.defer().promise);

        spyOn(ControllersManager, "setActiveItem").and.returnValue(

            $q.defer().promise);

        var defer = $q.defer();

        var controller = makeController(defer);

        defer.resolve();

        $rootScope.$digest();

        expect($scope.nodesManager).toBe(ControllersManager);

        expect($scope.isController).toBe(true);

        expect($scope.type_name).toBe('controller');

        expect($scope.type_name_title).toBe('Controller');

    });

    it("updateServices sets $scope.services when node is loaded", function() {

        spyOn(ControllersManager, "getServices").and.returnValue([

            { "status": "unknown", "name": "tgt" },

            { "status": "running", "name": "rackd" }

        ]);

        spyOn(ControllersManager, "setActiveItem").and.returnValue(

            $q.defer().promise);

        var defer = $q.defer();

        $routeParams.type = 'controller';

        var controller = makeController(defer);

        ControllersManager._activeItem = node;

        defer.resolve();

        $rootScope.$digest();

        expect($scope.node).toBe(node);

        expect($scope.loaded).toBe(true);

        expect(ControllersManager.getServices).toHaveBeenCalledWith(node);

        expect($scope.services).not.toBeNull();

        expect(Object.keys($scope.services).length).toBe(2);

        expect($scope.services.tgt.status).toBe('unknown');

        expect($scope.services.rackd.status).toBe('running');

    });

    it("getAllActionOptions called when node is loaded", function() {

        spyOn(ControllersManager, "setActiveItem").and.returnValue(

            $q.defer().promise);

        var defer = $q.defer();

        $routeParams.type = 'controller';

        var controller = makeController(defer);

        var getAllActionOptions = spyOn($scope, "getAllActionOptions");

        var myNode = angular.copy(node);

        // Make node a rack controller.

        myNode.node_type = 2;

        ControllersManager._activeItem = myNode;

        defer.resolve();

        $rootScope.$digest();

        expect(getAllActionOptions).toHaveBeenCalledWith(2);

    });

    it("title is updated once setActiveItem resolves", function() {

        var controller = makeControllerResolveSetActiveItem();

        expect($rootScope.title).toBe(node.fqdn);

    });

    it("summary section placed in edit mode if architecture blank",

        function() {

            node.architecture = "";

            GeneralManager._data.power_types.data = [{}];

            GeneralManager._data.architectures.data = ["amd64/generic"];

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.summary.editing).toBe(true);

        });

    it("summary section not placed in edit mode if no usable architectures",

        function() {

            node.architecture = "";

            GeneralManager._data.power_types.data = [{}];

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.summary.editing).toBe(false);

        });

    it("summary section not placed in edit mode if architecture present",

        function() {

            GeneralManager._data.architectures.data = [node.architecture];

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.summary.editing).toBe(false);

        });

    it("summary section is updated once setActiveItem resolves", function() {

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.summary.zone.selected).toBe(

            ZonesManager.getItemFromList(node.zone.id));

        expect($scope.summary.architecture.selected).toBe(node.architecture);

        expect($scope.summary.tags).toEqual(node.tags);

    });

    it("power section placed in edit mode if power_type blank", function() {

        GeneralManager._data.power_types.data = [{}];

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.power.editing).toBe(true);

    });

    it("power section not placed in edit mode if no power_types", function() {

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.power.editing).toBe(false);

    });

    it("power section not placed in edit mode if power_type", function() {

        node.power_type = makeName("power");

        GeneralManager._data.power_types.data = [{}];

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.power.editing).toBe(false);

    });

    it("machine output not visible if all required data missing", function() {

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.machine_output.viewable).toBe(false);

    });

    it("machine output visible if summary_xml and summary_yaml", function() {

        node.summary_xml = node.summary_yaml = "summary";

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.machine_output.viewable).toBe(true);

    });

    it("machine output visible if commissioning_results", function() {

        node.commissioning_results.push({});

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.machine_output.viewable).toBe(true);

    });

    it("machine output not visible if commissioning_results not an array",

        function() {

            node.commissioning_results = undefined;

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.viewable).toBe(false);

        });

    it("machine output visible if installation_results", function() {

        node.installation_results.push({});

        var controller = makeControllerResolveSetActiveItem();

        expect($scope.machine_output.viewable).toBe(true);

    });

    it("machine output not visible if installation_results not an array",

        function() {

            node.installation_results = undefined;

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.viewable).toBe(false);

        });

    it("machine output summary view available if summary_xml and summary_yaml",

        function() {

            node.summary_xml = node.summary_yaml = "summary";

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.views).toEqual([{

                name: "summary",

                title: "Commissioning Summary"

            }]);

        });

    it("machine output commissioning view available if commissioning_results",

        function() {

            node.commissioning_results.push({});

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.views).toEqual([{

                name: "commissioning",

                title: "Commissioning Results"

            }]);

        });

    it("machine output installation view available if installation_results",

        function() {

            node.installation_results.push({});

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.views).toEqual([{

                name: "installation",

                title: "Installation Output"

            }]);

        });

    it("machine output first available view is set as selectedView",

        function() {

            node.commissioning_results.push({});

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.selectedView).toEqual({

                name: "commissioning",

                title: "Commissioning Results"

            });

        });

    it("machine output previous selected view is still selected",

        function() {

            node.commissioning_results.push({});

            var controller = makeControllerResolveSetActiveItem();

            // Add summary output and make updateMachineOutput be called

            // again, but forcing a digest cycle.

            node.summary_xml = node.summary_yaml = "summary";

            $rootScope.$digest();

            // Output view should still be selected as it was initially

            // selected.

            expect($scope.machine_output.selectedView).toEqual({

                name: "commissioning",

                title: "Commissioning Results"

            });

        });

    it("machine output install view is always selected first if possible",

        function() {

            node.commissioning_results.push({});

            node.testing_results.push({});

            node.installation_results.push({});

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.selectedView).toEqual({

                name: "installation",

                title: "Installation Output"

            });

        });

    it("machine output summary toggle is viewable when summary view selected",

        function() {

            node.summary_xml = node.summary_yaml = "summary";

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.showSummaryToggle).toBe(true);

        });

    it("machine output summary toggle is not viewable when not summary view",

        function() {

            node.commissioning_results.push({});

            var controller = makeControllerResolveSetActiveItem();

            expect($scope.machine_output.showSummaryToggle).toBe(false);

        });

    it("starts watching once setActiveItem resolves", function() {

        var setActiveDefer = $q.defer();

        spyOn(MachinesManager, "setActiveItem").and.returnValue(

            setActiveDefer.promise);

        var defer = $q.defer();

        var controller = makeController(defer);

        spyOn($scope, "$watch");

        spyOn($scope, "$watchCollection");

        defer.resolve();

        $rootScope.$digest();

        setActiveDefer.resolve(node);

        $rootScope.$digest();

        var watches = [];

        var i, calls = $scope.$watch.calls.allArgs();

        for(i = 0; i < calls.length; i++) {

            watches.push(calls[i][0]);

        }

        var watchCollections = [];

        calls = $scope.$watchCollection.calls.allArgs();

        for(i = 0; i < calls.length; i++) {

            watchCollections.push(calls[i][0]);

        }

        expect(watches).toEqual([

            "node.fqdn",

            "node.devices",

            "node.actions",

            "node.architecture",

            "node.min_hwe_kernel",

            "node.zone.id",

            "node.power_type",

            "node.power_parameters",

            "node.service_ids",

            "node.summary_xml",

            "node.summary_yaml",

            "node.commissioning_results",

            "node.installation_results"

        ]);

        expect(watchCollections).toEqual([

            $scope.summary.architecture.options,

            $scope.summary.min_hwe_kernel.options,

            $scope.summary.zone.options,

            "power_types"

        ]);

    });

    it("calls startPolling once managers loaded", function() {

        spyOn(MachinesManager, "setActiveItem").and.returnValue(

            $q.defer().promise);

        spyOn(GeneralManager, "startPolling");

        var defer = $q.defer();

        var controller = makeController(defer);

        defer.resolve();

        $rootScope.$digest();

        expect(GeneralManager.startPolling.calls.allArgs()).toEqual(

            [["architectures"], ["hwe_kernels"], ["osinfo"], ["power_types"]]);

    });

    it("calls stopPolling when the $scope is destroyed", function() {

        spyOn(GeneralManager, "stopPolling");

        var controller = makeController();

        $scope.$destroy();

        expect(GeneralManager.stopPolling.calls.allArgs()).toEqual(

            [["architectures"], ["hwe_kernels"], ["osinfo"], ["power_types"]]);

    });

    it("updates $scope.devices", function() {

        var setActiveDefer = $q.defer();

        spyOn(MachinesManager, "setActiveItem").and.returnValue(

            setActiveDefer.promise);

        var defer = $q.defer();

        var controller = makeController(defer);

        node.devices = [

            {

                fqdn: "device1.maas",

                interfaces: []

            },

            {

                fqdn: "device2.maas",

                interfaces: [

                    {

                        mac_address: "00:11:22:33:44:55",

                        links: []

                    }

                ]

            },

            {

                fqdn: "device3.maas",

                interfaces: [

                    {

                        mac_address: "00:11:22:33:44:66",

                        links: []

                    },

                    {

                        mac_address: "00:11:22:33:44:77",

                        links: [

                            {

                                ip_address: "192.168.122.1"

                            },

                            {

                                ip_address: "192.168.122.2"

                            },

                            {

                                ip_address: "192.168.122.3"

                            }

                        ]

                    }

                ]

            }

        ];

        defer.resolve();