@spinnaker/google 0.0.0-main-2

package/src/loadBalancer/details/deleteModal/deleteModal.controller.ts

@@ -0,0 +1,105 @@
+import type { IController } from 'angular';
+import { module } from 'angular';
+import type { IModalInstanceService } from 'angular-ui-bootstrap';
+import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
+
+import type { Application, ILoadBalancerDeleteCommand } from '@spinnaker/core';
+import { LoadBalancerWriter, TaskMonitor } from '@spinnaker/core';
+
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE } from '../../configure/http/httpLoadBalancer.write.service';
+import type { GceHttpLoadBalancerUtils } from '../../httpLoadBalancerUtils.service';
+import { GCE_HTTP_LOAD_BALANCER_UTILS } from '../../httpLoadBalancerUtils.service';
+
+class Verification {
+  public verified = false;
+}
+
+class Params {
+  public deleteHealthChecks = false;
+}
+
+interface IGoogleLoadBalancerDeleteOperation extends ILoadBalancerDeleteCommand {
+  region: string;
+  accountName: string;
+  deleteHealthChecks: boolean;
+  loadBalancerType: string;
+}
+
+class DeleteLoadBalancerModalController implements IController {
+  public verification: Verification = new Verification();
+  public params: Params = new Params();
+  public taskMonitor: any;
+
+  public static $inject = [
+    'application',
+    'gceHttpLoadBalancerUtils',
+    'gceHttpLoadBalancerWriter',
+    'loadBalancer',
+    '$uibModalInstance',
+  ];
+  constructor(
+    private application: Application,
+    private gceHttpLoadBalancerUtils: GceHttpLoadBalancerUtils,
+    private gceHttpLoadBalancerWriter: any,
+    private loadBalancer: any,
+    private $uibModalInstance: IModalInstanceService,
+  ) {}
+
+  public $onInit(): void {
+    const taskMonitorConfig = {
+      application: this.application,
+      title: 'Deleting ' + this.loadBalancer.name,
+      modalInstance: this.$uibModalInstance,
+    };
+
+    this.taskMonitor = new TaskMonitor(taskMonitorConfig);
+  }
+
+  public isValid(): boolean {
+    return this.verification.verified;
+  }
+
+  public submit(): void {
+    this.taskMonitor.submit(this.getSubmitMethod());
+  }
+
+  public cancel(): void {
+    this.$uibModalInstance.dismiss();
+  }
+
+  public hasHealthChecks(): boolean {
+    if (this.gceHttpLoadBalancerUtils.isHttpLoadBalancer(this.loadBalancer)) {
+      return true;
+    } else {
+      return !!this.loadBalancer.healthCheck;
+    }
+  }
+
+  private getSubmitMethod(): () => PromiseLike<any> {
+    if (this.gceHttpLoadBalancerUtils.isHttpLoadBalancer(this.loadBalancer)) {
+      return () => {
+        return this.gceHttpLoadBalancerWriter.deleteLoadBalancers(this.loadBalancer, this.application, this.params);
+      };
+    } else {
+      return () => {
+        const command: IGoogleLoadBalancerDeleteOperation = {
+          cloudProvider: 'gce',
+          loadBalancerName: this.loadBalancer.name,
+          accountName: this.loadBalancer.account,
+          credentials: this.loadBalancer.account,
+          region: this.loadBalancer.region,
+          loadBalancerType: this.loadBalancer.loadBalancerType || 'NETWORK',
+          deleteHealthChecks: this.params.deleteHealthChecks,
+        };
+        return LoadBalancerWriter.deleteLoadBalancer(command, this.application);
+      };
+    }
+  }
+}
+
+export const DELETE_MODAL_CONTROLLER = 'spinnaker.gce.loadBalancer.deleteModal.controller';
+module(DELETE_MODAL_CONTROLLER, [
+  ANGULAR_UI_BOOTSTRAP as any,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE,
+  GCE_HTTP_LOAD_BALANCER_UTILS,
+]).controller('gceLoadBalancerDeleteModalCtrl', DeleteLoadBalancerModalController);

package/src/loadBalancer/details/deleteModal/deleteModal.html

