@spinnaker/cloudfoundry 0.0.0-main-2

package/src/pipeline/config/validation/instanceSize.validator.ts

@@ -0,0 +1,66 @@
+import { get, has, upperFirst } from 'lodash';
+
+import type { IPipeline, IStage, IStageOrTriggerValidator, ITrigger, IValidatorConfig } from '@spinnaker/core';
+import { PipelineConfigValidator } from '@spinnaker/core';
+
+export interface IInstanceFieldSizeValidationConfig extends IValidatorConfig {
+  fieldName: string;
+  fieldLabel?: string;
+  min?: number;
+  max?: number;
+  message?: string;
+}
+
+export class CfInstanceSizeFieldValidator implements IStageOrTriggerValidator {
+  public validate(
+    pipeline: IPipeline,
+    stage: IStage | ITrigger,
+    validationConfig: IInstanceFieldSizeValidationConfig,
+  ): string {
+    if (!this.passesValidation(stage, validationConfig)) {
+      return this.validationMessage(validationConfig, pipeline);
+    }
+    return null;
+  }
+
+  protected passesValidation(stage: IStage | ITrigger, validationConfig: IInstanceFieldSizeValidationConfig): boolean {
+    return this.fieldIsValid(stage, validationConfig);
+  }
+
+  protected validationMessage(validationConfig: IInstanceFieldSizeValidationConfig, pipeline: IPipeline): string {
+    const fieldLabel: string = this.printableFieldLabel(validationConfig);
+    const hasMin = has(validationConfig, 'min');
+    const min: any = hasMin ? get(validationConfig, 'min') : 'NA';
+    const hasMax = has(validationConfig, 'max');
+    const max: any = hasMax ? get(validationConfig, 'max') : 'NA';
+    let message = ``;
+    if (hasMin) {
+      if (hasMax) {
+        message = `<strong>${fieldLabel}</strong> should be from ${min} to ${max} in ${pipeline.name}.`;
+      } else {
+        message = `<strong>${fieldLabel}</strong> should be at least ${min} in ${pipeline.name}.`;
+      }
+    } else if (hasMax) {
+      message = `<strong>${fieldLabel}</strong> should be no more than ${max} in ${pipeline.name}.`;
+    }
+    return validationConfig.message || message;
+  }
+
+  protected printableFieldLabel(config: IInstanceFieldSizeValidationConfig): string {
+    const fieldLabel: string = config.fieldLabel || config.fieldName;
+    return upperFirst(fieldLabel);
+  }
+
+  protected fieldIsValid(stage: IStage | ITrigger, config: IInstanceFieldSizeValidationConfig): boolean {
+    const fieldExists = has(stage, config.fieldName);
+    const field: any = get(stage, config.fieldName);
+    const hasMax: boolean = has(config, 'max');
+    const hasMin: boolean = has(config, 'min');
+    const max: number = get(config, 'max');
+    const min: number = get(config, 'min');
+
+    return fieldExists && (!hasMax || (hasMax && field <= max)) && (!hasMin || (hasMin && field >= min));
+  }
+}
+
+PipelineConfigValidator.registerValidator('cfInstanceSizeField', new CfInstanceSizeFieldValidator());

package/src/pipeline/config/validation/requiredRoutes.validator.ts

@@ -0,0 +1,26 @@
+import { get } from 'lodash';
+
+import type { IPipeline, IStage, IStageOrTriggerValidator, ITrigger } from '@spinnaker/core';
+import { PipelineConfigValidator } from '@spinnaker/core';
+
+export class CfRequiredRoutesFieldValidator implements IStageOrTriggerValidator {
+  public validate(_pipeline: IPipeline, stage: IStage | ITrigger, validationConfig: any): string {
+    const routes: string[] = get(stage, validationConfig.fieldName);
+    const routeErrors = routes
+      .map((route: string) => {
+        const regex = /^([-\w]+)\.([-.\w]+)(:\d+)?([-/\w]+)?$/gm;
+        route = route || '';
+        if (regex.exec(route) === null) {
+          const spelRegex = /^\${.*}$/g;
+          if (spelRegex.exec(route) === null) {
+            return `"${route}" did not match the expected format "host.some.domain[:9999][/some/path]"`;
+          }
+        }
+        return null;
+      })
+      .filter((err) => err != null);
+    return (routeErrors && routeErrors.length && routeErrors[0]) || null;
+  }
+}
+
+PipelineConfigValidator.registerValidator('cfRequiredRoutesField', new CfRequiredRoutesFieldValidator());

