public async Task ResponceIsValidBsonPostSignUp(string input)
{
var accessMock = new Mock <IRepository <AccessTokenSchema> >();
var result = new Task <AccessTokenSchema>(() =>
{
return(new AccessTokenSchema
{
CreatedAt = new BsonDateTime(DateTime.UtcNow),
Role = RoleOptions.Admin,
});
});
result.Start();
accessMock.Setup(a => a.FindOne(It.IsAny <FilterDefinition <AccessTokenSchema> >()))
.Returns(result)
.Verifiable();
var client = CustomHost.Create(accessMock);
var request = CustomRequest.Create(HttpMethod.Post, $"/authentication/signUps{input}bson=true");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsByteArrayAsync();
var data = BsonSerializer.Deserialize <SignUpTokenResponce>(body);
Assert.False(data == null, "SignUp data is null.");
Assert.False(data.SignUpToken == null, "SignUp token data is null.");
Assert.False(data.SignUpToken == string.Empty, "SignUp token data is empty.");
Assert.False(data.Expiration == null, "SignUp expiration data is null.");
}
public async Task <string> RunCommand(string cmd)
{
var noUpRequest = new CustomRequest(cmd);
var noUpBean = await ExecuteTaskAsync <string>(noUpRequest).ConfigureAwait(false);
return(noUpBean.Data);
}
public async Task AnyStringIsAllowedPostTag(string value)
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = ObjectId.GenerateNewId(),
Id = string.Empty,
User = null,
CreatedAt = new BsonDateTime(DateTime.UtcNow),
Tags = new List <string>(),
});
});
result.Start();
sessionMock.Setup(s => s.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Post, $"/sessions/EXEX/tags/{value}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
}
public async Task UpdateIsCalledDeleteTag()
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = ObjectId.GenerateNewId(),
Id = string.Empty,
User = null,
CreatedAt = new BsonDateTime(DateTime.UtcNow),
Tags = new List <string>(),
});
});
result.Start();
sessionMock.Setup(s => s.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
// For some reason Verify() doesn't work
sessionMock.Setup(
s => s.Update(
It.IsAny <FilterDefinition <SessionSchema> >(),
It.IsAny <UpdateDefinition <SessionSchema> >()))
.Verifiable("A session was never updated.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Delete, $"/sessions/EXEX/tags/test");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
}
public async Task ResponceIsOkDeleteTags()
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = ObjectId.GenerateNewId(),
Id = string.Empty,
User = null,
CreatedAt = new BsonDateTime(DateTime.UtcNow),
Tags = new List <string>(),
});
});
result.Start();
sessionMock.Setup(s => s.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Delete, $"/sessions/EXEX/tags/test");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Assert.Equal(
"text/plain; charset=utf-8",
response.Content.Headers.ContentType.ToString());
Assert.True(
await response.Content.ReadAsStringAsync() == "OK",
"Tagging does not have a body of 'OK'.");
}
public async Task ExpiredTokenIsUnauthorizedPresecurity(int value)
{
var accessMock = new Mock <IRepository <AccessTokenSchema> >();
var result = new Task <AccessTokenSchema>(() =>
{
return(new AccessTokenSchema
{
InternalId = ObjectId.GenerateNewId(),
Hash = string.Empty,
User = ObjectId.GenerateNewId(),
CreatedAt = new BsonDateTime(DateTime.UtcNow.AddSeconds(-value)),
Role = RoleOptions.Admin,
});
});
result.Start();
accessMock.Setup(a => a.FindOne(It.IsAny <FilterDefinition <AccessTokenSchema> >()))
.Returns(result)
.Verifiable();
var client = CustomHost.Create(accessMock);
var request = CustomRequest.Create(HttpMethod.Post, "/authentication/signUps/", false);
request.Headers.TryAddWithoutValidation("Cookie", "ExperienceCapture-Access-Token=" + "ok");
var response = await client.SendAsync(request);
Assert.True(
response.StatusCode == HttpStatusCode.Unauthorized,
"Triggering pre-security with an expired token is not unauthorized.");
}
public async Task EmptyTagIsNotFoundPostTags()
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = ObjectId.GenerateNewId(),
Id = string.Empty,
User = null,
CreatedAt = new BsonDateTime(DateTime.UtcNow),
Tags = new List <string>(),
});
});
result.Start();
sessionMock.Setup(s => s.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Post, $"/sessions/EXEX/tags/");
var response = await client.SendAsync(request);
Assert.True(
response.StatusCode == HttpStatusCode.NotFound,
"Tagging a an empty is not 'not found'.");
}
/// <summary>
/// The WordPressClient holds all connection infos and provides methods to call WordPress APIs.
/// </summary>
/// <param name="uri">URI for WordPress API endpoint, e.g. "http://demo.wp-api.org/wp-json/"</param>
public WordPressClient(string uri)
{
if (string.IsNullOrWhiteSpace(uri))
{
throw new ArgumentNullException(nameof(uri));
}
if (!uri.EndsWith("/"))
{
uri += "/";
}
_wordPressUri = uri;
_httpHelper = new HttpHelper(WordPressUri);
Posts = new Posts(ref _httpHelper, defaultPath);
Comments = new Comments(ref _httpHelper, defaultPath);
Tags = new Tags(ref _httpHelper, defaultPath);
Users = new Users(ref _httpHelper, defaultPath);
Media = new Media(ref _httpHelper, defaultPath);
Categories = new Categories(ref _httpHelper, defaultPath);
Pages = new Pages(ref _httpHelper, defaultPath);
Taxonomies = new Taxonomies(ref _httpHelper, defaultPath);
PostTypes = new PostTypes(ref _httpHelper, defaultPath);
PostStatuses = new PostStatuses(ref _httpHelper, defaultPath);
CustomRequest = new CustomRequest(ref _httpHelper);
}
public async Task IsOkIfFoundPostExport()
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = null,
Id = null,
User = null,
CreatedAt = null,
Tags = null,
});
});
result.Start();
sessionMock.Setup(a => a.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Post, "/sessions/EXEX/export");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Assert.True(
body == "OK",
"Posting export responce is not 'OK'.");
}
/// <summary>
/// Custom steam request.
/// </summary>
/// <param name="interface">Interface.</param>
/// <param name="method">Method's name</param>
/// <param name="version">Method's version.</param>
/// <param name="actionBody">QueryStringDictionary action.</param>
/// <returns></returns>
public static SteamCustomBuilder CustomRequest(string @interface, string method, string version,
Action <QueryStringDictionary> actionBody)
{
if (string.IsNullOrEmpty(@interface))
{
throw new ArgumentNullException("Interface must be supplied.");
}
if (string.IsNullOrEmpty(method))
{
throw new ArgumentNullException("Method must be supplied.");
}
if (string.IsNullOrEmpty(version))
{
throw new ArgumentNullException("Version must be supplied.");
}
var request = new CustomRequest(_key)
{
Interface = @interface,
Method = method,
Version = version
};
actionBody(request.Parameters);
return(new SteamCustomBuilder(request));
}
public async Task BadAccessTokenIsUnauthorizedPresecurity(string value)
{
var accessMock = new Mock <IRepository <AccessTokenSchema> >();
var result = new Task <AccessTokenSchema>(() =>
{
return(null);
});
result.Start();
accessMock.Setup(a => a.FindOne(It.IsAny <FilterDefinition <AccessTokenSchema> >()))
.Returns(result)
.Verifiable();
var client = CustomHost.Create(accessMock);
var request = CustomRequest.Create(HttpMethod.Post, "/authentication/signUps/", false);
request.Headers.TryAddWithoutValidation("Cookie", "ExperienceCapture-Access-Token=" + value);
var response = await client.SendAsync(request);
Assert.True(
response.StatusCode == HttpStatusCode.Unauthorized,
"Triggering pre-security with a bad token is not unauthorized.");
}
public async Task ResponceExpirationIsInTheFuturePostSignUp()
{
var now = new BsonDateTime(DateTime.UtcNow);
var accessMock = new Mock <IRepository <AccessTokenSchema> >();
var result = new Task <AccessTokenSchema>(() =>
{
return(new AccessTokenSchema
{
CreatedAt = new BsonDateTime(DateTime.UtcNow),
Role = RoleOptions.Admin,
});
});
result.Start();
accessMock.Setup(a => a.FindOne(It.IsAny <FilterDefinition <AccessTokenSchema> >()))
.Returns(result)
.Verifiable();
var client = CustomHost.Create(accessMock);
var request = CustomRequest.Create(HttpMethod.Post, "/authentication/signUps");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
var data = BsonSerializer.Deserialize <SignUpTokenResponce>(body);
Assert.True(data.Expiration > now, "SignUp expiration data is before the current time.");
}
public async Task AddIsCalledPostSignUp()
{
var accessMock = new Mock <IRepository <AccessTokenSchema> >();
var result = new Task <AccessTokenSchema>(() =>
{
return(new AccessTokenSchema
{
InternalId = ObjectId.GenerateNewId(),
Hash = string.Empty,
User = ObjectId.GenerateNewId(),
// A day so the token can't expire while running
CreatedAt = new BsonDateTime(DateTime.UtcNow.AddSeconds(86400)),
Role = RoleOptions.Admin,
});
});
result.Start();
accessMock.Setup(a => a.FindOne(It.IsAny <FilterDefinition <AccessTokenSchema> >()))
.Returns(result);
accessMock.Setup(s => s.Add(It.IsAny <AccessTokenSchema>()))
.Verifiable("An access token is never added.");
var client = CustomHost.Create(accessMock: accessMock);
var request = CustomRequest.Create(HttpMethod.Post, "/authentication/signUps");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
}
private void SendCustomNotification(CustomMessageType messageType, string objectId, string eventId,
params string[] data)
{
using (Trace.Main.scope())
{
try
{
Trace.Main.note("SendCustomNotification request\nCustomMessageType: {}\nOID: {}\nEID: {}\nData:\n{}", messageType, objectId, eventId,
data == null ? "*NO DATA*" : data.Aggregate((a, b) => a + "\n" + b));
switch (messageType)
{
case CustomMessageType.ServerNotification:
{
var requestServerNotification =
new CustomRequest(new CustomMessageHeader(messageType, objectId, eventId));
if (data != null && data.Length > 0)
{
requestServerNotification.Write(data);
}
_customNotification.SendServerRequestNoResponse(requestServerNotification);
break;
}
case CustomMessageType.ApplicationRequest:
{
var requestApplicationRequest =
new CustomRequest(new CustomMessageHeader(messageType, objectId, eventId));
if (data != null && data.Length > 0)
{
requestApplicationRequest.Write(data);
}
_customNotification.SendApplicationRequest(requestApplicationRequest);
break;
}
case CustomMessageType.ApplicationResponse:
{
var responseApplicationResponse =
new CustomResponse(
new CustomMessage(new CustomMessageHeader(messageType, objectId, eventId)));
if (data != null && data.Length > 0)
{
responseApplicationResponse.Write(data);
}
_customNotification.SendApplicationResponse(responseApplicationResponse);
break;
}
default:
throw new Exception("Unsupported message type: " + messageType);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
Trace.Main.exception(ex);
}
}
}
/// <summary>
/// The WordPressClient holds all connection infos and provides methods to call WordPress APIs.
/// </summary>
/// <param name="httpClient">HttpClient with BaseAddress set which will be used for sending requests to the WordPress API endpoint.</param>
/// <param name="defaultPath">Relative path to standard API endpoints, defaults to "wp/v2/"</param>
public WordPressClient(HttpClient httpClient, string defaultPath = DEFAULT_PATH)
{
if (httpClient == null)
{
throw new ArgumentNullException(nameof(httpClient));
}
string uri = httpClient.BaseAddress.ToString();
if (!uri.EndsWith("/", StringComparison.Ordinal))
{
uri += "/";
}
WordPressUri = uri;
_defaultPath = defaultPath;
_httpHelper = new HttpHelper(httpClient);
Posts = new Posts(ref _httpHelper, _defaultPath);
Comments = new Comments(ref _httpHelper, _defaultPath);
Tags = new Tags(ref _httpHelper, _defaultPath);
Users = new Users(ref _httpHelper, _defaultPath);
Media = new Media(ref _httpHelper, _defaultPath);
Categories = new Categories(ref _httpHelper, _defaultPath);
Pages = new Pages(ref _httpHelper, _defaultPath);
Taxonomies = new Taxonomies(ref _httpHelper, _defaultPath);
PostTypes = new PostTypes(ref _httpHelper, _defaultPath);
PostStatuses = new PostStatuses(ref _httpHelper, _defaultPath);
CustomRequest = new CustomRequest(ref _httpHelper);
}
public void StronglyTypedRequestErrorsThrowsProperExceptionType()
{
MessagingClient client = null;
var r = new CustomRequest();
var publishedResponse = new JObject(
new JProperty("jsonrpc", "2.0"),
new JProperty("id", r.id),
new JProperty("error",
new JObject(
new JProperty("code", 1),
new JProperty("message", "Error Message"),
new JProperty("data", "Error Data")
)
)
);
client = new MessagingClient(m =>
{
client.PublishResponse(publishedResponse);
});
Exception recordedExeption = Record.Exception(() =>
{
var responseTask = client.SendMessageAsync <CustomRequest, CustomResponse>(r);
var result = responseTask.Result;
});
var messageException = ((AggregateException)recordedExeption).InnerExceptions[0];
Assert.IsType <MessagingException>(messageException);
Assert.Equal(publishedResponse["error"]["message"].ToString() + " " + publishedResponse["error"]["data"].ToString(), messageException.Message);
}
/// <summary>
/// Custom steam request.
/// </summary>
/// <param name="interface"></param>
/// <param name="method"></param>
/// <param name="version"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static SteamCustomBuilder CustomRequest(string @interface, string method, string version,
object parameters)
{
if (string.IsNullOrEmpty(@interface))
{
throw new ArgumentNullException("Interface must be supplied.");
}
if (string.IsNullOrEmpty(method))
{
throw new ArgumentNullException("Method must be supplied.");
}
if (string.IsNullOrEmpty(version))
{
throw new ArgumentNullException("Version must be supplied.");
}
var request = new CustomRequest(_key)
{
Interface = @interface,
Method = method,
Version = version,
Parameters = parameters.ToDictionary()
};
return(new SteamCustomBuilder(request));
}
public async Task BsonTypeIsCorrect()
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema()
{
User = new PersonSchema
{
},
});
});
result.Start();
sessionMock.Setup(s => s.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Get, "/sessions/EXEX?bson=true");
var response = await client.SendAsync(request);
Assert.Equal(
"application/bson",
response.Content.Headers.ContentType.ToString());
}
public async Task OtherMethodsSignUp(string input)
{
var client = CustomHost.Create();
var requestPut = CustomRequest.Create(HttpMethod.Put, $"/authentication/signUps{input}");
var responsePut = await client.SendAsync(requestPut);
Assert.True(
responsePut.StatusCode == HttpStatusCode.MethodNotAllowed,
"Putting SignUp is an allowed method.");
var requestPatch = CustomRequest.Create(HttpMethod.Patch, $"/authentication/signUps{input}");
var responsePatch = await client.SendAsync(requestPatch);
Assert.True(
responsePatch.StatusCode == HttpStatusCode.MethodNotAllowed,
"Patching SignUp is an allowed method.");
var requestGet = CustomRequest.Create(HttpMethod.Get, $"/authentication/signUps{input}");
var responseGet = await client.SendAsync(requestGet);
Assert.True(
responseGet.StatusCode == HttpStatusCode.MethodNotAllowed,
"Gettings SignUp is an allowed method.");
var requestDelete = CustomRequest.Create(HttpMethod.Delete, $"/authentication/signUps{input}");
var responseDelete = await client.SendAsync(requestDelete);
Assert.True(
responseDelete.StatusCode == HttpStatusCode.MethodNotAllowed,
"Deleting SignUp is an allowed method.");
}
public async Task MultipleRoutesPostSignUp(string input)
{
var accessMock = new Mock <IRepository <AccessTokenSchema> >();
var result = new Task <AccessTokenSchema>(() =>
{
return(new AccessTokenSchema
{
CreatedAt = new BsonDateTime(DateTime.UtcNow),
Role = RoleOptions.Admin,
});
});
result.Start();
accessMock.Setup(a => a.FindOne(It.IsAny <FilterDefinition <AccessTokenSchema> >()))
.Returns(result)
.Verifiable();
var client = CustomHost.Create(accessMock);
var request = CustomRequest.Create(HttpMethod.Post, $"/authentication/signUps{input}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
}
public async Task MultiplePathsAcceptedGetExport(string input)
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = null,
Id = null,
User = null,
CreatedAt = null,
Tags = null,
ExportState = ExportOptions.Done,
});
});
result.Start();
sessionMock.Setup(a => a.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Get, $"/sessions/EXEX/export{input}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
}
public async Task OtherMethodsExport(string input)
{
var client = CustomHost.Create();
var requestPut = CustomRequest.Create(HttpMethod.Put, $"/sessions/EXEX/export{input}");
var responsePut = await client.SendAsync(requestPut);
Assert.True(
responsePut.StatusCode == HttpStatusCode.MethodNotAllowed,
"Putting export is an allowed method.");
var requestPatch = CustomRequest.Create(HttpMethod.Patch, $"/sessions/EXEX/export{input}");
var responsePatch = await client.SendAsync(requestPatch);
Assert.True(
responsePatch.StatusCode == HttpStatusCode.MethodNotAllowed,
"Patching export is an allowed method.");
var requestDelete = CustomRequest.Create(HttpMethod.Patch, $"/sessions/EXEX/export{input}");
var responseDelete = await client.SendAsync(requestDelete);
Assert.True(
responseDelete.StatusCode == HttpStatusCode.MethodNotAllowed,
"Deleting export is an allowed method.");
}
public async Task CorrectContentGetExport()
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = null,
Id = null,
User = null,
CreatedAt = null,
Tags = null,
ExportState = ExportOptions.Done,
});
});
result.Start();
sessionMock.Setup(a => a.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Get, "/sessions/EXEX/export");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Assert.Equal(
"application/zip",
response.Content.Headers.ContentType.ToString());
}
public async Task IsBrokenGetExport()
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = null,
Id = null,
User = null,
CreatedAt = null,
Tags = null,
ExportState = ExportOptions.Error,
});
});
result.Start();
sessionMock.Setup(a => a.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Get, "/sessions/EXEX/export");
var response = await client.SendAsync(request);
Assert.True(
response.StatusCode == HttpStatusCode.InternalServerError,
"Getting export is not 'internal server error'.");
}
public async Task UpdateIsCalledPostExport()
{
var sessionMock = new Mock <IRepository <SessionSchema> >();
var result = new Task <SessionSchema>(() =>
{
return(new SessionSchema
{
InternalId = null,
Id = null,
User = null,
CreatedAt = null,
Tags = null,
});
});
result.Start();
sessionMock.Setup(s => s.FindById(It.IsAny <string>()))
.Returns(result)
.Verifiable("A session was never searched for.");
sessionMock.Setup(s => s.Update(
It.IsAny <FilterDefinition <SessionSchema> >(),
It.IsAny <UpdateDefinition <SessionSchema> >()))
.Verifiable("A session was never updated for.");
var client = CustomHost.Create(sessionMock: sessionMock);
var request = CustomRequest.Create(HttpMethod.Post, "/sessions/EXEX/export");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
}
public ActionResult <string> Put(string idRequest, long timestamp, [FromBody] DTOCategory categoryDTO)
{
CustomRequest req = new CustomRequest(idRequest, CustomRequest.FLAG_UPDATE, categoryDTO, categoryDTO.IdEditorial);
CategoryRequestActions categoryRequest = new CategoryRequestActions(req, CustomScope);
RequestManager requestManager = new RequestManager(timestamp, categoryRequest);
requestPile.AddRequest(categoryDTO.IdEditorial, requestManager);
return(Program.REQ_RESPONSE_POSITIVE);
}
public ActionResult <string> Delete(long timestamp, string idEditorial, [FromBody] DTOModelBase dto)
{
CustomRequest request = new CustomRequest(null, CustomRequest.FLAG_DELETE, dto, idEditorial);
EditorialRequestActions editorialRequest = new EditorialRequestActions(request, CustomScope);
RequestManager requestManager = new RequestManager(timestamp, editorialRequest);
requestsPile.AddRequest(idEditorial, requestManager);
return(Program.REQ_RESPONSE_POSITIVE);
}
public ActionResult <string> Put(string requestId, long timestamp, [FromBody] DTOEditorial editorialDTO)
{
CustomRequest request = new CustomRequest(requestId, Entity.CustomRequest.FLAG_UPDATE, editorialDTO, editorialDTO.Id);
EditorialRequestActions editorialRequest = new EditorialRequestActions(request, CustomScope);
RequestManager requestManager = new RequestManager(timestamp, editorialRequest);
requestsPile.AddRequest(editorialDTO.Id, requestManager);
return(Program.REQ_RESPONSE_POSITIVE);
}
public ActionResult <string> Put(string idRequest, long timestamp, [FromBody] DTOBook bookDTO)
{
CustomRequest request = new CustomRequest(idRequest, Entity.CustomRequest.FLAG_UPDATE, bookDTO, bookDTO.IdEditorial);
BookRequestActions bookRequest = new BookRequestActions(request, CustomScope);
RequestManager requestManager = new RequestManager(timestamp, bookRequest);
requestPile.AddRequest(bookDTO.IdEditorial, requestManager);
return(Program.REQ_RESPONSE_POSITIVE);
}
public async Task IllegalUrlIsNotFoundDelete(string input)
{
var client = CustomHost.Create();
var request = CustomRequest.Create(HttpMethod.Delete, input);
var response = await client.SendAsync(request);
Assert.True(
response.StatusCode == HttpStatusCode.NotFound,
$"The following illegal url is allowed: {input}");
}
private GameSparks.Api.Requests.CustomRequest build()
{
CustomRequest r = new CustomRequest(data);
//add scriptdata to request when not null
if (scriptData != null)
{
r.SetScriptData(new GameSparks.Core.GSRequestData(scriptData));
}
return r;
}
