services/incremental/test/IncrementalServiceTest.cpp

/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * 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 <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/unique_fd.h>
#include <binder/ParcelFileDescriptor.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <utils/Log.h>

#include <future>

#include "IncrementalService.h"
#include "Metadata.pb.h"
#include "ServiceWrappers.h"

using namespace testing;
using namespace android::incremental;
using namespace std::literals;
using testing::_;
using testing::Invoke;
using testing::NiceMock;

#undef LOG_TAG
#define LOG_TAG "IncrementalServiceTest"

using namespace android::incfs;
using namespace android::content::pm;

namespace android::os::incremental {

class MockVoldService : public VoldServiceWrapper {
public:
    MOCK_CONST_METHOD4(mountIncFs,
                       binder::Status(const std::string& backingPath, const std::string& targetDir,
                                      int32_t flags,
                                      IncrementalFileSystemControlParcel* _aidl_return));
    MOCK_CONST_METHOD1(unmountIncFs, binder::Status(const std::string& dir));
    MOCK_CONST_METHOD2(bindMount,
                       binder::Status(const std::string& sourceDir, const std::string& argetDir));

    void mountIncFsFails() {
        ON_CALL(*this, mountIncFs(_, _, _, _))
                .WillByDefault(
                        Return(binder::Status::fromExceptionCode(1, String8("failed to mount"))));
    }
    void mountIncFsInvalidControlParcel() {
        ON_CALL(*this, mountIncFs(_, _, _, _))
                .WillByDefault(Invoke(this, &MockVoldService::getInvalidControlParcel));
    }
    void mountIncFsSuccess() {
        ON_CALL(*this, mountIncFs(_, _, _, _))
                .WillByDefault(Invoke(this, &MockVoldService::incFsSuccess));
    }
    void bindMountFails() {
        ON_CALL(*this, bindMount(_, _))
                .WillByDefault(Return(
                        binder::Status::fromExceptionCode(1, String8("failed to bind-mount"))));
    }
    void bindMountSuccess() {
        ON_CALL(*this, bindMount(_, _)).WillByDefault(Return(binder::Status::ok()));
    }
    binder::Status getInvalidControlParcel(const std::string& imagePath,
                                           const std::string& targetDir, int32_t flags,
                                           IncrementalFileSystemControlParcel* _aidl_return) {
        _aidl_return = {};
        return binder::Status::ok();
    }
    binder::Status incFsSuccess(const std::string& imagePath, const std::string& targetDir,
                                int32_t flags, IncrementalFileSystemControlParcel* _aidl_return) {
        _aidl_return->pendingReads.reset(base::unique_fd(dup(STDIN_FILENO)));
        _aidl_return->cmd.reset(base::unique_fd(dup(STDIN_FILENO)));
        _aidl_return->log.reset(base::unique_fd(dup(STDIN_FILENO)));
        return binder::Status::ok();
    }

private:
    TemporaryFile cmdFile;
    TemporaryFile logFile;
};

class MockIncrementalManager : public IncrementalManagerWrapper {
public:
    MOCK_CONST_METHOD5(prepareDataLoader,
                       binder::Status(int32_t mountId, const FileSystemControlParcel& control,
                                      const DataLoaderParamsParcel& params,
                                      const sp<IDataLoaderStatusListener>& listener,
                                      bool* _aidl_return));
    MOCK_CONST_METHOD2(startDataLoader, binder::Status(int32_t mountId, bool* _aidl_return));
    MOCK_CONST_METHOD1(destroyDataLoader, binder::Status(int32_t mountId));
    MOCK_CONST_METHOD3(newFileForDataLoader,
                       binder::Status(int32_t mountId, FileId fileId,
                                      const ::std::vector<uint8_t>& metadata));
    MOCK_CONST_METHOD1(showHealthBlockedUI, binder::Status(int32_t mountId));

    binder::Status prepareDataLoaderOk(int32_t mountId, const FileSystemControlParcel& control,
                                       const DataLoaderParamsParcel& params,
                                       const sp<IDataLoaderStatusListener>& listener,
                                       bool* _aidl_return) {
        mId = mountId;
        mListener = listener;
        *_aidl_return = true;
        return binder::Status::ok();
    }

    binder::Status startDataLoaderOk(int32_t mountId, bool* _aidl_return) {
        *_aidl_return = true;
        return binder::Status::ok();
    }