package/src/pipeline/stages/bakeCloudFoundryManifest/BakeCloudFoundryManifestConfig.tsx

@@ -0,0 +1,62 @@
+import type { FormikErrors } from 'formik';
+import { cloneDeep } from 'lodash';
+import React from 'react';
+
+import type { IArtifact, IExpectedArtifact, IStage, IStageConfigProps } from '@spinnaker/core';
+import { FormikStageConfig, FormValidator } from '@spinnaker/core';
+
+import { BakeCloudFoundryManifestConfigForm } from './BakeCloudFoundryManifestConfigForm';
+
+export function BakeCloudFoundryManifestConfig({ application, pipeline, stage, updateStage }: IStageConfigProps) {
+  const stageWithDefaults = React.useMemo(() => {
+    return {
+      inputArtifacts: [],
+      ...cloneDeep(stage),
+    };
+  }, []);
+
+  return (
+    <FormikStageConfig
+      application={application}
+      onChange={updateStage}
+      pipeline={pipeline}
+      stage={stageWithDefaults}
+      validate={validateBakeCloudFoundryManifestStage}
+      render={(props) => <BakeCloudFoundryManifestConfigForm {...props} />}
+    />
+  );
+}
+
+export function validateBakeCloudFoundryManifestStage(stage: IStage): FormikErrors<IStage> {
+  const formValidator = new FormValidator(stage);
+
+  formValidator
+    .field('expectedArtifacts', 'Produced artifacts')
+    .required()
+    .withValidators((artifacts: IExpectedArtifact[]) => {
+      if (validateProducedArtifacts(artifacts)) {
+        return undefined;
+      }
+      return 'Exactly one expected artifact of type embedded/base64 must be configured in the Produces Artifacts section';
+    });
+  formValidator.field('outputName', 'Name').required();
+  formValidator
+    .field('inputArtifacts', 'Template and Variables Artifacts')
+    .required()
+    .withValidators((artifacts: IArtifact[]) => {
+      if (validateInputArtifacts(artifacts)) {
+        return undefined;
+      }
+      return 'There should be one manifest template and at least one variables artifact';
+    });
+
+  return formValidator.validateForm();
+}
+
+export function validateProducedArtifacts(artifacts: IExpectedArtifact[]): boolean {
+  return artifacts?.length === 1 && artifacts[0]?.matchArtifact?.type === 'embedded/base64';
+}
+
+export function validateInputArtifacts(artifacts: IArtifact[]): boolean {
+  return artifacts?.length >= 2;
+}

package/src/pipeline/stages/bakeCloudFoundryManifest/BakeCloudFoundryManifestConfigForm.tsx

