public override Task SetupAsync() { var data = new { analysisInput = new { conversationItem = new { text = "Send an email to Carol about the tomorrow's demo", id = "1", participantId = "1", } }, parameters = new { projectName = TestEnvironment.ProjectName, deploymentName = TestEnvironment.DeploymentName, // Use Utf16CodeUnit for Strings in .NET. stringIndexType = "Utf16CodeUnit", }, kind = "Conversation", }; _content = RequestContent.Create(data); return(Task.CompletedTask); }
public void DisableRequestBodyRecordingMakesRequestBodyNull() { var tempFile = Path.GetTempFileName(); TestRecording recording = new TestRecording(RecordedTestMode.Record, tempFile, new TestSanitizer(), new RecordMatcher()); HttpPipelineTransport transport = recording.CreateTransport(Mock.Of <HttpPipelineTransport>()); var body = "A nice and long body."; var request = new MockRequest(); request.Content = RequestContent.Create(Encoding.UTF8.GetBytes(body)); request.Headers.Add("Content-Type", "text/json"); HttpMessage message = new HttpMessage(request, null); message.Response = new MockResponse(200); using (recording.DisableRequestBodyRecording()) { transport.Process(message); } recording.Dispose(true); var text = File.ReadAllText(tempFile); StringAssert.DoesNotContain(body, text); StringAssert.Contains($"\"RequestBody\": null", text); }
public async Task CanGetAndSetMethod(RequestMethod method, string expectedMethod, bool content = false) { string httpMethod = null; using TestServer testServer = new TestServer( context => { httpMethod = context.Request.Method.ToString(); }); var transport = GetTransport(); Request request = transport.CreateRequest(); request.Method = method; request.Uri.Reset(testServer.Address); if (content) { request.Content = RequestContent.Create(Array.Empty <byte>()); } Assert.AreEqual(method, request.Method); await ExecuteRequest(request, transport); Assert.AreEqual(expectedMethod, httpMethod); }
public async Task CanGetAndSetContentStream() { byte[] requestBytes = null; using TestServer testServer = new TestServer( context => { using var memoryStream = new MemoryStream(); context.Request.Body.CopyTo(memoryStream); requestBytes = memoryStream.ToArray(); }); var stream = new MemoryStream(); stream.SetLength(10 * 1024); var content = RequestContent.Create(stream); var transport = GetTransport(); Request request = transport.CreateRequest(); request.Method = RequestMethod.Post; request.Uri.Reset(testServer.Address); request.Content = content; Assert.AreEqual(content, request.Content); await ExecuteRequest(request, transport); CollectionAssert.AreEqual(stream.ToArray(), requestBytes); Assert.AreEqual(10 * 1024, requestBytes.Length); }
public async Task CanSetContentLenghtOverMaxInt() { long contentLength = 0; using TestServer testServer = new TestServer( context => { contentLength = context.Request.ContentLength.Value; }); var requestContentLength = long.MaxValue; var transport = GetTransport(); Request request = transport.CreateRequest(); request.Method = RequestMethod.Post; request.Uri.Reset(testServer.Address); request.Content = RequestContent.Create(new byte[10]); request.Headers.Add("Content-Length", requestContentLength.ToString()); try { await ExecuteRequest(request, transport); } catch (Exception) { // Sending the request would fail because of length mismatch } Assert.AreEqual(requestContentLength, requestContentLength); }
public async Task <Response> SendAsync(string tableName, IEnumerable <IDictionary <string, object> > values) { byte[] data; using (var stream = new MemoryStream()) { using (var writer = new Utf8JsonWriter(stream)) { writer.WriteObjectValue(values); } data = stream.ToArray(); } var request = _pipeline.CreateRequest(); request.Uri.Reset(new Uri($"https://{_workspaceId}.{_ingestEndpointSuffix}/api/logs?api-version=2016-04-01")); request.Method = RequestMethod.Post; request.Headers.SetValue("Content-Type", "application/json"); request.Headers.SetValue("Log-Type", tableName); request.Headers.SetValue("time-generated-field", "EventTimeGenerated"); request.Content = RequestContent.Create(data); var response = await _pipeline.SendRequestAsync(request, default); if (response.Status != 200) { throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(response); } return(response); }
private async Task <Response> SendCloudNativeCloudEventsInternalAsync(ReadOnlyMemory <byte> cloudEvents, bool async, CancellationToken cancellationToken = default) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(EventGridPublisherClient)}.{nameof(SendEncodedCloudEvents)}"); scope.Start(); try { using HttpMessage message = _pipeline.CreateMessage(); Request request = message.Request; request.Method = RequestMethod.Post; var uri = new RawRequestUriBuilder(); uri.AppendRaw("https://", false); uri.AppendRaw(_hostName, false); uri.AppendPath("/api/events", false); uri.AppendQuery("api-version", _apiVersion, true); request.Uri = uri; request.Headers.Add("Content-Type", "application/cloudevents-batch+json; charset=utf-8"); RequestContent content = RequestContent.Create(cloudEvents); request.Content = content; if (async) { await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); } else { _pipeline.Send(message, cancellationToken); } return(message.Response.Status switch { 200 => message.Response, _ => async ? throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false) : throw _clientDiagnostics.CreateRequestFailedException(message.Response) }); }
public async Task DataSourceOperations() { string name = "test-datasources3"; var client = GetPurviewDataSourceClient(name); var data = new { kind = "AmazonS3", name = name, properties = new { serviceUrl = "s3://testpurview", collection = new { type = "CollectionReference", referenceName = "dotnetllcpurviewaccount" } } }; //Create Response createResponse = await client.CreateOrUpdateAsync(RequestContent.Create(data)); Assert.AreEqual(201, createResponse.Status); //Get Response getResponse = await client.GetPropertiesAsync(new()); Assert.AreEqual(200, getResponse.Status); JsonElement getBodyJson = JsonDocument.Parse(GetContentFromResponse(getResponse)).RootElement; Assert.AreEqual("datasources/test-datasources3", getBodyJson.GetProperty("id").GetString()); //Delete Response deleteResponse = await client.DeleteAsync(); Assert.AreEqual(200, deleteResponse.Status); }
private Request CreateInkRecognitionRequest(HttpPipeline pipeline, IEnumerable <InkStroke> strokes, ApplicationKind applicationKind, string language, InkPointUnit inkPointUnit, float unitMultiple) { Request request = pipeline.CreateRequest(); // add content var inkRecognitionRequest = new InkRecognitionRequest(strokes, applicationKind, language, inkPointUnit, unitMultiple); var content = new MemoryStream(Encoding.UTF8.GetBytes(inkRecognitionRequest.ToJson())); request.Content = RequestContent.Create(content); // specify HTTP request line request.Method = RequestMethod.Put; var requestUri = new RequestUriBuilder(); requestUri.Reset(_endpoint); request.Uri.Scheme = requestUri.Scheme; request.Uri.Host = requestUri.Host; request.Uri.Port = requestUri.Port; request.Uri.Path = requestUri.Path; request.Uri.Query = requestUri.Query; // add headers for authentication _credential.SetRequestCredentials(request); return(request); }
public async Task CreateOrUpdateTask() { var options = new PurviewAccountClientOptions(); var collectionName = "mysubCollection"; PurviewCollection client = GetCollectionsClient(collectionName); var data = new { parentCollection = new { referenceName = "dotnetLLCPurviewAccount" }, }; Response createResponse = await client.CreateOrUpdateCollectionAsync(RequestContent.Create(data), default); JsonElement createBodyJson = JsonDocument.Parse(GetContentFromResponse(createResponse)).RootElement; Assert.AreEqual("mysubCollection", createBodyJson.GetProperty("name").GetString()); while (true) { System.Threading.Thread.Sleep(1000); Response getResponse = await client.GetCollectionAsync(new()); JsonElement getBodyJson = JsonDocument.Parse(GetContentFromResponse(getResponse)).RootElement; if (getBodyJson.GetProperty("collectionProvisioningState").GetString() == "Succeeded") { break; } } Response delRespons = await client.DeleteCollectionAsync(default);
public async Task CanSetContentLengthOverMaxInt() { long contentLength = 0; using TestServer testServer = new TestServer( context => { contentLength = context.Request.ContentLength.Value; context.Abort(); }); var transport = GetTransport(); Request request = transport.CreateRequest(); request.Method = RequestMethod.Post; request.Uri.Reset(testServer.Address); var infiniteStream = new InfiniteStream(); request.Content = RequestContent.Create(infiniteStream); try { await ExecuteRequest(request, transport); } catch (Exception) { // Sending the request would fail because of length mismatch } // InfiniteStream has a length of long.MaxValue check that it got sent correctly Assert.AreEqual(infiniteStream.Length, contentLength); Assert.Greater(infiniteStream.Length, int.MaxValue); }
public async Task GettingErrorRequestProducesEvents() { var response = new MockResponse(500); response.SetContent(new byte[] { 6, 7, 8, 9, 0 }); response.AddHeader(new HttpHeader("Custom-Response-Header", "Improved value")); MockTransport mockTransport = CreateMockTransport(response); var pipeline = new HttpPipeline(mockTransport, new[] { new LoggingPolicy(logContent: true, int.MaxValue, s_allowedHeaders, s_allowedQueryParameters, "Test-SDK") }); string requestId = null; await SendRequestAsync(pipeline, request => { request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://contoso.a.io")); request.Headers.Add("Date", "3/26/2019"); request.Headers.Add("Custom-Header", "Value"); request.Content = RequestContent.Create(new byte[] { 1, 2, 3, 4, 5 }); requestId = request.ClientRequestId; }); EventWrittenEventArgs e = _listener.SingleEventById(ErrorResponseEvent); Assert.AreEqual(EventLevel.Warning, e.Level); Assert.AreEqual("ErrorResponse", e.EventName); Assert.AreEqual(requestId, e.GetProperty<string>("requestId")); Assert.AreEqual(e.GetProperty<int>("status"), 500); StringAssert.Contains($"Custom-Response-Header:Improved value{Environment.NewLine}", e.GetProperty<string>("headers")); e = _listener.SingleEventById(ErrorResponseContentEvent); Assert.AreEqual(EventLevel.Informational, e.Level); Assert.AreEqual("ErrorResponseContent", e.EventName); Assert.AreEqual(requestId, e.GetProperty<string>("requestId")); CollectionAssert.AreEqual(new byte[] { 6, 7, 8, 9, 0 }, e.GetProperty<byte[]>("content")); }
public async Task ScanTriggerOperations() { var client = GetPurviewScanClient("test-datasource1009", "test-scan1009"); //Create var data = new { name = "default", properties = new { scanLevel = "Incremental", recurrence = new { startTime = "2021-10-12T09:30:00", interval = 1, frequency = "Month", timezone = "China Standard Time", schedule = new { monthDays = new[] { 1 } } } } }; Response createResponse = await client.CreateOrUpdateTriggerAsync(RequestContent.Create(data)); Assert.AreEqual(201, createResponse.Status); //Delete Response deleteResponse = await client.DeleteTriggerAsync(); Assert.AreEqual(200, deleteResponse.Status); }
public async Task FliterOperations() { var client = GetPurviewScanClient("test-datasource1009", "test-scan1009"); //Create var data = new { name = "custom", id = "datasources/test-datasource1009/scans/test-scan1009/filters/custom", properties = new { includeUriPrefixes = new[] { "https://foo.file.core.windows.net/share1/user", "https://foo.file.core.windows.net/share1/aggregated" }, excludeUriPrefixes = new[] { "https://foo.file.core.windows.net/share1/user/temp" } } }; Response createResponse = await client.CreateOrUpdateFilterAsync(RequestContent.Create(data)); Assert.AreEqual(200, createResponse.Status); //Get Response getResponse = await client.GetFilterAsync(new()); Assert.AreEqual(200, getResponse.Status); JsonElement fetchBodyJson = JsonDocument.Parse(GetContentFromResponse(getResponse)).RootElement; Assert.AreEqual("https://foo.file.core.windows.net/share1/user/temp", fetchBodyJson.GetProperty("properties").GetProperty("excludeUriPrefixes")[0].GetString()); }
public void FailedTransaction() { var client = InstrumentClient( new ConfidentialLedgerClient( new("https://client"), new MockCredential(), new ConfidentialLedgerClientOptions { Transport = new MockTransport( req => { if (req.Uri.Path.Contains($"transactions/{transactionId}/status")) { var success = new MockResponse(500); success.SetContent("success"); return(success); } var failed = new MockResponse(200); failed.AddHeader("x-ms-ccf-transaction-id", transactionId); failed.SetContent("failed"); return(failed); }) })); var ex = Assert.ThrowsAsync <InvalidOperationException>( async() => await client.PostLedgerEntryAsync(RequestContent.Create(new { contents = "test" }), null, true, default)); Assert.That(ex.Message, Does.Contain(transactionId)); }
static async Task Main(string[] args) { if (args.Length != 1) { Console.WriteLine("Usage: publisher <connectionString>"); return; } var connectionString = args[0]; var hub = "test01"; var serviceClient = new WebPubSubServiceClient(connectionString, hub); var user = "******"; var count = 0; do { Console.WriteLine($"Sending {count}"); serviceClient.SendToUser(user, RequestContent.Create(new { TimeStamp = DateTime.UtcNow, Message = $"Hello World - {count}" })); count++; await Task.Delay(5000); }while(true); }
public async Task FarmersSmokeTest() { FarmersClient client = GetFarmersClient(); const string farmerId = "smoke-test-farmer"; Response createdResponse = await client.CreateOrUpdateAsync(farmerId, RequestContent.Create(new object())); JsonElement createdBodyJson = JsonDocument.Parse(GetContentFromResponse(createdResponse)).RootElement; Assert.AreEqual(farmerId, createdBodyJson.GetProperty("id").GetString()); Assert.IsTrue(HasProperty(createdBodyJson, "eTag")); Assert.IsTrue(HasProperty(createdBodyJson, "createdDateTime")); Assert.IsTrue(HasProperty(createdBodyJson, "modifiedDateTime")); Response fetchResponse = await client.GetFarmerAsync(farmerId, new()); JsonElement fetchBodyJson = JsonDocument.Parse(GetContentFromResponse(fetchResponse)).RootElement; Assert.AreEqual(createdBodyJson.GetProperty("id").GetString(), fetchBodyJson.GetProperty("id").GetString()); Assert.AreEqual(createdBodyJson.GetProperty("eTag").GetString(), fetchBodyJson.GetProperty("eTag").GetString()); Assert.AreEqual(createdBodyJson.GetProperty("createdDateTime").GetString(), fetchBodyJson.GetProperty("createdDateTime").GetString()); Assert.AreEqual(createdBodyJson.GetProperty("modifiedDateTime").GetString(), fetchBodyJson.GetProperty("modifiedDateTime").GetString()); await client.DeleteAsync(farmerId); }
public async Task UpdateSources() { string testProjectName = CreateTestProjectName(); await CreateProjectAsync(testProjectName); string sourceUri = "https://www.microsoft.com/en-in/software-download/faq"; RequestContent updateSourcesRequestContent = RequestContent.Create( new[] { new { op = "add", value = new { displayName = "MicrosoftFAQ", source = sourceUri, sourceUri = sourceUri, sourceKind = "url", contentStructureKind = "unstructured", refresh = false } } }); Operation <BinaryData> updateSourcesOperation = await Client.UpdateSourcesAsync(false, testProjectName, updateSourcesRequestContent); await updateSourcesOperation.WaitForCompletionAsync(); AsyncPageable <BinaryData> sources = Client.GetSourcesAsync(testProjectName); Assert.True(updateSourcesOperation.HasCompleted); Assert.AreEqual(200, updateSourcesOperation.GetRawResponse().Status); Assert.That((await sources.ToEnumerableAsync()).Any(source => source.ToString().Contains(sourceUri))); await DeleteProjectAsync(testProjectName); }
public async Task RequestContentLogsAreLimitedInLength() { var response = new MockResponse(500); MockTransport mockTransport = CreateMockTransport(response); var pipeline = new HttpPipeline(mockTransport, new[] { new LoggingPolicy(logContent: true, 5, s_allowedHeaders, s_allowedQueryParameters) }); string requestId = null; await SendRequestAsync(pipeline, request => { request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://contoso.a.io")); request.Content = RequestContent.Create(Encoding.UTF8.GetBytes("Hello world")); request.Headers.Add("Content-Type", "text/json"); requestId = request.ClientRequestId; }); EventWrittenEventArgs e = _listener.SingleEventById(RequestContentTextEvent); Assert.AreEqual(EventLevel.Verbose, e.Level); Assert.AreEqual("RequestContentText", e.EventName); Assert.AreEqual(requestId, e.GetProperty <string>("requestId")); Assert.AreEqual("Hello", e.GetProperty <string>("content")); CollectionAssert.IsEmpty(_listener.EventsById(ResponseContentEvent)); }
public async Task Import() { string testProjectName = CreateTestProjectName(); string importFormat = "json"; RequestContent importRequestContent = RequestContent.Create(new { Metadata = new { ProjectName = "NewProjectForExport", Description = "This is the description for a test project", Language = "en", DefaultAnswer = "No answer found for your question.", MultilingualResource = false, CreatedDateTime = "2021-11-25T09=35=33Z", LastModifiedDateTime = "2021-11-25T09=35=33Z", Settings = new { DefaultAnswer = "No answer found for your question." } } }); Operation <BinaryData> importOperation = await Client.ImportAsync(true, testProjectName, importRequestContent, importFormat); Response projectDetails = await Client.GetProjectDetailsAsync(testProjectName); Assert.True(importOperation.HasCompleted); Assert.AreEqual(200, importOperation.GetRawResponse().Status); Assert.AreEqual(200, projectDetails.Status); Assert.That(projectDetails.Content.ToString().Contains(testProjectName)); await DeleteProjectAsync(testProjectName); }
public async Task CanGetAndSetContent() { byte[] requestBytes = null; using TestServer testServer = new TestServer( context => { using var memoryStream = new MemoryStream(); context.Request.Body.CopyTo(memoryStream); requestBytes = memoryStream.ToArray(); }); var bytes = Encoding.ASCII.GetBytes("Hello world"); var content = RequestContent.Create(bytes); var transport = GetTransport(); Request request = transport.CreateRequest(); request.Method = RequestMethod.Post; request.Uri.Reset(testServer.Address); request.Content = content; Assert.AreEqual(content, request.Content); await ExecuteRequest(request, transport); CollectionAssert.AreEqual(bytes, requestBytes); }
public async Task AddFeedback() { string testProjectName = CreateTestProjectName(); await CreateProjectAsync(testProjectName); RequestContent addFeedbackRequestContent = RequestContent.Create( new { records = new[] { new { userId = "userX", userQuestion = "what do you mean?", qnaId = 1 } } }); Response addFeedbackResponse = await Client.AddFeedbackAsync(testProjectName, addFeedbackRequestContent); Assert.AreEqual(204, addFeedbackResponse.Status); await DeleteProjectAsync(testProjectName); }
public async Task SettingHeaderOverridesDefaultContentLength() { long contentLength = 0; using TestServer testServer = new TestServer( context => contentLength = context.Request.ContentLength.Value); var transport = GetTransport(); Request request = transport.CreateRequest(); request.Method = RequestMethod.Post; request.Uri.Reset(testServer.Address); request.Content = RequestContent.Create(new byte[10]); request.Headers.Add("Content-Length", "50"); try { await ExecuteRequest(request, transport); } catch (Exception) { // Sending the request would fail because of length mismatch } Assert.AreEqual(50, contentLength); }
public async Task UpdateQnAs() { string testProjectName = CreateTestProjectName(); await CreateProjectAsync(testProjectName); string question = "What is the easiest way to use azure services in my .NET project?"; string answer = "Using Microsoft's Azure SDKs"; RequestContent updateQnasRequestContent = RequestContent.Create( new[] { new { op = "add", value = new { questions = new[] { question }, answer = answer } } }); Operation <BinaryData> updateQnasOperation = await Client.UpdateQnasAsync(true, testProjectName, updateQnasRequestContent); AsyncPageable <BinaryData> sources = Client.GetQnasAsync(testProjectName); Assert.True(updateQnasOperation.HasCompleted); Assert.AreEqual(200, updateQnasOperation.GetRawResponse().Status); Assert.That((await sources.ToEnumerableAsync()).Any(source => source.ToString().Contains(question))); Assert.That((await sources.ToEnumerableAsync()).Any(source => source.ToString().Contains(answer))); await DeleteProjectAsync(testProjectName); }
private async Task <Response> SendCloudNativeCloudEventsInternalAsync(ReadOnlyMemory <byte> cloudEvents, bool async, CancellationToken cancellationToken = default) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(EventGridPublisherClient)}.{nameof(SendEncodedCloudEvents)}"); scope.Start(); try { using HttpMessage message = _pipeline.CreateMessage(); Request request = CreateEventRequest(message, "application/cloudevents-batch+json; charset=utf-8"); RequestContent content = RequestContent.Create(cloudEvents); request.Content = content; if (async) { await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); } else { _pipeline.Send(message, cancellationToken); } return(message.Response.Status switch { 200 => message.Response, _ => async ? throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false) : throw _clientDiagnostics.CreateRequestFailedException(message.Response) }); }
public async Task ExportAndImportAsync() { QuestionAnsweringProjectsClient client = Client; string exportedProjectName = CreateTestProjectName(); await CreateProjectAsync(exportedProjectName); #region Snippet:QuestionAnsweringProjectsClient_ExportProjectAsync Operation <BinaryData> exportOperation = await client.ExportAsync(waitForCompletion : true, exportedProjectName, format : "json"); // retrieve export operation response, and extract url of exported file JsonDocument operationValueJson = JsonDocument.Parse(exportOperation.Value); string exportedFileUrl = operationValueJson.RootElement.GetProperty("resultUrl").ToString(); #endregion Assert.True(exportOperation.HasCompleted); Assert.True(!String.IsNullOrEmpty(exportedFileUrl)); #region Snippet:QuestionAnsweringProjectsClient_ImportProjectAsync // Set import project name and request content string importedProjectName = "{ProjectNameToBeImported}"; #if !SNIPPET importedProjectName = "importedProject"; #endif RequestContent importRequestContent = RequestContent.Create(new { Metadata = new { ProjectName = "NewProjectForExport", Description = "This is the description for a test project", Language = "en", DefaultAnswer = "No answer found for your question.", MultilingualResource = false, CreatedDateTime = "2021-11-25T09=35=33Z", LastModifiedDateTime = "2021-11-25T09=35=33Z", Settings = new { DefaultAnswer = "No answer found for your question." } } }); Operation <BinaryData> importOperation = await client.ImportAsync(waitForCompletion : true, importedProjectName, importRequestContent, format : "json"); Console.WriteLine($"Operation status: {importOperation.GetRawResponse().Status}"); #endregion Assert.True(importOperation.HasCompleted); Assert.AreEqual(200, importOperation.GetRawResponse().Status); #region Snippet:QuestionAnsweringProjectsClient_GetProjectDetailsAsync Response projectDetails = await client.GetProjectDetailsAsync(importedProjectName); Console.WriteLine(projectDetails.Content); #endregion Assert.AreEqual(200, projectDetails.Status); await DeleteProjectAsync(importedProjectName); }
public void RecordSessionLookupSkipsRequestBodyWhenFilterIsOn() { var request = new MockRequest(); request.Uri.Reset(new Uri("https://mockuri.com")); request.Content = RequestContent.Create(Encoding.UTF8.GetBytes("A nice and long body.")); request.Headers.Add("Content-Type", "text/json"); HttpMessage message = new HttpMessage(request, null); message.Response = new MockResponse(200); var session = new RecordSession(); var recordTransport = new RecordTransport(session, Mock.Of <HttpPipelineTransport>(), entry => EntryRecordModel.RecordWithoutRequestBody, Mock.Of <Random>()); recordTransport.Process(message); request.Content = RequestContent.Create(Encoding.UTF8.GetBytes("A bad and longer body.")); var skipRequestBody = true; var playbackTransport = new PlaybackTransport(session, new RecordMatcher(), new RecordedTestSanitizer(), Mock.Of <Random>(), entry => skipRequestBody); playbackTransport.Process(message); skipRequestBody = false; Assert.Throws <InvalidOperationException>(() => playbackTransport.Process(message)); }
internal HttpMessage CreateAddRequest(string id, Stream twin, CreateOrReplaceDigitalTwinOptions digitalTwinsAddOptions) { var message = _pipeline.CreateMessage(); var request = message.Request; request.Method = RequestMethod.Put; var uri = new RawRequestUriBuilder(); uri.Reset(endpoint); uri.AppendPath("/digitaltwins/", false); uri.AppendPath(id, true); uri.AppendQuery("api-version", apiVersion, true); request.Uri = uri; if (digitalTwinsAddOptions?.TraceParent != null) { request.Headers.Add("TraceParent", digitalTwinsAddOptions.TraceParent); } if (digitalTwinsAddOptions?.TraceState != null) { request.Headers.Add("TraceState", digitalTwinsAddOptions.TraceState); } if (digitalTwinsAddOptions?.IfNoneMatch != null) { request.Headers.Add("If-None-Match", digitalTwinsAddOptions.IfNoneMatch); } request.Headers.Add("Content-Type", "application/json"); request.Headers.Add("Accept", "application/json"); var content = RequestContent.Create(twin); request.Content = content; return(message); }
public async Task CanGetAndAddRequestHeaders(string headerName, string headerValue, bool contentHeader, bool supportsMultiple) { StringValues httpHeaderValues = default; using TestServer testServer = new TestServer( context => { Assert.True(context.Request.Headers.TryGetValue(headerName, out httpHeaderValues)); }); var transport = GetTransport(); Request request = CreateRequest(transport, testServer); request.Headers.Add(headerName, headerValue); if (contentHeader) { request.Content = RequestContent.Create(new byte[16]); } Assert.True(request.Headers.TryGetValue(headerName, out var value)); Assert.AreEqual(headerValue, value); Assert.True(request.Headers.TryGetValue(headerName.ToUpper(), out value)); Assert.AreEqual(headerValue, value); CollectionAssert.AreEqual(new[] { new HttpHeader(headerName, headerValue), }, request.Headers); await ExecuteRequest(request, transport); Assert.AreEqual(headerValue, string.Join(",", httpHeaderValues)); }
/// <summary> /// Use text analytics services and detect whether a review is positive or not positive and print out the result to the console /// </summary> static async Task Task1() { var requestBody = new JsonData(); var documents = requestBody.SetEmptyArray("documents"); int i = 0; foreach (string review in ReadReviewsFromJson().Take(10)) { var document = documents.AddEmptyObject(); document["id"] = (++i).ToString(); document["text"] = review; } Response response = await client.GetSentimentAsync(RequestContent.Create(requestBody)); var responseBody = JsonData.FromBytes(response.Content.ToMemory()); if (response.Status == 200) { foreach (var document in responseBody["documents"].Items) { Console.WriteLine($"{document["id"]} is {document["sentiment"]}"); } } else { Console.Error.WriteLine(responseBody["error"]); } }