Replace deprecated packages in E2E (#1020)

andystaples · web-flow · commit 4f61c2543361 · 2023-10-18T13:31:34.000-07:00
* Replace Microsoft.Azure.EventHubs with latest stable Azure.Messaging.EventHubs
* Replace Microsoft.Azure.DocumentDB.Core with latest stable Microsoft.Azure.Cosmos
diff --git a/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E.csproj b/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E.csproj
@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Azure.DocumentDB.Core" Version="2.18.0" />
-    <PackageReference Include="Microsoft.Azure.EventHubs" Version="4.3.2" />
+    <PackageReference Include="Azure.Messaging.EventHubs" Version="5.9.3" />
+    <PackageReference Include="Microsoft.Azure.Cosmos" Version="3.35.4" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="7.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
diff --git a/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Constants.cs b/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Constants.cs
@@ -23,8 +23,8 @@ public static class Queue {
         public static class CosmosDB {
             public static string CosmosDBConnectionStringSetting = Environment.GetEnvironmentVariable("AzureWebJobsCosmosDBConnectionString");
             public static string DbName = "ItemDb";
-            public static string InputCollectionName = "ItemCollectionIn";
-            public static string OutputCollectionName = "ItemCollectionOut";
+            public static string InputCollectionName = "PartitionedItemCollectionIn";
+            public static string OutputCollectionName = "PartitionedItemCollectionOut";
             public static string LeaseCollectionName = "leases";
         }
 
diff --git a/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Helpers/CosmosDBHelpers.cs b/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Helpers/CosmosDBHelpers.cs
@@ -3,82 +3,76 @@
 
 using System;
 using System.Threading.Tasks;
-using Microsoft.Azure.Documents;
-using Microsoft.Azure.Documents.Client;
+using Microsoft.Azure.Cosmos;
 
 namespace Azure.Functions.PowerShell.Tests.E2E
 {
-    public class TestDocument
-    {
-        public string id { get; set; }
-        public string name { get; set; }
-    }
 
     public static class CosmosDBHelpers
     {
-        private static DocumentClient _docDbClient;
-        private static Uri inputCollectionsUri = UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName);
-        private static Uri outputCollectionsUri = UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName);
-        private static Uri leasesCollectionsUri = UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.LeaseCollectionName);
+        private static CosmosClient _cosmosDbClient;
+
+        private class Document
+        {
+            // lower-case because Cosmos expects a field with this name
+            public string id { get; set; }
+        }
 
         static CosmosDBHelpers()
         {
             var builder = new System.Data.Common.DbConnectionStringBuilder();
             builder.ConnectionString = Constants.CosmosDB.CosmosDBConnectionStringSetting;
-            var serviceUri = new Uri(builder["AccountEndpoint"].ToString());
-            _docDbClient = new DocumentClient(serviceUri, builder["AccountKey"].ToString());
+            var serviceUri = builder["AccountEndpoint"].ToString();
+            _cosmosDbClient = new CosmosClient(serviceUri, builder["AccountKey"].ToString());
         }
 
         // keep
         public async static Task CreateDocument(string docId)
         {
             Document documentToTest = new Document()
             {
-                Id = docId
+                id = docId
             };
 
-            Document insertedDoc = await _docDbClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName), documentToTest);
-        }
+            Container _inputContainer = _cosmosDbClient.GetContainer(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName);
 
