added option min-time-between-resolves-option and tests for it

[pingcheck] / test / test_dns.cpp

/*
The software in this package is distributed under the GNU General
Public License version 2 (with a special exception described below).

A copy of GNU General Public License (GPL) is included in this distribution,
in the file COPYING.GPL.

As a special exception, if other files instantiate templates or use macros
or inline functions from this file, or you compile this file and link it
with other works to produce a work based on this file, this file
does not by itself cause the resulting work to be covered
by the GNU General Public License.

However the source code for this file must still be made available
in accordance with section (3) of the GNU General Public License.

This exception does not invalidate any other reasons why a work based
on this file might be covered by the GNU General Public License.
*/

#define BOOST_TEST_MAIN
#define BOOST_TEST_DYN_LINK

#include <algorithm>

#include <boost/test/unit_test.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/asio/ip/address.hpp>
#include <boost/bind.hpp>

#include <logfunc.hpp>

#include "host/pingprotocol.h"
#include "dns/hostaddress.h"
#include "dns/dnsmaster.h"
#include "dns/dnscache.h"
#include "dns/resolverbase.h"
#include "dns/cname.h"

using boost::asio::ip::address;

//------------------------------------------------------------------------------
// Global Test fixture (created once for test suite)
//------------------------------------------------------------------------------

// constants for master
address name_server = address::from_string("127.0.0.1");
int resolved_ip_ttl_threshold = 5;
uint32_t min_time_between_resolves = 3; // should be < resolved_ip_ttl_threshold
int max_address_resolution_attempts = 2;
std::string cache_file = DnsCache::DoNotUseCacheFile;

// rely on boost that there will only be one instance
struct GlobalFixture;
GlobalFixture *global_fixture;


struct GlobalFixture
{

    GlobalFixture()
        : IoService()
        , Cache()
        , Master()
    {
        BOOST_TEST_MESSAGE("Create global fixture");

        // setup logging so we can see output from out code
        I2n::Logger::enable_stderr_log( true );
        I2n::Logger::set_log_level( I2n::Logger::LogLevel::Info );
        I2n::Logger::GlobalLogger.info() << "Logging enabled for DnsTest";

        // IoService
        IoServiceItem io_service_temp( new boost::asio::io_service() );
        io_service_temp.swap( IoService );
        io_service_temp.reset();

        // DNS Cache
        DnsCacheItem cache_temp = DnsCacheItem(
               new DnsCache(IoService, cache_file, min_time_between_resolves) );
        cache_temp.swap( Cache );
        cache_temp.reset();
        fill_cache();

        // create master
        DnsMaster::create_master(IoService,
                                 name_server,
                                 resolved_ip_ttl_threshold,
                                 max_address_resolution_attempts,
                                 Cache);
        Master = DnsMaster::get_instance();

        // remember this instance, so we can later access all these variables
        if (global_fixture == 0)
            global_fixture = this;
    }

    ~GlobalFixture()
    {
        BOOST_TEST_MESSAGE("Destructing global fixture");
        IoService->stop();
        IoService.reset();
        Master.reset();
    }

    void fill_cache()
    {
        BOOST_TEST_MESSAGE( "Filling cache..." );
        {
            HostAddress ip(address::from_string("192.168.42.1"), 61);
            HostAddressVec ips;
            ips.push_back(ip);
            Cache->update("host1.test", ips);
        }

        {
            HostAddress ip1(address::from_string("192.168.42.2"), 92);
            HostAddress ip2(address::from_string("192.168.42.3"), 93);
            HostAddressVec ips;
            ips.push_back(ip1);
            ips.push_back(ip2);
            Cache->update("host2_3.test", ips);
        }

        {
            // cname.test --> host1.test
            Cache->update("cname.test", Cname("host1.test", 35) );

            // cname2.test --> cname.test --> host1.test
            Cache->update("cname2.test", Cname("cname.test", 33) );

            // cname3.test --> cname2.test --> cname.test --> host1.test
            Cache->update("cname3.test", Cname("cname2.test", 37) );
        }

        {   // for cache_outdated_test
            HostAddressVec ips;
            ips.push_back( HostAddress( address::from_string("192.168.42.4"),
                                        0 ) );
            ips.push_back( HostAddress( address::from_string("192.168.42.5"),
                                        resolved_ip_ttl_threshold-1 ) );
            ips.push_back( HostAddress( address::from_string("192.168.42.6"),
                                        resolved_ip_ttl_threshold ) );
            ips.push_back( HostAddress( address::from_string("192.168.42.7"),
                                        resolved_ip_ttl_threshold+1 ) );
            Cache->update("host_outdated.test", ips);

            Cache->update( "cname_outdated.test",
                      Cname("host_outdated.test", resolved_ip_ttl_threshold) );
            Cache->update( "cname_up_to_date.test",
                      Cname("host_outdated.test", resolved_ip_ttl_threshold+1));
        }

        {   // for cache_ttl_below_thresh_test
            // TTLs < min_time_between_resolves should be corrected
            HostAddressVec ips;
            ips.push_back( HostAddress( address::from_string("192.128.42.8"),
                                        1 ) );
            Cache->update("host_ttl_below_thresh.test", ips);

            Cache->update( "cname_ttl_below_thresh.test",
                      Cname("host_ttl_below_thresh.test", 2) );
        }

        BOOST_TEST_MESSAGE( "Done filling cache." );
    }

