### Define OpenStack BAT Deployment Manifest

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Example configuration for an OpenStack deployment using dynamic networking.

```yaml
---
cpi: openstack
properties:
  stemcell:
    name: bosh-openstack-kvm-ubuntu-trusty-go_agent
    version: latest
  instances: 1
  instance_type: some-ephemeral
  availability_zone: az1 # (optional)
  flavor_with_no_ephemeral_disk: no-ephemeral
  vip: 0.0.0.43 # Virtual (public/floating) IP assigned to the bat-release job vm ('static' network), for ssh testing
  networks:
  - name: default
    type: dynamic
    cloud_properties:
      net_id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx # Network ID
      security_groups: ['default'] # security groups assigned to deployed VMs
  key_name: bosh # (optional) SSH keypair name, overrides the director's default_key_name setting
```

--------------------------------

### vSphere Deployment Specification

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Configuration for running BATs against vSphere infrastructure. This example specifies manual networking settings.

```yaml
---
cpi: vsphere
properties:
  stemcell:
    name: bosh-vsphere-esxi-ubuntu-trusty-go_agent
    version: latest
  instances: 1
  second_static_ip: 192.168.79.62
  datacenters:
  - name: myDC
    clusters:
    - myClusterName:
        resource_pool: myRP
  networks:
  - name: static
    type: manual
    static_ip: 192.168.79.61
    cidr: 192.168.79.0/24
    reserved: ['192.168.79.2 - 192.168.79.50', '192.168.79.128 - 192.168.79.254']
    static: ['192.168.79.60 - 192.168.79.70']
    gateway: 192.168.79.1
    vlan: Network_Name
```

--------------------------------

### AWS Deployment Specification (bat.yml)

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Configure infrastructure-specific settings for running BATs against AWS. This example demonstrates manual networking with IPv6 support.

```yaml
---
cpi: aws
properties:
  stemcell:
    name: bosh-aws-xen-ubuntu-trusty-go_agent
    version: latest
  instances: 1
  ssh_gateway:
    host: jumpbox.example.com
    username: vcap
  ssh_key_pair:
    public_key: "ssh-rsa AAAAB3..."
    private_key: |
      -----BEGIN RSA PRIVATE KEY-----
      MIIEpAIBAAKCAQEA...
      -----END RSA PRIVATE KEY-----
  vip: 54.54.54.54
  second_static_ip: 10.10.0.31
  networks:
  - name: default
    type: manual
    static_ip: 10.10.0.30
    cidr: 10.10.0.0/24
    reserved: ['10.10.0.2 - 10.10.0.9']
    static: ['10.10.0.10 - 10.10.0.31']
    gateway: 10.10.0.1
    subnet: subnet-xxxxxxxx
    security_groups: 'bat'
  - name: second
    type: manual
    static_ip: 10.10.0.50
    cidr: 10.10.0.0/24
    reserved: ['10.10.0.33 - 10.10.0.39']
    static: ['10.10.0.40 - 10.10.0.51']
    gateway: 10.10.0.1
    subnet: subnet-yyyyyyyy
    security_groups: 'bat'
  key_name: bosh
```

--------------------------------

### Define AWS BAT Deployment Manifest

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Example configuration for an AWS deployment using manual networking, including IPv6 and multiple network interfaces.

