Mockito ಜೊತೆ Quarkus ರಿಯಾಕ್ಟಿವ್ Panache ನಲ್ಲಿ Vert.x ಸಂದರ್ಭ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವುದು

ಕ್ವಾರ್ಕಸ್ ರಿಯಾಕ್ಟಿವ್ ಪ್ಯಾನಾಚೆ ಪರೀಕ್ಷೆಯಲ್ಲಿ Vert.x ಸಂದರ್ಭ ದೋಷವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಪನಾಚೆಯೊಂದಿಗೆ ಹೈಬರ್ನೇಟ್ ರಿಯಾಕ್ಟಿವ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ವಾರ್ಕಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುವಾಗ, ನಿರ್ಬಂಧಿಸದ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಡೆವಲಪರ್‌ಗಳು ಈ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವತ್ತ ಸಾಗುತ್ತಿದ್ದಂತೆ, ಅವರು ನಿರ್ದಿಷ್ಟ ಸವಾಲುಗಳನ್ನು ಎದುರಿಸಬಹುದು. ಕ್ವಾರ್ಕಸ್ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಪನಾಚೆಯ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಮಾದರಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಅಂತಹ ಒಂದು ಸಮಸ್ಯೆ ಉದ್ಭವಿಸುತ್ತದೆ.

ಡೆವಲಪರ್‌ಗಳು ಎದುರಿಸುತ್ತಿರುವ ಸಾಮಾನ್ಯ ದೋಷವೆಂದರೆ "ಪ್ರಸ್ತುತ ವರ್ಟ್‌ಕ್ಸ್ ಸಂದರ್ಭ ಕಂಡುಬಂದಿಲ್ಲ" ಸಂದೇಶವಾಗಿದೆ. ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ವಹಿವಾಟಿನೊಳಗೆ ಸುತ್ತುವ ಸೇವಾ ವಿಧಾನವನ್ನು ಪರೀಕ್ಷಿಸುವಾಗ ಈ ದೋಷವು ಸಾಮಾನ್ಯವಾಗಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ Panache.withTransaction(). ಇದು ಆಧಾರವಾಗಿರುವ Vert.x ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗೆ ಸಂಬಂಧಿಸಿದೆ, ಈ ತಡೆರಹಿತ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಸರಿಯಾದ ಸಂದರ್ಭದ ಅಗತ್ಯವಿದೆ.

ಸರಿಯಾದ Vert.x ಸನ್ನಿವೇಶದಲ್ಲಿ ಚಲಾಯಿಸಲು ಪರೀಕ್ಷಾ ಪರಿಸರವನ್ನು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಸವಾಲು. ಡೇಟಾಬೇಸ್ ಸಂವಹನಗಳನ್ನು ಅಪಹಾಸ್ಯ ಮಾಡುವುದು ಮತ್ತು ಸ್ಟಬ್ಬಿಂಗ್ ಮಾಡುವುದು ಸಹಾಯಕವಾಗಿದ್ದರೂ, ಆಗಾಗ್ಗೆ ಈ ಸಮಸ್ಯೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರಿಹರಿಸುವುದಿಲ್ಲ. ಪರಿಣಾಮವಾಗಿ, ಸೇವೆಯ ಕೋಡ್ ಉತ್ಪಾದನೆಯಲ್ಲಿ ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದಾಗಲೂ ಪರೀಕ್ಷೆಯು ವಿಫಲವಾಗಬಹುದು.

ಈ ಲೇಖನದಲ್ಲಿ, ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿ ಈ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಯಶಸ್ವಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಪ್ರಕರಣಗಳನ್ನು ಹೇಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ದೋಷದ ಹಿಂದಿನ ಕಾರಣಗಳನ್ನು ನಾವು ಧುಮುಕುತ್ತೇವೆ ಮತ್ತು ಸರಿಯಾದ Vert.x ಸಂದರ್ಭವನ್ನು ಹೊಂದಿಸಲು ಹಂತ-ಹಂತದ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಒದಗಿಸುತ್ತೇವೆ.

ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿ Vert.x ಸಂದರ್ಭ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಪನಾಚೆ ಪರೀಕ್ಷೆಯನ್ನು ನಿರ್ವಹಿಸುವುದು

