Home | History | Annotate | Download | only in engine 
      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/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
    120