tst/syncstorageimpl_test.cpp

/*
   Copyright (c) 2018-2019 Nokia.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

#include <gtest/gtest.h>
#include "private/error.hpp"
#include "private/redis/asyncredisstorage.hpp"
#include "private/syncstorageimpl.hpp"
#include "private/tst/asyncstoragemock.hpp"
#include "private/tst/systemmock.hpp"
#include <sdl/backenderror.hpp>
#include <sdl/invalidnamespace.hpp>
#include <sdl/notconnected.hpp>
#include <sdl/operationinterrupted.hpp>
#include <sdl/rejectedbybackend.hpp>

using namespace shareddatalayer;
using namespace shareddatalayer::redis;
using namespace shareddatalayer::tst;
using namespace testing;

namespace
{
    class SyncStorageImplTest: public testing::Test
    {
    public:
        std::unique_ptr<SyncStorageImpl> syncStorage;
        /* AsyncStorageMock ownership will be passed to implementation. To be able to do verification
         * with the mock object also here after its ownership is passed we take raw pointer to
         * AsyncStorageMock before passing it to implementation. Works fine, as implementation will
         * not release injected mock object before test case execution finishes
         */
        std::unique_ptr<StrictMock<AsyncStorageMock>> asyncStorageMockPassedToImplementation;
        StrictMock<AsyncStorageMock>* asyncStorageMockRawPtr;
        StrictMock<SystemMock> systemMock;
        AsyncStorage::ModifyAck savedModifyAck;
        AsyncStorage::ModifyIfAck savedModifyIfAck;
        AsyncStorage::GetAck savedGetAck;
        AsyncStorage::FindKeysAck savedFindKeysAck;
        AsyncStorage::ReadyAck savedReadyAck;
        int pFd;
        SyncStorage::DataMap dataMap;
        SyncStorage::Keys keys;
        const SyncStorage::Namespace ns;
        SyncStorageImplTest():
            asyncStorageMockPassedToImplementation(new StrictMock<AsyncStorageMock>()),
            asyncStorageMockRawPtr(asyncStorageMockPassedToImplementation.get()),
            pFd(10),
            dataMap({{ "key1", { 0x0a, 0x0b, 0x0c } }, { "key2", { 0x0d, 0x0e, 0x0f, 0xff } }}),
            keys({ "key1", "key2" }),
            ns("someKnownNamespace")
        {
            expectConstructorCalls();
            syncStorage.reset(new SyncStorageImpl(std::move(asyncStorageMockPassedToImplementation), systemMock));
        }

        void expectConstructorCalls()
        {
            InSequence dummy;
            EXPECT_CALL(*asyncStorageMockRawPtr, fd())
                .Times(1)
                .WillOnce(Return(pFd));
        }

        void expectSdlReadinessCheck()
        {
            InSequence dummy;
            expectWaitReadyAsync();
            expectPollWait();
            expectHandleEvents();
        }

        void expectPollWait()
        {
            EXPECT_CALL(systemMock, poll( _, 1, -1))
                .Times(1)
                .WillOnce(Invoke([](struct pollfd *fds, nfds_t, int)
                                 {
                                     fds->revents = POLLIN;
                                     return 1;
                                 }));
        }

        void expectPollError()
        {
            EXPECT_CALL(systemMock, poll( _, 1, -1))
                .Times(1)
                .WillOnce(Invoke([](struct pollfd *fds, nfds_t, int)
                                 {
                                     fds->revents = POLLIN;
                                     return -1;
                                 }));
        }

        void expectPollExceptionalCondition()
        {
            EXPECT_CALL(systemMock, poll( _, 1, -1))
                .Times(1)
                .WillOnce(Invoke([](struct pollfd *fds, nfds_t, int)
                                 {
                                     fds->revents = POLLPRI;
                                     return 1;
                                 }));
        }

        void expectHandleEvents()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, handleEvents())
                .Times(1)
                .WillOnce(Invoke([this]()
                                 {
                                    savedReadyAck(std::error_code());
                                 }));
        }

        void expectWaitReadyAsync()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, waitReadyAsync(ns,_))
                .Times(1)
                .WillOnce(SaveArg<1>(&savedReadyAck));
        }


        void expectModifyAckWithError()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, handleEvents())
                .Times(1)
                .WillOnce(Invoke([this]()
                                 {
                                    savedModifyAck(AsyncRedisCommandDispatcherErrorCode::OUT_OF_MEMORY);
                                 }));
        }

        void expectModifyIfAck(const std::error_code& error, bool status)
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, handleEvents())
                .Times(1)
                .WillOnce(Invoke([this, error, status]()
                                 {
                                    savedModifyIfAck(error, status);
                                 }));
        }

        void expectGetAckWithError()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, handleEvents())
                .Times(1)
                .WillOnce(Invoke([this]()
                                 {
                                    savedGetAck(AsyncRedisCommandDispatcherErrorCode::OUT_OF_MEMORY, dataMap);
                                 }));
        }

        void expectGetAck()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, handleEvents())
                .Times(1)
                .WillOnce(Invoke([this]()
                                 {
                                    savedGetAck(std::error_code(), dataMap);
                                 }));
        }

        void expectFindKeysAck()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, handleEvents())
                .Times(1)
                .WillOnce(Invoke([this]()
                                 {
                                    savedFindKeysAck(std::error_code(), keys);
                                 }));
        }

        void expectFindKeysAckWithError()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, handleEvents())
                .Times(1)
                .WillOnce(Invoke([this]()
                                 {
                                    savedFindKeysAck(AsyncRedisCommandDispatcherErrorCode::OUT_OF_MEMORY, keys);
                                 }));
        }

        void expectSetAsync(const SyncStorage::DataMap& dataMap)
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, setAsync(ns, dataMap, _))
                .Times(1)
                .WillOnce(SaveArg<2>(&savedModifyAck));
        }

        void expectSetIfAsync(const SyncStorage::Key& key, const SyncStorage::Data& oldData, const SyncStorage::Data& newData)
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, setIfAsync(ns, key, oldData, newData, _))
                .Times(1)
                .WillOnce(SaveArg<4>(&savedModifyIfAck));
        }

        void expectGetAsync(const SyncStorage::Keys& keys)
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, getAsync(ns, keys, _))
                .Times(1)
                .WillOnce(SaveArg<2>(&savedGetAck));
        }

        void expectFindKeysAsync()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, findKeysAsync(ns, _, _))
                .Times(1)
                .WillOnce(SaveArg<2>(&savedFindKeysAck));
        }

        void expectRemoveAsync(const SyncStorage::Keys& keys)
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, removeAsync(ns, keys, _))
                .Times(1)
                .WillOnce(SaveArg<2>(&savedModifyAck));
        }

        void expectRemoveIfAsync(const SyncStorage::Key& key, const SyncStorage::Data& data)
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, removeIfAsync(ns, key, data, _))
                .Times(1)
                .WillOnce(SaveArg<3>(&savedModifyIfAck));
        }

        void expectRemoveAllAsync()
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, removeAllAsync(ns, _))
                .Times(1)
                .WillOnce(SaveArg<1>(&savedModifyAck));
        }

        void expectSetIfNotExistsAsync(const SyncStorage::Key& key, const SyncStorage::Data& data)
        {
            EXPECT_CALL(*asyncStorageMockRawPtr, setIfNotExistsAsync(ns, key, data, _))
                .Times(1)
                .WillOnce(SaveArg<3>(&savedModifyIfAck));
        }
    };
}

