@spinnaker/google 2026.2.2 → 2026.3.0

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

@@ -1,260 +0,0 @@
-'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

@@ -1,41 +0,0 @@
-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();
-  });
-});

package/src/loadBalancer/details/loadBalancerDetails.html

@@ -1,202 +0,0 @@
-<div class="details-panel">
-  <div ng-if="state.loading" class="header">
-    <div class="close-button">
-      <a class="btn btn-link" ui-sref="^">
-        <span class="glyphicon glyphicon-remove"></span>
-      </a>
-    </div>
-    <div class="horizontal center middle">
-      <loading-spinner size="'small'"></loading-spinner>
-    </div>
-  </div>
-
-  <div ng-if="!state.loading" class="header">
-    <div class="close-button">
-      <a class="btn btn-link" ui-sref="^">
-        <span class="glyphicon glyphicon-remove"></span>
-      </a>
-    </div>
-    <div class="header-text horizontal middle">
-      <span class="fa icon-sitemap"></span>
-      <h3 class="horizontal middle space-between flex-1" select-on-dbl-click>
-        {{loadBalancer.name}}
-        <render-if-feature feature="entityTags">
-          <entity-notifications
-            entity="loadBalancer"
-            application="ctrl.application"
-            placement="bottom"
-            h-offset-percent="90%"
-            entity-type="loadBalancer"
-            page-location="details"
-            on-update="ctrl.application.loadBalancers.refresh()"
-          ></entity-notifications>
-        </render-if-feature>
-      </h3>
-    </div>
-    <div>
-      <div class="actions">
-        <div class="dropdown" uib-dropdown dropdown-append-to-body>
-          <button type="button" class="btn btn-sm btn-primary dropdown-toggle" uib-dropdown-toggle>
-            Load Balancer Actions <span class="caret"></span>
-          </button>
-          <ul class="dropdown-menu" uib-dropdown-menu role="menu">
-            <li><a href ng-click="ctrl.editLoadBalancer()">Edit Load Balancer</a></li>
-            <li ng-if="!loadBalancer.instances.length">
-              <a href ng-click="ctrl.deleteLoadBalancer()">Delete Load Balancer</a>
-            </li>
-            <li
-              ng-if="loadBalancer.instances.length"
-              class="disabled"
-              uib-tooltip="You must detach all instances before you can delete this load balancer."
-            >
-              <a href ng-click="ctrl.deleteLoadBalancer()">Delete Load Balancer</a>
-            </li>
-            <render-if-feature feature="entityTags">
-              <add-entity-tag-links
-                component="loadBalancer"
-                application="ctrl.application"
-                entity-type="loadBalancer"
-                on-update="ctrl.application.loadBalancers.refresh"
-              ></add-entity-tag-links>
-            </render-if-feature>
-          </ul>
-        </div>
-      </div>
-    </div>
-  </div>
-  <div ng-if="!state.loading" class="content">
-    <collapsible-section heading="Load Balancer Details" expanded="true">
-      <dl class="dl-horizontal dl-narrow">
-        <dt>Created</dt>
-        <dd>{{loadBalancer.elb.createdTime | timestamp}}</dd>
-        <dt>In</dt>
-        <dd><account-tag account="loadBalancer.account" pad="right"></account-tag></dd>
-        <dt>Region</dt>
-        <dd>{{loadBalancer.region}}</dd>
-        <dt>Type</dt>
-        <dd>
-          <gce-load-balancer-type load-balancer="loadBalancer"></gce-load-balancer-type>
-        </dd>
-        <dt ng-if="loadBalancer.network">Network</dt>
-        <dd ng-if="loadBalancer.network">{{ctrl.getNetworkId(loadBalancer)}}</dd>
-        <dt ng-if="loadBalancer.subnet">Subnet</dt>
-        <dd ng-if="loadBalancer.subnet">{{ctrl.getSubnetId(loadBalancer)}}</dd>
-        <dt ng-if="loadBalancer.serverGroups.length">Server Groups</dt>
-        <dd ng-if="loadBalancer.serverGroups.length">
-          <ul>
-            <li ng-repeat="serverGroup in loadBalancer.serverGroups | orderBy: ['isDisabled', '-name']">
-              <a
-                ui-sref="^.serverGroup({region: serverGroup.region,
-                                          accountId: serverGroup.account,
-                                          serverGroup: serverGroup.name,
-                                          provider: 'gce'})"
-              >
-                {{serverGroup.name}}
-              </a>
-            </li>
-          </ul>
-        </dd>
-        <div ng-if="!ctrl.isHttpLoadBalancer(loadBalancer) && loadBalancer.elb.dnsname">
-          <dt>DNS Name</dt>
-          <dd>
-            <a target="_blank" href="{{loadBalancer.elb.dns.protocol}}//{{loadBalancer.elb.dns.dnsname}}"
-              >{{loadBalancer.elb.dns.dnsname}}</a
-            >
-            <copy-to-clipboard
-              class="copy-to-clipboard copy-to-clipboard-sm"
-              text="loadBalancer.elb.dns.dnsname"
-              tool-tip="'Copy DNS Name to clipboard'"
-            >
-            </copy-to-clipboard>
-          </dd>
-        </div>
-        <div ng-if="ctrl.loadBalancer.loadBalancerType === 'HTTP'">
-          <dt>DNS Names</dt>
-          <dd>
-            <ul>
-              <li ng-repeat="dns in loadBalancer.elb.dns">
-                <a target="_blank" href="{{dns.protocol}}//{{dns.dnsname}}">{{dns.dnsname}}</a>
-                <copy-to-clipboard
-                  class="copy-to-clipboard copy-to-clipboard-sm"
-                  text="dns.dnsname"
-                  tool-tip="'Copy DNS Name to clipboard'"
-                >
-                </copy-to-clipboard>
-              </li>
-            </ul>
-          </dd>
-        </div>
-        <div ng-if="ctrl.isHttpLoadBalancer(loadBalancer)">
-          <gce-host-and-path-rules-button
-            default-service="loadBalancer.defaultService"
-            load-balancer-name="loadBalancer.name"
-            host-rules="loadBalancer.hostRules"
-          >
-          </gce-host-and-path-rules-button>
-        </div>
-      </dl>
-    </collapsible-section>
-    <collapsible-section heading="Status" expanded="true">
-      <health-counts class="pull-left" container="loadBalancer.instanceCounts"></health-counts>
-    </collapsible-section>
-    <collapsible-section heading="Listeners">
-      <dl>
-        <dt>
-          Load Balancer &rarr; Instance
-          <help-field
-            ng-if="ctrl.isHttpLoadBalancer(loadBalancer) || loadBalancer.loadBalancerType === 'SSL' || loadBalancer.loadBalancerType === 'TCP'"
-            key="gce.httpLoadBalancer.namedPort"
-          ></help-field>
-        </dt>
-        <dd ng-repeat="listener in loadBalancer.elb.listenerDescriptions">
-          {{listener.listener.protocol}}:{{listener.listener.loadBalancerPort}} &rarr;
-          {{listener.listener.instanceProtocol}}:{{listener.listener.instancePort}}
-        </dd>
-      </dl>
-    </collapsible-section>
-    <collapsible-section
-      heading="Backend Services"
-      ng-if="ctrl.isHttpLoadBalancer(loadBalancer) || loadBalancer.backendService"
-    >
-      <dl class="horizontal-when-filters-collapsed" ng-switch on="loadBalancer.loadBalancerType">
-        <div ng-repeat="service in loadBalancer.elb.backendServices" ng-switch-when="HTTP">
-          <hr ng-if="$index > 0" />
-          <gce-backend-service-details backend-service="service"></gce-backend-service-details>
-        </div>
-
-        <gce-backend-service-details
-          backend-service="loadBalancer.backendService"
-          ng-switch-default
-        ></gce-backend-service-details>
-      </dl>
-    </collapsible-section>
-    <collapsible-section
-      ng-if="ctrl.isHttpLoadBalancer(loadBalancer) || loadBalancer.healthCheck || loadBalancer.backendService.healthCheck"
-      heading="Health Checks"
-    >
-      <dl class="horizontal-when-filters-collapsed" ng-switch on="loadBalancer.loadBalancerType">
-        <gce-health-check ng-switch-when="NETWORK" health-check="loadBalancer.healthCheck"></gce-health-check>
-
-        <div ng-switch-when="HTTP" ng-repeat="healthCheck in loadBalancer.elb.healthChecks">
-          <hr ng-if="$index > 0" />
-          <gce-health-check health-check="healthCheck"></gce-health-check>
-        </div>
-
-        <gce-health-check ng-switch-default health-check="loadBalancer.backendService.healthCheck"></gce-health-check>
-      </dl>
-    </collapsible-section>
-    <collapsible-section heading="Logs">
-      <ul>
-        <li ng-if="loadBalancer.logsLink">
-          <a href="{{loadBalancer.logsLink}}" target="_blank">Cloud Console Logs</a>
-          <copy-to-clipboard
-            class="copy-to-clipboard copy-to-clipboard-sm"
-            text="loadBalancer.logsLink"
-            tool-tip="'Copy to clipboard'"
-          >
-          </copy-to-clipboard>
-        </li>
-      </ul>
-    </collapsible-section>
-  </div>
-</div>

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

