backoff_delay_provider_unittest.cc 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/sync/engine/backoff_delay_provider.h"
  5. #include <memory>
  6. #include "components/sync/base/syncer_error.h"
  7. #include "components/sync/engine/cycle/model_neutral_state.h"
  8. #include "components/sync/engine/polling_constants.h"
  9. #include "net/base/net_errors.h"
  10. #include "net/http/http_status_code.h"
  11. #include "testing/gmock/include/gmock/gmock.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace syncer {
  14. namespace {
  15. using testing::Gt;
  16. using testing::Lt;
  17. TEST(BackoffDelayProviderTest, GetRecommendedDelay) {
  18. std::unique_ptr<BackoffDelayProvider> delay(
  19. BackoffDelayProvider::FromDefaults());
  20. EXPECT_EQ(base::Seconds(1), delay->GetDelay(base::Seconds(0)));
  21. EXPECT_LE(base::Seconds(1), delay->GetDelay(base::Seconds(1)));
  22. EXPECT_LE(base::Seconds(50), delay->GetDelay(base::Seconds(50)));
  23. EXPECT_LE(base::Seconds(10), delay->GetDelay(base::Seconds(10)));
  24. EXPECT_EQ(kMaxBackoffTime, delay->GetDelay(kMaxBackoffTime));
  25. EXPECT_EQ(kMaxBackoffTime,
  26. delay->GetDelay(kMaxBackoffTime + base::Seconds(1)));
  27. }
  28. TEST(BackoffDelayProviderTest, GetInitialDelay) {
  29. std::unique_ptr<BackoffDelayProvider> delay(
  30. BackoffDelayProvider::FromDefaults());
  31. ModelNeutralState state;
  32. state.last_get_key_result =
  33. SyncerError::HttpError(net::HTTP_INTERNAL_SERVER_ERROR);
  34. EXPECT_EQ(kInitialBackoffRetryTime, delay->GetInitialDelay(state));
  35. state.last_get_key_result = SyncerError();
  36. state.last_download_updates_result =
  37. SyncerError(SyncerError::SERVER_RETURN_MIGRATION_DONE);
  38. EXPECT_EQ(kInitialBackoffImmediateRetryTime, delay->GetInitialDelay(state));
  39. state.last_download_updates_result =
  40. SyncerError::NetworkConnectionUnavailable(net::ERR_FAILED);
  41. EXPECT_EQ(kInitialBackoffRetryTime, delay->GetInitialDelay(state));
  42. state.last_download_updates_result =
  43. SyncerError(SyncerError::SERVER_RETURN_TRANSIENT_ERROR);
  44. EXPECT_EQ(kInitialBackoffRetryTime, delay->GetInitialDelay(state));
  45. state.last_download_updates_result =
  46. SyncerError(SyncerError::SERVER_RESPONSE_VALIDATION_FAILED);
  47. EXPECT_EQ(kInitialBackoffRetryTime, delay->GetInitialDelay(state));
  48. state.last_download_updates_result =
  49. SyncerError(SyncerError::DATATYPE_TRIGGERED_RETRY);
  50. EXPECT_EQ(kInitialBackoffImmediateRetryTime, delay->GetInitialDelay(state));
  51. state.last_download_updates_result = SyncerError(SyncerError::SYNCER_OK);
  52. state.commit_result = SyncerError(SyncerError::SERVER_RETURN_MIGRATION_DONE);
  53. EXPECT_EQ(kInitialBackoffImmediateRetryTime, delay->GetInitialDelay(state));
  54. state.commit_result =
  55. SyncerError::NetworkConnectionUnavailable(net::ERR_FAILED);
  56. EXPECT_EQ(kInitialBackoffRetryTime, delay->GetInitialDelay(state));
  57. state.commit_result = SyncerError(SyncerError::SERVER_RETURN_CONFLICT);
  58. EXPECT_EQ(kInitialBackoffImmediateRetryTime, delay->GetInitialDelay(state));
  59. }
  60. TEST(BackoffDelayProviderTest, GetInitialDelayWithOverride) {
  61. std::unique_ptr<BackoffDelayProvider> delay(
  62. BackoffDelayProvider::WithShortInitialRetryOverride());
  63. ModelNeutralState state;
  64. state.last_get_key_result =
  65. SyncerError::HttpError(net::HTTP_INTERNAL_SERVER_ERROR);
  66. EXPECT_EQ(kInitialBackoffShortRetryTime, delay->GetInitialDelay(state));
  67. state.last_get_key_result = SyncerError();
  68. state.last_download_updates_result =
  69. SyncerError(SyncerError::SERVER_RETURN_MIGRATION_DONE);
  70. EXPECT_EQ(kInitialBackoffImmediateRetryTime, delay->GetInitialDelay(state));
  71. state.last_download_updates_result =
  72. SyncerError(SyncerError::SERVER_RETURN_TRANSIENT_ERROR);
  73. EXPECT_EQ(kInitialBackoffShortRetryTime, delay->GetInitialDelay(state));
  74. state.last_download_updates_result =
  75. SyncerError(SyncerError::SERVER_RESPONSE_VALIDATION_FAILED);
  76. EXPECT_EQ(kInitialBackoffShortRetryTime, delay->GetInitialDelay(state));
  77. state.last_download_updates_result =
  78. SyncerError(SyncerError::DATATYPE_TRIGGERED_RETRY);
  79. EXPECT_EQ(kInitialBackoffImmediateRetryTime, delay->GetInitialDelay(state));
  80. state.last_download_updates_result = SyncerError(SyncerError::SYNCER_OK);
  81. state.commit_result = SyncerError(SyncerError::SERVER_RETURN_MIGRATION_DONE);
  82. EXPECT_EQ(kInitialBackoffImmediateRetryTime, delay->GetInitialDelay(state));
  83. state.commit_result = SyncerError(SyncerError::SERVER_RETURN_CONFLICT);
  84. EXPECT_EQ(kInitialBackoffImmediateRetryTime, delay->GetInitialDelay(state));
  85. }
  86. // This rules out accidents with the constants.
  87. TEST(BackoffDelayProviderTest, GetExponentiallyIncreasingDelay) {
  88. std::unique_ptr<BackoffDelayProvider> delay_provider(
  89. BackoffDelayProvider::FromDefaults());
  90. ASSERT_THAT(kBackoffMultiplyFactor, Gt(1.0));
  91. // Even when the jitter is negative, the delay should grow (overall
  92. // multiplicative factor bigger than 1).
  93. ASSERT_THAT(kBackoffJitterFactor, Lt(kBackoffMultiplyFactor - 1.0));
  94. const base::TimeDelta delay0 = base::Seconds(1);
  95. const base::TimeDelta delay1_min =
  96. delay_provider->GetDelayForTesting(delay0, /*jitter_sign=*/-1);
  97. const base::TimeDelta delay2_min =
  98. delay_provider->GetDelayForTesting(delay1_min, /*jitter_sign=*/-1);
  99. const base::TimeDelta delay1_max =
  100. delay_provider->GetDelayForTesting(delay0, /*jitter_sign=*/1);
  101. const base::TimeDelta delay2_max =
  102. delay_provider->GetDelayForTesting(delay1_max, /*jitter_sign=*/1);
  103. ASSERT_THAT(delay1_min, Lt(delay1_max));
  104. ASSERT_THAT(delay2_min, Lt(delay2_max));
  105. // The minimum value should increase faster than linearly.
  106. EXPECT_THAT(delay1_min, Gt(delay0));
  107. EXPECT_THAT(delay2_min, Gt(delay1_min));
  108. EXPECT_THAT(delay2_min - delay1_min, Gt(delay1_min - delay0));
  109. // The maximum value should increase faster than linearly.
  110. EXPECT_THAT(delay1_max, Gt(delay0));
  111. EXPECT_THAT(delay2_max, Gt(delay1_max));
  112. EXPECT_THAT(delay2_max - delay1_max, Gt(delay1_max - delay0));
  113. }
  114. } // namespace
  115. } // namespace syncer