$lang['tuto'] = "ਟਿ utorial ਟੋਰਿਅਲਸ"; ?> ਕੁਆਰਕਸ ਟੈਸਟਾਂ, ਟੈਸਟ

ਕੁਆਰਕਸ ਟੈਸਟਾਂ, ਟੈਸਟ ਕੰਟੇਨਰਾਂ, ਅਤੇ ਲਿਕਵੀਬੇਸ ਏਕੀਕਰਣ ਨਾਲ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ

Temp mail SuperHeros
ਕੁਆਰਕਸ ਟੈਸਟਾਂ, ਟੈਸਟ ਕੰਟੇਨਰਾਂ, ਅਤੇ ਲਿਕਵੀਬੇਸ ਏਕੀਕਰਣ ਨਾਲ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ
ਕੁਆਰਕਸ ਟੈਸਟਾਂ, ਟੈਸਟ ਕੰਟੇਨਰਾਂ, ਅਤੇ ਲਿਕਵੀਬੇਸ ਏਕੀਕਰਣ ਨਾਲ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ

Quarkus ਅਤੇ Liquibase ਨਾਲ ਟੈਸਟਿੰਗ ਵਿੱਚ ਚੁਣੌਤੀਆਂ ਨੂੰ ਪਾਰ ਕਰਨਾ

ਆਧੁਨਿਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਸਥਿਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਏਕੀਕਰਣ ਟੈਸਟਾਂ ਨੂੰ ਲਿਖਣਾ ਜ਼ਰੂਰੀ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਤਕਨਾਲੋਜੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਜਿਵੇਂ ਕਿ ਕੁਆਰਕਸ, ਟੈਸਟ ਕੰਟੇਨਰ, ਅਤੇ Liquibase. ਹਾਲਾਂਕਿ, ਪ੍ਰਕਿਰਿਆ ਹਮੇਸ਼ਾਂ ਸਿੱਧੀ ਨਹੀਂ ਹੁੰਦੀ. ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਅਕਸਰ ਅਚਾਨਕ ਚੁਣੌਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਸਰੋਤ ਵਿਵਾਦ ਜਾਂ ਗਲਤ ਸੰਰਚਨਾ।

ਟੈਸਟਾਂ ਵਿੱਚ ਡੇਟਾਬੇਸ ਮਾਈਗ੍ਰੇਸ਼ਨ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਆਮ ਮੁੱਦਾ ਪੈਦਾ ਹੁੰਦਾ ਹੈ। Liquibase ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਘੰਟੇ ਬਿਤਾਉਣ ਦੀ ਕਲਪਨਾ ਕਰੋ, ਸਿਰਫ ਇਹ ਮਹਿਸੂਸ ਕਰਨ ਲਈ ਕਿ ਤੁਹਾਡੀਆਂ ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਇੱਕ ਡੇਟਾਬੇਸ ਕੰਟੇਨਰ 'ਤੇ ਚੱਲਦੀਆਂ ਹਨ, ਜਦੋਂ ਕਿ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਦੂਜੇ ਨਾਲ ਜੁੜਦੀ ਹੈ। ਨਿਰਾਸ਼ਾਜਨਕ, ਸੱਜਾ? 🐛

ਇਸ ਪੋਸਟ ਵਿੱਚ, ਮੈਂ ਇੱਕ ਸਮਾਨ ਚੁਣੌਤੀ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਨ ਲਈ ਆਪਣਾ ਅਨੁਭਵ ਸਾਂਝਾ ਕਰਾਂਗਾ: ਟੈਸਟ ਕੰਟੇਨਰਾਂ ਅਤੇ ਲਿਕਵੀਬੇਸ ਦੇ ਨਾਲ ਇੱਕ ਕੁਆਰਕਸ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਏਕੀਕਰਣ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਣਾ। ਅਜੀਬ ਵਿਵਹਾਰ ਜੋ ਮੈਂ ਦੇਖਿਆ ਉਹ ਇਹ ਸੀ ਕਿ ਮਲਟੀਪਲ ਡੇਟਾਬੇਸ ਕੰਟੇਨਰ ਬਣਾਏ ਜਾ ਰਹੇ ਸਨ, ਜਿਸ ਨਾਲ ਫੇਲ੍ਹ ਹੋਏ ਟੈਸਟ ਹੋਏ। ਇਹ ਪੋਸਟ ਇਸ ਮੁੱਦੇ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਅਤੇ ਹੱਲ ਕਰਨ ਵਿੱਚ ਡੁੱਬੇਗੀ।