ಮೊದಲ ಪರಿಹಾರದಲ್ಲಿ, ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಪರೀಕ್ಷೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಕಾಣೆಯಾದ Vert.x ಸಂದರ್ಭವು ಪ್ರಮುಖ ಸವಾಲಾಗಿದೆ. ಕ್ವಾರ್ಕಸ್ ಒದಗಿಸುತ್ತದೆ @TestReactiveTransaction ಟಿಪ್ಪಣಿ, ಇದು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ವಹಿವಾಟಿನೊಳಗೆ ಪರೀಕ್ಷೆಯು ರನ್ ಆಗುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಅಗತ್ಯವಿರುವ Vert.x ಸಂದರ್ಭವನ್ನು ಹೊಂದಿಸುತ್ತದೆ. Panache ನ ತಡೆರಹಿತ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ Panache.withTransaction(), "ಪ್ರಸ್ತುತ Vert.x ಸಂದರ್ಭ ಕಂಡುಬಂದಿಲ್ಲ" ದೋಷವನ್ನು ಎಸೆಯದೆಯೇ ಸರಿಯಾಗಿ ರನ್ ಮಾಡಬಹುದು. ಈ ಟಿಪ್ಪಣಿಯನ್ನು ಸೇರಿಸುವ ಮೂಲಕ, ನಾವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸರಿಯಾದ ಪರಿಸರವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತೇವೆ, ಪರೀಕ್ಷೆಯು ನೈಜ ವಹಿವಾಟಿನ ನಡವಳಿಕೆಯನ್ನು ಅನುಕರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಎರಡನೇ ಪರಿಹಾರದಲ್ಲಿ, ನಾವು Vert.x ಸಂದರ್ಭವನ್ನು ಬಳಸಿಕೊಂಡು ಹಸ್ತಚಾಲಿತವಾಗಿ ರಚಿಸುತ್ತೇವೆ VertxContextSupport.runOnContext(). ಈ ವಿಧಾನವು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಕೋಡ್, ನಿರ್ದಿಷ್ಟವಾಗಿ Panache ನಿರ್ವಹಿಸುವ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು, Vert.x ಈವೆಂಟ್ ಲೂಪ್ ಒಳಗೆ ಚಲಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಹಾಗೆ ಮಾಡುವ ಮೂಲಕ, ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ನಾವು ಮಾನ್ಯವಾದ Vert.x ಸಂದರ್ಭವನ್ನು ಒದಗಿಸುತ್ತೇವೆ. ಪರೀಕ್ಷಾ ಪರಿಸರದ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣ ಅಗತ್ಯವಿದ್ದಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪನಾಚೆ ಅವರ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅಪಹಾಸ್ಯ ಮಾಡುವುದು PanacheMock.mock() ನಿಜವಾದ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಹೊಡೆಯದೆಯೇ ಪರೀಕ್ಷೆಗಾಗಿ ಡೇಟಾಬೇಸ್-ಸಂಬಂಧಿತ ಕೋಡ್ ಅನ್ನು ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಮೂರನೆಯ ಪರಿಹಾರವು ಹತೋಟಿಗೆ ತರುತ್ತದೆ Uni.createFrom().ಸಂದರ್ಭ() ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ Vert.x ಸಂದರ್ಭವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ರಚಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸುವ ವಿಧಾನ. ಈ ವಿಧಾನವು ಡೆವಲಪರ್‌ಗೆ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ಅಸಮಕಾಲಿಕ ಪ್ಯಾನಾಚೆ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಕಸ್ಟಮ್ ಸಂದರ್ಭವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಎಲ್ಲಾ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಕ್ರಿಯೆಗಳನ್ನು ಸರಿಯಾದ ಪರಿಸರದಲ್ಲಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಅಸಮಕಾಲಿಕ ಅಥವಾ ತಡೆರಹಿತ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವಾಗ ಈ ವಿಧಾನವು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಸಂದರ್ಭ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಡೇಟಾ ಹರಿವಿನ ಸುಗಮ ನಿರ್ವಹಣೆಯನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ.