-        public async static Task CreateDocument(TestDocument testDocument)
-        {
-            Document insertedDoc = await _docDbClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName), testDocument);
+            Document insertedDoc = await _inputContainer.CreateItemAsync<Document>(documentToTest, new PartitionKey(documentToTest.id));
         }
 
         // keep
         public async static Task<string> ReadDocument(string docId)
         {
-            var docUri = UriFactory.CreateDocumentUri(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, docId);
             Document retrievedDocument = null;
             await Utilities.RetryAsync(async () =>
             {
                 try
                 {
-                    retrievedDocument = await _docDbClient.ReadDocumentAsync(docUri);
+                    Container container = _cosmosDbClient.GetContainer(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName);
+
+                    retrievedDocument = await container.ReadItemAsync<Document>(docId, new PartitionKey(docId));
                     return true;
                 }
-                catch (DocumentClientException ex) when (ex.Error.Code == "NotFound" || ex.Error.Code == "Not Found")
+                catch (CosmosException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
                 {
                     return false;
                 }
             }, 120000, 4000);
-            return retrievedDocument.Id;
+            return retrievedDocument.id;
         }
 
         // keep
         public async static Task DeleteTestDocuments(string docId)
         {
-            var inputDocUri = UriFactory.CreateDocumentUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName, docId);
-            await DeleteDocument(inputDocUri);
-            var outputDocUri = UriFactory.CreateDocumentUri(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, docId);
-            await DeleteDocument(outputDocUri);
+            await DeleteDocument(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName, docId);
+            await DeleteDocument(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, docId);
         }
 
-        private async static Task DeleteDocument(Uri docUri)
+        private async static Task DeleteDocument(string dbName, string collectionName, string docId)
         {
             try
             {
-                await _docDbClient.DeleteDocumentAsync(docUri);
+                Container container = _cosmosDbClient.GetContainer(dbName, collectionName);
+                await container.DeleteItemAsync<Document>(docId, new PartitionKey(docId));
             }
             catch (Exception)
             {
@@ -89,41 +83,55 @@ private async static Task DeleteDocument(Uri docUri)
         // keep
         public async static Task CreateDocumentCollections()
         {
-            Database db = await _docDbClient.CreateDatabaseIfNotExistsAsync(new Database { Id = Constants.CosmosDB.DbName });
-            Uri dbUri = UriFactory.CreateDatabaseUri(db.Id);
-
-            await CreateCollection(dbUri, Constants.CosmosDB.InputCollectionName);
-            await CreateCollection(dbUri, Constants.CosmosDB.OutputCollectionName);
-            await CreateCollection(dbUri, Constants.CosmosDB.LeaseCollectionName);
+            Database db = await _cosmosDbClient.CreateDatabaseIfNotExistsAsync(Constants.CosmosDB.DbName);
 
+            await CreateCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName, "/id");
+            await CreateCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, "/id");
+            // While using extensions v2-3, the leases may not have a partition key, but the new SDK requires
+            // one to manually create a collection. This comment may be removed and this line uncommented when
+            // extension bundles for tests are updated. 
+            //await CreateCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.LeaseCollectionName, "/id");
         }
         public async static Task DeleteDocumentCollections()
         {
-            await DeleteCollection(inputCollectionsUri);
-            await DeleteCollection(outputCollectionsUri);
-            await DeleteCollection(leasesCollectionsUri);
+            await DeleteCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName);
+            await DeleteCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName);
+            await DeleteCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.LeaseCollectionName);
         }
 
-        private async static Task DeleteCollection(Uri collectionUri)
+        private async static Task DeleteCollection(string dbName, string collectionName)
         {
             try
             {
-                await _docDbClient.DeleteDocumentCollectionAsync(collectionUri);
+                Database database = _cosmosDbClient.GetDatabase(dbName);
+                await database.GetContainer(collectionName).DeleteContainerAsync();
             }
             catch (Exception)
             {
                 //Ignore
             }
         }
 
-        private async static Task CreateCollection(Uri dbUri, string collectioName)
+        private async static Task CreateCollection(string dbName, string collectionName, string partitionKey)
         {
-            DocumentCollection collection = new DocumentCollection() { Id = collectioName };
-            await _docDbClient.CreateDocumentCollectionIfNotExistsAsync(dbUri, collection,
-                new RequestOptions()
+            Database database = _cosmosDbClient.GetDatabase(dbName);
+            IndexingPolicy indexingPolicy = new IndexingPolicy
+            {
+                IndexingMode = IndexingMode.Consistent,
+                Automatic = true,
+                IncludedPaths =
                 {
-                    OfferThroughput = 400
-                });
+                    new IncludedPath
+                    {
+                        Path = "/*"
+                    }
+                }
+            };
+            var containerProperties = new ContainerProperties(collectionName, partitionKey)
+            {
+                IndexingPolicy = indexingPolicy
+            };
+            await database.CreateContainerIfNotExistsAsync(containerProperties, 400);
         }
     }
 }