@@ -0,0 +1,31 @@
+<div modal-page class="confirmation-modal">
+  <task-monitor monitor="ctrl.taskMonitor"></task-monitor>
+  <form role="form" ng-if="!ctrl.submitting">
+    <modal-close dismiss="$dismiss()"></modal-close>
+    <div class="modal-header">
+      <h4 class="modal-title">Really delete {{ctrl.loadBalancer.name}}?</h4>
+    </div>
+    <div class="modal-body confirmation-modal" ng-if="ctrl.hasHealthChecks()">
+      <div class="row">
+        <div class="col-md-offset-2 col-md-8" style="padding-left: 2px">
+          <div class="checkbox">
+            <label> <input ng-model="ctrl.params.deleteHealthChecks" type="checkbox" />Delete health checks? </label>
+            <help-field
+              expand="true"
+              content="If the health checks associated with this load balancer
+                                 are being used by other resources, they will not be deleted,
+                                 whether this option is selected or not."
+            ></help-field>
+          </div>
+        </div>
+      </div>
+    </div>
+    <gce-footer
+      action="ctrl.submit()"
+      cancel="ctrl.cancel()"
+      is-valid="ctrl.isValid()"
+      account="ctrl.loadBalancer.account"
+      verification="ctrl.verification"
+    ></gce-footer>
+  </form>
+</div>

package/src/loadBalancer/details/healthCheck/healthCheck.component.html

@@ -0,0 +1,14 @@
+<dt>Name</dt>
+<dd>{{ $ctrl.healthCheck.name }}</dd>
+<dt ng-if="$ctrl.healthCheck.healthCheckType">Type</dt>
+<dd ng-if="$ctrl.healthCheck.healthCheckType">{{ $ctrl.healthCheck.healthCheckType }}</dd>
+<dt ng-if="$ctrl.healthCheck.target">Target</dt>
+<dd ng-if="$ctrl.healthCheck.target">{{ $ctrl.healthCheck.target }}</dd>
+<dt>Timeout</dt>
+<dd>{{ $ctrl.healthCheck.timeout || $ctrl.healthCheck.timeoutSec }} seconds</dd>
+<dt>Interval</dt>
+<dd>{{ $ctrl.healthCheck.interval || $ctrl.healthCheck.checkIntervalSec }} seconds</dd>
+<dt>Healthy Threshold</dt>
+<dd>{{ $ctrl.healthCheck.healthyThreshold }}</dd>
+<dt>Unhealthy Threshold</dt>
+<dd>{{ $ctrl.healthCheck.unhealthyThreshold }}</dd>

package/src/loadBalancer/details/healthCheck/healthCheck.component.js

@@ -0,0 +1,13 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const GOOGLE_LOADBALANCER_DETAILS_HEALTHCHECK_HEALTHCHECK_COMPONENT =
+  'spinnaker.deck.gce.loadBalancer.details.healthCheck.component';
+export const name = GOOGLE_LOADBALANCER_DETAILS_HEALTHCHECK_HEALTHCHECK_COMPONENT; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_DETAILS_HEALTHCHECK_HEALTHCHECK_COMPONENT, []).component('gceHealthCheck', {
+  bindings: {
+    healthCheck: '=',
+  },
+  templateUrl: require('./healthCheck.component.html'),
+});

package/src/loadBalancer/details/hostAndPathRules/hostAndPathRules.controller.js

@@ -0,0 +1,23 @@
+import { module } from 'angular';
+
+import { GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE } from './hostAndPathRules.service';
+
+('use strict');
+
+export const GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER =
+  'spinnaker.deck.gce.loadBalancer.hostAndPathRules.controller';
+export const name = GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER, [
+  GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE,
+]).controller('gceHostAndPathRulesCtrl', [
+  'hostRules',
+  'defaultService',
+  'loadBalancerName',
+  '$uibModalInstance',
+  'hostAndPathRulesService',
+  function (hostRules, defaultService, loadBalancerName, $uibModalInstance, hostAndPathRulesService) {
+    this.table = hostAndPathRulesService.buildTable(hostRules, defaultService);
+    this.loadBalancerName = loadBalancerName;
+    this.close = $uibModalInstance.dismiss;
+  },
+]);

