9388947971

Committed 05 Jun 2024 05:56PM UTC coverage: 57.76% (+0.2%) from 57.587%

Build # 9388947971

Build Type

push

github

Committed by

pwelter34

Commit Message

fix flaky tests

Run Details

277 of 614 branches covered (45.11%)

Branch coverage included in aggregate %.

847 of 1332 relevant lines covered (63.59%)

73.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.27

/src/FluentRest/FluentClientExtensions.cs

namespace FluentRest;

/// <summary>
/// Extension methods for <see cref="IFluentClient"/>
/// </summary>
public static class FluentClientExtensions
{
    /// <summary>
    /// Sends a GET request using specified fluent <paramref name="builder" /> as an asynchronous operation.
    /// </summary>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>
    /// The task object representing the asynchronous operation.
    /// </returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<HttpResponseMessage> GetAsync(this IFluentClient fluentClient, Action<QueryBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var httpClient = fluentClient.HttpClient;
        var requestMessage = new HttpRequestMessage(HttpMethod.Get, httpClient.BaseAddress);
        requestMessage.SetContentSerializer(fluentClient.ContentSerializer);

        var fluentBuilder = new QueryBuilder(requestMessage);
        builder(fluentBuilder);

        var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);

        return response;
    }

    /// <summary>
    /// Sends a GET request using specified fluent <paramref name="builder"/> as an asynchronous operation.
    /// </summary>
    /// <typeparam name="TResponse">The type of the response.</typeparam>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<TResponse> GetAsync<TResponse>(this IFluentClient fluentClient, Action<QueryBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var response = await fluentClient.GetAsync(builder).ConfigureAwait(false);
        var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);

        return data;
    }


    /// <summary>
    /// Sends a POST request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<HttpResponseMessage> PostAsync(this IFluentClient fluentClient, Action<FormBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var httpClient = fluentClient.HttpClient;
        var requestMessage = new HttpRequestMessage(HttpMethod.Post, httpClient.BaseAddress);
        requestMessage.SetContentSerializer(fluentClient.ContentSerializer);

        var fluentBuilder = new FormBuilder(requestMessage);
        builder(fluentBuilder);

        var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);

        return response;
    }

    /// <summary>
    /// Sends a POST request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <typeparam name="TResponse">The type of the response.</typeparam>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<TResponse> PostAsync<TResponse>(this IFluentClient fluentClient, Action<FormBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var response = await fluentClient.PostAsync(builder).ConfigureAwait(false);
        var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);

        return data;
    }


    /// <summary>
    /// Sends a PUT request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<HttpResponseMessage> PutAsync(this IFluentClient fluentClient, Action<FormBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var httpClient = fluentClient.HttpClient;
        var requestMessage = new HttpRequestMessage(HttpMethod.Put, httpClient.BaseAddress);
        requestMessage.SetContentSerializer(fluentClient.ContentSerializer);

        var fluentBuilder = new FormBuilder(requestMessage);
        builder(fluentBuilder);

        var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);

        return response;
    }

    /// <summary>
    /// Sends a PUT request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <typeparam name="TResponse">The type of the response.</typeparam>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<TResponse> PutAsync<TResponse>(this IFluentClient fluentClient, Action<FormBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var response = await fluentClient.PutAsync(builder).ConfigureAwait(false);
        var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);

        return data;
    }


    /// <summary>
    /// Sends a PATCH request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<HttpResponseMessage> PatchAsync(this IFluentClient fluentClient, Action<FormBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var httpClient = fluentClient.HttpClient;
        var requestMessage = new HttpRequestMessage(FormBuilder.HttpPatch, httpClient.BaseAddress);
        requestMessage.SetContentSerializer(fluentClient.ContentSerializer);

        var fluentBuilder = new FormBuilder(requestMessage);
        builder(fluentBuilder);

        var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);

        return response;
    }

    /// <summary>
    /// Sends a PATCH request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <typeparam name="TResponse">The type of the response.</typeparam>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<TResponse> PatchAsync<TResponse>(this IFluentClient fluentClient, Action<FormBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var response = await fluentClient.PatchAsync(builder).ConfigureAwait(false);
        var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);

        return data;
    }


    /// <summary>
    /// Sends a DELETE request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<HttpResponseMessage> DeleteAsync(this IFluentClient fluentClient, Action<FormBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var httpClient = fluentClient.HttpClient;
        var requestMessage = new HttpRequestMessage(HttpMethod.Delete, httpClient.BaseAddress);
        requestMessage.SetContentSerializer(fluentClient.ContentSerializer);

        var fluentBuilder = new FormBuilder(requestMessage);
        builder(fluentBuilder);

        var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);

        return response;
    }

    /// <summary>
    /// Sends a DELETE request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <typeparam name="TResponse">The type of the response.</typeparam>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<TResponse> DeleteAsync<TResponse>(this IFluentClient fluentClient, Action<FormBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var response = await fluentClient.DeleteAsync(builder).ConfigureAwait(false);
        var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);

        return data;
    }


    /// <summary>
    /// Sends a request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<HttpResponseMessage> SendAsync(this IFluentClient fluentClient, Action<SendBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var httpClient = fluentClient.HttpClient;
        var requestMessage = new HttpRequestMessage(HttpMethod.Post, httpClient.BaseAddress);
        requestMessage.SetContentSerializer(fluentClient.ContentSerializer);

        var fluentBuilder = new SendBuilder(requestMessage);
        builder(fluentBuilder);

        var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);

        return response;
    }

    /// <summary>
    /// Sends a request using specified fluent builder as an asynchronous operation.
    /// </summary>
    /// <typeparam name="TResponse">The type of the response.</typeparam>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="builder">The fluent builder factory.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
    public static async Task<TResponse> SendAsync<TResponse>(this IFluentClient fluentClient, Action<SendBuilder> builder)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        var response = await fluentClient.SendAsync(builder).ConfigureAwait(false);
        var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);

        return data;
    }


    /// <summary>
    /// Sends a request using specified request message as an asynchronous operation.
    /// </summary>
    /// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
    /// <param name="requestMessage">The request message to send.</param>
    /// <returns>The task object representing the asynchronous operation.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="requestMessage" /> is <see langword="null" />.</exception>
    public static async Task<HttpResponseMessage> SendAsync(this IFluentClient fluentClient, HttpRequestMessage requestMessage)
    {
        if (fluentClient == null)
            throw new ArgumentNullException(nameof(fluentClient));

        if (requestMessage == null)
            throw new ArgumentNullException(nameof(requestMessage));

        var httpClient = fluentClient.HttpClient;

        requestMessage.SetContentSerializer(fluentClient.ContentSerializer);

        var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);

        return response;
    }

}

