text: // Copyright 2018 The Chromium OS 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 "shill/cellular/pending_activation_store.h"
  
  #include <utility>
  
  #include <base/files/scoped_temp_dir.h>
  #include <gmock/gmock.h>
  #include <gtest/gtest.h>
  
  #include "shill/mock_store.h"
  #include "shill/store_interface.h"
  
  using ::testing::_;
  using ::testing::DoAll;
  using ::testing::Mock;
  using ::testing::Return;
  using ::testing::SetArgPointee;
  
  namespace shill {
  
  class PendingActivationStoreTest : public ::testing::Test {
   public:
    PendingActivationStoreTest() : mock_store_(new MockStore()) {}
  
   protected:
    void SetMockStore() { store_.storage_ = std::move(mock_store_); }
  
    std::unique_ptr<MockStore> mock_store_;
    PendingActivationStore store_;
  };
  
  TEST_F(PendingActivationStoreTest, FileInteractions) {
    const char kEntry1[] = "1234";
    const char kEntry2[] = "4321";
  
    base::ScopedTempDir temp_dir;
    EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
  
    EXPECT_TRUE(store_.InitStorage(temp_dir.GetPath()));
  
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry2));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry2));
  
    EXPECT_TRUE(store_.SetActivationState(
        PendingActivationStore::kIdentifierICCID, kEntry1,
        PendingActivationStore::kStatePending));
    EXPECT_TRUE(store_.SetActivationState(
        PendingActivationStore::kIdentifierICCID, kEntry2,
        PendingActivationStore::kStateActivated));
  
    EXPECT_EQ(PendingActivationStore::kStatePending,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateActivated,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry2));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry2));
  
    EXPECT_TRUE(store_.SetActivationState(
        PendingActivationStore::kIdentifierMEID, kEntry1,
        PendingActivationStore::kStateActivated));
  
    EXPECT_EQ(PendingActivationStore::kStatePending,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateActivated,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry2));
    EXPECT_EQ(PendingActivationStore::kStateActivated,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry1));
  
    EXPECT_TRUE(store_.SetActivationState(
        PendingActivationStore::kIdentifierICCID, kEntry1,
        PendingActivationStore::kStateActivated));
    EXPECT_TRUE(store_.SetActivationState(
        PendingActivationStore::kIdentifierICCID, kEntry2,
        PendingActivationStore::kStatePending));
  
    EXPECT_EQ(PendingActivationStore::kStateActivated,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStatePending,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry2));
  
    // Close and reopen the file to verify that the entries persisted.
    EXPECT_TRUE(store_.InitStorage(temp_dir.GetPath()));
  
    EXPECT_EQ(PendingActivationStore::kStateActivated,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStatePending,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry2));
    EXPECT_EQ(PendingActivationStore::kStateActivated,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry1));
  
    EXPECT_TRUE(
        store_.RemoveEntry(PendingActivationStore::kIdentifierMEID, kEntry1));
    EXPECT_TRUE(
        store_.RemoveEntry(PendingActivationStore::kIdentifierICCID, kEntry2));
  
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry2));
    EXPECT_EQ(PendingActivationStore::kStateActivated,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry1));
  
    EXPECT_TRUE(
        store_.RemoveEntry(PendingActivationStore::kIdentifierICCID, kEntry1));
    EXPECT_FALSE(
        store_.RemoveEntry(PendingActivationStore::kIdentifierMEID, kEntry2));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry2));
  
    EXPECT_TRUE(store_.InitStorage(temp_dir.GetPath()));
  
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry2));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry1));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry2));
  }
  
  TEST_F(PendingActivationStoreTest, GetActivationState) {
    MockStore* mock_store = mock_store_.get();
    SetMockStore();
  
    const char kEntry[] = "12345689";
  
    // Value not found
    EXPECT_CALL(*mock_store,
                GetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
        .WillOnce(Return(false));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry));
  
    // File contains invalid entry
    EXPECT_CALL(*mock_store,
                GetInt(PendingActivationStore::kMeidGroupId, kEntry, _))
        .WillOnce(DoAll(
            SetArgPointee<2>(static_cast<int>(PendingActivationStore::kStateMax)),
            Return(true)));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry));
    EXPECT_CALL(*mock_store,
                GetInt(PendingActivationStore::kMeidGroupId, kEntry, _))
        .WillOnce(DoAll(SetArgPointee<2>(0), Return(true)));
    EXPECT_EQ(PendingActivationStore::kStateUnknown,
              store_.GetActivationState(PendingActivationStore::kIdentifierMEID,
                                        kEntry));
    Mock::VerifyAndClearExpectations(mock_store);
  
    // All enum values
    EXPECT_CALL(*mock_store,
                GetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
        .WillOnce(DoAll(SetArgPointee<2>(1), Return(true)));
    EXPECT_EQ(PendingActivationStore::kStatePending,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry));
    EXPECT_CALL(*mock_store,
                GetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
        .WillOnce(DoAll(SetArgPointee<2>(2), Return(true)));
    EXPECT_EQ(PendingActivationStore::kStateActivated,
              store_.GetActivationState(PendingActivationStore::kIdentifierICCID,
                                        kEntry));
    Mock::VerifyAndClearExpectations(mock_store);
  }
  
  TEST_F(PendingActivationStoreTest, SetActivationState) {
    MockStore* mock_store = mock_store_.get();
    SetMockStore();
  
    const char kEntry[] = "12345689";
  
    EXPECT_CALL(*mock_store, Flush()).WillRepeatedly(Return(true));
    EXPECT_CALL(*mock_store,
                SetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
        .WillOnce(Return(false));
    EXPECT_FALSE(
        store_.SetActivationState(PendingActivationStore::kIdentifierICCID,
                                  kEntry, PendingActivationStore::kStateUnknown));
    EXPECT_FALSE(
        store_.SetActivationState(PendingActivationStore::kIdentifierICCID,
                                  kEntry, PendingActivationStore::kStateUnknown));
    EXPECT_FALSE(
        store_.SetActivationState(PendingActivationStore::kIdentifierICCID,
                                  kEntry, PendingActivationStore::kStatePending));
  
    EXPECT_CALL(*mock_store,
                SetInt(PendingActivationStore::kIccidGroupId, kEntry, _))
        .WillRepeatedly(Return(true));
    EXPECT_FALSE(store_.SetActivationState(
        PendingActivationStore::kIdentifierICCID, kEntry,
        static_cast<PendingActivationStore::State>(-1)));
    EXPECT_FALSE(
        store_.SetActivationState(PendingActivationStore::kIdentifierICCID,
                                  kEntry, PendingActivationStore::kStateMax));
    EXPECT_FALSE(
        store_.SetActivationState(PendingActivationStore::kIdentifierICCID,
                                  kEntry, PendingActivationStore::kStateUnknown));
    EXPECT_TRUE(
        store_.SetActivationState(PendingActivationStore::kIdentifierICCID,
                                  kEntry, PendingActivationStore::kStatePending));
    EXPECT_TRUE(store_.SetActivationState(
        PendingActivationStore::kIdentifierICCID, kEntry,
        PendingActivationStore::kStateActivated));
  }
  
  TEST_F(PendingActivationStoreTest, RemoveEntry) {
    MockStore* mock_store = mock_store_.get();
    SetMockStore();
  
    const char kEntry[] = "12345689";
  
    EXPECT_CALL(*mock_store, Flush()).WillRepeatedly(Return(true));
    EXPECT_CALL(*mock_store,
                DeleteKey(PendingActivationStore::kIccidGroupId, kEntry))
        .WillOnce(Return(false));
    EXPECT_FALSE(
        store_.RemoveEntry(PendingActivationStore::kIdentifierICCID, kEntry));
    EXPECT_CALL(*mock_store,
                DeleteKey(PendingActivationStore::kIccidGroupId, kEntry))
        .WillOnce(Return(true));
    EXPECT_TRUE(
        store_.RemoveEntry(PendingActivationStore::kIdentifierICCID, kEntry));
  }
  
  }  // namespace shill
  