```yaml
---
cpi: aws
properties:
  stemcell:
    name: bosh-aws-xen-ubuntu-trusty-go_agent
    version: latest
  instances: 1
  ssh_gateway:
    host: "jumpbox_host" # optional host used to provide tunnel when the tests need to ssh to VMs
    username: "jumpbox_username" # optional username used to provide tunnel when the tests need to ssh to VMs
  ssh_key_pair:
    public_key: "public_key_string" # used when deploying VMs to allow direct ssh access
    private_key: "private_key_string" # used to ssh into bosh deployed VMs and the gateway host
  vip: 54.54.54.54 # elastic ip for bat deployed VM
  second_static_ip: 10.10.0.31 # Secondary (private) IP to use for reconfiguring networks, must be in the primary network & different from static_ip
  networks:
  - name: default
    type: manual
    static_ip: 10.10.0.30
    cidr: 10.10.0.0/24
    reserved: ['10.10.0.2 - 10.10.0.9']
    static: ['10.10.0.10 - 10.10.0.31']
    gateway: 10.10.0.1
    subnet: subnet-xxxxxxxx # VPC subnet
    security_groups: 'bat' # VPC security groups
    nic_group: 1
  - name: second
    type: manual
    static_ip: 10.10.0.50
    cidr: 10.10.0.0/24
    reserved: ['10.10.0.33 - 10.10.0.39']
    static: ['10.10.0.40 - 10.10.0.51']
    gateway: 10.10.0.1
    subnet: subnet-xxxxxxxx
    security_groups: 'bat'
    nic_group: 2
  - name: ipv6
    type: manual
    static_ip: 2001:db8:abcd:1234::30
    cidr: 2001:db8:abcd:1234::/56
    reserved: ['2001:db8:abcd:1234::2 - 2001:db8:abcd:1234::f']
    static: [2001:db8:abcd:1234::10 - 2001:db8:abcd:1234::31]
    gateway: 2001:db8:abcd:1234::1
    subnet: subnet-xxxxxxxx
    security_groups: 'bat'
    nic_group: 1
  - name: prefix
    type: manual
    cidr: 2001:db8:abcd:1234::/56
    reserved: ['2001:db8:abcd:1234::2 - 2001:db8:abcd:1234::f']
    gateway: 2001:db8:abcd:1234::1
    prefix: 80
    subnet: subnet-xxxxxxxx
    security_groups: 'bat'
    nic_group: 1
  key_name: bosh # (optional) SSH keypair name, overrides the director's default_key_name setting
```

--------------------------------

### Generate AWS Cloud Configuration

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Use `Bat::CloudConfig` to generate infrastructure-specific cloud configurations. This example shows generating a configuration for AWS, including network settings, instance type, and availability zone.

```ruby
require 'bat/cloud_config'

# Specification for AWS
spec = {
  'cpi' => 'aws',
  'properties' => {
    'networks' => [{
      'name' => 'default',
      'type' => 'manual',
      'cidr' => '10.10.0.0/24',
      'gateway' => '10.10.0.1',
      'subnet' => 'subnet-xxxxxxxx',
      'security_groups' => 'bat'
    }],
    'instance_type' => 'm4.large',
    'availability_zone' => 'us-east-1a'
  }
}

# Generate cloud config (uses templates/cloud_config_aws.yml.erb)
cloud_config = Bat::CloudConfig.new(spec)

puts cloud_config.to_path  # Path to generated cloud config file

# Apply to director
bosh_runner.bosh("update-cloud-config #{cloud_config.to_path}")
```

--------------------------------

### Configure Deployment with Bat::DeploymentHelper

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

The `Bat::DeploymentHelper` module provides a DSL for configuring deployments in RSpec tests. It allows setting up networking, persistent disks, instance counts, and job configurations.

```ruby
# In RSpec test
describe 'deployment tests' do
  include Bat::DeploymentHelper

  before(:each) do
    load_deployment_spec

    # Configure networking
    use_static_ip
    use_vip
    use_multiple_manual_networks

    # Configure persistent storage
    use_persistent_disk(1024)  # Single disk in MB
    use_multiple_persistent_disks(5120, 4096)  # Multiple disks

    # Configure instances
    use_instance_count(2)
    use_deployment_name('my-bat')
    use_instance_group('batlight')
    use_jobs(['batlight', 'batarang'])

    # Deployment configuration helpers
    use_canaries(1)
    use_pool_size(2)
    use_raw_instance_storage
    use_flavor_with_no_ephemeral_disk
  end

  it 'deploys successfully' do
    deployment = with_deployment
    expect(bosh("-d #{deployment.name} deploy #{deployment.to_path}")).to succeed

    # Get deployment info
    puts deployment_name     # => "my-bat"
    puts static_ip           # => "10.10.0.30"
    puts public_ip           # => "54.54.54.54" (VIP or static)
    puts static_ips          # => ["10.10.0.30", "192.168.0.30"]
  end
end
```

--------------------------------

### Local Testing with Warden (bosh-lite) Execution Script

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

A bash script to set up the environment and run BATs against a local bosh-lite director. It sources environment variables and configures BAT settings.