diff --git a/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Helpers/EventHubsHelpers.cs b/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/Helpers/EventHubsHelpers.cs
@@ -1,7 +1,8 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
-using Microsoft.Azure.EventHubs;
+using Azure.Messaging.EventHubs;
+using Azure.Messaging.EventHubs.Producer;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using System.Collections.Generic;
@@ -29,13 +30,11 @@ public static async Task SendJSONMessagesAsync(string eventId, string eventHubNa
                 events.Add(evt);
             }
 
-            EventHubsConnectionStringBuilder builder = new EventHubsConnectionStringBuilder(Constants.EventHubs.EventHubsConnectionStringSetting);
-            builder.EntityPath = eventHubName;
-            EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
+            EventHubProducerClient eventHubClient = new EventHubProducerClient(Constants.EventHubs.EventHubsConnectionStringSetting, eventHubName);
             await eventHubClient.SendAsync(events);
         }
 
-        public static async Task SendMessagesAsync(string eventId, string evenHubName)
+        public static async Task SendMessagesAsync(string eventId, string eventHubName)
         {
             // write 3 events
             List<EventData> events = new List<EventData>();
@@ -48,9 +47,7 @@ public static async Task SendMessagesAsync(string eventId, string evenHubName)
                 events.Add(evt);
             }
 
-            EventHubsConnectionStringBuilder builder = new EventHubsConnectionStringBuilder(Constants.EventHubs.EventHubsConnectionStringSetting);
-            builder.EntityPath = evenHubName;
-            EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());
+            EventHubProducerClient eventHubClient = new EventHubProducerClient(Constants.EventHubs.EventHubsConnectionStringSetting, eventHubName);
             await eventHubClient.SendAsync(events);
         }
     }
diff --git a/test/E2E/TestFunctionApp/CosmosDBTriggerAndOutput/function.json b/test/E2E/TestFunctionApp/CosmosDBTriggerAndOutput/function.json
@@ -7,7 +7,7 @@
       "leaseCollectionName": "leases",
       "connectionStringSetting": "AzureWebJobsCosmosDBConnectionString",
       "databaseName": "ItemDb",
-      "collectionName": "ItemCollectionIn",
+      "collectionName": "PartitionedItemCollectionIn",
       "createLeaseCollectionIfNotExists": true
     },
     {
@@ -17,7 +17,7 @@
       "leaseCollectionName": "leases",
       "connectionStringSetting": "AzureWebJobsCosmosDBConnectionString",
       "databaseName": "ItemDb",
-      "collectionName": "ItemCollectionOut"
+      "collectionName": "PartitionedItemCollectionOut"
     }
   ]
 }

Original file line number	Diff line number	Diff line change
`@@ -3,82 +3,76 @@`
`3`	`3`
`4`	`4`	`using System;`
`5`	`5`	`using System.Threading.Tasks;`
`6`		`-using Microsoft.Azure.Documents;`
`7`		`-using Microsoft.Azure.Documents.Client;`
	`6`	`+using Microsoft.Azure.Cosmos;`
`8`	`7`
`9`	`8`	`namespace Azure.Functions.PowerShell.Tests.E2E`
`10`	`9`	`{`
`11`		`- public class TestDocument`
`12`		`- {`
`13`		`- public string id { get; set; }`
`14`		`- public string name { get; set; }`
`15`		`- }`
`16`	`10`
`17`	`11`	`public static class CosmosDBHelpers`
`18`	`12`	`{`
`19`		`- private static DocumentClient _docDbClient;`
`20`		`- private static Uri inputCollectionsUri = UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName);`
`21`		`- private static Uri outputCollectionsUri = UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName);`
`22`		`- private static Uri leasesCollectionsUri = UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.LeaseCollectionName);`
	`13`	`+ private static CosmosClient _cosmosDbClient;`
	`14`	`+`
	`15`	`+ private class Document`
	`16`	`+ {`
	`17`	`+ // lower-case because Cosmos expects a field with this name`
	`18`	`+ public string id { get; set; }`
	`19`	`+ }`