ਜੇ ਤੁਸੀਂ ਕਦੇ ਵੀ ਅਜਿਹੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕੀਤਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਕੱਲੇ ਨਹੀਂ ਹੋ। ਅਸੀਂ ਕਦਮ-ਦਰ-ਕਦਮ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ ਕਿ ਮੂਲ ਕਾਰਨ ਦੀ ਪਛਾਣ ਕਿਵੇਂ ਕੀਤੀ ਜਾਵੇ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾਵੇ ਕਿ ਤੁਹਾਡੇ ਟੈਸਟ ਨਿਰਵਿਘਨ ਕੰਮ ਕਰਦੇ ਹਨ। ਇੱਕ ਕਾਰਜਸ਼ੀਲ ਉਦਾਹਰਣ ਅਤੇ ਵਿਹਾਰਕ ਸੁਝਾਵਾਂ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਆਮ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਣ ਅਤੇ ਮਜ਼ਬੂਤ ​​ਏਕੀਕਰਣ ਟੈਸਟ ਬਣਾਉਣ ਦੇ ਯੋਗ ਹੋਵੋਗੇ। 🚀

ਹੁਕਮ ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
QuarkusTestResource ਕੁਆਰਕਸ ਟੈਸਟਾਂ ਦੌਰਾਨ ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ, PostgreSQLTestResource ਵਰਗੇ ਕਸਟਮ ਟੈਸਟ ਸਰੋਤ ਲਾਈਫਸਾਈਕਲ ਮੈਨੇਜਰ ਨੂੰ ਰਜਿਸਟਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
withReuse(true) ਕਈ ਟੈਸਟਾਂ ਵਿੱਚ ਕੰਟੇਨਰ ਦੀ ਮੁੜ ਵਰਤੋਂ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ ਇੱਕ ਟੈਸਟਕੰਟੇਨਰਸ ਵਿਧੀ, ਇੱਕ ਡੇਟਾਬੇਸ ਕੰਟੇਨਰ ਦੀ ਮੁੜ ਵਰਤੋਂ ਕਰਨ ਵੇਲੇ ਸ਼ੁਰੂਆਤੀ ਸਮੇਂ ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ।
QuarkusTestProfile ਖਾਸ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨ ਲਈ ਇੱਕ ਕਸਟਮ ਟੈਸਟ ਪ੍ਰੋਫਾਈਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਵੱਖਰੀ ਸੰਰਚਨਾ ਫਾਈਲ ਮਾਰਗ ਜਾਂ ਪ੍ਰੋਫਾਈਲ-ਵਿਸ਼ੇਸ਼ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨਾ।
withDatabaseName PostgreSQL ਕੰਟੇਨਰ ਦੇ ਅੰਦਰ ਬਣਾਏ ਗਏ ਡੇਟਾਬੇਸ ਦਾ ਨਾਮ ਸੈੱਟ ਕਰਦਾ ਹੈ। ਟੈਸਟ-ਵਿਸ਼ੇਸ਼ ਡਾਟਾਬੇਸ ਉਦਾਹਰਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਉਪਯੋਗੀ।
given() RestAssured ਤੋਂ ਇੱਕ ਵਿਧੀ HTTP ਬੇਨਤੀਆਂ ਭੇਜਣ ਲਈ ਟੈਸਟਿੰਗ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਅੰਤਮ ਬਿੰਦੂਆਂ ਅਤੇ ਜਵਾਬ ਡੇਟਾ ਦੀ ਪ੍ਰਮਾਣਿਕਤਾ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।
then() ਜਵਾਬ ਸਥਿਤੀ ਜਾਂ ਬਾਡੀ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ RestAssured ਵਿੱਚ ਇੱਕ ਬੇਨਤੀ ਤੋਂ ਬਾਅਦ ਜੰਜ਼ੀਰਾਂ ਨਾਲ ਬੰਨ੍ਹਿਆ ਗਿਆ। ਉਦਾਹਰਨ ਲਈ, ਸਥਿਤੀ ਕੋਡ ਜਾਂ ਡੇਟਾ ਫਾਰਮੈਟਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ।
Map.of ਜਾਵਾ 9 ਵਿੱਚ ਇੱਕ ਸੰਖੇਪ ਰੂਪ ਵਿੱਚ ਅਟੱਲ ਨਕਸ਼ੇ ਬਣਾਉਣ ਲਈ ਪੇਸ਼ ਕੀਤੀ ਗਈ ਇੱਕ ਵਿਧੀ, ਇੱਥੇ ਟੈਸਟ ਪ੍ਰੋਫਾਈਲ ਲਈ ਸੰਰਚਨਾ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।
getJdbcUrl PostgreSQL TestContainer ਲਈ JDBC ਕਨੈਕਸ਼ਨ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਸਹੀ ਕੰਟੇਨਰ ਨਾਲ ਜੁੜਦੀ ਹੈ।
@QuarkusTest ਕੁਆਰਕਸ ਫਰੇਮਵਰਕ ਵਾਤਾਵਰਣ ਵਿੱਚ ਇੱਕ ਟੈਸਟ ਚਲਾਉਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਇੱਕ ਐਨੋਟੇਸ਼ਨ, ਟੈਸਟਾਂ ਵਿੱਚ ਨਿਰਭਰਤਾ ਟੀਕੇ ਅਤੇ ਕੁਆਰਕਸ-ਵਿਸ਼ੇਸ਼ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।
@TestProfile ਇੱਕ ਟੈਸਟ ਕਲਾਸ ਨੂੰ ਇੱਕ ਖਾਸ ਕੁਆਰਕਸ ਟੈਸਟ ਪ੍ਰੋਫਾਈਲ ਨਾਲ ਜੋੜਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ ਕਿ ਟੈਸਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਉਚਿਤ ਸੰਰਚਨਾ ਲਾਗੂ ਕੀਤੀ ਗਈ ਹੈ।

