@spinnaker/core 2026.2.2 → 2026.3.0

package/src/cache/cacheInitializer.service.spec.ts

@@ -1,13 +1,12 @@
-import type { IQService, IRootScopeService } from 'angular';
-import { mock } from 'angular';
 import { flatten } from 'lodash';
 
 import { InfrastructureCaches } from './';
 import { AccountService } from '../account/AccountService';
-import type { CacheInitializerService } from './cacheInitializer.service';
-import { CACHE_INITIALIZER_SERVICE } from './cacheInitializer.service';
+import type { DeckRuntime } from '../bootstrap/DeckRuntime';
+import { createDeckRuntime } from '../bootstrap/DeckRuntime';
+import { CacheInitializerService } from './cacheInitializer.service';
 import type { SecurityGroupReader } from '../securityGroup/securityGroupReader.service';
-import { SECURITY_GROUP_READER } from '../securityGroup/securityGroupReader.service';
+import { nativePromiseService } from '../utils/nativePromiseService';
 
 interface IKeys {
   [key: string]: string[];
@@ -15,95 +14,97 @@ interface IKeys {
 }
 
 describe('Service: cacheInitializer', function () {
-  let $q: IQService;
-  let $root: IRootScopeService;
   let cacheInitializer: CacheInitializerService;
   let securityGroupReader: SecurityGroupReader;
 
-  beforeEach(mock.module(CACHE_INITIALIZER_SERVICE, SECURITY_GROUP_READER));
-  beforeEach(
-    mock.inject(function (
-      _$q_: IQService,
-      _$rootScope_: IRootScopeService,
-      _cacheInitializer_: CacheInitializerService,
-      _securityGroupReader_: SecurityGroupReader,
-    ) {
-      $q = _$q_;
-      $root = _$rootScope_;
-      cacheInitializer = _cacheInitializer_;
-      securityGroupReader = _securityGroupReader_;
-    }),
-  );
   beforeEach(() => {
     InfrastructureCaches.destroyCaches();
-  });
-
-  it('should initialize injected dependencies', function () {
-    expect($q).toBeDefined();
-    expect($root).toBeDefined();
-    expect(cacheInitializer).toBeDefined();
-    expect(securityGroupReader).toBeDefined();
+    securityGroupReader = { getAllSecurityGroups: () => Promise.resolve([]) } as any;
+    cacheInitializer = new CacheInitializerService(nativePromiseService, securityGroupReader, {
+      hasDelegate: () => false,
+    });
   });
 
   describe('spinnaker.core.cache.initializer', () => {
     const keys: IKeys = {
       sg: ['sg1', 'sg2', 'sg3'],
     };
-    let initialized: boolean;
-
     beforeEach(() => {
-      initialized = false;
-      spyOn(securityGroupReader, 'getAllSecurityGroups').and.returnValue($q.when(keys.sg as any));
-      spyOn(AccountService, 'listProviders').and.returnValue($q.when([]));
+      spyOn(securityGroupReader, 'getAllSecurityGroups').and.returnValue(Promise.resolve(keys.sg as any));
+      spyOn(AccountService, 'listProviders').and.returnValue(Promise.resolve([]));
     });
 
-    it('should initialize the cache initializer with the initialization values', () => {
-      cacheInitializer.initialize().then((result: any[]) => {
-        expect(result.length).toBe(5); // from infrastructure cache config
-        const flattened: string[][] = flatten(result); // only the arrays that actually contain data
-        expect(flattened.length).toBe(1); // the four initialized string[] above used for the spyOns.
-        expect(flattened[0]).toEqual(keys.sg);
-        initialized = true;
-      });
-      $root.$digest();
-      expect(initialized).toBeTruthy();
+    it('should initialize the cache initializer with the initialization values', async () => {
+      const result = await cacheInitializer.initialize();
+
+      expect(result.length).toBe(5); // from infrastructure cache config
+      const flattened: string[][] = flatten(result); // only the arrays that actually contain data
+      expect(flattened.length).toBe(1); // the four initialized string[] above used for the spyOns.
+      expect(flattened[0]).toEqual(keys.sg);
     });
 
-    it('should remove all items from all caches', () => {
-      cacheInitializer.refreshCaches().then((result: any[]) => {
-        expect(result.length).toBe(5);
-        result.forEach((item: any) => expect(item).toBeUndefined());
-        initialized = true;
-      });
-      $root.$digest();
-      expect(initialized).toBeTruthy();
+    it('should remove all items from all caches', async () => {
+      const result = await cacheInitializer.refreshCaches();
+
+      expect(result.length).toBe(5);
+      result.forEach((item: any) => expect(item).toBeUndefined());
     });
 
-    it('should remove all items from the specified cache', () => {
+    it('should remove all items from the specified cache', async () => {
       let cache = InfrastructureCaches.get('securityGroups');
       expect(cache).toBeUndefined();
 
-      cacheInitializer.initialize().then(() => {
-        cache = InfrastructureCaches.get('securityGroups');
-        expect(cache).toBeDefined();
-        expect(cache.keys().length).toBe(0);
-
-        const key = 'myTestCacheKey';
-        const value = 'myTestCacheValue';
-        cache.put(key, value);
-
-        expect(cache.keys().length).toBe(1);
-        expect(cache.get(key)).toBe(value);
-
-        cacheInitializer.refreshCache('securityGroups').then((result: any[]) => {
-          expect(flatten(result)).toEqual(keys.sg);
-          cache = InfrastructureCaches.get('securityGroups');
-          expect(cache.keys().length).toBe(0);
-        });
-        initialized = true;
-      });
-      $root.$digest();
-      expect(initialized).toBeTruthy();
+      await cacheInitializer.initialize();
+      cache = InfrastructureCaches.get('securityGroups');
+      expect(cache).toBeDefined();
+      expect(cache.keys().length).toBe(0);
+
+      const key = 'myTestCacheKey';
+      const value = 'myTestCacheValue';
+      cache.put(key, value);
+
+      expect(cache.keys().length).toBe(1);
+      expect(cache.get(key)).toBe(value);
+
+      const result = await cacheInitializer.refreshCache('securityGroups');
+      expect(flatten(result)).toEqual(keys.sg);
+      cache = InfrastructureCaches.get('securityGroups');
+      expect(cache.keys().length).toBe(0);
     });
   });
 });
+
+describe('direct runtime cache initializer', () => {
+  let runtime: DeckRuntime;
+
+  beforeEach(() => {
+    InfrastructureCaches.destroyCaches();
+    runtime = createDeckRuntime();
+  });
+
+  afterEach(() => {
+    runtime.dispose();
+    InfrastructureCaches.destroyCaches();
+  });
+
+  it('initializes and refreshes infrastructure caches with native runtime dependencies', async () => {
+    spyOn(InfrastructureCaches, 'createCache').and.returnValue({} as any);
+    spyOn(InfrastructureCaches, 'clearCache');
+    spyOn(AccountService, 'listProviders').and.returnValue(Promise.resolve([]));
+    const getAllSecurityGroups = spyOn(runtime.services.securityGroupReader, 'getAllSecurityGroups').and.returnValue(
+      Promise.resolve([]),
+    );
+    const cacheInitializer = runtime.services.cacheInitializer;
+
+    expect(cacheInitializer.initialize).toEqual(jasmine.any(Function));
+    expect(cacheInitializer.refreshCache).toEqual(jasmine.any(Function));
+    expect(cacheInitializer.refreshCaches).toEqual(jasmine.any(Function));
+
+    await cacheInitializer.initialize();
+    await cacheInitializer.refreshCache('securityGroups');
+    await cacheInitializer.refreshCaches();
+
+    expect(AccountService.listProviders).toHaveBeenCalledWith();
+    expect(getAllSecurityGroups).toHaveBeenCalledTimes(3);
+  });
+});

package/src/cache/cacheInitializer.service.ts

@@ -1,6 +1,4 @@
-import type { IQService } from 'angular';
-import { module, noop } from 'angular';
-import { cloneDeep, uniq } from 'lodash';
+import { cloneDeep, noop, uniq } from 'lodash';
 import { Duration } from 'luxon';
 
 import { AccountService } from '../account/AccountService';
@@ -10,7 +8,7 @@ import type { IInfrastructureCacheConfig } from './infrastructureCacheConfig';
 import { INFRASTRUCTURE_CACHE_CONFIG } from './infrastructureCacheConfig';
 import { InfrastructureCaches } from './infrastructureCaches';
 import type { SecurityGroupReader } from '../securityGroup/securityGroupReader.service';
-import { SECURITY_GROUP_READER } from '../securityGroup/securityGroupReader.service';
+import type { PromiseService } from '../utils/nativePromiseService';
 
 interface IInitializers {
   [key: string]: any[];
@@ -31,7 +29,7 @@ export class CacheInitializerService {
     config.onReset = config.onReset || [noop];
   }
 
-  private extendConfig(): PromiseLike<void> {
+  private extendConfig(): Promise<void> {
     Object.keys(this.cacheConfig).forEach((key: string) => {
       this.setConfigDefaults(key, this.cacheConfig[key]);
     });
@@ -61,53 +59,49 @@ export class CacheInitializerService {
     });
   }
 
-  private initializeCache(key: string): PromiseLike<any[]> {
+  private initializeCache(key: string): Promise<any[]> {
     InfrastructureCaches.createCache(key, this.cacheConfig[key]);
     if (this.cacheConfig[key].initializers) {
       const initializer: any = this.cacheConfig[key].initializers;
-      const all: Array<PromiseLike<any>> = [];
+      const all: Array<Promise<any>> = [];
       initializer.forEach((method: Function) => {
         all.push(method());
       });
 
-      return this.$q.all(all);
+      return this.promiseService.all(all);
     } else {
-      return this.$q.resolve(undefined);
+      return this.promiseService.resolve(undefined);
     }
   }
 
-  public static $inject = ['$q', 'securityGroupReader', 'providerServiceDelegate'];
   constructor(
-    private $q: IQService,
+    private promiseService: PromiseService,
     private securityGroupReader: SecurityGroupReader,
     private providerServiceDelegate: any,
   ) {}
 
-  public initialize(): PromiseLike<any[]> {
+  public initialize(): Promise<any[]> {
     return this.extendConfig().then(() => {
       const all: any[] = [];
       Object.keys(this.cacheConfig).forEach((key: string) => {
         all.push(this.initializeCache(key));
       });
 
-      return this.$q.all(all);
+      return this.promiseService.all(all);
     });
   }
 
-  public refreshCache(key: string): PromiseLike<any[]> {
+  public refreshCache(key: string): Promise<any[]> {
     InfrastructureCaches.clearCache(key);
     return this.initializeCache(key);
   }
 
-  public refreshCaches(): PromiseLike<any[]> {
-    const all: Array<PromiseLike<any[]>> = [];
+  public refreshCaches(): Promise<any[]> {
+    const all: Array<Promise<any[]>> = [];
     Object.keys(this.cacheConfig).forEach((key: string) => {
       all.push(this.refreshCache(key));
     });
 
-    return this.$q.all(all);
+    return this.promiseService.all(all);
   }
 }
-
-export const CACHE_INITIALIZER_SERVICE = 'spinnaker.core.cache.initializer';
-module(CACHE_INITIALIZER_SERVICE, [SECURITY_GROUP_READER]).service('cacheInitializer', CacheInitializerService);

package/src/cache/deckCacheFactory.ts

@@ -99,7 +99,7 @@ export class DeckCacheFactory {
   private static cacheProxy: ICacheProxy = Object.create(null);
 
   public static getStoragePrefix(key: string, version: number): string {
-    return `angular-cache.caches.${key}:${version}.`;
+    return `deck-cache.caches.${key}:${version}.`;
   }
 
   private static buildCacheKey(namespace: string, cacheId: string): string {

package/src/cache/infrastructureCaches.spec.ts

@@ -81,6 +81,12 @@ describe('spinnaker.core.cache.infrastructure', function () {
       cacheFactory = new TestCacheFactory();
     });
 
+    it('uses a Deck-owned browser storage prefix', function () {
+      expect(DeckCacheFactory.getStoragePrefix('infrastructure:myCache', 2)).toBe(
+        'deck-cache.caches.infrastructure:myCache:2.',
+      );
+    });
+
     it('should remove all keys from previous versions', function () {
       const config: ICacheConfig = {
         version: 2,

package/src/certificates/certificate.read.service.ts

@@ -9,11 +9,11 @@ export interface ICertificate {
 }
 
 export class CertificateReader {
-  public static listCertificates(): PromiseLike<ICertificate[]> {
+  public static listCertificates(): Promise<ICertificate[]> {
     return REST('/certificates').get();
   }
 
-  public static listCertificatesByProvider(cloudProvider: string): PromiseLike<ICertificate[]> {
+  public static listCertificatesByProvider(cloudProvider: string): Promise<ICertificate[]> {
     return REST('/certificates').path(cloudProvider).get();
   }
 }

package/src/ci/CIReader.ts

@@ -50,18 +50,18 @@ export class CIReader {
     return 4095;
   }
 
-  public static getBuilds(repoType: string, projectKey: string, repoSlug: string): PromiseLike<ICiBuild[]> {
+  public static getBuilds(repoType: string, projectKey: string, repoSlug: string): Promise<ICiBuild[]> {
     return REST('ci/builds')
       .query({ repoType, projectKey, repoSlug })
       .get()
       .then((builds: ICiBuildAPI[]) => builds.map((build: ICiBuildAPI) => transformBuildToUIFormat(build)));
   }
 
-  public static getRunningBuilds(repoType: string, projectKey: string, repoSlug: string): PromiseLike<ICiBuild[]> {
+  public static getRunningBuilds(repoType: string, projectKey: string, repoSlug: string): Promise<ICiBuild[]> {
     return REST('ci/builds').query({ repoType, projectKey, repoSlug, completionStatus: 'INCOMPLETE' }).get();
   }
 
-  public static getBuildOutput(buildId: string, start = -1): PromiseLike<ICiBuildOutputConfig> {
+  public static getBuildOutput(buildId: string, start = -1): Promise<ICiBuildOutputConfig> {
     return REST('ci/builds').path(buildId, 'output').query({ start, limit: CIReader.MAX_LINES }).get();
   }
 }

package/src/ci/ci.dataSource.ts

@@ -1,5 +1,3 @@
-import type { IQService } from 'angular';
-import { module } from 'angular';
 import { isEmpty } from 'lodash';
 
 import { CIReader } from './CIReader';
@@ -8,31 +6,28 @@ import { ApplicationDataSourceRegistry, navigationCategoryRegistry } from '../ap
 import { SETTINGS } from '../config/settings';
 import type { ICiBuild } from './domain';
 
-export const CI_DATASOURCE = 'spinnaker.ci.dataSource';
-export const name = CI_DATASOURCE;
-module(CI_DATASOURCE, []).run([
-  '$q',
-  ($q: IQService) => {
-    if (!SETTINGS.feature.ci) {
-      return;
-    }
+export function registerCiDataSources(): void {
+  if (!SETTINGS.feature.ci) {
+    return;
+  }
 
-    const loadBuilds = (application: Application) => {
-      const { repoType, repoProjectKey, repoSlug } = application.attributes;
-      if (isEmpty(repoProjectKey) || isEmpty(repoType) || isEmpty(repoSlug)) {
-        return $q.when([]);
-      }
-      return CIReader.getBuilds(repoType, repoProjectKey, repoSlug);
-    };
+  const loadBuilds = (application: Application) => {
+    const { repoType, repoProjectKey, repoSlug } = application.attributes;
+    if (isEmpty(repoProjectKey) || isEmpty(repoType) || isEmpty(repoSlug)) {
+      return Promise.resolve([]);
+    }
+    return CIReader.getBuilds(repoType, repoProjectKey, repoSlug);
+  };
 
-    const loadRunningBuilds = (application: Application) => {
-      const { repoType, repoProjectKey, repoSlug } = application.attributes;
-      if (isEmpty(repoProjectKey) || isEmpty(repoType) || isEmpty(repoSlug)) {
-        return $q.when([]);
-      }
-      return CIReader.getRunningBuilds(repoType, repoProjectKey, repoSlug);
-    };
+  const loadRunningBuilds = (application: Application) => {
+    const { repoType, repoProjectKey, repoSlug } = application.attributes;
+    if (isEmpty(repoProjectKey) || isEmpty(repoType) || isEmpty(repoSlug)) {
+      return Promise.resolve([]);
+    }
+    return CIReader.getRunningBuilds(repoType, repoProjectKey, repoSlug);
+  };
 
+  if (!navigationCategoryRegistry.has('integration')) {
     navigationCategoryRegistry.register({
       key: 'integration',
       label: 'Integration',
@@ -41,44 +36,46 @@ module(CI_DATASOURCE, []).run([
       primary: true,
       order: 0,
     });
+  }
 
-    ApplicationDataSourceRegistry.registerDataSource({
-      key: 'integration',
-      badge: 'runningBuilds',
-      icon: 'icon-ci-branch',
-      iconName: 'spCIBranch',
-      category: 'integration',
-      label: 'Integration',
-      optional: true,
-      lazy: true,
-      description: 'Visibility into builds for pull requests and branches',
-      requireConfiguredApp: true,
-      defaultData: [],
-    });
+  ApplicationDataSourceRegistry.registerDataSource({
+    key: 'integration',
+    badge: 'runningBuilds',
+    icon: 'icon-ci-branch',
+    iconName: 'spCIBranch',
+    category: 'integration',
+    label: 'Integration',
+    optional: true,
+    lazy: true,
+    description: 'Visibility into builds for pull requests and branches',
+    requireConfiguredApp: true,
+    defaultData: [],
+  });
 
-    ApplicationDataSourceRegistry.registerDataSource({
-      key: 'builds',
-      sref: '.builds',
-      badge: 'runningBuilds',
-      icon: 'icon-ci-build',
-      iconName: 'spCIBuild',
-      category: 'integration',
-      label: 'Builds',
-      lazy: true,
-      requireConfiguredApp: true,
-      requiresDataSource: 'integration',
-      loader: loadBuilds,
-      onLoad: (_: Application, data: ICiBuild) => $q.when(data),
-      defaultData: [],
-    });
+  ApplicationDataSourceRegistry.registerDataSource({
+    key: 'builds',
+    sref: '.builds',
+    badge: 'runningBuilds',
+    icon: 'icon-ci-build',
+    iconName: 'spCIBuild',
+    category: 'integration',
+    label: 'Builds',
+    lazy: true,
+    requireConfiguredApp: true,
+    requiresDataSource: 'integration',
+    loader: loadBuilds,
+    onLoad: (_: Application, data: ICiBuild) => Promise.resolve(data),
+    defaultData: [],
+  });
 
-    ApplicationDataSourceRegistry.registerDataSource({
-      key: 'runningBuilds',
-      visible: false,
-      description: 'running builds',
-      loader: loadRunningBuilds,
-      onLoad: (_: Application, data: ICiBuild) => $q.when(data),
-      defaultData: [],
-    });
-  },
-]);
+  ApplicationDataSourceRegistry.registerDataSource({
+    key: 'runningBuilds',
+    visible: false,
+    description: 'running builds',
+    loader: loadRunningBuilds,
+    onLoad: (_: Application, data: ICiBuild) => Promise.resolve(data),
+    defaultData: [],
+  });
+}
+
+registerCiDataSources();

package/src/ci/ci.module.ts

@@ -1,10 +1,2 @@
-'use strict';
-
-import { module } from 'angular';
-
-import { CI_DATASOURCE } from './ci.dataSource';
-import { CI_STATES } from './ci.states';
-
-export const CI_MODULE = 'spinnaker.ci';
-export const name = CI_MODULE;
-module(CI_MODULE, [CI_STATES, CI_DATASOURCE]);
+import './ci.dataSource';
+import './ci.states';

package/src/ci/ci.states.ts

@@ -1,48 +1,40 @@
-import { module } from 'angular';
-
 import type { ApplicationStateProvider } from '../application';
-import { APPLICATION_STATE_PROVIDER } from '../application';
+import { registerApplicationState } from '../application';
 import { Builds } from './components/Builds';
 import { SETTINGS } from '../config/settings';
 import type { INestedState } from '../navigation';
 
-export const CI_STATES = 'spinnaker.ci.states';
-export const name = CI_STATES;
-
-module(CI_STATES, [APPLICATION_STATE_PROVIDER]).config([
-  'applicationStateProvider',
-  (applicationStateProvider: ApplicationStateProvider) => {
-    if (!SETTINGS.feature.ci) {
-      return;
-    }
-    const buildDetailTab: INestedState = {
-      name: 'buildTab',
-      url: '/:tab',
-    };
+registerApplicationState((applicationStateProvider: ApplicationStateProvider) => {
+  if (!SETTINGS.feature.ci) {
+    return;
+  }
+  const buildDetailTab: INestedState = {
+    name: 'buildTab',
+    url: '/:tab',
+  };
 
-    const buildDetail: INestedState = {
-      name: 'build',
-      url: '/:buildId',
-      children: [buildDetailTab],
-    };
+  const buildDetail: INestedState = {
+    name: 'build',
+    url: '/:buildId',
+    children: [buildDetailTab],
+  };
 
-    const builds: INestedState = {
-      name: 'builds',
-      url: '/builds',
-      views: {
-        insight: {
-          component: Builds,
-          $type: 'react',
-        },
+  const builds: INestedState = {
+    name: 'builds',
+    url: '/builds',
+    views: {
+      insight: {
+        component: Builds,
+        $type: 'react',
       },
-      data: {
-        pageTitleSection: {
-          title: 'Builds',
-        },
+    },
+    data: {
+      pageTitleSection: {
+        title: 'Builds',
       },
-      children: [buildDetail],
-    };
+    },
+    children: [buildDetail],
+  };
 
-    applicationStateProvider.addChildState(builds);
-  },
-]);
+  applicationStateProvider.addChildState(builds);
+});

package/src/ci/components/Builds.spec.tsx

@@ -0,0 +1,82 @@
+import { hashLocationPlugin, servicesPlugin, UIRouterContext, UIRouterReact } from '@uirouter/react';
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { ApplicationDataSource } from '../../application/service/applicationDataSource';
+import { ApplicationModelBuilder } from '../../application/applicationModel.builder';
+import { Builds } from './Builds';
+import type { ICiBuild } from '../domain';
+
+describe('Builds', () => {
+  let router: UIRouterReact;
+  const build = ({
+    id: 'build-1',
+    number: 1,
+    fullDisplayName: 'main #1',
+    result: 'SUCCEEDED',
+    artifacts: [],
+    author: 'octopus',
+    branchName: 'main',
+    commitId: 'abc123',
+    commitLink: 'https://example.test/commit/abc123',
+    commitMessage: 'Deploy app',
+    duration: 1000,
+    pullRequestNumber: '',
+    startTime: Date.now() - 1000,
+    url: 'https://example.test/build/1',
+  } as unknown) as ICiBuild;
+
+  beforeEach(() => {
+    router = new UIRouterReact();
+    router.plugin(servicesPlugin);
+    router.plugin(hashLocationPlugin);
+  });
+
+  afterEach(() => router.dispose());
+
+  it('renders loaded builds inside a single page wrapper', () => {
+    const app = ApplicationModelBuilder.createApplicationForTests(
+      'app',
+      { key: 'builds', defaultData: [] as ICiBuild[] },
+      { key: 'runningBuilds', defaultData: [] as ICiBuild[], visible: false },
+    );
+    const buildsDataSource = app.getDataSource('builds') as ApplicationDataSource<ICiBuild[]>;
+    buildsDataSource.data = [build];
+    buildsDataSource.status$.next({ status: 'FETCHED', loaded: true, data: [build], lastRefresh: 0, error: null });
+    app.attributes.repoType = 'github';
+    app.attributes.repoProjectKey = 'spinnaker';
+    app.attributes.repoSlug = 'deck';
+    spyOn(router.stateService, 'go').and.returnValue(Promise.resolve(null) as any);
+
+    const wrapper = mount(
+      <UIRouterContext.Provider value={router}>
+        <Builds app={app} />
+      </UIRouterContext.Provider>,
+    );
+
+    expect(
+      wrapper
+        .find('.builds-page')
+        .children()
+        .map((child) => child.prop('className')),
+    ).toEqual(['nav-ci', 'build-detail']);
+  });
+
+  it('renders configuration errors inside the page wrapper', () => {
+    const app = ApplicationModelBuilder.createApplicationForTests('app', {
+      key: 'builds',
+      defaultData: [] as ICiBuild[],
+    });
+    const buildsDataSource = app.getDataSource('builds') as ApplicationDataSource<ICiBuild[]>;
+    buildsDataSource.status$.next({ status: 'FETCHED', loaded: true, data: [], lastRefresh: 0, error: null });
+
+    const wrapper = mount(
+      <UIRouterContext.Provider value={router}>
+        <Builds app={app} />
+      </UIRouterContext.Provider>,
+    );
+
+    expect(wrapper.find('.builds-page').hasClass('builds-page-empty')).toBe(true);
+    expect(wrapper.find('.builds-page > .configuration-error').exists()).toBe(true);
+  });
+});