`23`	`20`
`24`	`21`	`static CosmosDBHelpers()`
`25`	`22`	`{`
`26`	`23`	`var builder = new System.Data.Common.DbConnectionStringBuilder();`
`27`	`24`	`builder.ConnectionString = Constants.CosmosDB.CosmosDBConnectionStringSetting;`
`28`		`- var serviceUri = new Uri(builder["AccountEndpoint"].ToString());`
`29`		`- _docDbClient = new DocumentClient(serviceUri, builder["AccountKey"].ToString());`
	`25`	`+ var serviceUri = builder["AccountEndpoint"].ToString();`
	`26`	`+ _cosmosDbClient = new CosmosClient(serviceUri, builder["AccountKey"].ToString());`
`30`	`27`	`}`
`31`	`28`
`32`	`29`	`// keep`
`33`	`30`	`public async static Task CreateDocument(string docId)`
`34`	`31`	`{`
`35`	`32`	`Document documentToTest = new Document()`
`36`	`33`	`{`
`37`		`- Id = docId`
	`34`	`+ id = docId`
`38`	`35`	`};`
`39`	`36`
`40`		`- Document insertedDoc = await _docDbClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName), documentToTest);`
`41`		`- }`
	`37`	`+ Container _inputContainer = _cosmosDbClient.GetContainer(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName);`
`42`	`38`
`43`		`- public async static Task CreateDocument(TestDocument testDocument)`
`44`		`- {`
`45`		`- Document insertedDoc = await _docDbClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName), testDocument);`
	`39`	`+ Document insertedDoc = await _inputContainer.CreateItemAsync<Document>(documentToTest, new PartitionKey(documentToTest.id));`
`46`	`40`	`}`
`47`	`41`
`48`	`42`	`// keep`
`49`	`43`	`public async static Task<string> ReadDocument(string docId)`
`50`	`44`	`{`
`51`		`- var docUri = UriFactory.CreateDocumentUri(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, docId);`
`52`	`45`	`Document retrievedDocument = null;`
`53`	`46`	`await Utilities.RetryAsync(async () =>`
`54`	`47`	`{`
`55`	`48`	`try`
`56`	`49`	`{`
`57`		`- retrievedDocument = await _docDbClient.ReadDocumentAsync(docUri);`
	`50`	`+ Container container = _cosmosDbClient.GetContainer(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName);`
	`51`	`+`
	`52`	`+ retrievedDocument = await container.ReadItemAsync<Document>(docId, new PartitionKey(docId));`
`58`	`53`	`return true;`
`59`	`54`	`}`
`60`		`- catch (DocumentClientException ex) when (ex.Error.Code == "NotFound" \|\| ex.Error.Code == "Not Found")`
	`55`	`+ catch (CosmosException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)`
`61`	`56`	`{`
`62`	`57`	`return false;`
`63`	`58`	`}`
`64`	`59`	`}, 120000, 4000);`
`65`		`- return retrievedDocument.Id;`
	`60`	`+ return retrievedDocument.id;`
`66`	`61`	`}`
`67`	`62`
`68`	`63`	`// keep`
`69`	`64`	`public async static Task DeleteTestDocuments(string docId)`
`70`	`65`	`{`
`71`		`- var inputDocUri = UriFactory.CreateDocumentUri(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName, docId);`
`72`		`- await DeleteDocument(inputDocUri);`
`73`		`- var outputDocUri = UriFactory.CreateDocumentUri(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, docId);`
`74`		`- await DeleteDocument(outputDocUri);`
	`66`	`+ await DeleteDocument(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName, docId);`
	`67`	`+ await DeleteDocument(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, docId);`
`75`	`68`	`}`
`76`	`69`
`77`		`- private async static Task DeleteDocument(Uri docUri)`
	`70`	`+ private async static Task DeleteDocument(string dbName, string collectionName, string docId)`