```bash
#!/bin/bash
# Local test execution script

# Source environment for local vbox director
source ~/deployments/vbox/.envrc

# Configure BAT environment
export BAT_INFRASTRUCTURE=warden
export BAT_STEMCELL=~/deployments/stemcells/bosh-stemcell-latest.tgz
export BAT_DEPLOYMENT_SPEC=./bats-warden.yml
export BAT_BOSH_CLI=$(which bosh)
export BAT_PRIVATE_KEY=$(bosh int ~/deployments/vbox/creds.yml --path /jumpbox_ssh/private_key)

# Run tests excluding unsupported features
bundle exec rspec spec/system \
  --tag ~multiple_manual_networks \
  --tag ~root_partition \
  --tag ~reboot \
  --tag ~raw_ephemeral_storage \
  --tag ~changing_static_ip
```

--------------------------------

### Manage Releases with Bat::Release

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Use Bat::Release to load release manifests from a directory and retrieve version information.

```ruby
require 'bat/release'

# Load release from directory containing release manifests
release = Bat::Release.from_path('/path/to/bat-release')

puts release.name           # => "bat"
puts release.version        # => "4" (latest version)
puts release.to_s           # => "bat-4"
puts release.sorted_versions # => ["1", "2", "3", "4"]
puts release.to_path        # => "/path/to/bat-release/releases/bat-4.yml"

# Create release reference
release = Bat::Release.new('bat', ['1', '2', '3', '4'], '/path/to/bat-release')
```

--------------------------------

### Generate Deployment Manifests

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

The Bat::Deployment class is used to generate BOSH deployment manifests from ERB templates.

```ruby
require 'bat/deployment'
```

--------------------------------

### Local Testing with Warden (bosh-lite) Configuration

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Configuration for running BATs against a local bosh-lite director using Warden CPI. This includes the deployment specification file.

```yaml
# bats-warden.yml
---
cpi: warden
properties:
  instances: 1
  networks:
  - name: default
  stemcell:
    name: bosh-warden-boshlite-ubuntu-xenial-go_agent
    version: latest
  persistent_disk: 1024
```

--------------------------------

### Configure BOSH v2 CLI Environment Variables

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Variables required for the BOSH CLI to authenticate and connect to the BOSH Director.

```bash
export BOSH_ENVIRONMENT=<director ip or alias to bosh-env>
export BOSH_CLIENT=<director username>
export BOSH_CLIENT_SECRET=<director password>
export BOSH_CA_CERT=<director ca cert content or path>
export BOSH_ALL_PROXY=<socks5 proxy url needed to connect to bosh or deployed vms>
```

--------------------------------

### Perform BOSH SSH Operations with Bat::BoshHelper

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

The `Bat::BoshHelper` module offers methods for SSH access to deployed VMs and infrastructure detection. It supports BOSH CLI-based SSH and direct SSH with gateway options.

```ruby
# In RSpec test
include Bat::BoshHelper

# SSH to deployed VM via BOSH CLI
result = bosh_ssh('batlight', 0, 'hostname',
  deployment: 'bat',
  result: true,
  column: 'stdout'
)
puts result.output  # => "batlight/abc123-..."

# Direct SSH with gateway support
options = {
  private_key: '-----BEGIN RSA PRIVATE KEY-----...', 
  gateway_host: 'jumpbox.example.com',
  gateway_username: 'vcap',
  gateway_private_key: '-----BEGIN RSA PRIVATE KEY-----...'
}
output = ssh('10.10.0.30', 'vcap', 'uptime', options)

# Check infrastructure type
aws?       # => true if BAT_INFRASTRUCTURE=aws
openstack? # => true if BAT_INFRASTRUCTURE=openstack
vsphere?   # => true if BAT_INFRASTRUCTURE=vsphere
warden?    # => true if BAT_INFRASTRUCTURE=warden

# Wait for instance state
wait_for_process_state('batlight', 0, 'running', 300)
wait_for_instance_state('batlight', 0, 'started', 300)

# Get instance information
instance_ips = get_instance_ips
# => {"batlight/abc123-..." => ["10.10.0.30", "192.168.0.30"]}

# Check persistent disk
disk_blocks = persistent_disk('batlight', 0, {deployment: 'bat', ...})
```

--------------------------------

### Generate BOSH Deployment Manifest

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Use `Bat::Deployment` to generate a BOSH deployment manifest from a specification. The manifest is saved to a temporary file and can be cleaned up automatically or kept for debugging.

