ONOS checkin based on commit tag e796610b1f721d02f9b0e213cf6f7790c10ecd60

Change-Id: Ife8810491034fe7becdba75dda20de4267bd15cd

10 files changed, 981 insertions, 0 deletions

diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoEvent-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoEvent-spec.js
new file mode 100644
index 00000000..ef94711e
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoEvent-spec.js
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Event Service - Unit Tests
+ */
+describe('factory: view/topo/topoEvent.js', function() {
+    var $log, fs, tes, bns;
+
+    beforeEach(module('ovTopo', 'onosNav', 'onosUtil', 'onosLayer', 'ngRoute',
+        'onosWidget'));
+
+    beforeEach(inject(function (_$log_, FnService,
+                                TopoEventService, ButtonService) {
+        $log = _$log_;
+        fs = FnService;
+        tes = TopoEventService;
+        bns = ButtonService;
+    }));
+
+    it('should define TopoEventService', function () {
+        expect(tes).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(tes, [
+            'start', 'stop'
+        ])).toBeTruthy();
+    });
+
+    // TODO: more tests...
+});
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoFilter-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoFilter-spec.js
new file mode 100644
index 00000000..eebccfca
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoFilter-spec.js
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Filter Service - Unit Tests
+ */
+describe('factory: view/topo/topoFilter.js', function() {
+    var $log, fs, fltr, bns, api;
+
+    var mockNodes = {
+            each: function () {},
+            classed: function () {}
+        },
+        mockLinks = {
+            each: function () {},
+            classed: function () {}
+        };
+
+    beforeEach(module('ovTopo', 'onosUtil', 'onosLayer', 'ngRoute', 'onosNav',
+        'onosWidget'));
+
+    beforeEach(inject(function (_$log_, FnService,
+                                TopoFilterService, ButtonService) {
+        $log = _$log_;
+        fs = FnService;
+        fltr = TopoFilterService;
+        bns = ButtonService;
+
+        api = {
+            node: function () { return mockNodes; },
+            link: function () { return mockLinks; }
+        };
+    }));
+
+    afterEach(function () {
+
+    });
+
+    it('should define TopoFilterService', function () {
+        expect(fltr).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(fltr, [
+            'initFilter',
+            'clickAction', 'selected', 'inLayer'
+        ])).toBeTruthy();
+    });
+
+    it('should report the selected button', function () {
+        fltr.initFilter(api);
+        expect(fltr.selected()).toEqual('all');
+    });
+
+    // TODO: test the on click functions
+
+});
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoForce-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoForce-spec.js
new file mode 100644
index 00000000..edb1cc56
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoForce-spec.js
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Force Service - Unit Tests
+ */
+describe('factory: view/topo/topoForce.js', function() {
+    var $log, fs, tfs, bns;
+
+    beforeEach(module('ovTopo', 'onosUtil', 'onosLayer', 'ngRoute', 'onosNav',
+        'onosWidget'));
+
+    beforeEach(inject(function (_$log_, FnService,
+                                TopoForceService, ButtonService) {
+        $log = _$log_;
+        fs = FnService;
+        tfs = TopoForceService;
+        bns = ButtonService;
+    }));
+
+    it('should define TopoForceService', function () {
+        expect(tfs).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(tfs, [
+            'initForce', 'newDim', 'destroyForce',
+
+            'updateDeviceColors', 'toggleHosts',
+            'togglePorts', 'toggleOffline',
+            'cycleDeviceLabels', 'unpin', 'showMastership', 'showBadLinks',
+
+            'addDevice', 'updateDevice', 'removeDevice',
+            'addHost', 'updateHost', 'removeHost',
+            'addLink', 'updateLink', 'removeLink'
+        ])).toBeTruthy();
+    });
+
+    // TODO: more tests...
+});
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoInst-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoInst-spec.js
new file mode 100644
index 00000000..a6a12651
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoInst-spec.js
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Instance Service - Unit Tests
+ */
+describe('factory: view/topo/topoInst.js', function() {
+    var $log, fs, tis;
+
+    beforeEach(module('ovTopo', 'onosUtil', 'onosLayer'));
+
+    beforeEach(inject(function (_$log_, FnService, TopoInstService) {
+        $log = _$log_;
+        fs = FnService;
+        tis = TopoInstService;
+    }));
+
+    it('should define TopoInstService', function () {
+        expect(tis).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(tis, [
+            'initInst', 'destroyInst',
+            'addInstance', 'updateInstance', 'removeInstance',
+            'cancelAffinity',
+            'isVisible', 'show', 'hide', 'toggle', 'showMaster'
+        ])).toBeTruthy();
+    });
+
+    // TODO: more tests...
+});
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoModel-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoModel-spec.js
new file mode 100644
index 00000000..725bd475
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoModel-spec.js
@@ -0,0 +1,414 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Model Service - Unit Tests
+ */
+describe('factory: view/topo/topoModel.js', function() {
+    var $log, fs, rnd, tms;
+
+    // stop random numbers from being quite so random
+    var mockRandom = {
+        // mock spread returns s + 1
+        spread: function (s) {
+            return s + 1;
+        },
+        // mock random dimension returns d / 2 - 1
+        randDim: function (d) {
+            return d/2 - 1;
+        },
+        mock: 'yup'
+    };
+
+    // to mock out the [lng,lat] <=> [x,y] transformations, we will
+    // add/subtract 2000, 3000 respectively:
+    //   lng:2005 === x:5,   lat:3004 === y:4
+
+    var mockProjection = function (lnglat) {
+        return [lnglat[0] - 2000, lnglat[1] - 3000];
+    };
+
+    mockProjection.invert = function (xy) {
+        return [xy[0] + 2000, xy[1] + 3000];
+    };
+
+    // our test devices and hosts:
+    var dev1 = {
+            'class': 'device',
+            id: 'dev1',
+            x: 17,
+            y: 27,
+            online: true
+        },
+        dev2 = {
+            'class': 'device',
+            id: 'dev2',
+            x: 18,
+            y: 28,
+            online: true
+        },
+        host1 = {
+            'class': 'host',
+            id: 'host1',
+            x: 23,
+            y: 33,
+            cp: {
+                device: 'dev1',
+                port: 7
+            },
+            ingress: 'dev1/7-host1'
+        },
+        host2 = {
+            'class': 'host',
+            id: 'host2',
+            x: 24,
+            y: 34,
+            cp: {
+                device: 'dev0',
+                port: 0
+            },
+            ingress: 'dev0/0-host2'
+        };
+
+
+    // our test api
+    var api = {
+        projection: function () { return mockProjection; },
+        network: {
+            nodes: [dev1, dev2, host1, host2],
+            links: [],
+            lookup: {dev1: dev1, dev2: dev2, host1: host1, host2: host2},
+            revLinkToKey: {}
+        },
+        restyleLinkElement: function () {},
+        removeLinkElement: function () {}
+    };
+
+    // our test dimensions and well known locations..
+    var dim = [20, 40],
+        randLoc = [9, 19],          // random location using randDim(): d/2-1
+        randHostLoc = [40, 50],     // host "near" random location
+                                    //  given that 'nearDist' = 15
+                                    //  and spread(15) = 16
+                                    //  9 + 15 + 16 = 40; 19 + 15 + 16 = 50
+        nearDev1 = [48,58],         // [17+15+16, 27+15+16]
+        dev1Loc = [17,27],
+        dev2Loc = [18,28],
+        host1Loc = [23,33],
+        host2Loc = [24,34];
+
+    // implement some custom matchers...
+    beforeEach(function () {
+        jasmine.addMatchers({
+            toBePositionedAt: function () {
+                return {
+                    compare: function (actual, xy) {
+                        var result = {},
+                            actCoord = [actual.x, actual.y];
+
+                        result.pass = (actual.x === xy[0]) && (actual.y === xy[1]);
+
+                        if (result.pass) {
+                            // for negation with ".not"
+                            result.message = 'Expected [' + actCoord +
+                            '] NOT to be positioned at [' + xy + ']';
+                        } else {
+                            result.message = 'Expected [' + actCoord +
+                            '] to be positioned at [' + xy + ']';
+                        }
+                        return result;
+                    }
+                }
+            },
+            toHaveEndPoints: function () {
+                return {
+                    compare: function (actual, xy1, xy2) {
+                        var result = {};
+
+                        result.pass = (actual.source.x === xy1[0]) &&
+                                      (actual.source.y === xy1[1]) &&
+                                      (actual.target.x === xy2[0]) &&
+                                      (actual.target.y === xy2[1]);
+
+                        if (result.pass) {
+                            // for negation with ".not"
+                            result.message = 'Expected ' + actual +
+                            ' NOT to have endpoints [' + xy1 + ']-[' + xy2 + ']';
+                        } else {
+                            result.message = 'Expected ' + actual +
+                            ' to have endpoints [' + xy1 + ']-[' + xy2 + ']';
+                        }
+                        return result;
+                    }
+                }
+            },
+            toBeFixed: function () {
+                return {
+                    compare: function (actual) {
+                        var result = {
+                            pass: actual.fixed
+                        };
+                        if (result.pass) {
+                            result.message = 'Expected ' + actual +
+                            ' NOT to be fixed!';
+                        } else {
+                            result.message = 'Expected ' + actual +
+                            ' to be fixed!';
+                        }
+                        return result;
+                    }
+                }
+            }
+        });
+    });
+
+    beforeEach(module('ovTopo', 'onosUtil'));
+
+    beforeEach(function () {
+        module(function ($provide) {
+            $provide.value('RandomService', mockRandom);
+        });
+    });
+
+    beforeEach(inject(function (_$log_, FnService, RandomService, TopoModelService) {
+        $log = _$log_;
+        fs = FnService;
+        rnd = RandomService;
+        tms = TopoModelService;
+        tms.initModel(api, dim);
+    }));
+
+
+    it('should install the mock random service', function () {
+        expect(rnd.mock).toBe('yup');
+        expect(rnd.spread(4)).toBe(5);
+        expect(rnd.randDim(8)).toBe(3);
+    });
+
+    it('should install the mock projection', function () {
+        expect(tms.coordFromLngLat({lng: 2005, lat: 3004})).toEqual([5,4]);
+        expect(tms.lngLatFromCoord([5,4])).toEqual([2005,3004]);
+    });
+
+    it('should define TopoModelService', function () {
+        expect(tms).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(tms, [
+            'initModel', 'newDim', 'destroyModel',
+            'positionNode', 'createDeviceNode', 'createHostNode',
+            'createHostLink', 'createLink',
+            'coordFromLngLat', 'lngLatFromCoord',
+            'findLink', 'findLinkById', 'findDevices',
+            'findAttachedHosts', 'findAttachedLinks', 'findBadLinks'
+        ])).toBeTruthy();
+    });
+
+    // === unit tests for positionNode()
+
+    it('should position a node using meta x/y', function () {
+        var node = {
+            metaUi: { x:37, y:48 }
+        };
+        tms.positionNode(node);
+        expect(node).toBePositionedAt([37,48]);
+        expect(node).toBeFixed();
+    });
+
+    it('should position a node by translating lng/lat', function () {
+        var node = {
+            location: {
+                type: 'latlng',
+                lng: 2008,
+                lat: 3009
+            }
+        };
+        tms.positionNode(node);
+        expect(node).toBePositionedAt([8,9]);
+        expect(node).toBeFixed();
+    });
+
+    it('should position a device with no location randomly', function () {
+        var node = { 'class': 'device' };
+        tms.positionNode(node);
+        expect(node).toBePositionedAt(randLoc);
+        expect(node).not.toBeFixed();
+    });
+
+    it('should position a device randomly even if x/y set', function () {
+        var node = { 'class': 'device', x: 1, y: 2 };
+        tms.positionNode(node);
+        expect(node).toBePositionedAt(randLoc);
+        expect(node).not.toBeFixed();
+    });
+
+    it('should NOT reposition a device randomly on update', function () {
+        var node = { 'class': 'device', x: 1, y: 2 };
+        tms.positionNode(node, true);
+        expect(node).toBePositionedAt([1,2]);
+        expect(node).not.toBeFixed();
+    });
+
+    it('should position a host close to its device', function () {
+        var node = { 'class': 'host', cp: { device: 'dev1' } };
+        tms.positionNode(node);
+
+        // note: nearDist is 15; spread(15) adds 16; dev1 at [17,27]
+
+        expect(node).toBePositionedAt(nearDev1);
+        expect(node).not.toBeFixed();
+    });
+
+    it('should randomize host with no assoc device', function () {
+        var node = { 'class': 'host', cp: { device: 'dev0' } };
+        tms.positionNode(node);
+
+        // note: no device gives 'rand loc' [9,19]
+        //       nearDist is 15; spread(15) adds 16
+
+        expect(node).toBePositionedAt(randHostLoc);
+        expect(node).not.toBeFixed();
+    });
+
+    // === unit tests for createDeviceNode()
+
+    it('should create a basic device node', function () {
+        var node = tms.createDeviceNode({ id: 'foo' });
+        expect(node).toBePositionedAt(randLoc);
+        expect(node).not.toBeFixed();
+        expect(node.class).toEqual('device');
+        expect(node.svgClass).toEqual('node device');
+        expect(node.id).toEqual('foo');
+    });
+
+    it('should create device node with type', function () {
+        var node = tms.createDeviceNode({ id: 'foo', type: 'cool' });
+        expect(node).toBePositionedAt(randLoc);
+        expect(node).not.toBeFixed();
+        expect(node.class).toEqual('device');
+        expect(node.svgClass).toEqual('node device cool');
+        expect(node.id).toEqual('foo');
+    });
+
+    it('should create online device node with type', function () {
+        var node = tms.createDeviceNode({ id: 'foo', type: 'cool', online: true });
+        expect(node).toBePositionedAt(randLoc);
+        expect(node).not.toBeFixed();
+        expect(node.class).toEqual('device');
+        expect(node.svgClass).toEqual('node device cool online');
+        expect(node.id).toEqual('foo');
+    });
+
+    it('should create online device node with type and lng/lat', function () {
+        var node = tms.createDeviceNode({
+            id: 'foo',
+            type: 'yowser',
+            online: true,
+            location: {
+                type: 'latlng',
+                lng: 2048,
+                lat: 3096
+            }
+        });
+        expect(node).toBePositionedAt([48,96]);
+        expect(node).toBeFixed();
+        expect(node.class).toEqual('device');
+        expect(node.svgClass).toEqual('node device yowser online');
+        expect(node.id).toEqual('foo');
+    });
+
+    // === unit tests for createHostNode()
+
+    it('should create a basic host node', function () {
+        var node = tms.createHostNode({ id: 'bar', cp: { device: 'dev0' } });
+        expect(node).toBePositionedAt(randHostLoc);
+        expect(node).not.toBeFixed();
+        expect(node.class).toEqual('host');
+        expect(node.svgClass).toEqual('node host endstation');
+        expect(node.id).toEqual('bar');
+    });
+
+    it('should create a host with type', function () {
+        var node = tms.createHostNode({
+            id: 'bar',
+            type: 'classic',
+            cp: { device: 'dev1' }
+        });
+        expect(node).toBePositionedAt(nearDev1);
+        expect(node).not.toBeFixed();
+        expect(node.class).toEqual('host');
+        expect(node.svgClass).toEqual('node host classic');
+        expect(node.id).toEqual('bar');
+    });
+
+    // === unit tests for createHostLink()
+
+    it('should create a basic host link', function () {
+        var link = tms.createHostLink(host1);
+        expect(link.source).toEqual(host1);
+        expect(link.target).toEqual(dev1);
+        expect(link).toHaveEndPoints(host1Loc, dev1Loc);
+        expect(link.key).toEqual('dev1/7-host1');
+        expect(link.class).toEqual('link');
+        expect(link.type()).toEqual('hostLink');
+        expect(link.linkWidth()).toEqual(1);
+        expect(link.online()).toEqual(true);
+    });
+
+    it('should return null for failed endpoint lookup', function () {
+        spyOn($log, 'error');
+        var link = tms.createHostLink(host2);
+        expect(link).toBeNull();
+        expect($log.error).toHaveBeenCalledWith(
+            'Node(s) not on map for link:\n[dst] "dev0" missing'
+        );
+    });
+
+    // === unit tests for createLink()
+
+    it('should return null for missing endpoints', function () {
+        spyOn($log, 'error');
+        var link = tms.createLink({src: 'dev0', dst: 'dev00'});
+        expect(link).toBeNull();
+        expect($log.error).toHaveBeenCalledWith(
+            'Node(s) not on map for link:\n[src] "dev0" missing\n[dst] "dev00" missing'
+        );
+    });
+
+    it('should create a basic link', function () {
+        var linkData = {
+                src: 'dev1',
+                dst: 'dev2',
+                id: 'baz',
+                type: 'zoo',
+                online: true,
+                linkWidth: 1.5
+            },
+            link = tms.createLink(linkData);
+        expect(link.source).toEqual(dev1);
+        expect(link.target).toEqual(dev2);
+        expect(link).toHaveEndPoints(dev1Loc, dev2Loc);
+        expect(link.key).toEqual('baz');
+        expect(link.class).toEqual('link');
+        expect(link.fromSource).toBe(linkData);
+        expect(link.type()).toEqual('zoo');
+        expect(link.online()).toEqual(true);
+        expect(link.linkWidth()).toEqual(1.5);
+    });
+
+    // TODO: more unit tests for additional functions....
+});
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoOblique-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoOblique-spec.js
new file mode 100644
index 00000000..2b563295
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoOblique-spec.js
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Oblique View Service - Unit Tests
+ */
+describe('factory: view/topo/topoOblique.js', function() {
+    var $log, fs, tos, flash;
+
+    beforeEach(module('ovTopo', 'onosUtil', 'onosLayer'));
+
+    beforeEach(inject(function (_$log_, FnService,
+                                TopoObliqueService, FlashService) {
+        $log = _$log_;
+        fs = FnService;
+        tos = TopoObliqueService;
+        flash = FlashService;
+    }));
+
+    it('should define TopoTrafficService', function () {
+        expect(tos).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(tos, [
+            'initOblique', 'destroyOblique', 'isOblique', 'toggleOblique'
+        ])).toBeTruthy();
+    });
+
+    // TODO: more tests...
+});
+
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoPanel-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoPanel-spec.js
new file mode 100644
index 00000000..21513d1b
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoPanel-spec.js
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Panel Service - Unit Tests
+ */
+describe('factory: view/topo/topoPanel.js', function() {
+    var $log, fs, tps, bns, ps, panelLayer;
+
+    var mockWindow = {
+        innerWidth: 300,
+        innerHeight: 100,
+        navigator: {
+            userAgent: 'defaultUA'
+        },
+        on: function () {},
+        addEventListener: function () {}
+    };
+
+    beforeEach(module('ovTopo', 'onosUtil', 'onosLayer', 'ngRoute', 'onosNav',
+        'onosWidget'));
+
+    beforeEach(function () {
+        module(function ($provide) {
+            $provide.value('$window', mockWindow);
+        });
+    });
+
+    beforeEach(inject(function (_$log_, FnService,
+                                TopoPanelService, ButtonService, PanelService) {
+        $log = _$log_;
+        fs = FnService;
+        tps = TopoPanelService;
+        bns = ButtonService;
+        ps = PanelService;
+        panelLayer = d3.select('body').append('div').attr('id', 'floatpanels');
+    }));
+
+    afterEach(function () {
+        panelLayer.remove();
+    });
+
+    it('should define TopoPanelService', function () {
+        expect(tps).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(tps, [
+            'initPanels',
+            'destroyPanels',
+            'createTopoPanel',
+
+            'showSummary',
+            'toggleSummary',
+
+            'toggleUseDetailsFlag',
+            'displaySingle',
+            'displayMulti',
+            'displayLink',
+            'displayNothing',
+            'displaySomething',
+            'addAction',
+
+            'hideSummaryPanel',
+
+            'detailVisible',
+            'summaryVisible'
+        ])).toBeTruthy();
+    });
+
+    // === topoPanel api ------------------
+
+    it('should define topoPanel api functions', function () {
+        var panel = tps.createTopoPanel('foo');
+        expect(fs.areFunctions(panel, [
+            'panel', 'setup', 'destroy',
+            'appendHeader', 'appendBody', 'appendFooter',
+            'adjustHeight'
+        ])).toBeTruthy();
+        panel.destroy();
+    });
+
+    it('should allow you to get panel', function () {
+        var panel = tps.createTopoPanel('foo');
+        expect(panel.panel()).toBeTruthy();
+        panel.destroy();
+    });
+
+    it('should set up panel', function () {
+        var p = tps.createTopoPanel('foo'),
+            h, b, f;
+        p.setup();
+        expect(p.panel().el().selectAll('div').size()).toBe(3);
+
+        h = p.panel().el().select('.header');
+        expect(h.empty()).toBe(false);
+        b = p.panel().el().select('.body');
+        expect(b.empty()).toBe(false);
+        f = p.panel().el().select('.footer');
+        expect(f.empty()).toBe(false);
+        p.destroy();
+    });
+
+    it('should destroy panel', function () {
+        spyOn(ps, 'destroyPanel').and.callThrough();
+        var p = tps.createTopoPanel('foo');
+        p.destroy();
+        expect(ps.destroyPanel).toHaveBeenCalledWith('foo');
+    });
+
+    it('should append to panel', function () {
+        var p = tps.createTopoPanel('foo');
+        p.setup();
+        p.appendHeader('div').attr('id', 'header-div');
+        expect(p.panel().el().select('#header-div').empty()).toBe(false);
+        p.appendBody('p').attr('id', 'body-paragraph');
+        expect(p.panel().el().select('#body-paragraph').empty()).toBe(false);
+        p.appendFooter('svg').attr('id', 'footer-svg');
+        expect(p.panel().el().select('#footer-svg').empty()).toBe(false);
+        p.destroy();
+    });
+
+    it('should warn if fromTop not given, adjustHeight', function () {
+        spyOn($log, 'warn');
+        var p = tps.createTopoPanel('foo');
+        p.adjustHeight();
+        expect($log.warn).toHaveBeenCalledWith(
+            'adjustHeight: height from top of page not given'
+        );
+        p.destroy();
+    });
+
+    it('should warn if panel is not setup/defined, adjustHeight', function () {
+        spyOn($log, 'warn');
+        var p = tps.createTopoPanel('foo');
+        p.adjustHeight(50);
+        expect($log.warn).toHaveBeenCalledWith(
+            'adjustHeight: panel contents are not defined'
+        );
+        p.destroy();
+    });
+
+    // TODO: test adjustHeight height adjustment
+
+    // TODO: more tests...
+});
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoSelect-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoSelect-spec.js
new file mode 100644
index 00000000..c8c051c9
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoSelect-spec.js
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Selection Service - Unit Tests
+ */
+describe('factory: view/topo/topoSelect.js', function() {
+    var $log, fs, tss, bns;
+
+    beforeEach(module('ovTopo', 'onosUtil', 'onosLayer', 'ngRoute', 'onosNav',
+        'onosWidget'));
+
+    beforeEach(inject(function (_$log_, FnService,
+                                TopoSelectService, ButtonService) {
+        $log = _$log_;
+        fs = FnService;
+        tss = TopoSelectService;
+        bns = ButtonService;
+    }));
+
+    it('should define TopoSelectService', function () {
+        expect(tss).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(tss, [
+            'initSelect', 'destroySelect',
+            'showDetails',
+            'nodeMouseOver', 'nodeMouseOut', 'selectObject', 'deselectObject',
+            'deselectAll',
+            'hovered', 'selectOrder',
+            'validateSelectionContext',
+            'clickConsumed'
+        ])).toBeTruthy();
+    });
+
+    // TODO: more tests...
+});
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoToolbar-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoToolbar-spec.js
new file mode 100644
index 00000000..eedc476f
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoToolbar-spec.js
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Toolbar Service - Unit Tests
+ */
+describe('factory: view/topo/topoToolbar.js', function() {
+    var $log, fs, ttbs, prefs, ps,
+        d3Elem;
+
+    beforeEach(module('ovTopo', 'onosUtil', 'onosLayer', 'ngRoute', 'onosNav',
+        'onosWidget'));
+
+    beforeEach(inject(function (_$log_, FnService,
+                                TopoToolbarService, PanelService, PrefsService) {
+        $log = _$log_;
+        fs = FnService;
+        ttbs = TopoToolbarService;
+        prefs = PrefsService;
+        ps = PanelService;
+        d3Elem = d3.select('body').append('div').attr('id', 'floatpanels');
+        ps.init();
+    }));
+
+    it('should define TopoToolbarService', function () {
+        expect(ttbs).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(ttbs, [
+            'init', 'createToolbar', 'destroyToolbar',
+            'keyListener', 'toggleToolbar'
+        ])).toBeTruthy();
+    });
+
+    // NOTE: topoToolbar relies too much on topo's closure variables
+    // to adequately test it
+
+});
\ No newline at end of file
diff --git a/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoTraffic-spec.js b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoTraffic-spec.js
new file mode 100644
index 00000000..a04c2021
--- /dev/null
+++ b/framework/src/onos/web/gui/src/main/webapp/tests/app/view/topo/topoTraffic-spec.js
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ ONOS GUI -- Topo View -- Topo Traffic Service - Unit Tests
+ */
+describe('factory: view/topo/topoTraffic.js', function() {
+    var $log, fs, tts;
+
+    beforeEach(module('ovTopo', 'onosUtil', 'onosLayer', 'onosNav', 'ngRoute'));
+
+    beforeEach(inject(function (_$log_, FnService, TopoTrafficService) {
+        $log = _$log_;
+        fs = FnService;
+        tts = TopoTrafficService;
+    }));
+
+    it('should define TopoTrafficService', function () {
+        expect(tts).toBeDefined();
+    });
+
+    it('should define api functions', function () {
+        expect(fs.areFunctions(tts, [
+            'initTraffic', 'destroyTraffic', 'showTraffic',
+            'cancelTraffic', 'requestTrafficForMode',
+            'showRelatedIntentsAction', 'addHostIntentAction',
+            'addMultiSourceIntentAction', 'showDeviceLinkFlowsAction',
+            'showNextIntentAction', 'showPrevIntentAction',
+            'showSelectedIntentTrafficAction', 'showAllTrafficAction'
+        ])).toBeTruthy();
+    });
+
+    // TODO: more tests...
+});