In test scenarios or lightweight application components, there is a need for a simple, thread-safe, in-memory data store that can temporarily hold a limited number of objects. The store should be easy to use, avoid external dependencies (e.g., databases), support generation and use of unique identifiers as keys, and automatically evict the oldest entries when a predefined capacity is exceeded. This enables predictable memory usage while providing fast access to recently stored data.

Solution

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MemoryStore<T> {

    private final Lock lock = new ReentrantLock();
    private final int maxElements;

    private final Map<String, T> data = new LinkedHashMap<>() {
        // called during put and ensures the map doesn't grow
        @Override
        protected boolean removeEldestEntry(Map.Entry<String, T> eldest) {
            return size() > maxElements;
        }
    };

    public MemoryStore(int maxElements) {
        if (maxElements < 1) {
            throw new IllegalArgumentException("maxElements must be > 1");
        }
        this.maxElements = maxElements;
    }
    
    public void store(T value) {
        this.store(UUID.randomUUID().toString(), value);
    }

    public void store(String key, T value) {
        lock.lock();
        try {
            data.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    public T get(String key) {
        lock.lock();
        try {
            return data.get(key);
        } finally {
            lock.unlock();
        }
    }
    
    public int size() {
        lock.lock();
        try {
            return data.size();
        } finally {
            lock.unlock();
        }
    }
    
    public LinkedHashMap<String, T> data() {
        lock.lock();
        try {
            return new LinkedHashMap<>(this.data);
        } finally {
            lock.unlock();
        }
    }
}

As soon we have timers in our project they may cause issues in our integration tests, as they start running in the most undesirable situation. E.g. during the trigger a specific function which would usually be triggered by the timer.

Solution 1

If we want to disable the timers even the construction of the beans we have to tell spring not event to lead the beans. To achieve that we require first some configuration. As we might have more than one timer it is easier to work with an own meta annotaton

Own Meta annotation

@ConditionalOnProperty(name = "my-project.timers-enabled", 
                       havingValue = "true", 
                       matchIfMissing = true)
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
public @interface TimersEnabled {

}

Use the annotation

@TimersEnabled
@Component
@RequiredArgsConstructor
public class MyTimer {
    
    private final MyService service;

    @Scheduled(fixedDelay = 30, timeUnit = TimeUnit.SECONDS)
    void scheduledMethod() {
        service.doStuff();
    }
}

Disable the timers

e.g. in the application.yml of your test resources:

my-project:
  timers-enabled: false

The timers will be disabled for any value other then true.

Solution 2

In the easiest scenario if it is a in memory Spring test we can just mock the ScheduledExecutorService and so stop any @Scheduled job executions.

    @MockBean
    private ScheduledExecutorService schedulerService;

Often we write JPA Entity classes an have to ensure in a larger team that refactoring doesn’t create performance problems or logical errors in the entity model usual problems are:

• Missing fetch joins in Queries
  • Which leads to slow fetch joins
• Wrong direction of Entity relations
  • which leads to updates after inserts
  • or even to deletes and reinserts of data
• Wrong transaction boundaries
  • Which leads to multiple transactions for one logical business operation

@Component
public class HibernateAsserts {
  private final Statistics statistics;

  public HibernateAsserts(EntityManager entityManager) {
    try (Session session = entityManager.unwrap(org.hibernate.Session.class)) {
      @SuppressWarnings("resource")
      SessionFactory factory = session.getSessionFactory();
      factory.getStatistics().setStatisticsEnabled(true);
      statistics = factory.getStatistics();
    }
  }
  
  public HibernateAsserts assertTrxCount(int expected) {
    long value = statistics.getTransactionCount();
    if (value != expected) {
      logSummary();
      fail("Expected " + expected + " TransactionCount, but found " + value);
    }
    return this;
  }
  
  public HibernateAsserts assertInsertCount(int expected) {
    long value = statistics.getEntityInsertCount();
    if (value != expected) {
      logSummary();
      fail("Expected " + expected + " EntityInsertCount, but found " + value);
    }
    return this;
  }

  public void reset() {
    statistics.clear();
  }

  public void logSummary() {
    statistics.logSummary();
  }
}

In your test

@SpringBootTest
class MyTestClassTest {

  @Autowired private SubjectUnderTest subject;
  @Autowired private HibernateAsserts hibernateAsserts;
  
  @Test
  void textMyBusinessMethod() {
    // GIVEN
    // custom data setup for the test

    // WHEN
    hibernateAsserts.reset(); // ensure the setup is not in the stats
    subject.runBusinessMethod();
    
    // THEN
    // any business asserts
    hibernateAsserts
      .assertTrxCount(1)
      .assertInsertCount(1);
  }
}

Caused by: java.lang.IllegalStateException: No Scope registered for scope 'session'
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:334)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:194)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.findAutowireCandidates(DefaultListableBeanFactory.java:1120)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1044)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:942)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:533)
	... 28 common frames omitted

You can easily have all needed web scopes in your unit test by adding the following annotation to your Tests: @WebAppConfiguration.

Now Web Scopes like:

@Bean(name = "foo") @Scope("session")
public String getString()

will work.

The Problem

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'demo.MyApplicationTests': Injection of autowired dependencies failed; 
	nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private java.lang.String demo.MyApplicationTests.url; 
	nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'my.url' in string value "${my.url}" at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:334)
		~[spring-beans-4.1.7.RELEASE.jar:4.1.7.RELEASE] 
	Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'my.url' in string value "${my.url}" at org.springframework.util.PropertyPlaceholderHelper.parseStringValue(PropertyPlaceholderHelper.java:174) 
		~[spring-core-4.1.7.RELEASE.jar:4.1.7.RELEASE]

Configuration was not available in my Unit tests but it was working fine in the normal application. I spend a lot of time searching but without real good post concerning this issue.

This code already wasn’t working:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = MyWebappApplication.class)
@WebAppConfiguration
public class MyApplicationTests {
    @Value("${my.url}")
    String url;

    @Test
    public void test() {
        System.out.println(url);
    }
}

Even if my application.yml / application.properties was looking good:

my:
   url: any kind of String we inject

The solution

Now here the working sample, do you see the difference?

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = MyWebappApplication.class)
@WebAppConfiguration
public class MyApplicationTests {
    @Value("${my.url}")
    String url;

    @Test
    public void test() {
        System.out.println(url);
    }
}

Yes it is just the @SpringApplicationConfiguration instead of the @ContextConfiguration annotation. (Even if the first is itself just a meta-annotation of the second.) If you look into this new annotation you will find that it uses a different loader class, which makes the difference.

@ContextConfiguration(loader = SpringApplicationContextLoader.class)
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface SpringApplicationConfiguration

That’s the trick. Having it in place the Spring Application configuration is successfully parsed an available in your unit test. Doesn’t matter if YAML or just property file.