    void prepareDataLoaderFails() {
        ON_CALL(*this, prepareDataLoader(_, _, _, _, _))
                .WillByDefault(Return(
                        (binder::Status::fromExceptionCode(1, String8("failed to prepare")))));
    }
    void prepareDataLoaderSuccess() {
        ON_CALL(*this, prepareDataLoader(_, _, _, _, _))
                .WillByDefault(Invoke(this, &MockIncrementalManager::prepareDataLoaderOk));
    }
    void startDataLoaderSuccess() {
        ON_CALL(*this, startDataLoader(_, _))
                .WillByDefault(Invoke(this, &MockIncrementalManager::startDataLoaderOk));
    }
    void setDataLoaderStatusNotReady() {
        mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_DESTROYED);
    }
    void setDataLoaderStatusReady() {
        mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_CREATED);
    }

private:
    int mId;
    sp<IDataLoaderStatusListener> mListener;
};

class MockIncFs : public IncFsWrapper {
public:
    MOCK_CONST_METHOD5(makeFile,
                       ErrorCode(Control control, std::string_view path, int mode, FileId id,
                                 NewFileParams params));
    MOCK_CONST_METHOD3(makeDir, ErrorCode(Control control, std::string_view path, int mode));
    MOCK_CONST_METHOD2(getMetadata, RawMetadata(Control control, FileId fileid));
    MOCK_CONST_METHOD2(getMetadata, RawMetadata(Control control, std::string_view path));
    MOCK_CONST_METHOD2(getFileId, FileId(Control control, std::string_view path));
    MOCK_CONST_METHOD3(link,
                       ErrorCode(Control control, std::string_view from, std::string_view to));
    MOCK_CONST_METHOD2(unlink, ErrorCode(Control control, std::string_view path));
    MOCK_CONST_METHOD2(openWrite, base::unique_fd(Control control, FileId id));
    MOCK_CONST_METHOD1(writeBlocks, ErrorCode(std::span<const DataBlock> blocks));

    void makeFileFails() { ON_CALL(*this, makeFile(_, _, _, _, _)).WillByDefault(Return(-1)); }
    void makeFileSuccess() { ON_CALL(*this, makeFile(_, _, _, _, _)).WillByDefault(Return(0)); }
    RawMetadata getMountInfoMetadata(Control control, std::string_view path) {
        metadata::Mount m;
        m.mutable_storage()->set_id(100);
        m.mutable_loader()->set_package_name("com.test");
        m.mutable_loader()->set_arguments("com.uri");
        const auto metadata = m.SerializeAsString();
        m.mutable_loader()->release_arguments();
        m.mutable_loader()->release_package_name();
        return {metadata.begin(), metadata.end()};
    }
    RawMetadata getStorageMetadata(Control control, std::string_view path) {
        metadata::Storage st;
        st.set_id(100);
        auto metadata = st.SerializeAsString();
        return {metadata.begin(), metadata.end()};
    }
    RawMetadata getBindPointMetadata(Control control, std::string_view path) {
        metadata::BindPoint bp;
        std::string destPath = "dest";
        std::string srcPath = "src";
        bp.set_storage_id(100);
        bp.set_allocated_dest_path(&destPath);
        bp.set_allocated_source_subdir(&srcPath);
        const auto metadata = bp.SerializeAsString();
        bp.release_source_subdir();
        bp.release_dest_path();
        return std::vector<char>(metadata.begin(), metadata.end());
    }
};

class MockServiceManager : public ServiceManagerWrapper {
public:
    MockServiceManager(std::unique_ptr<MockVoldService> vold,
                       std::unique_ptr<MockIncrementalManager> manager,
                       std::unique_ptr<MockIncFs> incfs)
          : mVold(std::move(vold)),
            mIncrementalManager(std::move(manager)),
            mIncFs(std::move(incfs)) {}
    std::unique_ptr<VoldServiceWrapper> getVoldService() final { return std::move(mVold); }
    std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() final {
        return std::move(mIncrementalManager);
    }
    std::unique_ptr<IncFsWrapper> getIncFs() final { return std::move(mIncFs); }

private:
    std::unique_ptr<MockVoldService> mVold;
    std::unique_ptr<MockIncrementalManager> mIncrementalManager;
    std::unique_ptr<MockIncFs> mIncFs;
};

// --- IncrementalServiceTest ---

