path: root/p2pvr/daemon/unittests/testMaint.cpp

#define BOOST_TEST_MODULE Maintenance
#include <boost/test/unit_test.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <testOptionsSource.h>
#include <Ice/ObjectAdapter.h>
#include <Ice/Service.h>
#include <maintenance.h>
#include <mockTuner.h>
#include "mockDevices.h"
#include "mockScheduler.h"
#include <si.h>
#include <recordings.h>
#include <linux/dvb/frontend.h>
#include <definedDirs.h>
#include "mockDefs.h"
#include <slicer/db/sqlSelectDeserializer.h>
#include "commonHelpers.h"
#include <slicer/slicer.h>
#include <testAppInstance.h>

class Core : public CommonObjects, public TestAppInstance {
	public:
		Core()
		{
			int paramCount = 0;
			ic = Ice::initialize(paramCount, NULL);
			auto adapter = ic->createObjectAdapterWithEndpoints("Adp", "tcp -p 12000");
			TestOptionsSource::LoadTestOptions({
					{ "common.datasourceRoot", (rootDir / "datasources").string() },
				});
			adapter->add(new MockDevices(), ic->stringToIdentity("GlobalDevices"));
			adapter->add(new MockScheduler(), ic->stringToIdentity("Schedules"));
			adapter->add(new SI(), ic->stringToIdentity("SI"));
			adapter->add(new Recordings(), ic->stringToIdentity("Recordings"));
			adapter->add(new Maintenance(adapter, NULL), ic->stringToIdentity("Maintenance"));
			adapter->activate();

			r = P2PVR::RecordingsPrx::checkedCast(ic->stringToProxy("Recordings"));
			BOOST_REQUIRE(r);
			r->ice_ping();

			s = P2PVR::SIPrx::checkedCast(ic->stringToProxy("SI"));
			BOOST_REQUIRE(s);
			s->ice_ping();

			m = P2PVR::MaintenancePrx::checkedCast(ic->stringToProxy("Maintenance"));
			BOOST_REQUIRE(m);
			m->ice_ping();
		}

		~Core()
		{
			ic->destroy();
		}

		P2PVR::MaintenancePrx m;
		P2PVR::RecordingsPrx r;
		P2PVR::SIPrx s;

	private:
		Ice::CommunicatorPtr ic;
};

BOOST_GLOBAL_FIXTURE( SchemaOnlyMockDatabase );

BOOST_FIXTURE_TEST_SUITE( MaintCore, Core );

const int serviceId = 4170;
const int transportId = 20544;
const int eventId1 = 31;
const int eventId2 = 915;

//
// Run all these tests when there's no data
// This tests behaviour from clean startup/fresh install
//
BOOST_AUTO_TEST_CASE( GetNetworks_emptySet )
{
	BOOST_REQUIRE(s->GetNetworks().empty());
}

BOOST_AUTO_TEST_CASE( GetAllDeliveries_emptySet )
{
	BOOST_REQUIRE(s->GetAllDeliveries().empty());
}

BOOST_AUTO_TEST_CASE( GetDeliveryForService_notFound )
{
	BOOST_REQUIRE_THROW(s->GetDeliveryForService(serviceId), P2PVR::NotFound);
}

BOOST_AUTO_TEST_CASE( GetDeliveryForTransport_notFound )
{
	BOOST_REQUIRE_THROW(s->GetDeliveryForTransport(transportId), P2PVR::NotFound);
}

BOOST_AUTO_TEST_CASE( GetDeliveryForSi_null )
{
	BOOST_REQUIRE_EQUAL(s->GetDeliveryForSi(), DVBSI::DeliveryPtr());
}

BOOST_AUTO_TEST_CASE( GetServices_emptySet )
{
	BOOST_REQUIRE(s->GetServices().empty());
}

BOOST_AUTO_TEST_CASE( GetService_notFound )
{
	BOOST_REQUIRE_THROW(s->GetService(serviceId), P2PVR::NotFound);
}

BOOST_AUTO_TEST_CASE( GetSpecificEvents_notFound )
{
	BOOST_REQUIRE_THROW(s->GetEvents({ eventId1, eventId2 }), P2PVR::NotFound);
}

//
// Now scan for and configure a network
//

BOOST_AUTO_TEST_CASE( update_network )
{
	m->UpdateNetwork(FE_OFDM);
}

BOOST_AUTO_TEST_CASE( GetNetworks )
{
	auto ns = s->GetNetworks();
	BOOST_REQUIRE_EQUAL(ns.size(), 1);
	BOOST_REQUIRE_EQUAL(ns[0]->NetworkId, 12333);
	BOOST_REQUIRE_EQUAL(ns[0]->Name, "Yorkshire");
}

BOOST_AUTO_TEST_CASE( GetDeliveryForService )
{
	auto del = s->GetDeliveryForService(serviceId);
	BOOST_REQUIRE(del);
	BOOST_REQUIRE_EQUAL(del->ice_id(), "::DVBSI::TerrestrialDelivery");
	BOOST_REQUIRE_EQUAL(del->Frequency, 682000000);
}

BOOST_AUTO_TEST_CASE( GetDeliveryForTransport )
{
	auto del = s->GetDeliveryForTransport(transportId);
	BOOST_REQUIRE(del);
	BOOST_REQUIRE_EQUAL(del->ice_id(), "::DVBSI::TerrestrialDelivery");
	BOOST_REQUIRE_EQUAL(del->Frequency, 722000000);
}

BOOST_AUTO_TEST_CASE( GetServices_stubs )
{
	auto services = s->GetServices();
	BOOST_REQUIRE_EQUAL(services.size(), 145);
	BOOST_REQUIRE_EQUAL(services[0]->ServiceId, 4170);
	BOOST_REQUIRE_EQUAL(services[0]->TransportStreamId, 4170);
	// Definitely a stub
	BOOST_REQUIRE(!services[0]->Name);
}

BOOST_AUTO_TEST_CASE( GetService_stubs )
{
	auto service = s->GetService(serviceId);
	BOOST_REQUIRE_EQUAL(service->ServiceId, serviceId);
	// Definitely a stub
	BOOST_REQUIRE(!service->Name);
}

BOOST_AUTO_TEST_CASE( GetDeliveryForSi_any )
{
	auto del = s->GetDeliveryForSi();
	BOOST_REQUIRE(del);
	// Any yes, but is our case it should be DVB-T
	BOOST_REQUIRE_EQUAL(del->ice_id(), "::DVBSI::TerrestrialDelivery");
}

BOOST_AUTO_TEST_CASE( UpdateNetwork_prepopulated )
{
	// This should now run using existing transport data (although this test doesn't prove that)
	m->UpdateNetwork(FE_OFDM);
}

//
// Load in the service details
// Should give things names etc, but not add/remove
//
BOOST_AUTO_TEST_CASE( update_services )
{
	m->UpdateServices();
}

BOOST_AUTO_TEST_CASE( GetServices )
{
	auto services = s->GetServices();
	BOOST_REQUIRE_EQUAL(services.size(), 145);
	BOOST_REQUIRE_EQUAL(services[0]->ServiceId, 4170);
	BOOST_REQUIRE_EQUAL(services[0]->TransportStreamId, 4170);
	BOOST_REQUIRE_EQUAL(services[0]->Name, "BBC ONE Yorks");
	BOOST_REQUIRE_EQUAL(services[0]->DefaultAuthority, "fp.bbc.co.uk");
}

BOOST_AUTO_TEST_CASE( GetService )
{
	auto service = s->GetService(serviceId);
	BOOST_REQUIRE_EQUAL(service->ServiceId, serviceId);
	BOOST_REQUIRE_EQUAL(service->TransportStreamId, 4170);
	BOOST_REQUIRE_EQUAL(service->Name, "BBC ONE Yorks");
	BOOST_REQUIRE_EQUAL(service->DefaultAuthority, "fp.bbc.co.uk");
}

BOOST_AUTO_TEST_CASE( update_events )
{
	BOOST_CHECKPOINT("Get a DB connection for faking stuff");
	auto db = this->dataSource<RdbmsDataSource>("postgres")->getReadonly(); // Naughty, but don't want txs

	BOOST_CHECKPOINT("Write first events");
	MockTuner::SetEventsSet(0);
	m->UpdateEvents();
	auto dayOneEvents = s->EventSearch(IceUtil::Optional<std::string>(), IceUtil::Optional<int>(),
			Common::DateTime {2014, 12, 18, 3, 0}, Common::DateTime {2014, 12, 19, 3, 0});
	BOOST_REQUIRE_EQUAL(dayOneEvents.size(), 3345);
	BOOST_REQUIRE(s->GetEvent(14448, 27052));
	BOOST_REQUIRE_THROW(s->GetEvent(15856, 3591), P2PVR::NotFound);

	BOOST_CHECKPOINT("Fake some recorded stuff");
	auto keyEvent1 = s->GetEvent(25664, 55689);
	auto keyEvent2 = s->GetEvent(24256, 1014);
	db->execute("INSERT INTO schedules(repeats) VALUES(false)");
	auto irecorded = boost::shared_ptr<DB::ModifyCommand>(
			db->newModifyCommand("INSERT INTO recorded(scheduleId, eventUid) VALUES(?, ?)"));
	irecorded->bindParamI(0, 1);
	irecorded->bindParamI(1, keyEvent1->EventUid);
	irecorded->execute();
	auto irecordings = boost::shared_ptr<DB::ModifyCommand>(
			db->newModifyCommand("INSERT INTO recordings(storageAddress, guid, scheduleId, eventUid) VALUES('', '', ?, ?)"));
	irecordings->bindParamI(0, 1);
	irecordings->bindParamI(1, keyEvent2->EventUid);
	irecordings->execute();
	BOOST_REQUIRE(keyEvent1);
	BOOST_REQUIRE(keyEvent2);
	BOOST_REQUIRE(keyEvent1->Current);
	BOOST_REQUIRE_EQUAL(keyEvent1->StartTime, Common::DateTime({2014, 12, 18, 21, 0}));
	BOOST_REQUIRE(keyEvent2->Current);
	BOOST_REQUIRE_EQUAL(keyEvent2->StartTime, Common::DateTime({2014, 12, 17, 5, 30}));

	BOOST_CHECKPOINT("Write second events");
	MockTuner::SetEventsSet(1);
	m->UpdateEvents();
	BOOST_REQUIRE_THROW(s->GetEvent(14448, 27052), P2PVR::NotFound);
	BOOST_REQUIRE(s->GetEvent(15856, 3591));

	BOOST_CHECKPOINT("Check our faked stuff is still there and right");
	auto dayOneEventsOnDayTwo = s->EventSearch(IceUtil::Optional<std::string>(), IceUtil::Optional<int>(),
			Common::DateTime {2014, 12, 18, 3, 0}, Common::DateTime {2014, 12, 19, 3, 0});
	// Some datetime range overlap, but most are gone
	BOOST_REQUIRE_EQUAL(dayOneEventsOnDayTwo.size(), 373);
	BOOST_REQUIRE_EQUAL(std::count_if(dayOneEventsOnDayTwo.begin(), dayOneEventsOnDayTwo.end(),
				[](const P2PVR::EventPtr & e) {
					return (e->ServiceId == 25664 && e->EventId == 55689)
						|| (e->ServiceId == 24256 && e->EventId == 1014); }), 0);
	auto keyEventsOnDayTwo = s->GetEvents({keyEvent1->EventUid, keyEvent2->EventUid});
	BOOST_REQUIRE_EQUAL(keyEventsOnDayTwo.size(), 2);
	BOOST_REQUIRE(!keyEventsOnDayTwo[0]->Current);
	BOOST_REQUIRE(!keyEventsOnDayTwo[1]->Current);

	BOOST_REQUIRE_EQUAL(keyEvent1->Title, keyEventsOnDayTwo[0]->Title);
	BOOST_REQUIRE_EQUAL(keyEvent2->Title, keyEventsOnDayTwo[1]->Title);
}

BOOST_AUTO_TEST_CASE( test_titleFiltering )
{
	auto thingsWithNew = s->EventSearch("new", IceUtil::Optional<int>(),
			IceUtil::Optional<Common::DateTime>(), IceUtil::Optional<Common::DateTime>());
	BOOST_REQUIRE_EQUAL(0, std::count_if(thingsWithNew.begin(), thingsWithNew.end(), [](auto e) {
			return boost::algorithm::starts_with(e->Title, "New:");
		}));
}

BOOST_AUTO_TEST_SUITE_END()