    // these variables will not be available in test cases:
    IoServiceItem IoService;
    DnsCacheItem Cache;
    DnsMasterItem Master;
};

// this causes above fixture to be created only once before tests start and
// destructed after tests end; however, variables are not accessible in test
// cases
BOOST_GLOBAL_FIXTURE( GlobalFixture )


// using this as suite-level fixture makes variable Master accessible in all
//   test cases
struct TestFixture
{
    IoServiceItem IoService;
    DnsCacheItem Cache;
    DnsMasterItem Master;

    TestFixture()
        : IoService()
        , Cache()
        , Master()
    {
        BOOST_TEST_MESSAGE("Create test-level fixture");
        GlobalFixture *global = global_fixture;
        IoService = global->IoService;
        Cache = global->Cache;
        Master = global->Master;
    }

    virtual ~TestFixture() {}
};

//------------------------------------------------------------------------------
// test suite
//------------------------------------------------------------------------------

BOOST_FIXTURE_TEST_SUITE( TestDns, TestFixture )

BOOST_AUTO_TEST_CASE( create_master )
{
    // simple checks
    BOOST_CHECK_EQUAL( Master->get_resolved_ip_ttl_threshold(),
                                   resolved_ip_ttl_threshold );
    BOOST_CHECK_EQUAL( Master->get_max_address_resolution_attempts(),
                                   max_address_resolution_attempts );
}

//------------------------------------------------------------------------------
// test Cache
//------------------------------------------------------------------------------
BOOST_FIXTURE_TEST_SUITE( TestDnsCache, TestFixture )

BOOST_AUTO_TEST_CASE( cache_retrieve_ip1 )
{
    HostAddressVec ips = Cache->get_ips("host1.test");
    BOOST_REQUIRE_EQUAL( ips.size(), 1 );
    HostAddress ip = ips.front();
    BOOST_CHECK( ip.is_valid() );
    BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.1" );
    BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 61 );
}


BOOST_AUTO_TEST_CASE( cache_retrieve_ip2 )
{
    HostAddressVec ips = Cache->get_ips("host2_3.test");
    BOOST_CHECK_EQUAL( ips.size(), 2 );
    HostAddress ip = ips[0];
    BOOST_CHECK( ip.is_valid() );
    BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.2" );
    BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 92 );
    ip = ips[1];
    BOOST_CHECK( ip.is_valid() );
    BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.3" );
    BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 93 );
}

BOOST_AUTO_TEST_CASE( cache_retrieve_cname )
{
    HostAddressVec ips = Cache->get_ips("cname.test");
    BOOST_CHECK( ips.empty() );

    Cname cname = Cache->get_cname("cname.test");
    BOOST_CHECK_EQUAL( cname.Host, "host1.test" );
    BOOST_CHECK_EQUAL( cname.Ttl.get_value(), 35 );
}

BOOST_AUTO_TEST_CASE( cache_retrieve_recursive1 )
{
    // should get IP from host1 but ttl from cname since is smaller
    HostAddressVec ips = Cache->get_ips_recursive("cname.test");
    BOOST_REQUIRE_EQUAL( ips.size(), 1 );
    HostAddress ip = ips.front();
    BOOST_CHECK( ip.is_valid() );
    BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.1" );
    BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 35 );
}

BOOST_AUTO_TEST_CASE( cache_retrieve_recursive2 )
{
    // should get IP from host1 but ttl from cname2 since is smaller
    HostAddressVec ips = Cache->get_ips_recursive("cname3.test");
    BOOST_REQUIRE_EQUAL( ips.size(), 1 );
    HostAddress ip = ips.front();
    BOOST_CHECK( ip.is_valid() );
    BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.1" );
    BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 33 );
}