Quarkus ਵਿੱਚ Liquibase ਅਤੇ TestContainers ਦੇ ਟਕਰਾਅ ਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕੀਤਾ ਜਾਵੇ

ਪਹਿਲਾਂ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਕੁਆਰਕਸ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਏਕੀਕਰਣ ਟੈਸਟਿੰਗ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਇੱਕ ਵਿਹਾਰਕ ਪਹੁੰਚ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੀਆਂ ਹਨ। ਟੈਸਟ ਕੰਟੇਨਰ ਅਤੇ Liquibase. ਮੁੱਖ ਟੀਚਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਉਸੇ ਡੇਟਾਬੇਸ ਕੰਟੇਨਰ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਦੀ ਹੈ ਜਿੱਥੇ Liquibase ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਕਸਟਮ ਲਾਈਫਸਾਈਕਲ ਮੈਨੇਜਰ, `PostgreSQLTestResource` ਬਣਾ ਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਇੱਕ PostgreSQL ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਅਤੇ ਟੈਸਟ ਦੇ ਅਧੀਨ ਕੁਆਰਕਸ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇਸਦੇ ਸੰਰਚਨਾ ਵੇਰਵੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਹ ਅਣਜਾਣੇ ਵਿੱਚ ਇੱਕ ਦੂਜਾ ਕੰਟੇਨਰ ਬਣਾਉਣ ਲਈ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਆਮ ਨੁਕਸਾਨ ਤੋਂ ਬਚਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਅਸੰਗਤਤਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। 🚀

`withReuse(true)` ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ PostgreSQL ਕੰਟੇਨਰ ਟੈਸਟਾਂ ਦੇ ਵਿਚਕਾਰ ਕਿਰਿਆਸ਼ੀਲ ਰਹਿੰਦਾ ਹੈ, ਹਰੇਕ ਟੈਸਟ ਕੇਸ ਲਈ ਰੀਸਟਾਰਟ ਕਰਨ ਵਾਲੇ ਕੰਟੇਨਰਾਂ ਦੇ ਓਵਰਹੈੱਡ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ ਜਿੱਥੇ ਕਈ ਟੈਸਟ ਕਲਾਸਾਂ ਨੂੰ ਇੱਕੋ ਡੇਟਾਬੇਸ ਸਥਿਤੀ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਕਸਟਮ 'TestProfileResolver' ਕੁਆਰਕਸ ਨੂੰ ਸਹੀ ਸੰਰਚਨਾ ਫਾਈਲ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਕੇ ਅਤੇ ਟੈਸਟ ਕੰਟੇਨਰ ਦੇ ਸੈੱਟਅੱਪ ਨਾਲ ਇਕਸਾਰ ਹੋਣ ਲਈ ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਜਿਵੇਂ ਕਿ ਡਾਟਾਬੇਸ URL ਅਤੇ Liquibase ਕੌਂਫਿਗਰੇਸ਼ਨ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਕੇ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਸੰਰਚਨਾ ਲਈ ਸੱਚ ਦੇ ਇੱਕ ਸਰੋਤ ਨੂੰ ਕਾਇਮ ਰੱਖਣ ਦੁਆਰਾ, ਤੁਸੀਂ ਮੇਲ ਖਾਂਦੇ ਵਾਤਾਵਰਣਾਂ ਕਾਰਨ ਹੋਣ ਵਾਲੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਘੱਟ ਕਰਦੇ ਹੋ।

