Add E2E tests for Cosmos extension

test/E2ETests/E2EApps/E2EApp/Cosmos/CosmosFunction.cs

@@ -3,20 +3,30 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using System.Text.Json.Serialization;
+using System.Net;
+using System.Threading.Tasks;
+using Microsoft.Azure.Cosmos;
+using Microsoft.Azure.Functions.Worker.Http;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.Azure.Functions.Worker.E2EApp
 {
-    public static class CosmosFunction
+    public class CosmosFunction
     {
+        private readonly ILogger<CosmosFunction> _logger;
+
+        public CosmosFunction(ILogger<CosmosFunction> logger)
+        {
+            _logger = logger;
+        }
+
         [Function(nameof(CosmosTrigger))]
         [CosmosDBOutput(
             databaseName: "%CosmosDb%",
             containerName: "%CosmosCollOut%",
             Connection = "CosmosConnection",
             CreateIfNotExists = true)]
-        public static object CosmosTrigger([CosmosDBTrigger(
+        public object CosmosTrigger([CosmosDBTrigger(
             databaseName: "%CosmosDb%",
             containerName: "%CosmosCollIn%",
             Connection = "CosmosConnection",
@@ -36,15 +46,129 @@ public static object CosmosTrigger([CosmosDBTrigger(
             return null;
         }
 
+        [Function(nameof(DocsByUsingCosmosClient))]
+        public async Task<HttpResponseData>  DocsByUsingCosmosClient(
+            [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req,
+            [CosmosDBInput("", "", Connection = "CosmosConnection")] CosmosClient client)
+        {
+            var container = client.GetContainer("ItemDb", "ItemCollectionIn");
+            var iterator = container.GetItemQueryIterator<MyDocument>("SELECT * FROM c");
+
+            var output = "";
+
+            while (iterator.HasMoreResults)
+            {
+                var documents = await iterator.ReadNextAsync();
+                foreach (dynamic d in documents)
+                {
+                    output += $"{(string)d.Id}, ";
+                }
+            }
+
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            await response.WriteStringAsync(output);
+            return response;
+        }
+
+        [Function(nameof(DocsByUsingDatabaseClient))]
+        public async Task<HttpResponseData> DocsByUsingDatabaseClient(
+            [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req,
+            [CosmosDBInput("%CosmosDb%", "", Connection = "CosmosConnection")] Database database)
+        {
+            var container = database.GetContainer("ItemCollectionIn");;
+            var iterator = container.GetItemQueryIterator<MyDocument>("SELECT * FROM c");
+
+            var output = "";
+
+            while (iterator.HasMoreResults)
+            {
+                var documents = await iterator.ReadNextAsync();
+                foreach (dynamic d in documents)
+                {
+                    output += $"{(string)d.Id}, ";
+                }
+            }
+
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            await response.WriteStringAsync(output);
+            return response;
+        }
+
+        [Function(nameof(DocsByUsingContainerClient))]
+        public async Task<HttpResponseData>  DocsByUsingContainerClient(
+            [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req,
+            [CosmosDBInput("%CosmosDb%", "%CosmosCollIn%", Connection = "CosmosConnection")] Container container)
+        {
+            var iterator = container.GetItemQueryIterator<MyDocument>("SELECT * FROM c");
+
+            var output = "";
+
+            while (iterator.HasMoreResults)
+            {
+                var documents = await iterator.ReadNextAsync();
+                foreach (dynamic d in documents)
+                {
+                    output += $"{(string)d.Id}, ";
+                }
+            }
+
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            await response.WriteStringAsync(output);
+            return response;
+        }
+
+        [Function(nameof(DocByIdFromRouteData))]
+        public async Task<HttpResponseData> DocByIdFromRouteData(
+            [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "docsbyroute/{partitionKey}/{id}")] HttpRequestData req,
+            [CosmosDBInput(
+                databaseName: "%CosmosDb%",
+                containerName: "%CosmosCollIn%",
+                Connection = "CosmosConnection",
+                Id = "{id}",
+                PartitionKey = "{partitionKey}")] MyDocument doc)
+        {
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            await response.WriteStringAsync(doc.Text);
+            return response;
+        }
+
+        [Function(nameof(DocByIdFromRouteDataUsingSqlQuery))]
+        public async Task<HttpResponseData> DocByIdFromRouteDataUsingSqlQuery(
+            [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "docsbysql/{id}")] HttpRequestData req,
+            [CosmosDBInput(
+                databaseName: "%CosmosDb%",
+                containerName: "%CosmosCollIn%",
+                Connection = "CosmosConnection",
+                SqlQuery = "SELECT * FROM ItemCollectionIn t where t.Id = {id}")]
+                IEnumerable<MyDocument> myDocs)
+        {
+            var output = myDocs.FirstOrDefault().Text;
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            await response.WriteStringAsync(output);
+            return response;
+        }
+
+        [Function(nameof(DocByIdFromQueryStringUsingSqlQuery))]
+        public async Task<HttpResponseData> DocByIdFromQueryStringUsingSqlQuery(
+            [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req,
+            [CosmosDBInput(
+                databaseName: "%CosmosDb%",
+                containerName: "%CosmosCollIn%",
+                Connection = "CosmosConnection",
+                SqlQuery = "SELECT * FROM ItemCollectionIn t where t.Id = {id}")]
+                IEnumerable<MyDocument> myDocs)
+        {
+            var output = myDocs.FirstOrDefault().Text;
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            await response.WriteStringAsync(output);
+            return response;
+        }
+
         public class MyDocument
         {
             public string Id { get; set; }
 
             public string Text { get; set; }
-
-            public int Number { get; set; }
-
-            public bool Boolean { get; set; }
         }
     }
 }

test/E2ETests/E2EApps/E2EApp/E2EApp.csproj

@@ -3,12 +3,12 @@
     <TargetFramework>net6.0</TargetFramework>
     <AzureFunctionsVersion>v4</AzureFunctionsVersion>
   </PropertyGroup>
-    
+
   <PropertyGroup Condition="$(FunctionsRuntimeVersion) == '3'">
     <TargetFramework>net7.0</TargetFramework>
     <AzureFunctionsVersion>v4</AzureFunctionsVersion>
   </PropertyGroup>
-    
+
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <_FunctionsSkipCleanOutput>true</_FunctionsSkipCleanOutput>
@@ -46,7 +46,6 @@
     <PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="2.2.0" />
     <PackageReference Condition="$(TestBuild) == 'true'" Include="Microsoft.Azure.Functions.Worker" Version="1.12.1-preview1" />
     <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.11.0-preview1" />
-
     <PackageReference Condition="$(FunctionsRuntimeVersion) != '3'" Include="System.Text.Json" Version="6.0.5" />
     <PackageReference Condition="$(FunctionsRuntimeVersion) == '3'" Include="System.Text.Json" Version="5.0.2" />
   </ItemGroup>

test/E2ETests/E2ETests/Cosmos/CosmosDBEndToEndTests.cs

@@ -2,6 +2,8 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
 using System;
+using System.Net;
+using System.Net.Http;
 using System.Threading.Tasks;
 using Xunit;
 using Xunit.Abstractions;
@@ -40,6 +42,117 @@ public async Task CosmosDBTriggerAndOutput_Succeeds()
             }
         }
 
+        [Theory]
+        [InlineData("DocsByUsingCosmosClient")]
+        [InlineData("DocsByUsingDatabaseClient")]
+        [InlineData("DocsByUsingContainerClient")]
+        public async Task CosmosInput_ClientBinding_Succeeds(string functionName)
+        {
+            string expectedDocId = Guid.NewGuid().ToString();
+            try
+            {
+                //Setup
+                await CosmosDBHelpers.CreateDocument(expectedDocId);
+
+                //Trigger
+                HttpResponseMessage response = await HttpHelpers.InvokeHttpTrigger(functionName);
+                string actualMessage = await response.Content.ReadAsStringAsync();
+
+                //Verify
+                HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
+
+                Assert.Equal(expectedStatusCode, response.StatusCode);
+                Assert.Contains(expectedDocId, actualMessage);
+            }
+            finally
+            {
+                //Clean up
+                await CosmosDBHelpers.DeleteTestDocuments(expectedDocId);
+            }
+        }
+
+        [Fact]
+        public async Task CosmosInput_DocByIdFromRouteData_Succeeds()
+        {
+            string expectedDocId = Guid.NewGuid().ToString();
+            string functionPath = $"docsbyroute/{expectedDocId}/{expectedDocId}";
+            try
+            {
+                //Setup
+                await CosmosDBHelpers.CreateDocument(expectedDocId, "DocByIdFromRouteData");
+
+                //Trigger
+                HttpResponseMessage response = await HttpHelpers.InvokeHttpTrigger(functionPath);
+                string actualMessage = await response.Content.ReadAsStringAsync();
+
+                //Verify
+                HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
+
+                Assert.Equal(expectedStatusCode, response.StatusCode);
+                Assert.Contains("DocByIdFromRouteData", actualMessage);
+            }
+            finally
+            {
+                //Clean up
+                await CosmosDBHelpers.DeleteTestDocuments(expectedDocId);
+            }
+        }
+
+        [Fact]
+        public async Task CosmosInput_DocByIdFromRouteDataUsingSqlQuery_Succeeds()
+        {
+            string expectedDocId = Guid.NewGuid().ToString();
+            string functionPath = $"docsbysql/{expectedDocId}";
+            try
+            {
+                //Setup
+                await CosmosDBHelpers.CreateDocument(expectedDocId, "DocByIdFromRouteDataUsingSqlQuery");
+
+                //Trigger
+                HttpResponseMessage response = await HttpHelpers.InvokeHttpTrigger(functionPath);
+                string actualMessage = await response.Content.ReadAsStringAsync();
+
+                //Verify
+                HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
+
+                Assert.Equal(expectedStatusCode, response.StatusCode);
+                Assert.Contains("DocByIdFromRouteDataUsingSqlQuery", actualMessage);
+            }
+            finally
+            {
+                //Clean up
+                await CosmosDBHelpers.DeleteTestDocuments(expectedDocId);
+            }
+        }
+
+        [Fact]
+        public async Task CosmosInput_DocByIdFromQueryStringUsingSqlQuery_Succeeds()
+        {
+            string expectedDocId = Guid.NewGuid().ToString();
+            string functionName = "DocByIdFromQueryStringUsingSqlQuery";
+            string requestBody = @$"{{ ""id"": ""{expectedDocId}"" }}";
+            try
+            {
+                //Setup
+                await CosmosDBHelpers.CreateDocument(expectedDocId, functionName);
+
+                //Trigger
+                HttpResponseMessage response = await HttpHelpers.InvokeHttpTriggerWithBody(functionName, requestBody, "application/json");
+                string actualMessage = await response.Content.ReadAsStringAsync();
+
+                //Verify
+                HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
+
+                Assert.Equal(expectedStatusCode, response.StatusCode);
+                Assert.Contains(functionName, actualMessage);
+            }
+            finally
+            {
+                //Clean up
+                await CosmosDBHelpers.DeleteTestDocuments(expectedDocId);
+            }
+        }
+
         public void Dispose()
         {
             _disposeLog?.Dispose();

test/E2ETests/E2ETests/E2ETests.csproj

@@ -8,6 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Azure.Data.Tables" Version="12.8.0" />
     <PackageReference Include="Azure.Storage.Blobs" Version="12.13.1" />
     <PackageReference Include="Azure.Storage.Queues" Version="12.12.0" />
     <PackageReference Include="Microsoft.Azure.DocumentDB.Core" Version="2.13.1" />
@@ -19,7 +20,6 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Azure.Data.Tables" Version="12.8.0" />
   </ItemGroup>
 
   <ItemGroup>

test/E2ETests/E2ETests/Helpers/CosmosDBHelpers.cs

@@ -28,12 +28,10 @@ static CosmosDBHelpers()
         }
 
         // keep
-        public async static Task CreateDocument(string docId)
+        public async static Task CreateDocument(string docId, string docText = "test")
         {
-            Document documentToTest = new Document()
-            {
-                Id = docId
-            };
+            Document documentToTest = new Document() { Id = docId };
+            documentToTest.SetPropertyValue("Text", docText);
 
             _ = await _docDbClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName), documentToTest);
         }
@@ -63,16 +61,16 @@ await TestUtility.RetryAsync(async () =>
         public async static Task DeleteTestDocuments(string docId)
         {
             var inputDocUri = UriFactory.CreateDocumentUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName, docId);
-            await DeleteDocument(inputDocUri);
+            await DeleteDocument(inputDocUri, docId);
             var outputDocUri = UriFactory.CreateDocumentUri(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, docId);
-            await DeleteDocument(outputDocUri);
+            await DeleteDocument(outputDocUri, docId);
         }
 
-        private async static Task DeleteDocument(Uri docUri)
+        private async static Task DeleteDocument(Uri docUri, string docId)
         {
             try
             {
-                await _docDbClient.DeleteDocumentAsync(docUri);
+                await _docDbClient.DeleteDocumentAsync(docUri, new RequestOptions { PartitionKey = new PartitionKey(docId) });
             }
             catch (Exception)
             {

test/E2ETests/E2ETests/Helpers/HttpHelpers.cs

@@ -19,7 +19,7 @@ public static async Task<HttpResponseMessage> InvokeHttpTrigger(string functionN
             return await GetResponseMessage(request);
         }
 
-        public static async Task<HttpResponseMessage> InvokeHttpTriggerWithBody(string functionName, string body, HttpStatusCode expectedStatusCode, string mediaType, int expectedCode = 0)
+        public static async Task<HttpResponseMessage> InvokeHttpTriggerWithBody(string functionName, string body, string mediaType)
         {
             HttpRequestMessage request = GetTestRequest(functionName);
             request.Content = new StringContent(body);