```ruby
spec = {
  'properties' => {
    'name' => 'bat',
    'instances' => 1,
    'stemcell' => {
      'name' => 'bosh-aws-xen-ubuntu-trusty-go_agent',
      'version' => 'latest'
    },
    'job_networks' => [
      { 'name' => 'default', 'type' => 'manual', 'static_ip' => '10.10.0.30' }
    ],
    'ssh_key_pair' => {
      'public_key' => 'ssh-rsa AAAA...',
      'private_key' => '-----BEGIN RSA PRIVATE KEY-----...'
    }
  }
}

# Generate deployment manifest
deployment = Bat::Deployment.new(spec)

puts deployment.name     # => "bat"
puts deployment.to_path  # => "/tmp/deployment123/deployment" (temp file path)

# Clean up generated manifest
deployment.delete

# Keep manifest for debugging (set BAT_MANIFEST=keep)
ENV['BAT_MANIFEST'] = 'keep'
```

--------------------------------

### Configure Manual Networking for OpenStack

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Defines the deployment properties for an OpenStack environment using manual networking with primary and secondary network interfaces.

```yaml
---
cpi: openstack
properties:
  stemcell:
    name: bosh-openstack-kvm-ubuntu-trusty-go_agent
    version: latest
  instances: 1
  instance_type: some-ephemeral
  flavor_with_no_ephemeral_disk: no-ephemeral
  vip: 0.0.0.43 # Virtual (public/floating) IP assigned to the bat-release job vm ('static' network), for ssh testing
  second_static_ip: 10.253.3.29 # Secondary (private) IP to use for reconfiguring networks, must be in the primary network & different from static_ip
  networks:
  - name: default
    type: manual
    static_ip: 10.0.1.30 # Primary (private) IP assigned to the bat-release job vm (primary NIC), must be in the primary static range
    cloud_properties:
      net_id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx # Primary Network ID
      security_groups: ['default'] # Security groups assigned to deployed VMs
    cidr: 10.0.1.0/24
    reserved: ['10.0.1.2 - 10.0.1.9']
    static: ['10.0.1.10 - 10.0.1.30']
    gateway: 10.0.1.1
  - name: second # Secondary network for testing jobs with multiple manual networks
    type: manual
    static_ip: 192.168.0.30 # Secondary (private) IP assigned to the bat-release job vm (secondary NIC)
    cloud_properties:
      net_id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx # Secondary Network ID
      security_groups: ['default'] # Security groups assigned to deployed VMs
    cidr: 192.168.0.0/24
    reserved: ['192.168.0.2 - 192.168.0.9']
    static: ['192.168.0.10 - 192.168.0.30']
    gateway: 192.168.0.1
  password: hash # (optional) vcap password hash
```

--------------------------------

### Configure BAT Environment Variables

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Required environment variables for running BOSH Acceptance Tests, including paths to stemcells and deployment specifications.

```bash
# path to the stemcell you want to use for testing
export BAT_STEMCELL=

# path to the bat yaml file which is used to generate the deployment manifest (see below `bat.yml`)
export BAT_DEPLOYMENT_SPEC=

# BOSH CLI executable path
export BAT_BOSH_CLI=bosh

# the name of infrastructure that is used by bosh deployment. Examples: aws, vsphere, openstack, warden, oci.
export BAT_INFRASTRUCTURE=

# Run tests with --fail-fast and skip cleanup in case of failure (optional)
export BAT_DEBUG_MODE=
```

--------------------------------

### OpenStack Deployment Specification

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Configuration for running BATs against OpenStack with manual networking. Includes settings for instance type, availability zone, and network details.

```yaml
---
cpi: openstack
properties:
  stemcell:
    name: bosh-openstack-kvm-ubuntu-trusty-go_agent
    version: latest
  instances: 1
  instance_type: some-ephemeral
  availability_zone: az1
  flavor_with_no_ephemeral_disk: no-ephemeral
  vip: 0.0.0.43
  second_static_ip: 10.253.3.29
  networks:
  - name: default
    type: manual
    static_ip: 10.0.1.30
    cloud_properties:
      net_id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
      security_groups: ['default']
    cidr: 10.0.1.0/24
    reserved: ['10.0.1.2 - 10.0.1.9']
    static: ['10.0.1.10 - 10.0.1.30']
    gateway: 10.0.1.1
  - name: second
    type: manual
    static_ip: 192.168.0.30
    cloud_properties:
      net_id: yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy
      security_groups: ['default']
    cidr: 192.168.0.0/24
    reserved: ['192.168.0.2 - 192.168.0.9']
    static: ['192.168.0.10 - 192.168.0.30']
    gateway: 192.168.0.1
  password: $6$encrypted_hash
```