ਟੈਸਟ ਸਕ੍ਰਿਪਟ `XServiceTest` ਦੇ ਅੰਦਰ, `@QuarkusTestResource` ਐਨੋਟੇਸ਼ਨ ਕਸਟਮ ਟੈਸਟ ਸਰੋਤ ਨੂੰ ਟੈਸਟ ਕਲਾਸ ਨਾਲ ਜੋੜਦੀ ਹੈ। ਇਹ ਰਨਟਾਈਮ 'ਤੇ ਕੰਟੇਨਰ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਇੰਜੈਕਟ ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਲਿਕਵੀਬੇਸ ਇੱਕੋ ਡਾਟਾਬੇਸ ਮੌਕੇ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, `@Inject` ਐਨੋਟੇਸ਼ਨ ਦੀ ਵਰਤੋਂ `XTypeVersionService` ਨੂੰ ਵਾਇਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇੱਕ ਸੇਵਾ ਜੋ ਡੇਟਾਬੇਸ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਦੀ ਹੈ। ਟੈਸਟ ਕੇਸ `getXTypeVersion` ਚਲਾ ਕੇ, ਤੁਸੀਂ ਪੁਸ਼ਟੀ ਕਰਦੇ ਹੋ ਕਿ ਡਾਟਾਬੇਸ ਪੋਸਟ-ਮਾਈਗ੍ਰੇਸ਼ਨ ਵਿੱਚ ਸੰਭਾਵਿਤ ਡੇਟਾ ਮੌਜੂਦ ਹੈ, ਇਹ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ Liquibase ਸਹੀ ਕੰਟੇਨਰ 'ਤੇ ਸਫਲਤਾਪੂਰਵਕ ਚਲਾਇਆ ਗਿਆ ਹੈ।

ਇੱਕ ਟੈਸਟ ਚਲਾਉਣ ਦੀ ਕਲਪਨਾ ਕਰੋ, ਸਾਰੀਆਂ ਸੇਵਾਵਾਂ ਨੂੰ ਇਕਸਾਰ ਹੋਣ ਦੀ ਉਮੀਦ ਕਰੋ, ਪਰ ਗਲਤ ਸੰਰਚਨਾਵਾਂ ਦੇ ਕਾਰਨ ਕੋਈ ਨਤੀਜਾ ਨਹੀਂ ਲੱਭ ਰਿਹਾ—ਇਸ ਨਾਲ ਡੀਬੱਗਿੰਗ ਸਮਾਂ ਬਰਬਾਦ ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਸਕ੍ਰਿਪਟਾਂ ਟੈਸਟ ਵਾਤਾਵਰਨ ਦੇ ਜੀਵਨ ਚੱਕਰ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਪ੍ਰਬੰਧਨ ਅਤੇ ਇਕਸਾਰ ਵਿਵਹਾਰ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਕੇ ਅਜਿਹੇ ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਰੋਕਣ ਲਈ ਤਿਆਰ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, RestAssured ਵਰਗੇ ਟੂਲ API ਅੰਤਮ ਬਿੰਦੂਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦੇ ਹਨ, ਇੱਕ ਪੂਰੇ-ਸਟੈਕ ਟੈਸਟ ਦ੍ਰਿਸ਼ ਨੂੰ ਸਮਰੱਥ ਕਰਦੇ ਹਨ ਜਿੱਥੇ ਬੈਕਐਂਡ ਮਾਈਗ੍ਰੇਸ਼ਨ ਅਤੇ ਫਰੰਟਐਂਡ ਇੰਟਰੈਕਸ਼ਨਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹਨਾਂ ਸੰਰਚਨਾਵਾਂ ਦੀ ਥਾਂ 'ਤੇ, ਤੁਸੀਂ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ​​​​ਟੈਸਟਾਂ ਨੂੰ ਵਿਕਸਿਤ ਕਰ ਸਕਦੇ ਹੋ, ਵਾਤਾਵਰਣ ਸੰਬੰਧੀ ਮੇਲ ਖਾਂਦੀ ਹੈ, ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡੀ ਟੀਮ ਦਾ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਕੁਸ਼ਲ ਹੈ। 🔧

Quarkus ਵਿੱਚ Liquibase ਅਤੇ Test Containers ਵਿਚਕਾਰ ਸਹੀ ਏਕੀਕਰਣ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ

PostgreSQL ਅਤੇ Liquibase ਮਾਈਗ੍ਰੇਸ਼ਨ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ TestContainers ਦੇ ਨਾਲ Quarkus ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬੈਕਐਂਡ ਹੱਲ। ਇਹ ਸਕ੍ਰਿਪਟ ਕੰਟੇਨਰ ਗਲਤ ਅਲਾਈਨਮੈਂਟ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਦੀ ਹੈ।

import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.utility.DockerImageName;
import java.util.HashMap;
import java.util.Map;
public class PostgreSQLTestResource implements QuarkusTestResourceLifecycleManager {
    private static PostgreSQLContainer<?> postgreSQLContainer;
    @Override
    public Map<String, String> start() {
        postgreSQLContainer = new PostgreSQLContainer<>(DockerImageName.parse("postgres:alpine"))
            .withDatabaseName("test")
            .withUsername("postgres")
            .withPassword("password")
            .withReuse(true);
        postgreSQLContainer.start();
        Map<String, String> config = new HashMap<>();
        config.put("quarkus.datasource.jdbc.url", postgreSQLContainer.getJdbcUrl());
        config.put("quarkus.datasource.username", postgreSQLContainer.getUsername());
        config.put("quarkus.datasource.password", postgreSQLContainer.getPassword());
        return config;
    }
    @Override
    public void stop() {
        if (postgreSQLContainer != null) {
            postgreSQLContainer.stop();
        }
    }
}

