Merge branch 'master' into DerkSchooltink/lambda-ruby-2.7-support

Author: RomainMuller

.mergify.yml

@@ -56,17 +56,11 @@ pull_request_rules:
       - status-success~=AWS CodeBuild us-east-1
       - status-success=Semantic Pull Request
       - status-success=mandatory-changes
-  - name: when changes are requested
-    actions:
-      comment:
-        message: Once all the requested changes have been addressed, and the PR is ready for another review, remember to [dismiss the review](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/dismissing-a-pull-request-review).
-    conditions:
-      - "#changes-requested-reviews-by>=1"
   - name: remove stale reviews
     actions:
       dismiss_reviews:
         approved: true
-        changes_requested: false
+        changes_requested: true
     conditions:
       - author!=dependabot[bot]
       - author!=dependabot-preview[bot]

packages/@aws-cdk/aws-kinesis/lib/stream.ts

@@ -1,6 +1,6 @@
 import * as iam from '@aws-cdk/aws-iam';
 import * as kms from '@aws-cdk/aws-kms';
-import { Construct, IResource, Resource, Stack } from '@aws-cdk/core';
+import { Construct, Duration, IResource, Resource, Stack } from '@aws-cdk/core';
 import { CfnStream } from './kinesis.generated';
 
 /**
@@ -185,9 +185,9 @@ export interface StreamProps {
 
   /**
    * The number of hours for the data records that are stored in shards to remain accessible.
-   * @default 24
+   * @default Duration.hours(24)
    */
-  readonly retentionPeriodHours?: number;
+  readonly retentionPeriod?: Duration;
 
   /**
    * The number of shards for the stream.
@@ -261,9 +261,9 @@ export class Stream extends StreamBase {
     });
 
     const shardCount = props.shardCount || 1;
-    const retentionPeriodHours = props.retentionPeriodHours || 24;
-    if (retentionPeriodHours < 24 && retentionPeriodHours > 168) {
-      throw new Error("retentionPeriodHours must be between 24 and 168 hours");
+    const retentionPeriodHours = props.retentionPeriod?.toHours() ?? 24;
+    if (retentionPeriodHours < 24 || retentionPeriodHours > 168) {
+      throw new Error(`retentionPeriod must be between 24 and 168 hours. Received ${retentionPeriodHours}`);
     }
 
     const { streamEncryption, encryptionKey } = this.parseEncryption(props);

packages/@aws-cdk/aws-kinesis/test/test.stream.ts

@@ -1,7 +1,7 @@
 import { expect } from '@aws-cdk/assert';
 import * as iam from '@aws-cdk/aws-iam';
 import * as kms from '@aws-cdk/aws-kms';
-import { App, Stack } from '@aws-cdk/core';
+import { App, Duration, Stack } from '@aws-cdk/core';
 import { Test } from 'nodeunit';
 import { Stream, StreamEncryption } from '../lib';
 
@@ -64,8 +64,8 @@ export = {
   "uses explicit retention period"(test: Test) {
     const stack = new Stack();
 
-    new Stream(stack, 'MyStream', {
-      retentionPeriodHours: 168
+    new Stream(stack, "MyStream", {
+      retentionPeriod: Duration.hours(168)
     });
 
     expect(stack).toMatch({
@@ -83,23 +83,17 @@ export = {
     test.done();
   },
   "retention period must be between 24 and 168 hours"(test: Test) {
-    test.throws({
-      block: () => {
-        new Stream(new Stack(), 'MyStream', {
-          retentionPeriodHours: 169
-        });
-      },
-      message: "retentionPeriodHours must be between 24 and 168 hours"
-    });
+    test.throws(() => {
+      new Stream(new Stack(), 'MyStream', {
+        retentionPeriod: Duration.hours(169)
+      });
+    }, /retentionPeriod must be between 24 and 168 hours. Received 169/);
 
-    test.throws({
-      block: () => {
+    test.throws(() => {
         new Stream(new Stack(), 'MyStream', {
-          retentionPeriodHours: 23
-        });
-      },
-      message: "retentionPeriodHours must be between 24 and 168 hours"
-    });
+          retentionPeriod: Duration.hours(23)
+          });
+    }, /retentionPeriod must be between 24 and 168 hours. Received 23/);
 
     test.done();
   },

packages/@aws-cdk/core/lib/size.ts

@@ -63,49 +63,61 @@ export class Size {
   /**
    * Return this storage as a total number of kibibytes.
    */
