public ValidationResult Validate(IResponseData data, IResourceManager resourceManager, Dictionary <string, string> savedState)
{
long actualContentLength = data.ResponseStream.Length;
string expectedContentLengthString;
data.Headers.TryGetValue("Content-Length", out expectedContentLengthString);
if (expectedContentLengthString == null)
{
// Content-Length header is optional, so pass if it's not specified.
return(new ValidationResult());
}
else
{
int expectedContentLength = Int32.Parse(expectedContentLengthString);
if (actualContentLength == expectedContentLength)
{
return(new ValidationResult());
}
else
{
return(new ValidationResult(string.Format("Actual content length '{0}' of response does not match value in header content-length '{1}'",
actualContentLength, expectedContentLength)));
}
}
}
public void Security_Permission_DeletePermission_ShouldBeSuccess_WithEmptyId()
{
IResponseData <string> response = this.Connector.Delete <string>(string.Format(this.BaseUrl, Guid.Empty));
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.permissons.permissionIdIsInvalid"));
}
public override void PreWebTest(object sender, PreWebTestEventArgs e)
{
ITestContext context = new TestContext(e, AuthenticationInfo.Authorization);
context.Add(TestContextConst.BaseUri, e.WebTest.Context[TestContextConst.BaseUri]);
context.SetEventArgs(e);
e.WebTest.Context[TestContextConst.ContextKey] = context;
//TestContext.Context = context;
//TestContext.Context.SetEventArgs(e);
base.PreWebTest(sender, e);
string loginUri = TemplateHelper.CompileTemplate(this.Url, context);
var loginRequest = new LoginRequest(this.UserName, this.Password);
IConnector connector = new RESTConnector();
IResponseData <LoginResponse> response = connector.Post <LoginRequest, LoginResponse>(loginUri, loginRequest);
if (response.HasError())
{
e.WebTest.Stop();
return;
}
e.WebTest.Context.Add(LoadTestConst.Authorization, response.Data.Authorization);
AuthenticationInfo.Authorization = new Authorization(response.Data.Authorization, response.Data.AuthToken);
context = e.WebTest.Context[TestContextConst.ContextKey] as ITestContext;
context.SetAuthorization(AuthenticationInfo.Authorization);
}
private void RunCleanupRequests(ITestCase testCase, Dictionary <string, string> savedState, IList <RequestInfo> requestDetails)
{
if (testCase.CleanupRequests == null)
{
return;
}
foreach (IRequest request in testCase.CleanupRequests)
{
try
{
IResponseData responseData = request.Execute(WopiEndpoint,
AccessToken,
AccessTokenTtl,
testCase,
savedState,
ResourceManager,
UserAgent,
ProofKeyProviderNew,
ProofKeyProviderOld);
// No validators needed, they're just cleanup and we don't care if they worked or not.
string responseContent = GetResponseContentForClient(responseData);
RequestInfo requestInfo = new RequestInfo(
request.Name,
request.TargetUrl,
request.RequestHeaders,
responseData.StatusCode,
responseData.Headers,
responseContent,
Enumerable.Empty <ValidationResult>().ToList(),
responseData.Elapsed,
request.CurrentProofData,
request.OldProofData);
requestDetails.Add(requestInfo);
}
catch (Exception)
{
// Swallow all exceptions from the cleanup requests - we don't care if they work and
// some will fail by design if the test's requests failed.
RequestInfo requestInfo = new RequestInfo(
request.Name,
request.TargetUrl,
request.RequestHeaders,
0,
Enumerable.Empty <KeyValuePair <string, string> >(),
"no content: request failed",
Enumerable.Empty <ValidationResult>().ToList(),
TimeSpan.Zero,
request.CurrentProofData,
request.OldProofData);
requestDetails.Add(requestInfo);
}
}
}
public IResponseData <Product> Fetch(string userSearchString)
{
var request = (HttpWebRequest)WebRequest.Create(String.Format(UriString, userSearchString));
ShopYourWayApiResponseData responseData = new ShopYourWayApiResponseData();
try
{
using (var shopYourWayResponse = (HttpWebResponse)request.GetResponse())
{
using (var reader = new StreamReader(shopYourWayResponse.GetResponseStream()))
{
JavaScriptSerializer js = new JavaScriptSerializer();
var objText = reader.ReadToEnd();
if (!objText.Equals("null"))
{
responseData = (ShopYourWayApiResponseData)js.Deserialize(objText, typeof(ShopYourWayApiResponseData));
Data = responseData;
}
}
}
}
catch (Exception e)
{
throw new ShopYourWayApiException("An error occurred in ShopYourWay api", e);
}
return(responseData);
}
private string GetResponseContentForClient(IResponseData responseData)
{
string responseContent = "No content";
if (ShouldGetResponseContentString(responseData))
{
if (responseData.IsTextResponse)
{
string responseContentString = responseData.GetResponseContentAsString();
if (responseContentString != null)
{
if (responseContentString.Length > 8000)
{
responseContent = responseContentString.Substring(0, 8000);
}
else
{
responseContent = responseContentString;
}
}
}
else
{
responseContent = "Non text content";
}
}
return(responseContent);
}
private CreatePermissionResponse CreateNewPermission()
{
CreatePermissionRequest request = new CreatePermissionRequest("update permission name" + Guid.NewGuid(), "update permission key" + Guid.NewGuid(), "desc");
IResponseData <CreatePermissionResponse> response = this.Connector.Post <CreatePermissionRequest, CreatePermissionResponse>(string.Format(this.BaseUrl, string.Empty), request);
return(response.Data);
}
public ResponseBase(TRequest request, RequestStatus status, IResponseData data, IDictionary <Key, IResponseData> dataSections)
{
Request = request ?? throw new ArgumentNullException(nameof(request));
Status = status;
Data = data;
DataSections = dataSections ?? throw new ArgumentNullException(nameof(dataSections));
}
public ReadResult(ReadStatus status, IEnumerable <IDataEntity> entities, IResponseData answer, IDictionary <Key, IResponseData> answerSections)
{
Status = status;
Entities = entities;
Response = answer;
AnswerSections = answerSections ?? throw new ArgumentNullException(nameof(answerSections));
}
public void Security_Role_DeleteRole_ShouldGetException_WithNotExistedId()
{
IResponseData <string> createRoleResponse = this.Connector.Delete <string>(string.Format(this.BaseUrl, Guid.NewGuid()));
Assert.IsTrue(createRoleResponse.Errors.Count > 0);
Assert.IsTrue(createRoleResponse.Errors.Any(item => item.Key == "security.roles.validation.roleNotExisted"));
}
public void Security_Role_DeleteRole_ShouldGetException_WithEmptyId()
{
IResponseData <string> response = this.Connector.Delete <string>(string.Format(this.BaseUrl, Guid.Empty));
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.roles.validation.idIsInvalid"));
}
public ValidationResult Validate(IResponseData data, IResourceManager resourceManager, Dictionary <string, string> savedState)
{
MemoryStream expectedContent;
if (!string.IsNullOrEmpty(ExpectedBodyContent))
{
expectedContent = new MemoryStream(Encoding.UTF8.GetBytes(ExpectedBodyContent));
}
else
{
expectedContent = resourceManager.GetContentStream(ResourceId);
}
expectedContent.Seek(0, SeekOrigin.Begin);
data.ResponseStream.Seek(0, SeekOrigin.Begin);
bool areEqual = StreamUtil.StreamEquals(expectedContent, data.ResponseStream);
if (!areEqual)
{
return(new ValidationResult(
string.Format("Response body does not match expected content. Expected stream length: {0}, actual stream length: {1}",
expectedContent.Length, data.ResponseStream.Length)));
}
return(new ValidationResult());
}
public void Security_Permission_UpdatePermission_ShouldBeSuccess_WithValidRequest()
{
UpdatePermissionRequest request = new UpdatePermissionRequest(this.createdPermissionResponse.Id, "new updated name" + Guid.NewGuid(), "New updated Key " + Guid.NewGuid(), "desc");
IResponseData <string> response = this.Connector.Put <UpdatePermissionRequest, string>(string.Format(this.BaseUrl, request.Id), request);
Assert.IsTrue(response.Errors.Count == 0);
}
/// <inheritdoc />
protected override Task WriteResponse(IRequestData request, IResponseData response)
{
HttpContext context = ((HttpContextRequestData)request).Context;
context.Response.ContentType = response.ContentType;
context.Response.StatusCode = response.StatusCode;
return(Task.CompletedTask);
}
private string GetAnswerString(IResponseData <Product> data)
{
var answerString = data.Count == 0 ?
"No items found" :
String.Format("I found you these {0} items: {1}", data.Count, String.Join(", ", data.Products.Select(x => x.name)));
return(answerString);
}
public void Security_Role_DeleteRole_ShouldBeSuccess_WithValidRequest()
{
IResponseData <string> deleteResponse = this.Connector.Delete <string>(string.Format(this.BaseUrl, this.createdRoleResponse.Id));
IResponseData <GetRoleResponse> roleResponse = this.Connector.Get <GetRoleResponse>(string.Format(this.BaseUrl, this.createdRoleResponse.Id));
Assert.IsNull(roleResponse.Data);
Assert.IsTrue(deleteResponse.Errors.Count == 0);
}
private DummyResponse(string requestID)
{
this.Data = new JsonResponseData();
this.CreationTime = DateTime.UtcNow;
this.RequestID = requestID;
this.IsFinal = true;
this.State = RequestState.Unknown;
}
public void Security_Permission_CreatePermission_ShouldThrowException_WithEmptyId()
{
UpdatePermissionRequest request = new UpdatePermissionRequest(Guid.Empty, "new updated name" + Guid.NewGuid(), "New updated Key " + Guid.NewGuid(), "desc");
IResponseData <object> response = this.Connector.Put <UpdatePermissionRequest, object>(string.Format(this.BaseUrl, request.Id), request);
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "common.validation.invalidRequest"));
}
public FTDIBoxResponse(FTDIBoxRequest request, RequestStatus status, IResponseData data, IResponseData serviceSection, IResponseData bodySection)
: base(request, status, data,
new Dictionary <Key, IResponseData>()
{
{ FTDIBoxProtocol.SERVICE_DATA_SECTION_KEY, serviceSection },
{ FTDIBoxProtocol.BODY_SECTION_KEY, bodySection }
})
{
}
public SalachovResponse(SalachovRequest request, RequestStatus status, IResponseData data, IResponseData headerSection, IResponseData bodySection)
: base(request, status, data,
new Dictionary <Key, IResponseData>()
{
{ SalachovProtocol.HEADER_SECTION_KEY, headerSection },
{ SalachovProtocol.BODY_SECTION_KEY, bodySection }
})
{
}
private ValidationResult ValidateGetChunkedFileResponse(IResponseData data)
{
data.ResponseStream.Seek(0, SeekOrigin.Begin);
if (data.ResponseStream == null || data.ResponseStream.Length == 0)
{
return(new ValidationResult(String.Format(CultureInfo.CurrentCulture, "ResponseData.ResponseStream is null or empty")));
}
List <Frame> outputFrames = FrameProtocolParser.ParseStream(data.ResponseStream);
data.ResponseStream.Seek(0, SeekOrigin.Begin);
if (outputFrames == null || outputFrames.Count < 1)
{
return(new ValidationResult(String.Format(CultureInfo.CurrentCulture, "Parsed outputFrameList is null or empty")));
}
if (outputFrames[0].Type != FrameType.MessageJSON)
{
return(new ValidationResult(String.Format(CultureInfo.CurrentCulture, "The first frame is not MessageJson type")));
}
for (int i = 0; i < outputFrames.Count; i++)
{
Frame outputFrame = outputFrames[i];
ValidationResult frameValidation = ValidateFrame(outputFrame);
if (frameValidation.HasFailures)
{
return(frameValidation);
}
switch (outputFrame.Type)
{
case FrameType.MessageJSON:
// Enrich HostBlobIdsPerStreamId with chunk ids of the file from download, keyed by stream id
PopulateMessageFrame(outputFrame);
break;
case FrameType.Chunk:
// Enrich HostBlobs with delta blobs of the file from download
PopulateHostFileChunkIdToBlobMapping(outputFrame);
break;
default:
break;
}
}
if (this.ExpectedHostBlobsCount != null && this.ExpectedHostBlobsCount.Value != HostBlobs.Count)
{
return(new ValidationResult($"{nameof(ExpectedHostBlobsCount)}: '{ExpectedHostBlobsCount.Value}' not equal to {nameof(HostBlobs)}.Count: '{HostBlobs.Count}'"));
}
return(new ValidationResult());
}
public override IResponseData <TResponse> Get <TResponse>(string uri)
{
using (HttpClient client = this.CreateHttpClient(Configuration.Current.IntegrationTest.BaseUrl))
{
HttpResponseMessage responseMessage = client.GetAsync(uri).Result;
IResponseData <TResponse> result = this.GetResponseAs <ResponseData <TResponse> >(responseMessage.Content);
return(result);
}
}
public void Security_Permission_CreatePermission_ShouldThroException_WithInValidRequest()
{
CreatePermissionRequest request = new CreatePermissionRequest(string.Empty, string.Empty, "desc");
IResponseData <CreatePermissionResponse> response = this.Connector.Post <CreatePermissionRequest, CreatePermissionResponse>(this.BaseUrl, request);
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.nameIsRequire"));
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.keyIsRequire"));
}
public void Security_Permission_UpdatePermission_ShouldThrowException_WithEmptyNameAndKey()
{
UpdatePermissionRequest request = new UpdatePermissionRequest(this.createdPermissionResponse.Id, string.Empty, string.Empty, "desc");
IResponseData <string> response = this.Connector.Put <UpdatePermissionRequest, string>(string.Format(this.BaseUrl, request.Id), request);
Assert.IsTrue(response.Errors.Count > 0);
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.nameIsRequire"));
Assert.IsTrue(response.Errors.Any(item => item.Key == "security.addPermission.validation.keyIsRequire"));
}
public async Task InvokeHandlerShouldReturnNoContentStatusCode()
{
this.request.Handler.Returns(Substitute.For <MethodInfo>());
this.mapper.GetAdapter(this.request.Handler)
.Returns(_ => Task.FromResult <object>(NoContent.Value));
IResponseData result = await this.processor.InvokeHandler(this.request);
Assert.That(result.StatusCode, Is.EqualTo(204));
}
public static async Task <byte[]> GetRangeSafeAsync(this IResponseData responseData, long from, int count, AsyncOperationInfo operationInfo)
{
var hasFrom = from < responseData.Count;
count = (int)Math.Min(count, (responseData.Count - from));
return(hasFrom
? await responseData.GetRangeAsync(from, count, operationInfo)
: new byte[0]);
}
public ValidationResult Validate(IResponseData data, IResourceManager resourceManager, Dictionary <string, string> savedState)
{
if (ExpectedResponseCode == data.StatusCode)
{
return(new ValidationResult());
}
return
(new ValidationResult(string.Format("Incorrect StatusCode. Expected: {0}, Actual: {1}",
_expectedResponseCode, data.StatusCode)));
}
public override IResponseData <TRespone> Put <TRequest, TRespone>(string uri, TRequest data)
{
using (HttpClient client = this.CreateHttpClient(Configuration.Current.IntegrationTest.BaseUrl))
{
HttpContent content = new JsonContent <TRequest>(data);
HttpResponseMessage responseMessage = client.PutAsync(uri, content).Result;
IResponseData <TRespone> result = this.GetResponseAs <ResponseData <TRespone> >(responseMessage.Content);
return(result);
}
}
public void Security_Permission_CreatePermission_ShouldBeSuccess_WithValidRequest()
{
CreatePermissionRequest request = new CreatePermissionRequest("Name " + Guid.NewGuid(), "Key " + Guid.NewGuid(), "desc");
IResponseData <CreatePermissionResponse> response = this.Connector.Post <CreatePermissionRequest, CreatePermissionResponse>(this.BaseUrl, request);
/* Assert.IsTrue(response.Status == HttpStatusCode.OK); */
Assert.IsTrue(response.Errors.Count == 0);
Assert.IsTrue(response.Data != null);
Assert.IsTrue(response.Data.Id != null && response.Data.Id != Guid.Empty);
}
public ValidationResult Validate(IResponseData data, IResourceManager resourceManager, Dictionary <string, string> savedState)
{
if (data.StatusCode == (int)HttpStatusCode.Unused &&
data.Headers.ContainsKey(Constants.Headers.ValidatorError))
{
return(new ValidationResult($"{Name}: Exception thrown while executing: {data.Headers[Constants.Headers.ValidatorError]}"));
}
return(new ValidationResult());
}