void cname_skip_test(const uint32_t ttl1, const uint32_t ttl2,
                     const uint32_t ttl3, const uint32_t ttl4,
                     const DnsCacheItem &cache,
                     const std::string &correct_host_after_skip)
{
    {   // create cname chain:
        // skip_chain_first -(ttl1)-> skip_chain_second -(ttl2)->
        //   skip_chain_third -(ttl3)-> skip_chain_fourth -(ttl4)-> IPs
        cache->update( "skip_chain_first.test",
                 Cname("skip_chain_second.test", ttl1) );
        cache->update( "skip_chain_second.test",
                 Cname("skip_chain_third.test", ttl2) );
        cache->update( "skip_chain_third.test",
                 Cname("skip_chain_fourth.test", ttl3) );
        HostAddressVec ips;
        ips.push_back( HostAddress( address::from_string("192.168.42.100"),
                                    ttl4 ) );
        cache->update("skip_chain_fourth.test", ips);
    }

    // normal recursive call should give nothing since one cname is outdated
    bool check_up_to_date = true;
    HostAddressVec ips = cache->get_ips_recursive("skip_chain_first.test",
                                                  check_up_to_date);
    bool one_is_out_of_date = (ttl1 < 5) || (ttl2 < 5)
                           || (ttl3 < 5) || (ttl4 < 5);
    BOOST_CHECK_EQUAL( ips.empty(), one_is_out_of_date );

    // now find host to resolve after the outdated one
    std::string first_outdated = cache->get_first_outdated_cname(
                                                    "skip_chain_first.test", 5);
    BOOST_CHECK_EQUAL( first_outdated, correct_host_after_skip );
}

BOOST_AUTO_TEST_CASE( cache_skip_tests )
{
    // build a cname chain where first one is out of date
    cname_skip_test(0, 120, 120, 60, Cache, "skip_chain_second.test");

    // build a cname chain where second one is out of date
    cname_skip_test(120, 0, 120, 60, Cache, "skip_chain_third.test");

    // build a cname chain where third one is out of date
    cname_skip_test(120, 120, 0, 120, Cache, "skip_chain_fourth.test");

    // build a cname chain where just IPs are out of date
    cname_skip_test(120, 120, 120, 0, Cache, "");

    // build a cname chain where all are out of date
    cname_skip_test(0, 0, 0, 0, Cache, "skip_chain_second.test");

    // build a cname chain where all is up to date
    cname_skip_test(120, 120, 120, 120, Cache, "");

    // test case with very short cname list that is up-to-date
    BOOST_CHECK_EQUAL( Cache->get_first_outdated_cname("cname.test", 5), "" );

    // test case where there is no cname at all
    BOOST_CHECK_EQUAL( Cache->get_first_outdated_cname("host1.test", 5), "" );
}

BOOST_AUTO_TEST_CASE( cache_load_test )
{
    std::stringstream file_name;
    file_name << DATA_DIR_STRING << "/" << "dns_cache_example.xml";
    BOOST_TEST_MESSAGE( "loading cache from file " << file_name.str() );
    DnsCache loaded_cache( IoService,
                           file_name.str(),
                           min_time_between_resolves );
    HostAddressVec ips = loaded_cache.get_ips("abc.xyz");
    BOOST_REQUIRE_EQUAL( ips.size(), 1 );
    HostAddress ip = ips.front();
    BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "11.22.33.44" );
    BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 567 );
    BOOST_CHECK_EQUAL( ip.get_ttl().get_updated_value(), 0 );

    Cname cname = loaded_cache.get_cname("cname1.xyz");
    BOOST_CHECK_EQUAL( cname.Host, "abc.xyz" );
    BOOST_CHECK_EQUAL( cname.Ttl.get_value(), 27 );
    BOOST_CHECK_EQUAL( cname.Ttl.get_updated_value(), 0 );

    // not testing Ttl set time since is private
}

