foreign/cpp/tests/unit_tests.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 <string>

#include <gtest/gtest.h>

#include "iggy.hpp"

TEST(CompressionAlgorithmTest, ReturnsExpectedValues) {
    EXPECT_EQ(iggy::CompressionAlgorithm::none().compression_algorithm_value(), "none");
    EXPECT_EQ(iggy::CompressionAlgorithm::gzip().compression_algorithm_value(), "gzip");
}

TEST(SnapshotCompressionTest, ReturnsExpectedValues) {
    EXPECT_EQ(iggy::SnapshotCompression::stored().snapshot_compression_value(), "stored");
    EXPECT_EQ(iggy::SnapshotCompression::deflated().snapshot_compression_value(), "deflated");
    EXPECT_EQ(iggy::SnapshotCompression::bzip2().snapshot_compression_value(), "bzip2");
    EXPECT_EQ(iggy::SnapshotCompression::zstd().snapshot_compression_value(), "zstd");
    EXPECT_EQ(iggy::SnapshotCompression::lzma().snapshot_compression_value(), "lzma");
    EXPECT_EQ(iggy::SnapshotCompression::xz().snapshot_compression_value(), "xz");
}

TEST(SystemSnapshotTypeTest, ReturnsExpectedValues) {
    EXPECT_EQ(iggy::SystemSnapshotType::filesystem_overview().snapshot_type_value(), "filesystem_overview");
    EXPECT_EQ(iggy::SystemSnapshotType::process_list().snapshot_type_value(), "process_list");
    EXPECT_EQ(iggy::SystemSnapshotType::resource_usage().snapshot_type_value(), "resource_usage");
    EXPECT_EQ(iggy::SystemSnapshotType::test().snapshot_type_value(), "test");
    EXPECT_EQ(iggy::SystemSnapshotType::server_logs().snapshot_type_value(), "server_logs");
    EXPECT_EQ(iggy::SystemSnapshotType::server_config().snapshot_type_value(), "server_config");
    EXPECT_EQ(iggy::SystemSnapshotType::all().snapshot_type_value(), "all");
}

TEST(IdKindTest, ReturnsExpectedValues) {
    EXPECT_EQ(iggy::IdKind::numeric().id_kind_value(), "numeric");
    EXPECT_EQ(iggy::IdKind::string().id_kind_value(), "string");
}

TEST(MaxTopicSizeTest, ReturnsExpectedValues) {
    EXPECT_EQ(iggy::MaxTopicSize::server_default().max_topic_size(), "server_default");
    EXPECT_EQ(iggy::MaxTopicSize::unlimited().max_topic_size(), "unlimited");
    EXPECT_EQ(iggy::MaxTopicSize::from_bytes(0).max_topic_size(), "server_default");
    EXPECT_EQ(iggy::MaxTopicSize::from_bytes(std::numeric_limits<std::uint64_t>::max()).max_topic_size(), "unlimited");
    EXPECT_EQ(iggy::MaxTopicSize::from_bytes(1024).max_topic_size(), "1024");
}

TEST(PollingStrategyTest, ReturnsExpectedKindAndValue) {
    const auto offset = iggy::PollingStrategy::offset(7);
    EXPECT_EQ(offset.polling_strategy_kind(), "offset");
    EXPECT_EQ(offset.polling_strategy_value(), 7u);

    const auto timestamp = iggy::PollingStrategy::timestamp(42);
    EXPECT_EQ(timestamp.polling_strategy_kind(), "timestamp");
    EXPECT_EQ(timestamp.polling_strategy_value(), 42u);

    const auto first = iggy::PollingStrategy::first();
    EXPECT_EQ(first.polling_strategy_kind(), "first");
    EXPECT_EQ(first.polling_strategy_value(), 0u);

    const auto last = iggy::PollingStrategy::last();
    EXPECT_EQ(last.polling_strategy_kind(), "last");
    EXPECT_EQ(last.polling_strategy_value(), 0u);

    const auto next = iggy::PollingStrategy::next();
    EXPECT_EQ(next.polling_strategy_kind(), "next");
    EXPECT_EQ(next.polling_strategy_value(), 0u);
}

TEST(ExpiryTest, ReturnsExpectedKindAndValue) {
    const auto server_default = iggy::Expiry::server_default();
    EXPECT_EQ(server_default.expiry_kind(), "server_default");
    EXPECT_EQ(server_default.expiry_value(), static_cast<std::uint64_t>(0));

    const auto never_expire = iggy::Expiry::never_expire();
    EXPECT_EQ(never_expire.expiry_kind(), "never_expire");
    EXPECT_EQ(never_expire.expiry_value(), std::numeric_limits<std::uint64_t>::max());

    const auto duration = iggy::Expiry::duration(15);
    EXPECT_EQ(duration.expiry_kind(), "duration");
    EXPECT_EQ(duration.expiry_value(), static_cast<std::uint64_t>(15));
}

TEST(IggyExceptionTest, StoresMessage) {
    const iggy::IggyException from_cstr("boom");
    EXPECT_EQ(std::string(from_cstr.what()), "boom");

    const std::string message = "boom2";
    const iggy::IggyException from_string(message);
    EXPECT_EQ(std::string(from_string.what()), message);
}