`78`	`71`	`{`
`79`	`72`	`try`
`80`	`73`	`{`
`81`		`- await _docDbClient.DeleteDocumentAsync(docUri);`
	`74`	`+ Container container = _cosmosDbClient.GetContainer(dbName, collectionName);`
	`75`	`+ await container.DeleteItemAsync<Document>(docId, new PartitionKey(docId));`
`82`	`76`	`}`
`83`	`77`	`catch (Exception)`
`84`	`78`	`{`
`@@ -89,41 +83,55 @@ private async static Task DeleteDocument(Uri docUri)`
`89`	`83`	`// keep`
`90`	`84`	`public async static Task CreateDocumentCollections()`
`91`	`85`	`{`
`92`		`- Database db = await _docDbClient.CreateDatabaseIfNotExistsAsync(new Database { Id = Constants.CosmosDB.DbName });`
`93`		`- Uri dbUri = UriFactory.CreateDatabaseUri(db.Id);`
`94`		`-`
`95`		`- await CreateCollection(dbUri, Constants.CosmosDB.InputCollectionName);`
`96`		`- await CreateCollection(dbUri, Constants.CosmosDB.OutputCollectionName);`
`97`		`- await CreateCollection(dbUri, Constants.CosmosDB.LeaseCollectionName);`
	`86`	`+ Database db = await _cosmosDbClient.CreateDatabaseIfNotExistsAsync(Constants.CosmosDB.DbName);`
`98`	`87`
	`88`	`+ await CreateCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName, "/id");`
	`89`	`+ await CreateCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName, "/id");`
	`90`	`+ // While using extensions v2-3, the leases may not have a partition key, but the new SDK requires`
	`91`	`+ // one to manually create a collection. This comment may be removed and this line uncommented when`
	`92`	`+ // extension bundles for tests are updated.`
	`93`	`+ //await CreateCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.LeaseCollectionName, "/id");`
`99`	`94`	`}`
`100`	`95`	`public async static Task DeleteDocumentCollections()`
`101`	`96`	`{`
`102`		`- await DeleteCollection(inputCollectionsUri);`
`103`		`- await DeleteCollection(outputCollectionsUri);`
`104`		`- await DeleteCollection(leasesCollectionsUri);`
	`97`	`+ await DeleteCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.InputCollectionName);`
	`98`	`+ await DeleteCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.OutputCollectionName);`
	`99`	`+ await DeleteCollection(Constants.CosmosDB.DbName, Constants.CosmosDB.LeaseCollectionName);`
`105`	`100`	`}`
`106`	`101`
`107`		`- private async static Task DeleteCollection(Uri collectionUri)`
	`102`	`+ private async static Task DeleteCollection(string dbName, string collectionName)`
`108`	`103`	`{`
`109`	`104`	`try`
`110`	`105`	`{`
`111`		`- await _docDbClient.DeleteDocumentCollectionAsync(collectionUri);`
	`106`	`+ Database database = _cosmosDbClient.GetDatabase(dbName);`
	`107`	`+ await database.GetContainer(collectionName).DeleteContainerAsync();`
`112`	`108`	`}`
`113`	`109`	`catch (Exception)`
`114`	`110`	`{`
`115`	`111`	`//Ignore`
`116`	`112`	`}`
`117`	`113`	`}`
`118`	`114`
`119`		`- private async static Task CreateCollection(Uri dbUri, string collectioName)`
	`115`	`+ private async static Task CreateCollection(string dbName, string collectionName, string partitionKey)`
`120`	`116`	`{`
`121`		`- DocumentCollection collection = new DocumentCollection() { Id = collectioName };`
`122`		`- await _docDbClient.CreateDocumentCollectionIfNotExistsAsync(dbUri, collection,`
`123`		`- new RequestOptions()`
	`117`	`+ Database database = _cosmosDbClient.GetDatabase(dbName);`
	`118`	`+ IndexingPolicy indexingPolicy = new IndexingPolicy`
	`119`	`+ {`
	`120`	`+ IndexingMode = IndexingMode.Consistent,`
	`121`	`+ Automatic = true,`
	`122`	`+ IncludedPaths =`