@@ -0,0 +1,174 @@
+import React from 'react';
+
+import type { IArtifact, IExpectedArtifact, IFormikStageConfigInjectedProps } from '@spinnaker/core';
+import {
+  ArtifactTypePatterns,
+  excludeAllTypesExcept,
+  StageArtifactSelectorDelegate,
+  StageConfigField,
+  TextInput,
+} from '@spinnaker/core';
+
+export class BakeCloudFoundryManifestConfigForm extends React.Component<IFormikStageConfigInjectedProps> {
+  private static readonly excludedArtifactTypes = excludeAllTypesExcept(
+    ArtifactTypePatterns.BITBUCKET_FILE,
+    ArtifactTypePatterns.CUSTOM_OBJECT,
+    ArtifactTypePatterns.EMBEDDED_BASE64,
+    ArtifactTypePatterns.GCS_OBJECT,
+    ArtifactTypePatterns.GITHUB_FILE,
+    ArtifactTypePatterns.GITLAB_FILE,
+    ArtifactTypePatterns.S3_OBJECT,
+    ArtifactTypePatterns.HTTP_FILE,
+    ArtifactTypePatterns.ORACLE_OBJECT,
+  );
+
+  public componentDidMount() {
+    const stage = this.props.formik.values;
+    if (stage.inputArtifacts && stage.inputArtifacts.length === 0) {
+      this.props.formik.setFieldValue('inputArtifacts', [
+        {
+          account: '',
+          id: '',
+        },
+      ]);
+    }
+  }
+
+  private onTemplateArtifactEdited = (artifact: IArtifact, index: number) => {
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].id`, null);
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].artifact`, artifact);
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].account`, artifact.artifactAccount);
+  };
+
+  private onTemplateArtifactSelected = (id: string, index: number) => {
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].id`, id);
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].artifact`, null);
+  };
+
+  private addInputArtifact = () => {
+    const stage = this.props.formik.values;
+    const newInputArtifacts = [
+      ...stage.inputArtifacts,
+      {
+        account: '',
+        id: '',
+      },
+    ];
+
+    this.props.formik.setFieldValue('inputArtifacts', newInputArtifacts);
+  };
+
+  private removeInputArtifact = (index: number) => {
+    const stage = this.props.formik.values;
+    const newInputArtifacts = [...stage.inputArtifacts];
+    newInputArtifacts.splice(index, 1);
+    this.props.formik.setFieldValue('inputArtifacts', newInputArtifacts);
+  };
+
+  private getInputArtifact = (stage: any, index: number) => {
+    if (!stage.inputArtifacts || stage.inputArtifacts.length === 0) {
+      return {
+        account: '',
+        id: '',
+      };
+    } else {
+      return stage.inputArtifacts[index];
+    }
+  };
+
+  private outputNameChange = (outputName: string) => {
+    const stage = this.props.formik.values;
+    const expectedArtifacts = stage.expectedArtifacts;
+    if (
+      expectedArtifacts &&
+      expectedArtifacts.length === 1 &&
+      expectedArtifacts[0].matchArtifact &&
+      expectedArtifacts[0].matchArtifact.type === 'embedded/base64'
+    ) {
+      this.props.formik.setFieldValue('expectedArtifacts', [
+        {
+          ...expectedArtifacts[0],
+          matchArtifact: {
+            ...expectedArtifacts[0].matchArtifact,
+            name: outputName,
+          },
+        },
+      ]);
+    }
+  };
+
+  public render() {
+    const stage = this.props.formik.values;
+
+    return (
+      <>
+        <h4>Manifest Options</h4>
+        <StageConfigField fieldColumns={3} label={'Name'} helpKey={'pipeline.config.bake.cf.manifest.name'}>
+          <TextInput
+            onChange={(e: React.ChangeEvent<any>) => {
+              this.props.formik.setFieldValue('outputName', e.target.value);
+              this.outputNameChange(e.target.value);
+            }}
+            value={stage.outputName}
+          />
+        </StageConfigField>
+        <h4>Manifest Template</h4>
+        <StageArtifactSelectorDelegate
+          artifact={this.getInputArtifact(stage, 0).artifact}
+          excludedArtifactTypePatterns={BakeCloudFoundryManifestConfigForm.excludedArtifactTypes}
+          expectedArtifactId={this.getInputArtifact(stage, 0).id}
+          label="Template Artifact"
+          onArtifactEdited={(artifact) => {
+            this.onTemplateArtifactEdited(artifact, 0);
+          }}
+          helpKey={'pipeline.config.bake.cf.manifest.templateArtifact'}
+          onExpectedArtifactSelected={(artifact: IExpectedArtifact) => this.onTemplateArtifactSelected(artifact.id, 0)}
+          pipeline={this.props.pipeline}
+          stage={stage}
+        />
+        <h4>Manifest Variables</h4>
+        {stage.inputArtifacts && stage.inputArtifacts.length > 1 && (
+          <div className="row form-group">
+            {stage.inputArtifacts.slice(1).map((a: any, index: number) => {
+              return (
+                <div key={index}>
+                  <div className="col-md-offset-1 col-md-9">
+                    <StageArtifactSelectorDelegate
+                      artifact={a.artifact}
+                      excludedArtifactTypePatterns={[]}
+                      expectedArtifactId={a.id}
+                      label="Variables Artifact"
+                      onArtifactEdited={(artifact) => {
+                        this.onTemplateArtifactEdited(artifact, index + 1);
+                      }}
+                      onExpectedArtifactSelected={(artifact: IExpectedArtifact) =>
+                        this.onTemplateArtifactSelected(artifact.id, index + 1)
+                      }
+                      helpKey={'pipeline.config.bake.cf.manifest.varsArtifact'}
+                      pipeline={this.props.pipeline}
+                      stage={stage}
+                    />
+                  </div>
+                  <div className="col-md-1">
+                    <div className="form-control-static">
+                      <button onClick={() => this.removeInputArtifact(index + 1)}>
+                        <span className="glyphicon glyphicon-trash" />
+                        <span className="sr-only">Remove field</span>
+                      </button>
+                    </div>
+                  </div>
+                </div>
+              );
+            })}
+          </div>
+        )}
+        <StageConfigField fieldColumns={8} label={''}>
+          <button className="btn btn-block btn-sm add-new" onClick={() => this.addInputArtifact()}>
+            <span className="glyphicon glyphicon-plus-sign" />
+            Add variables artifact
+          </button>
+        </StageConfigField>
+      </>
+    );
+  }
+}

package/src/pipeline/stages/bakeCloudFoundryManifest/BakeCloudFoundryManifestDetailsTab.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+
+import type { IArtifact, IExecutionDetailsSectionProps } from '@spinnaker/core';
+import {
+  decodeUnicodeBase64,
+  ExecutionDetailsSection,
+  ManifestYaml,
+  Overridable,
+  StageFailureMessage,
+} from '@spinnaker/core';
+
+@Overridable('bakeManifest.bakeManifestDetailsTab')
+export class BakeCloudFoundryManifestDetailsTab extends React.Component<IExecutionDetailsSectionProps> {
+  public static title = 'bakedManifest';
+
+  public render() {
+    const { current, name, stage } = this.props;
+    const bakedArtifacts: IArtifact[] = (stage.context.artifacts || []).filter(
+      (a: IArtifact) => a.type === 'embedded/base64',
+    );
+    return (
+      <ExecutionDetailsSection name={name} current={current}>
+        <StageFailureMessage stage={stage} message={stage.failureMessage} />
+        {bakedArtifacts.map((artifact, i) => (
+          <ManifestYaml
+            key={i}
+            linkName={bakedArtifacts.length > 1 ? `Baked Manifest ${i} YAML` : 'Baked Manifest YAML'}
+            manifestText={decodeUnicodeBase64(artifact.reference)}
+            modalTitle="Baked Manifest"
+          />
+        ))}
+      </ExecutionDetailsSection>
+    );
+  }
+}

package/src/pipeline/stages/bakeCloudFoundryManifest/bakeCloudFoundryManifestConfig.spec.tsx

@@ -0,0 +1,80 @@
+import type { IArtifact, IExpectedArtifact } from '@spinnaker/core';
+
+import { validateInputArtifacts, validateProducedArtifacts } from './BakeCloudFoundryManifestConfig';
+
+describe('Bake Cloud Foundry Form Validators', () => {
+  describe('Validate Input Artifacts', () => {
+    it('should fail when given empty input artifacts', () => {
+      const inputArtifacts: IArtifact[] = [];
+      expect(validateInputArtifacts(inputArtifacts)).toBe(false);
+    });
+
+    it('should fail when given less than 2 input artifacts', () => {
+      const inputArtifacts: IArtifact[] = [
+        {
+          id: 'abc123',
+        },
+      ];
+      expect(validateInputArtifacts(inputArtifacts)).toBe(false);
+    });
+
+    it('should pass when given 2 or more input artifacts', () => {
+      const inputArtifacts: IArtifact[] = [
+        {
+          id: 'abc123',
+        },
+        {
+          id: 'abc12345',
+        },
+        {
+          id: 'abc12345678',
+        },
+      ];
+      expect(validateInputArtifacts(inputArtifacts)).toBe(true);
+    });
+  });
+  describe('Validate Expected Artifacts', () => {
+    it('should fail when expected artifacts are empty', () => {
+      const expectedArtifacts: IExpectedArtifact[] = [];
+      expect(validateProducedArtifacts(expectedArtifacts)).toBe(false);
+    });
+
+    it('should pass when there is 1 expected artifact of type base64', () => {
+      const expectedArtifacts: IExpectedArtifact[] = [
+        {
+          id: 'abc123',
+          matchArtifact: {
+            type: 'embedded/base64',
+            id: 'abc123',
+          },
+          usePriorArtifact: false,
+          useDefaultArtifact: true,
+          defaultArtifact: {
+            id: 'abc123',
+          },
+          displayName: 'temp',
+        },
+      ];
+      expect(validateProducedArtifacts(expectedArtifacts)).toBe(true);
+    });
+
+    it('should fail when there is expected artifact of wrong type', () => {
+      const expectedArtifacts: IExpectedArtifact[] = [
+        {
+          id: 'abc123',
+          matchArtifact: {
+            type: 'NOTembedded/base64',
+            id: 'abc123',
+          },
+          usePriorArtifact: false,
+          useDefaultArtifact: true,
+          defaultArtifact: {
+            id: 'abc123',
+          },
+          displayName: 'temp',
+        },
+      ];
+      expect(validateProducedArtifacts(expectedArtifacts)).toBe(false);
+    });
+  });
+});

package/src/pipeline/stages/bakeCloudFoundryManifest/bakeCloudFoundryManifestStage.ts

@@ -0,0 +1,35 @@
+import type { IArtifact, IStage } from '@spinnaker/core';
+import {
+  ArtifactReferenceService,
+  ExecutionArtifactTab,
+  ExecutionDetailsTasks,
+  ExpectedArtifactService,
+  Registry,
+} from '@spinnaker/core';
+
+import {
+  BakeCloudFoundryManifestConfig,
+  validateBakeCloudFoundryManifestStage,
+} from './BakeCloudFoundryManifestConfig';
+import { BakeCloudFoundryManifestDetailsTab } from './BakeCloudFoundryManifestDetailsTab';
+
+export const BAKE_CF_MANIFEST_STAGE_KEY = 'bakeCloudFoundryManifest';
+
+Registry.pipeline.registerStage({
+  label: 'Bake CloudFoundry Manifest',
+  description: 'Bake a CF manifest using external variables files.',
+  key: BAKE_CF_MANIFEST_STAGE_KEY,
+  component: BakeCloudFoundryManifestConfig,
+  producesArtifacts: true,
+  cloudProvider: 'cloudfoundry',
+  executionDetailsSections: [BakeCloudFoundryManifestDetailsTab, ExecutionDetailsTasks, ExecutionArtifactTab],
+  artifactExtractor: (fields: string[]) =>
+    ExpectedArtifactService.accumulateArtifacts<IArtifact>(['inputArtifacts'])(fields).map((a: IArtifact) => a.id),
+  artifactRemover: (stage: IStage, artifactId: string) => {
+    ArtifactReferenceService.removeArtifactFromFields(['expectedArtifactId'])(stage, artifactId);
+    const artifactDoesNotMatch = (artifact: IArtifact) => artifact.id !== artifactId;
+    stage.expectedArtifacts = (stage.expectedArtifacts ?? []).filter(artifactDoesNotMatch);
+    stage.inputArtifacts = (stage.inputArtifacts ?? []).filter(artifactDoesNotMatch);
+  },
+  validateFn: validateBakeCloudFoundryManifestStage,
+});

package/src/pipeline/stages/cloneServerGroup/CloudFoundryCloneServerGroupStageConfig.tsx

@@ -0,0 +1,113 @@
+import React from 'react';
+
+import type { IStageConfigProps } from '@spinnaker/core';
+import { StageConstants } from '@spinnaker/core';
+import { CloudFoundryServerGroupCommandBuilder } from '../../../serverGroup/configure';
+import { CloudFoundryCreateServerGroupModal } from '../../../serverGroup/configure/wizard/CreateServerGroupModal';
+
+export interface ICloudFoundryCloneServerGroupStageConfigState {
+  buttonText: string;
+}
+
+export class CloudFoundryCloneServerGroupStageConfig extends React.Component<
+  IStageConfigProps,
+  ICloudFoundryCloneServerGroupStageConfigState
+> {
+  constructor(props: IStageConfigProps) {
+    super(props);
+    this.props.updateStageField({
+      cloudProvider: 'cloudfoundry',
+      application: props.application.name,
+    });
+    this.state = {
+      buttonText: props.stage.destination ? 'Edit clone configuration' : 'Add clone configuration',
+    };
+  }
+
+  private handleResult = (command: any) => {
+    this.props.updateStageField({
+      credentials: command.credentials,
+      capacity: command.capacity,
+      account: command.account,
+      delayBeforeDisableSec: command.delayBeforeDisableSec,
+      freeFormDetails: command.freeFormDetails,
+      maxRemainingAsgs: command.maxRemainingAsgs,
+      region: command.region,
+      startApplication: command.startApplication,
+      stack: command.stack,
+      strategy: command.strategy,
+      target: command.target,
+      targetCluster: command.targetCluster,
+      manifest: command.manifest,
+      source: command.source,
+    });
+    this.setState({ buttonText: 'Edit clone configuration' });
+  };
+
+  private addCluster = () => {
+    const { application, stage, pipeline } = this.props;
+    const title = 'Clone Cluster';
+    const command = CloudFoundryServerGroupCommandBuilder.buildCloneServerGroupCommandFromPipeline(stage, pipeline);
+    CloudFoundryCreateServerGroupModal.show({
+      application,
+      command,
+      isSourceConstant: false,
+      title,
+    })
+      .then(this.handleResult)
+      .catch(() => {});
+  };
+
+  public render() {
+    const { stage } = this.props;
+    const { buttonText } = this.state;
+    const cloneTargets = StageConstants.TARGET_LIST;
+    return (
+      <div className="form-horizontal">
+        <div>
+          <h4>Clone Source</h4>
+          <table className="table table-condensed table-deployStage">
+            <thead>
+              <tr>
+                <th>Account</th>
+                <th>Region</th>
+                <th>Cluster</th>
+                <th>Target</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr>
+                <td>{stage.source ? stage.source.account : ''}</td>
+                <td>{stage.source ? stage.source.region : ''}</td>
+                <td>{stage.source ? stage.source.clusterName : ''}</td>
+                <td>
+                  {stage.source ? cloneTargets.filter((t) => t.val === stage.source.target).map((t) => t.label) : ''}
+                </td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <div>
+          <h4>Clone Destination</h4>
+          <table className="table table-condensed table-deployStage">
+            <thead>
+              <tr>
+                <th>Account</th>
+                <th>Region</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr>
+                <td>{stage.credentials}</td>
+                <td>{stage.region}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <button className="btn btn-block btn-sm add-new" onClick={() => this.addCluster()}>
+          <span className="glyphicon glyphicon-plus-sign" /> {buttonText}
+        </button>
+      </div>
+    );
+  }
+}

package/src/pipeline/stages/cloneServerGroup/cloudFoundryCloneServerGroupStage.module.ts

@@ -0,0 +1,14 @@
+import type { IStage } from '@spinnaker/core';
+import { Registry } from '@spinnaker/core';
+
+import { CloudFoundryCloneServerGroupStageConfig } from './CloudFoundryCloneServerGroupStageConfig';
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryCloneServerGroupStageConfig,
+  configAccountExtractor: (stage: IStage) => [stage.credentials],
+  key: 'cloneServerGroup',
+  provides: 'cloneServerGroup',
+  validators: [],
+});

package/src/pipeline/stages/createServiceBindings/CloudFoundryCreateServiceBindingsConfig.spec.tsx

@@ -0,0 +1,35 @@
+import type { ServiceBindingRequests } from './CloudFoundryCreateServiceBindingsConfig';
+import { validateServiceBindingRequests } from './CloudFoundryCreateServiceBindingsConfig';
+
+describe('Cloud Foundry Create Service Bindings Config', () => {
+  describe('validate Service Binding Requests', () => {
+    it('should return false when the array is empty', () => {
+      const bindingRequests: ServiceBindingRequests[] = [];
+      expect(validateServiceBindingRequests(bindingRequests)).toBe(false);
+    });
+
+    it('should return false when at least one serviceInstanceName is null', () => {
+      const bindingRequests: ServiceBindingRequests[] = [
+        { serviceInstanceName: 'instanceName' },
+        { serviceInstanceName: null },
+      ];
+      expect(validateServiceBindingRequests(bindingRequests)).toBe(false);
+    });
+
+    it('should return false when at least one serviceInstanceName is empty', () => {
+      const bindingRequests: ServiceBindingRequests[] = [
+        { serviceInstanceName: 'instanceName' },
+        { serviceInstanceName: '' },
+      ];
+      expect(validateServiceBindingRequests(bindingRequests)).toBe(false);
+    });
+
+    it('should return true when all serviceInstanceName are not empty', () => {
+      const bindingRequests: ServiceBindingRequests[] = [
+        { serviceInstanceName: 'instanceName' },
+        { serviceInstanceName: 'instanceName2' },
+      ];
+      expect(validateServiceBindingRequests(bindingRequests)).toBe(true);
+    });
+  });
+});