package/src/loadBalancer/details/hostAndPathRules/hostAndPathRules.modal.html

@@ -0,0 +1,40 @@
+<div modal-page class="form-inline">
+  <modal-close dismiss="$dismiss()"></modal-close>
+  <div class="modal-header">
+    <h4 class="modal-title">Host And Path Rules for {{ ctrl.loadBalancerName }}</h4>
+  </div>
+  <div class="modal-body clearfix">
+    <div class="section-body">
+      <div class="well well-sm">
+        <div class="row">
+          <div class="col-md-12 content-fields">
+            <input placeholder="Filter" ng-model="searchText" class="form-control input-sm" />
+          </div>
+        </div>
+        <div class="row">
+          <div class="col-md-12">
+            <table class="table table-condensed">
+              <thead>
+                <tr>
+                  <th>Host</th>
+                  <th>Path</th>
+                  <th>Backend Service</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr ng-repeat="row in ctrl.table | filter:searchText">
+                  <td>{{ row.hostPattern }}</td>
+                  <td>{{ row.path }}</td>
+                  <td>{{ row.backend }}</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+  <div class="modal-footer">
+    <button class="btn btn-default" ng-click="ctrl.close()">Close</button>
+  </div>
+</div>

package/src/loadBalancer/details/hostAndPathRules/hostAndPathRules.service.js

@@ -0,0 +1,41 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE =
+  'spinnaker.deck.gce.loadBalancer.hostAndPathRules.service';
+export const name = GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE, []).factory(
+  'hostAndPathRulesService',
+  function () {
+    function buildTable(hostRules, defaultService) {
+      const defaultRow = buildRow('Any unmatched (default)', 'Any unmatched (default)', defaultService.name);
+      if (hostRules.length === 0) {
+        return [defaultRow];
+      }
+
+      return hostRules.reduce(
+        (rows, hostRule) => {
+          const [hostPattern] = hostRule.hostPatterns;
+          const { defaultService, pathRules } = hostRule.pathMatcher;
+
+          rows.push(buildRow(hostPattern, '/*', defaultService.name));
+
+          return rows.concat(
+            pathRules.reduce((rows, pathRule) => {
+              const { backendService, paths } = pathRule;
+              return rows.concat(paths.map((path) => buildRow(hostPattern, path, backendService.name)));
+            }, []),
+          );
+        },
+        [defaultRow],
+      );
+    }
+
+    function buildRow(hostPattern, path, backend) {
+      return { hostPattern, path, backend };
+    }
+
+    return { buildTable };
+  },
+);

package/src/loadBalancer/details/hostAndPathRules/hostAndPathRulesButton.component.js

@@ -0,0 +1,39 @@
+import { module } from 'angular';
+import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
+
+import { GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER } from './hostAndPathRules.controller';
+
+('use strict');
+
+export const GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT =
+  'spinnaker.deck.gce.loadBalancer.hostAndPathRulesButton.component';
+export const name = GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT, [
+  ANGULAR_UI_BOOTSTRAP,
+  GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER,
+]).component('gceHostAndPathRulesButton', {
+  bindings: {
+    hostRules: '=',
+    defaultService: '=',
+    loadBalancerName: '=',
+  },
+  template: '<a href ng-click="$ctrl.viewHostAndPathRules()">View Host and Path Rules</a>',
+  controller: [
+    '$uibModal',
+    function ($uibModal) {
+      this.viewHostAndPathRules = () => {
+        $uibModal.open({
+          templateUrl: require('./hostAndPathRules.modal.html'),
+          controller: 'gceHostAndPathRulesCtrl',
+          controllerAs: 'ctrl',
+          size: 'lg',
+          resolve: {
+            hostRules: () => this.hostRules,
+            defaultService: () => this.defaultService,
+            loadBalancerName: () => this.loadBalancerName,
+          },
+        });
+      };
+    },
+  ],
+});

package/src/loadBalancer/details/loadBalancerDetail.controller.js

