infrastructure-tests/src/test/java/org/gcube/accounting/documentstore/persistence/PersistenceBackendTest.java

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

import java.util.Calendar;
import java.util.concurrent.TimeUnit;

import org.gcube.accounting.datamodel.BasicUsageRecord;
import org.gcube.accounting.datamodel.UsageRecord;
import org.gcube.accounting.datamodel.basetypes.TestUsageRecord;
import org.gcube.accounting.testutility.TestUtility;
import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
import org.gcube.documentstore.exception.InvalidValueException;
import org.gcube.utils.StressTestUtility;
import org.gcube.utils.TestOperation;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Luca Frosini (ISTI - CNR) http://www.lucafrosini.com/
 *
 */
public class PersistenceBackendTest {
	
	private static Logger logger = LoggerFactory.getLogger(PersistenceBackendTest.class);
	
	public static final String[] SCOPES = new String[]{"/gcube", "/gcube/devNext"};
	public static final String GCUBE_SCOPE = SCOPES[0];
	public static final String GCUBE_DEVNEXT_SCOPE = SCOPES[1];
	
	public static final long timeout = 5000;
	public static final TimeUnit timeUnit = TimeUnit.MILLISECONDS;
	
	
	@Before
	public void before() throws Exception{
		SecurityTokenProvider.instance.set(TestUtility.TOKEN);
	}
	
	@After
	public void after() throws Exception{
		SecurityTokenProvider.instance.reset();
	}
	
	public static PersistenceBackend getPersistence(){
		PersistenceBackendFactory.setFallbackLocation(null);
		return PersistenceBackendFactory.getPersistenceBackend(BasicUsageRecord.getScopeFromToken());
	}
	
	@Test
	public void singleTestNoScope() throws Exception {
		PersistenceBackendFactory.setFallbackLocation(null);
		final PersistenceBackend persistence = PersistenceBackendFactory.getPersistenceBackend(null);
		Assert.assertTrue(persistence instanceof FallbackPersistenceBackend);
		StressTestUtility.stressTest(new TestOperation() {
			@Override
			public void operate(int i) {
				UsageRecord usageRecord;
				try {
					usageRecord = TestUsageRecord.createTestServiceUsageRecordExplicitScope();
					persistence.accountValidateAggregate(usageRecord, true, false);
				} catch (InvalidValueException e) {
					throw new RuntimeException(e);
				}
			}
		}, 1);
		
		persistence.flush(timeout, timeUnit);
	}
	
	@Test
	public void singleTest() throws Exception {
		final PersistenceBackend persistence = getPersistence();
		StressTestUtility.stressTest(new TestOperation() {
			@Override
			public void operate(int i) {
				UsageRecord usageRecord = TestUsageRecord.createTestServiceUsageRecordAutomaticScope();
				persistence.accountValidateAggregate(usageRecord, true, false);
			}
		}, 1);
		
		persistence.flush(timeout, timeUnit);
	}
	
	@Test
	public void stressTestNoAggregation() throws Exception {
		final PersistenceBackend persistence = getPersistence();
		StressTestUtility.stressTest(new TestOperation() {
			@Override
			public void operate(int i) {
				UsageRecord usageRecord = TestUsageRecord.createTestServiceUsageRecordAutomaticScope();
				persistence.accountValidateAggregate(usageRecord, true, false);
			}
		});
	}
	
	@Test
	public void stressTestWithAggregation() throws Exception {
		final PersistenceBackend persistence = getPersistence();
		
		StressTestUtility.stressTest(new TestOperation() {
			@Override
			public void operate(int i) throws Exception {
				UsageRecord usageRecord = TestUsageRecord.createTestServiceUsageRecordAutomaticScope();
				persistence.account(usageRecord);
			}
		});
		persistence.flush(timeout, timeUnit);
	}
	
	
	@Test
	public void testScopeRecheck() throws Exception {
		PersistenceBackendFactory.setFallbackLocation(null);
		logger.debug("Going to check First Time");
		PersistenceBackend first = PersistenceBackendFactory.getPersistenceBackend(BasicUsageRecord.getScopeFromToken());
		logger.debug("First {} : {}", PersistenceBackend.class.getSimpleName(), first);
		Long firstCheck = PersistenceBackendFactory.getFallbackLastCheck(BasicUsageRecord.getScopeFromToken());
		logger.debug("First Check Time {}", firstCheck);
		
		long startTime = Calendar.getInstance().getTimeInMillis();
		long endTime = startTime;
		
		while(endTime <=  (startTime + (PersistenceBackendFactory.FALLBACK_RETRY_TIME + 100))){
			endTime = Calendar.getInstance().getTimeInMillis();
		}

		logger.debug("Going to check Second Time");
		PersistenceBackend second = PersistenceBackendFactory.getPersistenceBackend(BasicUsageRecord.getScopeFromToken());
		logger.debug("Second {} : {}", PersistenceBackend.class.getSimpleName(), second);
		Long secondCheck = PersistenceBackendFactory.getFallbackLastCheck(BasicUsageRecord.getScopeFromToken());
		logger.debug("Second Check Time {}", secondCheck);
		
		Assert.assertNotEquals(firstCheck, secondCheck);
		Assert.assertEquals(first, second);
	}
	
}