fix(batch): jobQueueName returns ARN instead of name (#25093)

`JobQueue.jobQueueName` returns the ARN. This fix parses the ARN to retrieve the name.

Closes #23018

----

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: comcalvi

packages/@aws-cdk/aws-batch-alpha/README.md

@@ -250,7 +250,7 @@ For example, if there are two shares defined as follows:
 The weight factors share the following relationship:
 
 ```math
-AvCpus / A_weight = BvCpus / B_weight
+A_{vCpus} / A_{Weight} = B_{vCpus} / B_{Weight}
 ```
 
 where `BvCpus` is the number of vCPUs allocated to jobs with share identifier `'B'`, and `B_weight` is the weight factor of `B`.
@@ -259,18 +259,33 @@ The total number of vCpus allocated to a share is equal to the amount of jobs in
 Let's say that each A job needs 32 VCpus (`A_requirement` = 32) and each B job needs 64 vCpus (`B_requirement` = 64):
 
 ```math
-A_vCpus = A_jobs * A_requirement
-B_vCpus = B_jobs * B_requirement
+A_{vCpus} = A_{Jobs} * A_{Requirement}
+```
+
+```math
+B_{vCpus} = B_{Jobs} * B_{Requirement}
 ```
 
 We have:
 
 ```math
-A_vCpus / A_weight = B_vCpus / B_weight
-A_jobs * A_requirement / A_weight = B_jobs * B_requirement / B_weight
-A_jobs * 32 / 1 = B_jobs * 64 / 1
-A_jobs * 32 = B_jobs * 64 
-A_jobs = B_jobs * 2
+A_{vCpus} / A_{Weight} = B_{vCpus} / B_{Weight}
+```
+
+```math
+A_{Jobs} * A_{Requirement} / A_{Weight} = B_{Jobs} * B_{Requirement} / B_{Weight}
+```
+
+```math
+A_{Jobs} * 32 / 1 = B_{Jobs} * 64 / 1
+```
+
+```math
+A_{Jobs} * 32 = B_{Jobs} * 64
+```
+
+```math
+A_{Jobs} = B_{Jobs} * 2
 ```
 
 Thus the scheduler will schedule two `'A'` jobs for each `'B'` job.
@@ -320,7 +335,7 @@ maximum vCPU capacity that should be reserved for shares that are *not in the qu
 The actual reserved percentage is defined by Batch as:
 
 ```math
- (computeReservation/100)^ActiveFairShares
+ (\frac{computeReservation}{100}) ^ {ActiveFairShares}
 ```
 
 where `ActiveFairShares` is the number of shares for which there exists

packages/@aws-cdk/aws-batch-alpha/lib/ecs-container-definition.ts

@@ -309,6 +309,8 @@ export interface IEcsContainerDefinition extends IConstruct {
   /**
    * The role that the container can assume.
    *
+   * @default - no jobRole
+   *
    * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html
    */
   readonly jobRole?: iam.IRole;
@@ -414,7 +416,7 @@ export interface EcsContainerDefinitionProps {
    *
    * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html
    *
-   * @default - a role will be created
+   * @default - no job role
    */
   readonly jobRole?: iam.IRole;
 

packages/@aws-cdk/aws-batch-alpha/lib/job-queue.ts

@@ -198,7 +198,7 @@ export class JobQueue extends Resource implements IJobQueue {
       resource: 'job-queue',
       resourceName: this.physicalName,
     });
-    this.jobQueueName = this.getResourceNameAttribute(resource.ref);
+    this.jobQueueName = Stack.of(this).splitArn(this.jobQueueArn, ArnFormat.SLASH_RESOURCE_NAME).resourceName!;
 
     this.node.addValidation({ validate: () => validateOrderedComputeEnvironments(this.computeEnvironments) });
   }
@@ -221,5 +221,5 @@ function validateOrderedComputeEnvironments(computeEnvironments: OrderedComputeE
     seenOrders.push(ce.order);
   }
 
-  return [];
+  return seenOrders.length === 0 ? ['This JobQueue does not link any ComputeEnvironments'] : [];
 }

packages/@aws-cdk/aws-batch-alpha/test/job-queue.test.ts

@@ -1,5 +1,5 @@
 import { Template } from 'aws-cdk-lib/assertions';
-import { Stack } from 'aws-cdk-lib';
+import { DefaultTokenResolver, Stack, StringConcat, Tokenization } from 'aws-cdk-lib';
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import { FairshareSchedulingPolicy, JobQueue, ManagedEc2EcsComputeEnvironment } from '../lib';
 
@@ -87,6 +87,55 @@ test('JobQueue respects name', () => {
   });
 });
 
+test('JobQueue name is parsed from arn', () => {
+  // GIVEN
+  const stack = new Stack();
+  const vpc = new ec2.Vpc(stack, 'vpc');
+
+  // WHEN
+  const queue = new JobQueue(stack, 'joBBQ', {
+    computeEnvironments: [{
+      computeEnvironment: new ManagedEc2EcsComputeEnvironment(stack, 'CE', {
+        vpc,
+      }),
+      order: 1,
+    }],
+    priority: 10,
+    jobQueueName: 'JoBBQ',
+  });
+
+  // THEN
+  expect(Tokenization.resolve(queue.jobQueueName, {
+    scope: stack,
+    resolver: new DefaultTokenResolver(new StringConcat()),
+  })).toEqual({
+    'Fn::Select': [
+      1,
+      {
+        'Fn::Split': [
+          '/',
+          {
+            'Fn::Select': [
+              5,
+              {
+                'Fn::Split': [
+                  ':',
+                  {
+                    'Fn::GetAtt': [
+                      'joBBQ74605869',
+                      'JobQueueArn',
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  });
+});
+
 test('JobQueue respects schedulingPolicy', () => {
   // GIVEN
   const stack = new Stack();
@@ -199,3 +248,15 @@ test('JobQueue throws when the same order is assigned to multiple ComputeEnviron
     Template.fromStack(stack);
   }).toThrow(/assigns the same order to different ComputeEnvironments/);
 });
+
+test('JobQueue throws when there are no linked ComputeEnvironments', () => {
+  // GIVEN
+  const stack = new Stack();
+
+  // WHEN
+  new JobQueue(stack, 'joBBQ');
+
+  expect(() => {
+    Template.fromStack(stack);
+  }).toThrow(/This JobQueue does not link any ComputeEnvironments/);
+});