@@ -0,0 +1,260 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import * as angular from 'angular';
+import _ from 'lodash';
+
+import { AccountService, LOAD_BALANCER_READ_SERVICE } from '@spinnaker/core';
+
+import { GCE_BACKEND_SERVICE_DETAILS_COMPONENT } from './backendService/backendService.component';
+import { SESSION_AFFINITY_FILTER } from './backendService/sessionAffinity.filter';
+import { GOOGLE_COMMON_XPNNAMING_GCE_SERVICE } from '../../common/xpnNaming.gce.service';
+import { GCE_LOAD_BALANCER_TYPE_TO_WIZARD_CONSTANT } from '../configure/choice/loadBalancerTypeToWizardMap.constant';
+import { DELETE_MODAL_CONTROLLER } from './deleteModal/deleteModal.controller';
+import { GOOGLE_LOADBALANCER_DETAILS_HEALTHCHECK_HEALTHCHECK_COMPONENT } from './healthCheck/healthCheck.component';
+import { GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT } from './hostAndPathRules/hostAndPathRulesButton.component';
+import { GCE_HTTP_LOAD_BALANCER_UTILS } from '../httpLoadBalancerUtils.service';
+import { GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERTYPE_LOADBALANCERTYPE_COMPONENT } from './loadBalancerType/loadBalancerType.component';
+
+export const GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERDETAIL_CONTROLLER =
+  'spinnaker.loadBalancer.gce.details.controller';
+export const name = GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERDETAIL_CONTROLLER; // for backwards compatibility
+angular
+  .module(GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERDETAIL_CONTROLLER, [
+    UIROUTER_ANGULARJS,
+    LOAD_BALANCER_READ_SERVICE,
+    GOOGLE_COMMON_XPNNAMING_GCE_SERVICE,
+    GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT,
+    GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERTYPE_LOADBALANCERTYPE_COMPONENT,
+    GCE_HTTP_LOAD_BALANCER_UTILS,
+    GOOGLE_LOADBALANCER_DETAILS_HEALTHCHECK_HEALTHCHECK_COMPONENT,
+    GCE_BACKEND_SERVICE_DETAILS_COMPONENT,
+    DELETE_MODAL_CONTROLLER,
+    SESSION_AFFINITY_FILTER,
+    GCE_LOAD_BALANCER_TYPE_TO_WIZARD_CONSTANT,
+  ])
+  .controller('gceLoadBalancerDetailsCtrl', [
+    '$scope',
+    '$state',
+    '$uibModal',
+    'loadBalancer',
+    'app',
+    'gceHttpLoadBalancerUtils',
+    'loadBalancerReader',
+    '$q',
+    'loadBalancerTypeToWizardMap',
+    'gceXpnNamingService',
+    function (
+      $scope,
+      $state,
+      $uibModal,
+      loadBalancer,
+      app,
+      gceHttpLoadBalancerUtils,
+      loadBalancerReader,
+      $q,
+      loadBalancerTypeToWizardMap,
+      gceXpnNamingService,
+    ) {
+      const application = (this.application = app);
+
+      $scope.state = {
+        loading: true,
+      };
+
+      function extractLoadBalancer() {
+        $scope.loadBalancer = application.loadBalancers.data.filter(function (test) {
+          const testVpc = test.vpcId || null;
+          return (
+            test.name === loadBalancer.name &&
+            (test.region === loadBalancer.region || test.region === 'global') &&
+            test.account === loadBalancer.accountId &&
+            testVpc === loadBalancer.vpcId
+          );
+        })[0];
+
+        if ($scope.loadBalancer) {
+          return createDetailsLoader().then(function (details) {
+            $scope.state.loading = false;
+            const filtered = details.filter(function (test) {
+              return test.vpcid === loadBalancer.vpcId || (!test.vpcid && !loadBalancer.vpcId);
+            });
+            if (filtered.length) {
+              $scope.loadBalancer.elb = filtered[0];
+              $scope.loadBalancer.account = loadBalancer.accountId;
+
+              AccountService.getCredentialsKeyedByAccount('gce').then(function () {
+                if (gceHttpLoadBalancerUtils.isHttpLoadBalancer($scope.loadBalancer)) {
+                  $scope.loadBalancer.elb.backendServices = getBackendServices($scope.loadBalancer);
+                  $scope.loadBalancer.elb.healthChecks = _.chain($scope.loadBalancer.elb.backendServices)
+                    .map('healthCheck')
+                    .uniqBy('name')
+                    .value();
+                }
+              });
+            }
+            AccountService.getAccountDetails(loadBalancer.accountId).then(function (accountDetails) {
+              let resourceTypes;
+
+              if ($scope.loadBalancer.loadBalancerType === 'INTERNAL') {
+                resourceTypes = ['gce_forwarding_rule', 'gce_backend_service'];
+              } else if ($scope.loadBalancer.loadBalancerType === 'NETWORK') {
+                resourceTypes = ['gce_forwarding_rule', 'gce_target_pool', 'gce_health_check'];
+              } else if ($scope.loadBalancer.loadBalancerType === 'SSL') {
+                resourceTypes = ['gce_forwarding_rule', 'gce_backend_service'];
+              } else if ($scope.loadBalancer.loadBalancerType === 'TCP') {
+                resourceTypes = ['gce_forwarding_rule', 'gce_backend_service'];
+              } else if ($scope.loadBalancer.loadBalancerType === 'INTERNAL_MANAGED') {
+                resourceTypes = ['http_load_balancer', 'gce_target_http_proxy', 'gce_url_map', 'gce_backend_service'];
+              } else {
+                // $scope.loadBalancer.loadBalancerType === 'HTTP'
+                resourceTypes = ['http_load_balancer', 'gce_target_http_proxy', 'gce_url_map', 'gce_backend_service'];
+              }
+
+              resourceTypes = _.join(resourceTypes, ' OR ');
+
+              $scope.loadBalancer.project = accountDetails.project;
+              $scope.loadBalancer.logsLink =
+                'https://console.developers.google.com/project/' +
+                accountDetails.project +
+                '/logs?advancedFilter=resource.type=(' +
+                resourceTypes +
+                ')%0A"' +
+                $scope.loadBalancer.name +
+                '"';
+            });
+          }, autoClose);
+        }
+        if (!$scope.loadBalancer) {
+          autoClose();
+        }
+        return $q.when(null);
+      }
+
+      function createDetailsLoader() {
+        if (gceHttpLoadBalancerUtils.isHttpLoadBalancer($scope.loadBalancer)) {
+          const detailsPromises = $scope.loadBalancer.listeners.map((listener) => {
+            return loadBalancerReader.getLoadBalancerDetails(
+              $scope.loadBalancer.provider,
+              loadBalancer.accountId,
+              $scope.loadBalancer.region,
+              listener.name,
+            );
+          });
+
+          return $q.all(detailsPromises).then((loadBalancers) => {
+            loadBalancers = _.flatten(loadBalancers);
+            const representativeLb = loadBalancers[0];
+            representativeLb.dns = loadBalancers.map((loadBalancer) => {
+              let protocol;
+              if (loadBalancer.listenerDescriptions[0].listener.loadBalancerPort === '443') {
+                protocol = 'https:';
+              } else {
+                protocol = 'http:';
+              }
+              return { dnsname: loadBalancer.dnsname, protocol: protocol };
+            });
+            representativeLb.dns = _.uniqBy(representativeLb.dns, 'dnsname');
+            representativeLb.listenerDescriptions = _.flatten(loadBalancers.map((lb) => lb.listenerDescriptions));
+            return [representativeLb];
+          });
+        } else {
+          return loadBalancerReader
+            .getLoadBalancerDetails(
+              $scope.loadBalancer.provider,
+              loadBalancer.accountId,
+              $scope.loadBalancer.region,
+              $scope.loadBalancer.name,
+            )
+            .then((loadBalancerDetails) => {
+              const loadBalancer = loadBalancerDetails[0];
+              let protocol;
+              if (loadBalancer.listenerDescriptions[0].listener.loadBalancerPort === '443') {
+                protocol = 'https:';
+              } else {
+                protocol = 'http:';
+              }
+              loadBalancer.dns = { dnsname: loadBalancer.dnsname, protocol: protocol };
+              return loadBalancerDetails;
+            });
+        }
+      }
+
+      function getBackendServices(loadBalancer) {
+        let backendServices = [loadBalancer.defaultService];
+
+        if (loadBalancer.hostRules.length) {
+          backendServices = _.chain(loadBalancer.hostRules)
+            .reduce((services, hostRule) => {
+              services.push(hostRule.pathMatcher.defaultService);
+              return services.concat(_.map(hostRule.pathMatcher.pathRules, 'backendService'));
+            }, backendServices)
+            .uniqBy('name')
+            .value();
+        }
+        return backendServices;
+      }
+
+      function autoClose() {
+        if ($scope.$$destroyed) {
+          return;
+        }
+        $state.go('^', { allowModalToStayOpen: true }, { location: 'replace' });
+      }
+
+      app.loadBalancers
+        .ready()
+        .then(extractLoadBalancer)
+        .then(() => {
+          // If the user navigates away from the view before the initial extractLoadBalancer call completes,
+          // do not bother subscribing to the refresh
+          if (!$scope.$$destroyed) {
+            app.loadBalancers.onRefresh($scope, extractLoadBalancer);
+          }
+        });
+
+      this.editLoadBalancer = function editLoadBalancer() {
+        const wizard = loadBalancerTypeToWizardMap[$scope.loadBalancer.loadBalancerType];
+
+        $uibModal.open({
+          templateUrl: wizard.editTemplateUrl,
+          controller: `${wizard.controller} as ctrl`,
+          size: 'lg',
+          resolve: {
+            application: function () {
+              return application;
+            },
+            loadBalancer: function () {
+              return angular.copy($scope.loadBalancer);
+            },
+            isNew: function () {
+              return false;
+            },
+          },
+        });
+      };
+
+      this.deleteLoadBalancer = function deleteLoadBalancer() {
+        if (!($scope.loadBalancer.instances && $scope.loadBalancer.instances.length)) {
+          $uibModal.open({
+            controller: 'gceLoadBalancerDeleteModalCtrl as ctrl',
+            templateUrl: require('./deleteModal/deleteModal.html'),
+            resolve: {
+              application: () => application,
+              loadBalancer: () => $scope.loadBalancer,
+            },
+          });
+        }
+      };
+
+      this.isHttpLoadBalancer = (lb) => gceHttpLoadBalancerUtils.isHttpLoadBalancer(lb);
+
+      this.getNetworkId = function getNetworkId(loadBalancer) {
+        return gceXpnNamingService.decorateXpnResourceIfNecessary(loadBalancer.project, loadBalancer.network);
+      };
+
+      this.getSubnetId = function getSubnetId(loadBalancer) {
+        return gceXpnNamingService.decorateXpnResourceIfNecessary(loadBalancer.project, loadBalancer.subnet);
+      };
+    },
+  ]);