1	namespace FluentRest;
2
3	/// <summary>
4	/// Extension methods for <see cref="IFluentClient"/>
5	/// </summary>
6	public static class FluentClientExtensions
7	{
8	/// <summary>
9	/// Sends a GET request using specified fluent <paramref name="builder" /> as an asynchronous operation.
10	/// </summary>
11	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
12	/// <param name="builder">The fluent builder factory.</param>
13	/// <returns>
14	/// The task object representing the asynchronous operation.
15	/// </returns>
16	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
17	public static async Task<HttpResponseMessage> GetAsync(this IFluentClient fluentClient, Action<QueryBuilder> builder)
18	{
19	if (fluentClient == null)	33!
20	throw new ArgumentNullException(nameof(fluentClient));	×
21
22	if (builder == null)	33!
23	throw new ArgumentNullException(nameof(builder));	×
24
25	var httpClient = fluentClient.HttpClient;	33✔
26	var requestMessage = new HttpRequestMessage(HttpMethod.Get, httpClient.BaseAddress);	33✔
27	requestMessage.SetContentSerializer(fluentClient.ContentSerializer);	33✔
28
29	var fluentBuilder = new QueryBuilder(requestMessage);	33✔
30	builder(fluentBuilder);	33✔
31
32	var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);	33✔
33
34	return response;	30✔
35	}	30✔
36
37	/// <summary>
38	/// Sends a GET request using specified fluent <paramref name="builder"/> as an asynchronous operation.
39	/// </summary>
40	/// <typeparam name="TResponse">The type of the response.</typeparam>
41	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
42	/// <param name="builder">The fluent builder factory.</param>
43	/// <returns>The task object representing the asynchronous operation.</returns>
44	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
45	public static async Task<TResponse> GetAsync<TResponse>(this IFluentClient fluentClient, Action<QueryBuilder> builder)
46	{
47	if (fluentClient == null)	33!
48	throw new ArgumentNullException(nameof(fluentClient));	×
49
50	if (builder == null)	33!
51	throw new ArgumentNullException(nameof(builder));	×
52
53	var response = await fluentClient.GetAsync(builder).ConfigureAwait(false);	33✔
54	var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);	30✔
55
56	return data;	30✔
57	}	30✔
58
59
60	/// <summary>
61	/// Sends a POST request using specified fluent builder as an asynchronous operation.
62	/// </summary>
63	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
64	/// <param name="builder">The fluent builder factory.</param>
65	/// <returns>The task object representing the asynchronous operation.</returns>
66	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
67	public static async Task<HttpResponseMessage> PostAsync(this IFluentClient fluentClient, Action<FormBuilder> builder)
68	{
69	if (fluentClient == null)	48!
70	throw new ArgumentNullException(nameof(fluentClient));	×
71
72	if (builder == null)	48!
73	throw new ArgumentNullException(nameof(builder));	×
74
75	var httpClient = fluentClient.HttpClient;	48✔
76	var requestMessage = new HttpRequestMessage(HttpMethod.Post, httpClient.BaseAddress);	48✔
77	requestMessage.SetContentSerializer(fluentClient.ContentSerializer);	48✔
78
79	var fluentBuilder = new FormBuilder(requestMessage);	48✔
80	builder(fluentBuilder);	48✔
81
82	var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);	48✔
83
84	return response;	48✔
85	}	48✔
86
87	/// <summary>
88	/// Sends a POST request using specified fluent builder as an asynchronous operation.
89	/// </summary>
90	/// <typeparam name="TResponse">The type of the response.</typeparam>
91	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
92	/// <param name="builder">The fluent builder factory.</param>
93	/// <returns>The task object representing the asynchronous operation.</returns>
94	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
95	public static async Task<TResponse> PostAsync<TResponse>(this IFluentClient fluentClient, Action<FormBuilder> builder)
96	{
97	if (fluentClient == null)	45!
98	throw new ArgumentNullException(nameof(fluentClient));	×
99
100	if (builder == null)	45!
101	throw new ArgumentNullException(nameof(builder));	×
102
103	var response = await fluentClient.PostAsync(builder).ConfigureAwait(false);	45✔
104	var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);	45✔
105
106	return data;	42✔
107	}	42✔
108
109
110	/// <summary>
111	/// Sends a PUT request using specified fluent builder as an asynchronous operation.
112	/// </summary>
113	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
114	/// <param name="builder">The fluent builder factory.</param>
115	/// <returns>The task object representing the asynchronous operation.</returns>
116	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
117	public static async Task<HttpResponseMessage> PutAsync(this IFluentClient fluentClient, Action<FormBuilder> builder)
118	{
119	if (fluentClient == null)	3!
120	throw new ArgumentNullException(nameof(fluentClient));	×
121
122	if (builder == null)	3!
123	throw new ArgumentNullException(nameof(builder));	×
124
125	var httpClient = fluentClient.HttpClient;	3✔
126	var requestMessage = new HttpRequestMessage(HttpMethod.Put, httpClient.BaseAddress);	3✔
127	requestMessage.SetContentSerializer(fluentClient.ContentSerializer);	3✔
128
129	var fluentBuilder = new FormBuilder(requestMessage);	3✔
130	builder(fluentBuilder);	3✔
131
132	var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);	3✔
133
134	return response;	3✔
135	}	3✔
136
137	/// <summary>
138	/// Sends a PUT request using specified fluent builder as an asynchronous operation.
139	/// </summary>
140	/// <typeparam name="TResponse">The type of the response.</typeparam>
141	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
142	/// <param name="builder">The fluent builder factory.</param>
143	/// <returns>The task object representing the asynchronous operation.</returns>
144	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
145	public static async Task<TResponse> PutAsync<TResponse>(this IFluentClient fluentClient, Action<FormBuilder> builder)
146	{
147	if (fluentClient == null)	3!
148	throw new ArgumentNullException(nameof(fluentClient));	×
149
150	if (builder == null)	3!
151	throw new ArgumentNullException(nameof(builder));	×
152
153	var response = await fluentClient.PutAsync(builder).ConfigureAwait(false);	3✔
154	var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);	3✔
155
156	return data;	3✔
157	}	3✔
158
159
160	/// <summary>
161	/// Sends a PATCH request using specified fluent builder as an asynchronous operation.
162	/// </summary>
163	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
164	/// <param name="builder">The fluent builder factory.</param>
165	/// <returns>The task object representing the asynchronous operation.</returns>
166	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
167	public static async Task<HttpResponseMessage> PatchAsync(this IFluentClient fluentClient, Action<FormBuilder> builder)
168	{
169	if (fluentClient == null)	6!
170	throw new ArgumentNullException(nameof(fluentClient));	×
171
172	if (builder == null)	6!
173	throw new ArgumentNullException(nameof(builder));	×
174
175	var httpClient = fluentClient.HttpClient;	6✔
176	var requestMessage = new HttpRequestMessage(FormBuilder.HttpPatch, httpClient.BaseAddress);	6✔
177	requestMessage.SetContentSerializer(fluentClient.ContentSerializer);	6✔
178
179	var fluentBuilder = new FormBuilder(requestMessage);	6✔
180	builder(fluentBuilder);	6✔
181
182	var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);	6✔
183
184	return response;	6✔
185	}	6✔
186
187	/// <summary>
188	/// Sends a PATCH request using specified fluent builder as an asynchronous operation.
189	/// </summary>
190	/// <typeparam name="TResponse">The type of the response.</typeparam>
191	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
192	/// <param name="builder">The fluent builder factory.</param>
193	/// <returns>The task object representing the asynchronous operation.</returns>
194	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
195	public static async Task<TResponse> PatchAsync<TResponse>(this IFluentClient fluentClient, Action<FormBuilder> builder)
196	{
197	if (fluentClient == null)	3!
198	throw new ArgumentNullException(nameof(fluentClient));	×
199
200	if (builder == null)	3!
201	throw new ArgumentNullException(nameof(builder));	×
202
203	var response = await fluentClient.PatchAsync(builder).ConfigureAwait(false);	3✔
204	var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);	3✔
205
206	return data;	3✔
207	}	3✔
208
209
210	/// <summary>
211	/// Sends a DELETE request using specified fluent builder as an asynchronous operation.
212	/// </summary>
213	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
214	/// <param name="builder">The fluent builder factory.</param>
215	/// <returns>The task object representing the asynchronous operation.</returns>
216	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
217	public static async Task<HttpResponseMessage> DeleteAsync(this IFluentClient fluentClient, Action<FormBuilder> builder)
218	{
219	if (fluentClient == null)	3!
220	throw new ArgumentNullException(nameof(fluentClient));	×
221
222	if (builder == null)	3!
223	throw new ArgumentNullException(nameof(builder));	×
224
225	var httpClient = fluentClient.HttpClient;	3✔
226	var requestMessage = new HttpRequestMessage(HttpMethod.Delete, httpClient.BaseAddress);	3✔
227	requestMessage.SetContentSerializer(fluentClient.ContentSerializer);	3✔
228
229	var fluentBuilder = new FormBuilder(requestMessage);	3✔
230	builder(fluentBuilder);	3✔
231
232	var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);	3✔
233
234	return response;	3✔
235	}	3✔
236
237	/// <summary>
238	/// Sends a DELETE request using specified fluent builder as an asynchronous operation.
239	/// </summary>
240	/// <typeparam name="TResponse">The type of the response.</typeparam>
241	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
242	/// <param name="builder">The fluent builder factory.</param>
243	/// <returns>The task object representing the asynchronous operation.</returns>
244	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
245	public static async Task<TResponse> DeleteAsync<TResponse>(this IFluentClient fluentClient, Action<FormBuilder> builder)
246	{
247	if (fluentClient == null)	3!
248	throw new ArgumentNullException(nameof(fluentClient));	×
249
250	if (builder == null)	3!
251	throw new ArgumentNullException(nameof(builder));	×
252
253	var response = await fluentClient.DeleteAsync(builder).ConfigureAwait(false);	3✔
254	var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);	3✔
255
256	return data;	3✔
257	}	3✔
258
259
260	/// <summary>
261	/// Sends a request using specified fluent builder as an asynchronous operation.
262	/// </summary>
263	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
264	/// <param name="builder">The fluent builder factory.</param>
265	/// <returns>The task object representing the asynchronous operation.</returns>
266	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
267	public static async Task<HttpResponseMessage> SendAsync(this IFluentClient fluentClient, Action<SendBuilder> builder)
268	{
269	if (fluentClient == null)	3!
270	throw new ArgumentNullException(nameof(fluentClient));	×
271
272	if (builder == null)	3!
273	throw new ArgumentNullException(nameof(builder));	×
274
275	var httpClient = fluentClient.HttpClient;	3✔
276	var requestMessage = new HttpRequestMessage(HttpMethod.Post, httpClient.BaseAddress);	3✔
277	requestMessage.SetContentSerializer(fluentClient.ContentSerializer);	3✔
278
279	var fluentBuilder = new SendBuilder(requestMessage);	3✔
280	builder(fluentBuilder);	3✔
281
282	var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);	3✔
283
284	return response;	3✔
285	}	3✔
286
287	/// <summary>
288	/// Sends a request using specified fluent builder as an asynchronous operation.
289	/// </summary>
290	/// <typeparam name="TResponse">The type of the response.</typeparam>
291	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
292	/// <param name="builder">The fluent builder factory.</param>
293	/// <returns>The task object representing the asynchronous operation.</returns>
294	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="builder" /> is <see langword="null" />.</exception>
295	public static async Task<TResponse> SendAsync<TResponse>(this IFluentClient fluentClient, Action<SendBuilder> builder)
296	{
297	if (fluentClient == null)	3!
298	throw new ArgumentNullException(nameof(fluentClient));	×
299
300	if (builder == null)	3!
301	throw new ArgumentNullException(nameof(builder));	×
302
303	var response = await fluentClient.SendAsync(builder).ConfigureAwait(false);	3✔
304	var data = await response.DeserializeAsync<TResponse>().ConfigureAwait(false);	3✔
305
306	return data;	3✔
307	}	3✔
308
309
310	/// <summary>
311	/// Sends a request using specified request message as an asynchronous operation.
312	/// </summary>
313	/// <param name="fluentClient">The <see cref="IFluentClient"/> used to send request.</param>
314	/// <param name="requestMessage">The request message to send.</param>
315	/// <returns>The task object representing the asynchronous operation.</returns>
316	/// <exception cref="ArgumentNullException"><paramref name="fluentClient" /> or <paramref name="requestMessage" /> is <see langword="null" />.</exception>
317	public static async Task<HttpResponseMessage> SendAsync(this IFluentClient fluentClient, HttpRequestMessage requestMessage)
318	{
319	if (fluentClient == null)	3!
320	throw new ArgumentNullException(nameof(fluentClient));	×
321
322	if (requestMessage == null)	3!
323	throw new ArgumentNullException(nameof(requestMessage));	×
324
325	var httpClient = fluentClient.HttpClient;	3✔
326
327	requestMessage.SetContentSerializer(fluentClient.ContentSerializer);	3✔
328
329	var response = await FluentDispatcher.SendAsync(httpClient, requestMessage).ConfigureAwait(false);	3✔
330
331	return response;	3✔
332	}	3✔
333
334	}

loresoft / FluentRest / 9388947971

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous