[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 = 3;
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::Debug );
        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) );
        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) );

        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_CHECK_EQUAL( ips.size(), 1 );
    HostAddress ip = ips.front();
    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_EQUAL( ip.get_ip().to_string(), "192.168.42.2" );
    BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 92 );
    ip = ips[1];
    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_CHECK_EQUAL( ips.size(), 1 );
    HostAddress ip = ips.front();
    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_CHECK_EQUAL( ips.size(), 1 );
    HostAddress ip = ips.front();
    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.4"), 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_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() );

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

    // 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_AUTO_TEST_CASE( do_resolve )
{
    // create resolver
    std::string hostname = "www.intra2net.com";
    ResolverItem resolver = Master->get_resolver_for(hostname,
                                                     PingProtocol_ICMP);

    // set callback
    callback_type callback = boost::bind( resolve_callback, IoService, resolver,
                                          _1, _2 );
    // start resolving
    resolver->async_resolve(callback);
    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()
Commit	Line	Data
26b0f687 CH	1	/*
	2	The software in this package is distributed under the GNU General
	3	Public License version 2 (with a special exception described below).
	4
	5	A copy of GNU General Public License (GPL) is included in this distribution,
	6	in the file COPYING.GPL.
	7
	8	As a special exception, if other files instantiate templates or use macros
	9	or inline functions from this file, or you compile this file and link it
	10	with other works to produce a work based on this file, this file
	11	does not by itself cause the resulting work to be covered
	12	by the GNU General Public License.
	13
	14	However the source code for this file must still be made available
	15	in accordance with section (3) of the GNU General Public License.
	16
	17	This exception does not invalidate any other reasons why a work based
	18	on this file might be covered by the GNU General Public License.
	19	*/
	20
	21	#define BOOST_TEST_MAIN
	22	#define BOOST_TEST_DYN_LINK
	23
	24	#include <algorithm>
	25
	26	#include <boost/test/unit_test.hpp>
	27	#include <boost/asio/io_service.hpp>
	28	#include <boost/asio/ip/address.hpp>
8d26221d CH	29	#include <boost/bind.hpp>
	30
	31	#include <logfunc.hpp>
26b0f687 CH	32
	33	#include "host/pingprotocol.h"
	34	#include "dns/hostaddress.h"
	35	#include "dns/dnsmaster.h"
	36	#include "dns/dnscache.h"
	37	#include "dns/resolverbase.h"
8d26221d CH	38	#include "dns/cname.h"
	39
	40	using boost::asio::ip::address;
26b0f687 CH	41
26b0f687 CH	42	//------------------------------------------------------------------------------
8d26221d	43	// Global Test fixture (created once for test suite)
26b0f687 CH	44	//------------------------------------------------------------------------------
26b0f687 CH	45
8d26221d CH	46	// constants for master
	47	address name_server = address::from_string("127.0.0.1");
	48	int resolved_ip_ttl_threshold = 3;
	49	int max_address_resolution_attempts = 2;
	50	std::string cache_file = DnsCache::DoNotUseCacheFile;
	51
	52	// rely on boost that there will only be one instance
	53	struct GlobalFixture;
	54	GlobalFixture *global_fixture;
26b0f687	55
8d26221d CH	56
8d26221d CH	57	struct GlobalFixture
26b0f687	58	{
8d26221d CH	59
	60	GlobalFixture()
	61	: IoService()
	62	, Cache()
	63	, Master()
26b0f687	64	{
8d26221d CH	65	BOOST_TEST_MESSAGE("Create global fixture");
	66
	67	// setup logging so we can see output from out code
	68	I2n::Logger::enable_stderr_log( true );
	69	I2n::Logger::set_log_level( I2n::Logger::LogLevel::Debug );
	70	I2n::Logger::GlobalLogger.info() << "Logging enabled for DnsTest";
	71
	72	// IoService
	73	IoServiceItem io_service_temp( new boost::asio::io_service() );
	74	io_service_temp.swap( IoService );
	75	io_service_temp.reset();
	76
	77	// DNS Cache
	78	DnsCacheItem cache_temp = DnsCacheItem(
	79	new DnsCache(IoService, cache_file) );
	80	cache_temp.swap( Cache );
	81	cache_temp.reset();
	82	fill_cache();
	83
	84	// create master
	85	DnsMaster::create_master(IoService,
26b0f687 CH	86	name_server,
	87	resolved_ip_ttl_threshold,
	88	max_address_resolution_attempts,
8d26221d CH	89	Cache);
	90	Master = DnsMaster::get_instance();
	91
	92	// remember this instance, so we can later access all these variables
	93	if (global_fixture == 0)
	94	global_fixture = this;
26b0f687	95	}
8d26221d CH	96
	97	~GlobalFixture()
	98	{
	99	BOOST_TEST_MESSAGE("Destructing global fixture");
	100	IoService->stop();
	101	IoService.reset();
	102	Master.reset();
	103	}
	104
	105	void fill_cache()
	106	{
	107	BOOST_TEST_MESSAGE( "Filling cache..." );
	108	{
	109	HostAddress ip(address::from_string("192.168.42.1"), 61);
	110	HostAddressVec ips;
	111	ips.push_back(ip);
	112	Cache->update("host1.test", ips);
	113	}
	114
	115	{
	116	HostAddress ip1(address::from_string("192.168.42.2"), 92);
	117	HostAddress ip2(address::from_string("192.168.42.3"), 93);
	118	HostAddressVec ips;
	119	ips.push_back(ip1);
	120	ips.push_back(ip2);
	121	Cache->update("host2_3.test", ips);
	122	}
	123
9d1b2726 CH	124	// cname.test --> host1.test
9d1b2726 CH	125	Cache->update("cname.test", Cname("host1.test", 35) );
8d26221d	126
9d1b2726 CH	127	// cname2.test --> cname.test --> host1.test
	128	Cache->update("cname2.test", Cname("cname.test", 33) );
	129
	130	// cname3.test --> cname2.test --> cname.test --> host1.test
	131	Cache->update("cname3.test", Cname("cname2.test", 37) );
8d26221d	132
8d26221d CH	133	BOOST_TEST_MESSAGE( "Done filling cache." );
	134	}
	135
	136	// these variables will not be available in test cases:
	137	IoServiceItem IoService;
	138	DnsCacheItem Cache;
	139	DnsMasterItem Master;
	140	};
	141
	142	// this causes above fixture to be created only once before tests start and
	143	// destructed after tests end; however, variables are not accessible in test
	144	// cases
	145	BOOST_GLOBAL_FIXTURE( GlobalFixture )
	146
	147
	148	// using this as suite-level fixture makes variable Master accessible in all
	149	// test cases
	150	struct TestFixture
	151	{
	152	IoServiceItem IoService;
	153	DnsCacheItem Cache;
	154	DnsMasterItem Master;
	155
	156	TestFixture()
	157	: IoService()
	158	, Cache()
	159	, Master()
	160	{
	161	BOOST_TEST_MESSAGE("Create test-level fixture");
	162	GlobalFixture *global = global_fixture;
	163	IoService = global->IoService;
	164	Cache = global->Cache;
	165	Master = global->Master;
	166	}
	167
	168	virtual ~TestFixture() {}
	169	};
26b0f687 CH	170
	171	//------------------------------------------------------------------------------
	172	// test suite
	173	//------------------------------------------------------------------------------
	174
8d26221d	175	BOOST_FIXTURE_TEST_SUITE( TestDns, TestFixture )
26b0f687 CH	176
	177	BOOST_AUTO_TEST_CASE( create_master )
	178	{
8d26221d CH	179	// simple checks
	180	BOOST_CHECK_EQUAL( Master->get_resolved_ip_ttl_threshold(),
	181	resolved_ip_ttl_threshold );
	182	BOOST_CHECK_EQUAL( Master->get_max_address_resolution_attempts(),
	183	max_address_resolution_attempts );
26b0f687 CH	184	}
26b0f687 CH	185
8d26221d CH	186	//------------------------------------------------------------------------------
	187	// test Cache
	188	//------------------------------------------------------------------------------
	189	BOOST_FIXTURE_TEST_SUITE( TestDnsCache, TestFixture )
	190
	191	BOOST_AUTO_TEST_CASE( cache_retrieve_ip1 )
26b0f687	192	{
8d26221d CH	193	HostAddressVec ips = Cache->get_ips("host1.test");
	194	BOOST_CHECK_EQUAL( ips.size(), 1 );
	195	HostAddress ip = ips.front();
	196	BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.1" );
	197	BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 61 );
	198	}
	199
	200
	201	BOOST_AUTO_TEST_CASE( cache_retrieve_ip2 )
	202	{
	203	HostAddressVec ips = Cache->get_ips("host2_3.test");
	204	BOOST_CHECK_EQUAL( ips.size(), 2 );
	205	HostAddress ip = ips[0];
	206	BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.2" );
	207	BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 92 );
	208	ip = ips[1];
	209	BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.3" );
	210	BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 93 );
	211	}
