sync/engine/backoff_delay_provider_unittest.cc

   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
   5 #include "sync/engine/backoff_delay_provider.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/time.h"
   9 #include "sync/internal_api/public/engine/polling_constants.h"
  10 #include "sync/internal_api/public/sessions/model_neutral_state.h"
  11 #include "sync/internal_api/public/util/syncer_error.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using base::TimeDelta;
  15
  16 namespace syncer {
  17
  18 class BackoffDelayProviderTest : public testing::Test {};
  19
  20 TEST_F(BackoffDelayProviderTest, GetRecommendedDelay) {
  21   scoped_ptr<BackoffDelayProvider> delay(BackoffDelayProvider::FromDefaults());
  22   EXPECT_EQ(TimeDelta::FromSeconds(1),
  23             delay->GetDelay(TimeDelta::FromSeconds(0)));
  24   EXPECT_LE(TimeDelta::FromSeconds(1),
  25             delay->GetDelay(TimeDelta::FromSeconds(1)));
  26   EXPECT_LE(TimeDelta::FromSeconds(50),
  27             delay->GetDelay(TimeDelta::FromSeconds(50)));
  28   EXPECT_LE(TimeDelta::FromSeconds(10),
  29             delay->GetDelay(TimeDelta::FromSeconds(10)));
  30   EXPECT_EQ(TimeDelta::FromSeconds(kMaxBackoffSeconds),
  31             delay->GetDelay(TimeDelta::FromSeconds(kMaxBackoffSeconds)));
  32   EXPECT_EQ(TimeDelta::FromSeconds(kMaxBackoffSeconds),
  33             delay->GetDelay(TimeDelta::FromSeconds(kMaxBackoffSeconds + 1)));
  34 }
  35
  36 TEST_F(BackoffDelayProviderTest, GetInitialDelay) {
  37   scoped_ptr<BackoffDelayProvider> delay(BackoffDelayProvider::FromDefaults());
  38   sessions::ModelNeutralState state;
  39   state.last_get_key_result = SYNC_SERVER_ERROR;
  40   EXPECT_EQ(kInitialBackoffRetrySeconds,
  41             delay->GetInitialDelay(state).InSeconds());
  42
  43   state.last_get_key_result = UNSET;
  44   state.last_download_updates_result = SERVER_RETURN_MIGRATION_DONE;
  45   EXPECT_EQ(kInitialBackoffImmediateRetrySeconds,
  46             delay->GetInitialDelay(state).InSeconds());
  47
  48   state.last_download_updates_result = NETWORK_CONNECTION_UNAVAILABLE;
  49   EXPECT_EQ(kInitialBackoffImmediateRetrySeconds,
  50             delay->GetInitialDelay(state).InSeconds());
  51
  52   state.last_download_updates_result = SERVER_RETURN_TRANSIENT_ERROR;
  53   EXPECT_EQ(kInitialBackoffRetrySeconds,
  54             delay->GetInitialDelay(state).InSeconds());
  55
  56   state.last_download_updates_result = SERVER_RESPONSE_VALIDATION_FAILED;
  57   EXPECT_EQ(kInitialBackoffRetrySeconds,
  58             delay->GetInitialDelay(state).InSeconds());
  59
  60   state.last_download_updates_result = SYNCER_OK;
  61   // Note that updating credentials triggers a canary job, trumping
  62   // the initial delay, but in theory we still expect this function to treat
  63   // it like any other error in the system (except migration).
  64   state.commit_result = SERVER_RETURN_INVALID_CREDENTIAL;
  65   EXPECT_EQ(kInitialBackoffRetrySeconds,
  66             delay->GetInitialDelay(state).InSeconds());
  67
  68   state.commit_result = SERVER_RETURN_MIGRATION_DONE;
  69   EXPECT_EQ(kInitialBackoffImmediateRetrySeconds,
  70             delay->GetInitialDelay(state).InSeconds());
  71
  72   state.commit_result = NETWORK_CONNECTION_UNAVAILABLE;
  73   EXPECT_EQ(kInitialBackoffImmediateRetrySeconds,
  74             delay->GetInitialDelay(state).InSeconds());
  75
  76   state.commit_result = SERVER_RETURN_CONFLICT;
  77   EXPECT_EQ(kInitialBackoffImmediateRetrySeconds,
  78             delay->GetInitialDelay(state).InSeconds());
  79 }
  80
  81 TEST_F(BackoffDelayProviderTest, GetInitialDelayWithOverride) {
  82   scoped_ptr<BackoffDelayProvider> delay(
  83       BackoffDelayProvider::WithShortInitialRetryOverride());
  84   sessions::ModelNeutralState state;
  85   state.last_get_key_result = SYNC_SERVER_ERROR;
  86   EXPECT_EQ(kInitialBackoffShortRetrySeconds,
  87             delay->GetInitialDelay(state).InSeconds());
  88
  89   state.last_get_key_result = UNSET;
  90   state.last_download_updates_result = SERVER_RETURN_MIGRATION_DONE;
  91   EXPECT_EQ(kInitialBackoffImmediateRetrySeconds,
  92             delay->GetInitialDelay(state).InSeconds());
  93
  94   state.last_download_updates_result = SERVER_RETURN_TRANSIENT_ERROR;
  95   EXPECT_EQ(kInitialBackoffShortRetrySeconds,
  96             delay->GetInitialDelay(state).InSeconds());
  97
  98   state.last_download_updates_result = SERVER_RESPONSE_VALIDATION_FAILED;
  99   EXPECT_EQ(kInitialBackoffShortRetrySeconds,
 100             delay->GetInitialDelay(state).InSeconds());
 101
 102   state.last_download_updates_result = SYNCER_OK;
 103   // Note that updating credentials triggers a canary job, trumping
 104   // the initial delay, but in theory we still expect this function to treat
 105   // it like any other error in the system (except migration).
 106   state.commit_result = SERVER_RETURN_INVALID_CREDENTIAL;
 107   EXPECT_EQ(kInitialBackoffShortRetrySeconds,
 108             delay->GetInitialDelay(state).InSeconds());
 109
 110   state.commit_result = SERVER_RETURN_MIGRATION_DONE;
 111   EXPECT_EQ(kInitialBackoffImmediateRetrySeconds,
 112             delay->GetInitialDelay(state).InSeconds());
 113
 114   state.commit_result = SERVER_RETURN_CONFLICT;
 115   EXPECT_EQ(kInitialBackoffImmediateRetrySeconds,
 116             delay->GetInitialDelay(state).InSeconds());
 117 }
 118
 119 }  // namespace syncer