ಈ ಪರಿಹಾರಗಳ ಉದ್ದಕ್ಕೂ, Mockito.when() ಪನಾಚೆ ವಿಧಾನಗಳ ನಡವಳಿಕೆಯನ್ನು ಅಪಹಾಸ್ಯ ಮಾಡುವಲ್ಲಿ ಪ್ರಮುಖ ಪಾತ್ರ ವಹಿಸುತ್ತದೆ. ಈ ವಿಧಾನವನ್ನು ಬಳಸುವ ಮೂಲಕ, ನಾವು ಕಾರ್ಯಾಚರಣೆಗಳ ಫಲಿತಾಂಶವನ್ನು ನಿಯಂತ್ರಿಸುತ್ತೇವೆ Panache.withTransaction() ಮತ್ತು User.persist(), ವಿಭಿನ್ನ ಸನ್ನಿವೇಶಗಳನ್ನು ಅನುಕರಿಸಲು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಯಶಸ್ಸು ಅಥವಾ ವೈಫಲ್ಯ). ಈ ಪರಿಹಾರಗಳನ್ನು ಸಂಯೋಜಿಸುವುದರಿಂದ ಡೆವಲಪರ್‌ಗಳು ಅಸಮಕಾಲಿಕ ನಿರ್ವಹಣೆ ಅಥವಾ ಸರಿಯಾದ Vert.x ಸಂದರ್ಭದ ಕೊರತೆಗೆ ಸಂಬಂಧಿಸಿದ ಸಮಸ್ಯೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸದೆಯೇ ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿ Panache ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಹರಿವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

// Solution 1: Use TestReactiveTransaction to ensure a proper Vert.x context in your test.
@TestReactiveTransaction
@QuarkusTest
public class AuthServiceTest {
    @Inject
    AuthService authService;

    @Test
    void testCreateUserWithVertxContext() {
        Uni<Auth> result = authService.createUser(new Auth("test@gmail.com", "test123"));
        result.subscribe().with(auth -> {
            assertEquals("test@gmail.com", auth.getEmail());
        });
    }
}

// Solution 2: Mock the Vert.x context manually for your Panache operations.
@QuarkusTest
public class AuthServiceTest {
    @Inject
    AuthService authService;

    @BeforeEach
    void setup() {
        Vertx vertx = Vertx.vertx();
        VertxContextSupport.runOnContext(vertx, () -> {
            // Setup for Panache mock
            PanacheMock.mock(User.class);
            PanacheMock.mock(Panache.class);
        });
    }

    @Test
    void testCreateUserInMockedContext() {
        Mockito.when(Panache.withTransaction(any())).thenReturn(Uni.createFrom().item(new Auth("mock@gmail.com", "password123")));
        Auth auth = authService.createUser(new Auth("mock@gmail.com", "password123")).await().indefinitely();
        assertEquals("mock@gmail.com", auth.getEmail());
    }
}

// Solution 3: Use Uni.createFrom().context to create and manage a Vert.x context for reactive testing.
@QuarkusTest
public class AuthServiceTest {
    @Inject
    AuthService authService;

    @Test
    void testVertxContextSetupForReactivePanache() {
        Uni.createFrom().context(context -> {
            return authService.createUser(new Auth("reactive@gmail.com", "password123"));
        }).subscribe().with(auth -> {
            assertEquals("reactive@gmail.com", auth.getEmail());
        });
    }
}

ಕ್ವಾರ್ಕಸ್ ಪರೀಕ್ಷೆಯಲ್ಲಿ Vert.x ಸಂದರ್ಭದ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ತಿಳಿಸುವುದು