26b0f687	212
8d26221d CH	213	BOOST_AUTO_TEST_CASE( cache_retrieve_cname )
	214	{
	215	HostAddressVec ips = Cache->get_ips("cname.test");
	216	BOOST_CHECK( ips.empty() );
	217
	218	Cname cname = Cache->get_cname("cname.test");
	219	BOOST_CHECK_EQUAL( cname.Host, "host1.test" );
	220	BOOST_CHECK_EQUAL( cname.Ttl.get_value(), 35 );
	221	}
	222
	223	BOOST_AUTO_TEST_CASE( cache_retrieve_recursive1 )
	224	{
	225	// should get IP from host1 but ttl from cname since is smaller
	226	HostAddressVec ips = Cache->get_ips_recursive("cname.test");
	227	BOOST_CHECK_EQUAL( ips.size(), 1 );
	228	HostAddress ip = ips.front();
	229	BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.1" );
	230	BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 35 );
	231	}
	232
	233	BOOST_AUTO_TEST_CASE( cache_retrieve_recursive2 )
	234	{
	235	// should get IP from host1 but ttl from cname2 since is smaller
	236	HostAddressVec ips = Cache->get_ips_recursive("cname3.test");
	237	BOOST_CHECK_EQUAL( ips.size(), 1 );
	238	HostAddress ip = ips.front();
	239	BOOST_CHECK_EQUAL( ip.get_ip().to_string(), "192.168.42.1" );
	240	BOOST_CHECK_EQUAL( ip.get_ttl().get_value(), 33 );
	241	}
	242
9d1b2726 CH	243	void cname_skip_test(const uint32_t ttl1, const uint32_t ttl2,
	244	const uint32_t ttl3, const uint32_t ttl4,
	245	const DnsCacheItem &cache,
	246	const std::string &correct_host_after_skip)
8d26221d	247	{
9d1b2726 CH	248	{ // create cname chain:
	249	// skip_chain_first -(ttl1)-> skip_chain_second -(ttl2)->
	250	// skip_chain_third -(ttl3)-> skip_chain_fourth -(ttl4)-> IPs
	251	cache->update( "skip_chain_first.test",
	252	Cname("skip_chain_second.test", ttl1) );
	253	cache->update( "skip_chain_second.test",
	254	Cname("skip_chain_third.test", ttl2) );
	255	cache->update( "skip_chain_third.test",
	256	Cname("skip_chain_fourth.test", ttl3) );
8d26221d	257	HostAddressVec ips;
9d1b2726 CH	258	ips.push_back( HostAddress( address::from_string("192.168.42.4"), ttl4) );
9d1b2726 CH	259	cache->update("skip_chain_fourth.test", ips);
8d26221d CH	260	}
8d26221d CH	261
9d1b2726	262	// normal recursive call should give nothing since one cname is outdated
8d26221d	263	bool check_up_to_date = true;
9d1b2726	264	HostAddressVec ips = cache->get_ips_recursive("skip_chain_first.test",
8d26221d	265	check_up_to_date);
9d1b2726 CH	266	bool one_is_out_of_date = (ttl1 < 5) \|\| (ttl2 < 5)
	267	\|\| (ttl3 < 5) \|\| (ttl4 < 5);
	268	BOOST_CHECK_EQUAL( ips.empty(), one_is_out_of_date );
8d26221d	269
9d1b2726 CH	270	// now find host to resolve after the outdated one
9d1b2726 CH	271	std::string first_outdated = cache->get_first_outdated_cname(
8d26221d	272	"skip_chain_first.test", 5);
9d1b2726 CH	273	BOOST_CHECK_EQUAL( first_outdated, correct_host_after_skip );
	274	}
	275
	276	BOOST_AUTO_TEST_CASE( cache_skip_tests )
	277	{
	278	// build a cname chain where first one is out of date
	279	cname_skip_test(0, 120, 120, 60, Cache, "skip_chain_second.test");
	280
	281	// build a cname chain where second one is out of date
	282	cname_skip_test(120, 0, 120, 60, Cache, "skip_chain_third.test");
	283
	284	// build a cname chain where third one is out of date
	285	cname_skip_test(120, 120, 0, 120, Cache, "skip_chain_fourth.test");
	286
	287	// build a cname chain where just IPs are out of date
	288	cname_skip_test(120, 120, 120, 0, Cache, "");
	289
	290	// build a cname chain where all are out of date
	291	cname_skip_test(0, 0, 0, 0, Cache, "skip_chain_second.test");
	292
	293	// build a cname chain where all is up to date
	294	cname_skip_test(120, 120, 120, 120, Cache, "");
	295
	296	// test case with very short cname list that is up-to-date
	297	BOOST_CHECK_EQUAL( Cache->get_first_outdated_cname("cname.test", 5), "" );
	298
	299	// test case where there is no cname at all
	300	BOOST_CHECK_EQUAL( Cache->get_first_outdated_cname("host1.test", 5), "" );
8d26221d CH	301	}
	302
	303
	304	BOOST_AUTO_TEST_SUITE_END() // of TestDnsCache
	305
	306
	307	// -----------------------------------------------------------------------------
	308	// test resolver
	309	// -----------------------------------------------------------------------------
	310
	311	BOOST_FIXTURE_TEST_SUITE( TestDnsResolver, TestFixture )
	312
