Add test cases for filesystem.cpp functions

Previously, unit tests covered only about 26% of the lines,
this patch aims to increase the file coverage to at least 80%.

Change-Id: I985a2b690fdf1bbb355edb94753bf8c54108b9cf

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 3ccaacf3b1ad1f9c1b0feeea09b41e7c162c74b7..77bbc919e1b98215af78e9c3d4e7b68dda973918 100644 (file)
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -52,6 +52,7 @@ SET(TARGET_SM_PERFORMANCE_TESTS "security-manager-performance-tests")
 SET(SM_TESTS_SOURCES
     ${SM_TEST_SRC}/colour_log_formatter.cpp
     ${SM_TEST_SRC}/security-manager-tests.cpp
+    ${SM_TEST_SRC}/test_filesystem.cpp
     ${SM_TEST_SRC}/test_file-lock.cpp
     ${SM_TEST_SRC}/privilege_db_fixture.cpp
     ${SM_TEST_SRC}/test_privilege_db_transactions.cpp
@@ -76,6 +77,7 @@ SET(SM_TESTS_SOURCES
     ${DPL_PATH}/log/src/log.cpp
     ${DPL_PATH}/log/src/old_style_log_provider.cpp
     ${PROJECT_SOURCE_DIR}/src/common/config-file.cpp
+    ${PROJECT_SOURCE_DIR}/src/common/filesystem.cpp
     ${PROJECT_SOURCE_DIR}/src/common/file-lock.cpp
     ${PROJECT_SOURCE_DIR}/src/common/privilege_db.cpp
     ${PROJECT_SOURCE_DIR}/src/common/service_impl_utils.cpp

diff --git a/test/test_filesystem.cpp b/test/test_filesystem.cpp
new file mode 100644 (file)
index 0000000..dff449e
--- /dev/null
+++ b/test/test_filesystem.cpp
@@ -0,0 +1,264 @@
+/*
+ *  Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ *  Contact: Tomasz Swierczek <t.swierczek@samsung.com>
+ *
+ *  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
+ *
+ *
+ * @file        test_filesystem.cpp
+ * @author      Tomasz Świerczek (t.swierczek@samsung.com)
+ * @version     1.0
+ * @brief       Tests of SecurityManager::FS namespace functions
+ */
+
+#include <algorithm>
+#include <cstdio>
+#include <string>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <security-manager-types.h>
+
+#include <dpl/errno_string.h>
+#include <dpl/log/log.h>
+#include <filesystem.h>
+#include <testmacros.h>
+
+using namespace SecurityManager;
+
+struct FilesystemFixture
+{
+    FilesystemFixture()
+    {
+        std::string command = "rm -rf " + dir;
+        int ret = system(command.c_str());
+        BOOST_REQUIRE(ret != -1 && WIFEXITED(ret) && WEXITSTATUS(ret) == 0);
+        ret = mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
+        int er = errno;
+        BOOST_REQUIRE_MESSAGE(ret == 0, "Failed to create directory " << dir << " : " << GetErrnoString(er));
+        ret = mkdir(subdir1.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
+        er = errno;
+        BOOST_REQUIRE_MESSAGE(ret == 0, "Failed to create directory " << subdir1 << " : " << GetErrnoString(er));
+        ret = mkdir(subdir2.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
+        er = errno;
+        BOOST_REQUIRE_MESSAGE(ret == 0, "Failed to create directory " << subdir2 << " : " << GetErrnoString(er));
+        FILE *f = fopen(textFile.c_str(), "w");
+        er = errno;
+        BOOST_REQUIRE_MESSAGE(f != NULL, "Failed to create file " << textFile << " : " << GetErrnoString(er));
+        BOOST_REQUIRE_MESSAGE(fwrite(textFileContent.c_str(), textFileContent.length() * sizeof(char), 1, f) == 1,
+                              "File not filled properly");
+        fclose(f);
+        ret = symlink(textFile.c_str(), linkToTextFile.c_str());
+        er = errno;
+        BOOST_REQUIRE_MESSAGE(ret == 0, "Failed to create symbolic link from " << linkToTextFile << " to " << textFile << " : "
+                     << GetErrnoString(er));
+        ret = mkdir(dirToRemove.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
+        er = errno;
+        BOOST_REQUIRE_MESSAGE(ret == 0, "Failed to create directory " << dirToRemove << " : " << GetErrnoString(er));
+        errno = 0;
+        BOOST_REQUIRE_MESSAGE(!remove(dirToCreate.c_str()) || errno == ENOENT, "Can't remove item");
+        BOOST_REQUIRE_MESSAGE(!remove(dirToCreateNoParent.c_str()) || errno == ENOENT, "Can't remove item");
+        BOOST_REQUIRE_MESSAGE(!remove(parentNonexisting.c_str()) || errno == ENOENT, "Can't remove item");
+        BOOST_REQUIRE_MESSAGE(!remove(linkToCreate.c_str()) || errno == ENOENT, "Can't remove item");
+        BOOST_REQUIRE_MESSAGE(!remove(nonexistentFile.c_str()) || errno == ENOENT, "Can't remove item");
+        BOOST_REQUIRE_MESSAGE(!remove(nonexistentDir.c_str()) || errno == ENOENT, "Can't remove item");
+        f = fopen(fileToRemove.c_str(), "w");
+        er = errno;
+        BOOST_REQUIRE_MESSAGE(f != NULL, "Failed to open file " << fileToRemove << " : " << GetErrnoString(er));
+        fclose(f);
+    }
+
+    ~FilesystemFixture()
+    {
+        std::string command = "rm -rf " + dir;
+        BOOST_REQUIRE(!system(command.c_str()));
+    }
+
+    const static inline std::string dir = "/tmp/SecurityManagerUTDirectory/";
+    const static inline std::string subdir1name = "subdir1";
+    const static inline std::string subdir2name = "subdir2";
+    const static inline std::string subdir1 = dir + subdir1name;
+    const static inline std::string subdir2 = dir + subdir2name;
+    const static inline std::string textFile = dir + "textFile";
+    const static inline std::string textFileContent = "loremipsum\n\n.\n!@\n.";
+    const static inline std::string linkToTextFileName = "linkToTextFile";
+    const static inline std::string linkToTextFile = dir + linkToTextFileName;
+    const static inline std::string fileToRemove = subdir2 + "/fileToRemove";
+    const static inline std::string dirToRemove = subdir2 + "/dirToRemove";
+    const static inline std::string linkToCreate = dir + "newLink";
+    const static inline std::string dirToCreate = dir + "dirToCreate";
+    const static inline std::string parentNonexisting = dir + "parent";
+    const static inline std::string dirToCreateNoParent = parentNonexisting + "/dirToCreate2";
+    const static inline std::string nonexistentDir = "/tmp/imnotheredir";
+    const static inline std::string nonexistentFile = "/tmp/imnotherefile";
+    const static inline std::string dirCannotRemove = "/proc/1";
+    const static inline std::string fileCannotRemove = "/proc/1/status";
+    const static inline std::string dirCannotCreate = "/proc/1/cannotCreate";
+};
+
+BOOST_AUTO_TEST_SUITE(FILESYSTEM_TEST)
+
+POSITIVE_FIXTURE_TEST_CASE(T233_filesystem_mkdir, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::createDirectory(FilesystemFixture::dirToCreate) == SECURITY_MANAGER_SUCCESS,
+                          "Directory was not created");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T234_filesystem_mkdir_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::createDirectory(FilesystemFixture::dirCannotCreate) == SECURITY_MANAGER_ERROR_FILE_CREATE_FAILED,
+                          "Directory was created");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T235_filesystem_mkdir_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::createDirectory("") == SECURITY_MANAGER_ERROR_FILE_CREATE_FAILED,
+                          "Directory was created");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T236_filesystem_mkdir, FilesystemFixture)
+{
+    // dir exists, function is intended to return success on existing paths
+    BOOST_REQUIRE_MESSAGE(FS::createDirectory(FilesystemFixture::subdir1) == SECURITY_MANAGER_SUCCESS,
+                          "Error in createDirectory");
+    BOOST_REQUIRE_MESSAGE(FS::createDirectory(FilesystemFixture::dirToCreateNoParent) == SECURITY_MANAGER_SUCCESS,
+                          "Error in createDIrectory");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T237_filesystem_getSubDirectoriesFromDirectory, FilesystemFixture)
+{
+    FS::FileNameVector expected = {FilesystemFixture::subdir1name, FilesystemFixture::subdir2name};
+    FS::FileNameVector expectedDot = {FilesystemFixture::subdir1name, FilesystemFixture::subdir2name, ".", ".."};
+    FS::FileNameVector ret = FS::getSubDirectoriesFromDirectory(FilesystemFixture::dir, true);
+    FS::FileNameVector retDot = FS::getSubDirectoriesFromDirectory(FilesystemFixture::dir, false);
+    BOOST_REQUIRE_MESSAGE(ret.size() == expected.size(), "Invalid number of subdirs returned");
+    BOOST_REQUIRE_MESSAGE(retDot.size() == expectedDot.size(), "Invalid number of subdirs returned");
+    BOOST_REQUIRE_MESSAGE(std::is_permutation(expected.begin(), expected.end(), ret.begin()) ,"Wrong subdir list");
+    BOOST_REQUIRE_MESSAGE(std::is_permutation(expectedDot.begin(), expectedDot.end(), retDot.begin()) ,"Wrong subdir list");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T238_filesystem_getSubDirectoriesFromDirectory_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_THROW(FS::getSubDirectoriesFromDirectory(FilesystemFixture::nonexistentDir), FS::Exception::FileError);
+}
+
+POSITIVE_TEST_CASE(T239_filesystem_getDirectoryName)
+{
+    BOOST_REQUIRE_MESSAGE(FS::getDirectoryName("/just/a/path/to/file") == "/just/a/path/to", "Invalid output from getDirectoryName");
+    BOOST_REQUIRE_MESSAGE(FS::getDirectoryName("justapath") == ".", "Invalid output from getDirectoryName");
+    BOOST_REQUIRE_MESSAGE(FS::getDirectoryName("/justapath") == "/", "Invalid output from getDirectoryName");
+    BOOST_REQUIRE_MESSAGE(FS::getDirectoryName(".") == ".", "Invalid output from getDirectoryName");
+    BOOST_REQUIRE_MESSAGE(FS::getDirectoryName("/") == "/", "Invalid output from getDirectoryName");
+    BOOST_REQUIRE_MESSAGE(FS::getDirectoryName("") == ".", "Invalid output from getDirectoryName");
+}
+
+
+POSITIVE_TEST_CASE(T240_filesystem_getParentDirectoryName)
+{
+    BOOST_REQUIRE_MESSAGE(FS::getParentDirectoryName("/just/a/path/to/file") == "/just/a/path/to", "Invalid output from getDirectoryName");
+    BOOST_REQUIRE_MESSAGE(FS::getParentDirectoryName("justapath") == "", "Invalid output from getDirectoryName");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T241_filesystem_removeDirectory, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::removeDirectory(FilesystemFixture::dirToRemove) == SECURITY_MANAGER_SUCCESS,
+                          "Wrong return value from removeDirectory");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T242_filesystem_removeDirectory_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::removeDirectory(FilesystemFixture::dirCannotRemove) == SECURITY_MANAGER_ERROR_FILE_DELETE_FAILED,
+                          "Wrong return value from removeDirectory");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T243_filesystem_removeDirectory_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::removeDirectory(FilesystemFixture::nonexistentDir) == SECURITY_MANAGER_ERROR_FILE_DELETE_FAILED,
+                          "Wrong return value from removeDirectory");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T244_filesystem_removeFile, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::removeFile(FilesystemFixture::fileToRemove) == SECURITY_MANAGER_SUCCESS,
+                          "Wrong return value from removeFile");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T245_filesystem_removeFile_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::removeFile(FilesystemFixture::fileCannotRemove) == SECURITY_MANAGER_ERROR_FILE_DELETE_FAILED,
+                          "Wrong return value from removeFile");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T246_filesystem_removeFile, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::removeFile(FilesystemFixture::nonexistentFile) == SECURITY_MANAGER_ERROR_FILE_DELETE_FAILED,
+                          "Wrong return value from removeFile");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T247_filesystem_symlink, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::symLink(FilesystemFixture::textFile, FilesystemFixture::linkToCreate) == SECURITY_MANAGER_SUCCESS,
+                          "Wrong return value from symLink");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T248_filesystem_symlink_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::symLink(FilesystemFixture::textFile, FilesystemFixture::fileToRemove) == SECURITY_MANAGER_ERROR_FILE_CREATE_FAILED,
+                          "Wrong return value from symLink");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T249_filesystem_getLinksFromDirectory, FilesystemFixture)
+{
+    FS::FileNameVector ret = FS::getLinksFromDirectory(FilesystemFixture::dir);
+    BOOST_REQUIRE_MESSAGE(ret.size() == 1, "Invalid number of links returned (" + std::to_string(ret.size()) + ")");
+    BOOST_REQUIRE_MESSAGE(ret[0] == FilesystemFixture::linkToTextFileName, "Wrong links list (returned " + ret[0]+ ")");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T250_filesystem_getLinksFromDirectory, FilesystemFixture)
+{
+    BOOST_REQUIRE_THROW(FS::getLinksFromDirectory(FilesystemFixture::nonexistentDir), FS::Exception::FileError);
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T251_filesystem_fileStatus_normal_file, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::fileStatus(FilesystemFixture::textFile) == 1, "Wrong file status");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T251_filesystem_fileStatus_nonexistent_file, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::fileStatus(FilesystemFixture::nonexistentFile) == 0, "Wrong file status");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T252_filesytem_fileStatus_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::fileStatus(FilesystemFixture::dir) == -1, "Wrong file status");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T256_filesystem_directoryStatus_normal_dir, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::directoryStatus(FilesystemFixture::dir) == 1, "Wrong directory status");
+}
+
+POSITIVE_FIXTURE_TEST_CASE(T256_filesystem_directoryStatus_nonexistent_dir, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::directoryStatus(FilesystemFixture::nonexistentDir) == 0, "Wrong directory status");
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T257_filesytem_directoryStatus_n, FilesystemFixture)
+{
+    BOOST_REQUIRE_MESSAGE(FS::directoryStatus(FilesystemFixture::textFile) == -1, "Wrong directory status");
+}
+
+BOOST_AUTO_TEST_SUITE_END()