document-store-lib-postgresql/src/test/java/org/gcube/documentstore/persistence/PersistencePostgreSQLTest.java

/**
 * 
 */
package org.gcube.documentstore.persistence;

import org.gcube.accounting.datamodel.UsageRecord;
import org.gcube.accounting.datamodel.aggregation.AggregatedJobUsageRecord;
import org.gcube.accounting.datamodel.aggregation.AggregatedPortletUsageRecord;
import org.gcube.accounting.datamodel.aggregation.AggregatedServiceUsageRecord;
import org.gcube.accounting.datamodel.aggregation.AggregatedStorageStatusRecord;
import org.gcube.accounting.datamodel.aggregation.AggregatedStorageUsageRecord;
import org.gcube.accounting.datamodel.usagerecords.JobUsageRecord;
import org.gcube.accounting.datamodel.usagerecords.PortletUsageRecord;
import org.gcube.accounting.datamodel.usagerecords.ServiceUsageRecord;
import org.gcube.accounting.datamodel.usagerecords.StorageStatusRecord;
import org.gcube.accounting.datamodel.usagerecords.StorageUsageRecord;
import org.gcube.common.authorization.client.exceptions.ObjectNotFound;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Luca Frosini (ISTI - CNR)
 */
public class PersistencePostgreSQLTest extends ContextTest {

	private static final Logger logger = LoggerFactory.getLogger(PersistencePostgreSQLTest.class);

	/*
	protected UsageRecord getTestServiceUsageRecord() throws Exception {
		AggregatedServiceUsageRecord serviceUsageRecord = new AggregatedServiceUsageRecord();
		serviceUsageRecord.setAggregated(true);
		
		Calendar creationTime = Calendar.getInstance();
		serviceUsageRecord.setCreationTime(creationTime);
		
		Calendar startTime = Calendar.getInstance();
		serviceUsageRecord.setStartTime(startTime);
		
		serviceUsageRecord.setCalledMethod("createResource");
		serviceUsageRecord.setCallerHost("localhost");
		serviceUsageRecord.setHost("localhost");
		serviceUsageRecord.setConsumerId("luca.frosini");
		serviceUsageRecord.setCallerQualifier("TOKEN");
		serviceUsageRecord.setDuration((long) 100);
		
		serviceUsageRecord.setMaxInvocationTime((long) 150);
		serviceUsageRecord.setMinInvocationTime((long) 50);
		serviceUsageRecord.setOperationCount(9);
		serviceUsageRecord.setOperationResult(OperationResult.SUCCESS);
		serviceUsageRecord.setScope(ContextTest.getCurrentContextFullName());
		
		Calendar endTime = Calendar.getInstance();
		endTime.add(Calendar.MINUTE, 5);
		serviceUsageRecord.setEndTime(endTime);
		
		serviceUsageRecord.setServiceClass("information-system");
		serviceUsageRecord.setServiceName("resource-registry");
		
		return serviceUsageRecord;
	}
	*/
	protected AggregatedJobUsageRecord getTestAggregatedJobUsageRecord() throws Exception {
		JobUsageRecord jobUsageRecord = TestUsageRecord.createTestJobUsageRecord();
		AggregatedJobUsageRecord aggregatedJobUsageRecord = new AggregatedJobUsageRecord(jobUsageRecord);
		return aggregatedJobUsageRecord;
	}
	
	protected AggregatedPortletUsageRecord getTestAggregatedPortletUsageRecord() throws Exception {
		PortletUsageRecord portletUsageRecord = TestUsageRecord.createTestPortletUsageRecord();
		AggregatedPortletUsageRecord aggregatedPortletUsageRecord = new AggregatedPortletUsageRecord(portletUsageRecord);
		return aggregatedPortletUsageRecord;
	}
	
	protected AggregatedServiceUsageRecord getTestAggregatedServiceUsageRecord() throws Exception {
		ServiceUsageRecord serviceUsageRecord = TestUsageRecord.createTestServiceUsageRecord();
		AggregatedServiceUsageRecord aggregatedServiceUsageRecord = new AggregatedServiceUsageRecord(serviceUsageRecord);
		return aggregatedServiceUsageRecord;
	}
	
