public async Task ReturnAResponseFromAnyProxyRequest() { // Setup your mocked stuff var mockedProxyRequest = ProxyRequestBuilder <string[]> .CreateBuilder("https://www.this.is/fake", HttpRequestMethod.Get) .AppendToRoute("api/example") .Accept("application/json") .Build(); var mockedProxyResponse = new ProxyResponse <string[]> { IsSuccessfulStatusCode = true, StatusCode = HttpStatusCode.OK, ResponseDto = new[] { "Mocked Value From Any Request 1", "Mocked Value From Any Request 2" } }; // Create and configure TestProxy var testProxy = new TestProxy(); testProxy.WhenIReceiveAnyRequest <Missing, string[]>().ThenIShouldReturnThisResponse(mockedProxyResponse); // Use the TetProxy in the class that needs it var classThatUsesProxy = new ClassThatUsesProxy(testProxy); var methodThatUsesProxyResponse = await classThatUsesProxy.MethodThatUsesProxyAsync(mockedProxyRequest).ConfigureAwait(false); Assert.Equal("Mocked Value From Any Request 1", methodThatUsesProxyResponse[0]); Assert.Equal("Mocked Value From Any Request 2", methodThatUsesProxyResponse[1]); }
public void TestResponse_Constructor_SetsFields() { var expectedFields = new TestResponseFields(); var response = new ProxyResponse <TestResponseFields>(expectedFields); Assert.AreSame(expectedFields, response.Fields); }
public static async Task <string> HandleUrls(string content) { MatchCollection matches = Url_Regex.Matches(content); foreach (Match match in matches) { bool bypass = false; foreach (string s in Media_Bypass) { if (match.Value.ToLower().Replace("www.", "").StartsWith(s)) { bypass = true; content = content.Replace(match.Value, $"![]({match.Value})"); break; } } if (!bypass) { ProxyResponse proxied = await GetProxy(match.Value); if (Media_Types.Contains(proxied.Item.Mime_Type)) { content = content.Replace(match.Value, $"![]({proxied.Item.Url})"); } } } return(content); }
public virtual ProxyResponse <R> GetResponse <T, R>(string requestUri, T postData) where T : class where R : class { HttpResponseMessage responseMsg; if (OperationMethod != HttpMethod.Put && OperationMethod != HttpMethod.Post) { responseMsg = GetResponseMessage <object>(requestUri, null); } else { responseMsg = GetResponseMessage <T>(requestUri, postData); } if (responseMsg.IsSuccessStatusCode) { if (responseMsg.Content != null) { var textData = responseMsg.Content.ReadAsStringAsync().Result; if (!string.IsNullOrWhiteSpace(textData)) { var dto = Deserialise <R>(textData); var proxResponse = new ProxyResponse <R>(textData, dto, true, responseMsg.StatusCode, responseMsg.ReasonPhrase); return(proxResponse); } return(new ProxyResponse <R>(textData, default(R), true, responseMsg.StatusCode, responseMsg.ReasonPhrase)); } } return(new ProxyResponse <R>(responseMsg.Content.ReadAsStringAsync().Result, default(R), false, responseMsg.StatusCode, responseMsg.ReasonPhrase)); }
public async Task <IActionResult> Create([FromBody] CreateProxyRequest proxyRequest) { var proxy = new Proxy { Address = $"{proxyRequest.Host}:{proxyRequest.Port}", Host = proxyRequest.Host, Port = proxyRequest.Port, Country = proxyRequest.Country, User = proxyRequest.User, Password = proxyRequest.Password, Type = proxyRequest.Type, Status = proxyRequest.Status ?? 0, }; await _proxyService.CreateProxyAsync(proxy); var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}"; var locationUrl = $"{baseUrl}/{ApiRoutes.Proxies.Get.Replace("{proxyAddress}", proxy.Address)}"; var response = new ProxyResponse { Address = proxy.Address }; return(Created(locationUrl, response)); }
public async Task <ProxyResponse <T, ServiceErrorResponse> > Refund <T>(JObject jsonData) { var httpOperationResponse = await CreateApiClient(async apiClient => await apiClient.Refund(jsonData)); var result = new ProxyResponse <T, ServiceErrorResponse /*Api Standard error format*/>(httpOperationResponse); httpOperationResponse.Dispose(); return(result); }
public async Task ExecuteTestMethod() { using (var unitOfWork = new UnitOfWork()) { ExecuteTfs syncAll = new ExecuteTfs(unitOfWork); ProxyResponse res = await syncAll.Execute(2, 275, null); Assert.AreEqual(res.Result, "ok"); } }
public static async Task <ProxyResponse> GetProxy(string url) { string encoded_url = HttpUtility.UrlEncode(url); string encoded_key = HttpUtility.UrlEncode(MPSConfig.Current.Api_Key); var response = await Http.PostAsync($"{MSP_PROXY}?auth={encoded_key}&url={encoded_url}", null); ProxyResponse data = JsonSerializer.Deserialize <ProxyResponse>(await response.Content.ReadAsStringAsync()); return(data); }
/// <summary> /// Adds a proxy to the stub with predicate generators containing booleans /// </summary> /// <param name="to">endpoint address to proxy to</param> /// <param name="proxyMode">proxyalways, proxyonce or proxytransparent</param> /// <param name="predicateGenerators">list of predicates that a proxy repsonse will be recorded for</param> /// <returns></returns> public HttpStub ReturnsProxy(Uri to, ProxyMode proxyMode, IList <MatchesPredicate <HttpBooleanPredicateFields> > predicateGenerators) { var fields = new ProxyResponseFields <HttpBooleanPredicateFields> { To = to, Mode = proxyMode, PredicateGenerators = predicateGenerators }; var response = new ProxyResponse <ProxyResponseFields <HttpBooleanPredicateFields> >(fields); return(Returns(response)); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// private void WwwProxy_PostResponse(ProxyRequest request, ProxyResponse response) { try { object responseFilter = scriptEngine_.Operations.GetMember <object>(wwwProxyFilterInstance_, "post_response_filter"); object[] parameters = { request, response }; scriptEngine_.Operations.Call(responseFilter, parameters); } catch (Exception e) { debugLog_.Write("WwwProxyScripting.WwwProxy_PostResponse()", e.ToString()); } }
public override void Handle(ProxyRequest req) { using (var proxyStreamSsl = new SslStream(this.ProxyStream, true)) { if (req.KeepAlive) { this.ProxyStream.Write(ConnectionEstablishedKA, 0, ConnectionEstablishedKA.Length); } else { this.ProxyStream.Write(ConnectionEstablished, 0, ConnectionEstablished.Length); } proxyStreamSsl.AuthenticateAsServer(this.m_certificate, false, this.m_sslProtocols, false); req.Dispose(); while (ProxyRequest.TryParse(proxyStreamSsl, true, out req)) { using (req) using (var resp = new ProxyResponse(proxyStreamSsl)) { try { this.m_handler(new ProxyContext(req, resp)); } catch { if (!resp.HeaderSent) { resp.Headers.Clear(); resp.StatusCode = HttpStatusCode.InternalServerError; } throw; } } if (!req.KeepAlive) { break; } } } }
/// <summary> /// Parses the raw response into a proxy response object. /// </summary> /// <param name="response">Raw response returned by the destionation server.</param> /// <param name="destinationUri">Destination URI object.</param> /// <returns>Proxy Response</returns> public static ProxyResponse BuildProxyResponse(string response, Uri destinationUri) { var splitResponse = response.Split(new[] { RequestConstants.CONTENT_SEPERATOR }, 2, StringSplitOptions.None); if (splitResponse.Length == 1) { var status = ParseStatusCode(splitResponse[0]); return(ProxyResponse.Create(status, Enumerable.Empty <ProxyHeader>(), Enumerable.Empty <Cookie>(), splitResponse[0])); } else { var responseHeadersHtml = splitResponse[0]; var statusWithHeaders = responseHeadersHtml.Split(new[] { Environment.NewLine }, StringSplitOptions.None); var statusHtml = statusWithHeaders[0]; var status = ParseStatusCode(statusHtml); var headerList = new List <ProxyHeader>(); var cookieContainer = new CookieContainer(); var headerArray = statusWithHeaders.Skip(1); foreach (var header in headerArray) { var headerPair = header.Split(new[] { ": " }, 2, StringSplitOptions.None); if (headerPair[0].ToLower().Contains(RequestConstants.SET_COOKIE_HEADER)) { cookieContainer.SetCookies(destinationUri, headerPair[1]); continue; } headerList.Add(ProxyHeader.Create(headerPair[0], headerPair[1])); } return(ProxyResponse.Create(status, headerList, cookieContainer.GetCookies(destinationUri), splitResponse[1])); } }
public override void Handle(ProxyRequest req) { do { using (req) using (var resp = new ProxyResponse(this.ProxyStream)) { if (req.KeepAlive) { resp.Headers.Set(HttpResponseHeader.Connection, "Keep-Alive"); resp.Headers.Set(HttpResponseHeader.KeepAlive, "timeout=30"); } this.m_handler(new ProxyContext(req, resp)); if (!req.KeepAlive) { break; } } } while (ProxyRequest.TryParse(this.ProxyStream, false, out req)); }
private static void AssertUpdatedContact(ContactAggregate contactAggregate, ProxyResponse <Contact> updatedContact) { Assert.AreEqual(contactAggregate.EmailAddress, updatedContact.DataObject.EmailAddress); Assert.AreEqual(contactAggregate.ContactId, updatedContact.DataObject.ContactId); Assert.AreEqual(contactAggregate.FamilyName, updatedContact.DataObject.FamilyName); Assert.AreEqual(contactAggregate.Fax, updatedContact.DataObject.Fax); Assert.AreEqual(contactAggregate.GivenName, updatedContact.DataObject.GivenName); Assert.AreEqual(contactAggregate.IsPartner, updatedContact.DataObject.IsPartner); Assert.AreEqual(contactAggregate.IsContractor, updatedContact.DataObject.IsContractor); Assert.AreEqual(contactAggregate.IsCustomer, updatedContact.DataObject.IsCustomer); Assert.AreEqual(contactAggregate.IsPartner, updatedContact.DataObject.IsPartner); Assert.AreEqual(contactAggregate.IsSupplier, updatedContact.DataObject.IsSupplier); Assert.AreEqual(contactAggregate.MiddleInitials, updatedContact.DataObject.MiddleInitials); Assert.AreEqual(contactAggregate.MobilePhone, updatedContact.DataObject.MobilePhone); Assert.AreEqual(contactAggregate.HomePhone, updatedContact.DataObject.HomePhone); Assert.AreEqual(contactAggregate.PositionTitle, updatedContact.DataObject.PositionTitle); Assert.AreEqual(contactAggregate.PostalAddress.City, updatedContact.DataObject.PostalAddress.City); Assert.AreEqual(contactAggregate.PostalAddress.Country, updatedContact.DataObject.PostalAddress.Country); Assert.AreEqual(contactAggregate.PostalAddress.Postcode, updatedContact.DataObject.PostalAddress.Postcode); Assert.AreEqual(contactAggregate.PostalAddress.State, updatedContact.DataObject.PostalAddress.State); Assert.AreEqual(contactAggregate.PostalAddress.Street, updatedContact.DataObject.PostalAddress.Street); Assert.AreEqual(contactAggregate.PrimaryPhone, updatedContact.DataObject.PrimaryPhone); Assert.AreEqual(contactAggregate.Salutation, updatedContact.DataObject.Salutation); }
public ProxyContext(ProxyRequest req, ProxyResponse resp) { this.Request = req; this.Response = resp; }
public override void Handle(ProxyRequest req) { HttpWebRequest hreq = null; this.CancelSource.Token.Register(() => { try { hreq.Abort(); } catch { } }); do { using (req) using (var resp = new ProxyResponse(this.ProxyStream)) { hreq = req.CreateRequest(null, true) as HttpWebRequest; if (req.RequestBodyReader != null) { var hreqStream = hreq.GetRequestStream(); req.RequestBodyReader.CopyTo(hreqStream); } HttpWebResponse hresp = null; try { hresp = hreq.GetResponse() as HttpWebResponse; } catch (WebException ex) { hresp = ex.Response as HttpWebResponse; } catch { } if (hresp == null) { resp.StatusCode = HttpStatusCode.InternalServerError; req.RequestBodyReader?.CopyTo(Stream.Null); } else { using (hresp) { if (req.KeepAlive) { resp.Headers.Set(HttpResponseHeader.Connection, "Keep-Alive"); resp.Headers.Set(HttpResponseHeader.KeepAlive, "timeout=30"); } using (var hrespBody = hresp.GetResponseStream()) resp.FromHttpWebResponse(hresp, hrespBody); } } if (!req.KeepAlive) { break; } } } while (ProxyRequest.TryParse(this.ProxyStream, false, out req)); }
private static async Task Create(HttpContext ctx, ValourDB db, [FromHeader] string authorization, [Required] string name, [Required] string image_url) { ServerAuthToken auth = await ServerAuthToken.TryAuthorize(authorization, db); if (auth == null) { ctx.Response.StatusCode = 401; await ctx.Response.WriteAsync($"Token is invalid [token: {authorization}]"); return; } TaskResult nameValid = ServerPlanet.ValidateName(name); if (!nameValid.Success) { ctx.Response.StatusCode = 400; await ctx.Response.WriteAsync(nameValid.Message); return; } ServerUser user = await db.Users.FindAsync(auth.User_Id); if (!user.Valour_Staff) { var owned_planets = await db.Planets.CountAsync(x => x.Owner_Id == user.Id); if (owned_planets > MAX_OWNED_PLANETS) { ctx.Response.StatusCode = 400; await ctx.Response.WriteAsync("Max owned planets reached"); return; } } // Image handling via proxy ProxyResponse proxyResponse = await MPSManager.GetProxy(image_url); bool is_media = MPSManager.Media_Types.Contains(proxyResponse.Item.Mime_Type); if (proxyResponse.Item == null || !is_media) { image_url = "https://valour.gg/image.png"; } else { image_url = proxyResponse.Item.Url; } ulong planet_id = IdManager.Generate(); // Create general category ServerPlanetCategory category = new ServerPlanetCategory() { Id = IdManager.Generate(), Name = "General", Parent_Id = null, Planet_Id = planet_id, Description = "General category", Position = 0 }; // Create general channel ServerPlanetChatChannel channel = new ServerPlanetChatChannel() { Id = IdManager.Generate(), Planet_Id = planet_id, Name = "General", Message_Count = 0, Description = "General chat channel", Parent_Id = category.Id }; // Create default role ServerPlanetRole defaultRole = new ServerPlanetRole() { Id = IdManager.Generate(), Planet_Id = planet_id, Position = uint.MaxValue, Color_Blue = 255, Color_Green = 255, Color_Red = 255, Name = "@everyone" }; ServerPlanet planet = new ServerPlanet() { Id = planet_id, Name = name, Member_Count = 1, Description = "A Valour server.", Image_Url = image_url, Public = true, Owner_Id = user.Id, Default_Role_Id = defaultRole.Id, Main_Channel_Id = channel.Id }; // Add planet to database await db.Planets.AddAsync(planet); await db.SaveChangesAsync(); // We must do this first to prevent foreign key errors // Add category to database await db.PlanetCategories.AddAsync(category); // Add channel to database await db.PlanetChatChannels.AddAsync(channel); // Add default role to database await db.PlanetRoles.AddAsync(defaultRole); // Save changes await db.SaveChangesAsync(); // Add owner to planet await planet.AddMemberAsync(user, db); ctx.Response.StatusCode = 200; await ctx.Response.WriteAsJsonAsync(planet.Id); }
internal static ProxyResponse <ContactResponse> VerifyTestContactExistsOrCreate(ContactType contactType) { var proxy = new ContactsProxy(); ProxyResponse <ContactResponse> response = null; switch (contactType) { case Ola.RestClient.ContactType.Customer: { response = SearchCarl(proxy); if (response.DataObject.Contacts.Count == 0) { AddCarlCustomer(proxy.WsAccessKey, proxy.FileId); response = SearchCarl(proxy); } break; } case Ola.RestClient.ContactType.Supplier: { response = SearchJenny(proxy); if (response.DataObject.Contacts.Count == 0) { AddJennySupplier(proxy.WsAccessKey, proxy.FileId); response = SearchJenny(proxy); } break; } case Ola.RestClient.ContactType.Partner: { response = SearchBrad(proxy); if (response.DataObject.Contacts.Count == 0) { AddBradPartner(proxy.WsAccessKey, proxy.FileId); response = SearchBrad(proxy); } break; } case Ola.RestClient.ContactType.Contractor: { response = SearchKathy(proxy); if (response.DataObject.Contacts.Count == 0) { AddKathyContractor(proxy.WsAccessKey, proxy.FileId); response = SearchKathy(proxy); } break; } } if (response != null) { Assert.IsTrue(response.DataObject.Contacts.Count >= 1, "Incorrect number of contacts found."); } else { Assert.Fail("No contact type specified to be created."); } return(response); }