13613145020

Committed 02 Mar 2025 07:11AM UTC coverage: 46.263% (+4.6%) from 41.646%

Build # 13613145020

Build Type

push

github

Committed by

rwjdk

Commit Message

More Automated Tests

Run Details

1055 of 3227 branches covered (32.69%)

Branch coverage included in aggregate %.

16 of 17 new or added lines in 3 files covered. (94.12%)

3 existing lines in 3 files now uncovered.

2764 of 5028 relevant lines covered (54.97%)

46.84 hits per line

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

93.08

/src/TrelloDotNet/Control/ApiRequestController.cs

﻿using System;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using TrelloDotNet.Model;

namespace TrelloDotNet.Control
{
    internal class ApiRequestController
    {
        private const string BaseUrl = "https://api.trello.com/1/";
        private readonly HttpClient _httpClient;
        private readonly string _apiKey;
        private readonly string _token;
        private readonly TrelloClient _client;

        internal HttpClient HttpClient => _httpClient;

        internal ApiRequestController(HttpClient httpClient, string apiKey, string token, TrelloClient client)
        {
            _httpClient = httpClient;
            _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            _apiKey = apiKey;
            _token = token;
            _client = client;
        }

        public string Token => _token;

        public string ApiKey => _apiKey;

        internal async Task<T> Get<T>(string suffix, CancellationToken cancellationToken, params QueryParameter[] parameters)
        {
            string json = await Get(suffix, cancellationToken, 0, parameters);
            var @object = JsonSerializer.Deserialize<T>(json);
            return @object;
        }

        internal async Task<string> Get(string suffix, CancellationToken cancellationToken, int retryCount, params QueryParameter[] parameters)
        {
            var uri = BuildUri(suffix, parameters);
            var response = await _httpClient.GetAsync(uri, cancellationToken);
            var responseContent = await response.Content.ReadAsStringAsync();
            if (response.StatusCode != HttpStatusCode.OK)
            {
                return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => Get(suffix, cancellationToken, retry, parameters), retryCount, cancellationToken);
            }

            return responseContent; //Content is assumed JSON
        }

        internal async Task<T> Post<T>(string suffix, CancellationToken cancellationToken, params QueryParameter[] parameters)
        {
            string json = await Post(suffix, cancellationToken, 0, parameters);
            var @object = JsonSerializer.Deserialize<T>(json);
            return @object;
        }

        internal async Task<T> PostWithAttachmentFileUpload<T>(string suffix, AttachmentFileUpload attachmentFile, CancellationToken cancellationToken, params QueryParameter[] parameters)
        {
            string json = await PostWithAttachmentFileUpload(suffix, attachmentFile, cancellationToken, 0, parameters);
            var @object = JsonSerializer.Deserialize<T>(json);
            return @object;
        }

