gcube-cms-suite/geoportal-service/src/test/java/org/gcube/application/geoportal/service/engine/caches/Caches.java

package org.gcube.application.geoportal.service.engine.caches;

import lombok.extern.slf4j.Slf4j;
import org.gcube.application.cms.tests.TokenSetter;
import org.gcube.application.geoportal.service.BasicServiceTestUnit;
import org.gcube.application.geoportal.service.engine.mongo.ConcessioniMongoManager;
import org.gcube.application.geoportal.service.engine.providers.AbstractScopedMap;
import org.gcube.application.geoportal.service.engine.providers.TTLObject;
import org.gcube.application.geoportal.service.model.internal.faults.ConfigurationException;
import org.junit.Test;

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalUnit;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

import static org.junit.Assert.assertTrue;

@Slf4j
public class Caches extends BasicServiceTestUnit {

    @Test
    public void testCache() throws ConfigurationException {

        TokenSetter.set("/gcube/devsec/devVRE");

        Duration ttl=Duration.of(10, ChronoUnit.SECONDS);

        Duration monitorWindow=Duration.of(100, ChronoUnit.SECONDS);

        DummyCache cache= new DummyCache();
        cache.setTTL(ttl);


        Instant startMonitoring=Instant.now();

        LocalDateTime previous=cache.getObject();
        while(Duration.between(startMonitoring,Instant.now()).compareTo(monitorWindow)<0){
            LocalDateTime obj= cache.getObject();
            if(obj.equals(previous)){
                //objects are equals, TTL should be valid
                // Assert : now-creationTime < TTL
                assertTrue(Duration.between(obj,LocalDateTime.now()).compareTo(ttl)<0);
            }else {
                // different object only after TTL
                // Assert : now-creationTime < TTL
                assertTrue(Duration.between(obj,LocalDateTime.now()).compareTo(ttl)<0);
                // Assert : now-previous.creationTime > TTL
                assertTrue(Duration.between(previous,LocalDateTime.now()).compareTo(ttl)>0);
            }
            previous=obj;
            try {
                Thread.sleep(ttl.abs().dividedBy(2).toMillis());
            } catch (InterruptedException e) {
            }
        }
    }


    @Test
    public void mongoconnections() throws ConfigurationException, InterruptedException {
        TokenSetter.set(scope);
        ExecutorService service = Executors.newFixedThreadPool(1000);
        LocalDateTime start=LocalDateTime.now();
        AtomicLong executed = new AtomicLong(0);
        AtomicLong launched = new AtomicLong(0);
        //for 100 secs
        while(Duration.between(start,LocalDateTime.now()).
                compareTo(Duration.of(100, ChronoUnit.SECONDS))<0){
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        new ConcessioniMongoManager().list();
                    } catch (ConfigurationException e) {
                        e.printStackTrace();
                    }finally{
                     executed.incrementAndGet();
                    }
                }
            });
            launched.incrementAndGet();
        }

        while (!service.awaitTermination(2, TimeUnit.MINUTES)) {
            log.info("Waiting .. completed {}, out of {} ",executed.get(),launched.get());
            if(executed.get()==launched.get()) service.shutdown();
        }
    }
}