ਯੂਨਿਟ ਟੈਸਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਐਪਲੀਕੇਸ਼ਨ-ਲਿਕਵੀਬੇਸ ਏਕੀਕਰਣ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ

ਇੱਕ ਮਾਡਿਊਲਰ ਅਤੇ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਕੁਆਰਕਸ ਟੈਸਟ ਉਦਾਹਰਨ ਜੋ ਡਾਟਾਬੇਸ ਕਨੈਕਸ਼ਨ ਅਤੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦੀ ਹੈ।

import org.junit.jupiter.api.Test;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.junit.TestProfile;
@QuarkusTest
@TestProfile(TestProfileResolver.class)
public class XServiceTest {
    @Inject
    XTypeVersionService xTypeVersionService;
    @Test
    public void getXTypeVersion() {
        List<XTypeVersionEntity> entities = xTypeVersionService.get();
        assertFalse(entities.isEmpty(), "The entity list should not be empty.");
    }
}

ਟੈਸਟ ਪ੍ਰੋਫਾਈਲਾਂ ਵਿੱਚ ਸੰਰਚਨਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ

Liquibase ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਕੰਟੇਨਰਾਂ ਵਿਚਕਾਰ ਅਲਾਈਨਮੈਂਟ ਦੀ ਗਰੰਟੀ ਦੇਣ ਲਈ ਕਸਟਮ ਟੈਸਟ ਪ੍ਰੋਫਾਈਲ ਕੌਂਫਿਗਰੇਸ਼ਨ।

public class TestProfileResolver implements QuarkusTestProfile {
    @Override
    public String getConfigProfile() {
        return "test";
    }
    @Override
    public Map<String, String> getConfigOverrides() {
        return Map.of("quarkus.config.locations", "src/test/resources/application.yaml");
    }
}

ਡਾਟਾ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਫਰੰਟ-ਐਂਡ ਸਿਮੂਲੇਸ਼ਨ

ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਡਾਇਨਾਮਿਕ ਫਰੰਟ-ਐਂਡ ਕੋਡ ਸਨਿੱਪਟ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਡੇਟਾਬੇਸ ਏਕੀਕਰਣ ਤੋਂ ਡੇਟਾ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

fetch('/api/xTypeVersion')
    .then(response => response.json())
    .then(data => {
        const list = document.getElementById('entity-list');
        data.forEach(entity => {
            const item = document.createElement('li');
            item.textContent = entity.name;
            list.appendChild(item);
        });
    })
    .catch(error => console.error('Error fetching data:', error));

ਬੈਕਐਂਡ ਅਤੇ ਫਰੰਟ-ਐਂਡ ਇਕਸਾਰਤਾ ਲਈ ਯੂਨਿਟ ਟੈਸਟ

ਟੈਸਟ ਡੇਟਾ ਦੇ ਨਾਲ ਬੈਕਐਂਡ ਤਰਕ ਅਤੇ ਫਰੰਟ-ਐਂਡ ਏਕੀਕਰਣ ਦੋਵਾਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਉਦਾਹਰਨ ਟੈਸਟ ਸਕ੍ਰਿਪਟਾਂ।

import org.junit.jupiter.api.Test;
public class FrontEndValidationTest {
    @Test
    public void fetchData() {
        given().when().get("/api/xTypeVersion")
            .then().statusCode(200)
            .body("size()", greaterThan(0));
    }
}

ਕੁਆਰਕਸ ਟੈਸਟਾਂ ਲਈ ਡਾਟਾਬੇਸ ਏਕੀਕਰਣ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ

ਕੁਆਰਕਸ ਵਾਤਾਵਰਣ ਵਿੱਚ ਏਕੀਕਰਣ ਟੈਸਟਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਡੇਟਾਬੇਸ ਕੰਟੇਨਰ ਪ੍ਰਬੰਧਨ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸੰਬੋਧਿਤ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਆਮ ਮੁੱਦਾ ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਟੂਲਸ ਦੇ ਵਿਚਕਾਰ ਮੇਲ ਨਾ ਖਾਂਦੇ ਕੰਟੇਨਰਾਂ ਤੋਂ ਪੈਦਾ ਹੁੰਦਾ ਹੈ Liquibase. ਦਾ ਲਾਭ ਉਠਾਉਣ ਵਿੱਚ ਇੱਕ ਮੁੱਖ ਹੱਲ ਹੈ ਟੈਸਟ ਕੰਟੇਨਰ ਲਾਇਬ੍ਰੇਰੀ, ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਦੋਵੇਂ ਇੱਕੋ ਕੰਟੇਨਰ ਵਿੱਚ ਕੰਮ ਕਰਦੀਆਂ ਹਨ। ਇਹ ਪਹੁੰਚ ਡੁਪਲੀਕੇਟ ਕੰਟੇਨਰਾਂ ਦੀ ਸਿਰਜਣਾ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਦੀ ਹੈ ਅਤੇ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਟੈਸਟ ਜੀਵਨ ਚੱਕਰ ਦੌਰਾਨ ਇਕਸਾਰ ਰੱਖਦੀ ਹੈ। 🎯