        internal async Task<string> PostWithAttachmentFileUpload(string suffix, AttachmentFileUpload attachmentFile, CancellationToken cancellationToken, int retryCount, params QueryParameter[] parameters)
        {
            var uri = BuildUri(suffix, parameters);
            using (var multipartFormContent = new MultipartFormDataContent())
            {
                multipartFormContent.Add(new StreamContent(attachmentFile.Stream), name: "file", fileName: attachmentFile.Filename);
                var response = await _httpClient.PostAsync(uri, multipartFormContent, cancellationToken);
                var responseContent = await response.Content.ReadAsStringAsync();
                if (response.StatusCode != HttpStatusCode.OK)
                {
                    return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => PostWithAttachmentFileUpload(suffix, attachmentFile, cancellationToken, retry, parameters), retryCount, cancellationToken);
                }

                return responseContent; //Content is assumed JSON
            }
        }

        internal async Task<string> Post(string suffix, CancellationToken cancellationToken, int retryCount, params QueryParameter[] parameters)
        {
            var uri = BuildUri(suffix, parameters);
            var response = await _httpClient.PostAsync(uri, null, cancellationToken);
            var content = await response.Content.ReadAsStringAsync();
            if (response.StatusCode != HttpStatusCode.OK)
            {
                return await PreformRetryIfNeededOrThrow(uri, content, retry => Post(suffix, cancellationToken, retry, parameters), retryCount, cancellationToken);
            }

            return content; //Content is assumed JSON
        }

        internal async Task<T> Put<T>(string suffix, CancellationToken cancellationToken, params QueryParameter[] parameters)
        {
            string json = await Put(suffix, cancellationToken, 0, parameters);
            var @object = JsonSerializer.Deserialize<T>(json);
            return @object;
        }

        internal async Task<string> Put(string suffix, CancellationToken cancellationToken, int retryCount, params QueryParameter[] parameters)
        {
            var uri = BuildUri(suffix, parameters);
            var response = await _httpClient.PutAsync(uri, null, cancellationToken);
            var responseContent = await response.Content.ReadAsStringAsync();
            if (response.StatusCode != HttpStatusCode.OK)
            {
                return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => Put(suffix, cancellationToken, retry, parameters), retryCount, cancellationToken);
            }

            return responseContent; //Content is assumed JSON
        }

        internal async Task<T> PutWithJsonPayload<T>(string suffix, CancellationToken cancellationToken, string payload, params QueryParameter[] parameters)
        {
            string json = await PutWithJsonPayload(suffix, cancellationToken, payload, 0, parameters);
            var @object = JsonSerializer.Deserialize<T>(json);
            return @object;
        }

        internal async Task<string> PutWithJsonPayload(string suffix, CancellationToken cancellationToken, string payload, int retryCount, params QueryParameter[] parameters)
        {
            var uri = BuildUri(suffix, parameters);
            var response = await _httpClient.PutAsync(uri, new StringContent(payload, Encoding.UTF8, "application/json"), cancellationToken);
            var responseContent = await response.Content.ReadAsStringAsync();
            if (response.StatusCode != HttpStatusCode.OK)
            {
                return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => PutWithJsonPayload(suffix, cancellationToken, payload, retry, parameters), retryCount, cancellationToken);
            }

            return responseContent; //Content is assumed JSON
        }

        internal async Task<T> PostWithJsonPayload<T>(string suffix, CancellationToken cancellationToken, string payload, params QueryParameter[] parameters)
        {
            string json = await PostWithJsonPayload(suffix, cancellationToken, payload, 0, parameters);
            var @object = JsonSerializer.Deserialize<T>(json);
            return @object;
        }

        internal async Task<string> PostWithJsonPayload(string suffix, CancellationToken cancellationToken, string payload, int retryCount, params QueryParameter[] parameters)
        {
            var uri = BuildUri(suffix, parameters);
            var response = await _httpClient.PostAsync(uri, new StringContent(payload, Encoding.UTF8, "application/json"), cancellationToken);
            var responseContent = await response.Content.ReadAsStringAsync();
            if (response.StatusCode != HttpStatusCode.OK)
            {
                return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => PostWithJsonPayload(suffix, cancellationToken, payload, retry, parameters), retryCount, cancellationToken);
            }

            return responseContent; //Content is assumed JSON
        }

        private string FormatExceptionUrlAccordingToClientOptions(string fullUrl)
        {
            switch (_client.Options.ApiCallExceptionOption)
            {
                case ApiCallExceptionOption.IncludeUrlAndCredentials:
                    return fullUrl;
                case ApiCallExceptionOption.IncludeUrlButMaskCredentials:
                    // ReSharper disable StringLiteralTypo
                    return fullUrl.Replace($"?key={_apiKey}&token={_token}", "?key=XXXXX&token=XXXXXXXXXX");
                case ApiCallExceptionOption.DoNotIncludeTheUrl:
                    return string.Empty.PadLeft(5, 'X');
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        internal static StringBuilder GetParametersAsString(QueryParameter[] parameters)
        {
            StringBuilder parameterString = new StringBuilder();
            foreach (var parameter in parameters)
            {
                parameterString.Append($"&{parameter.Name}={parameter.GetValueAsApiFormattedString()}");
            }

            return parameterString;
        }

        private Uri BuildUri(string suffix, params QueryParameter[] parameters)
        {
            string separator = suffix.Contains("?") ? "&" : "?";
            return new Uri($"{BaseUrl}{suffix}{separator}key={_apiKey}&token={_token}" + GetParametersAsString(parameters));
        }

        internal async Task<string> Delete(string suffix, CancellationToken cancellationToken, int retryCount)
        {
            var uri = BuildUri(suffix);
            var response = await _httpClient.DeleteAsync(uri, cancellationToken);
            var responseContent = await response.Content.ReadAsStringAsync();
            if (response.StatusCode != HttpStatusCode.OK)
            {
                return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => Delete(suffix, cancellationToken, retry), retryCount, cancellationToken);
            }

            return null;
        }

        private async Task<string> PreformRetryIfNeededOrThrow(Uri uri, string responseContent, Func<int, Task<string>> toRetry, int retryCount, CancellationToken cancellationToken)
        {
            if (responseContent.Contains("API_TOKEN_LIMIT_EXCEEDED") && retryCount <= _client.Options.MaxRetryCountForTokenLimitExceeded)
            {
                await Task.Delay(TimeSpan.FromSeconds(_client.Options.DelayInSecondsToWaitInTokenLimitExceededRetry), cancellationToken);
                retryCount++;
                return await toRetry(retryCount);
            }

            throw new TrelloApiException(responseContent, FormatExceptionUrlAccordingToClientOptions(uri.AbsoluteUri)); //Content is assumed Error Message       
        }
    }
}