BOOST_AUTO_TEST_CASE( cache_outdated_test )
{
    bool check_up_to_date = false;
    HostAddressVec ips = Cache->get_ips("host_outdated.test", check_up_to_date);
    BOOST_CHECK_EQUAL( ips.size(), 4 );
    ips = Cache->get_ips_recursive("host_outdated.test", check_up_to_date);
    BOOST_CHECK_EQUAL( ips.size(), 4 );
    Cname cname = Cache->get_cname("cname_outdated.test", check_up_to_date);
    BOOST_CHECK( !cname.Host.empty() );
    ips = Cache->get_ips_recursive("cname_outdated.test", check_up_to_date);
    BOOST_CHECK_EQUAL( ips.size(), 4 );
    ips = Cache->get_ips_recursive("cname_up_to_date.test", check_up_to_date);
    BOOST_CHECK_EQUAL( ips.size(), 4 );

    check_up_to_date = true;
    ips = Cache->get_ips( "host_outdated.test", check_up_to_date );
    BOOST_CHECK_EQUAL( ips.size(), 1 );
    ips = Cache->get_ips_recursive("host_outdated.test", check_up_to_date);
    BOOST_CHECK_EQUAL( ips.size(), 1 );
    cname = Cache->get_cname("cname_outdated.test", check_up_to_date);
    BOOST_CHECK( cname.Host.empty() );
    ips = Cache->get_ips_recursive("cname_outdated.test", check_up_to_date);
    BOOST_CHECK_EQUAL( ips.size(), 0 );
    ips = Cache->get_ips_recursive("cname_up_to_date.test", check_up_to_date);
    BOOST_CHECK_EQUAL( ips.size(), 1 );
}

BOOST_AUTO_TEST_CASE( cache_ttl_below_thresh_test )
{
    // in fill_cache, 
    HostAddressVec ips = Cache->get_ips("host_ttl_below_thresh.test", false);
    BOOST_REQUIRE_EQUAL( ips.size(), 1 );
    HostAddress ip = ips.front();
    BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), min_time_between_resolves );

    Cname cname = Cache->get_cname("cname_ttl_below_thresh.test", false);
    BOOST_CHECK_EQUAL( cname.Ttl.get_value(), min_time_between_resolves );
}

BOOST_AUTO_TEST_SUITE_END()    // of TestDnsCache


// -----------------------------------------------------------------------------
// test resolver
// -----------------------------------------------------------------------------

BOOST_FIXTURE_TEST_SUITE( TestDnsResolver, TestFixture )

BOOST_AUTO_TEST_CASE( create_resolver_v4 )
{
    // create resolver
    std::string hostname = "www.intra2net.com";
    ResolverItem resolver = Master->get_resolver_for(hostname,
                                                     PingProtocol_ICMP);
    BOOST_CHECK_EQUAL( resolver->get_hostname(), hostname );
    BOOST_CHECK( !resolver->is_resolving() );
    BOOST_CHECK( !resolver->is_waiting_to_resolve() );

    // cancel should have no effect
    resolver->cancel_resolve();
    BOOST_CHECK( !resolver->is_resolving() );
    BOOST_CHECK( !resolver->is_waiting_to_resolve() );

    // should not have any ips since cache did not load anything
    BOOST_CHECK_EQUAL( resolver->get_resolved_ip_count(), 0 );
    BOOST_CHECK( !resolver->have_up_to_date_ip() );
    std::string no_ip = "0.0.0.0";
    BOOST_CHECK_EQUAL( resolver->get_next_ip().get_ip().to_string(), no_ip );
}


void resolve_callback(IoServiceItem io_serv, ResolverItem resolver,
                      const bool was_success, const int cname_count)
{
    resolver->cancel_resolve();
    io_serv->stop();
    BOOST_TEST_MESSAGE( "Stopped io_service" );
    BOOST_CHECK( was_success );
    BOOST_CHECK_EQUAL( cname_count, 0 );
}


BOOST_AUTO_TEST_CASE( do_resolve )
{
    // create resolver
    std::string hostname = "www.intra2net.com";
    ResolverItem resolver = Master->get_resolver_for(hostname,
                                                     PingProtocol_ICMP);
    BOOST_CHECK( !resolver->is_resolving() );
    BOOST_CHECK( !resolver->is_waiting_to_resolve() );

    // set callback
    callback_type callback = boost::bind( resolve_callback, IoService, resolver,
                                          _1, _2 );
    // start resolving
    resolver->async_resolve(callback);
    BOOST_CHECK( resolver->is_resolving() );
    IoService->run();
    // this will block until io service is stopped in resolve_callback

    // check for result
    BOOST_CHECK( resolver->have_up_to_date_ip() );
}

BOOST_AUTO_TEST_SUITE_END()   // of TestDnsResolver

BOOST_AUTO_TEST_SUITE_END()