public void Host_MustNotBeNull()
{
// Arrange
RequestBuilder r0 = Request.Builder().Host(null);
RequestBuilder r1 = Request.Builder().Host("foo");
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => r0.Build());
Assert.That(r1.Build().Host, Is.EqualTo("foo"));
Assert.That(r1.Build().Uri, Is.EqualTo(new Uri("http://foo:8080/org.talend.administrator/metaServlet?e30=")));
}
public void Path_MustNotBeNull()
{
// Arrange
RequestBuilder r0 = Request.Builder().Path(null);
RequestBuilder r1 = Request.Builder().Path("/foo");
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => r0.Build());
Assert.That(r1.Build().Path, Is.EqualTo("/foo"));
Assert.That(r1.Build().Uri, Is.EqualTo(new Uri("http://localhost:8080/foo?e30=")));
}
private Task <WebRequest> Request(object service, string methodName, object model)
{
var requestBuilder = new RequestBuilder();
requestBuilder.AddHeaders(Headers);
return(requestBuilder.Build(service, methodName, model));
}
public Boolean Go(ITestContext context, String serverURI, TestCaseItem tcItem, int value)
{
Request request = Request.NewGet();
//Uri uri = new Uri(new Uri(serverURI), flowTest.ResourceURI);
Uri uri = new Uri(serverURI);
request.URI = uri;
if (RequestBuilder != null)
{
request = RequestBuilder.Build(request);
}
request.Respond += delegate(object sender, ResponseEventArgs e)
{
context.ResponseQueue.Offer(e.Response);
};
context.RequestQueue.Offer(request);
context.Verbose.AppendFormat("{0}({1})\t--------->\t ", request.Type, request.CodeString);
StepItem stepItem = new StepItem();
stepItem.IsRequest = true;
stepItem.Name = request.Method.ToString() + " Request ";
stepItem.IsPassed = true;
stepItem.RowItemList = new List <RowItem>();
tcItem.StepItemList.Add(stepItem);
tcItem.stepOperation(request.Method.ToString() + " Request", value);
request.Send();
return(true);
}
public static void Main()
{
Capture capture = JsonConvert.DeserializeObject <Capture>(File.ReadAllText("capture.json"));
Dictionary <string, string> regexDictionary = new Dictionary <string, string>();
CookieContainer cookieContainer = new CookieContainer();
foreach (Request request in capture.requests)
{
WebRequest webRequest = RequestBuilder.Build(request, regexDictionary, cookieContainer);
HttpWebResponse response = (HttpWebResponse)webRequest.GetResponse();
string responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
if (request.regex.Count <= 0)
{
continue;
}
foreach (Regex regex in request.regex)
{
System.Text.RegularExpressions.Regex findRegex = new System.Text.RegularExpressions.Regex(regex.value);
string value = findRegex.Match(responseString).Groups[1].Value;
regexDictionary.Add(regex.name,
regex.urlEncode ? System.Web.HttpUtility.UrlEncode(value) : value);
}
}
Console.Read();
}
public void EmptyBuildedQueryIsNotNull()
{
var requestBuilder = new RequestBuilder();
var buildedQuery = requestBuilder.Build();
buildedQuery.Should().NotBe(null);
}
/// <summary>
/// Создать HTTP запрос
/// </summary>
/// <param name="message">
/// SOAP-запрос
/// </param>
/// <param name="attachment">
/// Вложение
/// </param>
/// <returns>
/// HTTP запрос
/// </returns>
private HttpsRequest CreateRequest(RequestMessage message, byte[] attachment)
{
var mime = new MimeModel
{
ContentLength2 = attachment.Length
};
message.AddHrefParameter("PackageBody", mime.DataId);
message.GenerateHeader(vcert);
mime.Message = message.ToString();
var request = CreateRequest(message.MethodName);
request.Head.AppendFormat("Content-Type: multipart/related; type=\"application/xop+xml\";boundary=\"{0}\"\r\n", mime.Boundary);
var mimeStr = RequestBuilder.Build(mime);
var msgBytes = Encoding.UTF8.GetBytes(mimeStr);
var ending = Encoding.UTF8.GetBytes(string.Format("\r\n--{0}--", mime.Boundary));
request.Body = new byte[msgBytes.Length + attachment.Length + ending.Length];
using (var stream = new MemoryStream(request.Body))
{
stream.Write(msgBytes, 0, msgBytes.Length);
stream.Write(attachment, 0, attachment.Length);
stream.Write(ending, 0, ending.Length);
stream.Close();
}
return(request);
}
public static BlitlineRequest Request(Action <RequestBuilder> action)
{
var requestBuilder = new RequestBuilder();
action(requestBuilder);
return(requestBuilder.Build());
}
/// <summary>
/// Calls the API and gets the results
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="httpClient"></param>
/// <returns></returns>
public Task <IEnumerable <TResult> > Call <TResult>(HttpClient httpClient)
where TResult : new()
{
if (query is null)
{
throw new Exception("No query provided");
}
if (httpClient is null)
{
throw new ArgumentNullException(nameof(httpClient));
}
httpClient.BaseAddress = igdbConfiguration.IgdbUrl;
if (httpClient.DefaultRequestHeaders.Contains(UserKeyHeaderName))
{
httpClient.DefaultRequestHeaders.Remove(UserKeyHeaderName);
}
httpClient.DefaultRequestHeaders.Add(UserKeyHeaderName, igdbConfiguration.UserToken);
var builder = new RequestBuilder <T>(new Apicalypse.DotNet.Configuration.RequestBuilderConfiguration
{
CaseContract = Apicalypse.DotNet.Configuration.CaseContract.SnakeCase
});
query.Invoke(builder);
return(builder.Build().Send <TResult>(httpClient, EndpointMapper.Map <T>()));
}
internal HttpRequestMessage PrepareRequest(HttpMethod method, string path, string queryString, IDictionary <string, string> headers, IRequestContent data)
{
if (string.IsNullOrEmpty("path"))
{
throw new ArgumentNullException(nameof(path));
}
var request = new HttpRequestMessage(method, RequestBuilder.Build(endpointBaseUri, requestedApiVersion, path, queryString));
request.Headers.Add("User-Agent", UserAgent);
if (headers != null)
{
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
if (data != null)
{
var requestContent = data.GetContent(); // make the call only once.
request.Content = requestContent;
}
return(request);
}
public void BuildedQueryIsassignableToInterface()
{
var requestBuilder = new RequestBuilder();
var buildedQuery = requestBuilder.Build();
buildedQuery.Should().BeAssignableTo <IRequest>();
}
public void ShouldBuildBasicRequest()
{
var req = builder.Build("/test", HttpMethod.Get);
req.Method.Should().Be(HttpMethod.Get);
req.RequestUri.OriginalString.Should().Be("/test");
}
public void Should_log_exception_when_thrown_with_request_details()
{
var newRequest = RequestBuilder.Build();
QueryHandlerMock.Setup(qh => qh.Handle <GetCaseTypeQuery, CaseType>(It.IsAny <GetCaseTypeQuery>()))
.Throws <Exception>();
Assert.ThrowsAsync <Exception>(async() => await Controller.BookNewHearing(newRequest));
}
public void Process(HttpContext context)
{
var(requestInfo, requestDetail) = RequestBuilder.Build(context);
if (requestInfo != null && requestDetail != null)
{
ReportsTransport.SendDataAsync(new Core.RequestBag(requestInfo, requestDetail));
}
}
public Request Construct(string url, string username, string password, string body)
{
var builder = new RequestBuilder();
builder.SetUrl(url);
builder.AddHeader("username", username);
builder.AddHeader("password", password);
builder.SetBody(body);
return(builder.Build());
}
private async Task<HttpResponseMessage> MakeRequestAsync(
string url,
HttpMethod method,
object body = null,
Headers headers = null,
Query query = null
)
{
var request = _requestBuilder.Build(url, method, body, headers, query);
return await _client.AsyncMakeRequest(request);
}
public void GetRequestToGoogleShouldBeValid()
{
var requestBuilder = new RequestBuilder();
requestBuilder.CreateRequest(new HttpMethod("GET"), "http://google.com");
var buildedQuery = requestBuilder.Build();
var messageValidation = buildedQuery.ValidateMessage();
var requestMessage = requestBuilder.Message;
messageValidation.Should().BeTrue();
requestMessage.Method.Should().Be(new HttpMethod("GET"));
requestMessage.RequestUri.Should().Be(new Uri("http://google.com"));
}
public async Task Should_return_badrequest_without_valid_request()
{
var newRequest = RequestBuilder.Build();
newRequest.CaseTypeName = string.Empty;
var result = await Controller.BookNewHearing(newRequest);
result.Should().NotBeNull();
var objectResult = (BadRequestObjectResult)result;
objectResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
var errors = (Dictionary <string, object>)((SerializableError)objectResult.Value);
errors.Should().ContainKey("CaseTypeName");
((string[])errors["CaseTypeName"])[0].Should().Be("Please provide a case type name");
}
private async Task <bool> SendFileAudioToServerAndDelete(string filePath, string name, ServerSendFileCallback callback = null)
{
RequestBuilder requestBuilder = new RequestBuilder();
requestBuilder
.SetDevice_id(App.config.GetDeviceId())
.SetDevice_tokenFirebase(App.firebaseInstanceId.Token);
if (timerSpanToRecord != null)
{
requestBuilder.SetLength(timerSpanToRecord.ToString());
}
_serverSendFile.request = requestBuilder.Build();
bool result =
await _serverSendFile.SendGenericFileToServer(ServerConfig.Instance.server_url_send_audio, filePath, name, callback);
result = result && await StorageUtility.DeleteFileLocalStorage(filePath);
return(result);
}
public async Task Should_successfully_book_hearing_without_endpoint()
{
var newRequest = RequestBuilder.Build();
newRequest.Endpoints = null;
var response = await Controller.BookNewHearing(newRequest);
response.Should().NotBeNull();
var result = (CreatedAtActionResult)response;
result.StatusCode.Should().Be((int)HttpStatusCode.Created);
QueryHandlerMock.Verify(x => x.Handle <GetCaseTypeQuery, CaseType>(It.IsAny <GetCaseTypeQuery>()), Times.Once);
QueryHandlerMock.Verify(x => x.Handle <GetHearingVenuesQuery, List <HearingVenue> >(It.IsAny <GetHearingVenuesQuery>()), Times.Once);
QueryHandlerMock.Verify(x => x.Handle <GetHearingByIdQuery, VideoHearing>(It.IsAny <GetHearingByIdQuery>()), Times.Once);
RandomGenerator.Verify(x => x.GetWeakDeterministic(It.IsAny <long>(), It.IsAny <uint>(), It.IsAny <uint>()), Times.Never);
CommandHandlerMock.Verify(c => c.Handle(It.Is <CreateVideoHearingCommand>(c => c.Endpoints.Count == 0)), Times.Once);
}
public IReadOnlyList <dynamic> GetItems(string type, int gameId, int typeId, string steamProfile)
{
var formatedTemplate = string.Format(_steamCommunityApiTemplate, type, steamProfile, gameId, typeId);
var request = RequestBuilder.Build <string>(new RequestConfiguration
{
BaseAddress = _steamCommunityBaseUrl,
HttpMethod = "GET",
RequestName = "GetInventoryItems",
TimeoutSeconds = 30,
Polly = new PollyConfiguration
{
IntervalInSeconds = 30,
Name = "GetInventoryItemsPolly",
Retries = 3
}
});
var result = request.Execute(formatedTemplate);
var value = result.Content.ReadAsStringAsync().Result;
var a = result.ToEntity <InventoryModel>();
return(null);
}
public static BlitlineRequest Request(Action<RequestBuilder> action)
{
var requestBuilder = new RequestBuilder();
action(requestBuilder);
return requestBuilder.Build();
}
public ActionResult Create([Bind(Include = "ServiceId,Category1Id,Category2Id,Category3Id,Category4Id,ImpactId,Contact,Title,Description")] CreateRequestViewModel createRequestUserViewModel)
{
RequestBuilder builder = new RequestBuilder();
ActiveDirectoryReadOnlyRepository ad = new ActiveDirectoryReadOnlyRepository();
ActiveDirectoryUser adu = ad.GetUser(HttpContext.User.Identity.Name);
User user;
user = unitOfWork.UserRepository.GetUserBySamAccountName(HttpContext.User.Identity.Name);
if (user == null)
{
UserName un = new UserName(adu.Name, adu.Surname);
user = new User(un, adu.SamAccountName, adu.EmailAddress, "");
}
else
{
user.mail = adu.EmailAddress;
}
builder.WithWhoRegistered(user);
builder.WithOwner(user);
Origin origin = unitOfWork.OriginRepository.GetOriginByName("Aplicação");
builder.WithOrigin(origin);
builder.WithContact(createRequestUserViewModel.Contact);
Category category;
if (createRequestUserViewModel.Category4Id < 1)
{
if (createRequestUserViewModel.Category3Id < 1)
{
if (createRequestUserViewModel.Category2Id < 1)
{
if (createRequestUserViewModel.Category1Id < 1)
{
}
else
{
category = unitOfWork.CategoryRepository.Get(createRequestUserViewModel.Category1Id);
builder.WithCategory(category);
}
}
else
{
category = unitOfWork.CategoryRepository.Get(createRequestUserViewModel.Category2Id);
builder.WithCategory(category);
}
}
else
{
category = unitOfWork.CategoryRepository.Get(createRequestUserViewModel.Category3Id);
builder.WithCategory(category);
}
}
else
{
category = unitOfWork.CategoryRepository.Get(createRequestUserViewModel.Category4Id);
builder.WithCategory(category);
}
Impact impact = unitOfWork.ImpactRepository.Get(createRequestUserViewModel.ImpactId);
builder.WithContact(createRequestUserViewModel.Contact);
builder.WithImpact(impact);
builder.WithTitle(createRequestUserViewModel.Title);
builder.WithDescription(HttpUtility.HtmlDecode(createRequestUserViewModel.Description));
Service service = unitOfWork.ServiceRepository.Get(createRequestUserViewModel.ServiceId);
InteractionBuilder interactionBuilder = new InteractionBuilder();
interactionBuilder.WithTitle(createRequestUserViewModel.Title);
interactionBuilder.WithService(service);
Interaction interaction = interactionBuilder.Build();
Request request = builder.Build();
request.AddInteraction(interaction);
unitOfWork.RequestRepository.Insert(request);
unitOfWork.SaveChanges();
MailService ms = new MailService();
ms.CreateMail("Assunto", "Corpo");
MailAddress mail = new MailAddress(user.mail);
ms.AddMail(mail);
ms.Send();
return(RedirectToAction("Index", "Home"));
}
public void Build_NothingWasSetUp_ThrowsAnException()
{
Assert.ThrowsException <ArgumentNullException>(() => _requestBuilder.Build());
}
public ActionResult Create([Bind(Include = "OriginId,ServiceId,Category1Id,Category2Id,Category3Id,Category4Id,ImpactId,Contact,Title,Description")] CreateRequestViewModel createRequestViewModel)
{
RequestBuilder builder = new RequestBuilder();
User user1 = unitOfWork.UserRepository.Get(1);
User user2 = unitOfWork.UserRepository.Get(2);
builder.WithWhoRegistered(user1);
builder.WithOwner(user2);
Origin origin = unitOfWork.OriginRepository.Get(createRequestViewModel.OriginId);
builder.WithOrigin(origin);
Category category;
if (createRequestViewModel.Category4Id < 1)
{
}
else
{
category = unitOfWork.CategoryRepository.Get(createRequestViewModel.Category4Id);
builder.WithCategory(category);
}
if (createRequestViewModel.Category3Id < 1)
{
}
else
{
category = unitOfWork.CategoryRepository.Get(createRequestViewModel.Category3Id);
builder.WithCategory(category);
}
if (createRequestViewModel.Category2Id < 1)
{
}
else
{
category = unitOfWork.CategoryRepository.Get(createRequestViewModel.Category2Id);
builder.WithCategory(category);
}
if (createRequestViewModel.Category1Id < 1)
{
}
else
{
category = unitOfWork.CategoryRepository.Get(createRequestViewModel.Category1Id);
builder.WithCategory(category);
}
Impact impact = unitOfWork.ImpactRepository.Get(createRequestViewModel.ImpactId);
builder.WithImpact(impact);
builder.WithContact(createRequestViewModel.Contact);
builder.WithTitle(createRequestViewModel.Title);
builder.WithDescription(createRequestViewModel.Description);
Service service = unitOfWork.ServiceRepository.Get(createRequestViewModel.ServiceId);
InteractionBuilder interactionBuilder = new InteractionBuilder();
interactionBuilder.WithTitle(createRequestViewModel.Title);
interactionBuilder.WithService(service);
Interaction interaction = interactionBuilder.Build();
Request request = builder.Build();
request.AddInteraction(interaction);
unitOfWork.RequestRepository.Insert(request);
unitOfWork.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public void ReturnRequestOnBuildTest()
{
var builder = new RequestBuilder <Game>();
Assert.IsInstanceOf <ApicalipseRequest>(builder.Build());
}
private BookNewHearingRequest BuildRequest()
{
return(RequestBuilder.Build());
}