TEST_F(SyncStorageImplTest, IsNotCopyable)
{
    InSequence dummy;
    EXPECT_FALSE(std::is_copy_constructible<SyncStorageImpl>::value);
    EXPECT_FALSE(std::is_copy_assignable<SyncStorageImpl>::value);
}

TEST_F(SyncStorageImplTest, ImplementssyncStorage)
{
    InSequence dummy;
    EXPECT_TRUE((std::is_base_of<SyncStorage, SyncStorageImpl>::value));
}

TEST_F(SyncStorageImplTest, EventsAreNotHandledWhenPollReturnsError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetAsync(dataMap);
    expectPollError();
    expectPollWait();
    expectHandleEvents();
    syncStorage->set(ns, dataMap);
}

TEST_F(SyncStorageImplTest, EventsAreNotHandledWhenThereIsAnExceptionalConditionOnTheFd)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetAsync(dataMap);
    expectPollExceptionalCondition();
    expectPollWait();
    expectHandleEvents();
    syncStorage->set(ns, dataMap);
}

TEST_F(SyncStorageImplTest, SetSuccessfully)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetAsync(dataMap);
    expectPollWait();
    expectHandleEvents();
    syncStorage->set(ns, dataMap);
}

TEST_F(SyncStorageImplTest, SetCanThrowBackendError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetAsync(dataMap);
    expectPollWait();
    expectModifyAckWithError();
    EXPECT_THROW(syncStorage->set(ns, dataMap), BackendError);
}

