public async Task TestServerlessPackage() { var logger = new TestToolLogger(); var assembly = this.GetType().GetTypeInfo().Assembly; var fullPath = Path.GetFullPath(Path.GetDirectoryName(assembly.Location) + "../../../../../../testapps/TestServerlessWebApp"); var command = new PackageCICommand(logger, fullPath, new string[0]); command.Region = "us-west-2"; command.Configuration = "Release"; command.TargetFramework = "netcoreapp2.1"; command.CloudFormationTemplate = "serverless.template"; command.CloudFormationOutputTemplate = Path.Combine(Path.GetTempPath(), "output-serverless.template"); command.S3Bucket = "serverless-package-test-" + DateTime.Now.Ticks; command.DisableInteractive = true; if (File.Exists(command.CloudFormationOutputTemplate)) { File.Delete(command.CloudFormationOutputTemplate); } await command.S3Client.PutBucketAsync(command.S3Bucket); try { Assert.True(await command.ExecuteAsync()); Assert.True(File.Exists(command.CloudFormationOutputTemplate)); } finally { await AmazonS3Util.DeleteS3BucketWithObjectsAsync(command.S3Client, command.S3Bucket); } }
public void NETCore_2_1_AllWithTooNewVersionNumber() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest-v2.1.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/NETCore_2_1_AllWithTooNewVersionNumber.xml"); try { LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.1", manifest, projectFile); Assert.True(true, "Missing LambdaToolsException thrown"); } catch (LambdaToolsException e) { Assert.Contains("which is newer than", e.Message); } projectFile = projectFile.Replace("Microsoft.AspNetCore.All", "Microsoft.AspNetCore.App"); try { LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.1", manifest, projectFile); Assert.True(true, "Missing LambdaToolsException thrown"); } catch (LambdaToolsException e) { Assert.Contains("which is newer than", e.Message); } }
public async Task FunctionImmediateAvailable() { var functionName = "fakeFunction"; var mockLambda = new Mock <IAmazonLambda>(); mockLambda.Setup(client => client.GetFunctionConfigurationAsync(It.IsAny <GetFunctionConfigurationRequest>(), It.IsAny <CancellationToken>())) .Callback <GetFunctionConfigurationRequest, CancellationToken>((request, token) => { Assert.Equal(functionName, request.FunctionName); }) .Returns((GetFunctionConfigurationRequest r, CancellationToken token) => { return(Task.FromResult(new GetFunctionConfigurationResponse { State = State.Active, LastUpdateStatus = LastUpdateStatus.Successful })); }); var logger = new TestToolLogger(); await LambdaUtilities.WaitTillFunctionAvailableAsync(logger, mockLambda.Object, functionName); Assert.Equal(0, logger.Buffer.Length); }
public void NewerAspNetCoreReference() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/NewerAspNetCoreReference.xml"); Assert.Throws <LambdaToolsException>(() => Utilities.ValidateMicrosoftAspNetCoreAllReferenceWithManifest(logger, manifest, projectFile)); }
public void FindProjFiles(string projectDirectory) { var logger = new TestToolLogger(); string manifest = LambdaUtilities.LoadPackageStoreManifest(logger, "netcoreapp2.0"); LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectPath(logger, "netcoreapp2.0", manifest, projectDirectory); Assert.DoesNotContain("error", logger.Buffer.ToLower()); }
public void NotUsingAspNetCore() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/CurrentAspNetCoreReference.xml"); Utilities.ValidateMicrosoftAspNetCoreAllReferenceWithManifest(logger, manifest, projectFile); Assert.DoesNotContain("error", logger.Buffer.ToLower()); }
public void NETCore_2_0_NotUsingAspNetCore() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/CurrentAspNetCoreReference.xml"); LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.0", manifest, projectFile); Assert.DoesNotContain("error", logger.Buffer.ToLower()); }
public void NETCore_2_1_AllWithSupportedVersionNumber() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest-v2.1.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/NETCore_2_1_AllWithSupportedVersionNumber.xml"); LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.1", manifest, projectFile); projectFile = projectFile.Replace("Microsoft.AspNetCore.All", "Microsoft.AspNetCore.App"); LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.1", manifest, projectFile); }
public async Task TestServerlessPackage() { var logger = new TestToolLogger(); var assembly = this.GetType().GetTypeInfo().Assembly; var fullPath = Path.GetFullPath(Path.GetDirectoryName(assembly.Location) + "../../../../../../testapps/TestServerlessWebApp"); var command = new PackageCICommand(logger, fullPath, new string[0]); command.Region = "us-west-2"; command.Configuration = "Release"; command.CloudFormationTemplate = "serverless-arm.template"; command.CloudFormationOutputTemplate = Path.Combine(Path.GetTempPath(), "output-serverless-arm.template"); command.S3Bucket = "serverless-package-test-" + DateTime.Now.Ticks; command.DisableInteractive = true; if (File.Exists(command.CloudFormationOutputTemplate)) { File.Delete(command.CloudFormationOutputTemplate); } await command.S3Client.PutBucketAsync(command.S3Bucket); try { Assert.True(await command.ExecuteAsync()); Assert.True(File.Exists(command.CloudFormationOutputTemplate)); var templateJson = File.ReadAllText(command.CloudFormationOutputTemplate); var templateRoot = JsonConvert.DeserializeObject(templateJson) as JObject; var codeUri = templateRoot["Resources"]["DefaultFunction"]["Properties"]["CodeUri"].ToString(); Assert.False(string.IsNullOrEmpty(codeUri)); var s3Key = codeUri.Split('/').Last(); var transfer = new TransferUtility(command.S3Client); var functionZipPath = Path.GetTempFileName(); await transfer.DownloadAsync(functionZipPath, command.S3Bucket, s3Key); Assert.Equal("linux-arm64", GetRuntimeFromBundle(functionZipPath)); File.Delete(functionZipPath); } finally { await AmazonS3Util.DeleteS3BucketWithObjectsAsync(command.S3Client, command.S3Bucket); } }
public void NETCore_2_0_NewerAspNetCoreReference() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/NewerAspNetCoreReference.xml"); try { LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.0", manifest, projectFile); Assert.True(true, "Missing LambdaToolsException thrown"); } catch (LambdaToolsException e) { Assert.Contains("which is newer", e.Message); } }
public async Task CreateLayer() { var logger = new TestToolLogger(_testOutputHelper); var command = new PublishLayerCommand(logger, _singleLayerFunctionPath, new string[0]); command.Region = "us-east-1"; command.TargetFramework = "netcoreapp2.1"; command.S3Bucket = this._testFixture.Bucket; command.DisableInteractive = true; command.LayerName = "DotnetTest-CreateLayer"; command.LayerType = LambdaConstants.LAYER_TYPE_RUNTIME_PACKAGE_STORE; command.PackageManifest = _singleLayerFunctionPath; try { Assert.True(await command.ExecuteAsync()); Assert.NotNull(command.NewLayerVersionArn); var getResponse = await this._testFixture.LambdaClient.GetLayerVersionAsync(new GetLayerVersionRequest { LayerName = command.NewLayerArn, VersionNumber = command.NewLayerVersionNumber }); Assert.NotNull(getResponse.Description); var data = JsonMapper.ToObject <LayerDescriptionManifest>(getResponse.Description); Assert.Equal(LayerDescriptionManifest.ManifestType.RuntimePackageStore, data.Nlt); Assert.NotNull(data.Dir); Assert.Equal(this._testFixture.Bucket, data.Buc); Assert.NotNull(data.Key); using (var getManifestResponse = await this._testFixture.S3Client.GetObjectAsync(data.Buc, data.Key)) using (var reader = new StreamReader(getManifestResponse.ResponseStream)) { var xml = await reader.ReadToEndAsync(); Assert.Contains("AWSSDK.S3", xml); Assert.Contains("Amazon.Lambda.Core", xml); } } finally { await this._testFixture.LambdaClient.DeleteLayerVersionAsync(new DeleteLayerVersionRequest { LayerName = command.NewLayerArn, VersionNumber = command.NewLayerVersionNumber }); } }
public void SingleAppendEnv() { var logger = new TestToolLogger(); var assembly = this.GetType().GetTypeInfo().Assembly; var fullPath = Path.GetFullPath(Path.GetDirectoryName(assembly.Location) + "../../../../../../testapps/TestServerlessWebApp"); var command = new UpdateFunctionConfigCommand(logger, fullPath, new string[0]); command.EnvironmentVariables = null; command.AppendEnvironmentVariables = new Dictionary <string, string> { { "foo", "bar" } }; var combinedEnv = command.GetEnvironmentVariables(null); Assert.Single(combinedEnv); Assert.Equal("bar", combinedEnv["foo"]); }
public async Task UseNewtonsoft10() { var fullPath = GetTestProjectPath("UseNewtonsoft10"); var logger = new TestToolLogger(); var command = new PackageCommand(logger, fullPath, new string[0]); command.DisableInteractive = true; command.Configuration = "Release"; command.TargetFramework = "netcoreapp1.0"; command.OutputPackageFileName = Path.GetTempFileName() + ".zip"; var created = await command.ExecuteAsync(); Assert.False(created); Assert.True(logger.Buffer.ToLower().Contains("error: netstandard.library 1.6.1 is used for target framework netcoreapp1.1")); Assert.True(logger.Buffer.ToLower().Contains("error: newtonsoft.json : 10.0.2")); }
public async Task Use11ASPNetCoreDependencies() { var fullPath = GetTestProjectPath("Use11ASPNetCoreDependencies"); var logger = new TestToolLogger(); var command = new PackageCommand(logger, fullPath, new string[0]); command.DisableInteractive = true; command.Configuration = "Release"; command.TargetFramework = "netcoreapp1.0"; command.OutputPackageFileName = Path.GetTempFileName() + ".zip"; var created = await command.ExecuteAsync(); Assert.False(created); Assert.True(logger.Buffer.ToLower().Contains("error: netstandard.library 1.6.1 is used for target framework netcoreapp1.1")); Assert.True(logger.Buffer.ToLower().Contains("error: microsoft.aspnetcore.diagnostics : 1.1.1")); Assert.True(logger.Buffer.ToLower().Contains("error: microsoft.extensions.fileproviders.embedded : 1.1.0")); }
public async Task UpdateFunctionGoesToFailure() { var functionName = "fakeFunction"; var mockLambda = new Mock <IAmazonLambda>(); var getConfigCallCount = 0; mockLambda.Setup(client => client.GetFunctionConfigurationAsync(It.IsAny <GetFunctionConfigurationRequest>(), It.IsAny <CancellationToken>())) .Callback <GetFunctionConfigurationRequest, CancellationToken>((request, token) => { Assert.Equal(functionName, request.FunctionName); }) .Returns((GetFunctionConfigurationRequest r, CancellationToken token) => { getConfigCallCount++; if (getConfigCallCount < 3) { return(Task.FromResult(new GetFunctionConfigurationResponse { State = State.Active, LastUpdateStatus = LastUpdateStatus.InProgress })); } return(Task.FromResult(new GetFunctionConfigurationResponse { State = State.Active, LastUpdateStatus = LastUpdateStatus.Failed, LastUpdateStatusReason = "Its Bad" })); }); var logger = new TestToolLogger(); await LambdaUtilities.WaitTillFunctionAvailableAsync(logger, mockLambda.Object, functionName); Assert.Contains("An update is currently", logger.Buffer); Assert.Contains("... Waiting", logger.Buffer); Assert.Contains("Warning: function", logger.Buffer); Assert.Contains("Its Bad", logger.Buffer); }
public async Task TestDeployLargeServerless() { var logger = new TestToolLogger(); var assembly = this.GetType().GetTypeInfo().Assembly; var fullPath = Path.GetFullPath(Path.GetDirectoryName(assembly.Location) + "../../../../../../testapps/TestServerlessWebApp"); var command = new DeployServerlessCommand(logger, fullPath, new string[0]); command.Region = "us-east-1"; command.Configuration = "Release"; command.TargetFramework = "netcoreapp2.1"; command.CloudFormationTemplate = "large-serverless.template"; command.StackName = "TestDeployLargeServerless-" + DateTime.Now.Ticks; command.S3Bucket = this._testFixture.Bucket; command.WaitForStackToComplete = true; command.ProjectLocation = fullPath; command.DisableInteractive = true; var created = await command.ExecuteAsync(); try { Assert.True(created); } finally { if (created) { var deleteCommand = new DeleteServerlessCommand(new TestToolLogger(_testOutputHelper), fullPath, new string[0]); deleteCommand.StackName = command.StackName; deleteCommand.Region = command.Region; deleteCommand.DisableInteractive = true; await deleteCommand.ExecuteAsync(); } } }
private async Task <PublishLayerCommand> PublishLayerAsync(string projectDirectory, string optDirectory) { var logger = new TestToolLogger(_testOutputHelper); var publishLayerCommand = new PublishLayerCommand(logger, projectDirectory, new string[0]); publishLayerCommand.Region = "us-east-1"; publishLayerCommand.TargetFramework = "netcoreapp2.1"; publishLayerCommand.S3Bucket = this._testFixture.Bucket; publishLayerCommand.DisableInteractive = true; publishLayerCommand.LayerName = "Dotnet-IntegTest-"; publishLayerCommand.LayerType = LambdaConstants.LAYER_TYPE_RUNTIME_PACKAGE_STORE; publishLayerCommand.OptDirectory = optDirectory; // publishLayerCommand.PackageManifest = _singleLayerFunctionPath; if (!(await publishLayerCommand.ExecuteAsync())) { throw publishLayerCommand.LastToolsException; } return(publishLayerCommand); }
public void CombinedEnvAndAppendEnvIgnoreExisting() { var logger = new TestToolLogger(); var assembly = this.GetType().GetTypeInfo().Assembly; var fullPath = Path.GetFullPath(Path.GetDirectoryName(assembly.Location) + "../../../../../../testapps/TestServerlessWebApp"); var command = new UpdateFunctionConfigCommand(logger, fullPath, new string[0]); command.EnvironmentVariables = new Dictionary <string, string> { { "service", "s3" } }; command.AppendEnvironmentVariables = new Dictionary <string, string> { { "foo", "bar" } }; var combinedEnv = command.GetEnvironmentVariables(new Dictionary <string, string> { { "service", "lambda" } }); Assert.Equal(2, combinedEnv.Count); Assert.Equal("bar", combinedEnv["foo"]); Assert.Equal("s3", combinedEnv["service"]); }
public async Task DeployServerlessWithlayer() { var logger = new TestToolLogger(_testOutputHelper); var templateTilePath = Path.Combine(_serverlessLayerFunctionPath, "serverless.template"); if (File.Exists(templateTilePath)) { File.Delete(templateTilePath); } var publishLayerCommand = await PublishLayerAsync(_serverlessLayerFunctionPath, ""); try { var templateContent = File.ReadAllText(Path.Combine(_serverlessLayerFunctionPath, "fake.template")); templateContent = templateContent.Replace("LAYER_ARN_PLACEHOLDER", publishLayerCommand.NewLayerVersionArn); File.WriteAllText(templateTilePath, templateContent); var command = new DeployServerlessCommand(new TestToolLogger(_testOutputHelper), _serverlessLayerFunctionPath, new string[] { }); command.DisableInteractive = true; command.StackName = "DeployServerlessWithlayer-" + DateTime.Now.Ticks; command.Region = publishLayerCommand.Region; command.S3Bucket = this._testFixture.Bucket; command.WaitForStackToComplete = true; command.DisableInteractive = true; command.ProjectLocation = _serverlessLayerFunctionPath; var created = await command.ExecuteAsync(); try { Assert.True(created); Func <string, Task> testFunctionAsync = async(functionName) => { var lambdaFunctionName = await TestHelper.GetPhysicalCloudFormationResourceId(_testFixture.CFClient, command.StackName, functionName); await ValidateInvokeAsync(lambdaFunctionName, "\"hello\"", "\"HELLO\""); var getConfigResponse = await this._testFixture.LambdaClient.GetFunctionConfigurationAsync(new GetFunctionConfigurationRequest { FunctionName = lambdaFunctionName }); Assert.NotNull(getConfigResponse.Layers.FirstOrDefault(x => string.Equals(x.Arn, publishLayerCommand.NewLayerVersionArn))); var getCodeResponse = await this._testFixture.LambdaClient.GetFunctionAsync(lambdaFunctionName); using (var client = new HttpClient()) { var data = await client.GetByteArrayAsync(getCodeResponse.Code.Location); var zipArchive = new ZipArchive(new MemoryStream(data), ZipArchiveMode.Read); Assert.NotNull(zipArchive.GetEntry("TestLayerServerless.dll")); Assert.Null(zipArchive.GetEntry("Amazon.Lambda.Core.dll")); } }; await testFunctionAsync("TheFunction"); await testFunctionAsync("TheSecondFunctionSameSource"); } finally { if (created) { var deleteCommand = new DeleteServerlessCommand(new TestToolLogger(_testOutputHelper), _serverlessLayerFunctionPath, new string[0]); deleteCommand.DisableInteractive = true; deleteCommand.Region = publishLayerCommand.Region; deleteCommand.StackName = command.StackName; await deleteCommand.ExecuteAsync(); } } } finally { await this._testFixture.LambdaClient.DeleteLayerVersionAsync(new DeleteLayerVersionRequest { LayerName = publishLayerCommand.NewLayerArn, VersionNumber = publishLayerCommand.NewLayerVersionNumber }); if (File.Exists(templateTilePath)) { File.Delete(templateTilePath); } } }
public async Task DeployStepFunctionWithTemplateSubstitution() { var cfClient = new AmazonCloudFormationClient(RegionEndpoint.USEast2); var s3Client = new AmazonS3Client(RegionEndpoint.USEast2); var bucketName = "deploy-step-functions-" + DateTime.Now.Ticks; await s3Client.PutBucketAsync(bucketName); try { var logger = new TestToolLogger(); var assembly = this.GetType().GetTypeInfo().Assembly; var fullPath = Path.GetFullPath(Path.GetDirectoryName(assembly.Location) + "../../../../../../testapps/TemplateSubstitutionTestProjects/StateMachineDefinitionStringTest"); var command = new DeployServerlessCommand(logger, fullPath, new string[0]); command.DisableInteractive = true; command.Configuration = "Release"; command.TargetFramework = "netcoreapp1.0"; command.StackName = "DeployStepFunctionWithTemplateSubstitution-" + DateTime.Now.Ticks; command.S3Bucket = bucketName; command.WaitForStackToComplete = true; command.TemplateParameters = new Dictionary <string, string> { { "NonExisting", "Parameter" }, { "StubParameter", "SecretFoo" } }; var created = await command.ExecuteAsync(); try { Assert.True(created); var describeResponse = await cfClient.DescribeStacksAsync(new DescribeStacksRequest { StackName = command.StackName }); Assert.Equal(StackStatus.CREATE_COMPLETE, describeResponse.Stacks[0].StackStatus); Assert.DoesNotContain("SecretFoo", logger.Buffer.ToString()); Assert.Contains("****", logger.Buffer.ToString()); } finally { if (created) { try { var deleteCommand = new DeleteServerlessCommand(new TestToolLogger(_testOutputHelper), fullPath, new string[0]); deleteCommand.StackName = command.StackName; await deleteCommand.ExecuteAsync(); } catch { // Bury exception because we don't want to lose any exceptions during the deploy stage. } } } } finally { await AmazonS3Util.DeleteS3BucketWithObjectsAsync(s3Client, bucketName); } }
public async Task DeployAspNetCoreWithlayer() { var logger = new TestToolLogger(_testOutputHelper); var templateTilePath = Path.Combine(_aspnercoreLayerFunctionPath, "serverless.template"); if (File.Exists(templateTilePath)) { File.Delete(templateTilePath); } var publishLayerCommand = await PublishLayerAsync(_aspnercoreLayerFunctionPath, ""); try { var getLayerResponse = await this._testFixture.LambdaClient.GetLayerVersionAsync(new GetLayerVersionRequest { LayerName = publishLayerCommand.NewLayerArn, VersionNumber = publishLayerCommand.NewLayerVersionNumber }); Assert.NotNull(getLayerResponse.Description); // Make sure layer does not contain any core ASP.NET Core dependencies. var layerManifest = JsonMapper.ToObject <LayerDescriptionManifest>(getLayerResponse.Description); using (var getManifestResponse = await this._testFixture.S3Client.GetObjectAsync(layerManifest.Buc, layerManifest.Key)) using (var reader = new StreamReader(getManifestResponse.ResponseStream)) { var xml = await reader.ReadToEndAsync(); Assert.False(xml.Contains("Microsoft.AspNetCore")); Assert.False(xml.Contains("runtime")); } var templateContent = File.ReadAllText(Path.Combine(_aspnercoreLayerFunctionPath, "fake.template")); templateContent = templateContent.Replace("LAYER_ARN_PLACEHOLDER", publishLayerCommand.NewLayerVersionArn); File.WriteAllText(templateTilePath, templateContent); var command = new DeployServerlessCommand(new TestToolLogger(_testOutputHelper), _aspnercoreLayerFunctionPath, new string[] { }); command.DisableInteractive = true; command.StackName = "DeployAspNetCoreWithlayer-" + DateTime.Now.Ticks; command.Region = publishLayerCommand.Region; command.S3Bucket = this._testFixture.Bucket; command.WaitForStackToComplete = true; command.DisableInteractive = true; command.ProjectLocation = _aspnercoreLayerFunctionPath; var created = await command.ExecuteAsync(); try { Assert.True(created); var lambdaFunctionName = await TestHelper.GetPhysicalCloudFormationResourceId(_testFixture.CFClient, command.StackName, "AspNetCoreFunction"); var apiUrl = await TestHelper.GetOutputParameter(_testFixture.CFClient, command.StackName, "ApiURL"); using (var client = new HttpClient()) { await client.GetStringAsync(new Uri(new Uri(apiUrl), "api/values")); } var getConfigResponse = await this._testFixture.LambdaClient.GetFunctionConfigurationAsync(new GetFunctionConfigurationRequest { FunctionName = lambdaFunctionName }); Assert.NotNull(getConfigResponse.Layers.FirstOrDefault(x => string.Equals(x.Arn, publishLayerCommand.NewLayerVersionArn))); var getCodeResponse = await this._testFixture.LambdaClient.GetFunctionAsync(lambdaFunctionName); using (var client = new HttpClient()) { var data = await client.GetByteArrayAsync(getCodeResponse.Code.Location); var zipArchive = new ZipArchive(new MemoryStream(data), ZipArchiveMode.Read); Assert.NotNull(zipArchive.GetEntry("TestLayerAspNetCore.dll")); Assert.Null(zipArchive.GetEntry("Amazon.Lambda.Core.dll")); Assert.Null(zipArchive.GetEntry("AWSSDK.S3.dll")); Assert.Null(zipArchive.GetEntry("AWSSDK.Extensions.NETCore.Setup.dll")); Assert.Null(zipArchive.GetEntry("Amazon.Lambda.AspNetCoreServer.dll")); } } finally { if (created) { var deleteCommand = new DeleteServerlessCommand(new TestToolLogger(_testOutputHelper), _aspnercoreLayerFunctionPath, new string[0]); deleteCommand.DisableInteractive = true; deleteCommand.Region = publishLayerCommand.Region; deleteCommand.StackName = command.StackName; await deleteCommand.ExecuteAsync(); } } } finally { await this._testFixture.LambdaClient.DeleteLayerVersionAsync(new DeleteLayerVersionRequest { LayerName = publishLayerCommand.NewLayerArn, VersionNumber = publishLayerCommand.NewLayerVersionNumber }); if (File.Exists(templateTilePath)) { File.Delete(templateTilePath); } } }
public async Task DeployFunctionWithLayer(string optDirectory) { var logger = new TestToolLogger(_testOutputHelper); var publishLayerCommand = await PublishLayerAsync(_singleLayerFunctionPath, optDirectory); try { Assert.NotNull(publishLayerCommand.NewLayerVersionArn); var deployCommand = new DeployFunctionCommand(new TestToolLogger(_testOutputHelper), _singleLayerFunctionPath, new string[0]); deployCommand.FunctionName = "test-layer-function-" + DateTime.Now.Ticks; deployCommand.Region = publishLayerCommand.Region; deployCommand.Handler = "TestLayerExample::TestLayerExample.Function::FunctionHandler"; deployCommand.Timeout = 10; deployCommand.MemorySize = 512; deployCommand.Role = await TestHelper.GetTestRoleArnAsync(); deployCommand.Configuration = "Release"; deployCommand.TargetFramework = "netcoreapp2.1"; deployCommand.Runtime = "dotnetcore2.1"; deployCommand.LayerVersionArns = new string[] { publishLayerCommand.NewLayerVersionArn }; deployCommand.DisableInteractive = true; var created = await deployCommand.ExecuteAsync(); try { // See if we got back the return which proves we were able to load an assembly from the S3 NuGet package // return new Amazon.S3.Model.ListBucketsRequest().ToString(); await ValidateInvokeAsync(deployCommand.FunctionName, "\"TEST\"", "\"Amazon.S3.Model.ListBucketsRequest\""); var getConfigResponse = await this._testFixture.LambdaClient.GetFunctionConfigurationAsync(new GetFunctionConfigurationRequest { FunctionName = deployCommand.FunctionName }); Assert.NotNull(getConfigResponse.Layers.FirstOrDefault(x => string.Equals(x.Arn, publishLayerCommand.NewLayerVersionArn))); var dotnetSharedSource = getConfigResponse.Environment.Variables[LambdaConstants.ENV_DOTNET_SHARED_STORE]; if (!string.IsNullOrEmpty(optDirectory)) { Assert.Equal($"/opt/{optDirectory}/", dotnetSharedSource); } else { Assert.Equal($"/opt/{LambdaConstants.DEFAULT_LAYER_OPT_DIRECTORY}/", dotnetSharedSource); } var getCodeResponse = await this._testFixture.LambdaClient.GetFunctionAsync(deployCommand.FunctionName); using (var client = new HttpClient()) { var data = await client.GetByteArrayAsync(getCodeResponse.Code.Location); var zipArchive = new ZipArchive(new MemoryStream(data), ZipArchiveMode.Read); Assert.NotNull(zipArchive.GetEntry("TestLayerExample.dll")); Assert.Null(zipArchive.GetEntry("Amazon.Lambda.Core.dll")); Assert.Null(zipArchive.GetEntry("AWSSDK.S3.dll")); } var redeployLayerCommand = await PublishLayerAsync(_singleLayerFunctionPath, optDirectory); var redeployFunctionCommand = new DeployFunctionCommand(new TestToolLogger(_testOutputHelper), _singleLayerFunctionPath, new string[0]); redeployFunctionCommand.FunctionName = deployCommand.FunctionName; redeployFunctionCommand.Region = deployCommand.Region; redeployFunctionCommand.Handler = deployCommand.Handler; redeployFunctionCommand.Timeout = deployCommand.Timeout; redeployFunctionCommand.MemorySize = deployCommand.MemorySize; redeployFunctionCommand.Role = deployCommand.Role; redeployFunctionCommand.Configuration = deployCommand.Configuration; redeployFunctionCommand.TargetFramework = deployCommand.TargetFramework; redeployFunctionCommand.Runtime = deployCommand.Runtime; redeployFunctionCommand.LayerVersionArns = new string[] { redeployLayerCommand.NewLayerVersionArn }; redeployFunctionCommand.DisableInteractive = true; if (!await redeployFunctionCommand.ExecuteAsync()) { throw redeployFunctionCommand.LastToolsException; } await ValidateInvokeAsync(redeployFunctionCommand.FunctionName, "\"TEST\"", "\"Amazon.S3.Model.ListBucketsRequest\""); } finally { await this._testFixture.LambdaClient.DeleteFunctionAsync(new DeleteFunctionRequest { FunctionName = deployCommand.FunctionName }); } } finally { await this._testFixture.LambdaClient.DeleteLayerVersionAsync(new DeleteLayerVersionRequest { LayerName = publishLayerCommand.NewLayerArn, VersionNumber = publishLayerCommand.NewLayerVersionNumber }); } }
// This test behaves different depending on the OS the test is running on which means // all code paths are not always being tested. Future work is needed to figure out how to // mock the underlying calls to the dotnet CLI. public async Task AttemptToCreateAnOptmizedLayer() { var logger = new TestToolLogger(_testOutputHelper); var assembly = this.GetType().GetTypeInfo().Assembly; var fullPath = Path.GetFullPath(Path.GetDirectoryName(assembly.Location) + "../../../../../../testapps/TestLayerExample"); var command = new PublishLayerCommand(logger, fullPath, new string[] { "--enable-package-optimization", "true" }); command.Region = "us-east-1"; command.TargetFramework = "netcoreapp2.1"; command.S3Bucket = this._testFixture.Bucket; command.DisableInteractive = true; command.LayerName = "DotnetTest-AttemptToCreateAnOptmizedLayer"; command.LayerType = LambdaConstants.LAYER_TYPE_RUNTIME_PACKAGE_STORE; command.PackageManifest = fullPath; bool success = false; try { success = await command.ExecuteAsync(); if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Assert.False(success); Assert.Equal(LambdaToolsException.LambdaErrorCode.UnsupportedOptimizationPlatform.ToString(), command.LastToolsException.Code); } else { Assert.True(success); Assert.NotNull(command.NewLayerVersionArn); var getResponse = await this._testFixture.LambdaClient.GetLayerVersionAsync(new GetLayerVersionRequest { LayerName = command.NewLayerArn, VersionNumber = command.NewLayerVersionNumber }); Assert.NotNull(getResponse.Description); var data = JsonMapper.ToObject <LayerDescriptionManifest>(getResponse.Description); Assert.Equal(LayerDescriptionManifest.ManifestType.RuntimePackageStore, data.Nlt); Assert.NotNull(data.Dir); Assert.Equal(this._testFixture.Bucket, data.Buc); Assert.NotNull(data.Key); using (var getManifestResponse = await this._testFixture.S3Client.GetObjectAsync(data.Buc, data.Key)) using (var reader = new StreamReader(getManifestResponse.ResponseStream)) { var xml = await reader.ReadToEndAsync(); Assert.Contains("AWSSDK.S3", xml); Assert.Contains("Amazon.Lambda.Core", xml); } } } finally { if (success) { await this._testFixture.LambdaClient.DeleteLayerVersionAsync(new DeleteLayerVersionRequest { LayerName = command.NewLayerArn, VersionNumber = command.NewLayerVersionNumber }); } } }