@@ -1,31 +0,0 @@
-'use strict';
-
-import { module } from 'angular';
-import _ from 'lodash';
-
-export const GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERTYPE_LOADBALANCERTYPE_COMPONENT =
-  'spinnaker.deck.gce.loadBalancer.loadBalancerType';
-export const name = GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERTYPE_LOADBALANCERTYPE_COMPONENT; // for backwards compatibility
-module(GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERTYPE_LOADBALANCERTYPE_COMPONENT, []).component('gceLoadBalancerType', {
-  template: '<span>{{ $ctrl.type }}</span>',
-  bindings: {
-    loadBalancer: '=',
-  },
-  controller: function () {
-    this.$onInit = () => {
-      this.type = (function (lb) {
-        if (lb.loadBalancerType === 'HTTP') {
-          const hasCertificate = _.isString(lb.certificate) && !_.isEmpty(lb.certificate);
-          const hasCertificateMap = _.isString(lb.certificateMap) && !_.isEmpty(lb.certificateMap);
-          if (hasCertificate || hasCertificateMap) {
-            return 'HTTPS';
-          } else {
-            return 'HTTP';
-          }
-        } else {
-          return lb.loadBalancerType;
-        }
-      })(this.loadBalancer);
-    };
-  },
-});

package/src/loadBalancer/details/loadBalancerType/loadBalancerType.component.spec.js