TEST_F(SyncStorageImplTest, SetIfSuccessfully)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetAsync(dataMap);
    expectPollWait();
    expectHandleEvents();
    syncStorage->set(ns, dataMap);
    expectSdlReadinessCheck();
    expectSetIfAsync("key1", { 0x0a, 0x0b, 0x0c }, { 0x0d, 0x0e, 0x0f });
    expectPollWait();
    expectHandleEvents();
    syncStorage->setIf(ns, "key1", { 0x0a, 0x0b, 0x0c }, { 0x0d, 0x0e, 0x0f });
}

TEST_F(SyncStorageImplTest, SetIfCanThrowBackendError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetAsync(dataMap);
    expectPollWait();
    expectHandleEvents();
    syncStorage->set(ns, dataMap);
    expectSdlReadinessCheck();
    expectSetIfAsync("key1", { 0x0a, 0x0b, 0x0c }, { 0x0d, 0x0e, 0x0f });
    expectPollWait();
    expectModifyIfAck(AsyncRedisCommandDispatcherErrorCode::OUT_OF_MEMORY, false);
    EXPECT_THROW(syncStorage->setIf(ns, "key1", { 0x0a, 0x0b, 0x0c }, { 0x0d, 0x0e, 0x0f }), BackendError);
}

TEST_F(SyncStorageImplTest, SetIfNotExistsSuccessfully)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetIfNotExistsAsync("key1", { 0x0a, 0x0b, 0x0c });
    expectPollWait();
    expectModifyIfAck(std::error_code(), true);
    EXPECT_EQ(true, syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }));
}

TEST_F(SyncStorageImplTest, SetIfNotExistsReturnsFalseIfKeyAlreadyExists)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetIfNotExistsAsync("key1", { 0x0a, 0x0b, 0x0c });
    expectPollWait();
    expectModifyIfAck(std::error_code(), false);
    EXPECT_EQ(false, syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }));
}

TEST_F(SyncStorageImplTest, SetIfNotExistsCanThrowBackendError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetIfNotExistsAsync("key1", { 0x0a, 0x0b, 0x0c });
    expectPollWait();
    expectModifyIfAck(AsyncRedisCommandDispatcherErrorCode::OUT_OF_MEMORY, false);
    EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), BackendError);
}

TEST_F(SyncStorageImplTest, GetSuccessfully)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectGetAsync(keys);
    expectPollWait();
    expectGetAck();
    auto map(syncStorage->get(ns, keys));
    EXPECT_EQ(map, dataMap);
}

TEST_F(SyncStorageImplTest, GetCanThrowBackendError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectGetAsync(keys);
    expectPollWait();
    expectGetAckWithError();
    EXPECT_THROW(syncStorage->get(ns, keys), BackendError);
}

TEST_F(SyncStorageImplTest, RemoveSuccessfully)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectRemoveAsync(keys);
    expectPollWait();
    expectHandleEvents();
    syncStorage->remove(ns, keys);
}

TEST_F(SyncStorageImplTest, RemoveCanThrowBackendError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectRemoveAsync(keys);
    expectPollWait();
    expectModifyAckWithError();
    EXPECT_THROW(syncStorage->remove(ns, keys), BackendError);
}

TEST_F(SyncStorageImplTest, RemoveIfSuccessfully)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectRemoveIfAsync("key1", { 0x0a, 0x0b, 0x0c });
    expectPollWait();
    expectModifyIfAck(std::error_code(), true);
    EXPECT_EQ(true, syncStorage->removeIf(ns, "key1", { 0x0a, 0x0b, 0x0c }));
}

TEST_F(SyncStorageImplTest, RemoveIfReturnsFalseIfKeyDoesnotMatch)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectRemoveIfAsync("key1", { 0x0a, 0x0b, 0x0c });
    expectPollWait();
    expectModifyIfAck(std::error_code(), false);
    EXPECT_EQ(false, syncStorage->removeIf(ns, "key1", { 0x0a, 0x0b, 0x0c }));
}

TEST_F(SyncStorageImplTest, RemoveIfCanThrowBackendError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectRemoveIfAsync("key1", { 0x0a, 0x0b, 0x0c });
    expectPollWait();
    expectModifyIfAck(AsyncRedisCommandDispatcherErrorCode::OUT_OF_MEMORY, false);
    EXPECT_THROW(syncStorage->removeIf(ns, "key1", { 0x0a, 0x0b, 0x0c }), BackendError);
}

TEST_F(SyncStorageImplTest, FindKeysSuccessfully)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectFindKeysAsync();
    expectPollWait();
    expectFindKeysAck();
    auto ids(syncStorage->findKeys(ns, "*"));
    EXPECT_EQ(ids, keys);
}

