← Back to branch summary

~ltrager/maas/lp1566108

« back to all changes in this revision

Viewing changes to src/maasserver/static/js/angular/controllers/tests/test_node_details.js

  • Committer: MAAS Lander
  • Author(s): Blake Rouse
  • Date: 2016-04-11 14:14:58 UTC
  • mfrom: (4892.1.1 fix-1566920)
  • Revision ID: maas_lander-20160411141458-s0crhw03vcuws6wv
[r=mpontillo][bug=1566920][author=blake-rouse] Fix handling no connected rack controllers on the machine details page. Cleanup error messages on the machine details page. Fix power_type options from being reset mid type.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/static/js/angular/controllers/tests/test_node_details.js
328
328
        expect($rootScope.title).toBe(node.fqdn);
329
329
    });
330
330
 
331
 
    it("invalid_arch error visible if node architecture empty", function() {
332
 
        node.architecture = "";
333
 
 
334
 
        var controller = makeControllerResolveSetActiveItem();
335
 
        expect($scope.errors.invalid_arch.viewable).toBe(true);
336
 
    });
337
 
 
338
 
    it("invalid_arch error visible if node architecture not present",
339
 
        function() {
340
 
            GeneralManager._data.architectures.data = [makeName("arch")];
341
 
 
342
 
            var controller = makeControllerResolveSetActiveItem();
343
 
            expect($scope.errors.invalid_arch.viewable).toBe(true);
344
 
        });
345
 
 
346
 
    it("invalid_arch error not visible if node architecture present",
347
 
        function() {
348
 
            GeneralManager._data.architectures.data = [node.architecture];
349
 
 
350
 
            var controller = makeControllerResolveSetActiveItem();
351
 
            expect($scope.errors.invalid_arch.viewable).toBe(false);
352
 
        });
353
 
 
354
331
    it("summary section placed in edit mode if architecture blank",
355
332
        function() {
356
333
            node.architecture = "";
 
334
            GeneralManager._data.power_types.data = [{}];
 
335
            GeneralManager._data.architectures.data = ["amd64/generic"];
357
336
 
358
337
            var controller = makeControllerResolveSetActiveItem();
359
338
            expect($scope.summary.editing).toBe(true);
360
339
        });
361
340
 
 
341
    it("summary section not placed in edit mode if no usable architectures",
 
342
        function() {
 
343
            node.architecture = "";
 
344
            GeneralManager._data.power_types.data = [{}];
 
345
 
 
346
            var controller = makeControllerResolveSetActiveItem();
 
347
            expect($scope.summary.editing).toBe(false);
 
348
        });
 
349
 
362
350
    it("summary section not placed in edit mode if architecture present",
363
351
        function() {
364
352
            GeneralManager._data.architectures.data = [node.architecture];
375
363
        expect($scope.summary.tags).toEqual(node.tags);
376
364
    });
377
365
 
378
 
    it("missing_power error visible if node power_type empty", function() {
379
 
        var controller = makeControllerResolveSetActiveItem();
380
 
        expect($scope.errors.missing_power.viewable).toBe(true);
381
 
    });
382
 
 
383
 
    it("missing_power error not visible if node power_type empty", function() {
384
 
        node.power_type = makeName("power");
385
 
 
386
 
        var controller = makeControllerResolveSetActiveItem();
387
 
        expect($scope.errors.missing_power.viewable).toBe(false);
388
 
    });
389
 
 
390
366
    it("power section placed in edit mode if power_type blank", function() {
 
367
        GeneralManager._data.power_types.data = [{}];
 
368
 
391
369
        var controller = makeControllerResolveSetActiveItem();
392
370
        expect($scope.power.editing).toBe(true);
393
371
    });
394
372
 
 
373
    it("power section not placed in edit mode if no power_types", function() {
 
374
        var controller = makeControllerResolveSetActiveItem();
 
375
        expect($scope.power.editing).toBe(false);
 
376
    });
 
377
 
395
378
    it("power section not placed in edit mode if power_type", function() {
396
379
        node.power_type = makeName("power");
 
380
        GeneralManager._data.power_types.data = [{}];
397
381
 
398
382
        var controller = makeControllerResolveSetActiveItem();
399
383
        expect($scope.power.editing).toBe(false);
564
548
        expect(watchCollections).toEqual([
565
549
            $scope.summary.architecture.options,
566
550
            $scope.summary.min_hwe_kernel.options,
567
 
            $scope.summary.zone.options
 
551
            $scope.summary.zone.options,
 
552
            "power_types"
568
553
        ]);
569
554
    });
570
555
 
1190
1175
        });
1191
1176
    });
1192
1177
 
 
1178
    describe("hasUsableArchitectures", function() {
 
1179
 
 
1180
        it("returns true if architecture available", function() {
 
1181
            var controller = makeController();
 
1182
            $scope.summary.architecture.options = ["amd64/generic"];
 
1183
            expect($scope.hasUsableArchitectures()).toBe(true);
 
1184
        });
 
1185
 
 
1186
        it("returns false if no architecture available", function() {
 
1187
            var controller = makeController();
 
1188
            $scope.summary.architecture.options = [];
 
1189
            expect($scope.hasUsableArchitectures()).toBe(false);
 
1190
        });
 
1191
    });
 