class IncrementalServiceTest : public testing::Test {
public:
    void SetUp() override {
        auto vold = std::make_unique<NiceMock<MockVoldService>>();
        mVold = vold.get();
        auto incrementalManager = std::make_unique<NiceMock<MockIncrementalManager>>();
        mIncrementalManager = incrementalManager.get();
        auto incFs = std::make_unique<NiceMock<MockIncFs>>();
        mIncFs = incFs.get();
        mIncrementalService =
                std::make_unique<IncrementalService>(MockServiceManager(std::move(vold),
                                                                        std::move(
                                                                                incrementalManager),
                                                                        std::move(incFs)),
                                                     mRootDir.path);
        mDataLoaderParcel.packageName = "com.test";
        mDataLoaderParcel.arguments = "uri";
        mIncrementalService->onSystemReady();
    }

    void setUpExistingMountDir(const std::string& rootDir) {
        const auto dir = rootDir + "/dir1";
        const auto mountDir = dir + "/mount";
        const auto backingDir = dir + "/backing_store";
        const auto storageDir = mountDir + "/st0";
        ASSERT_EQ(0, mkdir(dir.c_str(), 0755));
        ASSERT_EQ(0, mkdir(mountDir.c_str(), 0755));
        ASSERT_EQ(0, mkdir(backingDir.c_str(), 0755));
        ASSERT_EQ(0, mkdir(storageDir.c_str(), 0755));
        const auto mountInfoFile = rootDir + "/dir1/mount/.info";
        const auto mountPointsFile = rootDir + "/dir1/mount/.mountpoint.abcd";
        ASSERT_TRUE(base::WriteStringToFile("info", mountInfoFile));
        ASSERT_TRUE(base::WriteStringToFile("mounts", mountPointsFile));
        ON_CALL(*mIncFs, getMetadata(_, std::string_view(mountInfoFile)))
                .WillByDefault(Invoke(mIncFs, &MockIncFs::getMountInfoMetadata));
        ON_CALL(*mIncFs, getMetadata(_, std::string_view(mountPointsFile)))
                .WillByDefault(Invoke(mIncFs, &MockIncFs::getBindPointMetadata));
        ON_CALL(*mIncFs, getMetadata(_, std::string_view(rootDir + "/dir1/mount/st0")))
                .WillByDefault(Invoke(mIncFs, &MockIncFs::getStorageMetadata));
    }

protected:
    NiceMock<MockVoldService>* mVold;
    NiceMock<MockIncFs>* mIncFs;
    NiceMock<MockIncrementalManager>* mIncrementalManager;
    std::unique_ptr<IncrementalService> mIncrementalService;
    TemporaryDir mRootDir;
    DataLoaderParamsParcel mDataLoaderParcel;
};

/*
TEST_F(IncrementalServiceTest, testBootMountExistingImagesSuccess) {
    TemporaryDir tempDir;
    setUpExistingMountDir(tempDir.path);
    mVold->mountIncFsSuccess();
    mVold->bindMountSuccess();
    mIncrementalManager->prepareDataLoaderSuccess();
    ON_CALL(*mIncrementalManager, destroyDataLoader(_)).WillByDefault(Return(binder::Status::ok()));

    EXPECT_CALL(*mVold, mountIncFs(_, _, _, _)).Times(1);
    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(1);

    MockServiceManager serviceManager = MockServiceManager(mVold, mIncrementalManager, mIncFs);
    std::unique_ptr<IncrementalService> incrementalService =
            std::make_unique<IncrementalService>(serviceManager, tempDir.path);
    auto finished = incrementalService->onSystemReady();
    if (finished) {
        finished->wait();
    }
}
*/

TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {
    mVold->mountIncFsFails();
    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    ASSERT_LT(storageId, 0);
}

TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) {
    mVold->mountIncFsInvalidControlParcel();
    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    ASSERT_LT(storageId, 0);
}

TEST_F(IncrementalServiceTest, testCreateStorageMakeFileFails) {
    mVold->mountIncFsSuccess();
    mIncFs->makeFileFails();
    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
    EXPECT_CALL(*mVold, unmountIncFs(_));
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    ASSERT_LT(storageId, 0);
}

TEST_F(IncrementalServiceTest, testCreateStorageBindMountFails) {
    mVold->mountIncFsSuccess();
    mIncFs->makeFileSuccess();
    mVold->bindMountFails();
    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
    EXPECT_CALL(*mVold, unmountIncFs(_));
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    ASSERT_LT(storageId, 0);
}

TEST_F(IncrementalServiceTest, testCreateStoragePrepareDataLoaderFails) {
    mVold->mountIncFsSuccess();
    mIncFs->makeFileSuccess();
    mVold->bindMountSuccess();
    mIncrementalManager->prepareDataLoaderFails();
    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    ASSERT_LT(storageId, 0);
}

