fix(lambda) support adding deep clones of layers to a Function

packages/@aws-cdk/aws-lambda/lib/function.ts

@@ -496,7 +496,7 @@ export class Function extends FunctionBase {
     if (this.layers.length === 5) {
       throw new Error('Unable to add layer: this lambda function already uses 5 layers.');
     }
-    if (layer.compatibleRuntimes && layer.compatibleRuntimes.indexOf(this.runtime) === -1) {
+    if (layer.compatibleRuntimes && !layer.compatibleRuntimes.find(runtime => runtime.equals(this.runtime))) {
       const runtimes = layer.compatibleRuntimes.map(runtime => runtime.name).join(', ');
       throw new Error(`This lambda function uses a runtime that is incompatible with this layer (${this.runtime.name} is not in [${runtimes}])`);
     }

packages/@aws-cdk/aws-lambda/lib/runtime.ts

@@ -68,4 +68,10 @@ export class Runtime {
   public toString(): string {
     return this.name;
   }
+
+  public equals(other: Runtime): boolean {
+    return other.name === this.name &&
+           other.family === this.family &&
+           other.supportsInlineCode === this.supportsInlineCode;
+  }
 }

packages/@aws-cdk/aws-lambda/package.json

@@ -66,14 +66,16 @@
     "@types/aws-lambda": "^8.10.24",
     "@types/nock": "^9.3.1",
     "@types/sinon": "^7.0.11",
+    "@types/lodash": "^4.14.128",
     "aws-sdk": "^2.438.0",
     "aws-sdk-mock": "^4.4.0",
     "cdk-build-tools": "^0.31.0",
     "cdk-integ-tools": "^0.31.0",
     "cfn2ts": "^0.31.0",
     "nock": "^10.0.6",
     "pkglint": "^0.31.0",
-    "sinon": "^7.3.1"
+    "sinon": "^7.3.1",
+    "lodash": "^4.17.11"
   },
   "dependencies": {
     "@aws-cdk/assets": "^0.31.0",

packages/@aws-cdk/aws-lambda/test/test.function.ts

@@ -0,0 +1,76 @@
+import s3 = require('@aws-cdk/aws-s3');
+import cdk = require('@aws-cdk/cdk');
+import _ = require('lodash');
+import {Test, testCase} from 'nodeunit';
+import lambda = require('../lib');
+
+export = testCase({
+  'add incompatible layer'(test: Test) {
+    // GIVEN
+    const stack = new cdk.Stack(undefined, 'TestStack');
+    const bucket = new s3.Bucket(stack, 'Bucket');
+    const code = new lambda.S3Code(bucket, 'ObjectKey');
+
+    const func = new lambda.Function(stack, 'myFunc', {
+      runtime: lambda.Runtime.Python37,
+      handler: 'index.handler',
+      code,
+    });
+    const layer = new lambda.LayerVersion(stack, 'myLayer', {
+      code,
+      compatibleRuntimes: [lambda.Runtime.NodeJS]
+    });
+
+    // THEN
+    test.throws(() => func.addLayer(layer),
+      /This lambda function uses a runtime that is incompatible with this layer/);
+
+    test.done();
+  },
+  'add compatible layer'(test: Test) {
+    // GIVEN
+    const stack = new cdk.Stack(undefined, 'TestStack');
+    const bucket = new s3.Bucket(stack, 'Bucket');
+    const code = new lambda.S3Code(bucket, 'ObjectKey');
+
+    const func = new lambda.Function(stack, 'myFunc', {
+      runtime: lambda.Runtime.Python37,
+      handler: 'index.handler',
+      code,
+    });
+    const layer = new lambda.LayerVersion(stack, 'myLayer', {
+      code,
+      compatibleRuntimes: [lambda.Runtime.Python37]
+    });
+
+    // THEN
+    // should not throw
+    func.addLayer(layer);
+
+    test.done();
+  },
+  'add compatible layer for deep clone'(test: Test) {
+    // GIVEN
+    const stack = new cdk.Stack(undefined, 'TestStack');
+    const bucket = new s3.Bucket(stack, 'Bucket');
+    const code = new lambda.S3Code(bucket, 'ObjectKey');
+
+    const runtime = lambda.Runtime.Python37;
+    const func = new lambda.Function(stack, 'myFunc', {
+      runtime,
+      handler: 'index.handler',
+      code,
+    });
+    const clone = _.cloneDeep(runtime);
+    const layer = new lambda.LayerVersion(stack, 'myLayer', {
+      code,
+      compatibleRuntimes: [clone]
+    });
+
+    // THEN
+    // should not throw
+    func.addLayer(layer);
+
+    test.done();
+  },
+});

packages/@aws-cdk/aws-lambda/test/test.runtime.ts

@@ -0,0 +1,70 @@
+import {Test, testCase} from 'nodeunit';
+import {RuntimeFamily} from "../lib";
+import lambda = require('../lib');
+
+export = testCase({
+  'runtimes are equal for different instances'(test: Test) {
+    // GIVEN
+    const runtime1 = new lambda.Runtime('python3.7', RuntimeFamily.Python, {supportsInlineCode: true});
+    const runtime2 = new lambda.Runtime('python3.7', RuntimeFamily.Python, {supportsInlineCode: true});
+
+    // WHEN
+    const result = runtime1.equals(runtime2);
+
+    // THEN
+    test.strictEqual(result, true, 'Runtimes should be equal');
+
+    test.done();
+  },
+  'runtimes are equal for same instance'(test: Test) {
+    // GIVEN
+    const runtime = new lambda.Runtime('python3.7', RuntimeFamily.Python, {supportsInlineCode: true});
+
+    // WHEN
+    const result = runtime.equals(runtime);
+
+    // THEN
+    test.strictEqual(result, true, 'Runtimes should be equal');
+
+    test.done();
+  },
+  'unequal when name changes'(test: Test) {
+    // GIVEN
+    const runtime1 = new lambda.Runtime('python3.7', RuntimeFamily.Python, {supportsInlineCode: true});
+    const runtime2 = new lambda.Runtime('python3.6', RuntimeFamily.Python, {supportsInlineCode: true});
+
+    // WHEN
+    const result = runtime1.equals(runtime2);
+
+    // THEN
+    test.strictEqual(result, false, 'Runtimes should be unequal when name changes');
+
+    test.done();
+  },
+  'unequal when family changes'(test: Test) {
+    // GIVEN
+    const runtime1 = new lambda.Runtime('python3.7', RuntimeFamily.Python, {supportsInlineCode: true});
+    const runtime2 = new lambda.Runtime('python3.7', RuntimeFamily.Java, {supportsInlineCode: true});
+
+    // WHEN
+    const result = runtime1.equals(runtime2);
+
+    // THEN
+    test.strictEqual(result, false, 'Runtimes should be unequal when family changes');
+
+    test.done();
+  },
+  'unequal when supportsInlineCode changes'(test: Test) {
+    // GIVEN
+    const runtime1 = new lambda.Runtime('python3.7', RuntimeFamily.Python, {supportsInlineCode: true});
+    const runtime2 = new lambda.Runtime('python3.7', RuntimeFamily.Python, {supportsInlineCode: false});
+
+    // WHEN
+    const result = runtime1.equals(runtime2);
+
+    // THEN
+    test.strictEqual(result, false, 'Runtimes should be unequal when supportsInlineCode changes');
+
+    test.done();
+  },
+});