1	using System;
2	using System.Net;
3	using System.Net.Http;
4	using System.Net.Http.Headers;
5	using System.Text;
6	using System.Text.Json;
7	using System.Threading;
8	using System.Threading.Tasks;
9	using TrelloDotNet.Model;
10
11	namespace TrelloDotNet.Control
12	{
13	internal class ApiRequestController
14	{
15	private const string BaseUrl = "https://api.trello.com/1/";
16	private readonly HttpClient _httpClient;
17	private readonly string _apiKey;
18	private readonly string _token;
19	private readonly TrelloClient _client;
20
21	internal HttpClient HttpClient => _httpClient;	3✔
22
23	internal ApiRequestController(HttpClient httpClient, string apiKey, string token, TrelloClient client)	202✔
24	{
25	_httpClient = httpClient;	202✔
26	_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));	202✔
27	_apiKey = apiKey;	202✔
28	_token = token;	202✔
29	_client = client;	202✔
30	}	202✔
31
32	public string Token => _token;	26✔
33
34	public string ApiKey => _apiKey;	1✔
35
36	internal async Task<T> Get<T>(string suffix, CancellationToken cancellationToken, params QueryParameter[] parameters)
37	{
38	string json = await Get(suffix, cancellationToken, 0, parameters);	418✔
39	var @object = JsonSerializer.Deserialize<T>(json);	418✔
40	return @object;	418✔
41	}	418✔
42
43	internal async Task<string> Get(string suffix, CancellationToken cancellationToken, int retryCount, params QueryParameter[] parameters)
44	{
45	var uri = BuildUri(suffix, parameters);	455✔
46	var response = await _httpClient.GetAsync(uri, cancellationToken);	455✔
47	var responseContent = await response.Content.ReadAsStringAsync();	455✔
48	if (response.StatusCode != HttpStatusCode.OK)	455✔
49	{
50	return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => Get(suffix, cancellationToken, retry, parameters), retryCount, cancellationToken);	68✔
51	}
52
53	return responseContent; //Content is assumed JSON	419✔
54	}	451✔
55
56	internal async Task<T> Post<T>(string suffix, CancellationToken cancellationToken, params QueryParameter[] parameters)
57	{
58	string json = await Post(suffix, cancellationToken, 0, parameters);	271✔
59	var @object = JsonSerializer.Deserialize<T>(json);	271✔
60	return @object;	271✔
61	}	271✔
62
63	internal async Task<T> PostWithAttachmentFileUpload<T>(string suffix, AttachmentFileUpload attachmentFile, CancellationToken cancellationToken, params QueryParameter[] parameters)
64	{
65	string json = await PostWithAttachmentFileUpload(suffix, attachmentFile, cancellationToken, 0, parameters);	1✔
66	var @object = JsonSerializer.Deserialize<T>(json);	1✔
67	return @object;	1✔
68	}	1✔
69
70	internal async Task<string> PostWithAttachmentFileUpload(string suffix, AttachmentFileUpload attachmentFile, CancellationToken cancellationToken, int retryCount, params QueryParameter[] parameters)
71	{
72	var uri = BuildUri(suffix, parameters);	1✔
73	using (var multipartFormContent = new MultipartFormDataContent())	1✔
74	{
75	multipartFormContent.Add(new StreamContent(attachmentFile.Stream), name: "file", fileName: attachmentFile.Filename);	1✔
76	var response = await _httpClient.PostAsync(uri, multipartFormContent, cancellationToken);	1✔
77	var responseContent = await response.Content.ReadAsStringAsync();	1✔
78	if (response.StatusCode != HttpStatusCode.OK)	1!
79	{
80	return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => PostWithAttachmentFileUpload(suffix, attachmentFile, cancellationToken, retry, parameters), retryCount, cancellationToken);	×
81	}
82
83	return responseContent; //Content is assumed JSON	1✔
84	}
85	}	1✔
86
87	internal async Task<string> Post(string suffix, CancellationToken cancellationToken, int retryCount, params QueryParameter[] parameters)
88	{
89	var uri = BuildUri(suffix, parameters);	283✔
90	var response = await _httpClient.PostAsync(uri, null, cancellationToken);	283✔
91	var content = await response.Content.ReadAsStringAsync();	283✔
92	if (response.StatusCode != HttpStatusCode.OK)	283✔
93	{
94	return await PreformRetryIfNeededOrThrow(uri, content, retry => Post(suffix, cancellationToken, retry, parameters), retryCount, cancellationToken);	19✔
95	}
96
97	return content; //Content is assumed JSON	273✔
98	}	282✔
99
100	internal async Task<T> Put<T>(string suffix, CancellationToken cancellationToken, params QueryParameter[] parameters)
101	{
102	string json = await Put(suffix, cancellationToken, 0, parameters);	83✔
103	var @object = JsonSerializer.Deserialize<T>(json);	83✔
104	return @object;	83✔
105	}	83✔
106
107	internal async Task<string> Put(string suffix, CancellationToken cancellationToken, int retryCount, params QueryParameter[] parameters)
108	{
109	var uri = BuildUri(suffix, parameters);	91✔
110	var response = await _httpClient.PutAsync(uri, null, cancellationToken);	91✔
111	var responseContent = await response.Content.ReadAsStringAsync();	91✔
112	if (response.StatusCode != HttpStatusCode.OK)	91✔
113	{
114	return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => Put(suffix, cancellationToken, retry, parameters), retryCount, cancellationToken);	7✔
115	}
116
117	return responseContent; //Content is assumed JSON	87✔
118	}	90✔
119
120	internal async Task<T> PutWithJsonPayload<T>(string suffix, CancellationToken cancellationToken, string payload, params QueryParameter[] parameters)
121	{
122	string json = await PutWithJsonPayload(suffix, cancellationToken, payload, 0, parameters);	10✔
123	var @object = JsonSerializer.Deserialize<T>(json);	10✔
124	return @object;	10✔
125	}	10✔
126
127	internal async Task<string> PutWithJsonPayload(string suffix, CancellationToken cancellationToken, string payload, int retryCount, params QueryParameter[] parameters)
128	{
129	var uri = BuildUri(suffix, parameters);	11✔
130	var response = await _httpClient.PutAsync(uri, new StringContent(payload, Encoding.UTF8, "application/json"), cancellationToken);	11✔
131	var responseContent = await response.Content.ReadAsStringAsync();	11✔
132	if (response.StatusCode != HttpStatusCode.OK)	11!
133	{
UNCOV 134	return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => PutWithJsonPayload(suffix, cancellationToken, payload, retry, parameters), retryCount, cancellationToken);	×
135	}
136
137	return responseContent; //Content is assumed JSON	11✔
138	}	11✔
139
140	internal async Task<T> PostWithJsonPayload<T>(string suffix, CancellationToken cancellationToken, string payload, params QueryParameter[] parameters)
141	{
142	string json = await PostWithJsonPayload(suffix, cancellationToken, payload, 0, parameters);	1✔
143	var @object = JsonSerializer.Deserialize<T>(json);	1✔
144	return @object;	1✔
145	}	1✔
146
147	internal async Task<string> PostWithJsonPayload(string suffix, CancellationToken cancellationToken, string payload, int retryCount, params QueryParameter[] parameters)
148	{
149	var uri = BuildUri(suffix, parameters);	1✔
150	var response = await _httpClient.PostAsync(uri, new StringContent(payload, Encoding.UTF8, "application/json"), cancellationToken);	1✔
151	var responseContent = await response.Content.ReadAsStringAsync();	1✔
152	if (response.StatusCode != HttpStatusCode.OK)	1!
153	{
NEW 154	return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => PostWithJsonPayload(suffix, cancellationToken, payload, retry, parameters), retryCount, cancellationToken);	×
155	}
156
157	return responseContent; //Content is assumed JSON	1✔
158	}	1✔
159
160	private string FormatExceptionUrlAccordingToClientOptions(string fullUrl)
161	{
162	switch (_client.Options.ApiCallExceptionOption)	7!
163	{
164	case ApiCallExceptionOption.IncludeUrlAndCredentials:
165	return fullUrl;	1✔
166	case ApiCallExceptionOption.IncludeUrlButMaskCredentials:
167	// ReSharper disable StringLiteralTypo
168	return fullUrl.Replace($"?key={_apiKey}&token={_token}", "?key=XXXXX&token=XXXXXXXXXX");	5✔
169	case ApiCallExceptionOption.DoNotIncludeTheUrl:
170	return string.Empty.PadLeft(5, 'X');	1✔
171	default:
172	throw new ArgumentOutOfRangeException();	×
173	}
174	}
175
176	internal static StringBuilder GetParametersAsString(QueryParameter[] parameters)
177	{
178	StringBuilder parameterString = new StringBuilder();	912✔
179	foreach (var parameter in parameters)	8,542✔
180	{
181	parameterString.Append($"&{parameter.Name}={parameter.GetValueAsApiFormattedString()}");	3,359✔
182	}
183
184	return parameterString;	912✔
185	}
186
187	private Uri BuildUri(string suffix, params QueryParameter[] parameters)
188	{
189	string separator = suffix.Contains("?") ? "&" : "?";	911✔
190	return new Uri($"{BaseUrl}{suffix}{separator}key={_apiKey}&token={_token}" + GetParametersAsString(parameters));	911!
191	}
192
193	internal async Task<string> Delete(string suffix, CancellationToken cancellationToken, int retryCount)
194	{
195	var uri = BuildUri(suffix);	69✔
196	var response = await _httpClient.DeleteAsync(uri, cancellationToken);	69✔
197	var responseContent = await response.Content.ReadAsStringAsync();	69✔
198	if (response.StatusCode != HttpStatusCode.OK)	69✔
199	{
200	return await PreformRetryIfNeededOrThrow(uri, responseContent, retry => Delete(suffix, cancellationToken, retry), retryCount, cancellationToken);	35✔
201	}
202
203	return null;	51✔
204	}	68✔
205
206	private async Task<string> PreformRetryIfNeededOrThrow(Uri uri, string responseContent, Func<int, Task<string>> toRetry, int retryCount, CancellationToken cancellationToken)
207	{
208	if (responseContent.Contains("API_TOKEN_LIMIT_EXCEEDED") && retryCount <= _client.Options.MaxRetryCountForTokenLimitExceeded)	68✔
209	{
210	await Task.Delay(TimeSpan.FromSeconds(_client.Options.DelayInSecondsToWaitInTokenLimitExceededRetry), cancellationToken);	61✔
211	retryCount++;	61✔
212	return await toRetry(retryCount);	61✔
213	}
214
215	throw new TrelloApiException(responseContent, FormatExceptionUrlAccordingToClientOptions(uri.AbsoluteUri)); //Content is assumed Error Message	7✔
216	}	61✔
217	}
218	}

rwjdk / TrelloDotNet / 13613145020

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