ਵਿਚਾਰਨ ਲਈ ਇਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਹੈ ਮਾਈਗ੍ਰੇਸ਼ਨ ਰਣਨੀਤੀ। ਬਹੁਤ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਡਿਵੈਲਪਰ ਇੱਕ ਤਾਜ਼ਾ ਡਾਟਾਬੇਸ ਸਥਿਤੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਟੈਸਟਾਂ ਦੌਰਾਨ 'ਡਰਾਪ-ਐਂਡ-ਕ੍ਰਿਏਟ' ਰਣਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਤੁਸੀਂ Liquibase ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟ ਡੇਟਾ ਦੇ ਨਾਲ ਡੇਟਾਬੇਸ ਨੂੰ ਵੀ ਸੀਡ ਕਰਨਾ ਚਾਹ ਸਕਦੇ ਹੋ। ਇਸ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਰਨ ਲਈ, ਇੱਕ ਸ਼ੁਰੂਆਤੀ SQL ਸਕ੍ਰਿਪਟ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਇਸਨੂੰ `TC_INITSCRIPT` ਵਿਸ਼ੇਸ਼ਤਾ ਰਾਹੀਂ ਕੌਂਫਿਗਰ ਕਰੋ। ਇਹ ਪਹੁੰਚ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਤੁਹਾਡੇ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਡਾਟਾਬੇਸ ਢਾਂਚਾ ਅਤੇ ਲੋੜੀਂਦਾ ਟੈਸਟ ਡੇਟਾ ਦੋਵੇਂ ਤਿਆਰ ਹਨ, ਗੁੰਮ ਹੋਏ ਰਿਕਾਰਡਾਂ ਕਾਰਨ ਹੋਣ ਵਾਲੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਦੂਰ ਕਰਦੇ ਹੋਏ।

ਅੰਤ ਵਿੱਚ, ਨਿਗਰਾਨੀ ਲੌਗ ਇੱਕ ਜੀਵਨ ਬਚਾਉਣ ਵਾਲਾ ਹੋ ਸਕਦਾ ਹੈ। Quarkus ਅਤੇ Liquibase ਦੋਵੇਂ ਵਿਸਤ੍ਰਿਤ ਲੌਗਿੰਗ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਜੋ ਕਨੈਕਟੀਵਿਟੀ ਸਮੱਸਿਆਵਾਂ ਜਾਂ ਗਲਤ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰ ਸਕਦੇ ਹਨ। ਉਚਿਤ ਲੌਗ ਪੱਧਰਾਂ ਨੂੰ ਸੈੱਟ ਕਰਕੇ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਕੀ Liquibase ਸਕ੍ਰਿਪਟਾਂ ਉਮੀਦ ਅਨੁਸਾਰ ਚੱਲ ਰਹੀਆਂ ਹਨ ਅਤੇ ਡਾਟਾਬੇਸ ਨਾਲ ਜੁੜਨ ਲਈ ਵਰਤੇ ਜਾ ਰਹੇ URL ਦੀ ਪੁਸ਼ਟੀ ਕਰ ਸਕਦੇ ਹੋ। ਦਿੱਖ ਦਾ ਇਹ ਪੱਧਰ ਟੈਸਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਟਕਰਾਅ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਇੱਕ ਮਜ਼ਬੂਤ ​​ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਬਣਾਉਣ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰਦਾ ਹੈ। 🚀

