public static void AddLargeImage(JsonServiceClient client) { Console.WriteLine("Getting image"); var fp = client.Post(new FloorPlanRequestDto.FloorplanAdd {BluePrintId = 1, Floor = RandomGenerator.Integer(10000), FloorDesc = "1"}); Console.WriteLine(string.Format("Added image id is {0}", fp.Id)); var image = Image.FromFile(LargeImageLocation); string base64 = Convert.ToBase64String(image.ImageToByteArray()); Console.WriteLine("Sending image..."); var resp = client.Post(new FloorPlanRequestDto.FloorplanAddImage {FloorplanId = fp.Id, Image = base64}); Console.WriteLine("Message: {0}\nMessage: {1}\nResponse Status: {2}", resp.Result, resp.Message, resp.ResponseStatus); Console.ReadLine(); }
public void Test_GET_two_PASS() { var restClient = new JsonServiceClient(serviceUrl); var newemp1 = new Employee() { Id = 1, Name = "Joe", StartDate = new DateTime(2015, 1, 2), }; var newemp2 = new Employee() { Id = 2, Name = "Julie", StartDate = new DateTime(2012, 12, 2), }; restClient.Post<object>("/employees", newemp1); restClient.Post<object>("/employees", newemp2); var emps = restClient.Get<List<Employee>>("/employees"); Assert.NotNull(emps); Assert.NotEmpty(emps); Assert.Equal(2, emps.Count); }
private static void Main() { AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler; // PerformanceTest(); var client = new JsonServiceClient(Settings.Default.ServiceAddress); var createRequest = new CreateClientRequest { Email = "*****@*****.**" }; var response = client.Post<ClientResponse>(createRequest); Console.WriteLine("POST Response: {0}\n", response); var updateRequest = new UpdateClientRequest { Email = "*****@*****.**", Id = response.Id }; response = client.Put<ClientResponse>(updateRequest); Console.WriteLine("PUT Response: {0}\n", response); var getClientRequest = new GetClientRequest { Id = response.Id, Date = DateTime.Now.Date }; response = client.Get<ClientResponse>(getClientRequest); Console.WriteLine("GET Response: {0}\n", response); var deleteRequest = new DeleteClientRequest { Id = response.Id }; client.Delete(deleteRequest); var certificate = new MemoryStream(File.ReadAllBytes("Certificate.cer")); var uploadRequest = new UploadRequest { FileContents = certificate.ToArray(), OriginalFileName = "MyFileName.cert", UploaderId = Guid.NewGuid().ToString() }; client.Post(uploadRequest); Console.ReadKey(); }
public void TryLogin() { using(var tempDb = new TempFile()) { //GlobalProxySelection.Select = new WebProxy("127.0.0.1", 8888); // proxy via Fiddler2. using (var server = new Server() { Port = 8000, SqliteFile = tempDb.Path }) { server.Start(); // log in var restClient = new JsonServiceClient(FakeServer.BaseUri); var response = restClient.Post<AuthResponseEx>( "/api/auth/credentials?format=json", new Auth() { UserName = "******", Password = "******", RememberMe = true }); response.SessionId.ShouldMatch(@"[a-zA-Z0-9=+/]{20,100}"); response.UserName.ShouldBe("tech"); response.UserId.ShouldMatch(@"^[a-zA-Z0-9_-]{8}$"); // log out var logoutResponse = restClient.Delete<AuthResponse>("/api/auth/credentials?format=json&UserName=tech"); logoutResponse.SessionId.ShouldBe(null); // can't come up with a good way to verify that we logged out. } } }
/// <summary> /// Get a new build /// </summary> /// <returns>BuildInfo object or null on error/no build</returns> public static BuildInfo getBuild() { Console.WriteLine("* Checking for builds..."); var client = new JsonServiceClient (apiurl); try { var buildInfo = client.Post (new CheckForBuild { token = Uri.EscapeDataString (Config.token) }); if (buildInfo != null) { return buildInfo; } } catch (WebServiceException ex) { if(ex.StatusCode == 404) { Console.WriteLine ("* Nothing"); } else { Console.WriteLine ("* Failed"); } } return null; }
public void Test_PostWithBadHostnameAndGetMessage_StatusIsFailed() { // Create message var postRequest = new CreateMessage { ApplicationId = 1, Bcc = new[] { "*****@*****.**" }, Body = "This is a test email.", Cc = new[] { "*****@*****.**" }, Connection = new Connection { EnableSsl = false, Host = "nonexistant", Port = 25 }, Credential = new Credential(), From = "*****@*****.**", ReplyTo = new[] { "*****@*****.**" }, Sender = "*****@*****.**", Subject = "Test Message", To = new[] { "*****@*****.**" } }; var client = new JsonServiceClient("http://localhost:59200/"); var postResponse = client.Post(postRequest); // Get message var getRequest = new GetMessage { Id = postResponse.Id }; var getResponse = client.Get(getRequest); Assert.Equal(3, getResponse.Status.TypeMessageStatusId); Assert.Equal(postResponse.Id, getResponse.Id); }
public void RunTests() { byte[] imageData; using (Image srcImage = Image.FromFile(@"D:\Bill\Code\XamarinEvolve2013Project\TestSSAPI\testavatar.jpg")) { using (MemoryStream m = new MemoryStream()) { srcImage.Save(m, ImageFormat.Jpeg); imageData = m.ToArray(); //buffers } } JsonServiceClient client = new JsonServiceClient(SystemConstants.WebServiceBaseURL); UserAvatar userAvatar = new UserAvatar() { UserName = "******", Data = imageData, }; UserAvatarResponse response = client.Post<UserAvatarResponse>("UserAvatar", userAvatar); //response = client.Delete<UserAvatarResponse>("UserAvatar/billholmes"); return; }
/// <summary> /// Register the runner with the coordinator /// </summary> /// <param name="sPubKey">SSH Public Key</param> /// <param name="sToken">Token</param> /// <returns>Token</returns> public static string registerRunner(String sPubKey, String sToken) { var client = new JsonServiceClient (apiurl); try { var authToken = client.Post (new RegisterRunner { token = Uri.EscapeDataString (sToken), public_key = Uri.EscapeDataString (sPubKey) }); if (!authToken.token.IsNullOrEmpty ()) { Console.WriteLine ("Runner registered with id {0}", authToken.id); return authToken.token; } else { return null; } } catch(WebException ex) { Console.WriteLine ("Error while registering runner :", ex.Message); return null; } }
public void OnTestFixtureSetUp() { Client = new JsonServiceClient(BaseUri); var response = Client.Post<AuthenticateResponse>("/auth", new Authenticate { UserName = "******", Password = "******" }); }
public void Populate() { ////var svc = new KnockKnockMongo(); //var db = svc.Database<PotatoKnock>(); //db.DeleteMany(Builders<PotatoKnock>.Filter.Empty); var knock = new KnockDto { FeedId = Guid.NewGuid(), Id = Guid.NewGuid(), Location = new LocationDto { Latitude = 45, Longitude = 60 }, Message = "Turn me into a french fry?" }; using (var svc = new JsonServiceClient("http://localhost:40300/")) { var knockstr = knock.SerializeToString(); svc.Post(new KnockPost { Knock = knock }); } //svc.Any(new KnockPost {Knock = knock}); Console.WriteLine(knock.Id); }
public void check_secured_post_requires_credentials() { var restClient = new JsonServiceClient(WebServerUrl); var request = new Secured { Data = "Bob" }; var error = Assert.Throws<WebServiceException>(() => restClient.Post<SecuredResponse>("/Secured/", request)); Assert.AreEqual("Unauthorized", error.Message); Assert.AreEqual((int)HttpStatusCode.Unauthorized, error.StatusCode); }
public void OnTestFixtureSetUp() { Client = new JsonServiceClient(BaseUri); var response= Client.Post<AuthResponse>("/auth", new ServiceInterface.Auth.Auth { UserName = "******", Password = "******" }); Console.WriteLine(response.Dump()); }
private void btnCreate_Click(object sender, EventArgs e) { AdventureType type = new AdventureType() { Name = txtName.Text }; ServiceClientBase client = new JsonServiceClient("http://localhost:10768"); var response = client.Post<AdventureType>("/Adventure/Types/", (AdventureType)type); }
public void OnTestFixtureSetUp() { //appHost = new AppHost(); //appHost.Init(); //appHost.Start(ListeningOn); Client = new JsonServiceClient(BaseUri); Client.Post<AuthenticationResponse>("/login", new Authentication(){UserName="******", Password="******"}); //Client.Send<AuthResponse>(new Auth(){UserName="******", Password="******"}); }
public void BypassOAuthForTemporaryAccessToken() { var restClient = new JsonServiceClient (testServer.ListenUrl); var req = new OAuthTemporaryAccessTokenRequest (); req.Username = RainyTestServer.TEST_USER; req.Password = RainyTestServer.TEST_PASS; var token = restClient.Post<OAuthTemporaryAccessTokenResponse> ("/oauth/temporary_access_token", req); Assert.That (!token.AccessToken.StartsWith ("oauth_")); Assert.GreaterOrEqual (400, token.AccessToken.Length); }
public void Logout_Test() { IRestClient client = new JsonServiceClient(); LogoutResponse response = client.Post <LogoutResponse>("http://localhost:888/security/1.0/logout", new LogoutRequest { Context = "NG", Token = "53162017072ef71b5c3d8e4f" } as object); Assert.AreEqual(response.SuccessfulLogout, true); }
public void ReproduceErrorTest() { var restClient = new JsonServiceClient(BaseUrl); var errorList = restClient.Get<ErrorCollectionResponse>("error"); Assert.That(errorList.Result.Count, Is.EqualTo(1)); var error = restClient.Post<ErrorResponse>("error", new Error { Id = "Test" }); Assert.That(error, !Is.Null); }
/// <summary> /// POST方式调用服务 直接返回JSON /// </summary> /// <typeparam name="TRequestDto">请求类</typeparam> /// <param name="request">请求实例</param> /// <param name="url"></param> /// <returns>响应实例</returns> public static string PostService <TRequestDto>(TRequestDto request, string url) where TRequestDto : BaseRequest { var client = new JsonServiceClient(url) { Timeout = new TimeSpan(0, 0, 90) }; string responseJson = client.Post <string>(request); return(responseJson); }
public void AddEmptyThing() { using (FakeServer fs = new FakeServer().StartWithFakeRepos()) { using(JsonServiceClient client = new JsonServiceClient(FakeServer.BaseUri)){ var newThing = new Thing(); client.Post(newThing); } } }
public void StopProduction() { var client = new JsonServiceClient("https://{0}.campfirenow.com".FormatWith(_account)) { UserName = _token, Password = "******" }; Parallel.ForEach(_listeners, (campfireRoomListener) => { client.Post<string>("/room/{0}/leave.json".FormatWith(campfireRoomListener.Context.RoomId), string.Empty); campfireRoomListener.StopListening(); }); }
public void POST_JSON_Request_calls_Any() { var client = new JsonServiceClient(Config.ListeningOn); var response = client.Post <ContentRoute>(new ContentRoute { Id = 1 }); Assert.That(response.Id, Is.EqualTo(1)); }
public void OnTestSetup() { string pass; _host = new ServiceTestAppHost(); _host.Init(); _host.Start(ServiceTestAppHost.BaseUrl); _client = new JsonServiceClient(ServiceTestAppHost.BaseUrl); _testUser = DbDataGenerator.AddUserToDatabase(out pass); _client.Post(new Auth {provider = "credentials", UserName = _testUser.Email, Password = pass}); }
public void OnTestFixtureSetUp() { Client = new JsonServiceClient(BaseUri); var response = Client.Post <AuthResponse>("/auth", new ServiceStack.ServiceInterface.Auth.Auth { UserName = "******", Password = "******" }); Console.WriteLine(response.Dump()); }
public void Check_For_Changes_In_Checksum() { var client = new JsonServiceClient(BaseUri); var url = "https://en.wikipedia.org/wiki/Static_web_page"; var firstChecksumResponse = client.Post(new MD5Request() { Url = url }); //make another call to the same url var secondChecksumResponse = client.Post(new MD5Request() { Url = url }); Assert.AreEqual(firstChecksumResponse.Checksum, secondChecksumResponse.Checksum, "Provided MD5 checksums for the same url are not the same!"); }
public void Does_url_transparently_decode_RequestBody() { var client = new JsonServiceClient(Config.AbsoluteBaseUri); var request = new Echo { Param = "test://?&% encoding" }; var response = client.Post(request); Assert.That(response.Param, Is.EqualTo(request.Param)); }
public void do_unsecured_post() { var restClient = new JsonServiceClient(WebServerUrl); var request = new Unsecured { Data = "Bob" }; var response = restClient.Post<UnsecuredResponse>("/Unsecured/", request); Assert.IsNotNull(response); Assert.AreEqual("Bob", response.Result); }
public void Does_compress_raw_Bytes_responses() { var client = new JsonServiceClient(Config.ListeningOn); var response = client.Post(new CompressBytes { Bytes = "foo".ToUtf8Bytes(), }); Assert.That(response, Is.EquivalentTo("foo".ToUtf8Bytes())); }
public void Does_compress_raw_String_responses() { var client = new JsonServiceClient(Config.ListeningOn); var response = client.Post(new CompressString { String = "foo", }); Assert.That(response, Is.EqualTo("foo")); }
public void Can_send_to_GoogleAppEngine_JSON_Python_Service() { var client = new JsonServiceClient("http://servicestackdemo.appspot.com"); var receipt = client.Post(new EmailMessage { To = "*****@*****.**", Subject = "Hello from JsonServiceClient", Body = "ServiceStack SMessage", }); receipt.PrintDump(); }
public static void CreateSecrets(string rootToken, string secretName, string[] secrets) { using (var client = new JsonServiceClient(VaultUriInstance)) { client.AddHeader("X-Vault-Token", rootToken); client.Post <JsonObject>($"v1/secret/{secretName}", new { value = Encoding.UTF8.GetBytes(secrets.ToJson()) }); } }
public void SaveProduct_RequiresRole() { var client = new JsonServiceClient(TestAppHost.BaseUri); var login = client.Post(Constants.TestAuthenticate); client.SessionId = login.SessionId; var authException = Assert.Throws <WebServiceException>(() => client.Post(new SaveProduct())); Assert.AreEqual(403, authException.StatusCode); Assert.AreEqual("Invalid Role", authException.ErrorCode); login = client.Post(Constants.TestAdminAuthenticate); client.SessionId = login.SessionId; var exception = Assert.Throws <WebServiceException>(() => client.Post(new SaveProduct())); Assert.AreEqual(400, exception.StatusCode); }
public void SetUp() { MongoHelpers.DeleteAllTestUserEntries(); _client = HTTPClientHelpers.GetClient(HTTPClientHelpers.RootUrl, HTTPClientHelpers.UserName, HTTPClientHelpers.Password); AuthResponse authResponse = HTTPClientHelpers.Login(); User request = new User { UserName = MongoHelpers.MongoTestUsername, Password = MongoHelpers.MongoTestUserPassword }; request.Active = _currentActivitySetting; request.Roles.Add(_currentRole); User response = _client.Post(request); _userId = response.Id; }
public void MethodNotSupported_NotFoundException() { using (var client = new JsonServiceClient()) { var ex = Assert.Throws<WebServiceException>(()=> client.Post<string>( UrlFor("/languages"), null)); Assert.That(ex.StatusCode, Is.EqualTo((int)HttpStatusCode.NotFound)); } }
static void Main() { var client = new JsonServiceClient { BaseUri="http://10.1.1.106:2001", UserName="******", Password="******" }; var result = client.Post(new HelloRequest {Name = "Ameer"}).Result; Console.WriteLine(result); }
public static JsonServiceClient authenticatedClient(int domain_id, string username, string password) { var jsonclient = new JsonServiceClient("https://" + url); jsonclient.StoreCookies = true; var response = jsonclient.Post<AuthenticationResponse>(new Authentication() { domain_id = domain_id, password = password, username = username }); var headers = jsonclient.Headers.AllKeys; var cookie = new System.Net.Cookie("ss-id", response.session_id, "/", url); jsonclient.CookieContainer.Add(cookie); return jsonclient; }
private static void Main() { var client = new JsonServiceClient(Settings.Default.ServiceAddress); var shipInfo = client.Post<ShipInfo>(new AddShipCommand { ShipName = "Star" }); Console.WriteLine("The ship has added: {0}", shipInfo); var shipLocation = client.Get<ShipLocation>(new ShipLocationQuery { ShipId = shipInfo.Id }); Console.WriteLine("The ship {0}", shipLocation); Console.ReadKey(); }
public async Task Can_call_return_void() { client.Post(new ReturnsVoid { Message = "Foo" }); Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Foo")); await client.PostAsync(new ReturnsVoid { Message = "Foo" }); Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Foo")); }
public void Test_PATCH_PASS() { var restClient = new JsonServiceClient(serviceUrl); // register callback to grab the Location: header when executed string lastResponseLocation = ""; HttpStatusCode lastResponseStatusCode = 0; restClient.LocalHttpWebResponseFilter = httpRes => { lastResponseLocation = httpRes.Headers[HttpHeaders.Location]; lastResponseStatusCode = httpRes.StatusCode; }; // dummy data var newemp1 = new Employee() { Id = 123, Name = "Kimo", StartDate = new DateTime(2015, 7, 2), CubicleNo = 4234, Email = "*****@*****.**", }; restClient.Post<object>("/employees", newemp1); var emps = restClient.Get<List<Employee>>("/employees"); var emp = emps.First(); var empPatch = new Operations.EmployeePatch(); empPatch.Add(new Operations.JsonPatchElement() { op = "replace", path = "/title", value = "Kahuna Laau Lapaau", }); empPatch.Add(new Operations.JsonPatchElement() { op = "replace", path = "/cubicleno", value = "32", }); restClient.Patch<object>(string.Format("/employees/{0}", emp.Id), empPatch); var empAfterPatch = restClient.Get<Employee>(string.Format("/employees/{0}", emp.Id)); Assert.NotNull(empAfterPatch); // patched Assert.Equal("Kahuna Laau Lapaau", empAfterPatch.Title); Assert.Equal("32", empAfterPatch.CubicleNo.ToString()); // unpatched Assert.Equal("*****@*****.**", empAfterPatch.Email); }
public void PublishMessageToPhantonjs <T>(T request) { using (var client = new JsonServiceClient(AppConfig.PhantonjsOneWayUrl)) { try { client.Post(request); } catch (Exception e) { LogPublishException(request, e, "phn-remoto"); throw new HttpError(e.Message); } } }
/// <summary> /// Return true if we can connect to server /// </summary> /// <returns></returns> bool _LoginToServer() { var username = (string)Settings.Get(Enum_Settings_Key.SMS_SERVICE_USERNAME, "", Enum_Settings_DataType.String); var password = (string)Settings.Get(Enum_Settings_Key.SMS_SERVICE_PASSWORD, "", Enum_Settings_DataType.String); SMSServer_LoginModel loginmodel = new SMSServer_LoginModel() { Username = username, Password = password }; var login = server_client.Post(loginmodel); if (login.Status != null && login.Status.ErrorCode == "1") { return(true); } else { return(false); } }
public void ReceiveAndReleaseQuantity_HappyPath_ReceivesAndReleases() { var productId = Product.Light.Id; var locationId = Location.TestRack.Id; var rng = new Random(); var quant = rng.Next(10) + 1; var client = new JsonServiceClient(TestAppHost.BaseUri); var xact = new CreateInventoryTransaction { ProductId = productId, LocationId = locationId, Quantity = quant }; var count = new GetProductQuantityOnHand { Id = xact.ProductId }; var login = client.Post(new Authenticate { provider = AuthenticateService.CredentialsProvider, UserName = "******", Password = "******" }); client.SessionId = login.SessionId; client.Post(xact); var qoh = client.Get(count); Assert.GreaterOrEqual(quant, 1); Assert.NotNull(qoh); Assert.AreEqual(quant, qoh.Quantity); xact.Quantity = -xact.Quantity + 1; client.Post(xact); qoh = client.Get(count); Assert.NotNull(qoh); Assert.AreEqual(1, qoh.Quantity); }
private GetNextNumberResponse GetNextSequenceNumber(string key) { string url = (string)new AppSettingsReader().GetValue("NextSequenceNumberServiceUrl", typeof(string)); using (var client = new JsonServiceClient(url)) { var response = client.Post <GetNextNumberResponse>(new GetNextNumber { ForKey = key }); return(response); } }
private ProjectRole AddActorToRole(Uri projectUri, int roleId, string actorType, string actorName) { var uri = projectUri.Append(ProjectRoleUriPostfix).Append(roleId.ToString()); var actors = new List <string> { actorName }; var request = new JsonObject { { actorType, actors.ToJson() } }; return(client.Post <ProjectRole>(uri.ToString(), request)); }
public void BypassOAuthForTemporaryAccessToken() { var restClient = new JsonServiceClient(testServer.ListenUrl); var req = new OAuthTemporaryAccessTokenRequest(); req.Username = RainyTestServer.TEST_USER; req.Password = RainyTestServer.TEST_PASS; var token = restClient.Post <OAuthTemporaryAccessTokenResponse> ("/oauth/temporary_access_token", req); Assert.That(!token.AccessToken.StartsWith("oauth_")); Assert.GreaterOrEqual(400, token.AccessToken.Length); }
public static List <PatientIntervention> GetInterventions(GetInterventionsRequest request) { List <PatientIntervention> interventions = null; try { //[Route("/{Context}/{Version}/{ContractNumber}/Goal/Interventions", "POST")] IRestClient client = new JsonServiceClient(); string url = Common.Helper.BuildURL(string.Format("{0}/{1}/{2}/{3}/Goal/Interventions", DDPatientGoalsServiceUrl, "NG", request.Version, request.ContractNumber), request.UserId); GetPatientInterventionsDataResponse ddResponse = client.Post <GetPatientInterventionsDataResponse>(url, new GetPatientInterventionsDataRequest { Context = "NG", ContractNumber = request.ContractNumber, Version = request.Version, UserId = request.UserId, AssignedToId = request.AssignedToId, CreatedById = request.CreatedById, PatientId = request.PatientId, StatusIds = request.StatusIds } as object); if (ddResponse != null && ddResponse.InterventionsData != null) { var filteredInterventions = ddResponse.InterventionsData; if (request.InterventionFilterType != 0) { filteredInterventions = GetFilteredInterventions(ddResponse.InterventionsData, request); } interventions = new List <PatientIntervention>(); var patientIds = filteredInterventions.Select(x => x.PatientId).ToList(); var patientsDetails = GetPatientsDetails(request.Version, request.ContractNumber, request.UserId, client, patientIds); foreach (PatientInterventionData n in filteredInterventions) { PatientIntervention i = GoalsUtil.ConvertToIntervention(n); i.PatientDetails = patientsDetails.FirstOrDefault(x => x.Id == n.PatientId); i.PatientId = n.PatientId; interventions.Add(i); } } } catch { throw; } return(interventions); }
public void WhenCreatePerson_ThenReturnsPerson() { var client = new JsonServiceClient(ServiceUrl); var person = client.Post(new CreatePersonRequest { FirstName = "afirstname", LastName = "alastname" }).Person; person.Should().NotBeNull(); }
public bool PostHook(string repo, string url) { try { _client.Post <Hook>("repos/" + repo + "/hooks", new Hook(url)); } catch (Exception) { return(false); } return(true); }
public void flushToDisk(UserFile file) { try { logger.Debug("Flushing file to disk with filename and owner : " + file.filemetadata.filepath + " " + file.filemetadata.owner); JsonServiceClient client = new JsonServiceClient(PERSISTENT_STORAGE_SERVICE_ENDPOINT); client.Post <Object> ("/flushfile", new FlushFile { file = file }); } catch (Exception e) { logger.Warn(e); } }
protected virtual EventResponse ReportEvent(EventInfo eventInfo) { var eventInfoWithExceptionAsString = new EventInfoWithExceptionAsString { AdditionalInfo = eventInfo.AdditionalInfo, Exception = eventInfo.Exception?.ToString(), Message = eventInfo.Message, Type = (EventInfoWithExceptionAsString.EventType)eventInfo.Type }; return(_orchestratorClient.Post <EventResponse>($"/report?testName={TestName}", eventInfoWithExceptionAsString)); }
public void Authorize(ILoginSettings loginSettings) { _jsonServiceClient.LocalHttpWebRequestFilter = LocalHttpWebRequestFilter(loginSettings); var request = new Auth { UserName = loginSettings.UserName, Password = loginSettings.Password, RememberMe = true, //important tell client to retain permanent cookies }; _jsonServiceClient.Post(request); }
public void Does_compress_RequestDto_responses() { var client = new JsonServiceClient(Config.ListeningOn); var response = client.Post(new CompressData { String = "Hello", Bytes = "World".ToUtf8Bytes() }); Assert.That(response.String, Is.EqualTo("Hello")); Assert.That(response.Bytes, Is.EqualTo("World".ToUtf8Bytes())); }
public void Can_send_gzip_client_request_ASPNET() { var client = new JsonServiceClient(Config.AspNetServiceStackBaseUri) { RequestCompressionType = CompressionTypes.GZip, }; var response = client.Post(new HelloZip { Name = "GZIP" }); Assert.That(response.Result, Is.EqualTo("Hello, GZIP")); }
public TaskQueue.RepresentedModel GetValidationInfo(string MType, string channelName = null) { Validation.ValidationResponse result = client.Post <Validation.ValidationResponse>("/tmq/v", new Validation.ValidationRequest { MType = MType, ChannelName = channelName }); if (result == null) { throw new Exception(string.Format("Message type '{0}' not routed to worker module {1}", MType, channelName == null ? "" : string.Format("or '{1}' channel absent", channelName))); } return(TaskQueue.RepresentedModel.FromSchema(result.ModelScheme)); }
public void Can_send_Deflate_client_request() { var client = new JsonServiceClient(Config.ListeningOn) { RequestCompressionType = CompressionTypes.Deflate, }; var response = client.Post(new HelloZip { Name = "Deflate" }); Assert.That(response.Result, Is.EqualTo("Hello, Deflate")); }
private void BtnUpload_Click(object sender, EventArgs e) { var BrowseWin = new System.Windows.Forms.OpenFileDialog(); BrowseWin.Filter = "All Files (*.*)|*.*"; var ret = BrowseWin.ShowDialog(); if (ret == System.Windows.Forms.DialogResult.OK) { long FileVer = -1; string FileName = DirectoryTextBox.Text + BrowseWin.SafeFileName; foreach (FileMetaData file in FileList.fileMDList) { if (file.filepath == FileName) { FileVer = 1 + file.versionNumber; break; } } if (FileVer == -1) {// false FileVer = 1; } UpdateFile arg = new UpdateFile(); string LocalFilePath = BrowseWin.FileName; UserFile FileToUpload = new UserFile(FileName, ConnectedUser.ClientId); //byte[] fileStream = File.ReadAllBytes(LocalFilePath);` string fileStream = File.ReadAllText(LocalFilePath); //bool done = FileToUpload.SetFileContent(fileStream, (long)0); FileToUpload.SetFileContent(Encoding.UTF8.GetBytes(fileStream), FileVer); arg.file = FileToUpload; string requestUrl = string.Format("/updatefile/{0}/{1}", ConnectedUser.ClientId, ConnectedUser.Password); ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(ValidateRemoteCertificate); JsonServiceClient Updateclient = new JsonServiceClient(CLOUD_SERVICE_ENDPOINT); //Updateclient.ContentType = "application/json"; try { Updateclient.Post <Object>(requestUrl, arg); ClientFileSystem.addFileSynchronized(FileToUpload); // update clientfilesystem on upload } catch (Exception ex) { MessageBox.Show("This File has been changed by another client. Please download the latest copy and try to uplaod"); } //send file for Upload this.UpdateFileList(); } }
public void RunTests() { string username = "******"; string passHash = MD5Helper.CalculateMD5Hash("password"); JsonServiceClient client = new JsonServiceClient(SystemConstants.WebServiceBaseURL); Login(client, username, passHash); client.Get<XamarinEvolveSSLibrary.UserResponse>("User"); Logout(client); client.Get<XamarinEvolveSSLibrary.UserResponse>("User"); Login(client, username, passHash); User user = new User() { UserName = username, City = "changedtown", Email = "*****@*****.**" }; client.Post<XamarinEvolveSSLibrary.UserResponse>("User", user); Logout(client); client.Post<XamarinEvolveSSLibrary.UserResponse>("User", user); }
public static void CreateApp(string endpoint, string appName) { JsonServiceClient client = new JsonServiceClient(endpoint); client.Post(new Server.CreateAppRequest() { AppName = appName }); try { Server.CreateAppStatus status; do { status = client.Get(new Server.CreateAppStatusRequest() { AppName = appName }); if (status == null) break; Console.Write(status.Log); Thread.Sleep(200); } while (!status.Completed); } catch (WebServiceException e) { Console.WriteLine(e.ResponseBody); Console.WriteLine(e.ErrorMessage); Console.WriteLine(e.ServerStackTrace); } }
public void CanPerform_PartialUpdate() { var client = new JsonServiceClient("http://localhost:53990/api/"); // back date for readability var created = DateTime.Now.AddHours(-2); // Create a record so we can patch it var league = new League() {Name = "BEFORE", Abbreviation = "BEFORE", DateUpdated = created, DateCreated = created}; var newLeague = client.Post<League>(league); // Update Name and DateUpdated fields. Notice I don't want to update DateCreatedField. // I also added a fake field to show it does not cause any errors var updated = DateTime.Now; newLeague.Name = "AFTER"; newLeague.Abbreviation = "AFTER"; // setting to after but it should not get updated newLeague.DateUpdated = updated; client.Patch<League>("http://localhost:53990/api/leagues/" + newLeague.Id + "?fields=Name,DateUpdated,thisFieldDoesNotExist", newLeague); var updatedLeague = client.Get<League>(newLeague); Assert.AreEqual(updatedLeague.Name, "AFTER"); Assert.AreEqual(updatedLeague.Abbreviation, "BEFORE"); Assert.AreEqual(updatedLeague.DateUpdated.ToString(), updated.ToString(), "update fields don't match"); Assert.AreEqual(updatedLeague.DateCreated.ToString(), created.ToString(), "created fields don't match"); // double check Assert.AreNotEqual(updatedLeague.DateCreated, updatedLeague.DateUpdated); }