8d26221d CH	313	BOOST_AUTO_TEST_CASE( create_resolver_v4 )
8d26221d CH	314	{
26b0f687 CH	315	// create resolver
26b0f687 CH	316	std::string hostname = "www.intra2net.com";
8d26221d CH	317	ResolverItem resolver = Master->get_resolver_for(hostname,
8d26221d CH	318	PingProtocol_ICMP);
26b0f687 CH	319	BOOST_CHECK_EQUAL( resolver->get_hostname(), hostname );
	320	BOOST_CHECK( !resolver->is_resolving() );
	321
	322	// cancel should have no effect
	323	resolver->cancel_resolve();
	324	BOOST_CHECK( !resolver->is_resolving() );
	325
	326	// should not have any ips since cache did not load anything
	327	BOOST_CHECK_EQUAL( resolver->get_resolved_ip_count(), 0 );
	328	BOOST_CHECK( !resolver->have_up_to_date_ip() );
	329	std::string no_ip = "0.0.0.0";
	330	BOOST_CHECK_EQUAL( resolver->get_next_ip().get_ip().to_string(), no_ip );
	331	}
	332
8d26221d CH	333
	334	void resolve_callback(IoServiceItem io_serv, ResolverItem resolver,
	335	const bool was_success, const int cname_count)
	336	{
	337	resolver->cancel_resolve();
	338	io_serv->stop();
	339	BOOST_TEST_MESSAGE( "Stopped io_service" );
	340	}
	341
	342
	343	BOOST_AUTO_TEST_CASE( do_resolve )
	344	{
	345	// create resolver
	346	std::string hostname = "www.intra2net.com";
	347	ResolverItem resolver = Master->get_resolver_for(hostname,
	348	PingProtocol_ICMP);
	349
	350	// set callback
	351	callback_type callback = boost::bind( resolve_callback, IoService, resolver,
	352	_1, _2 );
	353	// start resolving
	354	resolver->async_resolve(callback);
	355	IoService->run();
	356	// this will block until io service is stopped in resolve_callback
	357
	358	// check for result
	359	BOOST_CHECK( resolver->have_up_to_date_ip() );
	360	}
	361
	362	BOOST_AUTO_TEST_SUITE_END() // of TestDnsResolver
	363
26b0f687	364	BOOST_AUTO_TEST_SUITE_END()