--------------------------------

### Manage BOSH Requirements with Bat::Requirements

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

The `Bat::Requirements` class handles test prerequisites like stemcell and release uploads, and deployments. It ensures requirements are met before proceeding with tests.

```ruby
require 'bat/requirements'

logger = Logger.new(STDOUT)
env = Bat::Env.from_env
spec_state = Bat::SpecState.new(env.debug_mode)
bosh_runner = Bat::BoshRunner.new(env.bosh_cli_path, logger)

requirements = Bat::Requirements.new(env.stemcell_path, bosh_runner, spec_state, logger)

# Ensure stemcell is uploaded (uploads if not present)
requirements.requirement(requirements.stemcell)

# Ensure release is uploaded
requirements.requirement(requirements.release)

# Deploy if not already deployed
deployment = Bat::Deployment.new(spec)
requirements.requirement(deployment, spec)

# Force redeploy even if deployed
requirements.requirement(deployment, spec, force: true)
```

--------------------------------

### Run BOSH Acceptance Tests with RSpec

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Use RSpec with tags to selectively run infrastructure-specific tests. This is useful for filtering tests by functionality like networking or persistent disks.

```bash
# Install dependencies
bundle install
```

```bash
# Run all tests
bundle exec rspec spec/system
```

```bash
# Run with specific tags
bundle exec rspec spec/system --tag core
bundle exec rspec spec/system --tag persistent_disk
bundle exec rspec spec/system --tag manual_networking
```

```bash
# Exclude tags (for unsupported features)
bundle exec rspec spec/system \
  --tag ~vip_networking \
  --tag ~dynamic_networking \
  --tag ~root_partition \
  --tag ~raw_ephemeral_storage
```

```bash
# Run specific test file
bundle exec rspec spec/system/network_configuration_spec.rb
```

```bash
# Run with fail-fast for debugging
BAT_DEBUG_MODE=true bundle exec rspec spec/system
```

--------------------------------

### Configure vSphere Deployment

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Specifies the deployment properties for vSphere, including datacenter clusters and manual network configuration.

```yaml
---
cpi: vsphere
properties:
  stemcell:
    name: bosh-vsphere-esxi-ubuntu-trusty-go_agent
    version: latest
  instances: 1
  second_static_ip: 192.168.79.62 # Secondary (private) IP assigned to the bat-release job vm, used for testing network reconfiguration, must be in the primary network & different from static_ip
  datacenters:  # This whole block is optional, and the format should match what the CPI expects in an AZ's datacenters configuration block
  - name: myDC
    clusters:
    - myClusterName:
        resource_pool: myRP
  networks:
  - name: static
    type: manual
    static_ip: 192.168.79.61 # Primary (private) IP assigned to the bat-release job vm, must be in the static range
    cidr: 192.168.79.0/24
    reserved: ['192.168.79.2 - 192.168.79.50', '192.168.79.128 - 192.168.79.254'] # multiple reserved ranges are allowed but optional
    static: ['192.168.79.60 - 192.168.79.70']
    gateway: 192.168.79.1
    vlan: Network_Name # vSphere network name
```

--------------------------------

### Configure BATs Environment Variables

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Set these environment variables before running tests to define the target infrastructure, stemcell path, and BOSH CLI connection details.

```bash
# Required environment variables for BAT execution
export BAT_STEMCELL=/path/to/stemcell.tgz
export BAT_DEPLOYMENT_SPEC=/path/to/bat.yml
export BAT_BOSH_CLI=bosh
export BAT_INFRASTRUCTURE=aws  # aws, vsphere, openstack, warden, oci

# Optional debug mode - enables fail-fast and skips cleanup on failure
export BAT_DEBUG_MODE=true

# BOSH CLI connection variables
export BOSH_ENVIRONMENT=192.168.50.6
export BOSH_CLIENT=admin
export BOSH_CLIENT_SECRET=password
export BOSH_CA_CERT=/path/to/ca-cert.pem
```