ਕੁਆਰਕਸ, ਟੈਸਟ ਕੰਟੇਨਰਾਂ, ਅਤੇ ਲਿਕਵੀਬੇਸ ਏਕੀਕਰਣ ਬਾਰੇ ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ

  1. ਦੀ ਭੂਮਿਕਾ ਕੀ ਹੈ TestContainers ਏਕੀਕਰਣ ਟੈਸਟਾਂ ਵਿੱਚ?
  2. TestContainers ਟੈਸਟਿੰਗ ਦੌਰਾਨ ਅਲੱਗ-ਥਲੱਗ ਡੇਟਾਬੇਸ ਉਦਾਹਰਨਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਇਕਸਾਰ ਵਾਤਾਵਰਣ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।
  3. ਮੈਨੂੰ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ withReuse(true) ਹੁਕਮ?
  4. withReuse(true) ਕਮਾਂਡ ਤੁਹਾਨੂੰ ਕਈ ਟੈਸਟਾਂ ਵਿੱਚ ਇੱਕੋ ਕੰਟੇਨਰ ਦੀ ਮੁੜ ਵਰਤੋਂ ਕਰਨ, ਸਰੋਤਾਂ ਅਤੇ ਸੈੱਟਅੱਪ ਸਮੇਂ ਦੀ ਬਚਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ।
  5. ਦਾ ਮਕਸਦ ਕੀ ਹੈ TC_INITSCRIPT ਜਾਇਦਾਦ?
  6. TC_INITSCRIPT ਸੰਪਤੀ ਕੰਟੇਨਰ ਸਟਾਰਟਅੱਪ 'ਤੇ ਡਾਟਾਬੇਸ ਨੂੰ ਸੀਡ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ੁਰੂਆਤੀ SQL ਸਕ੍ਰਿਪਟ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ।
  7. ਮੈਂ ਇਹ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾਵਾਂ ਕਿ Liquibase ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਹੀ ਢੰਗ ਨਾਲ ਲਾਗੂ ਕੀਤੇ ਗਏ ਹਨ?
  8. ਦੀ ਸੰਰਚਨਾ ਕਰਕੇ quarkus.liquibase.jdbc.url ਸੰਪੱਤੀ, ਤੁਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ ਕਿ Liquibase ਉਸੇ ਡੇਟਾਬੇਸ ਕੰਟੇਨਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਐਪਲੀਕੇਸ਼ਨ।
  9. ਡੀਬੱਗਿੰਗ ਲਈ ਮੈਨੂੰ ਕਿਹੜੇ ਲੌਗ ਪੱਧਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ?
  10. ਸੈੱਟ ਕਰੋ TRACE ਜਾਂ DEBUG ਡਾਟਾਬੇਸ ਸੰਚਾਲਨ ਅਤੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ Liquibase ਅਤੇ TestContainers ਲਈ ਪੱਧਰ।
  11. ਮੈਂ ਸੀਡ ਡੇਟਾ ਨਾਲ API ਜਵਾਬਾਂ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰ ਸਕਦਾ ਹਾਂ?
  12. ਵਰਗੇ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ RestAssured ਅੰਤਮ ਬਿੰਦੂਆਂ ਨੂੰ ਬੇਨਤੀਆਂ ਭੇਜਣ ਅਤੇ ਵਾਪਸ ਕੀਤੇ ਡੇਟਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਟੈਸਟ ਡੇਟਾ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
  13. ਕੀ ਕਰਦਾ ਹੈ @QuarkusTestResource ਐਨੋਟੇਸ਼ਨ ਕਰਦੇ ਹਨ?
  14. @QuarkusTestResource ਐਨੋਟੇਸ਼ਨ ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਜਿਵੇਂ ਕਿ ਡੇਟਾਬੇਸ ਲਈ ਇੱਕ ਕਸਟਮ ਲਾਈਫਸਾਈਕਲ ਮੈਨੇਜਰ ਨੂੰ ਰਜਿਸਟਰ ਕਰਦੀ ਹੈ।
  15. ਮੈਨੂੰ ਇੱਕ ਕਸਟਮ TestProfileResolver ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ?
  16. ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਟੈਸਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ, ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਅਤੇ ਸਰੋਤਾਂ ਨੂੰ ਅਲਾਈਨ ਕਰਨ ਲਈ ਸਹੀ ਸੰਰਚਨਾ ਲੋਡ ਕੀਤੀ ਗਈ ਹੈ।
  17. ਮੈਂ ਇਹ ਕਿਵੇਂ ਪਤਾ ਲਗਾ ਸਕਦਾ ਹਾਂ ਕਿ ਕੀ ਕਈ ਕੰਟੇਨਰ ਬਣਾਏ ਜਾ ਰਹੇ ਹਨ?
  18. ਆਪਣੇ ਡੌਕਰ ਡੈਸਕਟਾਪ ਦੀ ਜਾਂਚ ਕਰੋ ਜਾਂ ਡੁਪਲੀਕੇਟ ਕੰਟੇਨਰ ਉਦਾਹਰਨਾਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਸੰਬੰਧਿਤ ਪੋਰਟਾਂ ਲਈ ਕੰਸੋਲ ਲੌਗ ਦੀ ਨਿਗਰਾਨੀ ਕਰੋ।
  19. ਟੈਸਟ ਸਰੋਤਾਂ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ?
  20. ਨੂੰ ਓਵਰਰਾਈਡ ਕਰੋ stop ਟੈਸਟਾਂ ਦੇ ਮੁਕੰਮਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਕੰਟੇਨਰ ਨੂੰ ਰੋਕਣ ਅਤੇ ਹਟਾਉਣ ਲਈ ਤੁਹਾਡੇ ਜੀਵਨ ਚੱਕਰ ਪ੍ਰਬੰਧਕ ਵਿੱਚ ਵਿਧੀ।

