sync/notifier/sync_system_resources_unittest.cc

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "sync/notifier/sync_system_resources.h"

#include <string>

#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/callback.h"
#include "base/message_loop/message_loop.h"

#include "google/cacheinvalidation/include/types.h"
#include "jingle/notifier/listener/fake_push_client.h"
#include "sync/notifier/push_client_channel.h"
#include "sync/notifier/state_writer.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace syncer {
namespace {

using ::testing::_;
using ::testing::SaveArg;

class MockStateWriter : public StateWriter {
 public:
  MOCK_METHOD1(WriteState, void(const std::string&));
};

class MockClosure {
 public:
  MOCK_CONST_METHOD0(Run, void(void));
  base::Closure* CreateClosure() {
    return new base::Closure(
        base::Bind(&MockClosure::Run, base::Unretained(this)));
  }
};

class MockStorageCallback {
 public:
  MOCK_CONST_METHOD1(Run, void(invalidation::Status));
  base::Callback<void(invalidation::Status)>* CreateCallback() {
    return new base::Callback<void(invalidation::Status)>(
        base::Bind(&MockStorageCallback::Run, base::Unretained(this)));
  }
};

class SyncSystemResourcesTest : public testing::Test {
 protected:
  SyncSystemResourcesTest()
      : push_client_channel_(
            scoped_ptr<notifier::PushClient>(new notifier::FakePushClient())),
        sync_system_resources_(&push_client_channel_, &mock_state_writer_) {}

  virtual ~SyncSystemResourcesTest() {}

  void ScheduleShouldNotRun() {
    {
      // Owned by ScheduleImmediately.
      MockClosure mock_closure;
      base::Closure* should_not_run = mock_closure.CreateClosure();
      EXPECT_CALL(mock_closure, Run()).Times(0);
      sync_system_resources_.internal_scheduler()->Schedule(
          invalidation::Scheduler::NoDelay(), should_not_run);
    }
    {
      // Owned by ScheduleOnListenerThread.
      MockClosure mock_closure;
      base::Closure* should_not_run = mock_closure.CreateClosure();
      EXPECT_CALL(mock_closure, Run()).Times(0);
      sync_system_resources_.listener_scheduler()->Schedule(
          invalidation::Scheduler::NoDelay(), should_not_run);
    }
    {
      // Owned by ScheduleWithDelay.
      MockClosure mock_closure;
      base::Closure* should_not_run = mock_closure.CreateClosure();
      EXPECT_CALL(mock_closure, Run()).Times(0);
      sync_system_resources_.internal_scheduler()->Schedule(
          invalidation::TimeDelta::FromSeconds(0), should_not_run);
    }
  }

  // Needed by |sync_system_resources_|.
  base::MessageLoop message_loop_;
  MockStateWriter mock_state_writer_;
  PushClientChannel push_client_channel_;
  SyncSystemResources sync_system_resources_;