	protected AggregatedStorageStatusRecord getTestAggregatedStorageStatusRecord() throws Exception {
		StorageStatusRecord storageStatusRecord = TestUsageRecord.createTestStorageVolumeUsageRecord();
		AggregatedStorageStatusRecord aggregatedStorageStatusRecord = new AggregatedStorageStatusRecord(storageStatusRecord);
		return aggregatedStorageStatusRecord;
	}
	
	protected AggregatedStorageUsageRecord getTestAggregatedStorageUsageRecord() throws Exception {
		StorageUsageRecord storageUsageRecord = TestUsageRecord.createTestStorageUsageRecord();
		AggregatedStorageUsageRecord aggregatedStorageUsageRecord = new AggregatedStorageUsageRecord(storageUsageRecord);
		return aggregatedStorageUsageRecord;
	}
		
	@Test
	public void testSQLStatementString() throws Exception {
		PersistencePostgreSQL persistencePostgreSQL = new PersistencePostgreSQL();
		
		UsageRecord usageRecord = getTestAggregatedJobUsageRecord();
		String sql = persistencePostgreSQL.getSQLInsertCommand(usageRecord);
		logger.debug(sql);
		
		usageRecord = getTestAggregatedPortletUsageRecord();
		sql = persistencePostgreSQL.getSQLInsertCommand(usageRecord);
		logger.debug(sql);
		
		usageRecord = getTestAggregatedServiceUsageRecord();
		sql = persistencePostgreSQL.getSQLInsertCommand(usageRecord);
		logger.debug(sql);
		
		usageRecord = getTestAggregatedStorageStatusRecord();
		sql = persistencePostgreSQL.getSQLInsertCommand(usageRecord);
		logger.debug(sql);
		
		usageRecord = getTestAggregatedStorageUsageRecord();
		sql = persistencePostgreSQL.getSQLInsertCommand(usageRecord);
		logger.debug(sql);
	}
	
	@Test
	public void persistenceIsPostgreSQL() throws ObjectNotFound, Exception {
		logger.debug("Going to check if the Persistence is CouchBase");
		PersistenceBackendFactory.setFallbackLocation(null);
		String context = ContextTest.getCurrentContextFullName();
		FallbackPersistenceBackend fallbackPersistenceBackend = PersistenceBackendFactory.createFallback(context);
		
		PersistenceBackend persistenceBackend = PersistenceBackendFactory.rediscoverPersistenceBackend(fallbackPersistenceBackend, context);
		
		Assert.assertTrue(persistenceBackend instanceof PersistencePostgreSQL);
		
	}
	
	
	@Test
	public void testInsertRecords() throws ObjectNotFound, Exception {
		PersistenceBackendFactory.setFallbackLocation(null);
		String context = ContextTest.getCurrentContextFullName();
		FallbackPersistenceBackend fallbackPersistenceBackend = PersistenceBackendFactory.createFallback(context);
		PersistenceBackend persistenceBackend = PersistenceBackendFactory.rediscoverPersistenceBackend(fallbackPersistenceBackend, context);
		Assert.assertTrue(persistenceBackend instanceof PersistencePostgreSQL);
		PersistencePostgreSQL persistencePostgreSQL = (PersistencePostgreSQL) persistenceBackend;
		persistencePostgreSQL.newConnection();
		for(int i=0; i<10; i++) {
			UsageRecord usageRecord = getTestAggregatedJobUsageRecord();
			persistencePostgreSQL.insert(usageRecord);
			
			usageRecord = getTestAggregatedPortletUsageRecord();
			persistencePostgreSQL.insert(usageRecord);
			
			usageRecord = getTestAggregatedServiceUsageRecord();
			persistencePostgreSQL.insert(usageRecord);
			
			usageRecord = getTestAggregatedStorageStatusRecord();
			persistencePostgreSQL.insert(usageRecord);
			
			
			usageRecord = getTestAggregatedStorageUsageRecord();
			persistencePostgreSQL.insert(usageRecord);
			
		}
		persistencePostgreSQL.commitAndClose();
	}
	
	
}