io.mongock.driver.mongodb.test.template

Class MongoLockManagerITestBase

java.lang.Object

io.mongock.driver.mongodb.test.template.util.IntegrationTestBase

io.mongock.driver.mongodb.test.template.MongoLockManagerITestBase

public abstract class MongoLockManagerITestBase
extends IntegrationTestBase

Field Summary

Fields

Modifier and Type	Field and Description
protected static long	LOCK_ACQUIRED_FOR_MILLIS
protected static String	LOCK_COLLECTION_NAME
protected static long	LOCK_QUIT_TRYING_AFTER_MILLIS
protected static long	LOCK_TRY_FRQUENCY_MILLIS
protected io.mongock.driver.api.lock.LockManager	lockManager
protected LockRepositoryWithEntity<org.bson.Document>	repository

Fields inherited from class io.mongock.driver.mongodb.test.template.util.IntegrationTestBase

CHANGELOG_COLLECTION_NAME, DEFAULT_DATABASE_NAME

Constructor Summary

Constructors

Constructor and Description
MongoLockManagerITestBase()

Method Summary

Modifier and Type	Method and Description
protected abstract void	initializeRepository()
void	releaseLockShouldBeIdempotent_WhenHeldByOtherOwner()
void	releaseLockShouldBeIdempotent_WhenHeldBySameOwner()
void	releaseLockShouldNotThrowAnyException_WhenLockNoPresent()
void	setUp()
void	shouldAcquireLock_WhenHeld_IfSameOwner()
void	shouldAcquireLock_WhenHeldByOther_IfExpired()
void	shouldEnsureLock_WhenAcquiredPreviously_IfSameOwner()
void	shouldEnsureLock_WhenHeldBySame_IfExpiredInDB() If it's expired, the lock should be ensured because no one has requested, so it should be extended for the same owner
void	shouldEnsureLock_WhenHeldBySame_IfNotExpiredInDB() If it's not expired, the lock is ensured because still belongs to the owner
void	shouldFinallyAcquireLock_WhenTheLockIsHeldByOther_IfTheTimeItWIllBeReTryingIsLongerThanTheCurrentLockExpireTime()
void	shouldNotAcquireLock_WhenHeldByOther_IfExpiresAtIsGreaterThanMaxWaitTime()
void	shouldNotEnsureLock_WhenHeldByOther_IfNotExpiredInDB()
void	shouldNotEnsureLock_WhenHeldByOtherAndExpiredInDB_ifHasNotBeenRequestedPreviously()
void	shouldNotReleaseLock_IfHeldByOtherOwner()
void	shouldReleaseLock_WhenHeldBySameOwner()
void	shouldThrowException_WhenEnsuring_IfNotAcquiredFirst()
void	tearDown()

Methods inherited from class io.mongock.driver.mongodb.test.template.util.IntegrationTestBase

getAdapter, getDataBase, getDefaultAdapter, getMongoClient

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOCK_COLLECTION_NAME

protected static final String LOCK_COLLECTION_NAME

See Also:

Constant Field Values

LOCK_ACQUIRED_FOR_MILLIS

protected static final long LOCK_ACQUIRED_FOR_MILLIS

See Also:

Constant Field Values

LOCK_QUIT_TRYING_AFTER_MILLIS

protected static final long LOCK_QUIT_TRYING_AFTER_MILLIS

See Also:

Constant Field Values

LOCK_TRY_FRQUENCY_MILLIS

protected static final long LOCK_TRY_FRQUENCY_MILLIS

See Also:

Constant Field Values

lockManager

protected io.mongock.driver.api.lock.LockManager lockManager

repository

protected LockRepositoryWithEntity<org.bson.Document> repository

Constructor Detail

MongoLockManagerITestBase

public MongoLockManagerITestBase()

Method Detail

setUp

@BeforeEach
public void setUp()

tearDown

@AfterEach
public void tearDown()

shouldAcquireLock_WhenHeld_IfSameOwner

@Test
public void shouldAcquireLock_WhenHeld_IfSameOwner()
                                                  throws io.mongock.driver.api.lock.LockCheckException

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldAcquireLock_WhenHeldByOther_IfExpired

@Test
public void shouldAcquireLock_WhenHeldByOther_IfExpired()
                                                       throws io.mongock.driver.api.lock.LockCheckException

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldFinallyAcquireLock_WhenTheLockIsHeldByOther_IfTheTimeItWIllBeReTryingIsLongerThanTheCurrentLockExpireTime

@Test
public void shouldFinallyAcquireLock_WhenTheLockIsHeldByOther_IfTheTimeItWIllBeReTryingIsLongerThanTheCurrentLockExpireTime()
                                                                                                                           throws io.mongock.driver.api.lock.LockCheckException

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldNotAcquireLock_WhenHeldByOther_IfExpiresAtIsGreaterThanMaxWaitTime

@Test
public void shouldNotAcquireLock_WhenHeldByOther_IfExpiresAtIsGreaterThanMaxWaitTime()
                                                                                    throws io.mongock.driver.api.lock.LockCheckException

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldThrowException_WhenEnsuring_IfNotAcquiredFirst

@Test
public void shouldThrowException_WhenEnsuring_IfNotAcquiredFirst()
                                                                throws io.mongock.driver.api.lock.LockCheckException

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldEnsureLock_WhenHeldBySame_IfNotExpiredInDB

@Test
public void shouldEnsureLock_WhenHeldBySame_IfNotExpiredInDB()
                                                            throws io.mongock.driver.api.lock.LockCheckException

If it's not expired, the lock is ensured because still belongs to the owner

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldEnsureLock_WhenHeldBySame_IfExpiredInDB

@Test
public void shouldEnsureLock_WhenHeldBySame_IfExpiredInDB()
                                                         throws io.mongock.driver.api.lock.LockCheckException

If it's expired, the lock should be ensured because no one has requested, so it should be extended for the same owner

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldEnsureLock_WhenAcquiredPreviously_IfSameOwner

@Test
public void shouldEnsureLock_WhenAcquiredPreviously_IfSameOwner()
                                                               throws io.mongock.driver.api.lock.LockCheckException

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldNotEnsureLock_WhenHeldByOtherAndExpiredInDB_ifHasNotBeenRequestedPreviously

@Test
public void shouldNotEnsureLock_WhenHeldByOtherAndExpiredInDB_ifHasNotBeenRequestedPreviously()
                                                                                             throws io.mongock.driver.api.lock.LockCheckException

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldNotEnsureLock_WhenHeldByOther_IfNotExpiredInDB

@Test
public void shouldNotEnsureLock_WhenHeldByOther_IfNotExpiredInDB()
                                                                throws io.mongock.driver.api.lock.LockCheckException

Throws:

io.mongock.driver.api.lock.LockCheckException

shouldReleaseLock_WhenHeldBySameOwner

@Test
public void shouldReleaseLock_WhenHeldBySameOwner()

shouldNotReleaseLock_IfHeldByOtherOwner

@Test
public void shouldNotReleaseLock_IfHeldByOtherOwner()

releaseLockShouldBeIdempotent_WhenHeldBySameOwner

@Test
public void releaseLockShouldBeIdempotent_WhenHeldBySameOwner()

releaseLockShouldBeIdempotent_WhenHeldByOtherOwner

@Test
public void releaseLockShouldBeIdempotent_WhenHeldByOtherOwner()

releaseLockShouldNotThrowAnyException_WhenLockNoPresent

@Test
public void releaseLockShouldNotThrowAnyException_WhenLockNoPresent()

initializeRepository

protected abstract void initializeRepository()