 private:
  DISALLOW_COPY_AND_ASSIGN(SyncSystemResourcesTest);
};

// Make sure current_time() doesn't crash or leak.
TEST_F(SyncSystemResourcesTest, CurrentTime) {
  invalidation::Time current_time =
      sync_system_resources_.internal_scheduler()->GetCurrentTime();
  DVLOG(1) << "current_time returned: " << current_time.ToInternalValue();
}

// Make sure Log() doesn't crash or leak.
TEST_F(SyncSystemResourcesTest, Log) {
  sync_system_resources_.logger()->Log(SyncLogger::INFO_LEVEL,
                                         __FILE__, __LINE__, "%s %d",
                                         "test string", 5);
}

TEST_F(SyncSystemResourcesTest, ScheduleBeforeStart) {
  ScheduleShouldNotRun();
  sync_system_resources_.Start();
}

TEST_F(SyncSystemResourcesTest, ScheduleAfterStop) {
  sync_system_resources_.Start();
  sync_system_resources_.Stop();
  ScheduleShouldNotRun();
}

TEST_F(SyncSystemResourcesTest, ScheduleAndStop) {
  sync_system_resources_.Start();
  ScheduleShouldNotRun();
  sync_system_resources_.Stop();
}

TEST_F(SyncSystemResourcesTest, ScheduleAndDestroy) {
  sync_system_resources_.Start();
  ScheduleShouldNotRun();
}

TEST_F(SyncSystemResourcesTest, ScheduleImmediately) {
  sync_system_resources_.Start();
  MockClosure mock_closure;
  EXPECT_CALL(mock_closure, Run());
  sync_system_resources_.internal_scheduler()->Schedule(
      invalidation::Scheduler::NoDelay(), mock_closure.CreateClosure());
  message_loop_.RunUntilIdle();
}

TEST_F(SyncSystemResourcesTest, ScheduleOnListenerThread) {
  sync_system_resources_.Start();
  MockClosure mock_closure;
  EXPECT_CALL(mock_closure, Run());
  sync_system_resources_.listener_scheduler()->Schedule(
      invalidation::Scheduler::NoDelay(), mock_closure.CreateClosure());
  EXPECT_TRUE(
      sync_system_resources_.internal_scheduler()->IsRunningOnThread());
  message_loop_.RunUntilIdle();
}

TEST_F(SyncSystemResourcesTest, ScheduleWithZeroDelay) {
  sync_system_resources_.Start();
  MockClosure mock_closure;
  EXPECT_CALL(mock_closure, Run());
  sync_system_resources_.internal_scheduler()->Schedule(
      invalidation::TimeDelta::FromSeconds(0), mock_closure.CreateClosure());
  message_loop_.RunUntilIdle();
}

// TODO(akalin): Figure out how to test with a non-zero delay.

TEST_F(SyncSystemResourcesTest, WriteState) {
  sync_system_resources_.Start();
  EXPECT_CALL(mock_state_writer_, WriteState(_));
  // Owned by WriteState.
  MockStorageCallback mock_storage_callback;
  invalidation::Status results(invalidation::Status::PERMANENT_FAILURE,
                               "fake-failure");
  EXPECT_CALL(mock_storage_callback, Run(_))
      .WillOnce(SaveArg<0>(&results));
  sync_system_resources_.storage()->WriteKey(
      std::string(), "state", mock_storage_callback.CreateCallback());
  message_loop_.RunUntilIdle();
  EXPECT_EQ(invalidation::Status(invalidation::Status::SUCCESS, std::string()),
            results);
}

class TestSyncNetworkChannel : public SyncNetworkChannel {
 public:
  TestSyncNetworkChannel() {}
  virtual ~TestSyncNetworkChannel() {}

  using SyncNetworkChannel::NotifyStateChange;
  using SyncNetworkChannel::DeliverIncomingMessage;

  virtual void SendEncodedMessage(const std::string& encoded_message) OVERRIDE {
    last_encoded_message_ = encoded_message;
  }