@@ -1,85 +0,0 @@
-import { mock } from 'angular';
-
-describe('Component: gceLoadBalancerType', () => {
-  let $componentController;
-
-  beforeEach(mock.module(require('./loadBalancerType.component').name));
-
-  beforeEach(
-    mock.inject((_$componentController_) => {
-      $componentController = _$componentController_;
-    }),
-  );
-
-  function buildController(loadBalancer) {
-    return $componentController(
-      'gceLoadBalancerType',
-      {},
-      {
-        loadBalancer,
-      },
-    );
-  }
-
-  it('detects HTTPS when certificate is present', () => {
-    const ctrl = buildController({
-      loadBalancerType: 'HTTP',
-      certificate: 'legacy-cert',
-      certificateMap: null,
-    });
-
-    ctrl.$onInit();
-
-    expect(ctrl.type).toBe('HTTPS');
-  });
-
-  it('detects HTTPS when certificateMap is present', () => {
-    const ctrl = buildController({
-      loadBalancerType: 'HTTP',
-      certificate: null,
-      certificateMap: 'cm',
-    });
-
-    ctrl.$onInit();
-
-    expect(ctrl.type).toBe('HTTPS');
-  });
-
-  it('detects HTTP when neither certificate field is present', () => {
-    const ctrl = buildController({
-      loadBalancerType: 'HTTP',
-      certificate: null,
-      certificateMap: null,
-    });
-
-    ctrl.$onInit();
-
-    expect(ctrl.type).toBe('HTTP');
-  });
-
-  // Both fields populated simultaneously — the || means either triggers HTTPS.
-  it('detects HTTPS when both certificate and certificateMap are present', () => {
-    const ctrl = buildController({
-      loadBalancerType: 'HTTP',
-      certificate: 'legacy-cert',
-      certificateMap: 'cm',
-    });
-
-    ctrl.$onInit();
-
-    expect(ctrl.type).toBe('HTTPS');
-  });
-
-  // Non-HTTP types pass through the else branch and return verbatim.
-  it('returns loadBalancerType verbatim for non-HTTP types', () => {
-    const ctrl = buildController({
-      loadBalancerType: 'SSL',
-      certificate: null,
-      certificateMap: null,
-    });
-
-    ctrl.$onInit();
-
-    expect(ctrl.type).toBe('SSL');
-  });
-});