ಕ್ವಾರ್ಕಸ್‌ನಂತಹ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ವಿಶೇಷವಾಗಿ ಹೈಬರ್ನೇಟ್ ರಿಯಾಕ್ಟಿವ್ ಮತ್ತು ಪನಾಚೆಯಂತಹ ಚೌಕಟ್ಟುಗಳೊಂದಿಗೆ, ನಿರ್ವಹಿಸುವುದು Vert.x ಸಂದರ್ಭ ನಿರ್ಣಾಯಕ ಅಂಶವಾಗುತ್ತದೆ. ರಚನಾತ್ಮಕ ಮತ್ತು ನಿಯಂತ್ರಿತ ರೀತಿಯಲ್ಲಿ ನಿರ್ಬಂಧಿಸದ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು Vert.x ಸಂದರ್ಭವು ಅವಶ್ಯಕವಾಗಿದೆ. ಇದು ಇಲ್ಲದೆ, ಸಾಮಾನ್ಯ "ಪ್ರಸ್ತುತ ವರ್ಟ್ಕ್ಸ್ ಸಂದರ್ಭ ಕಂಡುಬಂದಿಲ್ಲ" ದೋಷ, ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಕಂಡುಬರುವಂತೆ Panache.withTransaction() ಪರೀಕ್ಷೆಗಳ ಸಮಯದಲ್ಲಿ ವಿಫಲರಾಗುತ್ತಾರೆ. ಅಸಮಕಾಲಿಕ, ನಿರ್ಬಂಧಿಸದ I/O ಅನ್ನು ನಿರ್ವಹಿಸಲು ಕ್ವಾರ್ಕಸ್ ಹುಡ್ ಅಡಿಯಲ್ಲಿ Vert.x ಅನ್ನು ಬಳಸುವುದರಿಂದ ಇದು ಸಂಭವಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ರಿಯಾಕ್ಟಿವ್ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸೂಕ್ತ ಸಂದರ್ಭದಲ್ಲಿ ಸುತ್ತುವ ಅಗತ್ಯವಿದೆ.

ಪರೀಕ್ಷಾ ಜೀವನಚಕ್ರದ ಸಮಯದಲ್ಲಿ ಮಾನ್ಯವಾದ Vert.x ಸಂದರ್ಭದ ಅನುಪಸ್ಥಿತಿಯ ಕಾರಣದಿಂದಾಗಿ ಡೆವಲಪರ್‌ಗಳು ಈ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ವಿಧಾನಗಳನ್ನು ಪರೀಕ್ಷಿಸುವಲ್ಲಿ ತೊಂದರೆಗಳನ್ನು ಎದುರಿಸುತ್ತಾರೆ. ವಿಶಿಷ್ಟವಾದ ಪರೀಕ್ಷಾ ಪರಿಸರವು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸದ ಹೊರತು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಈ ಸಂದರ್ಭವನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ, ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅಪಹಾಸ್ಯ ಮಾಡುವಾಗ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ರೀತಿಯ ಉಪಕರಣಗಳ ಬಳಕೆ TestReactiveTransaction ಅಥವಾ ಪರೀಕ್ಷಾ ಪರಿಸರದಲ್ಲಿ Vert.x ಸಂದರ್ಭವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ರಚಿಸುವುದು ಈ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸಬಹುದು. ಈ ವಿಧಾನವು ಉತ್ಪಾದನೆಯಲ್ಲಿನ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಪರೀಕ್ಷೆಗಳು ನಿಕಟವಾಗಿ ಅನುಕರಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಅಲ್ಲಿ Vert.x ಸಂದರ್ಭವು ಯಾವಾಗಲೂ ಇರುತ್ತದೆ.

ಇದಲ್ಲದೆ, ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಪರೀಕ್ಷೆಯು ಸಿಂಕ್ರೊನೈಸೇಶನ್ಗೆ ಹೆಚ್ಚಿನ ಗಮನವನ್ನು ಬಯಸುತ್ತದೆ. ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಸ್ಟ್ರೀಮ್ಗಳು, ಹಾಗೆ Uni SmallRye ದಂಗೆಯಿಂದ, ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಹರಿವುಗಳನ್ನು ನಿರ್ವಹಿಸಿ, ಅಂದರೆ ಸರಿಯಾದ ಸಂದರ್ಭ ನಿರ್ವಹಣೆಯಿಲ್ಲದೆ, ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವಿಭಿನ್ನ ಥ್ರೆಡ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಇದು ವೈಫಲ್ಯಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ವಿಧಾನಗಳನ್ನು ಅಪಹಾಸ್ಯ ಮಾಡುವುದು ಮಾತ್ರವಲ್ಲದೇ ಪರೀಕ್ಷೆಯು ಸರಿಯಾದ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ವಹಿವಾಟಿನ ಗಡಿಗಳಲ್ಲಿ ನಡೆಯುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದರಲ್ಲಿ ಪರಿಹಾರವು ಇರುತ್ತದೆ. ಈ ರೀತಿಯಾಗಿ, ಡೆವಲಪರ್‌ಗಳು ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಬಹುದು ಮತ್ತು ನಿಯಂತ್ರಿತ ಪರೀಕ್ಷಾ ಪರಿಸರದಲ್ಲಿ ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಅನುಕರಿಸಬಹುದು.