Esempio n. 1
0
        internal async Task <PVOutputResponse <TResponseContentType> > ExecuteSingleItemRequestAsync <TResponseContentType>(IRequest request, Dictionary <string, object> loggingScope, CancellationToken cancellationToken)
        {
            HttpResponseMessage responseMessage = null;

            try
            {
                using (Logger.BeginScope(loggingScope))
                {
                    using (HttpRequestMessage requestMessage = CreateRequestMessage(request))
                    {
                        responseMessage = await ExecuteRequestAsync(requestMessage, cancellationToken).ConfigureAwait(false);
                    }
                    Stream responseStream = await GetResponseContentStreamAsync(responseMessage).ConfigureAwait(false);

                    var result = new PVOutputResponse <TResponseContentType>();
                    result.ApiRateInformation = GetApiRateInformationfromResponse(responseMessage);

                    if (ResponseIsErrorResponse(responseMessage, responseStream, result))
                    {
                        return(result);
                    }

                    IObjectStringReader <TResponseContentType> reader = StringFactoryContainer.CreateObjectReader <TResponseContentType>();
                    TResponseContentType content = await reader.ReadObjectAsync(responseStream, cancellationToken).ConfigureAwait(false);

                    result.IsSuccess = true;
                    result.Value     = content;
                    return(result);
                }
            }
            finally
            {
                responseMessage.Dispose();
            }
        }
Esempio n. 2
0
 protected static void AssertStandardResponse <TResponseContentType>(PVOutputResponse <TResponseContentType> response)
 {
     Assert.Multiple(() =>
     {
         Assert.That(response.Error, Is.Null);
         Assert.That(response.HasValue, Is.True);
         Assert.That(response.IsSuccess, Is.True);
         Assert.That(response.Value, Is.Not.Null);
     });
 }
        public async Task SystemService_GetOwnSystem_CallsCorrectUri()
        {
            PVOutputClient client = TestUtility.GetMockClient(out MockHttpMessageHandler testProvider);

            testProvider.ExpectUriFromBase(GETSYSTEM_URL)
            .RespondPlainText(SYSTEM_RESPONSE_EXTENDED);

            PVOutputResponse <ISystem> response = await client.System.GetOwnSystemAsync();

            testProvider.VerifyNoOutstandingExpectation();
            AssertStandardResponse(response);
        }
        public void PVOutputResponse_IsEquivalentTo_ReturnsEquivelanceNotEquals()
        {
            var response1 = new PVOutputResponse <IStatus>()
            {
                IsSuccess = true, Value = new Status()
            };
            var response2 = new PVOutputResponse <IStatus>()
            {
                IsSuccess = true, Value = new Status()
            };
            var response3 = new PVOutputResponse <IStatus>()
            {
                IsSuccess = false
            };

            Assert.Multiple(() =>
            {
                Assert.That(response1.IsEquivalentTo(response2), Is.True);
                Assert.That(response1.IsEquivalentTo(response3), Is.False);
            });
        }