add support for SQS batchsize and enable properties

Author: sebsto

Sources/AWSLambdaDeploymentDescriptor/DeploymentDescriptor.swift

@@ -345,33 +345,34 @@ public enum HttpVerb: String, Encodable {
  -----------------------------------------------------------------------------------------*/
 
 extension Resource {
-    internal static func sqs(
-        name: String = "SQSEvent",
-        properties: SQSEventProperties
-    ) -> Resource<EventSourceType> {
+    internal static func sqs(name: String = "SQSEvent", properties: SQSEventProperties) -> Resource<EventSourceType> {
 
         return Resource<EventSourceType>(
             type: .sqs,
             properties: properties,
             name: name)
     }
-    public static func sqs(
-        name: String = "SQSEvent",
-        queue queueRef: String
-    ) -> Resource<EventSourceType> {
+    public static func sqs(name: String = "SQSEvent",
+                           queue queueRef: String,
+                           batchSize: Int = 10,
+                           enabled: Bool = true) -> Resource<EventSourceType> {
 
-        let properties = SQSEventProperties(byRef: queueRef)
+        let properties = SQSEventProperties(byRef: queueRef,
+                                                   batchSize: batchSize,
+                                                   enabled: enabled)
         return Resource<EventSourceType>.sqs(
             name: name,
             properties: properties)
     }
 
-    public static func sqs(
-        name: String = "SQSEvent",
-        queue: Resource<ResourceType>
-    ) -> Resource<EventSourceType> {
+    public static func sqs(name: String = "SQSEvent",                           
+                           queue: Resource<ResourceType>,
+                           batchSize: Int = 10,
+                           enabled: Bool = true) -> Resource<EventSourceType> {
 
-        let properties = SQSEventProperties(queue)
+        let properties = SQSEventProperties(queue,
+                                            batchSize: batchSize,
+                                            enabled: enabled)
         return Resource<EventSourceType>.sqs(
             name: name,
             properties: properties)
@@ -384,26 +385,41 @@ public struct SQSEventProperties: SAMResourceProperties, Equatable {
 
     public var queueByArn: String? = nil
     public var queue: Resource<ResourceType>? = nil
+    public var batchSize : Int
+    public var enabled : Bool
 
-    init(byRef ref: String) {
+    init(byRef ref: String,
+         batchSize: Int,
+         enabled: Bool) {
 
         // when the ref is an ARN, leave it as it, otherwise, create a queue resource and pass a reference to it
         if let arn = Arn(ref)?.arn {
             self.queueByArn = arn
         } else {
             let logicalName = Resource<EventSourceType>.logicalName(
-                resourceType: "Queue",
-                resourceName: ref)
+                                            resourceType: "Queue",
+                                            resourceName: ref)
             self.queue = Resource<ResourceType>.queue(
-                name: logicalName,
-                properties: SQSResourceProperties(queueName: ref))
-        }
-        
+                                                name: logicalName,
+                                                properties: SQSResourceProperties(queueName: ref))
+        }   
+        self.batchSize = batchSize
+        self.enabled = enabled
+    }
+
+    init(_ queue: Resource<ResourceType>,
+         batchSize: Int,
+         enabled: Bool) { 
+
+        self.queue = queue
+        self.batchSize = batchSize
+        self.enabled = enabled
     }
-    init(_ queue: Resource<ResourceType>) { self.queue = queue }
 
     enum CodingKeys: String, CodingKey {
         case queue = "Queue"
+        case batchSize = " BatchSize"
+        case enabled = "Enabled"
     }
 
     public func encode(to encoder: Encoder) throws {
@@ -418,6 +434,8 @@ public struct SQSEventProperties: SAMResourceProperties, Equatable {
             getAttIntrinsicFunction["Fn::GetAtt"] = [queue.name, "Arn"]
             try container.encode(getAttIntrinsicFunction, forKey: .queue)
         }
+        try container.encode(batchSize, forKey: .batchSize)
+        try container.encode(enabled, forKey: .enabled)
     }
 }
 

Sources/AWSLambdaDeploymentDescriptor/DeploymentDescriptorBuilder.swift

@@ -251,26 +251,45 @@ public struct Sqs {
     private let name: String
     private var queueRef: String? = nil
     private var queue: Queue? = nil
+    public var batchSize : Int = 10 
+    public var enabled : Bool = true 
+
     public init(name: String = "SQSEvent") {
         self.name = name
     }
-    public init(name: String = "SQSEvent", _ queue: String) {
+    public init(name: String = "SQSEvent",
+                _ queue: String,
+                batchSize: Int = 10,
+                enabled: Bool = true) {
         self.name = name
         self.queueRef = queue
+        self.batchSize = batchSize
+        self.enabled = enabled
     }
-    public init(name: String = "SQSEvent", _ queue: Queue) {
+    public init(name: String = "SQSEvent",
+                _ queue: Queue,
+                batchSize: Int = 10,
+                enabled: Bool = true) {
         self.name = name
         self.queue = queue
+        self.batchSize = batchSize
+        self.enabled = enabled
     }
     public func queue(logicalName: String, physicalName: String) -> Sqs {
         let queue = Queue(logicalName: logicalName, physicalName: physicalName)
         return Sqs(name: self.name, queue)
     }
     internal func resource() -> Resource<EventSourceType> {
         if self.queue != nil {
-            return Resource<EventSourceType>.sqs(name: self.name, queue: self.queue!.resource())
+            return Resource<EventSourceType>.sqs(name: self.name,
+                                                 queue: self.queue!.resource(),
+                                                 batchSize: self.batchSize,
+                                                 enabled: self.enabled)
         } else if self.queueRef != nil {
-            return Resource<EventSourceType>.sqs(name: self.name, queue: self.queueRef!)
+            return Resource<EventSourceType>.sqs(name: self.name,
+                                                 queue: self.queueRef!,
+                                                 batchSize: self.batchSize,
+                                                 enabled: self.enabled)
         } else {
             fatalError("Either queue or queueRef muts have a value")
         }
@@ -376,6 +395,10 @@ private struct DeploymentDescriptorSerializer {
                           format: SerializeFormat,
                           to fileDesc: Int32 = 1
     ) throws {
+        
+        // do not output the deployment descriptor on stdout when running unit tests
+        if Thread.current.isRunningXCTest { return }
+
         guard let fd = fdopen(fileDesc, "w") else { return }
         switch format {
         case .json: fputs(deploymentDescriptor.toJSON(), fd)

Tests/AWSLambdaDeploymentDescriptorTests/DeploymentDescriptorTests.swift

@@ -22,6 +22,9 @@ final class DeploymentDescriptorTest: XCTestCase {
                                                      expected: String) -> Bool {
         // when
         let samJSON = deployment.toJSON()
+        // print(samJSON)
+        // print("===========")
+        // print(expected)
 
         // then
         return samJSON.contains(expected)
@@ -129,7 +132,7 @@ function","AWSTemplateFormatVersion":"2010-09-09","Resources":{"TestLambda":{"Ty
 
         // given
         let expected = """
-"Resources":{"TestLambda":{"Type":"AWS::Serverless::Function","Properties":{"Runtime":"provided.al2","CodeUri":"\\/path\\/lambda.zip","Events":{"SQSEvent":{"Type":"SQS","Properties":{"Queue":"arn:aws:sqs:eu-central-1:012345678901:lambda-test"}}},"Handler":"Provided","AutoPublishAlias":"Live","Architectures":["\(Architectures.defaultArchitecture())"]}}}
+"Resources":{"TestLambda":{"Type":"AWS::Serverless::Function","Properties":{"Runtime":"provided.al2","CodeUri":"\\/path\\/lambda.zip","Events":{"SQSEvent":{"Type":"SQS","Properties":{"Queue":"arn:aws:sqs:eu-central-1:012345678901:lambda-test"," BatchSize":10,"Enabled":true}}},"Handler":"Provided","AutoPublishAlias":"Live","Architectures":["arm64"]}}}
 """
 
         let testDeployment = MockDeploymentDescriptor(withFunction: true,
@@ -146,7 +149,7 @@ function","AWSTemplateFormatVersion":"2010-09-09","Resources":{"TestLambda":{"Ty
                                                       eventSource: [ .sqs(queue: "queue-lambda-test") ] )
 
         let expected = """
-"Events":{"SQSEvent":{"Type":"SQS","Properties":{"Queue":{"Fn::GetAtt":["QueueQueueLambdaTest","Arn"]}}}}
+"Events":{"SQSEvent":{"Type":"SQS","Properties":{"Queue":{"Fn::GetAtt":["QueueQueueLambdaTest","Arn"]}," BatchSize":10,"Enabled":true}}}
 """
         XCTAssertTrue(self.generateAndTestDeploymentDescriptor(deployment: testDeployment,
                                                                expected: expected))