TEST_F(SyncStorageImplTest, FindKeysAckCanThrowBackendError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectFindKeysAsync();
    expectPollWait();
    expectFindKeysAckWithError();
    EXPECT_THROW(syncStorage->findKeys(ns, "*"), BackendError);
}

TEST_F(SyncStorageImplTest, RemoveAllSuccessfully)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectRemoveAllAsync();
    expectPollWait();
    expectHandleEvents();
    syncStorage->removeAll(ns);
}

TEST_F(SyncStorageImplTest, RemoveAllCanThrowBackendError)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectRemoveAllAsync();
    expectPollWait();
    expectModifyAckWithError();
    EXPECT_THROW(syncStorage->removeAll(ns), BackendError);
}

TEST_F(SyncStorageImplTest, AllAsyncRedisStorageErrorCodesThrowCorrectException)
{
    InSequence dummy;
    std::error_code ec;

    for (AsyncRedisStorage::ErrorCode arsec = AsyncRedisStorage::ErrorCode::SUCCESS; arsec < AsyncRedisStorage::ErrorCode::END_MARKER; ++arsec)
    {
        if (arsec != AsyncRedisStorage::ErrorCode::SUCCESS)
        {
            expectSdlReadinessCheck();
            expectSetIfNotExistsAsync("key1", { 0x0a, 0x0b, 0x0c });
            expectPollWait();
        }

        switch (arsec)
        {
            case AsyncRedisStorage::ErrorCode::SUCCESS:
                break;
            case AsyncRedisStorage::ErrorCode::INVALID_NAMESPACE:
                expectModifyIfAck(arsec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), InvalidNamespace);
                break;
            case AsyncRedisStorage::ErrorCode::REDIS_NOT_YET_DISCOVERED:
                expectModifyIfAck(arsec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), NotConnected);
                break;
            default:
                FAIL() << "No mapping for AsyncRedisStorage::ErrorCode value: " << arsec;
                break;
        }
    }
}

TEST_F(SyncStorageImplTest, AllDispatcherErrorCodesThrowCorrectException)
{
    InSequence dummy;
    std::error_code ec;

    for (AsyncRedisCommandDispatcherErrorCode aec = AsyncRedisCommandDispatcherErrorCode::SUCCESS; aec < AsyncRedisCommandDispatcherErrorCode::END_MARKER; ++aec)
    {
        if (aec != AsyncRedisCommandDispatcherErrorCode::SUCCESS)
        {
            expectSdlReadinessCheck();
            expectSetIfNotExistsAsync("key1", { 0x0a, 0x0b, 0x0c });
            expectPollWait();
        }

        switch (aec)
        {
            case AsyncRedisCommandDispatcherErrorCode::SUCCESS:
                break;
            case AsyncRedisCommandDispatcherErrorCode::UNKNOWN_ERROR:
                expectModifyIfAck(aec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), BackendError);
                break;
            case AsyncRedisCommandDispatcherErrorCode::CONNECTION_LOST:
                expectModifyIfAck(aec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), OperationInterrupted);
                break;
            case AsyncRedisCommandDispatcherErrorCode::PROTOCOL_ERROR:
                expectModifyIfAck(aec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), RejectedByBackend);
                break;
            case AsyncRedisCommandDispatcherErrorCode::OUT_OF_MEMORY:
                expectModifyIfAck(aec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), BackendError);
                break;
            case AsyncRedisCommandDispatcherErrorCode::DATASET_LOADING:
                expectModifyIfAck(aec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), NotConnected);
                break;
            case AsyncRedisCommandDispatcherErrorCode::NOT_CONNECTED:
                expectModifyIfAck(aec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), NotConnected);
                break;
            case AsyncRedisCommandDispatcherErrorCode::IO_ERROR:
                expectModifyIfAck(aec, false);
                EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), BackendError);
                break;
            default:
                FAIL() << "No mapping for AsyncRedisCommandDispatcherErrorCode value: " << aec;
                break;
        }
    }
}

TEST_F(SyncStorageImplTest, CanThrowStdExceptionIfDispatcherErrorCodeCannotBeMappedToSdlException)
{
    InSequence dummy;
    expectSdlReadinessCheck();
    expectSetIfNotExistsAsync("key1", { 0x0a, 0x0b, 0x0c });
    expectPollWait();
    expectModifyIfAck(std::error_code(1, std::system_category()), false);
    EXPECT_THROW(syncStorage->setIfNotExists(ns, "key1", { 0x0a, 0x0b, 0x0c }), std::range_error);
}