--------------------------------

### Run BATs with exclusions

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Execute tests while skipping specific features not supported by the target IaaS.

```bash
bundle exec rspec spec --tag ~vip_networking --tag ~dynamic_networking --tag ~root_partition --tag ~raw_ephemeral_storage
```

--------------------------------

### Manage Stemcells with Bat::Stemcell

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

The Bat::Stemcell class handles loading metadata from tarballs or creating references for existing stemcells.

```ruby
require 'bat/stemcell'

# Load stemcell from tarball path
stemcell = Bat::Stemcell.from_path('/path/to/bosh-stemcell-3468.17-aws-xen-ubuntu-trusty-go_agent.tgz')

puts stemcell.name     # => "bosh-aws-xen-ubuntu-trusty-go_agent"
puts stemcell.version  # => "3468.17"
puts stemcell.cpi      # => "aws"
puts stemcell.to_s     # => "bosh-aws-xen-ubuntu-trusty-go_agent-3468.17"

# Create stemcell reference directly
stemcell = Bat::Stemcell.new('bosh-warden-boshlite-ubuntu-xenial-go_agent', 'latest')

# Compare stemcells
stemcell1 == stemcell2  # Compares by name-version string
```

--------------------------------

### Configure Oracle Cloud Infrastructure (OCI) Networking

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Defines the BAT deployment specification for OCI, requiring specific VCN and subnet cloud properties.

```yaml

---
cpi: oci 
properties:
  stemcell:
    name: light-oracle-ubuntu-stemcell 
    version: latest
  instances: 1
  instance_shape: 'VM.Standard1.2' # Instance shape
  availability_domain: WZYX:PHX-AD-3 

  networks:
  - name: default
    type: manual
    static_ip: 10.0.X.30 # Primary (private) IP assigned to the bat-release job vm (primary NIC), must be in the primary static range
    cloud_properties:
      vcn: cloudfoundry_vcn 
      subnet: private_subnet_ad3 
    cidr: 10.0.X.0/24 # CIDR bock of the subnet
    reserved: ['10.0.X.2 - 10.0.X.9'] # 
    static: ['10.0.X.10 - 10.0.X.30']
    gateway: 10.0.X.1
  - name: second # Secondary network for testing jobs with multiple manual networks
    type: manual
    static_ip: 10.0.Y.30 # Must be in the static range defined below
    cloud_properties:
      vcn: cloudfoundry_vcn 
      subnet: private_subnet_ad3_for_bats 
    cidr: 10.0.Y.0/24
    reserved: ['10.0.Y.2 - 10.0.Y.9']
    static: ['10.0.Y.10 - 10.0.Y.30']
    gateway: 10.0.Y.1
```

--------------------------------

### Execute BOSH CLI Commands with BoshRunner

Source: https://context7.com/cloudfoundry/bosh-acceptance-tests/llms.txt

Use the Bat::BoshRunner class to wrap BOSH CLI operations, providing built-in error handling and JSON parsing for command outputs.

```ruby
require 'bat/bosh_runner'

# Initialize the runner
logger = Logger.new(STDOUT)
bosh_runner = Bat::BoshRunner.new('/usr/local/bin/bosh', logger)

# Execute a BOSH command with JSON output (default)
result = bosh_runner.bosh('deployments')
deployments = JSON.parse(result.output)["Tables"][0]["Rows"]
# => [{"name" => "bat", "release_s" => "bat/4", ...}]

# Execute a command for a specific deployment
result = bosh_runner.bosh('instances --details', deployment: 'bat')

# Safe execution that returns on error instead of raising
result = bosh_runner.bosh_safe('delete-deployment --force', deployment: 'bat')
if result.exit_status == 0
  puts "Deployment deleted successfully"
end

# List all releases uploaded to director
releases = bosh_runner.releases
# => [#<Bat::Release name="bat" versions=["4"]>]

# List all stemcells
stemcells = bosh_runner.stemcells
# => [#<Bat::Stemcell name="bosh-aws-xen-ubuntu-trusty-go_agent" version="3468.17">]
```

--------------------------------

### Run specific BATs

Source: https://github.com/cloudfoundry/bosh-acceptance-tests/blob/master/README.md

Execute only the tests associated with the provided tags.

```bash
bundle exec rspec spec --tag manual_networking --tag dynamic_networking
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.