package/src/loadBalancer/details/loadBalancerDetail.controller.spec.js

@@ -0,0 +1,41 @@
+import { ApplicationModelBuilder } from '@spinnaker/core';
+
+describe('Controller: LoadBalancerDetailsCtrl', function () {
+  //NOTE: This is just a skeleton test to test DI.  Please add more tests.;
+
+  let controller;
+  let $scope;
+  let $state;
+  const loadBalancer = {
+    name: 'foo',
+    region: 'us-west-1',
+    account: 'test',
+    accountId: 'test',
+    vpcId: '1',
+  };
+
+  beforeEach(window.module(require('./loadBalancerDetail.controller').name));
+
+  beforeEach(
+    window.inject(function ($controller, $rootScope, _$state_) {
+      $scope = $rootScope.$new();
+      $state = _$state_;
+      const app = ApplicationModelBuilder.createApplicationForTests('app', {
+        key: 'loadBalancers',
+        lazy: true,
+        defaultData: [],
+      });
+      app.loadBalancers.data.push(loadBalancer);
+      controller = $controller('gceLoadBalancerDetailsCtrl', {
+        $scope: $scope,
+        loadBalancer: loadBalancer,
+        app: app,
+        $state: $state,
+      });
+    }),
+  );
+
+  it('should have an instantiated controller', function () {
+    expect(controller).toBeDefined();
+  });
+});