package/src/networkSelectField.directive.html

@@ -1,14 +0,0 @@
-<div class="form-group">
-  <div class="col-md-{{labelColumns}} sm-label-right">
-    Network <help-field ng-if="helpKey" key="{{helpKey}}"></help-field>
-  </div>
-  <div class="col-md-{{fieldColumns || 7}}" ng-if="!account">(Select an account)</div>
-  <div class="col-md-{{fieldColumns || 7}}">
-    <select class="form-control input-sm" ng-if="account" ng-model="component.network" ng-change="onChange()" required>
-      <option ng-repeat="network in networks" value="{{network}}" ng-selected="component[field] === network">
-        {{network}}
-      </option>
-    </select>
-    <p ng-if="readOnly" class="form-control-static">{{component[field]}}</p>
-  </div>
-</div>

package/src/pipeline/stages/bake/bakeExecutionDetails.controller.js

@@ -1,40 +0,0 @@
-'use strict';
-
-import UIROUTER_ANGULARJS from '@uirouter/angularjs';
-import { module } from 'angular';
-
-import { SETTINGS } from '@spinnaker/core';
-
-export const GOOGLE_PIPELINE_STAGES_BAKE_BAKEEXECUTIONDETAILS_CONTROLLER =
-  'spinnaker.gce.pipeline.stage.bake.executionDetails.controller';
-export const name = GOOGLE_PIPELINE_STAGES_BAKE_BAKEEXECUTIONDETAILS_CONTROLLER; // for backwards compatibility
-module(GOOGLE_PIPELINE_STAGES_BAKE_BAKEEXECUTIONDETAILS_CONTROLLER, [UIROUTER_ANGULARJS]).controller(
-  'gceBakeExecutionDetailsCtrl',
-  [
-    '$scope',
-    '$stateParams',
-    'executionDetailsSectionService',
-    '$interpolate',
-    function ($scope, $stateParams, executionDetailsSectionService, $interpolate) {
-      $scope.configSections = ['bakeConfig', 'taskStatus', 'artifactStatus'];
-
-      const initialized = () => {
-        $scope.detailsSection = $stateParams.details;
-        $scope.provider = $scope.stage.context.cloudProviderType || 'gce';
-        $scope.roscoMode =
-          SETTINGS.feature.roscoMode ||
-          (typeof SETTINGS.feature.roscoSelector === 'function' &&
-            SETTINGS.feature.roscoSelector($scope.stage.context));
-        $scope.bakeryDetailUrl = $interpolate(
-          $scope.roscoMode && SETTINGS.roscoDetailUrl ? SETTINGS.roscoDetailUrl : SETTINGS.bakeryDetailUrl,
-        );
-      };
-
-      const initialize = () => executionDetailsSectionService.synchronizeSection($scope.configSections, initialized);
-
-      initialize();
-
-      $scope.$on('$stateChangeSuccess', initialize);
-    },
-  ],
-);