1192
 
 
1193
    describe("getArchitecturePlaceholder", function() {
 
1194
 
 
1195
        it("returns choose if architecture available", function() {
 
1196
            var controller = makeController();
 
1197
            $scope.summary.architecture.options = ["amd64/generic"];
 
1198
            expect($scope.getArchitecturePlaceholder()).toBe(
 
1199
                "Choose an architecture");
 
1200
        });
 
1201
 
 
1202
        it("returns error if no architecture available", function() {
 
1203
            var controller = makeController();
 
1204
            $scope.summary.architecture.options = [];
 
1205
            expect($scope.getArchitecturePlaceholder()).toBe(
 
1206
                "-- No usable architectures --");
 
1207
        });
 
1208
    });
 
1209
 
 
1210
    describe("hasInvalidArchitecture", function() {
 
1211
 
 
1212
        it("returns false if node is null", function() {
 
1213
            var controller = makeController();
 
1214
            $scope.node = null;
 
1215
            $scope.summary.architecture.options = ["amd64/generic"];
 
1216
            expect($scope.hasInvalidArchitecture()).toBe(false);
 
1217
        });
 
1218
 
 
1219
        it("returns true if node.architecture is blank", function() {
 
1220
            var controller = makeController();
 
1221
            $scope.node = {
 
1222
                architecture: ""
 
1223
            };
 
1224
            $scope.summary.architecture.options = ["amd64/generic"];
 
1225
            expect($scope.hasInvalidArchitecture()).toBe(true);
 
1226
        });
 
1227
 
 
1228
        it("returns true if node.architecture not in options", function() {
 
1229
            var controller = makeController();
 
1230
            $scope.node = {
 
1231
                architecture: "i386/generic"
 
1232
            };
 
1233
            $scope.summary.architecture.options = ["amd64/generic"];
 
1234
            expect($scope.hasInvalidArchitecture()).toBe(true);
 
1235
        });
 
1236
 
 
1237
        it("returns false if node.architecture in options", function() {
 
1238
            var controller = makeController();
 
1239
            $scope.node = {
 
1240
                architecture: "amd64/generic"
 
1241
            };
 
1242
            $scope.summary.architecture.options = ["amd64/generic"];
 
1243
            expect($scope.hasInvalidArchitecture()).toBe(false);
 
1244
        });
 
1245
    });
 
1246
 
1193
1247
    describe("invalidArchitecture", function() {
1194
1248
 
1195
1249
        it("returns true if selected architecture empty", function() {
1214
1268
        });
1215
1269
    });
1216
1270
 
 
1271
    describe("isRackControllerConnected", function() {
 
1272
 
 
1273
        it("returns false no power_types", function() {
 
1274
            var controller = makeController();
 
1275
            $scope.power_types = [];
 
1276
            expect($scope.isRackControllerConnected()).toBe(false);
 
1277
        });
 
1278
 
 
1279
        it("returns true if power_types", function() {
 
1280
            var controller = makeController();
 
1281
            $scope.power_types = [{}];
 
1282
            expect($scope.isRackControllerConnected()).toBe(true);
 
1283
        });
 
1284
    });
 
1285
 
1217
1286
    describe("canEdit", function() {
1218
1287
 
1219
 
        it("returns false if not super user and not controller", function() {
 
1288
        it("returns false if not super user", function() {
1220
1289
            var controller = makeController();
1221
1290
            $scope.isController = false;
1222
1291
            spyOn($scope, "isSuperUser").and.returnValue(false);
 
1292
            spyOn(
 
1293
                $scope,
 
1294
                "isRackControllerConnected").and.returnValue(true);
1223
1295
            expect($scope.canEdit()).toBe(false);
1224
1296
        });
1225
1297
 
1226
 
        it("returns false if super user and controller", function() {
 
1298
        it("returns false if controller", function() {
1227
1299
            var controller = makeController();
1228
1300
            $scope.isController = true;
1229
 
            expect($scope.canEdit()).toBe(false);
1230
 
        });
1231
 
 
1232
 
        it("returns true if super user and not controller",
 
1301
            spyOn(
 
1302
                $scope,
 
1303
                "isRackControllerConnected").and.returnValue(true);
 
1304
            expect($scope.canEdit()).toBe(false);
 
1305
        });
 
1306
 
 
1307
        it("returns false if rack disconnected", function() {
 
1308
            var controller = makeController();
 
1309
            $scope.isController = false;
 
1310
            spyOn(
 
1311
                $scope,
 
1312
                "isRackControllerConnected").and.returnValue(false);
 
1313
            expect($scope.canEdit()).toBe(false);
 
1314
        });
 
1315
 
 
1316
        it("returns true if super user, rack connected, not controller",
1233
1317
            function() {
1234
1318
                var controller = makeController();
1235
1319
                $scope.isController = false;
 
1320
                spyOn(
 
1321
                    $scope,
 
1322
                    "isRackControllerConnected").and.returnValue(true);
1236
1323
                expect($scope.canEdit()).toBe(true);
1237
1324
            });
1238
1325
    });