ਟੈਸਟਿੰਗ ਵਿਵਾਦਾਂ ਨੂੰ ਸੁਲਝਾਉਣ ਲਈ ਮੁੱਖ ਉਪਾਅ

Quarkus, Liquibase, ਅਤੇ TestContainers ਦੇ ਨਾਲ ਏਕੀਕਰਣ ਟੈਸਟਿੰਗ ਲਈ ਮਾਈਗ੍ਰੇਸ਼ਨ ਅਤੇ ਡੇਟਾਬੇਸ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਇਕਸਾਰ ਕਰਨ ਲਈ ਧਿਆਨ ਨਾਲ ਸੈੱਟਅੱਪ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਆਪਣੇ ਟੈਸਟ ਸਰੋਤ ਪ੍ਰਬੰਧਕ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਕੇ ਅਤੇ ਇੱਕ ਯੂਨੀਫਾਈਡ ਕੌਂਫਿਗਰੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ Liquibase ਅਤੇ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਕੰਟੇਨਰਾਂ ਵਿਚਕਾਰ ਟਕਰਾਅ ਨੂੰ ਖਤਮ ਕਰ ਸਕਦੇ ਹੋ।

ਇਹ ਕਦਮ ਤੁਹਾਡੀ ਜਾਂਚ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸੁਚਾਰੂ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਤੁਹਾਡੇ ਟੈਸਟਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ। ਵਿਸਤ੍ਰਿਤ ਲੌਗਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਾਦ ਰੱਖੋ, ਜਿਵੇਂ ਕਿ ਯੋਗ ਕਰਨਾ TRACE Liquibase ਲਈ, ਤੁਹਾਡੇ ਟੈਸਟਾਂ ਦੇ ਵਿਵਹਾਰ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਅਤੇ ਮਤਭੇਦਾਂ ਨੂੰ ਜਲਦੀ ਹੱਲ ਕਰਨ ਲਈ। ਇਸ ਪਹੁੰਚ ਨਾਲ, ਤੁਸੀਂ ਭਰੋਸੇ ਨਾਲ ਸਕੇਲੇਬਲ ਅਤੇ ਸਾਂਭਣਯੋਗ ਟੈਸਟ ਬਣਾ ਸਕਦੇ ਹੋ। 🐛

Quarkus, Liquibase, ਅਤੇ Test Containers ਨਾਲ ਜਾਂਚ ਲਈ ਸਰੋਤ ਅਤੇ ਹਵਾਲੇ
  1. ਦੀ ਵਰਤੋਂ ਬਾਰੇ ਵਿਸਥਾਰ ਨਾਲ ਦੱਸਦਾ ਹੈ Liquibase ਟੈਸਟਿੰਗ ਦੌਰਾਨ ਡਾਟਾਬੇਸ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ। ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ ਵੇਖੋ: Liquibase ਦਸਤਾਵੇਜ਼ .
  2. ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਵੇਂ ਟੈਸਟ ਕੰਟੇਨਰ ਟੈਸਟਾਂ ਲਈ ਗਤੀਸ਼ੀਲ ਕੰਟੇਨਰਾਈਜ਼ਡ ਵਾਤਾਵਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਹਵਾਲਾ: ਟੈਸਟ ਕੰਟੇਨਰਜ਼ ਦੀ ਅਧਿਕਾਰਤ ਸਾਈਟ .
  3. ਵਿੱਚ ਉੱਨਤ ਟੈਸਟਿੰਗ ਪੈਟਰਨਾਂ ਦੀ ਚਰਚਾ ਕਰਦਾ ਹੈ ਕੁਆਰਕਸ, ਟੈਸਟ ਪ੍ਰੋਫਾਈਲਾਂ ਅਤੇ ਜੀਵਨ ਚੱਕਰ ਪ੍ਰਬੰਧਨ ਸਮੇਤ। ਇੱਥੇ ਹੋਰ ਜਾਣੋ: ਕੁਆਰਕਸ ਟੈਸਟਿੰਗ ਗਾਈਡ .
  4. ਕਈ ਕੰਟੇਨਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਵਾਲੇ ਏਕੀਕਰਣ ਮੁੱਦਿਆਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਣਾ ਹੈ ਬਾਰੇ ਦੱਸਦਾ ਹੈ। ਭਾਈਚਾਰਕ ਸਰੋਤ: ਸਟੈਕ ਓਵਰਫਲੋ ਟੈਸਟ ਕੰਟੇਨਰ ਟੈਗ .
  5. ਵਿੱਚ ਵਾਧੂ ਸਮਝ PostgreSQL TestContainers ਵਿੱਚ ਸੰਰਚਨਾ: TestContainers PostgreSQL ਮੋਡੀਊਲ .