/** * @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$ */ #include "../llviewerprecompiledheaders.h" #include "../llhttpretrypolicy.h" #include "lltut.h" namespace tut { struct TestData { }; 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)); } 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)); } 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); } // 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); } // Test handling of "retry-after" header. If present, this header // value overrides the computed delay, but does not affect the // progression of delay values. For example, if the normal // progression of delays would be 1,2,4,8..., but the 2nd and 3rd calls // get a retry header of 33, the pattern would become 1,33,33,8... 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); } // Test getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait), // used by header parsing of the retry policy. template<> template<> void RetryPolicyTestObject::test<6>() { F32 seconds_to_wait; bool success; 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); 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); 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); } // 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); } }