/// <summary>
/// Puts payload in a response operation with given status code.
/// </summary>
/// <typeparam name="T">Must be a PayloadTestDescriptor.</typeparam>
/// <param name="payload">Payload to put in operation.</param>
/// <param name="statusCode">Status code for response.</param>
/// <param name="requestManager">Used to construct the body of the response.</param>
/// <param name="contentType">The (optional) content type to be used for the operation content.</param>
/// <returns>The response encapsulating the <paramref name="payload"/>.</returns>
public static ODataResponse InResponseOperation <T>(
this T payload,
int statusCode,
IODataRequestManager requestManager,
string contentType = null) where T : PayloadTestDescriptor
{
ExceptionUtilities.CheckArgumentNotNull(payload, "payload");
ExceptionUtilities.CheckArgumentNotNull(statusCode, "statusCode");
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
var httpResponseData = new HttpResponseData
{
StatusCode = (HttpStatusCode)statusCode
};
httpResponseData.Headers.Add("GivenPayloadResponseHeader", "ResponseHeaderValue");
if (payload.PayloadElement != null)
{
if (string.IsNullOrEmpty(contentType))
{
contentType = payload.PayloadElement.GetDefaultContentType();
}
httpResponseData.Headers.Add(Microsoft.OData.Core.ODataConstants.ContentTypeHeader, contentType);
// Convert the payload element to the byte[] representation
httpResponseData.Body = requestManager.BuildBody(contentType, /*ODataUri*/ null, payload.PayloadElement).SerializedValue;
}
return(new ODataResponse(httpResponseData)
{
RootElement = payload.PayloadElement
});
}
/// <summary>
/// Puts payload in a batch response.
/// </summary>
/// <typeparam name="T">T must be a PayloadTestDescriptor.</typeparam>
/// <param name="originalPayload">Payload to be inserted into batch.</param>
/// <param name="statusCode">Status code associated with payload</param>
/// <param name="random">Use of random makes this method non deterministic</param>
/// <param name="requestManager">Used to construct the response payload.</param>
/// <param name="inChangeset">Specifies whether this is in a changeset or an operation.</param>
/// <param name="operationsBefore">Number of operations/changesets to go before payload.</param>
/// <param name="operationsAfter">Number of operations/changesets to go after payload.</param>
/// <param name="version">Maximum version for extra generated payloads</param>
/// <returns>Test descriptor for the new BatchResponsePayload.</returns>
public static T InBatchResponse <T>(
this T originalPayload,
int statusCode,
IRandomNumberGenerator random,
IODataRequestManager requestManager,
bool inChangeset = false,
int operationsBefore = 0,
int operationsAfter = 0,
ODataVersion version = ODataVersion.V4
) where T : PayloadTestDescriptor
{
ExceptionUtilities.CheckArgumentNotNull(originalPayload, "originalPayload");
ExceptionUtilities.CheckArgumentNotNull(statusCode, "statusCode");
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
var payload = (T)originalPayload.Clone();
var headers = new Dictionary <string, string> {
{ "ResponseHeader", "ResponseValue" }
};
var baseUri = new ODataUri(ODataUriBuilder.Root(new Uri("http://www.odata.org/service.svc")));
IMimePart[] extraoperations = BatchUtils.ExtraResponseChangesets(random, (EdmModel)payload.PayloadEdmModel, version); // add extraChangesets methods
extraoperations.Concat(BatchUtils.ExtraResponseOperations(random, (EdmModel)payload.PayloadEdmModel, version));
//Work out the operations and changesets to go before the payload
var parts = Enumerable.Range(0, operationsBefore).Select(i => random.ChooseFrom(extraoperations));
if (!inChangeset)
{
extraoperations.ConcatSingle(payload.InResponseOperation(statusCode, requestManager));
}
else
{
extraoperations.ConcatSingle(payload.InResponseChangeset(statusCode, random, requestManager, random.NextFromRange(0, 2), random.NextFromRange(0, 2), version));
}
parts.Concat(Enumerable.Range(0, operationsAfter).Select(i => random.ChooseFrom(extraoperations)));
var batchResponse = new BatchResponsePayload();
foreach (var part in parts)
{
HttpResponseData operation = part as HttpResponseData;
if (operation != null)
{
batchResponse.Add(operation.AsBatchFragment());
}
BatchResponseChangeset changeset = part as BatchResponseChangeset;
if (changeset != null)
{
batchResponse.Add(changeset);
}
}
//payload.PayloadEdmModel.Fixup();
payload.PayloadElement = batchResponse;
return(payload);
}
private HttpResponseData CheckRequestSuccessInsert(HttpRequestData r)
{
if (r.Path != "/query")
{
throw new Exception("Wrong path!");
}
var response = new HttpResponseData();
if (r.Data.Contains("token: \"77a5e3fad4d2646594fc12e67d2b6590e30df81f\""))
{
if (r.Data.Contains("query: \"SELECT ?val FROM <https://carre.kmi.open.ac.uk/users/MindaugasB> WHERE { <https://carre.kmi.open.ac.uk/users/MindaugasB/measurements/vivaport_635692320000000000>"))
{
response.StatusCode = System.Net.HttpStatusCode.OK;
}
if (r.Data.Contains("query: \"INSERT DATA { GRAPH <https://carre.kmi.open.ac.uk/users/MindaugasB> { <https://carre.kmi.open.ac.uk/users/MindaugasB/measurements/vivaport_635692320000000000> <http://www.w3.org/2000/01/rdf-schema#type> :individual_test1_measurement .\n"))
{
response.StatusCode = System.Net.HttpStatusCode.OK;
response.Data = "OK";
response.ContentLength = 1;
}
}
else
{
response.StatusCode = System.Net.HttpStatusCode.InternalServerError;
}
return(response);
}
/// <summary>
/// Visits the root element of the operation.
/// </summary>
/// <param name="operation">The operation to visit</param>
protected override void VisitResponseOperation(HttpResponseData operation)
{
var responseOperation = operation as ODataResponse;
ExceptionUtilities.CheckObjectNotNull(responseOperation, "Operation must be a response");
ODataPayloadElement rootElement = null;
string contentType = null;
if (responseOperation.RootElement != null)
{
rootElement = responseOperation.RootElement;
contentType = responseOperation.GetHeaderValueIfExists(Microsoft.OData.ODataConstants.ContentTypeHeader);
}
if (rootElement != null)
{
ODataFormat format = null;
if (contentType.Contains(MimeTypes.ApplicationJson))
{
format = ODataFormat.Json;
}
new ExpectedPayloadFixups().Fixup(rootElement, format);
}
}
/// <summary>
/// Set an exception to an HTTP output response
/// </summary>
/// <param name="ex"></param>
/// <param name="response"></param>
/// <param name="jsonOptions"></param>
public static void SetExceptionToHttpResponse(
Exception ex, HttpResponseData response, JsonSerializerOptions jsonOptions)
{
string error = "InternalError";
if (ex is IndexOutOfRangeException iorex)
{
error = "BadId";
response.StatusCode = System.Net.HttpStatusCode.BadRequest;
}
else if (ex is KeyNotFoundException nfex)
{
error = "NotFound";
response.StatusCode = System.Net.HttpStatusCode.NotFound;
}
else
{
response.StatusCode = System.Net.HttpStatusCode.InternalServerError;
}
var stringBody = JsonSerializer.Serialize(new
{
Error = error,
ex.Message
}, jsonOptions);
response.WriteString(stringBody);
}
public async Task <ActionResult <HttpResponseData <SuccessfulLoginRespModel, ClientsApiErrorCodes> > > SigninFacialRecognition([FromBody] LoginFacialRequestModel input)
{
HttpResponseData <SuccessfulLoginRespModel, ClientsApiErrorCodes> response = await _authServices.FacialRecognition(input);
if (response.Success == true)
{
return(Ok(response));
}
ClientsApiErrorCodes val = response.Error.ErrorCode;
switch (val)
{
case ClientsApiErrorCodes.NotExistingUser:
goto NotExistingUserCase;
case ClientsApiErrorCodes.BiometricAuthenticationFailure:
goto BiometricAuthenticationFailureCase;
case ClientsApiErrorCodes.FlaskFaceAuthInternalError:
goto FlaskInternalErrorCase;
}
NotExistingUserCase : return(StatusCode(StatusCodes.Status500InternalServerError, new HttpResponseData <SuccessfulLoginRespModel, ClientsApiErrorCodes>(ClientsApiErrorCodes.NotExistingUser)));
BiometricAuthenticationFailureCase : return(StatusCode(StatusCodes.Status500InternalServerError, new HttpResponseData <SuccessfulLoginRespModel, ClientsApiErrorCodes>(ClientsApiErrorCodes.BiometricAuthenticationFailure)));
FlaskInternalErrorCase : return(StatusCode(StatusCodes.Status500InternalServerError, new HttpResponseData <SuccessfulLoginRespModel, ClientsApiErrorCodes>(ClientsApiErrorCodes.FlaskFaceAuthInternalError)));
}
/// <summary>
/// Asynchronously continues an intercepted network request.
/// </summary>
/// <param name="requestData">The <see cref="HttpRequestData"/> of the request.</param>
/// <param name="responseData">The <see cref="HttpResponseData"/> with which to respond to the request</param>
/// <returns>A task that represents the asynchronous operation.</returns>
public override async Task ContinueRequest(HttpRequestData requestData, HttpResponseData responseData)
{
var commandSettings = new FulfillRequestCommandSettings()
{
RequestId = requestData.RequestId,
ResponseCode = responseData.StatusCode,
};
if (responseData.Headers.Count > 0)
{
List <HeaderEntry> headers = new List <HeaderEntry>();
foreach (KeyValuePair <string, string> headerPair in responseData.Headers)
{
headers.Add(new HeaderEntry()
{
Name = headerPair.Key, Value = headerPair.Value
});
}
commandSettings.ResponseHeaders = headers.ToArray();
}
if (!string.IsNullOrEmpty(responseData.Body))
{
commandSettings.Body = Convert.ToBase64String(Encoding.UTF8.GetBytes(responseData.Body));
}
await fetch.FulfillRequest(commandSettings);
}
/// <summary>
/// Asynchronously contines an intercepted network response without modification.
/// </summary>
/// <param name="responseData">The <see cref="HttpResponseData"/> of the network response.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
public override async Task ContinueResponseWithoutModification(HttpResponseData responseData)
{
await fetch.ContinueRequest(new ContinueRequestCommandSettings()
{
RequestId = responseData.RequestId
});
}
/// <summary>
/// Initializes a new instance of the HttpResponse class using the status code and headers given, and by reading from the given stream
/// </summary>
/// <param name="statusCode">The status code for the response</param>
/// <param name="headers">The headers for the response</param>
/// <param name="bodyStream">The underlying response body stream</param>
/// <returns>The http response</returns>
public static HttpResponseData BuildResponse(HttpStatusCode statusCode, IDictionary<string, string> headers, Stream bodyStream)
{
ExceptionUtilities.CheckArgumentNotNull(headers, "headers");
ExceptionUtilities.CheckArgumentNotNull(bodyStream, "bodyStream");
var response = new HttpResponseData();
response.StatusCode = statusCode;
foreach (var header in headers)
{
response.Headers.Add(header.Key, header.Value);
}
// get the content length from the headers, using -1 to indicate that it is not known
int contentLength = -1;
if (headers.ContainsKey(HttpHeaders.ContentLength))
{
// note that numbers greater than int.MaxValue will not be parsed,
// and so we will read as if we did not know the length
if (!int.TryParse(headers[HttpHeaders.ContentLength], out contentLength))
{
contentLength = -1;
}
}
// Empty could also be null, but this is nicer to work with
if (contentLength == 0)
{
response.Body = new byte[0];
}
else
{
// create an in-memory stream to store the body. if the length is known, pre-allocate the space
MemoryStream tempStream;
if (contentLength > 0)
{
tempStream = new MemoryStream(contentLength);
}
else
{
tempStream = new MemoryStream();
}
using (tempStream)
{
// copy blocks into the in-memory stream until read() returns -1
int read;
byte[] buffer = new byte[BufferSize];
while ((read = bodyStream.Read(buffer, 0, buffer.Length)) > 0)
{
tempStream.Write(buffer, 0, read);
}
// save the bytes in the in-memory stream
response.Body = tempStream.ToArray();
}
}
return response;
}
static async Task Main(string[] args)
{
Console.WriteLine("Azure Cosmos Table Samples");
string baseurl = @"https://vsdatalp5wlk3s5zotgic.table.core.windows.net/";
//Console.WriteLine("pls input table name:");
string tbname = "demo123";//Console.ReadLine();
//You can find in portal
string sastoken = @"<sas-token>";
string filter = @"&$filter=PartitionKey%20eq%20'Harp'%20";
baseurl = baseurl + tbname + "()" + sastoken + filter;
HttpResponseData data = GetForOData(baseurl);
string responseData = data.Data.Replace(".", "_");
ODataResponse odata = JsonConvert.DeserializeObject <ODataResponse>(responseData);
foreach (ODatavalue m in odata.value)
{
Console.WriteLine(m.PartitionKey + " " + m.PhoneNumber + " " + m.RowKey + " " + m.Email);
}
Console.WriteLine("Press any key to exit");
Console.Read();
//var list1 = linqQuery1.AsQueryable();
}
/// <summary>
/// Visits the root element of the operation.
/// </summary>
/// <param name="operation">The operation to visit</param>
protected override void VisitResponseOperation(HttpResponseData operation)
{
var responseOperation = operation as ODataResponse;
ExceptionUtilities.CheckObjectNotNull(responseOperation, "Operation must be a response");
ODataPayloadElement rootElement = null;
string contentType = null;
if (responseOperation.RootElement != null)
{
rootElement = responseOperation.RootElement;
contentType = responseOperation.GetHeaderValueIfExists(Microsoft.OData.Core.ODataConstants.ContentTypeHeader);
}
if (rootElement != null)
{
ODataFormat format = null;
if (contentType.Contains(MimeTypes.ApplicationAtomXml))
{
format = ODataFormat.Atom;
}
else if (contentType.Contains(MimeTypes.ApplicationJson))
{
format = ODataFormat.Json;
}
new ExpectedPayloadFixups().Fixup(rootElement, format);
}
}
/// <summary>
/// Replaces operation if payload is updated
/// </summary>
/// <param name="operation">Operation to visit</param>
protected virtual void VisitResponseOperation(HttpResponseData operation)
{
var responseOperation = operation as ODataResponse;
if (responseOperation.RootElement != null)
{
this.Recurse(responseOperation.RootElement);
}
}
/// <summary>
/// 引数 <paramref name="responceFunctions"/> からローカルHTTPサーバで動作させる
/// レスポンス処理を生成し取得する
/// </summary>
/// <param name="responceFunctions">
/// 音声認識した文字に対する処理の指定（複数指定可、優先順位は上から）
/// ・引数1 string：音声認識した文字列を渡す
/// ・戻り値 byte[]：処理を実行した結果返却するデータ
/// </param>
/// <param name="postRegex">
/// 「音声認識用.html」において、音声認識認識した文字列をPOSTする際に使用するURLの正規表現
/// （「音声認識用.html」と整合性をとる必要があるパラメータ）
/// </param>
/// <param name="postParamName">
/// 「音声認識用.html」において、音声認識認識した文字列をPOSTする際に使用する
/// POSTデータのパラメータ名
/// （「音声認識用.html」と整合性をとる必要があるパラメータ）
/// </param>
/// <exception cref="ArgumentNullException">
/// 引数の <paramref name="postRegex"/> がNULLの場合に発生
/// </exception>
/// <exception cref="ArgumentException">
/// 引数の <paramref name="postRegex"/> が正規表現として不正な値の場合に発生
/// </exception>
/// <returns>
/// 生成したローカルHTTPサーバで動作させるレスポンス処理
/// 引数 <paramref name="responceFunctions"/> の値がNULLの場合はNULLをそのまま返却
/// </returns>
private static LocalHttpServerResponceProcess[] GetResponceProcesses(
Func <string, byte[]>[] responceFunctions,
string postRegex,
string postParamName)
{
// 引数チェック
if (responceFunctions == null)
{
// responceActionsの値がNULLの場合はNULLをそのまま返却
return(null);
}
else if (postRegex == null)
{
throw new ArgumentNullException(nameof(postRegex));
}
// 戻り値の配列を生成（要素数は引数と同じになる）
LocalHttpServerResponceProcess[] responceProcesses
= new LocalHttpServerResponceProcess[responceFunctions.Length];
// 引数の配列でループ
for (int i = 0; i < responceFunctions.Length; i++)
{
// 対象の処理を取得
Func <string, byte[]> function = responceFunctions[i];
// レスポンスデータを扱うクラスを生成
HttpResponseData httpResponseData = new HttpResponseData(
mimeType: "text/html",
setStream: (Stream stream, HttpListenerRequest request) =>
{
// POSTデータの受け取り
NameValueCollection postData = LocalHttpServerCommon.GetPostData(request);
// 処理
string voiceTxt = postData[postParamName];
byte[] responseData = null;
if (!string.IsNullOrEmpty(voiceTxt))
{
responseData = function(voiceTxt);
}
// レスポンスデータをレスポンス用のStreamに格納し返却する
return(LocalHttpServerCommon.GetDataResponse(
responseData ?? new byte[0], "text/html").SetStream(stream, request));
});
// ローカルHTTPサーバで動作させるレスポンス処理のクラスを生成し戻り値の配列に設定する
responceProcesses[i] = new LocalHttpServerResponceProcess(
method: System.Net.Http.HttpMethod.Post,
processName: postRegex,
responseData: httpResponseData);
}
// 生成した配列を返却する
return(responceProcesses);
}
// PREVIEW: setting stuff via Reflection is bad.
private static void SetRequestResponse(FunctionContext context, HttpResponseData response)
{
var keyValuePair = context.Features.SingleOrDefault(f => f.Key.Name == "IFunctionBindingsFeature");
var functionBindingsFeature = keyValuePair.Value;
var type = functionBindingsFeature.GetType();
var result = type.GetProperties().Single(p => p.Name == "InvocationResult");
result.SetValue(functionBindingsFeature, response);
}
public ODataResponse GetResponse(ODataRequest request)
{
ExceptionUtilities.CheckArgumentNotNull(request, "request");
ExceptionUtilities.CheckAllRequiredDependencies(this);
HttpResponseData underlyingResponse = this.HttpImplementation.GetResponse(request);
return(this.BuildResponse(request, underlyingResponse));
}
/// <summary>
/// Build QueryValue from query expresion and server response.
/// </summary>
/// <param name="expression">The query expresion of client request.</param>
/// <param name="response">The http response from the server.</param>
/// <returns>The baseline QueryValue converted from payload.</returns>
public QueryValue BuildQueryValue(QueryExpression expression, HttpResponseData response)
{
ExceptionUtilities.CheckArgumentNotNull(expression, "expression");
ExceptionUtilities.CheckArgumentNotNull(response, "response");
ExceptionUtilities.CheckAllRequiredDependencies(this);
// get type resolver and payload deserializer.
var typeResolver = new LinqToAstoriaTypeResolutionVisitor(this.TypeLibrary);
// if the response has an error
if (response.StatusCode != HttpStatusCode.OK)
{
return(expression.ExpressionType.CreateErrorValue(new QueryError("Response from server has an error!")));
}
string contentType;
ExceptionUtilities.Assert(response.Headers.TryGetValue(HttpHeaders.ContentType, out contentType), "Cannot get content type from response.");
var deserializer = this.StrategySelector.GetStrategy(contentType, null).GetDeserializer();
this.currentExpression = expression;
var expressionForUri = this.ClientSideProjectionReplacer.ReplaceClientSideProjections(expression);
ODataUri queryUri = this.QueryToODataUriConverter.ComputeUri(expressionForUri);
queryUri.Segments.Insert(0, ODataUriBuilder.Root(this.Workspace.ServiceUri));
// deserialize byte array payload to OData payload element.
ODataPayloadElement payload = this.DeserializePayloadData(deserializer, response, queryUri);
this.PayloadElementMetadataResolver.ResolveMetadata(payload, queryUri);
var normalizer = this.StrategySelector.GetStrategy(contentType, null).GetPayloadNormalizer();
payload = normalizer.Normalize(payload);
if (this.ShouldUsePayloadDrivenVerification(queryUri))
{
return(this.BuildQueryValueForActionResponse(payload, expression.ExpressionType));
}
else
{
// build query data set from payload for evaluation. It's a different data set from the initial one of current workspace.
IQueryDataSet dataSet = this.BuildQueryDataSet(payload);
// filter the query and resolve types. Need to remove expressions such as $top, $skip, $orderby, $filter because the returned payload is already the result of performing these expressions.
// need to keep root expression, key expression, $expand and $select to have correct anonymous type.
var filteredQuery = this.FilterExpression(expression);
filteredQuery = typeResolver.ResolveTypes(filteredQuery, this.EvaluationStrategy);
// replace the evaluator's query-data-set with the one generated in the payload
using (this.Evaluator.WithTemporaryDataSet(dataSet))
{
return(this.Evaluator.Evaluate(filteredQuery));
}
}
}
private void HandleRequestResponsePair(DataServiceContext context, HttpRequestData request, HttpResponseData response)
{
ExceptionUtilities.CheckArgumentNotNull(context, "context");
ExceptionUtilities.CheckArgumentNotNull(request, "request");
ExceptionUtilities.CheckArgumentNotNull(response, "response");
this.Assert.AreSame(this.Input.Context, context, "Handle request/response pair called with unexpected context");
this.httpLog.Add(new KeyValuePair<HttpRequestData, HttpResponseData>(request, response));
}
/// <summary>
/// Verifies the headers present on the HTTP request
/// </summary>
/// <param name="context">The data service context</param>
/// <param name="request">The http request</param>
/// <param name="response">The http response</param>
public void HandleRequestResponsePair(DataServiceContext context, HttpRequestData request, HttpResponseData response)
{
#if !SILVERLIGHT || WIN8
this.VerifyPreferHeaderOnRequest(request, context.AddAndUpdateResponsePreference);
if (context.AddAndUpdateResponsePreference != DataServiceResponsePreference.None && this.IsCreateOrUpdate(request.GetEffectiveVerb()))
{
this.VerifyVersionHeaders(request);
}
#endif
}
public static TElement DeserializeAndCast <TElement>(this HttpResponseData response, IProtocolFormatStrategySelector selector) where TElement : ODataPayloadElement
{
ExceptionUtilities.CheckArgumentNotNull(response, "response");
// TODO: parse uri
string contentType;
ExceptionUtilities.Assert(response.TryGetHeaderValueIgnoreHeaderCase(HttpHeaders.ContentType, out contentType), "Cannot deserialize response. 'Content-Type' header not found");
return(DeserializeAndCast <TElement>(selector, null, contentType, response.Body));
}
public static HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestData req,
[Queue("functionstesting2", Connection = "AzureWebJobsStorage")] OutputBinding <string> name)
{
var response = new HttpResponseData(HttpStatusCode.OK);
response.Body = "Success!!";
name.SetValue("some name");
return(response);
}
/// <summary>
/// Initializes a new instance of the ODataResponse class. Copies information from given response, but does not maintain a reference to it.
/// </summary>
/// <param name="toCopy">The response to copy information from</param>
public ODataResponse(HttpResponseData toCopy)
{
ExceptionUtilities.CheckArgumentNotNull(toCopy, "toCopy");
this.StatusCode = toCopy.StatusCode;
foreach (var header in toCopy.Headers)
{
this.Headers.Add(header.Key, header.Value);
}
this.Body = toCopy.Body;
}
/// <summary>
/// Replaces operation if payload is updated
/// </summary>
/// <param name="operation">Operation to visit</param>
protected override void VisitResponseOperation(HttpResponseData operation)
{
base.VisitResponseOperation(operation);
var responseOperation = operation as ODataResponse;
if (responseOperation.RootElement != null)
{
responseOperation.RootElement = this.applyExpectedResultNormalizers(responseOperation.RootElement, this.GetOperationTestConfiguration(operation));
}
}
/// <summary>
/// Initializes a new instance of the ODataResponse class. Copies information from given response, but does not maintain a reference to it.
/// </summary>
/// <param name="toCopy">The response to copy information from</param>
public ODataResponse(HttpResponseData toCopy)
{
ExceptionUtilities.CheckArgumentNotNull(toCopy, "toCopy");
this.StatusCode = toCopy.StatusCode;
foreach (var header in toCopy.Headers)
{
this.Headers.Add(header.Key, header.Value);
}
this.Body = toCopy.Body;
}
/// <summary>
/// Constructs an OData response to the given request using the given response data
/// </summary>
/// <param name="request">The odata request that was made</param>
/// <param name="underlyingResponse">The response data</param>
/// <returns>An odata response</returns>
public ODataResponse BuildResponse(ODataRequest request, HttpResponseData underlyingResponse)
{
ExceptionUtilities.CheckArgumentNotNull(request, "request");
ExceptionUtilities.CheckArgumentNotNull(underlyingResponse, "underlyingResponse");
ODataResponse odataResponse = new ODataResponse(underlyingResponse);
if (request.Uri.IsBatch())
{
ExceptionUtilities.CheckObjectNotNull(request.Body, "Batch request had no body");
var batchRequestPayload = request.Body.RootElement as BatchRequestPayload;
ExceptionUtilities.CheckObjectNotNull(batchRequestPayload, "Batch request body was not a valid batch payload");
this.ExecuteAndCatchErrors(request, odataResponse, () => odataResponse.RootElement = this.BatchDeserializer.DeserializeBatchResponse(batchRequestPayload, underlyingResponse));
return(odataResponse);
}
string contentType;
if (underlyingResponse.TryGetHeaderValueIgnoreHeaderCase(HttpHeaders.ContentType, out contentType))
{
IProtocolFormatStrategy strategy = this.FormatSelector.GetStrategy(contentType, request.Uri);
ExceptionUtilities.CheckObjectNotNull(strategy, "Strategy selector did not return a strategy for content type '{0}'", contentType);
IPayloadDeserializer deserializer = strategy.GetDeserializer();
ExceptionUtilities.CheckObjectNotNull(deserializer, "Strategy returned a null deserializer");
this.ExecuteAndCatchErrors(
request,
odataResponse,
() =>
{
var payloadContext = ODataPayloadContext.BuildPayloadContextFromRequest(request);
payloadContext.ContentType = contentType;
payloadContext.EncodingName = HttpUtilities.GetContentTypeCharsetOrNull(contentType);
odataResponse.RootElement = deserializer.DeserializeFromBinary(odataResponse.Body, payloadContext);
if (ShouldResolveMetadata(request.Uri, odataResponse.StatusCode, odataResponse.RootElement.ElementType))
{
// resolve the payload's metadata
this.MetadataResolver.ResolveMetadata(odataResponse.RootElement, request.Uri);
// normalize the payload
var normalizer = strategy.GetPayloadNormalizer();
ExceptionUtilities.CheckObjectNotNull(normalizer, "Strategy returned a null payload normalizer");
odataResponse.RootElement = normalizer.Normalize(odataResponse.RootElement);
}
});
}
return(odataResponse);
}
/// <summary>
/// 操作调用
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Method"></param>
/// <param name="url"></param>
/// <param name="Id"></param>
/// <param name="Data"></param>
/// <returns></returns>
private static HttpResponseData Invoke <T>(String Method, String url, Object Id, T Data, string accessToken)
{
HttpResponseData Response = new HttpResponseData()
{
Code = HttpStatusCode.RequestTimeout,
Data = String.Empty,
Message = String.Empty,
};
try
{
String PostParam = String.Empty;
if (Data != null)
{
PostParam = JsonConvert.SerializeObject(Data);
}
byte[] postData = Encoding.UTF8.GetBytes(PostParam);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(new Uri(url + (Id == null ? "" : '/' + Id.ToString())));
request.Method = Method;
if (!string.IsNullOrEmpty(accessToken))
{
string authorization = "{0} {1}";
authorization = string.Format(authorization, "Bearer", accessToken);
request.Headers.Add("Authorization", authorization);
}
request.ServicePoint.Expect100Continue = false;
request.Timeout = HttpRequestTimeOut;
request.Accept = "application/json";
request.ContentType = "application/json";
request.ContentLength = postData.Length;
if (postData.Length > 0)
{
request.GetRequestStream().Write(postData, 0, postData.Length);
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Response.Code = response.StatusCode;
using (StreamReader stream = new StreamReader(response.GetResponseStream(), Encoding.Default))
{
Response.Data = stream.ReadToEnd();
}
}
}
catch (Exception ex)
{
Response.Message = ex.Message;
}
return(Response);
}
private void WriteResponse(HttpResponseData response)
{
this.writer.WriteLine(response.GetFirstLine());
this.WriteHeaders(response);
var responseBody = response.Body;
this.WriteRequestOrResponseBody(responseBody);
this.writer.Flush();
}
public HttpResponseData ProcessRequest(HttpRequestData httpRequest)
{
var response = new HttpResponseData(HttpStatusCode.OK);
var headers = new Dictionary <string, string>();
headers.Add("Date", "Mon, 18 Jul 2016 16:06:00 GMT");
headers.Add("Content", "Content - Type: text / html; charset = utf - 8");
response.Headers = headers;
response.Body = "Welcome to .NET 5!!";
return(response);
}
private static string GetStringResult(HttpResponseData data)
{
var count = data.Body.Length;
if (count > 0)
{
byte[] byteData = new byte[count];
data.Body.Position = 0;
data.Body.Read(byteData, 0, (int)count);
return(Encoding.UTF8.GetString(byteData));
}
return(null);
}
private static HttpResponseData InvokeForOData <T>(String Method, String url, Object Id, T Data)
{
HttpResponseData Response = new HttpResponseData()
{
Code = HttpStatusCode.RequestTimeout,
Data = String.Empty,
Message = String.Empty,
};
try
{
String PostParam = String.Empty;
if (Data != null)
{
PostParam = Data.ToString();//Newtonsoft.Json.JsonConvert.SerializeObject(Data);
}
byte[] postData = Encoding.UTF8.GetBytes(PostParam);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(new Uri(url + (Id == null ? "" : '/' + Id.ToString())));
request.Method = Method;
request.ServicePoint.Expect100Continue = false;
request.Timeout = HttpRequestTimeOut;
request.ContentType = "application/json";
request.ContentLength = postData.Length;
DateTime now = DateTime.UtcNow;
request.Headers.Add("x-ms-date", now.ToString("R", CultureInfo.InvariantCulture));
request.Headers.Add("x-ms-version", "2019-07-07");
request.Headers.Add("Accept", "application/json;odata=fullmetadata");
if (postData.Length > 0)
{
using (Stream requestStream = request.GetRequestStream())
{
requestStream.Write(postData, 0, postData.Length);
}
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Response.Code = response.StatusCode;
using (StreamReader stream = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
{
Response.Data = stream.ReadToEnd();
}
}
}
catch (Exception ex)
{
Response.Message = ex.Message;
}
return(Response);
}
internal static HttpResponseData CreateResponse(byte[] body, Encoding encoding)
{
var response = new HttpResponseData();
var statusLine = ReadLine(ref body, encoding);
var statusSections = statusLine.Split(' ');
ExceptionUtilities.Assert(statusSections.Length >= 3, "Response status line was malformed: '{0}'", statusLine);
response.StatusCode = (HttpStatusCode)Enum.Parse(typeof(HttpStatusCode), statusSections[1], false);
PopulateHeadersAndBody(response, body, encoding);
return(response);
}
/// <summary>
/// Converts an ODataBatchOperation to the corresponding IMimePart.
/// </summary>
/// <param name="operation">The operation to convert.</param>
/// <returns>The converted operation.</returns>
private IMimePart ConvertBatchOperation(ODataBatchOperation operation)
{
ODataPayloadElement payloadElement = operation.Payload == null ? null : this.Visit(operation.Payload);
if (this.response)
{
ODataBatchResponseOperation responseOperation = (ODataBatchResponseOperation)operation;
HttpResponseData httpResponse = new HttpResponseData
{
StatusCode = (HttpStatusCode)responseOperation.StatusCode,
};
if (responseOperation.Headers != null)
{
foreach (var kvp in responseOperation.Headers)
{
httpResponse.Headers.Add(kvp.Key, kvp.Value);
}
}
;
return(new ODataResponse(httpResponse)
{
RootElement = payloadElement
});
}
ODataBatchRequestOperation requestOperation = (ODataBatchRequestOperation)operation;
// NOTE: this is abusing the ODataUriBuilder but is sufficient for our purposes
// We use Unrecognized because the request URI may be relative (in the case of a reference)
ODataUri requestUri = new ODataUri(ODataUriBuilder.Unrecognized(requestOperation.Url.OriginalString));
ODataRequest request = this.requestManager.BuildRequest(
requestUri,
(HttpVerb)Enum.Parse(typeof(HttpVerb), requestOperation.HttpMethod, /*ignoreCase*/ true),
requestOperation.Headers);
if (payloadElement != null)
{
string contentType;
if (!request.Headers.TryGetValue(Microsoft.OData.ODataConstants.ContentTypeHeader, out contentType))
{
throw new InvalidOperationException("ContentType header not found.");
}
request.Body = this.requestManager.BuildBody(contentType, requestUri, payloadElement);
}
return(request);
}
public string Get(int id)
{
HttpResponseData response = new HttpResponseData();
List<UserDataModel> users = service.GetUsers(id);
if(users.Count > 0)
{
response.Request = id;
response.Data = users[0];
response.Message = "Successfully did the thing.";
}
return JsonConvert.SerializeObject(response);
//return JsonConvert.SerializeObject(service.GetUsers(id));
}
/// <summary>
/// Asynchronously adds the response body to the provided <see cref="HttpResponseData"/> object.
/// </summary>
/// <param name="responseData">The <see cref="HttpResponseData"/> object to which to add the response body.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
public override async Task AddResponseBody(HttpResponseData responseData)
{
var bodyResponse = await fetch.GetResponseBody(new Fetch.GetResponseBodyCommandSettings()
{
RequestId = responseData.RequestId
});
if (bodyResponse.Base64Encoded)
{
responseData.Body = Encoding.UTF8.GetString(Convert.FromBase64String(bodyResponse.Body));
}
else
{
responseData.Body = bodyResponse.Body;
}
}
/// <summary>
/// 判断返回值
/// </summary>
/// <param name="res"></param>
/// <returns></returns>
private static dynamic ReturnResult(HttpResponseData res)
{
var result = res.Result.Trim();
var obj = JsonHelper.FromJson <dynamic>(result);
if (obj.error != null)
{
string error = JsonHelper.ToJson(obj.error);
throw new Exception(error);
}
else
{
return(obj.data);
}
}
private string ReadResponseBody(HttpResponseData response)
{
if (response.Body is MemoryStream stream)
{
if (stream.Position != 0)
{
stream.Position = 0;
}
using (StreamReader reader = new StreamReader(stream))
{
return(reader.ReadToEnd());
}
}
return(null);
}
protected override void VisitResponseOperation(HttpResponseData operation)
{
var responseOperation = operation as ODataResponse;
ExceptionUtilities.CheckObjectNotNull(responseOperation, "Operation must be a response");
ODataPayloadElement rootElement = null;
string contentType = null;
if (responseOperation.RootElement != null)
{
rootElement = responseOperation.RootElement;
contentType = responseOperation.GetHeaderValueIfExists(Microsoft.OData.Core.ODataConstants.ContentTypeHeader);
}
if (rootElement != null)
{
this.resolver.ResolveMetadata(rootElement, this.BuildODataUri(rootElement));
this.selector.GetNormalizer(contentType);
}
}
/// <summary>
/// Generates the raw test message with mixed encodings defined by the test case, as well as the expected ODataPayloadElement.
/// </summary>
/// <param name="testCase">The test case defining the structure and encodings of the batch payload.</param>
/// <param name="payload">The payload to use for all generated batch operations.</param>
/// <param name="payloadUri">The URI to use for all generated batch operations.</param>
/// <param name="isRequest">If true, generates a batch request, otherwise a batch response.</param>
/// <returns>The test descriptor for this test case/configuration.</returns>
private BatchReaderMixedEncodingTestDescriptor CreateTestDescriptor(BatchReaderMixedEncodingTestCase testCase, ODataPayloadElement payload, ODataUri payloadUri, bool isRequest)
{
ExceptionUtilities.Assert(testCase.BatchEncoding != null, "Batch encoding has not been specified.");
string batchBoundary = "batch_" + Guid.NewGuid().ToString();
string payloadUriString = this.UriConverter.ConvertToString(payloadUri);
var batchPayload = isRequest ? (ODataPayloadElement)new BatchRequestPayload() : (ODataPayloadElement)new BatchResponsePayload();
batchPayload.AddAnnotation(new BatchBoundaryAnnotation(batchBoundary));
var rawMessage = new List<byte>();
// TODO: Batch reader does not support multi codepoint encodings
Encoding unsupportedEncoding = AsUnsupportedEncoding(testCase.BatchEncoding);
foreach (var changeset in testCase.Changesets)
{
string changesetBoundary = "change_" + Guid.NewGuid().ToString();
Encoding changesetEncoding = changeset.ChangesetEncoding ?? testCase.BatchEncoding;
// TODO: Batch reader does not support multi codepoint encodings
unsupportedEncoding = unsupportedEncoding ?? AsUnsupportedEncoding(changesetEncoding);
string changesetContentType = HttpUtilities.BuildContentType(
MimeTypes.MultipartMixed,
changeset.ChangesetEncoding == null ? string.Empty : changeset.ChangesetEncoding.WebName,
changesetBoundary);
rawMessage.AddRange(
WriteMessagePart(
testCase.BatchEncoding,
(writer) =>
{
writer.Write("--");
writer.WriteLine(batchBoundary);
writer.WriteLine(HttpHeaders.ContentType + ": " + changesetContentType);
writer.WriteLine();
}));
var mimeParts = new List<IMimePart>();
int contentId = 0;
foreach (var operation in changeset.Operations)
{
ExceptionUtilities.Assert(operation.PayloadFormat == ODataFormat.Atom || operation.PayloadFormat == ODataFormat.Json, "Payload format must be ATOM or JSON.");
string formatType = MimeTypes.ApplicationAtomXml + ";type=entry";
Encoding payloadEncoding = operation.OperationEncoding ?? changesetEncoding;
string payloadContentType = HttpUtilities.BuildContentType(
formatType,
operation.OperationEncoding == null ? string.Empty : operation.OperationEncoding.WebName,
string.Empty);
string httpStatus = isRequest ? "POST " + payloadUriString + " HTTP/1.1" : "HTTP/1.1 201 Created";
rawMessage.AddRange(
WriteMessagePart(
changesetEncoding,
(writer) =>
{
writer.WriteLine();
writer.Write("--");
writer.WriteLine(changesetBoundary);
writer.WriteLine(HttpHeaders.ContentType + ": application/http");
writer.WriteLine(HttpHeaders.ContentTransferEncoding + ": binary");
writer.WriteLine(HttpHeaders.ContentId + ": " + (++contentId).ToString());
writer.WriteLine();
writer.WriteLine(httpStatus);
writer.WriteLine(HttpHeaders.ContentType + ": " + payloadContentType);
writer.WriteLine();
}));
IPayloadSerializer payloadSerializer =
operation.PayloadFormat == ODataFormat.Atom ?
(IPayloadSerializer)new XmlPayloadSerializer(this.PayloadElementToXmlConverter) :
(IPayloadSerializer)new JsonPayloadSerializer(this.PayloadElementToJsonConverter.ConvertToJson);
byte[] payloadBytes = payloadSerializer.SerializeToBinary(payload, payloadEncoding.WebName);
rawMessage.AddRange(payloadBytes.Skip(payloadEncoding.GetPreamble().Length));
if (isRequest)
{
var request = this.RequestManager.BuildRequest(payloadUri, HttpVerb.Post, new Dictionary<string, string> { { HttpHeaders.ContentType, payloadContentType } });
request.Body = new ODataPayloadBody(payloadBytes, payload);
mimeParts.Add(request);
}
else
{
var httpResponseData = new HttpResponseData { StatusCode = HttpStatusCode.Created, };
httpResponseData.Headers.Add(HttpHeaders.ContentType, payloadContentType);
var response = new ODataResponse(httpResponseData) { Body = payloadBytes, RootElement = payload };
mimeParts.Add(response);
}
}
rawMessage.AddRange(
WriteMessagePart(
changesetEncoding,
(writer) =>
{
writer.WriteLine();
writer.Write("--");
writer.Write(changesetBoundary);
writer.WriteLine("--");
}));
if (isRequest)
{
((BatchRequestPayload)batchPayload).Add(BatchPayloadBuilder.RequestChangeset(changesetBoundary, changesetEncoding.WebName, mimeParts.ToArray()));
}
else
{
((BatchResponsePayload)batchPayload).Add(BatchPayloadBuilder.ResponseChangeset(changesetBoundary, changesetEncoding.WebName, mimeParts.ToArray()));
}
}
rawMessage.AddRange(
WriteMessagePart(
testCase.BatchEncoding,
(writer) =>
{
writer.WriteLine();
writer.Write("--");
writer.Write(batchBoundary);
writer.WriteLine("--");
}));
return new BatchReaderMixedEncodingTestDescriptor(this.PayloadReaderSettings)
{
BatchContentTypeHeader = HttpUtilities.BuildContentType(MimeTypes.MultipartMixed, testCase.BatchEncoding.WebName, batchBoundary),
RawMessage = rawMessage.ToArray(),
PayloadElement = batchPayload,
ExpectedException = unsupportedEncoding == null ? null : ODataExpectedExceptions.ODataException("ODataBatchReaderStream_MultiByteEncodingsNotSupported", unsupportedEncoding.WebName)
};
}
internal static HttpResponseData CreateResponse(byte[] body, Encoding encoding)
{
var response = new HttpResponseData();
var statusLine = ReadLine(ref body, encoding);
var statusSections = statusLine.Split(' ');
ExceptionUtilities.Assert(statusSections.Length >= 3, "Response status line was malformed: '{0}'", statusLine);
response.StatusCode = (HttpStatusCode)Enum.Parse(typeof(HttpStatusCode), statusSections[1], false);
PopulateHeadersAndBody(response, body, encoding);
return response;
}
/// <summary>
/// Deserializes the given response's binary payload into a batch payload
/// </summary>
/// <param name="requestPayload">The batch request payload that corresponds to the request</param>
/// <param name="response">The response to deserialize</param>
/// <returns>The deserialized batch response payload</returns>
public BatchResponsePayload DeserializeBatchResponse(BatchRequestPayload requestPayload, HttpResponseData response)
{
var encoding = HttpUtilities.DefaultEncoding;
string charset;
if (response.TryGetMimeCharset(out charset))
{
encoding = Encoding.GetEncoding(charset);
}
MultipartMimeData<MimePartData<byte[]>> split;
ExceptionUtilities.Assert(TrySplitMimePart(response, encoding, out split), "Failed to split batch response body");
var batchResponse = new BatchResponsePayload();
var requestPartQueue = new Queue<IMimePart>(requestPayload.Parts);
foreach (var subPart in split.ToList())
{
MultipartMimeData<MimePartData<byte[]>> splitChangeset;
if (TrySplitMimePart(subPart, encoding, out splitChangeset))
{
ExceptionUtilities.Assert(requestPartQueue.Count > 0, "Response changeset did not line up anything in request");
var requestChangeset = requestPartQueue.Dequeue() as BatchRequestChangeset;
ExceptionUtilities.CheckObjectNotNull(requestChangeset, "Response changeset did not line up with a request changeset");
var requestsQueue = new Queue<IHttpRequest>(requestChangeset.Operations);
var changeset = new BatchResponseChangeset();
changeset.Headers.AddRange(splitChangeset.Headers);
foreach (var changesetPart in splitChangeset)
{
ExceptionUtilities.Assert(requestsQueue.Count > 0, "Response did not line up anything in request changeset");
changeset.Add(this.BuildResponseFromPart(changesetPart, requestsQueue.Dequeue(), encoding));
}
batchResponse.Add(changeset);
}
else
{
ExceptionUtilities.Assert(requestPartQueue.Count > 0, "Response did not line up anything in request");
var requestOperation = requestPartQueue.Dequeue() as MimePartData<IHttpRequest>;
ExceptionUtilities.CheckObjectNotNull(requestOperation, "Response operation did not line up with request operation");
batchResponse.Add(this.BuildResponseFromPart(subPart, requestOperation.Body, encoding));
}
}
return batchResponse;
}
private void UpdateResponse(DataServiceResponseData responseData, DescriptorData descriptor, HttpResponseData response)
{
var operationResponse = new ChangeOperationResponseData(descriptor);
operationResponse.StatusCode = (int)response.StatusCode;
foreach (var header in response.Headers)
{
operationResponse.Headers.Add(header.Key, header.Value);
}
responseData.Add(operationResponse);
}
private void ApplyResponseToDescriptor(DescriptorData descriptor, HttpResponseData response)
{
var entityDescriptor = descriptor as EntityDescriptorData;
var streamDescriptor = descriptor as StreamDescriptorData;
if (entityDescriptor != null)
{
if (entityDescriptor.IsMediaLinkEntry && entityDescriptor.DefaultStreamState == EntityStates.Modified)
{
// in this case (and only this case), the response headers apply to the stream itself
entityDescriptor.DefaultStreamDescriptor.UpdateFromHeaders(response.Headers);
}
else
{
entityDescriptor.UpdateFromHeaders(response.Headers);
}
if (response.StatusCode != HttpStatusCode.NoContent)
{
var entityInstance = response.DeserializeAndCast<EntityInstance>(this.parent.FormatSelector);
entityDescriptor.UpdateFromPayload(entityInstance, this.contextData.BaseUri);
}
if (entityDescriptor.IsMediaLinkEntry && entityDescriptor.DefaultStreamState != EntityStates.Unchanged)
{
this.VerifyStreamClosed(entityDescriptor.DefaultStreamDescriptor);
}
}
else
{
if (streamDescriptor != null)
{
streamDescriptor.UpdateFromHeaders(response.Headers);
this.VerifyStreamClosed(streamDescriptor);
}
else
{
ExceptionUtilities.Assert(descriptor is LinkDescriptorData, "Descriptor is of unexpected type '{0}'", descriptor.GetType());
}
}
}
/// <summary>
/// Constructs an OData response to the given request using the given response data
/// </summary>
/// <param name="request">The odata request that was made</param>
/// <param name="underlyingResponse">The response data</param>
/// <returns>An odata response</returns>
public ODataResponse BuildResponse(ODataRequest request, HttpResponseData underlyingResponse)
{
ExceptionUtilities.CheckArgumentNotNull(request, "request");
ExceptionUtilities.CheckArgumentNotNull(underlyingResponse, "underlyingResponse");
ODataResponse odataResponse = new ODataResponse(underlyingResponse);
if (request.Uri.IsBatch())
{
ExceptionUtilities.CheckObjectNotNull(request.Body, "Batch request had no body");
var batchRequestPayload = request.Body.RootElement as BatchRequestPayload;
ExceptionUtilities.CheckObjectNotNull(batchRequestPayload, "Batch request body was not a valid batch payload");
this.ExecuteAndCatchErrors(request, odataResponse, () => odataResponse.RootElement = this.BatchDeserializer.DeserializeBatchResponse(batchRequestPayload, underlyingResponse));
return odataResponse;
}
string contentType;
if (underlyingResponse.TryGetHeaderValueIgnoreHeaderCase(HttpHeaders.ContentType, out contentType))
{
IProtocolFormatStrategy strategy = this.FormatSelector.GetStrategy(contentType, request.Uri);
ExceptionUtilities.CheckObjectNotNull(strategy, "Strategy selector did not return a strategy for content type '{0}'", contentType);
IPayloadDeserializer deserializer = strategy.GetDeserializer();
ExceptionUtilities.CheckObjectNotNull(deserializer, "Strategy returned a null deserializer");
this.ExecuteAndCatchErrors(
request,
odataResponse,
() =>
{
var payloadContext = ODataPayloadContext.BuildPayloadContextFromRequest(request);
payloadContext.ContentType = contentType;
payloadContext.EncodingName = HttpUtilities.GetContentTypeCharsetOrNull(contentType);
odataResponse.RootElement = deserializer.DeserializeFromBinary(odataResponse.Body, payloadContext);
if (ShouldResolveMetadata(request.Uri, odataResponse.StatusCode, odataResponse.RootElement.ElementType))
{
// resolve the payload's metadata
this.MetadataResolver.ResolveMetadata(odataResponse.RootElement, request.Uri);
// normalize the payload
var normalizer = strategy.GetPayloadNormalizer();
ExceptionUtilities.CheckObjectNotNull(normalizer, "Strategy returned a null payload normalizer");
odataResponse.RootElement = normalizer.Normalize(odataResponse.RootElement);
}
});
}
return odataResponse;
}
/// <summary>
/// Handles the request/response pair
/// </summary>
/// <param name="context">The context making the request</param>
/// <param name="request">The http request</param>
/// <param name="response">The http response</param>
internal void HandleRequestResponsePair(DataServiceContext context, HttpRequestData request, HttpResponseData response)
{
ExceptionUtilities.CheckArgumentNotNull(context, "context");
ExceptionUtilities.CheckArgumentNotNull(request, "request");
ExceptionUtilities.CheckArgumentNotNull(response, "response");
this.assert.AreSame(this.expectedContext, context, "Test hook fired by unexpected context");
// verify request uri
this.assert.IsNotNull(this.uriFromEvent, "Uri from event unexpectely null. Sending request event did not fire");
this.assert.AreEqual(this.uriFromEvent, request.Uri, "Uri on wire did not match uri from SendingRequest event.");
this.uriFromEvent = null;
// verify request verb
this.assert.IsNotNull(this.methodFromEvent, "Method from event unexpectely null. Sending request event did not fire");
bool usingXmlHttpStack = false;
string expectedMethod = request.Verb.ToHttpMethod();
if (request.Headers.ContainsKey("X-HTTP-Method"))
{
expectedMethod = request.Headers["X-HTTP-Method"];
}
this.assert.AreEqual(this.methodFromEvent.ToUpperInvariant(), expectedMethod.ToUpperInvariant(), "Method on wire did not match verb from SendingRequest event.");
this.methodFromEvent = null;
// Not validating headers on XmlHttpRequests as these will fail
if (!usingXmlHttpStack)
{
// verify request headers
this.VerifyHeaders(request.Headers);
}
}
/// <summary>
/// Replaces operation if payload is updated
/// </summary>
/// <param name="operation">Operation to visit</param>
protected override void VisitResponseOperation(HttpResponseData operation)
{
base.VisitResponseOperation(operation);
var responseOperation = operation as ODataResponse;
if (responseOperation.RootElement != null)
{
responseOperation.RootElement = this.applyExpectedResultNormalizers(responseOperation.RootElement, this.GetOperationTestConfiguration(operation));
}
}
private HttpResponseData CheckRequestFailInsert(HttpRequestData r)
{
if (r.Path != "/query") { throw new Exception("Wrong path!"); }
var response = new HttpResponseData();
if (r.Data == "{ token: \"77a5e3fad4d2646594fc12e67d2b6590e30df81f\", query: \"SELECT ?val FROM <https://carre.kmi.open.ac.uk/users/MindaugasB> WHERE { <https://carre.kmi.open.ac.uk/users/MindaugasB/measurements/vivaport_635688864000000000> <https://carre.kmi.open.ac.uk/users/MindaugasB/measurements/vivaport_635688864000000000_has_test1> ?val . }\" }")
{
response.StatusCode = System.Net.HttpStatusCode.OK;
response.Data = "OK";
response.ContentLength = 1;
} else {
response.StatusCode = System.Net.HttpStatusCode.InternalServerError;
}
return response;
}
private HttpResponseData CheckRequestSuccessInsert(HttpRequestData r)
{
if (r.Path != "/query") { throw new Exception("Wrong path!"); }
var response = new HttpResponseData();
if (r.Data.Contains("token: \"77a5e3fad4d2646594fc12e67d2b6590e30df81f\""))
{
if (r.Data.Contains("query: \"SELECT ?val FROM <https://carre.kmi.open.ac.uk/users/MindaugasB> WHERE { <https://carre.kmi.open.ac.uk/users/MindaugasB/measurements/vivaport_635692320000000000>"))
{
response.StatusCode = System.Net.HttpStatusCode.OK;
}
if (r.Data.Contains("query: \"INSERT DATA { GRAPH <https://carre.kmi.open.ac.uk/users/MindaugasB> { <https://carre.kmi.open.ac.uk/users/MindaugasB/measurements/vivaport_635692320000000000> <http://www.w3.org/2000/01/rdf-schema#type> :individual_test1_measurement .\n"))
{
response.StatusCode = System.Net.HttpStatusCode.OK;
response.Data = "OK";
response.ContentLength = 1;
}
}
else
{
response.StatusCode = System.Net.HttpStatusCode.InternalServerError;
}
return response;
}