TEST_F(IncrementalServiceTest, testDeleteStorageSuccess) {
    mVold->mountIncFsSuccess();
    mIncFs->makeFileSuccess();
    mVold->bindMountSuccess();
    mIncrementalManager->prepareDataLoaderSuccess();
    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    ASSERT_GE(storageId, 0);
    mIncrementalService->deleteStorage(storageId);
}

TEST_F(IncrementalServiceTest, testOnStatusNotReady) {
    mVold->mountIncFsSuccess();
    mIncFs->makeFileSuccess();
    mVold->bindMountSuccess();
    mIncrementalManager->prepareDataLoaderSuccess();
    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    ASSERT_GE(storageId, 0);
    mIncrementalManager->setDataLoaderStatusNotReady();
}

TEST_F(IncrementalServiceTest, testStartDataLoaderSuccess) {
    mVold->mountIncFsSuccess();
    mIncFs->makeFileSuccess();
    mVold->bindMountSuccess();
    mIncrementalManager->prepareDataLoaderSuccess();
    mIncrementalManager->startDataLoaderSuccess();
    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    ASSERT_GE(storageId, 0);
    mIncrementalManager->setDataLoaderStatusReady();
    ASSERT_TRUE(mIncrementalService->startLoading(storageId));
}

TEST_F(IncrementalServiceTest, testMakeDirectory) {
    mVold->mountIncFsSuccess();
    mIncFs->makeFileSuccess();
    mVold->bindMountSuccess();
    mIncrementalManager->prepareDataLoaderSuccess();
    mIncrementalManager->startDataLoaderSuccess();
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    std::string dir_path("test");

    std::string tempPath(tempDir.path);
    std::replace(tempPath.begin(), tempPath.end(), '/', '_');
    std::string mount_dir = std::string(mRootDir.path) + "/" + tempPath.substr(1);
    std::string normalized_dir_path = mount_dir + "/mount/st_1_0/" + dir_path;

    // Expecting incfs to call makeDir on a path like:
    // /data/local/tmp/TemporaryDir-06yixG/data_local_tmp_TemporaryDir-xwdFhT/mount/st_1_0/test
    EXPECT_CALL(*mIncFs, makeDir(_, std::string_view(normalized_dir_path), _));
    auto res = mIncrementalService->makeDir(storageId, dir_path, 0555);
    ASSERT_EQ(res, 0);
}

TEST_F(IncrementalServiceTest, testMakeDirectories) {
    mVold->mountIncFsSuccess();
    mIncFs->makeFileSuccess();
    mVold->bindMountSuccess();
    mIncrementalManager->prepareDataLoaderSuccess();
    mIncrementalManager->startDataLoaderSuccess();
    TemporaryDir tempDir;
    int storageId =
            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel),
                                               IncrementalService::CreateOptions::CreateNew);
    auto first = "first"sv;
    auto second = "second"sv;
    auto third = "third"sv;

    std::string tempPath(tempDir.path);
    std::replace(tempPath.begin(), tempPath.end(), '/', '_');
    std::string mount_dir = std::string(mRootDir.path) + "/" + tempPath.substr(1);

    InSequence seq;
    auto parent_path = std::string(first) + "/" + std::string(second);
    auto dir_path = parent_path + "/" + std::string(third);

    std::string normalized_first_path = mount_dir + "/mount/st_1_0/" + std::string(first);
    std::string normalized_parent_path = mount_dir + "/mount/st_1_0/" + parent_path;
    std::string normalized_dir_path = mount_dir + "/mount/st_1_0/" + dir_path;

    EXPECT_CALL(*mIncFs, makeDir(_, std::string_view(normalized_dir_path), _))
            .WillOnce(Return(-ENOENT));
    EXPECT_CALL(*mIncFs, makeDir(_, std::string_view(normalized_parent_path), _))
            .WillOnce(Return(-ENOENT));
    EXPECT_CALL(*mIncFs, makeDir(_, std::string_view(normalized_first_path), _))
            .WillOnce(Return(0));
    EXPECT_CALL(*mIncFs, makeDir(_, std::string_view(normalized_parent_path), _))
            .WillOnce(Return(0));
    EXPECT_CALL(*mIncFs, makeDir(_, std::string_view(normalized_dir_path), _)).WillOnce(Return(0));
    auto res = mIncrementalService->makeDirs(storageId, normalized_dir_path, 0555);
    ASSERT_EQ(res, 0);
}
} // namespace android::os::incremental