public void Init() { _auth = new AuthenticationClient(); _auth.UsernamePasswordAsync(ConsumerKey, ConsumerSecret, Username, Password, TokenRequestEndpointUrl).Wait(); _jsonHttpClient = new JsonHttpClient(_auth.InstanceUrl, _auth.ApiVersion, _auth.AccessToken, new HttpClient()); }
public void BeforeTests() { httpClient = server.CreateClient(); client = new JsonHttpClient("https://server.example.com") { HttpClient = httpClient }; }
public async Task Can_POST_to_IdWithAlias_with_JsonHttpClient_async() { var client = new JsonHttpClient(Config.AbsoluteBaseUri); var response = await client.PostAsync(new IdWithAlias { Id = 1 }); Assert.That(response.Id, Is.EqualTo(1)); }
public void StartNewSession_throws_on_invalid_json() { var jsonHttp = new JsonHttpClient( JsonHttpClientTest.SetupGet("} invalid json {").Object, ""); Assert.That(() => Client.StartNewSession(TestData.ClientInfo, jsonHttp), ExceptionsTest.ThrowsInvalidResponseWithMessage("Invalid JSON")); }
static void Main(string[] args) { Console.WriteLine("JsonHttpClient SampleClient"); Console.WriteLine(""); //Example 1 { Console.WriteLine("Example 1"); Model1 model1 = JsonHttpClient.Deserialize <Model1>("http://localhost:5000/api/values"); Console.WriteLine(model1.Property1); } Console.WriteLine(""); //Example 2 { Console.WriteLine("Example 2"); JsonHttpClient <Model1> jsonHttpClient = new JsonHttpClient <Model1>("http://localhost:5000/api/values"); jsonHttpClient.DeserializeInside(); Console.WriteLine(jsonHttpClient.Object.Property1); } Console.WriteLine(""); //Example 3 { Console.WriteLine("Example 3"); Console.WriteLine(new JsonHttpClient <Model1>("http://localhost:5000/api/values").Deserialize().Property1); } Console.WriteLine(""); //Example 4 { Console.WriteLine("Example 4"); JsonHttpClient <Model1> jsonHttpClient = new JsonHttpClient <Model1>() { Url = "http://localhost:5000/api/values", HttpClient = new HttpClient(new SocketsHttpHandler() { }) }; jsonHttpClient.DeserializeInside(); Console.WriteLine(jsonHttpClient.Object.Property1); } Console.WriteLine(""); Console.Write("press any key to continue..."); Console.ReadKey(); }
public void StartNewSession_throws_on_network_error() { var jsonHttp = new JsonHttpClient(JsonHttpClientTest.SetupGetWithFailure().Object, ""); Assert.That(() => Client.StartNewSession(TestData.ClientInfo, jsonHttp), ExceptionsTest.ThrowsReasonWithMessage( ClientException.FailureReason.NetworkError, "request")); }
public async Task Does_compress_raw_Bytes_responses_HttpClient() { var client = new JsonHttpClient(Config.ListeningOn); var response = await client.PostAsync(new CompressBytes { Bytes = "foo".ToUtf8Bytes(), }); Assert.That(response, Is.EquivalentTo("foo".ToUtf8Bytes())); }
public async Task Does_compress_raw_String_responses_HttpClient() { var client = new JsonHttpClient(Config.ListeningOn); var response = await client.PostAsync(new CompressString { String = "foo", }); Assert.That(response, Is.EqualTo("foo")); }
public void Can_send_GZip_client_request_HttpClient() { var client = new JsonHttpClient(Constants.ServiceStackBaseHost) { RequestCompressionType = CompressionTypes.GZip, }; var response = client.Post(new HelloZip { Name = "GZIP" }); Assert.That(response.Result, Is.EqualTo("Hello, GZIP")); }
public static void Main() { var a = new[] { 1, 2, 3, 4 }; Func <int, int, int> f = (x, y) => x * y; var h = f(2, 3); if (h != 6) { Global.Alert("Error."); } var b = a.Select(z => z * z).ToArray(); var d = Convert.ToBase64String(Enumerable.Range(0, 255).Select(i => (Byte)(i)).ToArray()); Q("#button_alert").Click(e => { Global.Alert("Test Alert Message"); }); Q("#button_template").Click(e => { var users = new[] { new { id = "zhang3", name = "ZHANG San" }, new { id = "li4", name = "LI Si" } }; var template = T("#tmpl_template"); var text = template.render(new { users = users }); Q("#tbody_template").Append(text); }); Q("#button_ajax").Click(e => { jQuery.GetJSON("users.json", null, (data, textStatus, jqXHR) => { var users = data; var template = T("#tmpl_template"); var text = template.render(new { users = users }); Q("#tbody_ajax").Append(text); }); }); var jsca = new JsonSerializationClientAdapter(); var jhc = new JsonHttpClient(jsca, "/api/", "q", true, false); var jc = jsca.GetApplicationClient(); Q("#button_servertime").Click(async e => { var r = await jc.ServerTime(new ServerTimeRequest { }); if (r.OnSuccess) { var Time = r.Success; var template = T("#tmpl_paragraph"); Q("#div_servertime").Append(template.render(new { content = Time })); } }); }
public void Init() { string jsonConfig = File.ReadAllText("appsettings.json"); var config = JsonConvert.DeserializeObject <BulkForceClientConfig>(jsonConfig); _config = config; _auth = new AuthenticationClient(); _auth.UsernamePasswordAsync(config.ConsumerKey, config.ConsumerSecret, config.UserName, config.Password, config.TokenRequestEndpointUrl).Wait(); _jsonHttpClient = new JsonHttpClient(_auth.InstanceUrl, _auth.ApiVersion, _auth.AccessToken, new HttpClient()); }
public void Can_send_Deflate_client_request_HttpClient() { var client = new JsonHttpClient(Config.ListeningOn) { RequestCompressionType = CompressionTypes.Deflate, }; var response = client.Post(new HelloZip { Name = "Deflate" }); Assert.That(response.Result, Is.EqualTo("Hello, Deflate")); }
public async Task Does_compress_RequestDto_responses_HttpClient() { var client = new JsonHttpClient(Config.ListeningOn); var response = await client.PostAsync(new CompressData { String = "Hello", Bytes = "World".ToUtf8Bytes() }); Assert.That(response.String, Is.EqualTo("Hello")); Assert.That(response.Bytes, Is.EqualTo("World".ToUtf8Bytes())); }
public async Task <ContentResult> GetEvents() { var start = DateTime.Now.AddDays(-1); var end = start.AddDays(60); var url = string.Format("https://vocadb.net/api/releaseEvents?sort=Date&maxResults=100&afterDate={0:u}&beforeDate={1:u}", start, end); var vbEvents = await JsonHttpClient.GetObject <PartialFindResult <VdbEvent> >(url); var events = vbEvents.Items.Where(e => e.Date.HasValue).Select(CreateCalendarEvent); return(CalendarResponseFactory.CreateCalendarContentResult(Response, events, "events.ics")); }
public async Task <ContentResult> GetAlbums() { var start = DateTime.Now.AddDays(-1); var end = start.AddDays(60); var url = string.Format("https://vocadb.net/api/albums?sort=ReleaseDate&maxResults=100&releaseDateAfter={0:u}&releaseDateBefore={1:u}", start, end); var albums = await JsonHttpClient.GetObject <PartialFindResult <Album> >(url); var events = albums.Items.Select(CreateCalendarEvent); return(CalendarResponseFactory.CreateCalendarContentResult(Response, events, "albums.ics")); }
public void Does_handle_concurrent_requests() { var rand = new Random(); var client = new JsonHttpClient(Config.AbsoluteBaseUri); client.GetHttpClient().Timeout = TimeSpan.FromMinutes(5); long responsesReceived = 0; long totalSecondsWaited = 0; var sw = Stopwatch.StartNew(); const int ConcurrentRequests = 50; ConcurrentRequests.Times(i => { Interlocked.Increment(ref responsesReceived); ThreadPool.QueueUserWorkItem(async _ => { var request = new SleepTest { Name = $"Request {i+1}", WaitingSecs = rand.Next(30, 60), }; Interlocked.Add(ref totalSecondsWaited, request.WaitingSecs); log.Info($"[{DateTime.Now.TimeOfDay}] Sending {request.Name} to sleep for {request.WaitingSecs} seconds..."); try { var response = await client.GetAsync(request); log.Info($"[{DateTime.Now.TimeOfDay}] Received {request.Name}: {response.Message}"); } catch (Exception ex) { log.Error($"[{DateTime.Now.TimeOfDay}] Error Response: {ex.UnwrapIfSingleException().Message}", ex); } finally { Interlocked.Decrement(ref responsesReceived); } }); }); while (Interlocked.Read(ref responsesReceived) > 0) { Thread.Sleep(10); } log.Info($"Took {sw.Elapsed.TotalSeconds} to execute {ConcurrentRequests} Concurrent Requests waiting a total of {totalSecondsWaited} seconds."); }
public DnfClient(string?instanceUrl, string?accessToken, string?refreshToken, Action <string>?logger = null) { Logger = logger; SelectListResolver = new DataMemberSelectListResolver(); HttpClient jsonClient; HttpClient xmlClient; if (UseCompression) { var httpHandler = new HttpClientHandler { AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate }; jsonClient = new HttpClient(httpHandler) { Timeout = TimeSpan.FromSeconds(60 * 30) }; //jsonClient.DefaultRequestHeaders.ConnectionClose = true; jsonClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip")); xmlClient = new HttpClient(httpHandler) { Timeout = TimeSpan.FromSeconds(60 * 30) }; } else { jsonClient = new HttpClient { Timeout = TimeSpan.FromSeconds(60 * 30) }; xmlClient = new HttpClient { Timeout = TimeSpan.FromSeconds(60 * 30) }; } //xmlClient.DefaultRequestHeaders.ConnectionClose = true; xmlClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip")); InstanceUrl = instanceUrl; AccessToken = accessToken; RefreshToken = refreshToken; ApiVersion = DefaultApiVersion; JsonHttp = new JsonHttpClient(InstanceUrl, ApiVersion, AccessToken, jsonClient); XmlHttp = new XmlHttpClient(InstanceUrl, ApiVersion, AccessToken, xmlClient); Chatter = new ChatterClient(JsonHttp); Composite = new CompositeClient(JsonHttp, ApiVersion, Logger); Tooling = new ToolingClient(JsonHttp); Bulk = new BulkClient(XmlHttp, JsonHttp); Layout = new LayoutClient(XmlHttp, JsonHttp); }
public void Does_change_BasePath_HttpClient() { var client = new JsonHttpClient("https://example.org") { UseBasePath = "/api" }; Assert.That(client.SyncReplyBaseUri, Is.EqualTo("https://example.org/api/")); Assert.That(client.AsyncOneWayBaseUri, Is.EqualTo("https://example.org/api/")); client.UseBasePath = null; Assert.That(client.SyncReplyBaseUri, Is.EqualTo("https://example.org/json/reply/")); Assert.That(client.AsyncOneWayBaseUri, Is.EqualTo("https://example.org/json/oneway/")); }
public async Task <bool> Connect(string serviceUri) { client = JsonHttpClient.Create(serviceUri + baseApiPath, AddAuthorization); try { var result = await client.Send <string>(HttpMethod.Get, "/"); return(result.Response.StatusCode == HttpStatusCode.OK); } catch { return(false); } }
public void ResponseFilterIShouldHaveVaryFilterTest() { using (var client = new JsonHttpClient(Config.ListeningOn)) { client.ResponseFilter = message => { var headers = message.Headers.Vary.Join(","); Assert.That(headers, Is.EqualTo("accept,origin,authorization")); Assert.That(message.Headers.CacheControl.ToString(), Is.EqualTo("no-cache")); }; var response = client.Get(new ResponseFilterWithVaryRequest()); Assert.That(response, Is.EqualTo("Should have vary headers.")); } }
public void CheckInterfaces() { using (IAuthenticationClient aa = new AuthenticationClient()) { Assert.IsNotNull(aa); } using (IJsonHttpClient aa = new JsonHttpClient("instanceUrl", "apiVersion", "accessToken", new HttpClient())) { Assert.IsNotNull(aa); } using (IXmlHttpClient aa = new XmlHttpClient("instanceUrl", "apiVersion", "accessToken", new HttpClient())) { Assert.IsNotNull(aa); } }
public void Load_test_GetFactorialSync_HttpClient_sync() { var client = new JsonHttpClient(Config.ListeningOn); for (var i = 0; i < NoOfTimes; i++) { var response = client.Get(new GetFactorialSync { ForNumber = 3 }); if (i % 100 == 0) { "{0}: {1}".Print(i, response.Result); } } }
public async Task Requests_CheckCustomRequestsHeaders() { var client = new HttpClient(new ServiceClientRouteHandler(r => { Assert.IsNotNull(r.Headers.GetValues("headername")); Assert.AreEqual(r.Headers.GetValues("headername").FirstOrDefault(), "headervalue"); })); client.DefaultRequestHeaders.Add("headername", "headervalue"); using (var httpClient = new JsonHttpClient("http://localhost:1899", "v36", "accessToken", client)) { await httpClient.HttpGetAsync <object>("wade"); } }
public void NewServiceHttpClient_ResetsUserAgents() { var httpClientUserAgent = UserAgent + "/v36"; var httpClient = new HttpClient(); httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(httpClientUserAgent); httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(httpClientUserAgent); Assert.AreEqual(httpClientUserAgent + " " + httpClientUserAgent, httpClient.DefaultRequestHeaders.UserAgent.ToString()); var serviceClient = new JsonHttpClient("http://localhost:1899", "v36", "accessToken", httpClient); // Ensure the old user agent header is replaced. Assert.AreEqual(httpClientUserAgent, httpClient.DefaultRequestHeaders.UserAgent.ToString()); }
public void Can_send_GZip_client_request_list_HttpClient() { var client = new JsonHttpClient(Config.ListeningOn) { RequestCompressionType = CompressionTypes.GZip, }; var response = client.Post(new HelloZip { Name = "GZIP", Test = new List <string> { "Test" } }); Assert.That(response.Result, Is.EqualTo("Hello, GZIP (1)")); }
public async Task Does_not_compress_error_responses_HttpClient() { var client = new JsonHttpClient(Config.ListeningOn); try { await client.PostAsync(new CompressError()); Assert.Fail("Should throw"); } catch (WebServiceException ex) { Assert.That(ex.StatusCode, Is.EqualTo(404)); Assert.That(ex.ErrorCode, Is.EqualTo("NotFound")); Assert.That(ex.ErrorMessage, Is.EqualTo("Always NotFound")); } }
private async Task <string> PostRequest(RpcCommand request) { try { using (var client = new JsonHttpClient(VergeConfig.GetUri())) { client.AddHeader("Authorization", VergeConfig.GetAuthHeaderValue()); var response = await client.PostAsync <string>(new Payload(request)); return(response); } } catch (Exception ex) { throw new HttpError(HttpStatusCode.InternalServerError, ex); } }
public async void Requests_CheckHttpRequestMessage_HttpGet_WithNode() { var client = new HttpClient(new ServiceClientRouteHandler(r => { Assert.AreEqual(r.RequestUri.ToString(), "http://localhost:1899/services/data/v34/wade"); Assert.IsNotNull(r.Headers.UserAgent); Assert.AreEqual(r.Headers.UserAgent.ToString(), UserAgent + "/v34"); Assert.IsNotNull(r.Headers.Authorization); Assert.AreEqual(r.Headers.Authorization.ToString(), "Bearer accessToken"); })); using (var httpClient = new JsonHttpClient("http://localhost:1899", "v34", "accessToken", client)) { await httpClient.HttpGetAsync<object>("wade"); } }
public async Task Requests_CheckHttpRequestMessage_HttpPost() { var client = new HttpClient(new ServiceClientRouteHandler(r => { Assert.AreEqual(r.RequestUri.ToString(), "http://localhost:1899/services/data/v36/wade"); Assert.IsNotNull(r.Headers.UserAgent); Assert.AreEqual(r.Headers.UserAgent.ToString(), UserAgent + "/v36"); Assert.IsNotNull(r.Headers.Authorization); Assert.AreEqual(r.Headers.Authorization.ToString(), "Bearer accessToken"); })); using (var httpClient = new JsonHttpClient("http://localhost:1899", "v36", "accessToken", client)) { await httpClient.HttpPostAsync <object>(null, "wade"); } }
public async Task ThrowAsync_ServiceException_only_calls_ServiceExceptionHandlers() { ServiceEx = UnHandledEx = null; var client = new JsonHttpClient(Config.ListeningOn); try { var response = await client.GetAsync(new ThrowAsync()); Assert.Fail("Should fail"); } catch (WebServiceException ex) { Assert.That(ServiceEx.Message, Is.EqualTo(nameof(ThrowAsync))); Assert.That(UnHandledEx, Is.Null); Assert.That(ex.Message, Is.EqualTo(nameof(ThrowAsync))); } }
public void Does_serialize_request() { var client = new JsonHttpClient(Config.ListeningOn); var response = client.Put(new PutConfirmed { Confirmations = new List <Confirmation> { new Confirmation { ChangeId = 126552616, Confirmed = true, } } }); Assert.That(response.IsSucceed); }
/// <summary>Inititialies a new <see cref="ClientSession"/>.</summary> /// <param name="authenticationSetting">The authentication settings.</param> /// <returns>The initialize session.</returns> public static ClientSession InitializeSession(AuthenticationSetting authenticationSetting) { Uri addressUri = ServiceAddressProvider.ServiceAddress(new Uri(authenticationSetting.ServiceUrl)); ICredentials credentials = null; switch (authenticationSetting.AuthenticationScheme) { case AuthenticationScheme.UserNamePassword: credentials = new NetworkCredential(authenticationSetting.Username, authenticationSetting.Password); break; case AuthenticationScheme.AzureActiveDirectory: using (var client = new HttpClient()) { var result = client.PostAsync(new Uri(authenticationSetting.Authority + "/oauth2/token"), new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("resource", authenticationSetting.Resource), new KeyValuePair <string, string>("client_id", authenticationSetting.ClientId), new KeyValuePair <string, string>("grant_type", "password"), new KeyValuePair <string, string>("username", authenticationSetting.Username), new KeyValuePair <string, string>("password", authenticationSetting.Password), new KeyValuePair <string, string>("scope", "openid"), new KeyValuePair <string, string>("client_secret", authenticationSetting.ClientSecret), })).Result; var content = result.Content.ReadAsStringAsync().Result; var authResult = JsonConvert.DeserializeObject <OAuthResult>(content); credentials = new TokenCredential(authResult.Access_Token); } break; case AuthenticationScheme.Windows: // Windows auth is supported break; default: throw new Exception("Unsupported Authentication Scheme"); } var jsonClient = new JsonHttpClient(addressUri, credentials, authenticationSetting.AuthenticationScheme); return(new ClientSession(jsonClient, new NonDispatcher(), new TimerFactory <TaskTimer>())); }
public async void BadTokenHandling() { _auth = new AuthenticationClient(); _auth.UsernamePasswordAsync(ConsumerKey, ConsumerSecret, Username, Password, TokenRequestEndpointUrl).Wait(); var badToken = "badtoken"; var serviceHttpClient = new JsonHttpClient(_auth.InstanceUrl, _auth.ApiVersion, badToken, new HttpClient()); const string query = "SELECT count() FROM Account"; try { await serviceHttpClient.HttpGetAsync<QueryResult<dynamic>>(string.Format("query?q={0}", query)); } catch (ForceException ex) { Assert.IsNotNull(ex); Assert.IsNotNull(ex.Message); Assert.That(ex.Message, Is.EqualTo("Session expired or invalid")); Assert.IsNotNull(ex.Error); } }
public async void Requests_CheckCustomRequestsHeaders() { var client = new HttpClient(new ServiceClientRouteHandler(r => { Assert.IsNotNull(r.Headers.GetValues("headername")); Assert.AreEqual(r.Headers.GetValues("headername").FirstOrDefault(), "headervalue"); })); client.DefaultRequestHeaders.Add("headername", "headervalue"); using (var httpClient = new JsonHttpClient("http://localhost:1899", "v32", "accessToken", client)) { await httpClient.HttpGetAsync<object>("wade"); } }
/// <summary>Inititialies a new <see cref="ClientSession"/>.</summary> /// <param name="serviceAddress">The service Address.</param> /// <param name="tenantId">The optional tenant id.</param> /// <param name="company">The company to open</param> /// <param name="authentication">The authentication.</param> /// <param name="username">The username.</param> /// <param name="password">The password.</param> /// <returns>The initialize session.</returns> public static ClientSession InitializeSession(string serviceAddress, string tenantId = null, string company = null, AuthenticationScheme? authentication = null, string username = null, string password = null) { if (string.IsNullOrWhiteSpace(serviceAddress)) { throw new ArgumentNullException("serviceAddress"); } if (!string.IsNullOrEmpty(tenantId)) { serviceAddress += "?tenant=" + tenantId; } if (!string.IsNullOrEmpty(company)) { serviceAddress += (string.IsNullOrEmpty(tenantId) ? "?" : "&") + "company=" + Uri.EscapeDataString(company); } Uri addressUri = ServiceAddressProvider.ServiceAddress(new Uri(serviceAddress)); ICredentials credentials = null; if (authentication.GetValueOrDefault() == AuthenticationScheme.UserNamePassword) { credentials = new NetworkCredential(username, password); } var jsonClient = new JsonHttpClient(addressUri, credentials, authentication.GetValueOrDefault()); return new ClientSession(jsonClient, new NonDispatcher(), new TimerFactory<TaskTimer>()); }
private async Task<ObservableCollection<ResponseObject>> consultaServidorLicencas (object requestObj) { Console.WriteLine ("*** Consultando servidor de licenças......"); try { // consultar servico de licenças string urlcommerce = "http://mysafety.dyndns.org:8080/WsWebGate/json/registerclient/post"; JsonHttpClient service = new JsonHttpClient (); var request = (HttpWebRequest)WebRequest.Create (urlcommerce); request.Method = "POST"; request.Accept = "application/json"; var x = await service.PostAsync<ObservableCollection<ResponseObject>> (urlcommerce, requestObj); if (x != null) return x; } catch (Exception ex) { Console.WriteLine ("*** Exception Consultando servidor de licenças......" + ex); } return new ObservableCollection<ResponseObject> (); }
async void OpAction () { var sheet = await DisplayActionSheet (null, "Voltar", null, "Esqueci minha senha", null, "Reenviar email de confirmação"); if (sheet.Equals ("Esqueci minha senha")) Device.OpenUri (new Uri ("http://www.ineltec.com.br/index3.htm")); if (sheet.Equals ("Reenviar email de confirmação")) { PromptResult input = null; input = await UserDialogs.Instance.PromptAsync ("Reenviar email", "MySafety", "Ok", "Cancelar", "*****@*****.**", InputType.Email); if (input.Ok == true) { if (String.IsNullOrEmpty (input.Text)) { await DisplayAlert ("MySafety", "Email é obrigatório", "OK"); return; } if (!CrossConnectivity.Current.IsConnected) { await DependencyService.Get<IToastNotificator> ().Notify (ToastNotificationType.Error, "MySafety", "Não há conexão com internet.\nTente mais tarde.", TimeSpan.FromSeconds (3)); return; } string urlsite = "http://mysafety.azurewebsites.net/api/resend"; JsonHttpClient service = new JsonHttpClient (); var request = (HttpWebRequest)WebRequest.Create (urlsite); request.Method = "POST"; request.Accept = "application/json"; var result = await service.PostAsync<string> (urlsite, input.Text); await DisplayAlert ("MySafety", result, "OK"); } } }
public async Task Can_post_raw_response_as_raw_JSON_HttpClient() { var httpClient = new JsonHttpClient(BaseUrl); var request = new GetCustomer { CustomerId = 5 }; var response = httpClient.Post(request); Assert.That(response.Customer.Id, Is.EqualTo(5)); var requestPath = request.ToPostUrl(); string json = request.ToJson(); response = await httpClient.PostAsync<GetCustomerResponse>(requestPath, json); Assert.That(response.Customer.Id, Is.EqualTo(5)); byte[] bytes = json.ToUtf8Bytes(); response = await httpClient.PutAsync<GetCustomerResponse>(requestPath, bytes); Assert.That(response.Customer.Id, Is.EqualTo(5)); Stream ms = new MemoryStream(bytes); response = await httpClient.PostAsync<GetCustomerResponse>(requestPath, ms); Assert.That(response.Customer.Id, Is.EqualTo(5)); }