@aws-cdk/aws-iam - npm Package Compare versions

Comparing version 1.3.0 to 1.4.0

lib/group.d.ts

@@ -37,5 +37,6 @@ import { Construct, Resource } from '@aws-cdk/core';
     /**
-     * A list managed policies associated with this role.
+     * A list of managed policies associated with this role.
      *
-     * You can add managed policies later using `attachManagedPolicy(policy)`.
+     * You can add managed policies later using
+     * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.
      *
@@ -42,0 +43,0 @@ * @default - No managed policies.

lib/group.js

@@ -87,2 +87,5 @@ "use strict";
     addManagedPolicy(policy) {
+        if (this.managedPolicies.find(mp => mp === policy)) {
+            return;
+        }
         this.managedPolicies.push(policy);
@@ -92,2 +95,2 @@ }
 exports.Group = Group;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group.js","sourceRoot":"","sources":["group.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, Lazy, Resource, Stack } from '@aws-cdk/core';\nimport { CfnGroup } from './iam.generated';\nimport { IIdentity } from './identity-base';\nimport { IManagedPolicy } from './managed-policy';\nimport { Policy } from './policy';\nimport { PolicyStatement } from './policy-statement';\nimport { ArnPrincipal, IPrincipal, PrincipalPolicyFragment } from './principals';\nimport { IUser } from './user';\nimport { AttachedPolicies } from './util';\n\nexport interface IGroup extends IIdentity {\n  /**\n   * Returns the IAM Group Name\n   *\n   * @attribute\n   */\n  readonly groupName: string;\n\n  /**\n   * Returns the IAM Group ARN\n   *\n   * @attribute\n   */\n  readonly groupArn: string;\n}\n\nexport interface GroupProps {\n  /**\n   * A name for the IAM group. For valid values, see the GroupName parameter\n   * for the CreateGroup action in the IAM API Reference. If you don't specify\n   * a name, AWS CloudFormation generates a unique physical ID and uses that\n   * ID for the group name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   *\n   * @default Generated by CloudFormation (recommended)\n   */\n  readonly groupName?: string;\n\n  /**\n   * A list managed policies associated with this role.\n   *\n   * You can add managed policies later using `attachManagedPolicy(policy)`.\n   *\n   * @default - No managed policies.\n   */\n  readonly managedPolicies?: IManagedPolicy[];\n\n  /**\n   * The path to the group. For more information about paths, see [IAM\n   * Identifiers](http://docs.aws.amazon.com/IAM/latest/UserGuide/index.html?Using_Identifiers.html)\n   * in the IAM User Guide.\n   *\n   * @default /\n   */\n  readonly path?: string;\n}\n\nabstract class GroupBase extends Resource implements IGroup {\n  public abstract readonly groupName: string;\n  public abstract readonly groupArn: string;\n\n  public readonly grantPrincipal: IPrincipal = this;\n  public readonly assumeRoleAction: string = 'sts:AssumeRole';\n\n  private readonly attachedPolicies = new AttachedPolicies();\n  private defaultPolicy?: Policy;\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new ArnPrincipal(this.groupArn).policyFragment;\n  }\n\n  /**\n   * Attaches a policy to this group.\n   * @param policy The policy to attach.\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToGroup(this);\n  }\n\n  public addManagedPolicy(_policy: IManagedPolicy) {\n    // drop\n  }\n\n  /**\n   * Adds a user to this group.\n   */\n  public addUser(user: IUser) {\n    user.addToGroup(this);\n  }\n\n  /**\n   * Adds an IAM statement to the default policy.\n   */\n  public addToPolicy(statement: PolicyStatement): boolean {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.defaultPolicy.attachToGroup(this);\n    }\n\n    this.defaultPolicy.addStatements(statement);\n    return true;\n  }\n}\n\nexport class Group extends GroupBase {\n\n  /**\n   * Imports a group from ARN\n   * @param groupArn (e.g. `arn:aws:iam::account-id:group/group-name`)\n   */\n  public static fromGroupArn(scope: Construct, id: string, groupArn: string): IGroup {\n    const groupName = Stack.of(scope).parseArn(groupArn).resourceName!;\n    class Import extends GroupBase {\n      public groupName = groupName;\n      public groupArn = groupArn;\n    }\n\n    return new Import(scope, id);\n  }\n\n  public readonly groupName: string;\n  public readonly groupArn: string;\n\n  private readonly managedPolicies: IManagedPolicy[] = [];\n\n  constructor(scope: Construct, id: string, props: GroupProps = {}) {\n    super(scope, id, {\n      physicalName: props.groupName,\n    });\n\n    this.managedPolicies.push(...props.managedPolicies || []);\n\n    const group = new CfnGroup(this, 'Resource', {\n      groupName: this.physicalName,\n      managedPolicyArns: Lazy.listValue({ produce: () => this.managedPolicies.map(p => p.managedPolicyArn) }, { omitEmpty: true }),\n      path: props.path,\n    });\n\n    this.groupName = this.getResourceNameAttribute(group.ref);\n    this.groupArn = this.getResourceArnAttribute(group.attrArn, {\n      region: '', // IAM is global in each partition\n      service: 'iam',\n      resource: 'group',\n      resourceName: this.physicalName,\n    });\n  }\n\n  /**\n   * Attaches a managed policy to this group.\n   * @param policy The managed policy to attach.\n   */\n  public addManagedPolicy(policy: IManagedPolicy) {\n    this.managedPolicies.push(policy);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group.js","sourceRoot":"","sources":["group.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, Lazy, Resource, Stack } from '@aws-cdk/core';\nimport { CfnGroup } from './iam.generated';\nimport { IIdentity } from './identity-base';\nimport { IManagedPolicy } from './managed-policy';\nimport { Policy } from './policy';\nimport { PolicyStatement } from './policy-statement';\nimport { ArnPrincipal, IPrincipal, PrincipalPolicyFragment } from './principals';\nimport { IUser } from './user';\nimport { AttachedPolicies } from './util';\n\nexport interface IGroup extends IIdentity {\n  /**\n   * Returns the IAM Group Name\n   *\n   * @attribute\n   */\n  readonly groupName: string;\n\n  /**\n   * Returns the IAM Group ARN\n   *\n   * @attribute\n   */\n  readonly groupArn: string;\n}\n\nexport interface GroupProps {\n  /**\n   * A name for the IAM group. For valid values, see the GroupName parameter\n   * for the CreateGroup action in the IAM API Reference. If you don't specify\n   * a name, AWS CloudFormation generates a unique physical ID and uses that\n   * ID for the group name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   *\n   * @default Generated by CloudFormation (recommended)\n   */\n  readonly groupName?: string;\n\n  /**\n   * A list of managed policies associated with this role.\n   *\n   * You can add managed policies later using\n   * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.\n   *\n   * @default - No managed policies.\n   */\n  readonly managedPolicies?: IManagedPolicy[];\n\n  /**\n   * The path to the group. For more information about paths, see [IAM\n   * Identifiers](http://docs.aws.amazon.com/IAM/latest/UserGuide/index.html?Using_Identifiers.html)\n   * in the IAM User Guide.\n   *\n   * @default /\n   */\n  readonly path?: string;\n}\n\nabstract class GroupBase extends Resource implements IGroup {\n  public abstract readonly groupName: string;\n  public abstract readonly groupArn: string;\n\n  public readonly grantPrincipal: IPrincipal = this;\n  public readonly assumeRoleAction: string = 'sts:AssumeRole';\n\n  private readonly attachedPolicies = new AttachedPolicies();\n  private defaultPolicy?: Policy;\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new ArnPrincipal(this.groupArn).policyFragment;\n  }\n\n  /**\n   * Attaches a policy to this group.\n   * @param policy The policy to attach.\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToGroup(this);\n  }\n\n  public addManagedPolicy(_policy: IManagedPolicy) {\n    // drop\n  }\n\n  /**\n   * Adds a user to this group.\n   */\n  public addUser(user: IUser) {\n    user.addToGroup(this);\n  }\n\n  /**\n   * Adds an IAM statement to the default policy.\n   */\n  public addToPolicy(statement: PolicyStatement): boolean {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.defaultPolicy.attachToGroup(this);\n    }\n\n    this.defaultPolicy.addStatements(statement);\n    return true;\n  }\n}\n\nexport class Group extends GroupBase {\n\n  /**\n   * Imports a group from ARN\n   * @param groupArn (e.g. `arn:aws:iam::account-id:group/group-name`)\n   */\n  public static fromGroupArn(scope: Construct, id: string, groupArn: string): IGroup {\n    const groupName = Stack.of(scope).parseArn(groupArn).resourceName!;\n    class Import extends GroupBase {\n      public groupName = groupName;\n      public groupArn = groupArn;\n    }\n\n    return new Import(scope, id);\n  }\n\n  public readonly groupName: string;\n  public readonly groupArn: string;\n\n  private readonly managedPolicies: IManagedPolicy[] = [];\n\n  constructor(scope: Construct, id: string, props: GroupProps = {}) {\n    super(scope, id, {\n      physicalName: props.groupName,\n    });\n\n    this.managedPolicies.push(...props.managedPolicies || []);\n\n    const group = new CfnGroup(this, 'Resource', {\n      groupName: this.physicalName,\n      managedPolicyArns: Lazy.listValue({ produce: () => this.managedPolicies.map(p => p.managedPolicyArn) }, { omitEmpty: true }),\n      path: props.path,\n    });\n\n    this.groupName = this.getResourceNameAttribute(group.ref);\n    this.groupArn = this.getResourceArnAttribute(group.attrArn, {\n      region: '', // IAM is global in each partition\n      service: 'iam',\n      resource: 'group',\n      resourceName: this.physicalName,\n    });\n  }\n\n  /**\n   * Attaches a managed policy to this group.\n   * @param policy The managed policy to attach.\n   */\n  public addManagedPolicy(policy: IManagedPolicy) {\n    if (this.managedPolicies.find(mp => mp === policy)) { return; }\n    this.managedPolicies.push(policy);\n  }\n}\n"]}

lib/managed-policy.d.ts

@@ -0,1 +1,7 @@
+import { Construct, Resource } from '@aws-cdk/core';
+import { IGroup } from './group';
+import { PolicyDocument } from './policy-document';
+import { PolicyStatement } from './policy-statement';
+import { IRole } from './role';
+import { IUser } from './user';
 /**
@@ -7,13 +13,76 @@ * A managed policy
      * The ARN of the managed policy
+     * @attribute
      */
     readonly managedPolicyArn: string;
 }
+export interface ManagedPolicyProps {
+    /**
+     * The name of the managed policy. If you specify multiple policies for an entity,
+     * specify unique names. For example, if you specify a list of policies for
+     * an IAM role, each policy must have a unique name.
+     *
+     * @default - A name is automatically generated.
+     */
+    readonly managedPolicyName?: string;
+    /**
+     * A description of the managed policy. Typically used to store information about the
+     * permissions defined in the policy. For example, "Grants access to production DynamoDB tables."
+     * The policy description is immutable. After a value is assigned, it cannot be changed.
+     *
+     * @default - empty
+     */
+    readonly description?: string;
+    /**
+     * The path for the policy. This parameter allows (through its regex pattern) a string of characters
+     * consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes.
+     * In addition, it can contain any ASCII character from the ! (\u0021) through the DEL character (\u007F),
+     * including most punctuation characters, digits, and upper and lowercased letters.
+     *
+     * For more information about paths, see IAM Identifiers in the IAM User Guide.
+     *
+     * @default - "/"
+     */
+    readonly path?: string;
+    /**
+     * Users to attach this policy to.
+     * You can also use `attachToUser(user)` to attach this policy to a user.
+     *
+     * @default - No users.
+     */
+    readonly users?: IUser[];
+    /**
+     * Roles to attach this policy to.
+     * You can also use `attachToRole(role)` to attach this policy to a role.
+     *
+     * @default - No roles.
+     */
+    readonly roles?: IRole[];
+    /**
+     * Groups to attach this policy to.
+     * You can also use `attachToGroup(group)` to attach this policy to a group.
+     *
+     * @default - No groups.
+     */
+    readonly groups?: IGroup[];
+    /**
+     * Initial set of permissions to add to this policy document.
+     * You can also use `addPermission(statement)` to add permissions later.
+     *
+     * @default - No statements.
+     */
+    readonly statements?: PolicyStatement[];
+}
 /**
  * Managed policy
  *
- * This class is an incomplete placeholder class, and exists only to get access
- * to AWS Managed policies.
  */
-export declare class ManagedPolicy {
+export declare class ManagedPolicy extends Resource implements IManagedPolicy {
     /**
+     * Construct a customer managed policy from the managedPolicyName
+     *
+     * For this managed policy, you only need to know the name to be able to use it.
+     *
+     */
+    static fromManagedPolicyName(scope: Construct, id: string, managedPolicyName: string): IManagedPolicy;
+    /**
      * Construct a managed policy from one of the policies that AWS manages
@@ -28,3 +97,51 @@ *
     static fromAwsManagedPolicyName(managedPolicyName: string): IManagedPolicy;
-    protected constructor();
+    /**
+     * Returns the ARN of this managed policy.
+     *
+     * @attribute
+     */
+    readonly managedPolicyArn: string;
+    /**
+     * The policy document.
+     */
+    readonly document: PolicyDocument;
+    /**
+     * The name of this policy.
+     *
+     * @attribute
+     */
+    readonly managedPolicyName: string;
+    /**
+     * The description of this policy.
+     *
+     * @attribute
+     */
+    readonly description: string;
+    /**
+     * The path of this policy.
+     *
+     * @attribute
+     */
+    readonly path: string;
+    private readonly roles;
+    private readonly users;
+    private readonly groups;
+    constructor(scope: Construct, id: string, props?: ManagedPolicyProps);
+    /**
+     * Adds a statement to the policy document.
+     */
+    addStatements(...statement: PolicyStatement[]): void;
+    /**
+     * Attaches this policy to a user.
+     */
+    attachToUser(user: IUser): void;
+    /**
+     * Attaches this policy to a role.
+     */
+    attachToRole(role: IRole): void;
+    /**
+     * Attaches this policy to a group.
+     */
+    attachToGroup(group: IGroup): void;
+    protected validate(): string[];
 }

lib/managed-policy.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@aws-cdk/core");
+const iam_generated_1 = require("./iam.generated");
+const policy_document_1 = require("./policy-document");
+const util_1 = require("./util");
 /**
  * Managed policy
  *
- * This class is an incomplete placeholder class, and exists only to get access
- * to AWS Managed policies.
  */
-class ManagedPolicy {
+class ManagedPolicy extends core_1.Resource {
+    constructor(scope, id, props = {}) {
+        super(scope, id, {
+            physicalName: props.managedPolicyName
+        });
+        /**
+         * The policy document.
+         */
+        this.document = new policy_document_1.PolicyDocument();
+        this.roles = new Array();
+        this.users = new Array();
+        this.groups = new Array();
+        this.description = props.description || '';
+        this.path = props.path || '/';
+        const resource = new iam_generated_1.CfnManagedPolicy(this, 'Resource', {
+            policyDocument: this.document,
+            managedPolicyName: this.physicalName,
+            description: this.description,
+            path: this.path,
+            roles: util_1.undefinedIfEmpty(() => this.roles.map(r => r.roleName)),
+            users: util_1.undefinedIfEmpty(() => this.users.map(u => u.userName)),
+            groups: util_1.undefinedIfEmpty(() => this.groups.map(g => g.groupName)),
+        });
+        if (props.users) {
+            props.users.forEach(u => this.attachToUser(u));
+        }
+        if (props.groups) {
+            props.groups.forEach(g => this.attachToGroup(g));
+        }
+        if (props.roles) {
+            props.roles.forEach(r => this.attachToRole(r));
+        }
+        if (props.statements) {
+            props.statements.forEach(p => this.addStatements(p));
+        }
+        this.managedPolicyName = this.getResourceNameAttribute(resource.ref);
+        this.managedPolicyArn = this.getResourceArnAttribute(resource.ref, {
+            region: '',
+            service: 'iam',
+            resource: 'role',
+            resourceName: this.physicalName,
+        });
+    }
     /**
+     * Construct a customer managed policy from the managedPolicyName
+     *
+     * For this managed policy, you only need to know the name to be able to use it.
+     *
+     */
+    static fromManagedPolicyName(scope, id, managedPolicyName) {
+        class Import extends core_1.Resource {
+            constructor() {
+                super(...arguments);
+                this.managedPolicyArn = core_1.Stack.of(scope).formatArn({
+                    service: "iam",
+                    region: "",
+                    account: core_1.Stack.of(scope).account,
+                    resource: "policy",
+                    resourceName: managedPolicyName
+                });
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
      * Construct a managed policy from one of the policies that AWS manages
@@ -38,6 +102,45 @@ *
     }
-    constructor() {
+    /**
+     * Adds a statement to the policy document.
+     */
+    addStatements(...statement) {
+        this.document.addStatements(...statement);
     }
+    /**
+     * Attaches this policy to a user.
+     */
+    attachToUser(user) {
+        if (this.users.find(u => u === user)) {
+            return;
+        }
+        this.users.push(user);
+    }
+    /**
+     * Attaches this policy to a role.
+     */
+    attachToRole(role) {
+        if (this.roles.find(r => r === role)) {
+            return;
+        }
+        this.roles.push(role);
+    }
+    /**
+     * Attaches this policy to a group.
+     */
+    attachToGroup(group) {
+        if (this.groups.find(g => g === group)) {
+            return;
+        }
+        this.groups.push(group);
+    }
+    validate() {
+        const result = new Array();
+        // validate that the policy document is not empty
+        if (this.document.isEmpty) {
+            result.push('Managed Policy is empty. You must add statements to the policy');
+        }
+        return result;
+    }
 }
 exports.ManagedPolicy = ManagedPolicy;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"managed-policy.js","sourceRoot":"","sources":["managed-policy.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, IResolveContext, Lazy, Resource, Stack} from '@aws-cdk/core';\nimport { IGroup } from './group';\nimport { CfnManagedPolicy } from './iam.generated';\nimport { PolicyDocument } from './policy-document';\nimport { PolicyStatement } from './policy-statement';\nimport { IRole } from './role';\nimport { IUser } from './user';\nimport { undefinedIfEmpty } from './util';\n\n/**\n * A managed policy\n */\nexport interface IManagedPolicy {\n  /**\n   * The ARN of the managed policy\n   * @attribute\n   */\n  readonly managedPolicyArn: string;\n}\n\nexport interface ManagedPolicyProps {\n  /**\n   * The name of the managed policy. If you specify multiple policies for an entity,\n   * specify unique names. For example, if you specify a list of policies for\n   * an IAM role, each policy must have a unique name.\n   *\n   * @default - A name is automatically generated.\n   */\n  readonly managedPolicyName?: string;\n\n  /**\n   * A description of the managed policy. Typically used to store information about the\n   * permissions defined in the policy. For example, \"Grants access to production DynamoDB tables.\"\n   * The policy description is immutable. After a value is assigned, it cannot be changed.\n   *\n   * @default - empty\n   */\n  readonly description?: string;\n\n  /**\n   * The path for the policy. This parameter allows (through its regex pattern) a string of characters\n   * consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes.\n   * In addition, it can contain any ASCII character from the ! (\\u0021) through the DEL character (\\u007F),\n   * including most punctuation characters, digits, and upper and lowercased letters.\n   *\n   * For more information about paths, see IAM Identifiers in the IAM User Guide.\n   *\n   * @default - \"/\"\n   */\n  readonly path?: string;\n\n  /**\n   * Users to attach this policy to.\n   * You can also use `attachToUser(user)` to attach this policy to a user.\n   *\n   * @default - No users.\n   */\n  readonly users?: IUser[];\n\n  /**\n   * Roles to attach this policy to.\n   * You can also use `attachToRole(role)` to attach this policy to a role.\n   *\n   * @default - No roles.\n   */\n  readonly roles?: IRole[];\n\n  /**\n   * Groups to attach this policy to.\n   * You can also use `attachToGroup(group)` to attach this policy to a group.\n   *\n   * @default - No groups.\n   */\n  readonly groups?: IGroup[];\n\n  /**\n   * Initial set of permissions to add to this policy document.\n   * You can also use `addPermission(statement)` to add permissions later.\n   *\n   * @default - No statements.\n   */\n  readonly statements?: PolicyStatement[];\n}\n\n/**\n * Managed policy\n *\n */\nexport class ManagedPolicy extends Resource implements IManagedPolicy {\n  /**\n   * Construct a customer managed policy from the managedPolicyName\n   *\n   * For this managed policy, you only need to know the name to be able to use it.\n   *\n   */\n  public static fromManagedPolicyName(scope: Construct, id: string, managedPolicyName: string): IManagedPolicy {\n    class Import extends Resource implements IManagedPolicy {\n      public readonly managedPolicyArn = Stack.of(scope).formatArn({\n        service: \"iam\",\n        region: \"\", // no region for managed policy\n        account: Stack.of(scope).account, // Can this be something the user specifies?\n        resource: \"policy\",\n        resourceName: managedPolicyName\n      });\n    }\n    return new Import(scope, id);\n  }\n\n  /**\n   * Construct a managed policy from one of the policies that AWS manages\n   *\n   * For this managed policy, you only need to know the name to be able to use it.\n   *\n   * Some managed policy names start with \"service-role/\", some start with\n   * \"job-function/\", and some don't start with anything. Do include the\n   * prefix when constructing this object.\n   */\n  public static fromAwsManagedPolicyName(managedPolicyName: string): IManagedPolicy {\n    class AwsManagedPolicy implements IManagedPolicy {\n      public readonly managedPolicyArn = Lazy.stringValue({\n        produce(ctx: IResolveContext) {\n          return Stack.of(ctx.scope).formatArn({\n            service: \"iam\",\n            region: \"\", // no region for managed policy\n            account: \"aws\", // the account for a managed policy is 'aws'\n            resource: \"policy\",\n            resourceName: managedPolicyName\n          });\n        }\n      });\n    }\n    return new AwsManagedPolicy();\n  }\n\n  /**\n   * Returns the ARN of this managed policy.\n   *\n   * @attribute\n   */\n  public readonly managedPolicyArn: string;\n\n  /**\n   * The policy document.\n   */\n  public readonly document = new PolicyDocument();\n\n  /**\n   * The name of this policy.\n   *\n   * @attribute\n   */\n  public readonly managedPolicyName: string;\n\n  /**\n   * The description of this policy.\n   *\n   * @attribute\n   */\n  public readonly description: string;\n\n  /**\n   * The path of this policy.\n   *\n   * @attribute\n   */\n  public readonly path: string;\n\n  private readonly roles = new Array<IRole>();\n  private readonly users = new Array<IUser>();\n  private readonly groups = new Array<IGroup>();\n\n  constructor(scope: Construct, id: string, props: ManagedPolicyProps = {}) {\n    super(scope, id, {\n      physicalName: props.managedPolicyName\n    });\n\n    this.description = props.description || '';\n    this.path = props.path || '/';\n\n    const resource = new CfnManagedPolicy(this, 'Resource', {\n      policyDocument: this.document,\n      managedPolicyName: this.physicalName,\n      description: this.description,\n      path: this.path,\n      roles: undefinedIfEmpty(() => this.roles.map(r => r.roleName)),\n      users: undefinedIfEmpty(() => this.users.map(u => u.userName)),\n      groups: undefinedIfEmpty(() => this.groups.map(g => g.groupName)),\n    });\n\n    if (props.users) {\n      props.users.forEach(u => this.attachToUser(u));\n    }\n\n    if (props.groups) {\n      props.groups.forEach(g => this.attachToGroup(g));\n    }\n\n    if (props.roles) {\n      props.roles.forEach(r => this.attachToRole(r));\n    }\n\n    if (props.statements) {\n      props.statements.forEach(p => this.addStatements(p));\n    }\n\n    this.managedPolicyName = this.getResourceNameAttribute(resource.ref);\n    this.managedPolicyArn = this.getResourceArnAttribute(resource.ref, {\n      region: '', // IAM is global in each partition\n      service: 'iam',\n      resource: 'role',\n      resourceName: this.physicalName,\n    });\n  }\n\n  /**\n   * Adds a statement to the policy document.\n   */\n  public addStatements(...statement: PolicyStatement[]) {\n    this.document.addStatements(...statement);\n  }\n\n  /**\n   * Attaches this policy to a user.\n   */\n  public attachToUser(user: IUser) {\n    if (this.users.find(u => u === user)) { return; }\n    this.users.push(user);\n  }\n\n  /**\n   * Attaches this policy to a role.\n   */\n  public attachToRole(role: IRole) {\n    if (this.roles.find(r => r === role)) { return; }\n    this.roles.push(role);\n  }\n\n  /**\n   * Attaches this policy to a group.\n   */\n  public attachToGroup(group: IGroup) {\n    if (this.groups.find(g => g === group)) { return; }\n    this.groups.push(group);\n  }\n\n  protected validate(): string[] {\n    const result = new Array<string>();\n\n    // validate that the policy document is not empty\n    if (this.document.isEmpty) {\n      result.push('Managed Policy is empty. You must add statements to the policy');\n    }\n\n    return result;\n  }\n}\n"]}

lib/role.d.ts

@@ -24,2 +24,4 @@ import { Construct, Duration, Resource } from '@aws-cdk/core';
      *
+     * @deprecated see {@link externalIds}
+     *
      * @default No external ID required
@@ -29,5 +31,15 @@ */
     /**
+     * List of IDs that the role assumer needs to provide one of when assuming this role
+     *
+     * If the configured and provided external IDs do not match, the
+     * AssumeRole operation will fail.
+     *
+     * @default No external ID required
+     */
+    readonly externalIds?: string[];
+    /**
      * A list of managed policies associated with this role.
      *
-     * You can add managed policies later using `attachManagedPolicy(arn)`.
+     * You can add managed policies later using
+     * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.
      *
@@ -56,2 +68,16 @@ * @default - No managed policies.
     /**
+     * AWS supports permissions boundaries for IAM entities (users or roles).
+     * A permissions boundary is an advanced feature for using a managed policy
+     * to set the maximum permissions that an identity-based policy can grant to
+     * an IAM entity. An entity's permissions boundary allows it to perform only
+     * the actions that are allowed by both its identity-based policies and its
+     * permissions boundaries.
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-permissionsboundary
+     * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html
+     *
+     * @default - No permissions boundary.
+     */
+    readonly permissionsBoundary?: IManagedPolicy;
+    /**
      * A name for the IAM role. For valid values, see the RoleName parameter for
@@ -132,2 +158,6 @@ * the CreateRole action in the IAM API Reference.
     readonly policyFragment: PrincipalPolicyFragment;
+    /**
+     * Returns the permissions boundary attached to this role
+     */
+    readonly permissionsBoundary?: IManagedPolicy;
     private defaultPolicy?;
@@ -134,0 +164,0 @@ private readonly managedPolicies;

lib/role.js

@@ -26,4 +26,9 @@ "use strict";
         this.attachedPolicies = new util_1.AttachedPolicies();
-        this.assumeRolePolicy = createAssumeRolePolicy(props.assumedBy, props.externalId);
+        const externalIds = props.externalIds || [];
+        if (props.externalId) {
+            externalIds.push(props.externalId);
+        }
+        this.assumeRolePolicy = createAssumeRolePolicy(props.assumedBy, externalIds);
         this.managedPolicies.push(...props.managedPolicies || []);
+        this.permissionsBoundary = props.permissionsBoundary;
         const maxSessionDuration = props.maxSessionDuration && props.maxSessionDuration.toSeconds();
@@ -36,2 +41,3 @@ validateMaxSessionDuration(maxSessionDuration);
             path: props.path,
+            permissionsBoundary: this.permissionsBoundary ? this.permissionsBoundary.managedPolicyArn : undefined,
             roleName: this.physicalName,
@@ -131,2 +137,5 @@ maxSessionDuration,
     addManagedPolicy(policy) {
+        if (this.managedPolicies.find(mp => mp === policy)) {
+            return;
+        }
         this.managedPolicies.push(policy);
@@ -161,8 +170,8 @@ }
 exports.Role = Role;
-function createAssumeRolePolicy(principal, externalId) {
+function createAssumeRolePolicy(principal, externalIds) {
     const statement = new policy_statement_1.PolicyStatement();
     statement.addPrincipals(principal);
     statement.addActions(principal.assumeRoleAction);
-    if (externalId !== undefined) {
-        statement.addCondition('StringEquals', { 'sts:ExternalId': externalId });
+    if (externalIds.length) {
+        statement.addCondition('StringEquals', { 'sts:ExternalId': externalIds.length === 1 ? externalIds[0] : externalIds });
     }
@@ -181,2 +190,2 @@ const doc = new policy_document_1.PolicyDocument();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role.js","sourceRoot":"","sources":["role.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, Duration, Lazy, Resource, Stack } from '@aws-cdk/core';\nimport { Grant } from './grant';\nimport { CfnRole } from './iam.generated';\nimport { IIdentity } from './identity-base';\nimport { IManagedPolicy } from './managed-policy';\nimport { Policy } from './policy';\nimport { PolicyDocument } from './policy-document';\nimport { PolicyStatement } from './policy-statement';\nimport { ArnPrincipal, IPrincipal, PrincipalPolicyFragment } from './principals';\nimport { AttachedPolicies } from './util';\n\nexport interface RoleProps {\n  /**\n   * The IAM principal (i.e. `new ServicePrincipal('sns.amazonaws.com')`)\n   * which can assume this role.\n   *\n   * You can later modify the assume role policy document by accessing it via\n   * the `assumeRolePolicy` property.\n   */\n  readonly assumedBy: IPrincipal;\n\n  /**\n   * ID that the role assumer needs to provide when assuming this role\n   *\n   * If the configured and provided external IDs do not match, the\n   * AssumeRole operation will fail.\n   *\n   * @default No external ID required\n   */\n  readonly externalId?: string;\n\n  /**\n   * A list of managed policies associated with this role.\n   *\n   * You can add managed policies later using `attachManagedPolicy(arn)`.\n   *\n   * @default - No managed policies.\n   */\n  readonly managedPolicies?: IManagedPolicy[];\n\n  /**\n   * A list of named policies to inline into this role. These policies will be\n   * created with the role, whereas those added by ``addToPolicy`` are added\n   * using a separate CloudFormation resource (allowing a way around circular\n   * dependencies that could otherwise be introduced).\n   *\n   * @default - No policy is inlined in the Role resource.\n   */\n  readonly inlinePolicies?: { [name: string]: PolicyDocument };\n\n  /**\n   * The path associated with this role. For information about IAM paths, see\n   * Friendly Names and Paths in IAM User Guide.\n   *\n   * @default /\n   */\n  readonly path?: string;\n\n  /**\n   * A name for the IAM role. For valid values, see the RoleName parameter for\n   * the CreateRole action in the IAM API Reference.\n   *\n   * IMPORTANT: If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   *\n   * @default - AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the group name.\n   */\n  readonly roleName?: string;\n\n  /**\n   * The maximum session duration that you want to set for the specified role.\n   * This setting can have a value from 1 hour (3600sec) to 12 (43200sec) hours.\n   *\n   * Anyone who assumes the role from the AWS CLI or API can use the\n   * DurationSeconds API parameter or the duration-seconds CLI parameter to\n   * request a longer session. The MaxSessionDuration setting determines the\n   * maximum duration that can be requested using the DurationSeconds\n   * parameter.\n   *\n   * If users don't specify a value for the DurationSeconds parameter, their\n   * security credentials are valid for one hour by default. This applies when\n   * you use the AssumeRole* API operations or the assume-role* CLI operations\n   * but does not apply when you use those operations to create a console URL.\n   *\n   * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html\n   *\n   * @default Duration.hours(1)\n   */\n  readonly maxSessionDuration?: Duration;\n}\n\n/**\n * IAM Role\n *\n * Defines an IAM role. The role is created with an assume policy document associated with\n * the specified AWS service principal defined in `serviceAssumeRole`.\n */\nexport class Role extends Resource implements IRole {\n\n  /**\n   * Imports an external role by ARN\n   * @param scope construct scope\n   * @param id construct id\n   * @param roleArn the ARN of the role to import\n   */\n  public static fromRoleArn(scope: Construct, id: string, roleArn: string): IRole {\n\n    class Import extends Resource implements IRole {\n      public readonly grantPrincipal: IPrincipal = this;\n      public readonly assumeRoleAction: string = 'sts:AssumeRole';\n      public readonly policyFragment = new ArnPrincipal(roleArn).policyFragment;\n      public readonly roleArn = roleArn;\n      public readonly roleName = Stack.of(scope).parseArn(roleArn).resourceName!;\n\n      private readonly attachedPolicies = new AttachedPolicies();\n      private defaultPolicy?: Policy;\n\n      public addToPolicy(statement: PolicyStatement): boolean {\n        if (!this.defaultPolicy) {\n          this.defaultPolicy = new Policy(this, 'Policy');\n          this.attachInlinePolicy(this.defaultPolicy);\n        }\n        this.defaultPolicy.addStatements(statement);\n        return true;\n      }\n\n      public attachInlinePolicy(policy: Policy): void {\n        this.attachedPolicies.attach(policy);\n        policy.attachToRole(this);\n      }\n\n      public addManagedPolicy(_policy: IManagedPolicy): void {\n        // FIXME: Add warning that we're ignoring this\n      }\n\n      /**\n       * Grant the actions defined in actions to the identity Principal on this resource.\n       */\n      public grant(grantee: IPrincipal, ...actions: string[]): Grant {\n        return Grant.addToPrincipal({\n          grantee,\n          actions,\n          resourceArns: [this.roleArn],\n          scope: this\n        });\n      }\n\n      /**\n       * Grant permissions to the given principal to pass this role.\n       */\n      public grantPassRole(identity: IPrincipal): Grant {\n        return this.grant(identity, 'iam:PassRole');\n      }\n    }\n\n    return new Import(scope, id);\n\n  }\n\n  public readonly grantPrincipal: IPrincipal = this;\n\n  public readonly assumeRoleAction: string = 'sts:AssumeRole';\n\n  /**\n   * The assume role policy document associated with this role.\n   */\n  public readonly assumeRolePolicy?: PolicyDocument;\n\n  /**\n   * Returns the ARN of this role.\n   */\n  public readonly roleArn: string;\n\n  /**\n   * Returns the stable and unique string identifying the role. For example,\n   * AIDAJQABLZS4A3QDU576Q.\n   *\n   * @attribute\n   */\n  public readonly roleId: string;\n\n  /**\n   * Returns the name of the role.\n   */\n  public readonly roleName: string;\n\n  /**\n   * Returns the role.\n   */\n  public readonly policyFragment: PrincipalPolicyFragment;\n\n  private defaultPolicy?: Policy;\n  private readonly managedPolicies: IManagedPolicy[] = [];\n  private readonly attachedPolicies = new AttachedPolicies();\n\n  constructor(scope: Construct, id: string, props: RoleProps) {\n    super(scope, id, {\n      physicalName: props.roleName,\n    });\n\n    this.assumeRolePolicy = createAssumeRolePolicy(props.assumedBy, props.externalId);\n    this.managedPolicies.push(...props.managedPolicies || []);\n\n    const maxSessionDuration = props.maxSessionDuration && props.maxSessionDuration.toSeconds();\n    validateMaxSessionDuration(maxSessionDuration);\n\n    const role = new CfnRole(this, 'Resource', {\n      assumeRolePolicyDocument: this.assumeRolePolicy as any,\n      managedPolicyArns: Lazy.listValue({ produce: () => this.managedPolicies.map(p => p.managedPolicyArn) }, { omitEmpty: true }),\n      policies: _flatten(props.inlinePolicies),\n      path: props.path,\n      roleName: this.physicalName,\n      maxSessionDuration,\n    });\n\n    this.roleId = role.attrRoleId;\n    this.roleArn = this.getResourceArnAttribute(role.attrArn, {\n      region: '', // IAM is global in each partition\n      service: 'iam',\n      resource: 'role',\n      resourceName: this.physicalName,\n    });\n    this.roleName = this.getResourceNameAttribute(role.ref);\n    this.policyFragment = new ArnPrincipal(this.roleArn).policyFragment;\n\n    function _flatten(policies?: { [name: string]: PolicyDocument }) {\n      if (policies == null || Object.keys(policies).length === 0) {\n        return undefined;\n      }\n      const result = new Array<CfnRole.PolicyProperty>();\n      for (const policyName of Object.keys(policies)) {\n        const policyDocument = policies[policyName];\n        result.push({ policyName, policyDocument });\n      }\n      return result;\n    }\n  }\n\n  /**\n   * Adds a permission to the role's default policy document.\n   * If there is no default policy attached to this role, it will be created.\n   * @param statement The permission statement to add to the policy document\n   */\n  public addToPolicy(statement: PolicyStatement): boolean {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.attachInlinePolicy(this.defaultPolicy);\n    }\n    this.defaultPolicy.addStatements(statement);\n    return true;\n  }\n\n  /**\n   * Attaches a managed policy to this role.\n   * @param policy The the managed policy to attach.\n   */\n  public addManagedPolicy(policy: IManagedPolicy) {\n    this.managedPolicies.push(policy);\n  }\n\n  /**\n   * Attaches a policy to this role.\n   * @param policy The policy to attach\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToRole(this);\n  }\n\n  /**\n   * Grant the actions defined in actions to the identity Principal on this resource.\n   */\n  public grant(grantee: IPrincipal, ...actions: string[]) {\n    return Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.roleArn],\n      scope: this\n    });\n  }\n\n  /**\n   * Grant permissions to the given principal to pass this role.\n   */\n  public grantPassRole(identity: IPrincipal) {\n    return this.grant(identity, 'iam:PassRole');\n  }\n}\n\n/**\n * A Role object\n */\nexport interface IRole extends IIdentity {\n  /**\n   * Returns the ARN of this role.\n   *\n   * @attribute\n   */\n  readonly roleArn: string;\n\n  /**\n   * Returns the name of this role.\n   *\n   * @attribute\n   */\n  readonly roleName: string;\n\n  /**\n   * Grant the actions defined in actions to the identity Principal on this resource.\n   */\n  grant(grantee: IPrincipal, ...actions: string[]): Grant;\n\n  /**\n   * Grant permissions to the given principal to pass this role.\n   */\n  grantPassRole(grantee: IPrincipal): Grant;\n}\n\nfunction createAssumeRolePolicy(principal: IPrincipal, externalId?: string) {\n  const statement = new PolicyStatement();\n  statement.addPrincipals(principal);\n  statement.addActions(principal.assumeRoleAction);\n\n  if (externalId !== undefined) {\n    statement.addCondition('StringEquals', { 'sts:ExternalId': externalId });\n  }\n\n  const doc = new PolicyDocument();\n  doc.addStatements(statement);\n  return doc;\n}\n\nfunction validateMaxSessionDuration(duration?: number) {\n  if (duration === undefined) {\n    return;\n  }\n\n  if (duration < 3600 || duration > 43200) {\n    throw new Error(`maxSessionDuration is set to ${duration}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role.js","sourceRoot":"","sources":["role.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, Duration, Lazy, Resource, Stack } from '@aws-cdk/core';\nimport { Grant } from './grant';\nimport { CfnRole } from './iam.generated';\nimport { IIdentity } from './identity-base';\nimport { IManagedPolicy } from './managed-policy';\nimport { Policy } from './policy';\nimport { PolicyDocument } from './policy-document';\nimport { PolicyStatement } from './policy-statement';\nimport { ArnPrincipal, IPrincipal, PrincipalPolicyFragment } from './principals';\nimport { AttachedPolicies } from './util';\n\nexport interface RoleProps {\n  /**\n   * The IAM principal (i.e. `new ServicePrincipal('sns.amazonaws.com')`)\n   * which can assume this role.\n   *\n   * You can later modify the assume role policy document by accessing it via\n   * the `assumeRolePolicy` property.\n   */\n  readonly assumedBy: IPrincipal;\n\n  /**\n   * ID that the role assumer needs to provide when assuming this role\n   *\n   * If the configured and provided external IDs do not match, the\n   * AssumeRole operation will fail.\n   *\n   * @deprecated see {@link externalIds}\n   *\n   * @default No external ID required\n   */\n  readonly externalId?: string;\n\n  /**\n   * List of IDs that the role assumer needs to provide one of when assuming this role\n   *\n   * If the configured and provided external IDs do not match, the\n   * AssumeRole operation will fail.\n   *\n   * @default No external ID required\n   */\n  readonly externalIds?: string[];\n\n  /**\n   * A list of managed policies associated with this role.\n   *\n   * You can add managed policies later using\n   * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.\n   *\n   * @default - No managed policies.\n   */\n  readonly managedPolicies?: IManagedPolicy[];\n\n  /**\n   * A list of named policies to inline into this role. These policies will be\n   * created with the role, whereas those added by ``addToPolicy`` are added\n   * using a separate CloudFormation resource (allowing a way around circular\n   * dependencies that could otherwise be introduced).\n   *\n   * @default - No policy is inlined in the Role resource.\n   */\n  readonly inlinePolicies?: { [name: string]: PolicyDocument };\n\n  /**\n   * The path associated with this role. For information about IAM paths, see\n   * Friendly Names and Paths in IAM User Guide.\n   *\n   * @default /\n   */\n  readonly path?: string;\n\n  /**\n   * AWS supports permissions boundaries for IAM entities (users or roles).\n   * A permissions boundary is an advanced feature for using a managed policy\n   * to set the maximum permissions that an identity-based policy can grant to\n   * an IAM entity. An entity's permissions boundary allows it to perform only\n   * the actions that are allowed by both its identity-based policies and its\n   * permissions boundaries.\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-permissionsboundary\n   * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html\n   *\n   * @default - No permissions boundary.\n   */\n  readonly permissionsBoundary?: IManagedPolicy;\n\n  /**\n   * A name for the IAM role. For valid values, see the RoleName parameter for\n   * the CreateRole action in the IAM API Reference.\n   *\n   * IMPORTANT: If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   *\n   * @default - AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the group name.\n   */\n  readonly roleName?: string;\n\n  /**\n   * The maximum session duration that you want to set for the specified role.\n   * This setting can have a value from 1 hour (3600sec) to 12 (43200sec) hours.\n   *\n   * Anyone who assumes the role from the AWS CLI or API can use the\n   * DurationSeconds API parameter or the duration-seconds CLI parameter to\n   * request a longer session. The MaxSessionDuration setting determines the\n   * maximum duration that can be requested using the DurationSeconds\n   * parameter.\n   *\n   * If users don't specify a value for the DurationSeconds parameter, their\n   * security credentials are valid for one hour by default. This applies when\n   * you use the AssumeRole* API operations or the assume-role* CLI operations\n   * but does not apply when you use those operations to create a console URL.\n   *\n   * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html\n   *\n   * @default Duration.hours(1)\n   */\n  readonly maxSessionDuration?: Duration;\n}\n\n/**\n * IAM Role\n *\n * Defines an IAM role. The role is created with an assume policy document associated with\n * the specified AWS service principal defined in `serviceAssumeRole`.\n */\nexport class Role extends Resource implements IRole {\n\n  /**\n   * Imports an external role by ARN\n   * @param scope construct scope\n   * @param id construct id\n   * @param roleArn the ARN of the role to import\n   */\n  public static fromRoleArn(scope: Construct, id: string, roleArn: string): IRole {\n\n    class Import extends Resource implements IRole {\n      public readonly grantPrincipal: IPrincipal = this;\n      public readonly assumeRoleAction: string = 'sts:AssumeRole';\n      public readonly policyFragment = new ArnPrincipal(roleArn).policyFragment;\n      public readonly roleArn = roleArn;\n      public readonly roleName = Stack.of(scope).parseArn(roleArn).resourceName!;\n\n      private readonly attachedPolicies = new AttachedPolicies();\n      private defaultPolicy?: Policy;\n\n      public addToPolicy(statement: PolicyStatement): boolean {\n        if (!this.defaultPolicy) {\n          this.defaultPolicy = new Policy(this, 'Policy');\n          this.attachInlinePolicy(this.defaultPolicy);\n        }\n        this.defaultPolicy.addStatements(statement);\n        return true;\n      }\n\n      public attachInlinePolicy(policy: Policy): void {\n        this.attachedPolicies.attach(policy);\n        policy.attachToRole(this);\n      }\n\n      public addManagedPolicy(_policy: IManagedPolicy): void {\n        // FIXME: Add warning that we're ignoring this\n      }\n\n      /**\n       * Grant the actions defined in actions to the identity Principal on this resource.\n       */\n      public grant(grantee: IPrincipal, ...actions: string[]): Grant {\n        return Grant.addToPrincipal({\n          grantee,\n          actions,\n          resourceArns: [this.roleArn],\n          scope: this\n        });\n      }\n\n      /**\n       * Grant permissions to the given principal to pass this role.\n       */\n      public grantPassRole(identity: IPrincipal): Grant {\n        return this.grant(identity, 'iam:PassRole');\n      }\n    }\n\n    return new Import(scope, id);\n\n  }\n\n  public readonly grantPrincipal: IPrincipal = this;\n\n  public readonly assumeRoleAction: string = 'sts:AssumeRole';\n\n  /**\n   * The assume role policy document associated with this role.\n   */\n  public readonly assumeRolePolicy?: PolicyDocument;\n\n  /**\n   * Returns the ARN of this role.\n   */\n  public readonly roleArn: string;\n\n  /**\n   * Returns the stable and unique string identifying the role. For example,\n   * AIDAJQABLZS4A3QDU576Q.\n   *\n   * @attribute\n   */\n  public readonly roleId: string;\n\n  /**\n   * Returns the name of the role.\n   */\n  public readonly roleName: string;\n\n  /**\n   * Returns the role.\n   */\n  public readonly policyFragment: PrincipalPolicyFragment;\n\n  /**\n   * Returns the permissions boundary attached to this role\n   */\n  public readonly permissionsBoundary?: IManagedPolicy;\n\n  private defaultPolicy?: Policy;\n  private readonly managedPolicies: IManagedPolicy[] = [];\n  private readonly attachedPolicies = new AttachedPolicies();\n\n  constructor(scope: Construct, id: string, props: RoleProps) {\n    super(scope, id, {\n      physicalName: props.roleName,\n    });\n\n    const externalIds = props.externalIds || [];\n    if (props.externalId) {\n      externalIds.push(props.externalId);\n    }\n\n    this.assumeRolePolicy = createAssumeRolePolicy(props.assumedBy, externalIds);\n    this.managedPolicies.push(...props.managedPolicies || []);\n    this.permissionsBoundary = props.permissionsBoundary;\n    const maxSessionDuration = props.maxSessionDuration && props.maxSessionDuration.toSeconds();\n    validateMaxSessionDuration(maxSessionDuration);\n\n    const role = new CfnRole(this, 'Resource', {\n      assumeRolePolicyDocument: this.assumeRolePolicy as any,\n      managedPolicyArns: Lazy.listValue({ produce: () => this.managedPolicies.map(p => p.managedPolicyArn) }, { omitEmpty: true }),\n      policies: _flatten(props.inlinePolicies),\n      path: props.path,\n      permissionsBoundary: this.permissionsBoundary ? this.permissionsBoundary.managedPolicyArn : undefined,\n      roleName: this.physicalName,\n      maxSessionDuration,\n    });\n\n    this.roleId = role.attrRoleId;\n    this.roleArn = this.getResourceArnAttribute(role.attrArn, {\n      region: '', // IAM is global in each partition\n      service: 'iam',\n      resource: 'role',\n      resourceName: this.physicalName,\n    });\n    this.roleName = this.getResourceNameAttribute(role.ref);\n    this.policyFragment = new ArnPrincipal(this.roleArn).policyFragment;\n\n    function _flatten(policies?: { [name: string]: PolicyDocument }) {\n      if (policies == null || Object.keys(policies).length === 0) {\n        return undefined;\n      }\n      const result = new Array<CfnRole.PolicyProperty>();\n      for (const policyName of Object.keys(policies)) {\n        const policyDocument = policies[policyName];\n        result.push({ policyName, policyDocument });\n      }\n      return result;\n    }\n  }\n\n  /**\n   * Adds a permission to the role's default policy document.\n   * If there is no default policy attached to this role, it will be created.\n   * @param statement The permission statement to add to the policy document\n   */\n  public addToPolicy(statement: PolicyStatement): boolean {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.attachInlinePolicy(this.defaultPolicy);\n    }\n    this.defaultPolicy.addStatements(statement);\n    return true;\n  }\n\n  /**\n   * Attaches a managed policy to this role.\n   * @param policy The the managed policy to attach.\n   */\n  public addManagedPolicy(policy: IManagedPolicy) {\n    if (this.managedPolicies.find(mp => mp === policy)) { return; }\n    this.managedPolicies.push(policy);\n  }\n\n  /**\n   * Attaches a policy to this role.\n   * @param policy The policy to attach\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToRole(this);\n  }\n\n  /**\n   * Grant the actions defined in actions to the identity Principal on this resource.\n   */\n  public grant(grantee: IPrincipal, ...actions: string[]) {\n    return Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.roleArn],\n      scope: this\n    });\n  }\n\n  /**\n   * Grant permissions to the given principal to pass this role.\n   */\n  public grantPassRole(identity: IPrincipal) {\n    return this.grant(identity, 'iam:PassRole');\n  }\n}\n\n/**\n * A Role object\n */\nexport interface IRole extends IIdentity {\n  /**\n   * Returns the ARN of this role.\n   *\n   * @attribute\n   */\n  readonly roleArn: string;\n\n  /**\n   * Returns the name of this role.\n   *\n   * @attribute\n   */\n  readonly roleName: string;\n\n  /**\n   * Grant the actions defined in actions to the identity Principal on this resource.\n   */\n  grant(grantee: IPrincipal, ...actions: string[]): Grant;\n\n  /**\n   * Grant permissions to the given principal to pass this role.\n   */\n  grantPassRole(grantee: IPrincipal): Grant;\n}\n\nfunction createAssumeRolePolicy(principal: IPrincipal, externalIds: string[]) {\n  const statement = new PolicyStatement();\n  statement.addPrincipals(principal);\n  statement.addActions(principal.assumeRoleAction);\n\n  if (externalIds.length) {\n    statement.addCondition('StringEquals', { 'sts:ExternalId': externalIds.length === 1 ? externalIds[0] : externalIds });\n  }\n\n  const doc = new PolicyDocument();\n  doc.addStatements(statement);\n  return doc;\n}\n\nfunction validateMaxSessionDuration(duration?: number) {\n  if (duration === undefined) {\n    return;\n  }\n\n  if (duration < 3600 || duration > 43200) {\n    throw new Error(`maxSessionDuration is set to ${duration}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`);\n  }\n}\n"]}

lib/user.d.ts

@@ -22,5 +22,6 @@ import { Construct, Resource, SecretValue } from '@aws-cdk/core';
     /**
-     * A list managed policies associated with this role.
+     * A list of managed policies associated with this role.
      *
-     * You can add managed policies later using `attachManagedPolicy(policy)`.
+     * You can add managed policies later using
+     * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.
      *
@@ -38,2 +39,16 @@ * @default - No managed policies.
     /**
+     * AWS supports permissions boundaries for IAM entities (users or roles).
+     * A permissions boundary is an advanced feature for using a managed policy
+     * to set the maximum permissions that an identity-based policy can grant to
+     * an IAM entity. An entity's permissions boundary allows it to perform only
+     * the actions that are allowed by both its identity-based policies and its
+     * permissions boundaries.
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-permissionsboundary
+     * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html
+     *
+     * @default - No permissions boundary.
+     */
+    readonly permissionsBoundary?: IManagedPolicy;
+    /**
      * A name for the IAM user. For valid values, see the UserName parameter for
@@ -89,2 +104,6 @@ * the CreateUser action in the IAM API Reference. If you don't specify a
     readonly userArn: string;
+    /**
+     * Returns the permissions boundary attached to this user
+     */
+    readonly permissionsBoundary?: IManagedPolicy;
     readonly policyFragment: PrincipalPolicyFragment;
@@ -91,0 +110,0 @@ private readonly groups;

lib/user.js

@@ -19,2 +19,3 @@ "use strict";
         this.managedPolicies.push(...props.managedPolicies || []);
+        this.permissionsBoundary = props.permissionsBoundary;
         const user = new iam_generated_1.CfnUser(this, 'Resource', {
@@ -25,2 +26,3 @@ userName: this.physicalName,
             path: props.path,
+            permissionsBoundary: this.permissionsBoundary ? this.permissionsBoundary.managedPolicyArn : undefined,
             loginProfile: this.parseLoginProfile(props)
@@ -51,2 +53,5 @@ });
     addManagedPolicy(policy) {
+        if (this.managedPolicies.find(mp => mp === policy)) {
+            return;
+        }
         this.managedPolicies.push(policy);
@@ -88,2 +93,2 @@ }
 exports.User = User;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.js","sourceRoot":"","sources":["user.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, Lazy, Resource, SecretValue } from '@aws-cdk/core';\nimport { IGroup } from './group';\nimport { CfnUser } from './iam.generated';\nimport { IIdentity } from './identity-base';\nimport { IManagedPolicy } from './managed-policy';\nimport { Policy } from './policy';\nimport { PolicyStatement } from './policy-statement';\nimport { ArnPrincipal, PrincipalPolicyFragment } from './principals';\nimport { IPrincipal } from './principals';\nimport { AttachedPolicies, undefinedIfEmpty } from './util';\n\nexport interface IUser extends IIdentity {\n  readonly userName: string;\n  addToGroup(group: IGroup): void;\n}\n\nexport interface UserProps {\n  /**\n   * Groups to add this user to. You can also use `addToGroup` to add this\n   * user to a group.\n   *\n   * @default - No groups.\n   */\n  readonly groups?: IGroup[];\n\n  /**\n   * A list managed policies associated with this role.\n   *\n   * You can add managed policies later using `attachManagedPolicy(policy)`.\n   *\n   * @default - No managed policies.\n   */\n  readonly managedPolicies?: IManagedPolicy[];\n\n  /**\n   * The path for the user name. For more information about paths, see IAM\n   * Identifiers in the IAM User Guide.\n   *\n   * @default /\n   */\n  readonly path?: string;\n\n  /**\n   * A name for the IAM user. For valid values, see the UserName parameter for\n   * the CreateUser action in the IAM API Reference. If you don't specify a\n   * name, AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the user name.\n   *\n   * If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   *\n   * @default Generated by CloudFormation (recommended)\n   */\n  readonly userName?: string;\n\n  /**\n   * The password for the user. This is required so the user can access the\n   * AWS Management Console.\n   *\n   * You can use `SecretValue.plainText` to specify a password in plain text or\n   * use `secretsmanager.Secret.fromSecretAttributes` to reference a secret in\n   * Secrets Manager.\n   *\n   * @default User won't be able to access the management console without a password.\n   */\n  readonly password?: SecretValue;\n\n  /**\n   * Specifies whether the user is required to set a new password the next\n   * time the user logs in to the AWS Management Console.\n   *\n   * If this is set to 'true', you must also specify \"initialPassword\".\n   *\n   * @default false\n   */\n  readonly passwordResetRequired?: boolean;\n}\n\nexport class User extends Resource implements IIdentity {\n  public readonly grantPrincipal: IPrincipal = this;\n  public readonly assumeRoleAction: string = 'sts:AssumeRole';\n\n  /**\n   * An attribute that represents the user name.\n   * @attribute\n   */\n  public readonly userName: string;\n\n  /**\n   * An attribute that represents the user's ARN.\n   * @attribute\n   */\n  public readonly userArn: string;\n\n  public readonly policyFragment: PrincipalPolicyFragment;\n\n  private readonly groups = new Array<any>();\n  private readonly managedPolicies = new Array<IManagedPolicy>();\n  private readonly attachedPolicies = new AttachedPolicies();\n  private defaultPolicy?: Policy;\n\n  constructor(scope: Construct, id: string, props: UserProps = {}) {\n    super(scope, id, {\n      physicalName: props.userName,\n    });\n\n    this.managedPolicies.push(...props.managedPolicies || []);\n\n    const user = new CfnUser(this, 'Resource', {\n      userName: this.physicalName,\n      groups: undefinedIfEmpty(() => this.groups),\n      managedPolicyArns: Lazy.listValue({ produce: () => this.managedPolicies.map(p => p.managedPolicyArn) }, { omitEmpty: true }),\n      path: props.path,\n      loginProfile: this.parseLoginProfile(props)\n    });\n\n    this.userName = this.getResourceNameAttribute(user.ref);\n    this.userArn = this.getResourceArnAttribute(user.attrArn, {\n      region: '', // IAM is global in each partition\n      service: 'iam',\n      resource: 'user',\n      resourceName: this.physicalName,\n    });\n\n    this.policyFragment = new ArnPrincipal(this.userArn).policyFragment;\n\n    if (props.groups) {\n      props.groups.forEach(g => this.addToGroup(g));\n    }\n  }\n\n  /**\n   * Adds this user to a group.\n   */\n  public addToGroup(group: IGroup) {\n    this.groups.push(group.groupName);\n  }\n\n  /**\n   * Attaches a managed policy to the user.\n   * @param policy The managed policy to attach.\n   */\n  public addManagedPolicy(policy: IManagedPolicy) {\n    this.managedPolicies.push(policy);\n  }\n\n  /**\n   * Attaches a policy to this user.\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToUser(this);\n  }\n\n  /**\n   * Adds an IAM statement to the default policy.\n   *\n   * @returns true\n   */\n  public addToPolicy(statement: PolicyStatement): boolean {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.defaultPolicy.attachToUser(this);\n    }\n\n    this.defaultPolicy.addStatements(statement);\n    return true;\n  }\n\n  private parseLoginProfile(props: UserProps): CfnUser.LoginProfileProperty | undefined {\n    if (props.password) {\n      return {\n        password: props.password.toString(),\n        passwordResetRequired: props.passwordResetRequired\n      };\n    }\n\n    if (props.passwordResetRequired) {\n      throw new Error('Cannot set \"passwordResetRequired\" without specifying \"initialPassword\"');\n    }\n\n    return undefined; // no console access\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.js","sourceRoot":"","sources":["user.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, Lazy, Resource, SecretValue } from '@aws-cdk/core';\nimport { IGroup } from './group';\nimport { CfnUser } from './iam.generated';\nimport { IIdentity } from './identity-base';\nimport { IManagedPolicy } from './managed-policy';\nimport { Policy } from './policy';\nimport { PolicyStatement } from './policy-statement';\nimport { ArnPrincipal, PrincipalPolicyFragment } from './principals';\nimport { IPrincipal } from './principals';\nimport { AttachedPolicies, undefinedIfEmpty } from './util';\n\nexport interface IUser extends IIdentity {\n  readonly userName: string;\n  addToGroup(group: IGroup): void;\n}\n\nexport interface UserProps {\n  /**\n   * Groups to add this user to. You can also use `addToGroup` to add this\n   * user to a group.\n   *\n   * @default - No groups.\n   */\n  readonly groups?: IGroup[];\n\n  /**\n   * A list of managed policies associated with this role.\n   *\n   * You can add managed policies later using\n   * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.\n   *\n   * @default - No managed policies.\n   */\n  readonly managedPolicies?: IManagedPolicy[];\n\n  /**\n   * The path for the user name. For more information about paths, see IAM\n   * Identifiers in the IAM User Guide.\n   *\n   * @default /\n   */\n  readonly path?: string;\n\n  /**\n   * AWS supports permissions boundaries for IAM entities (users or roles).\n   * A permissions boundary is an advanced feature for using a managed policy\n   * to set the maximum permissions that an identity-based policy can grant to\n   * an IAM entity. An entity's permissions boundary allows it to perform only\n   * the actions that are allowed by both its identity-based policies and its\n   * permissions boundaries.\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-permissionsboundary\n   * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html\n   *\n   * @default - No permissions boundary.\n   */\n  readonly permissionsBoundary?: IManagedPolicy;\n\n  /**\n   * A name for the IAM user. For valid values, see the UserName parameter for\n   * the CreateUser action in the IAM API Reference. If you don't specify a\n   * name, AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the user name.\n   *\n   * If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   *\n   * @default Generated by CloudFormation (recommended)\n   */\n  readonly userName?: string;\n\n  /**\n   * The password for the user. This is required so the user can access the\n   * AWS Management Console.\n   *\n   * You can use `SecretValue.plainText` to specify a password in plain text or\n   * use `secretsmanager.Secret.fromSecretAttributes` to reference a secret in\n   * Secrets Manager.\n   *\n   * @default User won't be able to access the management console without a password.\n   */\n  readonly password?: SecretValue;\n\n  /**\n   * Specifies whether the user is required to set a new password the next\n   * time the user logs in to the AWS Management Console.\n   *\n   * If this is set to 'true', you must also specify \"initialPassword\".\n   *\n   * @default false\n   */\n  readonly passwordResetRequired?: boolean;\n}\n\nexport class User extends Resource implements IIdentity {\n  public readonly grantPrincipal: IPrincipal = this;\n  public readonly assumeRoleAction: string = 'sts:AssumeRole';\n\n  /**\n   * An attribute that represents the user name.\n   * @attribute\n   */\n  public readonly userName: string;\n\n  /**\n   * An attribute that represents the user's ARN.\n   * @attribute\n   */\n  public readonly userArn: string;\n\n  /**\n   * Returns the permissions boundary attached to this user\n   */\n  public readonly permissionsBoundary?: IManagedPolicy;\n\n  public readonly policyFragment: PrincipalPolicyFragment;\n\n  private readonly groups = new Array<any>();\n  private readonly managedPolicies = new Array<IManagedPolicy>();\n  private readonly attachedPolicies = new AttachedPolicies();\n  private defaultPolicy?: Policy;\n\n  constructor(scope: Construct, id: string, props: UserProps = {}) {\n    super(scope, id, {\n      physicalName: props.userName,\n    });\n\n    this.managedPolicies.push(...props.managedPolicies || []);\n    this.permissionsBoundary = props.permissionsBoundary;\n\n    const user = new CfnUser(this, 'Resource', {\n      userName: this.physicalName,\n      groups: undefinedIfEmpty(() => this.groups),\n      managedPolicyArns: Lazy.listValue({ produce: () => this.managedPolicies.map(p => p.managedPolicyArn) }, { omitEmpty: true }),\n      path: props.path,\n      permissionsBoundary: this.permissionsBoundary ? this.permissionsBoundary.managedPolicyArn : undefined,\n      loginProfile: this.parseLoginProfile(props)\n    });\n\n    this.userName = this.getResourceNameAttribute(user.ref);\n    this.userArn = this.getResourceArnAttribute(user.attrArn, {\n      region: '', // IAM is global in each partition\n      service: 'iam',\n      resource: 'user',\n      resourceName: this.physicalName,\n    });\n\n    this.policyFragment = new ArnPrincipal(this.userArn).policyFragment;\n\n    if (props.groups) {\n      props.groups.forEach(g => this.addToGroup(g));\n    }\n  }\n\n  /**\n   * Adds this user to a group.\n   */\n  public addToGroup(group: IGroup) {\n    this.groups.push(group.groupName);\n  }\n\n  /**\n   * Attaches a managed policy to the user.\n   * @param policy The managed policy to attach.\n   */\n  public addManagedPolicy(policy: IManagedPolicy) {\n    if (this.managedPolicies.find(mp => mp === policy)) { return; }\n    this.managedPolicies.push(policy);\n  }\n\n  /**\n   * Attaches a policy to this user.\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToUser(this);\n  }\n\n  /**\n   * Adds an IAM statement to the default policy.\n   *\n   * @returns true\n   */\n  public addToPolicy(statement: PolicyStatement): boolean {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.defaultPolicy.attachToUser(this);\n    }\n\n    this.defaultPolicy.addStatements(statement);\n    return true;\n  }\n\n  private parseLoginProfile(props: UserProps): CfnUser.LoginProfileProperty | undefined {\n    if (props.password) {\n      return {\n        password: props.password.toString(),\n        passwordResetRequired: props.passwordResetRequired\n      };\n    }\n\n    if (props.passwordResetRequired) {\n      throw new Error('Cannot set \"passwordResetRequired\" without specifying \"initialPassword\"');\n    }\n\n    return undefined; // no console access\n  }\n}\n"]}

package.json

 {
   "name": "@aws-cdk/aws-iam",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "CDK routines for easily assigning correct and minimal IAM permissions",
@@ -67,3 +67,3 @@ "main": "lib/index.js",
   "devDependencies": {
-    "@aws-cdk/assert": "^1.3.0",
+    "@aws-cdk/assert": "^1.4.0",
     "cdk-build-tools": "file:../../../tools/cdk-build-tools",
@@ -75,8 +75,8 @@ "cdk-integ-tools": "file:../../../tools/cdk-integ-tools",
   "dependencies": {
-    "@aws-cdk/core": "^1.3.0",
-    "@aws-cdk/region-info": "^1.3.0"
+    "@aws-cdk/core": "^1.4.0",
+    "@aws-cdk/region-info": "^1.4.0"
   },
   "peerDependencies": {
-    "@aws-cdk/core": "^1.3.0",
-    "@aws-cdk/region-info": "^1.3.0"
+    "@aws-cdk/core": "^1.4.0",
+    "@aws-cdk/region-info": "^1.4.0"
   },
@@ -87,3 +87,9 @@ "homepage": "https://github.com/aws/aws-cdk",
   },
+  "awslint": {
+    "exclude": [
+      "construct-interface-extends-iconstruct:@aws-cdk/aws-iam.IManagedPolicy",
+      "resource-interface-extends-resource:@aws-cdk/aws-iam.IManagedPolicy"
+    ]
+  },
   "stability": "stable"
 }

README.md

@@ -22,3 +22,3 @@ ## AWS Identity and Access Management Construct Library
 
-Managed policies can be attached using `xxx.attachManagedPolicy(arn)`:
+Managed policies can be attached using `xxx.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`:
 
@@ -25,0 +25,0 @@ [attaching managed policies](test/example.managedpolicy.lit.ts)

test/example.external-id.lit.js

@@ -11,3 +11,3 @@ "use strict";
             assumedBy: new iam.AccountPrincipal('123456789012'),
-            externalId: 'SUPPLY-ME',
+            externalIds: ['SUPPLY-ME'],
         });
@@ -19,2 +19,2 @@ /// !hide
 exports.ExampleConstruct = ExampleConstruct;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhhbXBsZS5leHRlcm5hbC1pZC5saXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJleGFtcGxlLmV4dGVybmFsLWlkLmxpdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHFDQUFzQztBQUN0Qyw4QkFBK0I7QUFFL0IsTUFBYSxnQkFBaUIsU0FBUSxHQUFHLENBQUMsU0FBUztJQUNqRCxZQUFZLEtBQW9CLEVBQUUsRUFBVTtRQUMxQyxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLFNBQVM7UUFDVCxNQUFNLElBQUksR0FBRyxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLFFBQVEsRUFBRTtZQUN4QyxTQUFTLEVBQUUsSUFBSSxHQUFHLENBQUMsZ0JBQWdCLENBQUMsY0FBYyxDQUFDO1lBQ25ELFVBQVUsRUFBRSxXQUFXO1NBQ3hCLENBQUMsQ0FBQztRQUNILFNBQVM7UUFFVCxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3RCLENBQUM7Q0FDRjtBQWJELDRDQWFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGNkayA9IHJlcXVpcmUoJ0Bhd3MtY2RrL2NvcmUnKTtcbmltcG9ydCBpYW0gPSByZXF1aXJlKCcuLi9saWInKTtcblxuZXhwb3J0IGNsYXNzIEV4YW1wbGVDb25zdHJ1Y3QgZXh0ZW5kcyBjZGsuQ29uc3RydWN0IHtcbiAgY29uc3RydWN0b3Ioc2NvcGU6IGNkay5Db25zdHJ1Y3QsIGlkOiBzdHJpbmcpIHtcbiAgICBzdXBlcihzY29wZSwgaWQpO1xuXG4gICAgLy8vICFzaG93XG4gICAgY29uc3Qgcm9sZSA9IG5ldyBpYW0uUm9sZSh0aGlzLCAnTXlSb2xlJywge1xuICAgICAgYXNzdW1lZEJ5OiBuZXcgaWFtLkFjY291bnRQcmluY2lwYWwoJzEyMzQ1Njc4OTAxMicpLFxuICAgICAgZXh0ZXJuYWxJZDogJ1NVUFBMWS1NRScsXG4gICAgfSk7XG4gICAgLy8vICFoaWRlXG5cbiAgICBBcnJheS5pc0FycmF5KHJvbGUpO1xuICB9XG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhhbXBsZS5leHRlcm5hbC1pZC5saXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJleGFtcGxlLmV4dGVybmFsLWlkLmxpdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHFDQUFzQztBQUN0Qyw4QkFBK0I7QUFFL0IsTUFBYSxnQkFBaUIsU0FBUSxHQUFHLENBQUMsU0FBUztJQUNqRCxZQUFZLEtBQW9CLEVBQUUsRUFBVTtRQUMxQyxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLFNBQVM7UUFDVCxNQUFNLElBQUksR0FBRyxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLFFBQVEsRUFBRTtZQUN4QyxTQUFTLEVBQUUsSUFBSSxHQUFHLENBQUMsZ0JBQWdCLENBQUMsY0FBYyxDQUFDO1lBQ25ELFdBQVcsRUFBRSxDQUFDLFdBQVcsQ0FBQztTQUMzQixDQUFDLENBQUM7UUFDSCxTQUFTO1FBRVQsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN0QixDQUFDO0NBQ0Y7QUFiRCw0Q0FhQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBjZGsgPSByZXF1aXJlKCdAYXdzLWNkay9jb3JlJyk7XG5pbXBvcnQgaWFtID0gcmVxdWlyZSgnLi4vbGliJyk7XG5cbmV4cG9ydCBjbGFzcyBFeGFtcGxlQ29uc3RydWN0IGV4dGVuZHMgY2RrLkNvbnN0cnVjdCB7XG4gIGNvbnN0cnVjdG9yKHNjb3BlOiBjZGsuQ29uc3RydWN0LCBpZDogc3RyaW5nKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcblxuICAgIC8vLyAhc2hvd1xuICAgIGNvbnN0IHJvbGUgPSBuZXcgaWFtLlJvbGUodGhpcywgJ015Um9sZScsIHtcbiAgICAgIGFzc3VtZWRCeTogbmV3IGlhbS5BY2NvdW50UHJpbmNpcGFsKCcxMjM0NTY3ODkwMTInKSxcbiAgICAgIGV4dGVybmFsSWRzOiBbJ1NVUFBMWS1NRSddLFxuICAgIH0pO1xuICAgIC8vLyAhaGlkZVxuXG4gICAgQXJyYXkuaXNBcnJheShyb2xlKTtcbiAgfVxufSJdfQ==

test/integ.role.js

@@ -17,5 +17,5 @@ "use strict";
     assumedBy: new lib_1.AccountRootPrincipal(),
-    externalId: 'supply-me',
+    externalIds: ['supply-me'],
 });
 app.synth();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

test/test.managed-policy.d.ts

 import { Test } from 'nodeunit';
 declare const _default: {
-    'simple managed policy'(test: Test): void;
+    'simple AWS managed policy'(test: Test): void;
+    'simple customer managed policy'(test: Test): void;
+    'managed policy with statements'(test: Test): void;
+    'policy name can be omitted, in which case the logical id will be used'(test: Test): void;
+    'via props, managed policy can be attached to users, groups and roles and permissions, description and path can be added'(test: Test): void;
+    'idempotent if a principal (user/group/role) is attached twice'(test: Test): void;
+    'users, groups, roles and permissions can be added using methods'(test: Test): void;
+    'policy can be attached to users, groups or role via methods on the principal'(test: Test): void;
+    'policy from AWS managed policy lookup can be attached to users, groups or role via methods on the principal'(test: Test): void;
+    'policy from customer managed policy lookup can be attached to users, groups or role via methods'(test: Test): void;
+    'fails if policy document is empty'(test: Test): void;
 };
 export = _default;

test/test.managed-policy.js

 "use strict";
+const assert_1 = require("@aws-cdk/assert");
 const cdk = require("@aws-cdk/core");
 const lib_1 = require("../lib");
 module.exports = {
-    'simple managed policy'(test) {
+    'simple AWS managed policy'(test) {
         const stack = new cdk.Stack();
@@ -17,3 +18,445 @@ const mp = lib_1.ManagedPolicy.fromAwsManagedPolicyName("service-role/SomePolicy");
     },
+    'simple customer managed policy'(test) {
+        const stack = new cdk.Stack();
+        const mp = lib_1.ManagedPolicy.fromManagedPolicyName(stack, 'MyCustomerManagedPolicy', "SomeCustomerPolicy");
+        test.deepEqual(stack.resolve(mp.managedPolicyArn), {
+            "Fn::Join": ['', [
+                    'arn:',
+                    { Ref: 'AWS::Partition' },
+                    ':iam::',
+                    { Ref: 'AWS::AccountId' },
+                    ':policy/SomeCustomerPolicy'
+                ]]
+        });
+        test.done();
+    },
+    'managed policy with statements'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        const policy = new lib_1.ManagedPolicy(stack, 'MyManagedPolicy', { managedPolicyName: 'MyManagedPolicyName' });
+        policy.addStatements(new lib_1.PolicyStatement({ resources: ['*'], actions: ['sqs:SendMessage'] }));
+        policy.addStatements(new lib_1.PolicyStatement({ resources: ['arn'], actions: ['sns:Subscribe'] }));
+        const group = new lib_1.Group(stack, 'MyGroup');
+        group.addManagedPolicy(policy);
+        assert_1.expect(stack).toMatch({
+            Resources: {
+                MyManagedPolicy9F3720AE: {
+                    Type: 'AWS::IAM::ManagedPolicy',
+                    Properties: {
+                        ManagedPolicyName: 'MyManagedPolicyName',
+                        PolicyDocument: {
+                            Statement: [{ Action: 'sqs:SendMessage', Effect: 'Allow', Resource: '*' },
+                                { Action: 'sns:Subscribe', Effect: 'Allow', Resource: 'arn' }],
+                            Version: '2012-10-17'
+                        },
+                        Path: '/',
+                        Description: ''
+                    }
+                },
+                MyGroupCBA54B1B: {
+                    Type: 'AWS::IAM::Group',
+                    Properties: {
+                        ManagedPolicyArns: [
+                            { Ref: 'MyManagedPolicy9F3720AE' }
+                        ]
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'policy name can be omitted, in which case the logical id will be used'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        const policy = new lib_1.ManagedPolicy(stack, 'MyManagedPolicy');
+        policy.addStatements(new lib_1.PolicyStatement({ resources: ['*'], actions: ['sqs:SendMessage'] }));
+        policy.addStatements(new lib_1.PolicyStatement({ resources: ['arn'], actions: ['sns:Subscribe'] }));
+        const group = new lib_1.Group(stack, 'MyGroup');
+        group.addManagedPolicy(policy);
+        assert_1.expect(stack).toMatch({
+            Resources: {
+                MyManagedPolicy9F3720AE: {
+                    Type: 'AWS::IAM::ManagedPolicy',
+                    Properties: {
+                        PolicyDocument: {
+                            Statement: [{ Action: 'sqs:SendMessage', Effect: 'Allow', Resource: '*' },
+                                { Action: 'sns:Subscribe', Effect: 'Allow', Resource: 'arn' }],
+                            Version: '2012-10-17'
+                        },
+                        Path: '/',
+                        Description: ''
+                    }
+                },
+                MyGroupCBA54B1B: {
+                    Type: 'AWS::IAM::Group',
+                    Properties: {
+                        ManagedPolicyArns: [
+                            { Ref: 'MyManagedPolicy9F3720AE' }
+                        ]
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'via props, managed policy can be attached to users, groups and roles and permissions, description and path can be added'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        const user1 = new lib_1.User(stack, 'User1');
+        const group1 = new lib_1.Group(stack, 'Group1');
+        const role1 = new lib_1.Role(stack, 'Role1', {
+            assumedBy: new lib_1.ServicePrincipal('test.service')
+        });
+        new lib_1.ManagedPolicy(stack, 'MyTestManagedPolicy', {
+            managedPolicyName: 'Foo',
+            users: [user1],
+            groups: [group1],
+            roles: [role1],
+            description: 'My Policy Description',
+            path: 'tahiti/is/a/magical/place',
+            statements: [new lib_1.PolicyStatement({ resources: ['*'], actions: ['dynamodb:PutItem'] })],
+        });
+        assert_1.expect(stack).toMatch({
+            Resources: {
+                User1E278A736: { Type: 'AWS::IAM::User' },
+                Group1BEBD4686: { Type: 'AWS::IAM::Group' },
+                Role13A5C70C1: {
+                    Type: 'AWS::IAM::Role',
+                    Properties: {
+                        AssumeRolePolicyDocument: {
+                            Statement: [{
+                                    Action: 'sts:AssumeRole',
+                                    Effect: 'Allow',
+                                    Principal: { Service: 'test.service' }
+                                }],
+                            Version: '2012-10-17'
+                        }
+                    }
+                },
+                MyTestManagedPolicy6535D9F5: {
+                    Type: 'AWS::IAM::ManagedPolicy',
+                    Properties: {
+                        Groups: [{ Ref: 'Group1BEBD4686' }],
+                        Description: 'My Policy Description',
+                        Path: 'tahiti/is/a/magical/place',
+                        PolicyDocument: {
+                            Statement: [{ Action: 'dynamodb:PutItem', Effect: 'Allow', Resource: '*' }],
+                            Version: '2012-10-17'
+                        },
+                        ManagedPolicyName: 'Foo',
+                        Roles: [{ Ref: 'Role13A5C70C1' }],
+                        Users: [{ Ref: 'User1E278A736' }]
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'idempotent if a principal (user/group/role) is attached twice'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        const p = new lib_1.ManagedPolicy(stack, 'MyManagedPolicy');
+        p.addStatements(new lib_1.PolicyStatement({ actions: ['*'], resources: ['*'] }));
+        const user = new lib_1.User(stack, 'MyUser');
+        p.attachToUser(user);
+        p.attachToUser(user);
+        const group = new lib_1.Group(stack, 'MyGroup');
+        p.attachToGroup(group);
+        p.attachToGroup(group);
+        const role = new lib_1.Role(stack, 'MyRole', {
+            assumedBy: new lib_1.ServicePrincipal('test.service')
+        });
+        p.attachToRole(role);
+        p.attachToRole(role);
+        assert_1.expect(stack).toMatch({
+            Resources: {
+                MyManagedPolicy9F3720AE: {
+                    Type: 'AWS::IAM::ManagedPolicy',
+                    Properties: {
+                        PolicyDocument: {
+                            Statement: [{ Action: '*', Effect: 'Allow', Resource: '*' }],
+                            Version: '2012-10-17'
+                        },
+                        Description: '',
+                        Path: '/',
+                        Users: [{ Ref: 'MyUserDC45028B' }],
+                        Groups: [{ Ref: 'MyGroupCBA54B1B' }],
+                        Roles: [{ Ref: 'MyRoleF48FFE04' }]
+                    }
+                },
+                MyUserDC45028B: { Type: 'AWS::IAM::User' },
+                MyGroupCBA54B1B: { Type: 'AWS::IAM::Group' },
+                MyRoleF48FFE04: {
+                    Type: 'AWS::IAM::Role',
+                    Properties: {
+                        AssumeRolePolicyDocument: {
+                            Statement: [{
+                                    Action: 'sts:AssumeRole',
+                                    Effect: 'Allow',
+                                    Principal: { Service: 'test.service' }
+                                }],
+                            Version: '2012-10-17'
+                        }
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'users, groups, roles and permissions can be added using methods'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        const p = new lib_1.ManagedPolicy(stack, 'MyManagedPolicy', {
+            managedPolicyName: 'Foo',
+        });
+        p.attachToUser(new lib_1.User(stack, 'User1'));
+        p.attachToUser(new lib_1.User(stack, 'User2'));
+        p.attachToGroup(new lib_1.Group(stack, 'Group1'));
+        p.attachToRole(new lib_1.Role(stack, 'Role1', { assumedBy: new lib_1.ServicePrincipal('test.service') }));
+        p.addStatements(new lib_1.PolicyStatement({ resources: ['*'], actions: ['dynamodb:GetItem'] }));
+        assert_1.expect(stack).toMatch({
+            Resources: {
+                MyManagedPolicy9F3720AE: {
+                    Type: 'AWS::IAM::ManagedPolicy',
+                    Properties: {
+                        Groups: [{ Ref: 'Group1BEBD4686' }],
+                        PolicyDocument: {
+                            Statement: [{ Action: 'dynamodb:GetItem', Effect: 'Allow', Resource: '*' }],
+                            Version: '2012-10-17'
+                        },
+                        ManagedPolicyName: 'Foo',
+                        Description: '',
+                        Path: '/',
+                        Roles: [{ Ref: 'Role13A5C70C1' }],
+                        Users: [{ Ref: 'User1E278A736' }, { Ref: 'User21F1486D1' }]
+                    }
+                },
+                User1E278A736: { Type: 'AWS::IAM::User' },
+                User21F1486D1: { Type: 'AWS::IAM::User' },
+                Group1BEBD4686: { Type: 'AWS::IAM::Group' },
+                Role13A5C70C1: {
+                    Type: 'AWS::IAM::Role',
+                    Properties: {
+                        AssumeRolePolicyDocument: {
+                            Statement: [{
+                                    Action: 'sts:AssumeRole',
+                                    Effect: 'Allow',
+                                    Principal: { Service: 'test.service' }
+                                }],
+                            Version: '2012-10-17'
+                        }
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'policy can be attached to users, groups or role via methods on the principal'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        const policy = new lib_1.ManagedPolicy(stack, 'MyManagedPolicy');
+        const user = new lib_1.User(stack, 'MyUser');
+        const group = new lib_1.Group(stack, 'MyGroup');
+        const role = new lib_1.Role(stack, 'MyRole', { assumedBy: new lib_1.ServicePrincipal('test.service') });
+        user.addManagedPolicy(policy);
+        group.addManagedPolicy(policy);
+        role.addManagedPolicy(policy);
+        policy.addStatements(new lib_1.PolicyStatement({ resources: ['*'], actions: ['*'] }));
+        assert_1.expect(stack).toMatch({
+            Resources: {
+                MyManagedPolicy9F3720AE: {
+                    Type: 'AWS::IAM::ManagedPolicy',
+                    Properties: {
+                        PolicyDocument: {
+                            Statement: [{ Action: '*', Effect: 'Allow', Resource: '*' }],
+                            Version: '2012-10-17'
+                        },
+                        Description: '',
+                        Path: '/'
+                    }
+                },
+                MyUserDC45028B: { Type: 'AWS::IAM::User', Properties: { ManagedPolicyArns: [{ Ref: 'MyManagedPolicy9F3720AE' }] } },
+                MyGroupCBA54B1B: { Type: 'AWS::IAM::Group', Properties: { ManagedPolicyArns: [{ Ref: 'MyManagedPolicy9F3720AE' }] } },
+                MyRoleF48FFE04: {
+                    Type: 'AWS::IAM::Role',
+                    Properties: {
+                        ManagedPolicyArns: [{ Ref: 'MyManagedPolicy9F3720AE' }],
+                        AssumeRolePolicyDocument: {
+                            Statement: [{
+                                    Action: 'sts:AssumeRole',
+                                    Effect: 'Allow',
+                                    Principal: { Service: 'test.service' }
+                                }],
+                            Version: '2012-10-17'
+                        }
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'policy from AWS managed policy lookup can be attached to users, groups or role via methods on the principal'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        const policy = lib_1.ManagedPolicy.fromAwsManagedPolicyName('AnAWSManagedPolicy');
+        const user = new lib_1.User(stack, 'MyUser');
+        const group = new lib_1.Group(stack, 'MyGroup');
+        const role = new lib_1.Role(stack, 'MyRole', { assumedBy: new lib_1.ServicePrincipal('test.service') });
+        user.addManagedPolicy(policy);
+        group.addManagedPolicy(policy);
+        role.addManagedPolicy(policy);
+        assert_1.expect(stack).toMatch({
+            Resources: {
+                MyUserDC45028B: {
+                    Type: 'AWS::IAM::User',
+                    Properties: {
+                        ManagedPolicyArns: [
+                            {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:",
+                                        { Ref: "AWS::Partition" },
+                                        ":iam::aws:policy/AnAWSManagedPolicy"
+                                    ]
+                                ]
+                            }
+                        ]
+                    }
+                },
+                MyGroupCBA54B1B: {
+                    Type: 'AWS::IAM::Group',
+                    Properties: {
+                        ManagedPolicyArns: [
+                            {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:",
+                                        { Ref: "AWS::Partition" },
+                                        ":iam::aws:policy/AnAWSManagedPolicy"
+                                    ]
+                                ]
+                            }
+                        ]
+                    }
+                },
+                MyRoleF48FFE04: {
+                    Type: 'AWS::IAM::Role',
+                    Properties: {
+                        ManagedPolicyArns: [
+                            {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:",
+                                        { Ref: "AWS::Partition" },
+                                        ":iam::aws:policy/AnAWSManagedPolicy"
+                                    ]
+                                ]
+                            }
+                        ],
+                        AssumeRolePolicyDocument: {
+                            Statement: [{
+                                    Action: 'sts:AssumeRole',
+                                    Effect: 'Allow',
+                                    Principal: { Service: 'test.service' }
+                                }],
+                            Version: '2012-10-17'
+                        }
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'policy from customer managed policy lookup can be attached to users, groups or role via methods'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        const policy = lib_1.ManagedPolicy.fromManagedPolicyName(stack, 'MyManagedPolicy', 'ACustomerManagedPolicyName');
+        const user = new lib_1.User(stack, 'MyUser');
+        const group = new lib_1.Group(stack, 'MyGroup');
+        const role = new lib_1.Role(stack, 'MyRole', { assumedBy: new lib_1.ServicePrincipal('test.service') });
+        user.addManagedPolicy(policy);
+        group.addManagedPolicy(policy);
+        role.addManagedPolicy(policy);
+        assert_1.expect(stack).toMatch({
+            Resources: {
+                MyUserDC45028B: {
+                    Type: 'AWS::IAM::User',
+                    Properties: {
+                        ManagedPolicyArns: [
+                            {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:",
+                                        { Ref: "AWS::Partition" },
+                                        ":iam::",
+                                        { Ref: "AWS::AccountId" },
+                                        ":policy/ACustomerManagedPolicyName"
+                                    ]
+                                ]
+                            }
+                        ]
+                    }
+                },
+                MyGroupCBA54B1B: {
+                    Type: 'AWS::IAM::Group',
+                    Properties: {
+                        ManagedPolicyArns: [
+                            {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:",
+                                        { Ref: "AWS::Partition" },
+                                        ":iam::",
+                                        { Ref: "AWS::AccountId" },
+                                        ":policy/ACustomerManagedPolicyName"
+                                    ]
+                                ]
+                            }
+                        ]
+                    }
+                },
+                MyRoleF48FFE04: {
+                    Type: 'AWS::IAM::Role',
+                    Properties: {
+                        ManagedPolicyArns: [
+                            {
+                                "Fn::Join": [
+                                    "",
+                                    [
+                                        "arn:",
+                                        { Ref: "AWS::Partition" },
+                                        ":iam::",
+                                        { Ref: "AWS::AccountId" },
+                                        ":policy/ACustomerManagedPolicyName"
+                                    ]
+                                ]
+                            }
+                        ],
+                        AssumeRolePolicyDocument: {
+                            Statement: [{
+                                    Action: 'sts:AssumeRole',
+                                    Effect: 'Allow',
+                                    Principal: { Service: 'test.service' }
+                                }],
+                            Version: '2012-10-17'
+                        }
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'fails if policy document is empty'(test) {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'MyStack');
+        new lib_1.ManagedPolicy(stack, 'MyPolicy');
+        test.throws(() => app.synth(), /Managed Policy is empty. You must add statements to the policy/);
+        test.done();
+    },
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5tYW5hZ2VkLXBvbGljeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QubWFuYWdlZC1wb2xpY3kudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHFDQUFzQztBQUV0QyxnQ0FBdUM7QUFFdkMsaUJBQVM7SUFDUCx1QkFBdUIsQ0FBQyxJQUFVO1FBQ2hDLE1BQU0sS0FBSyxHQUFHLElBQUksR0FBRyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQzlCLE1BQU0sRUFBRSxHQUFHLG1CQUFhLENBQUMsd0JBQXdCLENBQUMseUJBQXlCLENBQUMsQ0FBQztRQUU3RSxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLGdCQUFnQixDQUFDLEVBQUU7WUFDakQsVUFBVSxFQUFFLENBQUMsRUFBRSxFQUFFO29CQUNmLE1BQU07b0JBQ04sRUFBRSxHQUFHLEVBQUUsZ0JBQWdCLEVBQUU7b0JBQ3pCLDBDQUEwQztpQkFDM0MsQ0FBQztTQUNILENBQUMsQ0FBQztRQUVILElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNkLENBQUM7Q0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGNkayA9IHJlcXVpcmUoJ0Bhd3MtY2RrL2NvcmUnKTtcbmltcG9ydCB7IFRlc3QgfSBmcm9tICdub2RldW5pdCc7XG5pbXBvcnQgeyBNYW5hZ2VkUG9saWN5IH0gZnJvbSAnLi4vbGliJztcblxuZXhwb3J0ID0ge1xuICAnc2ltcGxlIG1hbmFnZWQgcG9saWN5Jyh0ZXN0OiBUZXN0KSB7XG4gICAgY29uc3Qgc3RhY2sgPSBuZXcgY2RrLlN0YWNrKCk7XG4gICAgY29uc3QgbXAgPSBNYW5hZ2VkUG9saWN5LmZyb21Bd3NNYW5hZ2VkUG9saWN5TmFtZShcInNlcnZpY2Utcm9sZS9Tb21lUG9saWN5XCIpO1xuXG4gICAgdGVzdC5kZWVwRXF1YWwoc3RhY2sucmVzb2x2ZShtcC5tYW5hZ2VkUG9saWN5QXJuKSwge1xuICAgICAgXCJGbjo6Sm9pblwiOiBbJycsIFtcbiAgICAgICAgJ2FybjonLFxuICAgICAgICB7IFJlZjogJ0FXUzo6UGFydGl0aW9uJyB9LFxuICAgICAgICAnOmlhbTo6YXdzOnBvbGljeS9zZXJ2aWNlLXJvbGUvU29tZVBvbGljeSdcbiAgICAgIF1dXG4gICAgfSk7XG5cbiAgICB0ZXN0LmRvbmUoKTtcbiAgfSxcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.managed-policy.js","sourceRoot":"","sources":["test.managed-policy.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect } from '@aws-cdk/assert';\nimport cdk = require('@aws-cdk/core');\nimport { Test } from 'nodeunit';\nimport { Group, ManagedPolicy, PolicyStatement, Role, ServicePrincipal, User } from '../lib';\n\nexport = {\n  'simple AWS managed policy'(test: Test) {\n    const stack = new cdk.Stack();\n    const mp = ManagedPolicy.fromAwsManagedPolicyName(\"service-role/SomePolicy\");\n\n    test.deepEqual(stack.resolve(mp.managedPolicyArn), {\n      \"Fn::Join\": ['', [\n        'arn:',\n        { Ref: 'AWS::Partition' },\n        ':iam::aws:policy/service-role/SomePolicy'\n      ]]\n    });\n\n    test.done();\n  },\n\n  'simple customer managed policy'(test: Test) {\n    const stack = new cdk.Stack();\n    const mp = ManagedPolicy.fromManagedPolicyName(stack, 'MyCustomerManagedPolicy', \"SomeCustomerPolicy\");\n\n    test.deepEqual(stack.resolve(mp.managedPolicyArn), {\n      \"Fn::Join\": ['', [\n        'arn:',\n        { Ref: 'AWS::Partition' },\n        ':iam::',\n        { Ref: 'AWS::AccountId' },\n        ':policy/SomeCustomerPolicy'\n      ]]\n    });\n\n    test.done();\n  },\n\n  'managed policy with statements'(test: Test) {\n    const app = new cdk.App();\n    const stack = new cdk.Stack(app, 'MyStack');\n\n    const policy = new ManagedPolicy(stack, 'MyManagedPolicy', { managedPolicyName: 'MyManagedPolicyName' });\n    policy.addStatements(new PolicyStatement({ resources: ['*'], actions: ['sqs:SendMessage'] }));\n    policy.addStatements(new PolicyStatement({ resources: ['arn'], actions: ['sns:Subscribe'] }));\n\n    const group = new Group(stack, 'MyGroup');\n    group.addManagedPolicy(policy);\n\n    expect(stack).toMatch({\n      Resources: {\n        MyManagedPolicy9F3720AE: {\n          Type: 'AWS::IAM::ManagedPolicy',\n          Properties: {\n            ManagedPolicyName: 'MyManagedPolicyName',\n            PolicyDocument: {\n              Statement:\n                [{ Action: 'sqs:SendMessage', Effect: 'Allow', Resource: '*' },\n                { Action: 'sns:Subscribe', Effect: 'Allow', Resource: 'arn' }],\n              Version: '2012-10-17'\n            },\n            Path: '/',\n            Description: ''\n          }\n        },\n        MyGroupCBA54B1B: {\n          Type: 'AWS::IAM::Group',\n          Properties: {\n            ManagedPolicyArns: [\n              { Ref: 'MyManagedPolicy9F3720AE' }\n            ]\n          }\n        }\n      }\n    });\n    test.done();\n  },\n\n  'policy name can be omitted, in which case the logical id will be used'(test: Test) {\n    const app = new cdk.App();\n    const stack = new cdk.Stack(app, 'MyStack');\n\n    const policy = new ManagedPolicy(stack, 'MyManagedPolicy');\n    policy.addStatements(new PolicyStatement({ resources: ['*'], actions: ['sqs:SendMessage'] }));\n    policy.addStatements(new PolicyStatement({ resources: ['arn'], actions: ['sns:Subscribe'] }));\n\n    const group = new Group(stack, 'MyGroup');\n    group.addManagedPolicy(policy);\n\n    expect(stack).toMatch({\n      Resources: {\n        MyManagedPolicy9F3720AE: {\n          Type: 'AWS::IAM::ManagedPolicy',\n          Properties: {\n            PolicyDocument: {\n              Statement:\n                [{ Action: 'sqs:SendMessage', Effect: 'Allow', Resource: '*' },\n                { Action: 'sns:Subscribe', Effect: 'Allow', Resource: 'arn' }],\n              Version: '2012-10-17'\n            },\n            Path: '/',\n            Description: ''\n          }\n        },\n        MyGroupCBA54B1B: {\n          Type: 'AWS::IAM::Group',\n          Properties: {\n            ManagedPolicyArns: [\n              { Ref: 'MyManagedPolicy9F3720AE' }\n            ]\n          }\n        }\n      }\n    });\n    test.done();\n  },\n\n  'via props, managed policy can be attached to users, groups and roles and permissions, description and path can be added'(test: Test) {\n    const app = new cdk.App();\n\n    const stack = new cdk.Stack(app, 'MyStack');\n\n    const user1 = new User(stack, 'User1');\n    const group1 = new Group(stack, 'Group1');\n    const role1 = new Role(stack, 'Role1', {\n      assumedBy: new ServicePrincipal('test.service')\n    });\n\n    new ManagedPolicy(stack, 'MyTestManagedPolicy', {\n      managedPolicyName: 'Foo',\n      users: [ user1 ],\n      groups: [ group1 ],\n      roles: [ role1 ],\n      description: 'My Policy Description',\n      path: 'tahiti/is/a/magical/place',\n      statements: [ new PolicyStatement({ resources: ['*'], actions: ['dynamodb:PutItem'] }) ],\n    });\n\n    expect(stack).toMatch({\n      Resources: {\n        User1E278A736: { Type: 'AWS::IAM::User' },\n        Group1BEBD4686: { Type: 'AWS::IAM::Group' },\n        Role13A5C70C1: {\n          Type: 'AWS::IAM::Role',\n          Properties: {\n            AssumeRolePolicyDocument: {\n              Statement:\n                [{\n                  Action: 'sts:AssumeRole',\n                  Effect: 'Allow',\n                  Principal: { Service: 'test.service' }\n                }],\n              Version: '2012-10-17'\n            }\n          }\n        },\n        MyTestManagedPolicy6535D9F5: {\n          Type: 'AWS::IAM::ManagedPolicy',\n          Properties: {\n            Groups: [{ Ref: 'Group1BEBD4686' }],\n            Description: 'My Policy Description',\n            Path: 'tahiti/is/a/magical/place',\n            PolicyDocument: {\n              Statement:\n                [{ Action: 'dynamodb:PutItem', Effect: 'Allow', Resource: '*' }],\n              Version: '2012-10-17'\n            },\n            ManagedPolicyName: 'Foo',\n            Roles: [{ Ref: 'Role13A5C70C1' }],\n            Users: [{ Ref: 'User1E278A736' }]\n          }\n        }\n      }\n    });\n\n    test.done();\n  },\n\n  'idempotent if a principal (user/group/role) is attached twice'(test: Test) {\n    const app = new cdk.App();\n    const stack = new cdk.Stack(app, 'MyStack');\n    const p = new ManagedPolicy(stack, 'MyManagedPolicy');\n    p.addStatements(new PolicyStatement({ actions: ['*'], resources: ['*'] }));\n\n    const user = new User(stack, 'MyUser');\n    p.attachToUser(user);\n    p.attachToUser(user);\n\n    const group = new Group(stack, 'MyGroup');\n    p.attachToGroup(group);\n    p.attachToGroup(group);\n\n    const role = new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('test.service')\n    });\n    p.attachToRole(role);\n    p.attachToRole(role);\n\n    expect(stack).toMatch({\n      Resources: {\n        MyManagedPolicy9F3720AE: {\n          Type: 'AWS::IAM::ManagedPolicy',\n          Properties: {\n            PolicyDocument: {\n              Statement: [{ Action: '*', Effect: 'Allow', Resource: '*' }],\n              Version: '2012-10-17'\n            },\n            Description: '',\n            Path: '/',\n            Users: [{ Ref: 'MyUserDC45028B' }],\n            Groups: [{ Ref: 'MyGroupCBA54B1B' }],\n            Roles: [{ Ref: 'MyRoleF48FFE04' }]\n          }\n        },\n        MyUserDC45028B: { Type: 'AWS::IAM::User' },\n        MyGroupCBA54B1B: { Type: 'AWS::IAM::Group' },\n        MyRoleF48FFE04: {\n          Type: 'AWS::IAM::Role',\n          Properties: {\n            AssumeRolePolicyDocument: {\n              Statement:\n                [{\n                  Action: 'sts:AssumeRole',\n                  Effect: 'Allow',\n                  Principal: { Service: 'test.service' }\n                }],\n              Version: '2012-10-17'\n            }\n          }\n        }\n      }\n    });\n    test.done();\n  },\n\n  'users, groups, roles and permissions can be added using methods'(test: Test) {\n    const app = new cdk.App();\n\n    const stack = new cdk.Stack(app, 'MyStack');\n\n    const p = new ManagedPolicy(stack, 'MyManagedPolicy', {\n      managedPolicyName: 'Foo',\n    });\n\n    p.attachToUser(new User(stack, 'User1'));\n    p.attachToUser(new User(stack, 'User2'));\n    p.attachToGroup(new Group(stack, 'Group1'));\n    p.attachToRole(new Role(stack, 'Role1', { assumedBy: new ServicePrincipal('test.service') }));\n    p.addStatements(new PolicyStatement({ resources: ['*'], actions: ['dynamodb:GetItem'] }));\n\n    expect(stack).toMatch({\n      Resources: {\n        MyManagedPolicy9F3720AE: {\n          Type: 'AWS::IAM::ManagedPolicy',\n          Properties: {\n            Groups: [{ Ref: 'Group1BEBD4686' }],\n            PolicyDocument: {\n              Statement:\n                [{ Action: 'dynamodb:GetItem', Effect: 'Allow', Resource: '*' }],\n              Version: '2012-10-17'\n            },\n            ManagedPolicyName: 'Foo',\n            Description: '',\n            Path: '/',\n            Roles: [{ Ref: 'Role13A5C70C1' }],\n            Users: [{ Ref: 'User1E278A736' }, { Ref: 'User21F1486D1' }]\n          }\n        },\n        User1E278A736: { Type: 'AWS::IAM::User' },\n        User21F1486D1: { Type: 'AWS::IAM::User' },\n        Group1BEBD4686: { Type: 'AWS::IAM::Group' },\n        Role13A5C70C1: {\n          Type: 'AWS::IAM::Role',\n          Properties: {\n            AssumeRolePolicyDocument: {\n              Statement:\n                [{\n                  Action: 'sts:AssumeRole',\n                  Effect: 'Allow',\n                  Principal: { Service: 'test.service' }\n                }],\n              Version: '2012-10-17'\n            }\n          }\n        }\n      }\n    });\n    test.done();\n  },\n\n  'policy can be attached to users, groups or role via methods on the principal'(test: Test) {\n    const app = new cdk.App();\n    const stack = new cdk.Stack(app, 'MyStack');\n\n    const policy = new ManagedPolicy(stack, 'MyManagedPolicy');\n    const user = new User(stack, 'MyUser');\n    const group = new Group(stack, 'MyGroup');\n    const role = new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('test.service') });\n\n    user.addManagedPolicy(policy);\n    group.addManagedPolicy(policy);\n    role.addManagedPolicy(policy);\n\n    policy.addStatements(new PolicyStatement({ resources: ['*'], actions: ['*'] }));\n\n    expect(stack).toMatch({\n      Resources: {\n        MyManagedPolicy9F3720AE: {\n          Type: 'AWS::IAM::ManagedPolicy',\n          Properties: {\n            PolicyDocument: {\n              Statement: [{ Action: '*', Effect: 'Allow', Resource: '*' }],\n              Version: '2012-10-17'\n            },\n            Description: '',\n            Path: '/'\n          }\n        },\n        MyUserDC45028B: { Type: 'AWS::IAM::User', Properties: { ManagedPolicyArns: [{ Ref: 'MyManagedPolicy9F3720AE' }] } },\n        MyGroupCBA54B1B: { Type: 'AWS::IAM::Group', Properties: { ManagedPolicyArns: [{ Ref: 'MyManagedPolicy9F3720AE' }] } },\n        MyRoleF48FFE04: {\n          Type: 'AWS::IAM::Role',\n          Properties: {\n            ManagedPolicyArns: [{ Ref: 'MyManagedPolicy9F3720AE' }],\n            AssumeRolePolicyDocument: {\n              Statement:\n                [{\n                  Action: 'sts:AssumeRole',\n                  Effect: 'Allow',\n                  Principal: { Service: 'test.service' }\n                }],\n              Version: '2012-10-17'\n            }\n          }\n        }\n      }\n    });\n    test.done();\n  },\n\n  'policy from AWS managed policy lookup can be attached to users, groups or role via methods on the principal'(test: Test) {\n    const app = new cdk.App();\n    const stack = new cdk.Stack(app, 'MyStack');\n\n    const policy = ManagedPolicy.fromAwsManagedPolicyName('AnAWSManagedPolicy');\n    const user = new User(stack, 'MyUser');\n    const group = new Group(stack, 'MyGroup');\n    const role = new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('test.service') });\n\n    user.addManagedPolicy(policy);\n    group.addManagedPolicy(policy);\n    role.addManagedPolicy(policy);\n\n    expect(stack).toMatch({\n      Resources: {\n        MyUserDC45028B: {\n          Type: 'AWS::IAM::User',\n          Properties: {\n            ManagedPolicyArns: [\n              {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:\",\n                    { Ref: \"AWS::Partition\" },\n                    \":iam::aws:policy/AnAWSManagedPolicy\"\n                  ]\n                ]\n              }]\n          }\n        },\n        MyGroupCBA54B1B: {\n          Type: 'AWS::IAM::Group',\n          Properties: {\n            ManagedPolicyArns: [\n              {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:\",\n                    { Ref: \"AWS::Partition\" },\n                    \":iam::aws:policy/AnAWSManagedPolicy\"\n                  ]\n                ]\n              }]\n          }\n        },\n        MyRoleF48FFE04: {\n          Type: 'AWS::IAM::Role',\n          Properties: {\n            ManagedPolicyArns: [\n              {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:\",\n                    { Ref: \"AWS::Partition\" },\n                    \":iam::aws:policy/AnAWSManagedPolicy\"\n                  ]\n                ]\n              }],\n            AssumeRolePolicyDocument: {\n              Statement:\n                [{\n                  Action: 'sts:AssumeRole',\n                  Effect: 'Allow',\n                  Principal: { Service: 'test.service' }\n                }],\n              Version: '2012-10-17'\n            }\n          }\n        }\n      }\n    });\n    test.done();\n  },\n\n  'policy from customer managed policy lookup can be attached to users, groups or role via methods'(test: Test) {\n    const app = new cdk.App();\n    const stack = new cdk.Stack(app, 'MyStack');\n\n    const policy = ManagedPolicy.fromManagedPolicyName(stack, 'MyManagedPolicy', 'ACustomerManagedPolicyName');\n    const user = new User(stack, 'MyUser');\n    const group = new Group(stack, 'MyGroup');\n    const role = new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('test.service') });\n\n    user.addManagedPolicy(policy);\n    group.addManagedPolicy(policy);\n    role.addManagedPolicy(policy);\n\n    expect(stack).toMatch({\n      Resources: {\n        MyUserDC45028B: {\n          Type: 'AWS::IAM::User',\n          Properties: {\n            ManagedPolicyArns: [\n              {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:\",\n                    { Ref: \"AWS::Partition\" },\n                    \":iam::\",\n                    { Ref: \"AWS::AccountId\" },\n                    \":policy/ACustomerManagedPolicyName\"\n                  ]\n                ]\n              }]\n          }\n        },\n        MyGroupCBA54B1B: {\n          Type: 'AWS::IAM::Group',\n          Properties: {\n            ManagedPolicyArns: [\n              {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:\",\n                    { Ref: \"AWS::Partition\" },\n                    \":iam::\",\n                    { Ref: \"AWS::AccountId\" },\n                    \":policy/ACustomerManagedPolicyName\"\n                  ]\n                ]\n              }]\n          }\n        },\n        MyRoleF48FFE04: {\n          Type: 'AWS::IAM::Role',\n          Properties: {\n            ManagedPolicyArns: [\n              {\n                \"Fn::Join\": [\n                  \"\",\n                  [\n                    \"arn:\",\n                    { Ref: \"AWS::Partition\" },\n                    \":iam::\",\n                    { Ref: \"AWS::AccountId\" },\n                    \":policy/ACustomerManagedPolicyName\"\n                  ]\n                ]\n              }],\n            AssumeRolePolicyDocument: {\n              Statement:\n                [{\n                  Action: 'sts:AssumeRole',\n                  Effect: 'Allow',\n                  Principal: { Service: 'test.service' }\n                }],\n              Version: '2012-10-17'\n            }\n          }\n        }\n      }\n    });\n    test.done();\n  },\n\n  'fails if policy document is empty'(test: Test) {\n    const app = new cdk.App();\n    const stack = new cdk.Stack(app, 'MyStack');\n    new ManagedPolicy(stack, 'MyPolicy');\n    test.throws(() => app.synth(), /Managed Policy is empty. You must add statements to the policy/);\n    test.done();\n  },\n};\n"]}

test/test.role.d.ts

@@ -6,2 +6,4 @@ import { Test } from 'nodeunit';
     'can supply externalId'(test: Test): void;
+    'can supply single externalIds'(test: Test): void;
+    'can supply multiple externalIds'(test: Test): void;
     'policy is created automatically when permissions are added'(test: Test): void;
@@ -18,3 +20,4 @@ 'managed policy arns can be supplied upon initialization and also added later'(test: Test): void;
     'add policy to imported role'(test: Test): void;
+    'can supply permissions boundary managed policy'(test: Test): void;
 };
 export = _default;

test/test.role.js

@@ -66,2 +66,54 @@ "use strict";
     },
+    'can supply single externalIds'(test) {
+        // GIVEN
+        const stack = new core_1.Stack();
+        // WHEN
+        new lib_1.Role(stack, 'MyRole', {
+            assumedBy: new lib_1.ServicePrincipal('sns.amazonaws.com'),
+            externalIds: ['SomeSecret'],
+        });
+        // THEN
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::IAM::Role', {
+            AssumeRolePolicyDocument: {
+                Statement: [
+                    {
+                        Action: "sts:AssumeRole",
+                        Condition: {
+                            StringEquals: { "sts:ExternalId": "SomeSecret" }
+                        },
+                        Effect: "Allow",
+                        Principal: { Service: "sns.amazonaws.com" }
+                    }
+                ],
+                Version: "2012-10-17"
+            }
+        }));
+        test.done();
+    },
+    'can supply multiple externalIds'(test) {
+        // GIVEN
+        const stack = new core_1.Stack();
+        // WHEN
+        new lib_1.Role(stack, 'MyRole', {
+            assumedBy: new lib_1.ServicePrincipal('sns.amazonaws.com'),
+            externalIds: ['SomeSecret', 'AnotherSecret'],
+        });
+        // THEN
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::IAM::Role', {
+            AssumeRolePolicyDocument: {
+                Statement: [
+                    {
+                        Action: "sts:AssumeRole",
+                        Condition: {
+                            StringEquals: { "sts:ExternalId": ["SomeSecret", "AnotherSecret"] }
+                        },
+                        Effect: "Allow",
+                        Principal: { Service: "sns.amazonaws.com" }
+                    }
+                ],
+                Version: "2012-10-17"
+            }
+        }));
+        test.done();
+    },
     'policy is created automatically when permissions are added'(test) {
@@ -236,3 +288,27 @@ // by default we don't expect a role policy
     },
+    'can supply permissions boundary managed policy'(test) {
+        // GIVEN
+        const stack = new core_1.Stack();
+        const permissionsBoundary = lib_1.ManagedPolicy.fromAwsManagedPolicyName('managed-policy');
+        new lib_1.Role(stack, 'MyRole', {
+            assumedBy: new lib_1.ServicePrincipal('sns.amazonaws.com'),
+            permissionsBoundary,
+        });
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::IAM::Role', {
+            PermissionsBoundary: {
+                "Fn::Join": [
+                    "",
+                    [
+                        "arn:",
+                        {
+                            Ref: "AWS::Partition"
+                        },
+                        ":iam::aws:policy/managed-policy"
+                    ]
+                ]
+            }
+        }));
+        test.done();
+    }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.role.js","sourceRoot":"","sources":["test.role.ts"],"names":[],"mappings":";AAAA,4CAAyE;AACzE,wCAAgD;AAEhD,gCAA6H;AAE7H,iBAAS;IACP,cAAc,CAAC,IAAU;QACvB,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAE1B,IAAI,UAAI,CAAC,KAAK,EAAE,QAAQ,EAAE;YACxB,SAAS,EAAE,IAAI,sBAAgB,CAAC,mBAAmB,CAAC;SACrD,CAAC,CAAC;QAEH,eAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,EAAE,SAAS,EAC/B,EAAE,cAAc,EACb,EAAE,IAAI,EAAE,gBAAgB;oBACxB,UAAU,EACT,EAAE,wBAAwB,EACzB,EAAE,SAAS,EACV,CAAE,EAAE,MAAM,EAAE,gBAAgB;oCAC1B,MAAM,EAAE,OAAO;oCACf,SAAS,EAAE,EAAE,OAAO,EAAE,mBAAmB,EAAE,EAAE,CAAE;4BAChD,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,uCAAuC,CAAC,IAAU;QAChD,QAAQ;QACR,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAC1B,MAAM,IAAI,GAAG,IAAI,UAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,sBAAgB,CAAC,oBAAoB,CAAC,EAAE,CAAC,CAAC;QAChG,MAAM,IAAI,GAAG,IAAI,UAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAErC,OAAO;QACP,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAEzB,OAAO;QACP,eAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,yBAAgB,CAAC,kBAAkB,EAAE;YACpD,cAAc,EAAE;gBACd,SAAS,EAAE;oBACT;wBACE,MAAM,EAAE,cAAc;wBACtB,MAAM,EAAE,OAAO;wBACf,QAAQ,EAAE,EAAE,YAAY,EAAE,CAAE,cAAc,EAAE,KAAK,CAAE,EAAE;qBACtD;iBACF;gBACD,OAAO,EAAE,YAAY;aACtB;SACF,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,uBAAuB,CAAC,IAAU;QAChC,QAAQ;QACR,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAE1B,OAAO;QACP,IAAI,UAAI,CAAC,KAAK,EAAE,QAAQ,EAAE;YACxB,SAAS,EAAE,IAAI,sBAAgB,CAAC,mBAAmB,CAAC;YACpD,UAAU,EAAE,YAAY;SACzB,CAAC,CAAC;QAEH,OAAO;QACP,eAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,qBAAY,CAAC,gBAAgB,EAAE;YAC9C,wBAAwB,EAAE;gBACxB,SAAS,EAAE;oBACT;wBACE,MAAM,EAAE,gBAAgB;wBACxB,SAAS,EAAE;4BACT,YAAY,EAAE,EAAE,gBAAgB,EAAE,YAAY,EAAE;yBACjD;wBACD,MAAM,EAAE,OAAO;wBACf,SAAS,EAAE,EAAE,OAAO,EAAE,mBAAmB,EAAE;qBAC5C;iBACF;gBACD,OAAO,EAAE,YAAY;aACtB;SACF,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,4DAA4D,CAAC,IAAU;QACrE,2CAA2C;QAC3C,MAAM,MAAM,GAAG,IAAI,YAAK,EAAE,CAAC;QAC3B,IAAI,UAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,sBAAgB,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;QACrF,eAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,qBAAY,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAEvD,2BAA2B;QAC3B,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAC1B,MAAM,SAAS,GAAG,IAAI,UAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,sBAAgB,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;QACtG,SAAS,CAAC,WAAW,CAAC,IAAI,qBAAe,CAAC,EAAE,SAAS,EAAE,CAAC,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;QACjG,eAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,qBAAY,CAAC,kBAAkB,EAAE;YAChD,cAAc,EAAE;gBACd,SAAS,EAAE;oBACT;wBACE,MAAM,EAAE,UAAU;wBAClB,MAAM,EAAE,OAAO;wBACf,QAAQ,EAAE,YAAY;qBACvB;iBACF;gBACD,OAAO,EAAE,YAAY;aACtB;YACD,UAAU,EAAE,6BAA6B;YACzC,KAAK,EAAE;gBACL;oBACE,GAAG,EAAE,gBAAgB;iBACtB;aACF;SACF,CAAC,CAAC,CAAC;QACJ,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,8EAA8E,CAAC,IAAU;QACvF,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAE1B,MAAM,IAAI,GAAG,IAAI,UAAI,CAAC,KAAK,EAAE,QAAQ,EAAE;YACrC,SAAS,EAAE,IAAI,sBAAgB,CAAC,cAAc,CAAC;YAC/C,eAAe,EAAE,CAAE,EAAE,gBAAgB,EAAE,UAAU,EAAE,EAAE,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAE;SACxF,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,CAAC;QACxD,eAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,EAAE,SAAS,EAC/B,EAAE,cAAc,EACb,EAAE,IAAI,EAAE,gBAAgB;oBACxB,UAAU,EACT,EAAE,wBAAwB,EACzB,EAAE,SAAS,EACV,CAAE,EAAE,MAAM,EAAE,gBAAgB;oCAC1B,MAAM,EAAE,OAAO;oCACf,SAAS,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,CAAE;4BAC3C,OAAO,EAAE,YAAY,EAAE;wBAC1B,iBAAiB,EAAE,CAAE,UAAU,EAAE,UAAU,EAAE,UAAU,CAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,iDAAiD,CAAC,IAAU;QAC1D,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAC1B,MAAM,gBAAgB,GAAG,IAAI,wBAAkB,CAC7C,KAAK,EACL,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,EAClC,qBAAqB,CAAC,CAAC;QAEzB,IAAI,UAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAE3D,eAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,qBAAY,CAAC,gBAAgB,EAAE;YAC9C,wBAAwB,EAAE;gBACxB,OAAO,EAAE,YAAY;gBACrB,SAAS,EAAE;oBACT;wBACE,SAAS,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE;wBAC/B,SAAS,EAAE;4BACT,YAAY,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE;yBAC/B;wBACD,MAAM,EAAE,qBAAqB;wBAC7B,MAAM,EAAE,OAAO;qBAChB;iBACF;aACF;SACF,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,oBAAoB,EAAE;QAEpB,6BAA6B,CAAC,IAAU;YACtC,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;YAC1B,IAAI,UAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,sBAAgB,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;YACpF,eAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;gBACpB,SAAS,EAAE;oBACT,cAAc,EAAE;wBAChB,IAAI,EAAE,gBAAgB;wBACtB,UAAU,EAAE;4BACV,wBAAwB,EAAE;gCAC1B,SAAS,EAAE;oCACT;wCACA,MAAM,EAAE,gBAAgB;wCACxB,MAAM,EAAE,OAAO;wCACf,SAAS,EAAE;4CACT,OAAO,EAAE,mBAAmB;yCAC7B;qCACA;iCACF;gCACD,OAAO,EAAE,YAAY;6BACpB;yBACF;qBACA;iBACF;aACF,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;QAED,2EAA2E,CAAC,IAAU;YACpF,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;YAE1B,IAAI,UAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,kBAAkB,EAAE,eAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,sBAAgB,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;YAEhI,eAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,qBAAY,CAAC,gBAAgB,EAAE;gBAC9C,kBAAkB,EAAE,IAAI;aACzB,CAAC,CAAC,CAAC;YAEJ,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;QAED,gCAAgC,CAAC,IAAU;YACzC,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;YAE1B,MAAM,SAAS,GAAG,IAAI,sBAAgB,CAAC,KAAK,CAAC,CAAC;YAE9C,IAAI,UAAI,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,kBAAkB,EAAE,eAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACjF,IAAI,UAAI,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,kBAAkB,EAAE,eAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAElF,MAAM,QAAQ,GAAG,CAAC,GAAQ,EAAE,EAAE,CAAC,gCAAgC,GAAG,wDAAwD,CAAC;YAC3H,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,UAAI,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,kBAAkB,EAAE,eAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;YACpH,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,UAAI,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,kBAAkB,EAAE,eAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;YACzH,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,UAAI,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,kBAAkB,EAAE,eAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;YAE3H,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;KACF;IAED,qCAAqC,CAAC,IAAU;QAC9C,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAE1B,IAAI,UAAI,CAAC,KAAK,EAAE,QAAQ,EAAE;YACxB,SAAS,EAAE,IAAI,wBAAkB,CAC/B,IAAI,sBAAgB,CAAC,qBAAqB,CAAC,EAC3C,IAAI,kBAAY,CAAC,SAAS,CAAC,CAC5B;SACF,CAAC,CAAC;QAEH,eAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,qBAAY,CAAC,gBAAgB,EAAE;YAC9C,wBAAwB,EAAE;gBACxB,SAAS,EAAE;oBACT;wBACE,MAAM,EAAE,gBAAgB;wBACxB,MAAM,EAAE,OAAO;wBACf,SAAS,EAAE;4BACT,OAAO,EAAE,qBAAqB;4BAC9B,GAAG,EAAE,SAAS;yBACf;qBACF;iBACF;gBACD,OAAO,EAAE,YAAY;aACtB;SACF,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,aAAa,CAAC,IAAU;QACtB,QAAQ;QACR,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAE1B,OAAO;QACP,MAAM,YAAY,GAAG,UAAI,CAAC,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,yCAAyC,CAAC,CAAC;QAExG,OAAO;QACP,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,yCAAyC,CAAC,CAAC;QAChF,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAClD,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,6BAA6B,CAAC,IAAU;QACtC,QAAQ;QACR,MAAM,KAAK,GAAG,IAAI,YAAK,EAAE,CAAC;QAC1B,MAAM,YAAY,GAAG,UAAI,CAAC,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,uCAAuC,CAAC,CAAC;QAEtG,OAAO;QACP,YAAY,CAAC,WAAW,CAAC,IAAI,qBAAe,CAAC;YAC3C,OAAO,EAAE,CAAC,MAAM,CAAC;YACjB,SAAS,EAAE,CAAC,KAAK,CAAC;SACnB,CAAC,CAAC,CAAC;QAEJ,OAAO;QACP,eAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,qBAAY,CAAC,kBAAkB,EAAE;YAChD,cAAc,EAAE;gBACd,SAAS,EAAE;oBACT;wBACE,MAAM,EAAE,MAAM;wBACd,MAAM,EAAE,OAAO;wBACf,QAAQ,EAAE,KAAK;qBAChB;iBACF;gBACD,OAAO,EAAE,YAAY;aACtB;YACD,KAAK,EAAE,CAAE,QAAQ,CAAE;SACpB,CAAC,CAAC,CAAC;QACJ,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;CAEF,CAAC","sourcesContent":["import { expect, haveResource, haveResourceLike } from '@aws-cdk/assert';\nimport { Duration, Stack } from '@aws-cdk/core';\nimport { Test } from 'nodeunit';\nimport { ArnPrincipal, CompositePrincipal, FederatedPrincipal, PolicyStatement, Role, ServicePrincipal, User } from '../lib';\n\nexport = {\n  'default role'(test: Test) {\n    const stack = new Stack();\n\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com')\n    });\n\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'sns.amazonaws.com' } } ],\n             Version: '2012-10-17' } } } } });\n    test.done();\n  },\n\n  'a role can grant PassRole permissions'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const role = new Role(stack, 'Role', { assumedBy: new ServicePrincipal('henk.amazonaws.com') });\n    const user = new User(stack, 'User');\n\n    // WHEN\n    role.grantPassRole(user);\n\n    // THEN\n    expect(stack).to(haveResourceLike('AWS::IAM::Policy', {\n      PolicyDocument: {\n        Statement: [\n          {\n            Action: \"iam:PassRole\",\n            Effect: \"Allow\",\n            Resource: { \"Fn::GetAtt\": [ \"Role1ABCC5F0\", \"Arn\" ] }\n          }\n        ],\n        Version: \"2012-10-17\"\n      },\n    }));\n\n    test.done();\n  },\n\n  'can supply externalId'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    // WHEN\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com'),\n      externalId: 'SomeSecret',\n    });\n\n    // THEN\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [\n          {\n            Action: \"sts:AssumeRole\",\n            Condition: {\n              StringEquals: { \"sts:ExternalId\": \"SomeSecret\" }\n            },\n            Effect: \"Allow\",\n            Principal: { Service: \"sns.amazonaws.com\" }\n          }\n        ],\n        Version: \"2012-10-17\"\n      }\n    }));\n\n    test.done();\n  },\n\n  'policy is created automatically when permissions are added'(test: Test) {\n    // by default we don't expect a role policy\n    const before = new Stack();\n    new Role(before, 'MyRole', { assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n    expect(before).notTo(haveResource('AWS::IAM::Policy'));\n\n    // add a policy to the role\n    const after = new Stack();\n    const afterRole = new Role(after, 'MyRole', { assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n    afterRole.addToPolicy(new PolicyStatement({ resources: ['myresource'], actions: ['myaction'] }));\n    expect(after).to(haveResource('AWS::IAM::Policy', {\n      PolicyDocument: {\n        Statement: [\n          {\n            Action: \"myaction\",\n            Effect: \"Allow\",\n            Resource: \"myresource\"\n          }\n        ],\n        Version: \"2012-10-17\"\n      },\n      PolicyName: \"MyRoleDefaultPolicyA36BE1DD\",\n      Roles: [\n        {\n          Ref: \"MyRoleF48FFE04\"\n        }\n      ]\n    }));\n    test.done();\n  },\n\n  'managed policy arns can be supplied upon initialization and also added later'(test: Test) {\n    const stack = new Stack();\n\n    const role = new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('test.service'),\n      managedPolicies: [ { managedPolicyArn: 'managed1' }, { managedPolicyArn: 'managed2' } ]\n    });\n\n    role.addManagedPolicy({ managedPolicyArn: 'managed3' });\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'test.service' } } ],\n             Version: '2012-10-17' },\n          ManagedPolicyArns: [ 'managed1', 'managed2', 'managed3' ] } } } });\n    test.done();\n  },\n\n  'federated principal can change AssumeRoleAction'(test: Test) {\n    const stack = new Stack();\n    const cognitoPrincipal = new FederatedPrincipal(\n      'foo',\n      { StringEquals: { key: 'value' } },\n      'sts:AssumeSomething');\n\n    new Role(stack, 'MyRole', { assumedBy: cognitoPrincipal });\n\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Version: \"2012-10-17\",\n        Statement: [\n          {\n            Principal: { Federated: \"foo\" },\n            Condition: {\n              StringEquals: { key: \"value\" }\n            },\n            Action: \"sts:AssumeSomething\",\n            Effect: \"Allow\",\n          }\n        ],\n      }\n    }));\n\n    test.done();\n  },\n\n  'maxSessionDuration': {\n\n    'is not specified by default'(test: Test) {\n      const stack = new Stack();\n      new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n      expect(stack).toMatch({\n        Resources: {\n          MyRoleF48FFE04: {\n          Type: \"AWS::IAM::Role\",\n          Properties: {\n            AssumeRolePolicyDocument: {\n            Statement: [\n              {\n              Action: \"sts:AssumeRole\",\n              Effect: \"Allow\",\n              Principal: {\n                Service: \"sns.amazonaws.com\"\n              }\n              }\n            ],\n            Version: \"2012-10-17\"\n            }\n          }\n          }\n        }\n      });\n      test.done();\n    },\n\n    'can be used to specify the maximum session duration for assuming the role'(test: Test) {\n      const stack = new Stack();\n\n      new Role(stack, 'MyRole', { maxSessionDuration: Duration.seconds(3700), assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n\n      expect(stack).to(haveResource('AWS::IAM::Role', {\n        MaxSessionDuration: 3700\n      }));\n\n      test.done();\n    },\n\n    'must be between 3600 and 43200'(test: Test) {\n      const stack = new Stack();\n\n      const assumedBy = new ServicePrincipal('bla');\n\n      new Role(stack, 'MyRole1', { assumedBy, maxSessionDuration: Duration.hours(1) });\n      new Role(stack, 'MyRole2', { assumedBy, maxSessionDuration: Duration.hours(12) });\n\n      const expected = (val: any) => `maxSessionDuration is set to ${val}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`;\n      test.throws(() => new Role(stack, 'MyRole3', { assumedBy, maxSessionDuration: Duration.minutes(1) }), expected(60));\n      test.throws(() => new Role(stack, 'MyRole4', { assumedBy, maxSessionDuration: Duration.seconds(3599) }), expected(3599));\n      test.throws(() => new Role(stack, 'MyRole5', { assumedBy, maxSessionDuration: Duration.seconds(43201) }), expected(43201));\n\n      test.done();\n    }\n  },\n\n  'allow role with multiple principals'(test: Test) {\n    const stack = new Stack();\n\n    new Role(stack, 'MyRole', {\n      assumedBy: new CompositePrincipal(\n        new ServicePrincipal('boom.amazonaws.test'),\n        new ArnPrincipal('1111111')\n      )\n    });\n\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [\n          {\n            Action: \"sts:AssumeRole\",\n            Effect: \"Allow\",\n            Principal: {\n              Service: \"boom.amazonaws.test\",\n              AWS: \"1111111\"\n            }\n          }\n        ],\n        Version: \"2012-10-17\"\n      }\n    }));\n\n    test.done();\n  },\n\n  'fromRoleArn'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    // WHEN\n    const importedRole = Role.fromRoleArn(stack, 'ImportedRole', 'arn:aws:iam::123456789012:role/S3Access');\n\n    // THEN\n    test.deepEqual(importedRole.roleArn, 'arn:aws:iam::123456789012:role/S3Access');\n    test.deepEqual(importedRole.roleName, 'S3Access');\n    test.done();\n  },\n\n  'add policy to imported role'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const importedRole = Role.fromRoleArn(stack, 'ImportedRole', 'arn:aws:iam::123456789012:role/MyRole');\n\n    // WHEN\n    importedRole.addToPolicy(new PolicyStatement({\n      actions: ['s3:*'],\n      resources: ['xyz']\n    }));\n\n    // THEN\n    expect(stack).to(haveResource('AWS::IAM::Policy', {\n      PolicyDocument: {\n        Statement: [\n          {\n            Action: \"s3:*\",\n            Effect: \"Allow\",\n            Resource: \"xyz\"\n          }\n        ],\n        Version: \"2012-10-17\"\n      },\n      Roles: [ \"MyRole\" ]\n    }));\n    test.done();\n  },\n\n};"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.role.js","sourceRoot":"","sources":["test.role.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, haveResource, haveResourceLike } from '@aws-cdk/assert';\nimport { Duration, Stack } from '@aws-cdk/core';\nimport { Test } from 'nodeunit';\nimport { ArnPrincipal, CompositePrincipal, FederatedPrincipal, ManagedPolicy, PolicyStatement, Role, ServicePrincipal, User } from '../lib';\n\nexport = {\n  'default role'(test: Test) {\n    const stack = new Stack();\n\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com')\n    });\n\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'sns.amazonaws.com' } } ],\n             Version: '2012-10-17' } } } } });\n    test.done();\n  },\n\n  'a role can grant PassRole permissions'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const role = new Role(stack, 'Role', { assumedBy: new ServicePrincipal('henk.amazonaws.com') });\n    const user = new User(stack, 'User');\n\n    // WHEN\n    role.grantPassRole(user);\n\n    // THEN\n    expect(stack).to(haveResourceLike('AWS::IAM::Policy', {\n      PolicyDocument: {\n        Statement: [\n          {\n            Action: \"iam:PassRole\",\n            Effect: \"Allow\",\n            Resource: { \"Fn::GetAtt\": [ \"Role1ABCC5F0\", \"Arn\" ] }\n          }\n        ],\n        Version: \"2012-10-17\"\n      },\n    }));\n\n    test.done();\n  },\n\n  'can supply externalId'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    // WHEN\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com'),\n      externalId: 'SomeSecret',\n    });\n\n    // THEN\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [\n          {\n            Action: \"sts:AssumeRole\",\n            Condition: {\n              StringEquals: { \"sts:ExternalId\": \"SomeSecret\" }\n            },\n            Effect: \"Allow\",\n            Principal: { Service: \"sns.amazonaws.com\" }\n          }\n        ],\n        Version: \"2012-10-17\"\n      }\n    }));\n\n    test.done();\n  },\n\n  'can supply single externalIds'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    // WHEN\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com'),\n      externalIds: ['SomeSecret'],\n    });\n\n    // THEN\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [\n          {\n            Action: \"sts:AssumeRole\",\n            Condition: {\n              StringEquals: { \"sts:ExternalId\": \"SomeSecret\" }\n            },\n            Effect: \"Allow\",\n            Principal: { Service: \"sns.amazonaws.com\" }\n          }\n        ],\n        Version: \"2012-10-17\"\n      }\n    }));\n\n    test.done();\n  },\n\n  'can supply multiple externalIds'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    // WHEN\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com'),\n      externalIds: ['SomeSecret', 'AnotherSecret'],\n    });\n\n    // THEN\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [\n          {\n            Action: \"sts:AssumeRole\",\n            Condition: {\n              StringEquals: { \"sts:ExternalId\": [\"SomeSecret\", \"AnotherSecret\"] }\n            },\n            Effect: \"Allow\",\n            Principal: { Service: \"sns.amazonaws.com\" }\n          }\n        ],\n        Version: \"2012-10-17\"\n      }\n    }));\n\n    test.done();\n  },\n\n  'policy is created automatically when permissions are added'(test: Test) {\n    // by default we don't expect a role policy\n    const before = new Stack();\n    new Role(before, 'MyRole', { assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n    expect(before).notTo(haveResource('AWS::IAM::Policy'));\n\n    // add a policy to the role\n    const after = new Stack();\n    const afterRole = new Role(after, 'MyRole', { assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n    afterRole.addToPolicy(new PolicyStatement({ resources: ['myresource'], actions: ['myaction'] }));\n    expect(after).to(haveResource('AWS::IAM::Policy', {\n      PolicyDocument: {\n        Statement: [\n          {\n            Action: \"myaction\",\n            Effect: \"Allow\",\n            Resource: \"myresource\"\n          }\n        ],\n        Version: \"2012-10-17\"\n      },\n      PolicyName: \"MyRoleDefaultPolicyA36BE1DD\",\n      Roles: [\n        {\n          Ref: \"MyRoleF48FFE04\"\n        }\n      ]\n    }));\n    test.done();\n  },\n\n  'managed policy arns can be supplied upon initialization and also added later'(test: Test) {\n    const stack = new Stack();\n\n    const role = new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('test.service'),\n      managedPolicies: [ { managedPolicyArn: 'managed1' }, { managedPolicyArn: 'managed2' } ]\n    });\n\n    role.addManagedPolicy({ managedPolicyArn: 'managed3' });\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'test.service' } } ],\n             Version: '2012-10-17' },\n          ManagedPolicyArns: [ 'managed1', 'managed2', 'managed3' ] } } } });\n    test.done();\n  },\n\n  'federated principal can change AssumeRoleAction'(test: Test) {\n    const stack = new Stack();\n    const cognitoPrincipal = new FederatedPrincipal(\n      'foo',\n      { StringEquals: { key: 'value' } },\n      'sts:AssumeSomething');\n\n    new Role(stack, 'MyRole', { assumedBy: cognitoPrincipal });\n\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Version: \"2012-10-17\",\n        Statement: [\n          {\n            Principal: { Federated: \"foo\" },\n            Condition: {\n              StringEquals: { key: \"value\" }\n            },\n            Action: \"sts:AssumeSomething\",\n            Effect: \"Allow\",\n          }\n        ],\n      }\n    }));\n\n    test.done();\n  },\n\n  'maxSessionDuration': {\n\n    'is not specified by default'(test: Test) {\n      const stack = new Stack();\n      new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n      expect(stack).toMatch({\n        Resources: {\n          MyRoleF48FFE04: {\n          Type: \"AWS::IAM::Role\",\n          Properties: {\n            AssumeRolePolicyDocument: {\n            Statement: [\n              {\n              Action: \"sts:AssumeRole\",\n              Effect: \"Allow\",\n              Principal: {\n                Service: \"sns.amazonaws.com\"\n              }\n              }\n            ],\n            Version: \"2012-10-17\"\n            }\n          }\n          }\n        }\n      });\n      test.done();\n    },\n\n    'can be used to specify the maximum session duration for assuming the role'(test: Test) {\n      const stack = new Stack();\n\n      new Role(stack, 'MyRole', { maxSessionDuration: Duration.seconds(3700), assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n\n      expect(stack).to(haveResource('AWS::IAM::Role', {\n        MaxSessionDuration: 3700\n      }));\n\n      test.done();\n    },\n\n    'must be between 3600 and 43200'(test: Test) {\n      const stack = new Stack();\n\n      const assumedBy = new ServicePrincipal('bla');\n\n      new Role(stack, 'MyRole1', { assumedBy, maxSessionDuration: Duration.hours(1) });\n      new Role(stack, 'MyRole2', { assumedBy, maxSessionDuration: Duration.hours(12) });\n\n      const expected = (val: any) => `maxSessionDuration is set to ${val}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`;\n      test.throws(() => new Role(stack, 'MyRole3', { assumedBy, maxSessionDuration: Duration.minutes(1) }), expected(60));\n      test.throws(() => new Role(stack, 'MyRole4', { assumedBy, maxSessionDuration: Duration.seconds(3599) }), expected(3599));\n      test.throws(() => new Role(stack, 'MyRole5', { assumedBy, maxSessionDuration: Duration.seconds(43201) }), expected(43201));\n\n      test.done();\n    }\n  },\n\n  'allow role with multiple principals'(test: Test) {\n    const stack = new Stack();\n\n    new Role(stack, 'MyRole', {\n      assumedBy: new CompositePrincipal(\n        new ServicePrincipal('boom.amazonaws.test'),\n        new ArnPrincipal('1111111')\n      )\n    });\n\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [\n          {\n            Action: \"sts:AssumeRole\",\n            Effect: \"Allow\",\n            Principal: {\n              Service: \"boom.amazonaws.test\",\n              AWS: \"1111111\"\n            }\n          }\n        ],\n        Version: \"2012-10-17\"\n      }\n    }));\n\n    test.done();\n  },\n\n  'fromRoleArn'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    // WHEN\n    const importedRole = Role.fromRoleArn(stack, 'ImportedRole', 'arn:aws:iam::123456789012:role/S3Access');\n\n    // THEN\n    test.deepEqual(importedRole.roleArn, 'arn:aws:iam::123456789012:role/S3Access');\n    test.deepEqual(importedRole.roleName, 'S3Access');\n    test.done();\n  },\n\n  'add policy to imported role'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const importedRole = Role.fromRoleArn(stack, 'ImportedRole', 'arn:aws:iam::123456789012:role/MyRole');\n\n    // WHEN\n    importedRole.addToPolicy(new PolicyStatement({\n      actions: ['s3:*'],\n      resources: ['xyz']\n    }));\n\n    // THEN\n    expect(stack).to(haveResource('AWS::IAM::Policy', {\n      PolicyDocument: {\n        Statement: [\n          {\n            Action: \"s3:*\",\n            Effect: \"Allow\",\n            Resource: \"xyz\"\n          }\n        ],\n        Version: \"2012-10-17\"\n      },\n      Roles: [ \"MyRole\" ]\n    }));\n    test.done();\n  },\n\n  'can supply permissions boundary managed policy'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    const permissionsBoundary = ManagedPolicy.fromAwsManagedPolicyName('managed-policy');\n\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com'),\n      permissionsBoundary,\n    });\n\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      PermissionsBoundary: {\n        \"Fn::Join\": [\n          \"\",\n          [\n            \"arn:\",\n            {\n              Ref: \"AWS::Partition\"\n            },\n            \":iam::aws:policy/managed-policy\"\n          ]\n        ]\n      }\n    }));\n\n    test.done();\n  }\n};\n"]}

test/test.user.d.ts

@@ -7,3 +7,4 @@ import { Test } from 'nodeunit';
     'create with managed policy'(test: Test): void;
+    'can supply permissions boundary managed policy'(test: Test): void;
 };
 export = _default;

test/test.user.js

@@ -46,4 +46,27 @@ "use strict";
         test.done();
+    },
+    'can supply permissions boundary managed policy'(test) {
+        // GIVEN
+        const stack = new core_1.Stack();
+        const permissionsBoundary = lib_1.ManagedPolicy.fromAwsManagedPolicyName('managed-policy');
+        new lib_1.User(stack, 'MyUser', {
+            permissionsBoundary,
+        });
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::IAM::User', {
+            PermissionsBoundary: {
+                "Fn::Join": [
+                    "",
+                    [
+                        "arn:",
+                        {
+                            Ref: "AWS::Partition"
+                        },
+                        ":iam::aws:policy/managed-policy"
+                    ]
+                ]
+            }
+        }));
+        test.done();
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1005501

increased by13.38%

Number of package files

85

increased by3.66%

Lines of code

7090

increased by15.12%

Dependency changes

• Updated@aws-cdk/core@^1.4.0

• Updated@aws-cdk/region-info@^1.4.0