-  public toKibibytes(opts: StorageConversionOptions = {}): number {
+  public toKibibytes(opts: SizeConversionOptions = {}): number {
     return convert(this.amount, this.unit, StorageUnit.Kibibytes, opts);
   }
 
   /**
    * Return this storage as a total number of mebibytes.
    */
-  public toMebibytes(opts: StorageConversionOptions = {}): number {
+  public toMebibytes(opts: SizeConversionOptions = {}): number {
     return convert(this.amount, this.unit, StorageUnit.Mebibytes, opts);
   }
 
   /**
    * Return this storage as a total number of gibibytes.
    */
-  public toGibibytes(opts: StorageConversionOptions = {}): number {
+  public toGibibytes(opts: SizeConversionOptions = {}): number {
     return convert(this.amount, this.unit, StorageUnit.Gibibytes, opts);
   }
 
   /**
    * Return this storage as a total number of tebibytes.
    */
-  public toTebibytes(opts: StorageConversionOptions = {}): number {
+  public toTebibytes(opts: SizeConversionOptions = {}): number {
     return convert(this.amount, this.unit, StorageUnit.Tebibytes, opts);
   }
 
   /**
    * Return this storage as a total number of pebibytes.
    */
-  public toPebibytes(opts: StorageConversionOptions = {}): number {
+  public toPebibytes(opts: SizeConversionOptions = {}): number {
     return convert(this.amount, this.unit, StorageUnit.Pebibytes, opts);
   }
 }
 
+/**
+ * Rouding behaviour when converting between units of `Size`.
+ */
+export enum SizeRoundingBehavior {
+  /** Fail the conversion if the result is not an integer. */
+  FAIL,
+  /** If the result is not an integer, round it to the closest integer less than the result */
+  FLOOR,
+  /** Don't round. Return even if the result is a fraction. */
+  NONE,
+
+}
+
 /**
  * Options for how to convert time to a different unit.
  */
-export interface StorageConversionOptions {
+export interface SizeConversionOptions {
   /**
-   * If `true`, conversions into a larger storage units (e.g. `Kibibytes` to `Mebibytes`) will fail if the result is not
-   * an integer.
-   * @default true
+   * How conversions should behave when it encounters a non-integer result
+   * @default SizeRoundingBehavior.FAIL
    */
-  readonly integral?: boolean;
+  readonly rounding?: SizeRoundingBehavior;
 }
 
 class StorageUnit {
@@ -125,16 +137,25 @@ class StorageUnit {
   }
 }
 
-function convert(amount: number, fromUnit: StorageUnit, toUnit: StorageUnit, { integral = true }: StorageConversionOptions) {
+function convert(amount: number, fromUnit: StorageUnit, toUnit: StorageUnit, options: SizeConversionOptions = {}) {
+  const rounding = options.rounding ?? SizeRoundingBehavior.FAIL;
   if (fromUnit.inKibiBytes === toUnit.inKibiBytes) { return amount; }
   if (Token.isUnresolved(amount)) {
     throw new Error(`Unable to perform time unit conversion on un-resolved token ${amount}.`);
   }
 
   const multiplier = fromUnit.inKibiBytes / toUnit.inKibiBytes;
   const value = amount * multiplier;
-  if (!Number.isInteger(value) && integral) {
-    throw new Error(`'${amount} ${fromUnit}' cannot be converted into a whole number of ${toUnit}.`);
+  switch (rounding) {
+    case SizeRoundingBehavior.NONE:
+      return value;
+    case SizeRoundingBehavior.FLOOR:
+      return Math.floor(value);
+    default:
+    case SizeRoundingBehavior.FAIL:
+      if (!Number.isInteger(value)) {
+        throw new Error(`'${amount} ${fromUnit}' cannot be converted into a whole number of ${toUnit}.`);
+      }
+      return value;
   }
-  return value;
 }

packages/@aws-cdk/core/test/test.size.ts

@@ -1,5 +1,5 @@
 import { Test } from 'nodeunit';
-import { Size, Stack, Token } from '../lib';
+import { Size, SizeRoundingBehavior, Stack, Token } from '../lib';
 
 export = {
   'negative amount'(test: Test) {
@@ -28,7 +28,7 @@ export = {
     test.equal(size.toGibibytes(), 4_096);
     test.equal(size.toTebibytes(), 4);
     test.throws(() => size.toPebibytes(), /'4294967296 kibibytes' cannot be converted into a whole number/);
-    floatEqual(test, size.toPebibytes({ integral: false }), 4_294_967_296 / (1024 * 1024 * 1024 * 1024));
+    floatEqual(test, size.toPebibytes({ rounding: SizeRoundingBehavior.NONE }), 4_294_967_296 / (1024 * 1024 * 1024 * 1024));
 
     test.equal(Size.kibibytes(4 * 1024 * 1024).toGibibytes(), 4);
 
@@ -43,7 +43,7 @@ export = {
     test.equal(size.toGibibytes(), 4_096);
     test.equal(size.toTebibytes(), 4);
     test.throws(() => size.toPebibytes(), /'4194304 mebibytes' cannot be converted into a whole number/);
-    floatEqual(test, size.toPebibytes({ integral: false }), 4_194_304 / (1024 * 1024 * 1024));
+    floatEqual(test, size.toPebibytes({ rounding: SizeRoundingBehavior.NONE }), 4_194_304 / (1024 * 1024 * 1024));
 
     test.equal(Size.mebibytes(4 * 1024).toGibibytes(), 4);
 
@@ -57,9 +57,9 @@ export = {
     test.equal(size.toMebibytes(), 5_120);
     test.equal(size.toGibibytes(), 5);
     test.throws(() => size.toTebibytes(), /'5 gibibytes' cannot be converted into a whole number/);
-    floatEqual(test, size.toTebibytes({ integral: false }), 5 / 1024);
+    floatEqual(test, size.toTebibytes({ rounding: SizeRoundingBehavior.NONE }), 5 / 1024);
     test.throws(() => size.toPebibytes(), /'5 gibibytes' cannot be converted into a whole number/);
-    floatEqual(test, size.toPebibytes({ integral: false }), 5 / (1024 * 1024));
+    floatEqual(test, size.toPebibytes({ rounding: SizeRoundingBehavior.NONE }), 5 / (1024 * 1024));
 
     test.equal(Size.gibibytes(4096).toTebibytes(), 4);
 
@@ -74,7 +74,7 @@ export = {
     test.equal(size.toGibibytes(), 5_120);
     test.equal(size.toTebibytes(), 5);
     test.throws(() => size.toPebibytes(), /'5 tebibytes' cannot be converted into a whole number/);
-    floatEqual(test, size.toPebibytes({ integral: false }), 5 / 1024);
+    floatEqual(test, size.toPebibytes({ rounding: SizeRoundingBehavior.NONE }), 5 / 1024);
 
     test.equal(Size.tebibytes(4096).toPebibytes(), 4);
 
@@ -92,6 +92,23 @@ export = {
 
     test.done();
   },
+
+  'rounding behavior'(test: Test) {
+    const size = Size.mebibytes(5_200);
+
+    test.throws(() => size.toGibibytes(), /cannot be converted into a whole number/);
+    test.throws(() => size.toGibibytes({ rounding: SizeRoundingBehavior.FAIL }), /cannot be converted into a whole number/);
+
+    test.equals(size.toGibibytes({ rounding: SizeRoundingBehavior.FLOOR }), 5);
+    test.equals(size.toTebibytes({ rounding: SizeRoundingBehavior.FLOOR }), 0);
+    floatEqual(test, size.toKibibytes({ rounding: SizeRoundingBehavior.FLOOR }), 5_324_800);
+
+    test.equals(size.toGibibytes({ rounding: SizeRoundingBehavior.NONE}), 5.078125);
+    test.equals(size.toTebibytes({ rounding: SizeRoundingBehavior.NONE}), 5200 / (1024 * 1024));
+    test.equals(size.toKibibytes({ rounding: SizeRoundingBehavior.NONE}), 5_324_800);
+
+    test.done();
+  }
 };
 
 function floatEqual(test: Test, actual: number, expected: number) {