Skip to content

I
iSulad

openeuler / iSulad

通知 15
Star 0
Fork 0
I
iSulad

体验新版 GitCode，发现更多精彩内容 >>

提交 543d1f57 编写于 作者: J jikui 提交者： lifeng68
浏览文件
操作

iSulad: change llt to ut 

Signed-off-by: Njikui <jikui2@huawei.com>
上级 cee8b715
展开全部 隐藏空白更改
内联 并排
Showing with 0 addition and 1164 deletion
test/image/oci/storage/layers/storage_layers_llt.cc 已删除 100644 → 0
浏览文件 @ cee8b715
/******************************************************************************
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
* iSulad licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
* PURPOSE.
* See the Mulan PSL v2 for more details.
* Author: wujing
* Create: 2020-03-30
* Description: provide oci storage images unit test
******************************************************************************/
#include "layer_store.h"
#include <cstddef>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <tuple>
#include <fstream>
#include <climits>
#include <dirent.h>
#include <unistd.h>
#include <sys/stat.h>
#include <gtest/gtest.h>
#include "path.h"
#include "storage.h"
#include "layer.h"
std::string GetDirectory()
{
char abs_path[PATH_MAX];
int ret = readlink("/proc/self/exe", abs_path, sizeof(abs_path));
if (ret < 0 || (size_t)ret >= sizeof(abs_path)) {
return "";
}
for (int i { ret }; i >= 0; --i) {
if (abs_path[i] == '/') {
abs_path[i + 1] = '\0';
break;
}
}
return static_cast<std::string>(abs_path);
}
bool dirExists(const char *path)
{
DIR *dp = NULL;
if ((dp = opendir(path)) == NULL) {
return false;
}
closedir(dp);
return true;
}
/********************************test data 1: container layer json**************************************
{
"id": "ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1",
"names": [
"689feccc14f14112b43b1fbf7dc14c3426e4fdd6e2bff462ec70b9f6ee4b3fae-layer"
],
"parent": "6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a",
"created": "2020-04-29T07:34:27.076073345Z"
}
mount info
{
"id": "ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1",
"path": "/var/lib/isulad/storage/overlay/ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1/merged",
"count": 1
}
******************************************************************************************/
/********************************test data 2: busybox image layer json**************************************
{
"id": "6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a",
"created": "2020-04-16T12:08:52.304153815Z",
"compressed-diff-digest": "sha256:8f52abd3da461b2c0c11fda7a1b53413f1a92320eb96525ddf92c0b5cde781ad",
"compressed-size": 740169,
"diff-digest": "sha256:6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a",
"diff-size": 1441280,
"compression": 2
}
******************************************************************************************/
class StorageImagesUnitTest : public testing::Test {
protected:
void SetUp() override
{
struct storage_module_init_options opts = {0};
std::string dir = GetDirectory() + "/data";
std::string rundir = GetDirectory() + "/data/run";
ASSERT_STRNE(cleanpath(dir.c_str(), real_path, sizeof(real_path)), nullptr);
opts.storage_root = strdup(real_path);
ASSERT_STRNE(cleanpath(rundir.c_str(), real_run_path, sizeof(real_run_path)), nullptr);
opts.storage_run_root = strdup(real_run_path);
opts.driver_name = strdup("overlay");
ASSERT_EQ(layer_store_init(&opts), 0);
free(opts.storage_root);
free(opts.driver_name);
}
void TearDown() override
{
}
std::vector<std::string> ids { "6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a",
"ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1" };
char real_path[PATH_MAX] = { 0x00 };
char real_run_path[PATH_MAX] = { 0x00 };
};
TEST_F(StorageImagesUnitTest, test_layers_load)
{
size_t layers_len = 0;
struct layer **layers = layer_store_list(&layers_len);
ASSERT_EQ(layers_len, 2);
// check layer 6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a
ASSERT_NE(layers[0], nullptr);
ASSERT_STREQ(layers[0]->id, "6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a");
ASSERT_EQ(layers[0]->parent, nullptr);
ASSERT_STREQ(layers[0]->compressed_digest, "sha256:8f52abd3da461b2c0c11fda7a1b53413f1a92320eb96525ddf92c0b5cde781ad");
ASSERT_EQ(layers[0]->compress_size, 740169);
ASSERT_STREQ(layers[0]->uncompressed_digest, "sha256:6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a");
ASSERT_EQ(layers[0]->uncompress_size, 1441280);
// check layer ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1
ASSERT_NE(layers[1], nullptr);
ASSERT_STREQ(layers[1]->id, "ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1");
ASSERT_STREQ(layers[1]->parent, "6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a");
ASSERT_EQ(layers[1]->mount_count, 1);
ASSERT_STREQ(layers[1]->mount_point,
"/var/lib/isulad/storage/overlay/ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1/merged");
}
/********************************test data *************************************************
{
"id": "50551ff67da98ab8540d71320915f33d2eb80ab42908e398472cab3c1ce7ac10",
"digest": "manifest",
"names": [
"euleros:3.1",
"hello_world:latest"
],
"layer": "9994458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a",
"metadata": "{}",
"created": "2020-04-02T05:44:23.408951489-04:00",
"loaded": "2020-04-02T05:44:23.408987703-04:00"
}
******************************************************************************************/
TEST_F(StorageImagesUnitTest, test_layer_store_create)
{
std::string id { "d3b9337701b412d8235da15ae7653560ccc6cf042c18298214aa5543c38588f8" };
std::string parent { "6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a" };
struct layer_opts opts = {
.parent = strdup(parent.c_str()),
.writable = true,
};
char *new_id = nullptr;
auto created_layer = layer_store_create(id.c_str(), &opts, nullptr, &new_id);
ASSERT_EQ(created_layer, 0);
ASSERT_TRUE(layer_store_exists(id.c_str()));
ASSERT_EQ(layer_store_delete(id.c_str()), 0);
ASSERT_FALSE(layer_store_exists(id.c_str()));
ASSERT_FALSE(dirExists((std::string(real_path) + "/" + id).c_str()));
}
TEST_F(StorageImagesUnitTest, test_layer_store_lookup)
{
std::string id { "ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1" };
std::string name { "689feccc14f14112b43b1fbf7dc14c3426e4fdd6e2bff462ec70b9f6ee4b3fae-layer" };
std::string incorrectId { "4db68de4ff27" };
struct layer *l = NULL;
l = layer_store_lookup(name.c_str());
ASSERT_NE(l, nullptr);
ASSERT_STREQ(l->id, id.c_str());
free_layer(l);
l = layer_store_lookup(id.c_str());
ASSERT_NE(l, nullptr);
ASSERT_STREQ(l->id, id.c_str());
free_layer(l);
l = layer_store_lookup(incorrectId.c_str());
ASSERT_EQ(l->id, nullptr);
free_layer(l);
}
TEST_F(StorageImagesUnitTest, test_layer_store_exists)
{
std::string id { "ac86325a0e6384e251f2f4418d7b36321ad6811f9ba8a3dc87e13d634b0ec1d1" };
std::string name { "689feccc14f14112b43b1fbf7dc14c3426e4fdd6e2bff462ec70b9f6ee4b3fae-layer" };
std::string incorrectId { "4db68de4ff27" };
ASSERT_TRUE(layer_store_exists(name.c_str()));
ASSERT_TRUE(layer_store_exists(id.c_str()));
ASSERT_FALSE(layer_store_exists(incorrectId.c_str()));
}
TEST_F(StorageImagesUnitTest, test_layer_store_list)
{
struct layer **layers = NULL;
size_t len = 0;
layers = layer_store_list(&len);
ASSERT_EQ(len, 2);
for (size_t i {}; i < len; i++) {
ASSERT_NE(find(ids.begin(), ids.end(), std::string(layers[i]->id)), ids.end());
}
for (size_t i {}; i < len; i++) {
free_layer(layers[i]);
layers[i] = NULL;
}
free(layers);
}
TEST_F(StorageImagesUnitTest, test_layer_store_by_compress_digest)
{
struct layer **layers = NULL;
size_t len = 0;
std::string compress { "sha256:8f52abd3da461b2c0c11fda7a1b53413f1a92320eb96525ddf92c0b5cde781ad" };
std::string id { "6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a" };
layers = layer_store_by_compress_digest(compress.c_str(), &len);
ASSERT_EQ(len, 1);
ASSERT_STREQ(layers[0]->id, id.c_str());
ASSERT_STREQ(layers[0]->compressed_digest, compress.c_str());
ASSERT_EQ(layers[0]->compress_size, 740169);
for (size_t i {}; i < len; i++) {
free_layer(layers[i]);
layers[i] = NULL;
}
free(layers);
}
TEST_F(StorageImagesUnitTest, test_layer_store_by_uncompress_digest)
{
struct layer **layers = NULL;
size_t len = 0;
std::string uncompress { "sha256:6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a" };
std::string id { "6194458b07fcf01f1483d96cd6c34302ffff7f382bb151a6d023c4e80ba3050a" };
layers = layer_store_by_uncompress_digest(uncompress.c_str(), &len);
ASSERT_EQ(len, 1);
ASSERT_STREQ(layers[0]->id, id.c_str());
ASSERT_STREQ(layers[0]->uncompressed_digest, uncompress.c_str());
ASSERT_EQ(layers[0]->uncompress_size, 1441280);
for (size_t i {}; i < len; i++) {
free_layer(layers[i]);
layers[i] = NULL;
}
free(layers);
}
test/image/oci/storage/rootfs/storage_rootfs_llt.cc 已删除 100644 → 0
浏览文件 @ cee8b715
/******************************************************************************
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
* iSulad licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
* PURPOSE.
* See the Mulan PSL v2 for more details.
* Author: jikui
* Create: 2020-05-18
* Description: provide oci storage rootfs unit test
******************************************************************************/
#include "rootfs_store.h"
#include "utils_array.h"
#include <cstring>
#include <iostream>
#include <algorithm>
#include <tuple>
#include <fstream>
#include <string>
#include <fstream>
#include <streambuf>
#include <climits>
#include <dirent.h>
#include <unistd.h>
#include <sys/stat.h>
#include <gtest/gtest.h>
#include "utils.h"
#include "path.h"
#include "storage.h"
std::string BIG_DATA_CONTENT = "big data test";
std::string META_DATA_CONTENT = "metadata test";
std::string GetDirectory()
{
char abs_path[PATH_MAX];
int ret = readlink("/proc/self/exe", abs_path, sizeof(abs_path));
if (ret < 0 || (size_t)ret >= sizeof(abs_path)) {
return "";
}
for (int i { ret }; i >= 0; --i) {
if (abs_path[i] == '/') {
abs_path[i + 1] = '\0';
break;
}
}
return static_cast<std::string>(abs_path);
}
bool dirExists(const char *path)
{
DIR *dp = NULL;
if ((dp = opendir(path)) == NULL) {
return false;
}
closedir(dp);
return true;
}
static void free_rootfs_list(struct rootfs_list *list)
{
size_t i;
if (list == NULL) {
return;
}
for (i = 0; i < list->rootfs_len; i++) {
free_storage_rootfs(list->rootfs[i]);
list->rootfs[i] = NULL;
}
free(list->rootfs);
list->rootfs = NULL;
list->rootfs_len = 0;
free(list);
}
class StorageRootfsUnitTest : public testing::Test {
protected:
void SetUp() override
{
struct storage_module_init_options opts;
std::string dir = GetDirectory() + "/data";
ASSERT_STRNE(cleanpath(dir.c_str(), store_real_path, sizeof(store_real_path)), nullptr);
opts.storage_root = strdup(store_real_path);
opts.driver_name = strdup("overlay");
ASSERT_EQ(rootfs_store_init(&opts), 0);
free(opts.storage_root);
free(opts.driver_name);
}
void TearDown() override
{
rootfs_store_free();
}
std::vector<std::string> ids { "0e025f44cdca20966a5e5f11e1d9d8eb726aef2d38ed20f89ea986987c2010a9",
"28a8e1311d71345b08788c16b8c4f45a57641854f0e7c16802eedd0eb334b832" };
char store_real_path[PATH_MAX] = { 0x00 };
};
TEST_F(StorageRootfsUnitTest, test_rootfs_load)
{
auto cntr = rootfs_store_get_rootfs(ids.at(0).c_str());
ASSERT_NE(cntr, nullptr);
ASSERT_STREQ(cntr->created, "2020-05-27T08:55:26.273287183Z");
ASSERT_STREQ(cntr->image, "e4db68de4ff27c2adfea0c54bbb73a61a42f5b667c326de4d7d5b19ab71c6a3b");
ASSERT_STREQ(cntr->layer, "253836aa199405a39b6262b1e55a0d946b80988bc2f82d8f2b802fc175e4874e");
ASSERT_STRNE(cntr->metadata, nullptr);
ASSERT_EQ(cntr->names_len, 1);
ASSERT_STREQ(cntr->names[0], "0e025f44cdca20966a5e5f11e1d9d8eb726aef2d38ed20f89ea986987c2010a9");
ASSERT_EQ(rootfs_store_set_big_data(ids.at(0).c_str(), "userdata", BIG_DATA_CONTENT.c_str()), 0);
ASSERT_STREQ(rootfs_store_big_data(ids.at(0).c_str(), "userdata"), BIG_DATA_CONTENT.c_str());
ASSERT_EQ(rootfs_store_set_metadata(ids.at(0).c_str(), META_DATA_CONTENT.c_str()), 0);
free_storage_rootfs(cntr);
}
TEST_F(StorageRootfsUnitTest, test_rootfs_store_create)
{
std::string id { "5aca18b065db4741a9e24ff898cec48307ee12cb9ecec5dcb83e8210230f766f" };
const char *names_with_id[] = { "5aca18b065db4741a9e24ff898cec48307ee12cb9ecec5dcb83e8210230f766f" };
const char *names_without_id[] = { "jkha18b065db4741a9e24ff898cec48307ee12cb9ecec5dcbhje8210230f766f" };
std::string image { "e4db68de4ff27c2adfea0c54bbb73a61a42f5b667c326de4d7d5b19ab71c6a3b" };
std::string layer_with_id { "f32ca140c6716a68d7bba0fe6529334e98de529bd8fb7a203a21f08e772629a9" };
std::string layer_without_id { "h88ca140c6716a68d7bba0fe6529334e98de529bd8fb7agf3a21f08e772629a9" };
std::string metadata { "{}" };
char *created_container = rootfs_store_create(id.c_str(), names_with_id,
sizeof(names_with_id) / sizeof(names_with_id[0]), image.c_str(), layer_with_id.c_str(),
metadata.c_str(), nullptr);
char *container_without_id = rootfs_store_create(nullptr, names_without_id,
sizeof(names_without_id) / sizeof(names_without_id[0]), image.c_str(),
layer_without_id.c_str(), metadata.c_str(), nullptr);
ASSERT_STREQ(created_container, id.c_str());
ASSERT_NE(container_without_id, nullptr);
ASSERT_EQ(rootfs_store_delete(id.c_str()), 0);
ASSERT_EQ(rootfs_store_get_rootfs(id.c_str()), nullptr);
ASSERT_EQ(rootfs_store_delete(container_without_id), 0);
ASSERT_FALSE(dirExists((std::string(store_real_path) + "/" + id).c_str()));
}
TEST_F(StorageRootfsUnitTest, test_rootfs_store_lookup)
{
std::string id { "28a8e1311d71345b08788c16b8c4f45a57641854f0e7c16802eedd0eb334b832" };
std::string name { "28a8e1311d71345b08788c16b8c4f45a57641854f0e7c16802eedd0eb334b832" };
std::string truncatedId { "28a8e1311d71" };
std::string incorrectId { "89jfl9hds13k" };
char *value = NULL;
ASSERT_STREQ((value = rootfs_store_lookup(name.c_str())), id.c_str());
free(value);
ASSERT_STREQ((value = rootfs_store_lookup(truncatedId.c_str())), id.c_str());
free(value);
ASSERT_EQ(rootfs_store_lookup(incorrectId.c_str()), nullptr);
}
TEST_F(StorageRootfsUnitTest, test_rootfs_store_exists)
{
std::string id { "28a8e1311d71345b08788c16b8c4f45a57641854f0e7c16802eedd0eb334b832" };
std::string name { "28a8e1311d71345b08788c16b8c4f45a57641854f0e7c16802eedd0eb334b832" };
std::string truncatedId { "28a8e1311d71345b" };
std::string incorrectId { "c4f45a57641854f0" };
ASSERT_TRUE(rootfs_store_exists(name.c_str()));
ASSERT_TRUE(rootfs_store_exists(truncatedId.c_str()));
ASSERT_FALSE(rootfs_store_exists(incorrectId.c_str()));
}
TEST_F(StorageRootfsUnitTest, test_rootfs_store_metadata)
{
std::string incorrectId { "ff67da98ab8540d713209" };
char *metadata = NULL;
metadata = rootfs_store_metadata(ids.at(0).c_str());
ASSERT_STREQ(metadata, META_DATA_CONTENT.c_str());
free(metadata);
metadata = NULL;
metadata = rootfs_store_metadata(ids.at(1).c_str());
ASSERT_STREQ(metadata, "{}");
free(metadata);
metadata = NULL;
ASSERT_EQ(rootfs_store_metadata(incorrectId.c_str()), nullptr);
}
TEST_F(StorageRootfsUnitTest, test_rootfs_store_get_all_rootfs)
{
rootfs_list *rf_list = NULL;
rf_list = (rootfs_list *)util_common_calloc_s(sizeof(rootfs_list));
ASSERT_NE(rf_list, nullptr);
ASSERT_EQ(rootfs_store_get_all_rootfs(rf_list), 0);
ASSERT_EQ(rf_list->rootfs_len, 2);
for (size_t i {}; i < rf_list->rootfs_len; i++) {
ASSERT_NE(find(ids.begin(), ids.end(), std::string(rf_list->rootfs[i]->id)), ids.end());
auto cntr = rf_list->rootfs[i];
if (std::string(rf_list->rootfs[i]->id) == ids.at(0)) {
ASSERT_STREQ(cntr->created, "2020-05-27T08:55:26.273287183Z");
ASSERT_STREQ(cntr->image, "e4db68de4ff27c2adfea0c54bbb73a61a42f5b667c326de4d7d5b19ab71c6a3b");
ASSERT_STREQ(cntr->layer, "253836aa199405a39b6262b1e55a0d946b80988bc2f82d8f2b802fc175e4874e");
ASSERT_STREQ(cntr->names[0], "0e025f44cdca20966a5e5f11e1d9d8eb726aef2d38ed20f89ea986987c2010a9");
ASSERT_EQ(cntr->names_len, 1);
ASSERT_STREQ(cntr->big_data_names[0], "userdata");
ASSERT_EQ(*(cntr->big_data_sizes->values), BIG_DATA_CONTENT.size());
}
}
free_rootfs_list(rf_list);
}
TEST_F(StorageRootfsUnitTest, test_rootfs_store_delete)
{
std::string backup = std::string(store_real_path) + ".bak";
std::string command = "cp -r " + std::string(store_real_path) + " " + backup;
std::string rm_command = "rm -rf " + std::string(store_real_path);
std::string undo_command = "mv " + backup + " " + std::string(store_real_path);
ASSERT_EQ(system(command.c_str()), 0);
for (auto elem : ids) {
ASSERT_TRUE(rootfs_store_exists(elem.c_str()));
ASSERT_TRUE(dirExists((std::string(store_real_path) + "/overlay-containers/" + elem).c_str()));
ASSERT_EQ(rootfs_store_delete(elem.c_str()), 0);
ASSERT_FALSE(rootfs_store_exists(elem.c_str()));
ASSERT_FALSE(dirExists((std::string(store_real_path) + "/overlay-containers/" + elem).c_str()));
}
ASSERT_EQ(system(rm_command.c_str()), 0);
ASSERT_EQ(system(undo_command.c_str()), 0);
}
TEST_F(StorageRootfsUnitTest, test_rootfs_store_wipe)
{
std::string backup = std::string(store_real_path) + ".bak";
std::string command = "cp -r " + std::string(store_real_path) + " " + backup;
std::string rm_command = "rm -rf " + std::string(store_real_path);
std::string undo_command = "mv " + backup + " " + std::string(store_real_path);
ASSERT_EQ(system(command.c_str()), 0);
for (auto elem : ids) {
ASSERT_TRUE(rootfs_store_exists(elem.c_str()));
ASSERT_TRUE(dirExists((std::string(store_real_path) + "/overlay-containers/" + elem).c_str()));
}
ASSERT_EQ(rootfs_store_wipe(), 0);
for (auto elem : ids) {
ASSERT_FALSE(rootfs_store_exists(elem.c_str()));
ASSERT_FALSE(dirExists((std::string(store_real_path) + "/overlay-containers/" + elem).c_str()));
}
ASSERT_EQ(system(rm_command.c_str()), 0);
ASSERT_EQ(system(undo_command.c_str()), 0);
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或