diff options
Diffstat (limited to 'indra/newview/tests/llhttpretrypolicy_test.cpp')
| -rw-r--r-- | indra/newview/tests/llhttpretrypolicy_test.cpp | 486 |
1 files changed, 243 insertions, 243 deletions
diff --git a/indra/newview/tests/llhttpretrypolicy_test.cpp b/indra/newview/tests/llhttpretrypolicy_test.cpp index 21c83184dc..5c995c807b 100644 --- a/indra/newview/tests/llhttpretrypolicy_test.cpp +++ b/indra/newview/tests/llhttpretrypolicy_test.cpp @@ -1,25 +1,25 @@ -/** +/** * @file llhttpretrypolicy_test.cpp * @brief Header tests to exercise the LLHTTPRetryPolicy classes. * * $LicenseInfo:firstyear=2013&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2013, Linden Research, Inc. - * + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. - * + * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * + * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ @@ -34,141 +34,141 @@ struct TestData { }; -typedef test_group<TestData> RetryPolicyTestGroup; -typedef RetryPolicyTestGroup::object RetryPolicyTestObject; +typedef test_group<TestData> RetryPolicyTestGroup; +typedef RetryPolicyTestGroup::object RetryPolicyTestObject; RetryPolicyTestGroup retryPolicyTestGroup("retry_policy"); template<> template<> void RetryPolicyTestObject::test<1>() { - LLAdaptiveRetryPolicy never_retry(1.0,1.0,1.0,0); - LLSD headers; - F32 wait_seconds; - - // No retry until we've failed a try. - ensure("never retry 0", !never_retry.shouldRetry(wait_seconds)); - - // 0 retries max. - never_retry.onFailure(500,headers); - ensure("never retry 1", !never_retry.shouldRetry(wait_seconds)); + LLAdaptiveRetryPolicy never_retry(1.0,1.0,1.0,0); + LLSD headers; + F32 wait_seconds; + + // No retry until we've failed a try. + ensure("never retry 0", !never_retry.shouldRetry(wait_seconds)); + + // 0 retries max. + never_retry.onFailure(500,headers); + ensure("never retry 1", !never_retry.shouldRetry(wait_seconds)); } template<> template<> void RetryPolicyTestObject::test<2>() { - LLSD headers; - F32 wait_seconds; - - // Normally only retry on server error (5xx) - LLAdaptiveRetryPolicy noRetry404(1.0,2.0,3.0,10); - noRetry404.onFailure(404,headers); - ensure("no retry on 404", !noRetry404.shouldRetry(wait_seconds)); - - // Can retry on 4xx errors if enabled by flag. - bool do_retry_4xx = true; - LLAdaptiveRetryPolicy doRetry404(1.0,2.0,3.0,10,do_retry_4xx); - doRetry404.onFailure(404,headers); - ensure("do retry on 404", doRetry404.shouldRetry(wait_seconds)); + LLSD headers; + F32 wait_seconds; + + // Normally only retry on server error (5xx) + LLAdaptiveRetryPolicy noRetry404(1.0,2.0,3.0,10); + noRetry404.onFailure(404,headers); + ensure("no retry on 404", !noRetry404.shouldRetry(wait_seconds)); + + // Can retry on 4xx errors if enabled by flag. + bool do_retry_4xx = true; + LLAdaptiveRetryPolicy doRetry404(1.0,2.0,3.0,10,do_retry_4xx); + doRetry404.onFailure(404,headers); + ensure("do retry on 404", doRetry404.shouldRetry(wait_seconds)); } template<> template<> void RetryPolicyTestObject::test<3>() { - // Should retry after 1.0, 2.0, 3.0, 3.0 seconds. - LLAdaptiveRetryPolicy basic_retry(1.0,3.0,2.0,4); - LLSD headers; - F32 wait_seconds; - bool should_retry; - U32 frac_bits = 6; - - // No retry until we've failed a try. - ensure("basic_retry 0", !basic_retry.shouldRetry(wait_seconds)); - - // Starting wait 1.0 - basic_retry.onFailure(500,headers); - should_retry = basic_retry.shouldRetry(wait_seconds); - ensure("basic_retry 1", should_retry); - ensure_approximately_equals("basic_retry 1", wait_seconds, 1.0F, frac_bits); - - // Double wait to 2.0 - basic_retry.onFailure(500,headers); - should_retry = basic_retry.shouldRetry(wait_seconds); - ensure("basic_retry 2", should_retry); - ensure_approximately_equals("basic_retry 2", wait_seconds, 2.0F, frac_bits); - - // Hit max wait of 3.0 (4.0 clamped to max 3) - basic_retry.onFailure(500,headers); - should_retry = basic_retry.shouldRetry(wait_seconds); - ensure("basic_retry 3", should_retry); - ensure_approximately_equals("basic_retry 3", wait_seconds, 3.0F, frac_bits); - - // At max wait, should stay at 3.0 - basic_retry.onFailure(500,headers); - should_retry = basic_retry.shouldRetry(wait_seconds); - ensure("basic_retry 4", should_retry); - ensure_approximately_equals("basic_retry 4", wait_seconds, 3.0F, frac_bits); - - // Max retries, should fail now. - basic_retry.onFailure(500,headers); - should_retry = basic_retry.shouldRetry(wait_seconds); - ensure("basic_retry 5", !should_retry); - - // Max retries, should fail now. - basic_retry.onFailure(500,headers); - should_retry = basic_retry.shouldRetry(wait_seconds); - ensure("basic_retry 5", !should_retry); - - // After a success, should reset to the starting state. - basic_retry.onSuccess(); - - // No retry until we've failed a try. - ensure("basic_retry 6", !basic_retry.shouldRetry(wait_seconds)); - - // Starting wait 1.0 - basic_retry.onFailure(500,headers); - should_retry = basic_retry.shouldRetry(wait_seconds); - ensure("basic_retry 7", should_retry); - ensure_approximately_equals("basic_retry 7", wait_seconds, 1.0F, frac_bits); - - // Double wait to 2.0 - basic_retry.onFailure(500,headers); - should_retry = basic_retry.shouldRetry(wait_seconds); - ensure("basic_retry 8", should_retry); - ensure_approximately_equals("basic_retry 8", wait_seconds, 2.0F, frac_bits); + // Should retry after 1.0, 2.0, 3.0, 3.0 seconds. + LLAdaptiveRetryPolicy basic_retry(1.0,3.0,2.0,4); + LLSD headers; + F32 wait_seconds; + bool should_retry; + U32 frac_bits = 6; + + // No retry until we've failed a try. + ensure("basic_retry 0", !basic_retry.shouldRetry(wait_seconds)); + + // Starting wait 1.0 + basic_retry.onFailure(500,headers); + should_retry = basic_retry.shouldRetry(wait_seconds); + ensure("basic_retry 1", should_retry); + ensure_approximately_equals("basic_retry 1", wait_seconds, 1.0F, frac_bits); + + // Double wait to 2.0 + basic_retry.onFailure(500,headers); + should_retry = basic_retry.shouldRetry(wait_seconds); + ensure("basic_retry 2", should_retry); + ensure_approximately_equals("basic_retry 2", wait_seconds, 2.0F, frac_bits); + + // Hit max wait of 3.0 (4.0 clamped to max 3) + basic_retry.onFailure(500,headers); + should_retry = basic_retry.shouldRetry(wait_seconds); + ensure("basic_retry 3", should_retry); + ensure_approximately_equals("basic_retry 3", wait_seconds, 3.0F, frac_bits); + + // At max wait, should stay at 3.0 + basic_retry.onFailure(500,headers); + should_retry = basic_retry.shouldRetry(wait_seconds); + ensure("basic_retry 4", should_retry); + ensure_approximately_equals("basic_retry 4", wait_seconds, 3.0F, frac_bits); + + // Max retries, should fail now. + basic_retry.onFailure(500,headers); + should_retry = basic_retry.shouldRetry(wait_seconds); + ensure("basic_retry 5", !should_retry); + + // Max retries, should fail now. + basic_retry.onFailure(500,headers); + should_retry = basic_retry.shouldRetry(wait_seconds); + ensure("basic_retry 5", !should_retry); + + // After a success, should reset to the starting state. + basic_retry.onSuccess(); + + // No retry until we've failed a try. + ensure("basic_retry 6", !basic_retry.shouldRetry(wait_seconds)); + + // Starting wait 1.0 + basic_retry.onFailure(500,headers); + should_retry = basic_retry.shouldRetry(wait_seconds); + ensure("basic_retry 7", should_retry); + ensure_approximately_equals("basic_retry 7", wait_seconds, 1.0F, frac_bits); + + // Double wait to 2.0 + basic_retry.onFailure(500,headers); + should_retry = basic_retry.shouldRetry(wait_seconds); + ensure("basic_retry 8", should_retry); + ensure_approximately_equals("basic_retry 8", wait_seconds, 2.0F, frac_bits); } // Retries should stop as soon as a non-5xx error is received. template<> template<> void RetryPolicyTestObject::test<4>() { - // Should retry after 1.0, 2.0, 3.0, 3.0 seconds. - LLAdaptiveRetryPolicy killer404(1.0,3.0,2.0,4); - LLSD headers; - F32 wait_seconds; - bool should_retry; - U32 frac_bits = 6; - - // Starting wait 1.0 - killer404.onFailure(500,headers); - should_retry = killer404.shouldRetry(wait_seconds); - ensure("killer404 1", should_retry); - ensure_approximately_equals("killer404 1", wait_seconds, 1.0F, frac_bits); - - // Double wait to 2.0 - killer404.onFailure(500,headers); - should_retry = killer404.shouldRetry(wait_seconds); - ensure("killer404 2", should_retry); - ensure_approximately_equals("killer404 2", wait_seconds, 2.0F, frac_bits); - - // Should fail on non-5xx - killer404.onFailure(404,headers); - should_retry = killer404.shouldRetry(wait_seconds); - ensure("killer404 3", !should_retry); - - // After a non-5xx, should keep failing. - killer404.onFailure(500,headers); - should_retry = killer404.shouldRetry(wait_seconds); - ensure("killer404 4", !should_retry); + // Should retry after 1.0, 2.0, 3.0, 3.0 seconds. + LLAdaptiveRetryPolicy killer404(1.0,3.0,2.0,4); + LLSD headers; + F32 wait_seconds; + bool should_retry; + U32 frac_bits = 6; + + // Starting wait 1.0 + killer404.onFailure(500,headers); + should_retry = killer404.shouldRetry(wait_seconds); + ensure("killer404 1", should_retry); + ensure_approximately_equals("killer404 1", wait_seconds, 1.0F, frac_bits); + + // Double wait to 2.0 + killer404.onFailure(500,headers); + should_retry = killer404.shouldRetry(wait_seconds); + ensure("killer404 2", should_retry); + ensure_approximately_equals("killer404 2", wait_seconds, 2.0F, frac_bits); + + // Should fail on non-5xx + killer404.onFailure(404,headers); + should_retry = killer404.shouldRetry(wait_seconds); + ensure("killer404 3", !should_retry); + + // After a non-5xx, should keep failing. + killer404.onFailure(500,headers); + should_retry = killer404.shouldRetry(wait_seconds); + ensure("killer404 4", !should_retry); } // Test handling of "retry-after" header. If present, this header @@ -179,49 +179,49 @@ void RetryPolicyTestObject::test<4>() template<> template<> void RetryPolicyTestObject::test<5>() { - LLAdaptiveRetryPolicy policy(1.0,25.0,2.0,6); - LLSD headers_with_retry; - headers_with_retry[HTTP_IN_HEADER_RETRY_AFTER] = "666"; - LLSD headers_without_retry; - F32 wait_seconds; - bool should_retry; - U32 frac_bits = 6; - - policy.onFailure(500,headers_without_retry); - should_retry = policy.shouldRetry(wait_seconds); - ensure("retry header 1", should_retry); - ensure_approximately_equals("retry header 1", wait_seconds, 1.0F, frac_bits); - - policy.onFailure(500,headers_without_retry); - should_retry = policy.shouldRetry(wait_seconds); - ensure("retry header 2", should_retry); - ensure_approximately_equals("retry header 2", wait_seconds, 2.0F, frac_bits); - - policy.onFailure(500,headers_with_retry); - should_retry = policy.shouldRetry(wait_seconds); - ensure("retry header 3", should_retry); - // 4.0 overrides by header -> 666.0 - ensure_approximately_equals("retry header 3", wait_seconds, 666.0F, frac_bits); - - policy.onFailure(500,headers_with_retry); - should_retry = policy.shouldRetry(wait_seconds); - ensure("retry header 4", should_retry); - // 8.0 overrides by header -> 666.0 - ensure_approximately_equals("retry header 4", wait_seconds, 666.0F, frac_bits); - - policy.onFailure(500,headers_without_retry); - should_retry = policy.shouldRetry(wait_seconds); - ensure("retry header 5", should_retry); - ensure_approximately_equals("retry header 5", wait_seconds, 16.0F, frac_bits); - - policy.onFailure(500,headers_without_retry); - should_retry = policy.shouldRetry(wait_seconds); - ensure("retry header 6", should_retry); - ensure_approximately_equals("retry header 6", wait_seconds, 25.0F, frac_bits); - - policy.onFailure(500,headers_with_retry); - should_retry = policy.shouldRetry(wait_seconds); - ensure("retry header 7", !should_retry); + LLAdaptiveRetryPolicy policy(1.0,25.0,2.0,6); + LLSD headers_with_retry; + headers_with_retry[HTTP_IN_HEADER_RETRY_AFTER] = "666"; + LLSD headers_without_retry; + F32 wait_seconds; + bool should_retry; + U32 frac_bits = 6; + + policy.onFailure(500,headers_without_retry); + should_retry = policy.shouldRetry(wait_seconds); + ensure("retry header 1", should_retry); + ensure_approximately_equals("retry header 1", wait_seconds, 1.0F, frac_bits); + + policy.onFailure(500,headers_without_retry); + should_retry = policy.shouldRetry(wait_seconds); + ensure("retry header 2", should_retry); + ensure_approximately_equals("retry header 2", wait_seconds, 2.0F, frac_bits); + + policy.onFailure(500,headers_with_retry); + should_retry = policy.shouldRetry(wait_seconds); + ensure("retry header 3", should_retry); + // 4.0 overrides by header -> 666.0 + ensure_approximately_equals("retry header 3", wait_seconds, 666.0F, frac_bits); + + policy.onFailure(500,headers_with_retry); + should_retry = policy.shouldRetry(wait_seconds); + ensure("retry header 4", should_retry); + // 8.0 overrides by header -> 666.0 + ensure_approximately_equals("retry header 4", wait_seconds, 666.0F, frac_bits); + + policy.onFailure(500,headers_without_retry); + should_retry = policy.shouldRetry(wait_seconds); + ensure("retry header 5", should_retry); + ensure_approximately_equals("retry header 5", wait_seconds, 16.0F, frac_bits); + + policy.onFailure(500,headers_without_retry); + should_retry = policy.shouldRetry(wait_seconds); + ensure("retry header 6", should_retry); + ensure_approximately_equals("retry header 6", wait_seconds, 25.0F, frac_bits); + + policy.onFailure(500,headers_with_retry); + should_retry = policy.shouldRetry(wait_seconds); + ensure("retry header 7", !should_retry); } // Test getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait), @@ -229,99 +229,99 @@ void RetryPolicyTestObject::test<5>() template<> template<> void RetryPolicyTestObject::test<6>() { - F32 seconds_to_wait; - bool success; + F32 seconds_to_wait; + bool success; - std::string str1("0"); - seconds_to_wait = F32_MAX; + std::string str1("0"); + seconds_to_wait = F32_MAX; success = LLAdaptiveRetryPolicy::getSecondsUntilRetryAfter(str1, seconds_to_wait); - ensure("parse 1", success); - ensure_equals("parse 1", seconds_to_wait, 0.0); + ensure("parse 1", success); + ensure_equals("parse 1", seconds_to_wait, 0.0); - std::string str2("999.9"); - seconds_to_wait = F32_MAX; + std::string str2("999.9"); + seconds_to_wait = F32_MAX; success = LLAdaptiveRetryPolicy::getSecondsUntilRetryAfter(str2, seconds_to_wait); - ensure("parse 2", success); - ensure_approximately_equals("parse 2", seconds_to_wait, 999.9F, 8); + ensure("parse 2", success); + ensure_approximately_equals("parse 2", seconds_to_wait, 999.9F, 8); - time_t nowseconds; - time(&nowseconds); - std::string str3 = LLDate((F64)(nowseconds+44)).asRFC1123(); - seconds_to_wait = F32_MAX; + time_t nowseconds; + time(&nowseconds); + std::string str3 = LLDate((F64)(nowseconds+44)).asRFC1123(); + seconds_to_wait = F32_MAX; success = LLAdaptiveRetryPolicy::getSecondsUntilRetryAfter(str3, seconds_to_wait); - std::cerr << " str3 [" << str3 << "]" << std::endl; - ensure("parse 3", success); - ensure_approximately_equals_range("parse 3", seconds_to_wait, 44.0F, 2.0F); + std::cerr << " str3 [" << str3 << "]" << std::endl; + ensure("parse 3", success); + ensure_approximately_equals_range("parse 3", seconds_to_wait, 44.0F, 2.0F); } // Test retry-after field in both llmessage and CoreHttp headers. template<> template<> void RetryPolicyTestObject::test<7>() { - std::cerr << "7 starts" << std::endl; - - LLSD sd_headers; - time_t nowseconds; - time(&nowseconds); - LLAdaptiveRetryPolicy policy(17.0,644.0,3.0,5); - F32 seconds_to_wait; - bool should_retry; - - // No retry until we've failed a try. - ensure("header 0", !policy.shouldRetry(seconds_to_wait)); - - // no retry header, use default. - policy.onFailure(500,LLSD()); - should_retry = policy.shouldRetry(seconds_to_wait); - ensure("header 1", should_retry); - ensure_approximately_equals("header 1", seconds_to_wait, 17.0F, 6); - - // retry header should override, give delay of 0 - std::string date_string = LLDate((F64)(nowseconds+7)).asRFC1123(); - sd_headers[HTTP_IN_HEADER_RETRY_AFTER] = date_string; - policy.onFailure(503,sd_headers); - should_retry = policy.shouldRetry(seconds_to_wait); - ensure("header 2", should_retry); - ensure_approximately_equals_range("header 2", seconds_to_wait, 7.0F, 2.0F); - - LLCore::HttpResponse *response; - LLCore::HttpHeaders::ptr_t headers; - - response = new LLCore::HttpResponse(); - headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()); - response->setStatus(503); - response->setHeaders(headers); - headers->append(HTTP_IN_HEADER_RETRY_AFTER, std::string("600")); - policy.onFailure(response); - should_retry = policy.shouldRetry(seconds_to_wait); - ensure("header 3",should_retry); - ensure_approximately_equals("header 3", seconds_to_wait, 600.0F, 6); - response->release(); - - response = new LLCore::HttpResponse(); - headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()); - response->setStatus(503); - response->setHeaders(headers); - time(&nowseconds); - date_string = LLDate((F64)(nowseconds+77)).asRFC1123(); - std::cerr << "date_string [" << date_string << "]" << std::endl; - headers->append(HTTP_IN_HEADER_RETRY_AFTER,date_string); - policy.onFailure(response); - should_retry = policy.shouldRetry(seconds_to_wait); - ensure("header 4",should_retry); - ensure_approximately_equals_range("header 4", seconds_to_wait, 77.0F, 2.0F); - response->release(); - - // Timeout should be clamped at max. - policy.onFailure(500,LLSD()); - should_retry = policy.shouldRetry(seconds_to_wait); - ensure("header 5", should_retry); - ensure_approximately_equals("header 5", seconds_to_wait, 644.0F, 6); - - // No more retries. - policy.onFailure(500,LLSD()); - should_retry = policy.shouldRetry(seconds_to_wait); - ensure("header 6", !should_retry); + std::cerr << "7 starts" << std::endl; + + LLSD sd_headers; + time_t nowseconds; + time(&nowseconds); + LLAdaptiveRetryPolicy policy(17.0,644.0,3.0,5); + F32 seconds_to_wait; + bool should_retry; + + // No retry until we've failed a try. + ensure("header 0", !policy.shouldRetry(seconds_to_wait)); + + // no retry header, use default. + policy.onFailure(500,LLSD()); + should_retry = policy.shouldRetry(seconds_to_wait); + ensure("header 1", should_retry); + ensure_approximately_equals("header 1", seconds_to_wait, 17.0F, 6); + + // retry header should override, give delay of 0 + std::string date_string = LLDate((F64)(nowseconds+7)).asRFC1123(); + sd_headers[HTTP_IN_HEADER_RETRY_AFTER] = date_string; + policy.onFailure(503,sd_headers); + should_retry = policy.shouldRetry(seconds_to_wait); + ensure("header 2", should_retry); + ensure_approximately_equals_range("header 2", seconds_to_wait, 7.0F, 2.0F); + + LLCore::HttpResponse *response; + LLCore::HttpHeaders::ptr_t headers; + + response = new LLCore::HttpResponse(); + headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()); + response->setStatus(503); + response->setHeaders(headers); + headers->append(HTTP_IN_HEADER_RETRY_AFTER, std::string("600")); + policy.onFailure(response); + should_retry = policy.shouldRetry(seconds_to_wait); + ensure("header 3",should_retry); + ensure_approximately_equals("header 3", seconds_to_wait, 600.0F, 6); + response->release(); + + response = new LLCore::HttpResponse(); + headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()); + response->setStatus(503); + response->setHeaders(headers); + time(&nowseconds); + date_string = LLDate((F64)(nowseconds+77)).asRFC1123(); + std::cerr << "date_string [" << date_string << "]" << std::endl; + headers->append(HTTP_IN_HEADER_RETRY_AFTER,date_string); + policy.onFailure(response); + should_retry = policy.shouldRetry(seconds_to_wait); + ensure("header 4",should_retry); + ensure_approximately_equals_range("header 4", seconds_to_wait, 77.0F, 2.0F); + response->release(); + + // Timeout should be clamped at max. + policy.onFailure(500,LLSD()); + should_retry = policy.shouldRetry(seconds_to_wait); + ensure("header 5", should_retry); + ensure_approximately_equals("header 5", seconds_to_wait, 644.0F, 6); + + // No more retries. + policy.onFailure(500,LLSD()); + should_retry = policy.shouldRetry(seconds_to_wait); + ensure("header 6", !should_retry); } } |