Light, fluffy, and always free - The AWS Local Emulator alternative
Feat/lambda image config working directory (#673)
Yorí8eeb2244a7b9
diff --git a/compatibility-tests/sdk-test-awscli/test/lambda.bats b/compatibility-tests/sdk-test-awscli/test/lambda.batsnew file mode 100644index 0000000000..f1e84b85e6--- /dev/null+++ b/compatibility-tests/sdk-test-awscli/test/lambda.bats@@ -0,0 +1,67 @@+#!/usr/bin/env bats+# Lambda tests++setup() {+ load 'test_helper/common-setup'+ FUNC_NAME=""+}++teardown() {+ if [ -n "$FUNC_NAME" ]; then+ aws_cmd lambda delete-function --function-name "$FUNC_NAME" >/dev/null 2>&1 || true+ fi+}++_role="arn:aws:iam::000000000000:role/lambda-role"+_image_uri="000000000000.dkr.ecr.us-east-1.amazonaws.com/fake-repo:latest"++@test "Lambda: ImageConfig.WorkingDirectory is returned in CreateFunction response" {+ FUNC_NAME="bats-imgwd-create-$(unique_name)"++ run aws_cmd lambda create-function \+ --function-name "$FUNC_NAME" \+ --package-type Image \+ --role "$_role" \+ --code "ImageUri=$_image_uri" \+ --image-config 'WorkingDirectory=/app'+ assert_success++ wd=$(json_get "$output" '.ImageConfigResponse.ImageConfig.WorkingDirectory')+ [ "$wd" = "/app" ] || { echo "expected WorkingDirectory=/app, got: $wd"; return 1; }+}++@test "Lambda: ImageConfig.WorkingDirectory is persisted and returned by get-function-configuration" {+ FUNC_NAME="bats-imgwd-get-$(unique_name)"++ aws_cmd lambda create-function \+ --function-name "$FUNC_NAME" \+ --package-type Image \+ --role "$_role" \+ --code "ImageUri=$_image_uri" \+ --image-config 'WorkingDirectory=/workspace' >/dev/null++ run aws_cmd lambda get-function-configuration --function-name "$FUNC_NAME"+ assert_success++ wd=$(json_get "$output" '.ImageConfigResponse.ImageConfig.WorkingDirectory')+ [ "$wd" = "/workspace" ] || { echo "expected WorkingDirectory=/workspace, got: $wd"; return 1; }+}++@test "Lambda: ImageConfig.WorkingDirectory is updated by update-function-configuration" {+ FUNC_NAME="bats-imgwd-upd-$(unique_name)"++ aws_cmd lambda create-function \+ --function-name "$FUNC_NAME" \+ --package-type Image \+ --role "$_role" \+ --code "ImageUri=$_image_uri" \+ --image-config 'WorkingDirectory=/initial' >/dev/null++ run aws_cmd lambda update-function-configuration \+ --function-name "$FUNC_NAME" \+ --image-config 'WorkingDirectory=/updated'+ assert_success++ wd=$(json_get "$output" '.ImageConfigResponse.ImageConfig.WorkingDirectory')+ [ "$wd" = "/updated" ] || { echo "expected WorkingDirectory=/updated, got: $wd"; return 1; }+}diff --git a/compatibility-tests/sdk-test-go/tests/lambda_test.go b/compatibility-tests/sdk-test-go/tests/lambda_test.goindex 1867db28be..83d0273280 100644--- a/compatibility-tests/sdk-test-go/tests/lambda_test.go+++ b/compatibility-tests/sdk-test-go/tests/lambda_test.go@@ -73,3 +73,58 @@ func TestLambda(t *testing.T) {require.NoError(t, err)})}++func TestLambdaImageConfigWorkingDirectory(t *testing.T) {+ ctx := context.Background()+ svc := testutil.LambdaClient()+ roleARN := "arn:aws:iam::000000000000:role/test-role"+ imageURI := "000000000000.dkr.ecr.us-east-1.amazonaws.com/fake-repo:latest"++ t.Run("RoundTripsWorkingDirectoryOnCreate", func(t *testing.T) {+ fnName := "go-test-imgwd-create"+ t.Cleanup(func() {+ svc.DeleteFunction(ctx, &lambda.DeleteFunctionInput{FunctionName: aws.String(fnName)})+ })++ createResp, err := svc.CreateFunction(ctx, &lambda.CreateFunctionInput{+ FunctionName: aws.String(fnName),+ PackageType: lambdatypes.PackageTypeImage,+ Role: aws.String(roleARN),+ Code: &lambdatypes.FunctionCode{ImageUri: aws.String(imageURI)},+ ImageConfig: &lambdatypes.ImageConfig{WorkingDirectory: aws.String("/app")},+ })+ require.NoError(t, err)+ require.NotNil(t, createResp.ImageConfigResponse)+ require.NotNil(t, createResp.ImageConfigResponse.ImageConfig)+ assert.Equal(t, "/app", aws.ToString(createResp.ImageConfigResponse.ImageConfig.WorkingDirectory))++ getResp, err := svc.GetFunctionConfiguration(ctx, &lambda.GetFunctionConfigurationInput{+ FunctionName: aws.String(fnName),+ })+ require.NoError(t, err)+ assert.Equal(t, "/app", aws.ToString(getResp.ImageConfigResponse.ImageConfig.WorkingDirectory))+ })++ t.Run("UpdatesWorkingDirectory", func(t *testing.T) {+ fnName := "go-test-imgwd-update"+ t.Cleanup(func() {+ svc.DeleteFunction(ctx, &lambda.DeleteFunctionInput{FunctionName: aws.String(fnName)})+ })++ _, err := svc.CreateFunction(ctx, &lambda.CreateFunctionInput{+ FunctionName: aws.String(fnName),+ PackageType: lambdatypes.PackageTypeImage,+ Role: aws.String(roleARN),+ Code: &lambdatypes.FunctionCode{ImageUri: aws.String(imageURI)},+ ImageConfig: &lambdatypes.ImageConfig{WorkingDirectory: aws.String("/initial")},+ })+ require.NoError(t, err)++ updateResp, err := svc.UpdateFunctionConfiguration(ctx, &lambda.UpdateFunctionConfigurationInput{+ FunctionName: aws.String(fnName),+ ImageConfig: &lambdatypes.ImageConfig{WorkingDirectory: aws.String("/updated")},+ })+ require.NoError(t, err)+ assert.Equal(t, "/updated", aws.ToString(updateResp.ImageConfigResponse.ImageConfig.WorkingDirectory))+ })+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaFunctionConfigTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaFunctionConfigTest.javaindex e258b2404c..c13dbdd953 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaFunctionConfigTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaFunctionConfigTest.java@@ -218,4 +218,51 @@ class LambdaFunctionConfigTest {.as("Environment block must be present even after clearing variables").isNotNull();}++ @Test+ @Order(6)+ @DisplayName("ImageConfig.WorkingDirectory round-trips via create and get")+ void imageConfigWorkingDirectoryRoundTrips() {+ String imageFn = TestFixtures.uniqueName("fn-image-wd");+ try {+ CreateFunctionResponse createResp = lambda.createFunction(CreateFunctionRequest.builder()+ .functionName(imageFn)+ .packageType(software.amazon.awssdk.services.lambda.model.PackageType.IMAGE)+ .role(ROLE)+ .code(FunctionCode.builder()+ .imageUri("000000000000.dkr.ecr.us-east-1.amazonaws.com/fake-repo:latest")+ .build())+ .imageConfig(software.amazon.awssdk.services.lambda.model.ImageConfig.builder()+ .workingDirectory("/app")+ .build())+ .build());++ assertThat(createResp.imageConfigResponse().imageConfig().workingDirectory())+ .as("CreateFunction response must include ImageConfig.WorkingDirectory")+ .isEqualTo("/app");++ GetFunctionConfigurationResponse getResp = lambda.getFunctionConfiguration(+ GetFunctionConfigurationRequest.builder().functionName(imageFn).build());++ assertThat(getResp.imageConfigResponse().imageConfig().workingDirectory())+ .as("GetFunctionConfiguration must persist ImageConfig.WorkingDirectory")+ .isEqualTo("/app");++ UpdateFunctionConfigurationResponse updateResp = lambda.updateFunctionConfiguration(+ UpdateFunctionConfigurationRequest.builder()+ .functionName(imageFn)+ .imageConfig(software.amazon.awssdk.services.lambda.model.ImageConfig.builder()+ .workingDirectory("/updated")+ .build())+ .build());++ assertThat(updateResp.imageConfigResponse().imageConfig().workingDirectory())+ .as("UpdateFunctionConfiguration must update ImageConfig.WorkingDirectory")+ .isEqualTo("/updated");+ } finally {+ try {+ lambda.deleteFunction(DeleteFunctionRequest.builder().functionName(imageFn).build());+ } catch (Exception ignored) {}+ }+ }}diff --git a/compatibility-tests/sdk-test-node/tests/lambda.test.ts b/compatibility-tests/sdk-test-node/tests/lambda.test.tsindex 0874a52526..57efb7685a 100644--- a/compatibility-tests/sdk-test-node/tests/lambda.test.ts+++ b/compatibility-tests/sdk-test-node/tests/lambda.test.ts@@ -7,6 +7,8 @@ import {LambdaClient,CreateFunctionCommand,GetFunctionCommand,+ GetFunctionConfigurationCommand,+ UpdateFunctionConfigurationCommand,ListFunctionsCommand,DeleteFunctionCommand,CreateAliasCommand,@@ -128,3 +130,58 @@ describe('Lambda', () => {).rejects.toThrow();});});++describe('Lambda ImageConfig.WorkingDirectory', () => {+ let lambda: LambdaClient;+ const IMAGE_URI = '000000000000.dkr.ecr.us-east-1.amazonaws.com/fake-repo:latest';+ const ROLE = 'arn:aws:iam::000000000000:role/lambda-role';++ beforeAll(() => {+ lambda = makeClient(LambdaClient);+ });++ it('round-trips WorkingDirectory through create and get', async () => {+ const fnName = `test-imgwd-${uniqueName()}`;+ try {+ const createResp = await lambda.send(new CreateFunctionCommand({+ FunctionName: fnName,+ PackageType: 'Image',+ Role: ROLE,+ Code: { ImageUri: IMAGE_URI },+ ImageConfig: { WorkingDirectory: '/app' },+ }));++ expect(createResp.ImageConfigResponse?.ImageConfig?.WorkingDirectory).toBe('/app');++ const getResp = await lambda.send(new GetFunctionConfigurationCommand({+ FunctionName: fnName,+ }));++ expect(getResp.ImageConfigResponse?.ImageConfig?.WorkingDirectory).toBe('/app');+ } finally {+ await lambda.send(new DeleteFunctionCommand({ FunctionName: fnName })).catch(() => {});+ }+ });++ it('updates WorkingDirectory via updateFunctionConfiguration', async () => {+ const fnName = `test-imgwd-upd-${uniqueName()}`;+ try {+ await lambda.send(new CreateFunctionCommand({+ FunctionName: fnName,+ PackageType: 'Image',+ Role: ROLE,+ Code: { ImageUri: IMAGE_URI },+ ImageConfig: { WorkingDirectory: '/initial' },+ }));++ const updateResp = await lambda.send(new UpdateFunctionConfigurationCommand({+ FunctionName: fnName,+ ImageConfig: { WorkingDirectory: '/updated' },+ }));++ expect(updateResp.ImageConfigResponse?.ImageConfig?.WorkingDirectory).toBe('/updated');+ } finally {+ await lambda.send(new DeleteFunctionCommand({ FunctionName: fnName })).catch(() => {});+ }+ });+});diff --git a/compatibility-tests/sdk-test-python/tests/test_lambda_function_config.py b/compatibility-tests/sdk-test-python/tests/test_lambda_function_config.pyindex ee5f278678..8cf5f30505 100644--- a/compatibility-tests/sdk-test-python/tests/test_lambda_function_config.py+++ b/compatibility-tests/sdk-test-python/tests/test_lambda_function_config.py@@ -280,3 +280,83 @@ class TestUpdateFunctionConfiguration:)finally:lambda_client.delete_function(FunctionName=fn)+++class TestImageConfigWorkingDirectory:+ """ImageConfig.WorkingDirectory is persisted and returned correctly."""++ IMAGE_URI = "000000000000.dkr.ecr.us-east-1.amazonaws.com/fake-repo:latest"++ def test_create_image_function_with_working_directory(+ self, lambda_client, unique_name+ ):+ fn = f"pytest-imgwd-{unique_name}"+ try:+ resp = lambda_client.create_function(+ FunctionName=fn,+ PackageType="Image",+ Role=ROLE,+ Code={"ImageUri": self.IMAGE_URI},+ ImageConfig={"WorkingDirectory": "/app"},+ )+ wd = (+ resp.get("ImageConfigResponse", {})+ .get("ImageConfig", {})+ .get("WorkingDirectory")+ )+ assert wd == "/app", (+ f"CreateFunction response must include ImageConfig.WorkingDirectory='/app', got: {wd!r}"+ )+ finally:+ lambda_client.delete_function(FunctionName=fn)++ def test_get_function_configuration_persists_working_directory(+ self, lambda_client, unique_name+ ):+ fn = f"pytest-imgwd-get-{unique_name}"+ try:+ lambda_client.create_function(+ FunctionName=fn,+ PackageType="Image",+ Role=ROLE,+ Code={"ImageUri": self.IMAGE_URI},+ ImageConfig={"WorkingDirectory": "/workspace"},+ )+ resp = lambda_client.get_function_configuration(FunctionName=fn)+ wd = (+ resp.get("ImageConfigResponse", {})+ .get("ImageConfig", {})+ .get("WorkingDirectory")+ )+ assert wd == "/workspace", (+ f"GetFunctionConfiguration must persist WorkingDirectory='/workspace', got: {wd!r}"+ )+ finally:+ lambda_client.delete_function(FunctionName=fn)++ def test_update_function_configuration_updates_working_directory(+ self, lambda_client, unique_name+ ):+ fn = f"pytest-imgwd-upd-{unique_name}"+ try:+ lambda_client.create_function(+ FunctionName=fn,+ PackageType="Image",+ Role=ROLE,+ Code={"ImageUri": self.IMAGE_URI},+ ImageConfig={"WorkingDirectory": "/initial"},+ )+ resp = lambda_client.update_function_configuration(+ FunctionName=fn,+ ImageConfig={"WorkingDirectory": "/updated"},+ )+ wd = (+ resp.get("ImageConfigResponse", {})+ .get("ImageConfig", {})+ .get("WorkingDirectory")+ )+ assert wd == "/updated", (+ f"UpdateFunctionConfiguration must update WorkingDirectory to '/updated', got: {wd!r}"+ )+ finally:+ lambda_client.delete_function(FunctionName=fn)diff --git a/compatibility-tests/sdk-test-rust/tests/lambda_test.rs b/compatibility-tests/sdk-test-rust/tests/lambda_test.rsindex 11036b23af..748ae6b750 100644--- a/compatibility-tests/sdk-test-rust/tests/lambda_test.rs+++ b/compatibility-tests/sdk-test-rust/tests/lambda_test.rs@@ -1,6 +1,6 @@mod common;-use aws_sdk_lambda::types::Runtime;+use aws_sdk_lambda::types::{ImageConfig, PackageType, Runtime};#[tokio::test(flavor = "multi_thread")]async fn test_lambda_create_function() {@@ -176,3 +176,74 @@ async fn test_lambda_delete_function() {let result = lambda.delete_function().function_name(func_name).send().await;assert!(result.is_ok(), "DeleteFunction failed: {:?}", result.err());}++#[tokio::test(flavor = "multi_thread")]+async fn test_lambda_image_config_working_directory_round_trip() {+ let lambda = common::lambda_client().await;+ let func_name = "rust-test-imgwd-fn";+ let role_arn = "arn:aws:iam::000000000000:role/test-role";+ let image_uri = "000000000000.dkr.ecr.us-east-1.amazonaws.com/fake-repo:latest";++ let _guard = common::CleanupGuard::new({+ let lambda = lambda.clone();+ async move {+ let _ = lambda.delete_function().function_name(func_name).send().await;+ }+ });++ let create_resp = lambda+ .create_function()+ .function_name(func_name)+ .package_type(PackageType::Image)+ .role(role_arn)+ .code(+ aws_sdk_lambda::types::FunctionCode::builder()+ .image_uri(image_uri)+ .build(),+ )+ .image_config(+ ImageConfig::builder()+ .working_directory("/app")+ .build(),+ )+ .send()+ .await+ .expect("CreateFunction with ImageConfig.WorkingDirectory failed");++ let wd = create_resp+ .image_config_response()+ .and_then(|r| r.image_config())+ .and_then(|c| c.working_directory());+ assert_eq!(wd, Some("/app"), "CreateFunction response must include WorkingDirectory");++ let get_resp = lambda+ .get_function_configuration()+ .function_name(func_name)+ .send()+ .await+ .expect("GetFunctionConfiguration failed");++ let wd = get_resp+ .image_config_response()+ .and_then(|r| r.image_config())+ .and_then(|c| c.working_directory());+ assert_eq!(wd, Some("/app"), "GetFunctionConfiguration must persist WorkingDirectory");++ let update_resp = lambda+ .update_function_configuration()+ .function_name(func_name)+ .image_config(+ ImageConfig::builder()+ .working_directory("/updated")+ .build(),+ )+ .send()+ .await+ .expect("UpdateFunctionConfiguration failed");++ let wd = update_resp+ .image_config_response()+ .and_then(|r| r.image_config())+ .and_then(|c| c.working_directory());+ assert_eq!(wd, Some("/updated"), "UpdateFunctionConfiguration must update WorkingDirectory");+}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerBuilder.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerBuilder.javaindex 198c8e11c3..b6a0bcc754 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerBuilder.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerBuilder.java@@ -69,6 +69,7 @@ public class ContainerBuilder {private final List<String> env = new ArrayList<>();private List<String> cmd;private List<String> entrypoint;+ private String workingDir;private Long memoryBytes;private final Map<Integer, Integer> portBindings = new HashMap<>();private final List<Integer> exposedPorts = new ArrayList<>();@@ -136,6 +137,14 @@ public class ContainerBuilder {return this;}+ /**+ * Sets the working directory inside the container (overrides image WORKDIR).+ */+ public Builder withWorkingDir(String workingDir) {+ this.workingDir = workingDir;+ return this;+ }+/*** Sets the memory limit in megabytes.*/@@ -315,7 +324,8 @@ public class ContainerBuilder {List.copyOf(extraHosts),logConfig,privileged,- List.copyOf(dnsServers)+ List.copyOf(dnsServers),+ workingDir);}}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.javaindex 00625d8d36..7db390953b 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java@@ -90,6 +90,9 @@ public class ContainerLifecycleManager {if (spec.entrypoint() != null && !spec.entrypoint().isEmpty()) {createCmd.withEntrypoint(spec.entrypoint());}+ if (spec.workingDir() != null && !spec.workingDir().isBlank()) {+ createCmd.withWorkingDir(spec.workingDir());+ }if (spec.exposedPorts() != null && !spec.exposedPorts().isEmpty()) {ExposedPort[] exposed = spec.exposedPorts().stream().map(ExposedPort::tcp)diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerSpec.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerSpec.javaindex 3bb3b0f74f..35856e4b88 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerSpec.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerSpec.java@@ -26,6 +26,7 @@ import java.util.Map;* @param logConfig Docker log driver configuration (null = daemon default)* @param privileged Whether to run the container in privileged mode (required for k3s)* @param dnsServers DNS server IPs to inject into the container (e.g. Floci's embedded DNS)+ * @param workingDir Working directory inside the container (overrides image WORKDIR)*/public record ContainerSpec(String image,@@ -42,14 +43,15 @@ public record ContainerSpec(List<String> extraHosts,LogConfig logConfig,boolean privileged,- List<String> dnsServers+ List<String> dnsServers,+ String workingDir) {/*** Creates a minimal spec with just the image name.* All other fields will be null or empty lists.*/public ContainerSpec(String image) {- this(image, null, List.of(), null, null, null, Map.of(), List.of(), null, List.of(), List.of(), List.of(), null, false, List.of());+ this(image, null, List.of(), null, null, null, Map.of(), List.of(), null, List.of(), List.of(), List.of(), null, false, List.of(), null);}/**diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.javaindex c1a0bb171e..e39500f4ff 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java@@ -539,6 +539,9 @@ public class LambdaController {ArrayNode epNode = imageConfig.putArray("EntryPoint");fn.getImageConfigEntryPoint().forEach(epNode::add);}+ if (fn.getImageConfigWorkingDirectory() != null && !fn.getImageConfigWorkingDirectory().isBlank()) {+ imageConfig.put("WorkingDirectory", fn.getImageConfigWorkingDirectory());+ }}node.put("LastModified", DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSZ").format(Instant.ofEpochMilli(fn.getLastModified()).atOffset(ZoneOffset.UTC)));diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.javaindex 83599b556f..4d87f3e2b2 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java@@ -296,6 +296,9 @@ public class LambdaService {if (imageConfig.get("EntryPoint") instanceof List<?> ep) {fn.setImageConfigEntryPoint(ep.stream().map(Object::toString).toList());}+ if (imageConfig.get("WorkingDirectory") instanceof String wd) {+ fn.setImageConfigWorkingDirectory(wd);+ }}// Handle code deployment@@ -509,6 +512,10 @@ public class LambdaService {? ((List<?>) imageConfig.get("EntryPoint")).stream().map(Object::toString).toList() : null;fn.setImageConfigEntryPoint(ep);}+ if (imageConfig.containsKey("WorkingDirectory")) {+ fn.setImageConfigWorkingDirectory(+ imageConfig.get("WorkingDirectory") instanceof String wd ? wd : null);+ }}}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.javaindex 8d46f3c5cf..bd63321ffc 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java@@ -192,7 +192,7 @@ public class ContainerLauncher {specBuilder.withBind(fn.getHotReloadHostPath(), TASK_DIR);}- // For Image package type use ImageConfig.Command if set, otherwise fall back to Handler (Zip-style)+ // For Image package type use ImageConfig.Command/EntryPoint/WorkingDirectory if set, otherwise fall back to Handler (Zip-style)if ("Image".equals(fn.getPackageType())) {if (fn.getImageConfigEntryPoint() != null && !fn.getImageConfigEntryPoint().isEmpty()) {specBuilder.withEntrypoint(fn.getImageConfigEntryPoint());@@ -200,6 +200,9 @@ public class ContainerLauncher {if (fn.getImageConfigCommand() != null && !fn.getImageConfigCommand().isEmpty()) {specBuilder.withCmd(fn.getImageConfigCommand());}+ if (fn.getImageConfigWorkingDirectory() != null && !fn.getImageConfigWorkingDirectory().isBlank()) {+ specBuilder.withWorkingDir(fn.getImageConfigWorkingDirectory());+ }} else if (fn.getHandler() != null && !fn.getHandler().isBlank()) {specBuilder.withCmd(fn.getHandler());}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/model/LambdaFunction.java b/src/main/java/io/github/hectorvent/floci/services/lambda/model/LambdaFunction.javaindex e315c24449..635a144625 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/model/LambdaFunction.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/model/LambdaFunction.java@@ -29,6 +29,7 @@ public class LambdaFunction {private String imageUri;private List<String> imageConfigCommand;private List<String> imageConfigEntryPoint;+ private String imageConfigWorkingDirectory;private String codeLocalPath;private String s3Bucket;private String s3Key;@@ -106,6 +107,9 @@ public class LambdaFunction {public List<String> getImageConfigEntryPoint() { return imageConfigEntryPoint; }public void setImageConfigEntryPoint(List<String> imageConfigEntryPoint) { this.imageConfigEntryPoint = imageConfigEntryPoint; }+ public String getImageConfigWorkingDirectory() { return imageConfigWorkingDirectory; }+ public void setImageConfigWorkingDirectory(String imageConfigWorkingDirectory) { this.imageConfigWorkingDirectory = imageConfigWorkingDirectory; }+public String getCodeLocalPath() { return codeLocalPath; }public void setCodeLocalPath(String codeLocalPath) { this.codeLocalPath = codeLocalPath; }diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaImageConfigTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaImageConfigTest.javaindex 7b6e6a7946..8ae74c6a30 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaImageConfigTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaImageConfigTest.java@@ -96,12 +96,41 @@ class LambdaImageConfigTest {assertEquals(List.of("/entry.sh"), fn.getImageConfigEntryPoint());}+ @Test+ void storesImageConfigWorkingDirectory() {+ Map<String, Object> req = imageRequest("fn-wd");+ req.put("ImageConfig", Map.of("WorkingDirectory", "/app"));++ LambdaFunction fn = service.createFunction(REGION, req);++ assertEquals("/app", fn.getImageConfigWorkingDirectory());+ assertNull(fn.getImageConfigCommand());+ assertNull(fn.getImageConfigEntryPoint());+ }++ @Test+ void storesAllThreeImageConfigFields() {+ Map<String, Object> req = imageRequest("fn-all");+ req.put("ImageConfig", Map.of(+ "Command", List.of("app.handler"),+ "EntryPoint", List.of("/entry.sh"),+ "WorkingDirectory", "/workspace"+ ));++ LambdaFunction fn = service.createFunction(REGION, req);++ assertEquals(List.of("app.handler"), fn.getImageConfigCommand());+ assertEquals(List.of("/entry.sh"), fn.getImageConfigEntryPoint());+ assertEquals("/workspace", fn.getImageConfigWorkingDirectory());+ }+@Testvoid noImageConfigLeavesFieldsNull() {LambdaFunction fn = service.createFunction(REGION, imageRequest("fn-none"));assertNull(fn.getImageConfigCommand());assertNull(fn.getImageConfigEntryPoint());+ assertNull(fn.getImageConfigWorkingDirectory());}}@@ -146,6 +175,32 @@ class LambdaImageConfigTest {assertTrue(fn.getImageConfigCommand() == null || fn.getImageConfigCommand().isEmpty());}++ @Test+ void updatesImageConfigWorkingDirectory() {+ service.createFunction(REGION, imageRequest("fn-upd-wd"));++ Map<String, Object> update = new HashMap<>();+ update.put("ImageConfig", Map.of("WorkingDirectory", "/updated"));+ LambdaFunction fn = service.updateFunctionConfiguration(REGION, "fn-upd-wd", update);++ assertEquals("/updated", fn.getImageConfigWorkingDirectory());+ }++ @Test+ void clearsWorkingDirectoryWhenNullValueProvided() {+ Map<String, Object> req = imageRequest("fn-clear-wd");+ req.put("ImageConfig", Map.of("WorkingDirectory", "/initial"));+ service.createFunction(REGION, req);++ Map<String, Object> update = new HashMap<>();+ Map<String, Object> imageConfig = new HashMap<>();+ imageConfig.put("WorkingDirectory", null);+ update.put("ImageConfig", imageConfig);+ LambdaFunction fn = service.updateFunctionConfiguration(REGION, "fn-clear-wd", update);++ assertNull(fn.getImageConfigWorkingDirectory());+ }}// -------------------------------------------------------------------------@@ -259,6 +314,31 @@ class LambdaImageConfigTest {assertNull(spec.entrypoint());}+ @Test+ void usesImageConfigWorkingDirectoryForImageFunction() {+ LambdaFunction fn = imageFn("img-wd-fn");+ fn.setImageConfigWorkingDirectory("/app");++ launcher.launch(fn);++ ArgumentCaptor<ContainerSpec> specCaptor = ArgumentCaptor.forClass(ContainerSpec.class);+ verify(lifecycleManager).create(specCaptor.capture());++ assertEquals("/app", specCaptor.getValue().workingDir());+ }++ @Test+ void doesNotSetWorkingDirWhenNotConfigured() {+ LambdaFunction fn = imageFn("img-no-wd-fn");++ launcher.launch(fn);++ ArgumentCaptor<ContainerSpec> specCaptor = ArgumentCaptor.forClass(ContainerSpec.class);+ verify(lifecycleManager).create(specCaptor.capture());++ assertNull(specCaptor.getValue().workingDir(), "workingDir must be null when not configured");+ }+@Testvoid zipFunctionStillUsesHandlerAsCmd() throws Exception {LambdaFunction fn = new LambdaFunction();