`124`	`123`	`{`
`125`		`- OfferThroughput = 400`
`126`		`- });`
	`124`	`+ new IncludedPath`
	`125`	`+ {`
	`126`	`+ Path = "/*"`
	`127`	`+ }`
	`128`	`+ }`
	`129`	`+ };`
	`130`	`+ var containerProperties = new ContainerProperties(collectionName, partitionKey)`
	`131`	`+ {`
	`132`	`+ IndexingPolicy = indexingPolicy`
	`133`	`+ };`
	`134`	`+ await database.CreateContainerIfNotExistsAsync(containerProperties, 400);`
`127`	`135`	`}`
`128`	`136`	`}`
`129`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,8 @@`
`1`	`1`	`// Copyright (c) .NET Foundation. All rights reserved.`
`2`	`2`	`// Licensed under the MIT License. See License.txt in the project root for license information.`
`3`	`3`
`4`		`-using Microsoft.Azure.EventHubs;`
	`4`	`+using Azure.Messaging.EventHubs;`
	`5`	`+using Azure.Messaging.EventHubs.Producer;`
`5`	`6`	`using Newtonsoft.Json;`
`6`	`7`	`using Newtonsoft.Json.Linq;`
`7`	`8`	`using System.Collections.Generic;`
`@@ -29,13 +30,11 @@ public static async Task SendJSONMessagesAsync(string eventId, string eventHubNa`
`29`	`30`	`events.Add(evt);`
`30`	`31`	`}`
`31`	`32`
`32`		`- EventHubsConnectionStringBuilder builder = new EventHubsConnectionStringBuilder(Constants.EventHubs.EventHubsConnectionStringSetting);`
`33`		`- builder.EntityPath = eventHubName;`
`34`		`- EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());`
	`33`	`+ EventHubProducerClient eventHubClient = new EventHubProducerClient(Constants.EventHubs.EventHubsConnectionStringSetting, eventHubName);`
`35`	`34`	`await eventHubClient.SendAsync(events);`
`36`	`35`	`}`
`37`	`36`
`38`		`- public static async Task SendMessagesAsync(string eventId, string evenHubName)`
	`37`	`+ public static async Task SendMessagesAsync(string eventId, string eventHubName)`
`39`	`38`	`{`
`40`	`39`	`// write 3 events`
`41`	`40`	`List<EventData> events = new List<EventData>();`
`@@ -48,9 +47,7 @@ public static async Task SendMessagesAsync(string eventId, string evenHubName)`
`48`	`47`	`events.Add(evt);`
`49`	`48`	`}`
`50`	`49`
`51`		`- EventHubsConnectionStringBuilder builder = new EventHubsConnectionStringBuilder(Constants.EventHubs.EventHubsConnectionStringSetting);`
`52`		`- builder.EntityPath = evenHubName;`
`53`		`- EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString());`
	`50`	`+ EventHubProducerClient eventHubClient = new EventHubProducerClient(Constants.EventHubs.EventHubsConnectionStringSetting, eventHubName);`
`54`	`51`	`await eventHubClient.SendAsync(events);`
`55`	`52`	`}`
`56`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`"leaseCollectionName": "leases",`
`8`	`8`	`"connectionStringSetting": "AzureWebJobsCosmosDBConnectionString",`
`9`	`9`	`"databaseName": "ItemDb",`
`10`		`- "collectionName": "ItemCollectionIn",`
	`10`	`+ "collectionName": "PartitionedItemCollectionIn",`
`11`	`11`	`"createLeaseCollectionIfNotExists": true`
`12`	`12`	`},`
`13`	`13`	`{`
`@@ -17,7 +17,7 @@`
`17`	`17`	`"leaseCollectionName": "leases",`
`18`	`18`	`"connectionStringSetting": "AzureWebJobsCosmosDBConnectionString",`
`19`	`19`	`"databaseName": "ItemDb",`
`20`		`- "collectionName": "ItemCollectionOut"`
	`20`	`+ "collectionName": "PartitionedItemCollectionOut"`
`21`	`21`	`}`
`22`	`22`	`]`
`23`	`23`	`}`