  std::string last_encoded_message_;
};

class SyncNetworkChannelTest
    : public testing::Test,
      public SyncNetworkChannel::Observer {
 protected:
  SyncNetworkChannelTest()
      : last_invalidator_state_(DEFAULT_INVALIDATION_ERROR),
        connected_(false) {
    network_channel_.AddObserver(this);
    network_channel_.SetMessageReceiver(
        invalidation::NewPermanentCallback(
            this, &SyncNetworkChannelTest::OnIncomingMessage));
    network_channel_.AddNetworkStatusReceiver(
        invalidation::NewPermanentCallback(
            this, &SyncNetworkChannelTest::OnNetworkStatusChange));
  }

  virtual ~SyncNetworkChannelTest() {
    network_channel_.RemoveObserver(this);
  }

  virtual void OnNetworkChannelStateChanged(
      InvalidatorState invalidator_state) OVERRIDE {
    last_invalidator_state_ = invalidator_state;
  }

  void OnIncomingMessage(std::string incoming_message) {
    last_message_ = incoming_message;
  }

  void OnNetworkStatusChange(bool connected) {
    connected_ = connected;
  }

  TestSyncNetworkChannel network_channel_;
  InvalidatorState last_invalidator_state_;
  std::string last_message_;
  bool connected_;
};

const char kMessage[] = "message";
const char kServiceContext[] = "service context";
const int64 kSchedulingHash = 100;

// Encode a message with some context and then decode it.  The decoded info
// should match the original info.
TEST_F(SyncNetworkChannelTest, EncodeDecode) {
  const std::string& data =
      SyncNetworkChannel::EncodeMessageForTest(
          kMessage, kServiceContext, kSchedulingHash);
  std::string message;
  std::string service_context;
  int64 scheduling_hash = 0LL;
  EXPECT_TRUE(SyncNetworkChannel::DecodeMessageForTest(
      data, &message, &service_context, &scheduling_hash));
  EXPECT_EQ(kMessage, message);
  EXPECT_EQ(kServiceContext, service_context);
  EXPECT_EQ(kSchedulingHash, scheduling_hash);
}

// Encode a message with no context and then decode it.  The decoded message
// should match the original message, but the context and hash should be
// untouched.
TEST_F(SyncNetworkChannelTest, EncodeDecodeNoContext) {
  const std::string& data =
      SyncNetworkChannel::EncodeMessageForTest(
          kMessage, std::string(), kSchedulingHash);
  std::string message;
  std::string service_context = kServiceContext;
  int64 scheduling_hash = kSchedulingHash + 1;
  EXPECT_TRUE(SyncNetworkChannel::DecodeMessageForTest(
      data, &message, &service_context, &scheduling_hash));
  EXPECT_EQ(kMessage, message);
  EXPECT_EQ(kServiceContext, service_context);
  EXPECT_EQ(kSchedulingHash + 1, scheduling_hash);
}

// Decode an empty notification. It should result in an empty message
// but should leave the context and hash untouched.
TEST_F(SyncNetworkChannelTest, DecodeEmpty) {
  std::string message = kMessage;
  std::string service_context = kServiceContext;
  int64 scheduling_hash = kSchedulingHash;
  EXPECT_TRUE(SyncNetworkChannel::DecodeMessageForTest(
      std::string(), &message, &service_context, &scheduling_hash));
  EXPECT_TRUE(message.empty());
  EXPECT_EQ(kServiceContext, service_context);
  EXPECT_EQ(kSchedulingHash, scheduling_hash);
}

// Try to decode a garbage notification.  It should leave all its
// arguments untouched and return false.
TEST_F(SyncNetworkChannelTest, DecodeGarbage) {
  std::string data = "garbage";
  std::string message = kMessage;
  std::string service_context = kServiceContext;
  int64 scheduling_hash = kSchedulingHash;
  EXPECT_FALSE(SyncNetworkChannel::DecodeMessageForTest(
      data, &message, &service_context, &scheduling_hash));
  EXPECT_EQ(kMessage, message);
  EXPECT_EQ(kServiceContext, service_context);
  EXPECT_EQ(kSchedulingHash, scheduling_hash);
}

// Simulate network channel state change. It should propagate to observer.
TEST_F(SyncNetworkChannelTest, OnNetworkChannelStateChanged) {
  EXPECT_EQ(DEFAULT_INVALIDATION_ERROR, last_invalidator_state_);
  EXPECT_FALSE(connected_);
  network_channel_.NotifyStateChange(INVALIDATIONS_ENABLED);
  EXPECT_EQ(INVALIDATIONS_ENABLED, last_invalidator_state_);
  EXPECT_TRUE(connected_);
  network_channel_.NotifyStateChange(INVALIDATION_CREDENTIALS_REJECTED);
  EXPECT_EQ(INVALIDATION_CREDENTIALS_REJECTED, last_invalidator_state_);
  EXPECT_FALSE(connected_);
}

// Call SendMessage on the channel.  SendEncodedMessage should be called for it.
TEST_F(SyncNetworkChannelTest, SendMessage) {
  network_channel_.SendMessage(kMessage);
  std::string expected_encoded_message =
      SyncNetworkChannel::EncodeMessageForTest(
          kMessage,
          network_channel_.GetServiceContextForTest(),
          network_channel_.GetSchedulingHashForTest());
  ASSERT_EQ(expected_encoded_message, network_channel_.last_encoded_message_);
}

// Simulate an incoming notification. It should be decoded properly
// by the channel.
TEST_F(SyncNetworkChannelTest, OnIncomingMessage) {
  const std::string message =
      SyncNetworkChannel::EncodeMessageForTest(
          kMessage, kServiceContext, kSchedulingHash);

  network_channel_.DeliverIncomingMessage(message);
  EXPECT_EQ(kServiceContext,
            network_channel_.GetServiceContextForTest());
  EXPECT_EQ(kSchedulingHash,
            network_channel_.GetSchedulingHashForTest());
  EXPECT_EQ(kMessage, last_message_);
}

// Simulate an incoming notification with no receiver. It should be dropped by
// the channel.
TEST_F(SyncNetworkChannelTest, OnIncomingMessageNoReceiver) {
  const std::string message =
      SyncNetworkChannel::EncodeMessageForTest(
          kMessage, kServiceContext, kSchedulingHash);

  network_channel_.SetMessageReceiver(NULL);
  network_channel_.DeliverIncomingMessage(message);
  EXPECT_TRUE(network_channel_.GetServiceContextForTest().empty());
  EXPECT_EQ(static_cast<int64>(0),
            network_channel_.GetSchedulingHashForTest());
  EXPECT_TRUE(last_message_.empty());
}

// Simulate an incoming garbage notification. It should be dropped by
// the channel.
TEST_F(SyncNetworkChannelTest, OnIncomingMessageGarbage) {
  std::string message = "garbage";

  network_channel_.DeliverIncomingMessage(message);
  EXPECT_TRUE(network_channel_.GetServiceContextForTest().empty());
  EXPECT_EQ(static_cast<int64>(0),
            network_channel_.GetSchedulingHashForTest());
  EXPECT_TRUE(last_message_.empty());
}

// Send a message, simulate an incoming message with context, and then
// send the same message again.  The first sent message should not
// have any context, but the second sent message should have the
// context from the incoming emssage.
TEST_F(SyncNetworkChannelTest, PersistedMessageState) {
  network_channel_.SendMessage(kMessage);
  ASSERT_FALSE(network_channel_.last_encoded_message_.empty());
  {
    std::string message;
    std::string service_context;
    int64 scheduling_hash = 0LL;
    EXPECT_TRUE(SyncNetworkChannel::DecodeMessageForTest(
        network_channel_.last_encoded_message_,
        &message, &service_context, &scheduling_hash));
    EXPECT_EQ(kMessage, message);
    EXPECT_TRUE(service_context.empty());
    EXPECT_EQ(0LL, scheduling_hash);
  }

  const std::string& encoded_message =
      SyncNetworkChannel::EncodeMessageForTest(
          kMessage, kServiceContext, kSchedulingHash);
  network_channel_.DeliverIncomingMessage(encoded_message);

  network_channel_.last_encoded_message_.clear();
  network_channel_.SendMessage(kMessage);
  ASSERT_FALSE(network_channel_.last_encoded_message_.empty());
  {
    std::string message;
    std::string service_context;
    int64 scheduling_hash = 0LL;
    EXPECT_TRUE(SyncNetworkChannel::DecodeMessageForTest(
        network_channel_.last_encoded_message_,
        &message, &service_context, &scheduling_hash));
    EXPECT_EQ(kMessage, message);
    EXPECT_EQ(kServiceContext, service_context);
    EXPECT_EQ(kSchedulingHash, scheduling_hash);
  }
}

}  // namespace
}  // namespace syncer