test: add route segments and multiple detinations tests

Author: illuminati1911

example/e2e/initialization.test.js

@@ -28,8 +28,6 @@ describe('Initialization tests', () => {
 
   it('T01 - initialize map and test default values', async () => {
     await selectTestByName('testMapInitialization');
-    // await waitForStepNumber(1);
-    // await agreeToTermsAndConditions();
     await waitForTestToFinish();
     const failureMessageLabel = element(by.id('failure_message_label'));
     const attributes = await failureMessageLabel.getAttributes();

example/e2e/navigation.test.js

@@ -20,7 +20,7 @@ import {
   selectTestByName,
   waitForTestToFinish,
 } from './shared.js';
-import { element, by } from 'detox';
+import { element, by, log } from 'detox';
 
 describe('Navigation tests', () => {
   beforeEach(async () => {
@@ -44,4 +44,26 @@ describe('Navigation tests', () => {
       'Test result: Success'
     );
   });
+
+  it('T03 - initialize navigation controller and navigate to multiple destinations', async () => {
+    await selectTestByName('testNavigationToMultipleDestination');
+    await agreeToTermsAndConditions();
+    await waitForTestToFinish();
+    await expect(element(by.id('test_result_label'))).toHaveText(
+      'Test result: Success'
+    );
+  });
+
+  it('T04 - initialize navigation controller and test route segments', async () => {
+    await selectTestByName('testRouteSegments');
+    await agreeToTermsAndConditions();
+    const failureMessageLabel = element(by.id('failure_message_label'));
+    const attributes = await failureMessageLabel.getAttributes();
+    log.error(attributes.text);
+    await expect(element(by.id('failure_message_label'))).toHaveText('');
+    await waitForTestToFinish();
+    await expect(element(by.id('test_result_label'))).toHaveText(
+      'Test result: Success'
+    );
+  });
 });

example/src/screens/IntegrationTestsScreen.tsx

@@ -37,6 +37,8 @@ import {
   testMapInitialization,
   testNavigationToSingleDestination,
   testNavigationSessionInitialization,
+  testNavigationToMultipleDestination,
+  testRouteSegments,
 } from './integration_tests/integration_test';
 
 // Utility function for showing Snackbar
@@ -174,6 +176,12 @@ const IntegrationTestsScreen = () => {
       case 'testNavigationToSingleDestination':
         await testNavigationToSingleDestination(getTestTools());
         break;
+      case 'testNavigationToMultipleDestination':
+        await testNavigationToMultipleDestination(getTestTools());
+        break;
+      case 'testRouteSegments':
+        await testRouteSegments(getTestTools());
+        break;
       default:
         resetTestState();
         break;
@@ -244,6 +252,20 @@ const IntegrationTestsScreen = () => {
             runTest('testNavigationToSingleDestination');
           }}
         />
+        <Button
+          title="testNavigationToMultipleDestination"
+          testID="testNavigationToMultipleDestination"
+          onPress={() => {
+            runTest('testNavigationToMultipleDestination');
+          }}
+        />
+        <Button
+          title="testRouteSegments"
+          testID="testRouteSegments"
+          onPress={() => {
+            runTest('testRouteSegments');
+          }}
+        />
       </OverlayModal>
     </View>
   );

example/src/screens/integration_tests/integration_test.ts

@@ -218,3 +218,130 @@ export const testNavigationToSingleDestination = async (
     failTest('navigationController.init() exception');
   }
 };
+
+export const testNavigationToMultipleDestination = async (
+  testTools: TestTools
+) => {
+  const { navigationController, addListeners, passTest, failTest } = testTools;
+  let onArrivalCount = 0;
+  addListeners({
+    onNavigationReady: async () => {
+      await navigationController.simulator.simulateLocation({
+        lat: 37.4195823,
+        lng: -122.0799018,
+      });
+      await navigationController.setDestinations(
+        [
+          {
+            position: {
+              lat: 37.4152112,
+              lng: -122.0813741,
+            },
+          },
+          {
+            position: {
+              lat: 37.4155112,
+              lng: -122.0806959,
+            },
+          },
+        ],
+        {
+          travelMode: TravelMode.DRIVING,
+          avoidFerries: true,
+          avoidTolls: false,
+        }
+      );
+      await navigationController.startGuidance();
+
+      // Timeout here is used to avoid issues on Android.
+      setTimeout(() => {
+        navigationController.simulator.simulateLocationsAlongExistingRoute({
+          speedMultiplier: Platform.OS === 'ios' ? 5 : 10,
+        });
+      }, 3000);
+    },
+    onNavigationInitError: (errorCode: NavigationInitErrorCode) => {
+      console.log(errorCode);
+      failTest('onNavigatonInitError');
+    },
+    onArrival: async () => {
+      onArrivalCount += 1;
+      if (onArrivalCount > 1) {
+        return passTest();
+      }
+      await navigationController.continueToNextDestination();
+    },
+  });
+  try {
+    await navigationController.init();
+  } catch (error) {
+    console.error('Error initializing navigator', error);
+    failTest('navigationController.init() exception');
+  }
+};
+
+export const testRouteSegments = async (testTools: TestTools) => {
+  const {
+    navigationController,
+    addListeners,
+    passTest,
+    failTest,
+    expectFalseError,
+  } = testTools;
+  let beginTraveledPath;
+  addListeners({
+    onNavigationReady: async () => {
+      await navigationController.simulator.simulateLocation({
+        lat: 37.79136614772824,
+        lng: -122.41565900473043,
+      });
+      await navigationController.setDestination({
+        title: 'Grace Cathedral',
+        position: {
+          lat: 37.791957,
+          lng: -122.412529,
+        },
+      });
+      await navigationController.startGuidance();
+
+      // Timeout here is used to avoid issues on Android.
+      setTimeout(async () => {
+        const beginRouteSegments =
+          await navigationController.getRouteSegments();
+        const beginCurrentRouteSegment =
+          await navigationController.getCurrentRouteSegment();
+        beginTraveledPath = await navigationController.getTraveledPath();
+
+        if (beginRouteSegments.length === 0) {
+          expectFalseError('beginRouteSegments.length === 0');
+          return;
+        }
+        if (!beginCurrentRouteSegment) {
+          return expectFalseError('!beginCurrentRouteSegment');
+        }
+        navigationController.simulator.simulateLocationsAlongExistingRoute({
+          speedMultiplier: 5,
+        });
+      }, 3000);
+    },
+    onNavigationInitError: (errorCode: NavigationInitErrorCode) => {
+      console.log(errorCode);
+      failTest('onNavigatonInitError');
+    },
+    onArrival: async () => {
+      const endTraveledPath = await navigationController.getTraveledPath();
+      if (endTraveledPath.length <= beginTraveledPath.length) {
+        return expectFalseError(
+          'endTraveledPath.length <= beginTraveledPath.length'
+        );
+      }
+      passTest();
+    },
+  });
+  try {
+    await navigationController.init();
+  } catch (error) {
+    console.error('Error initializing navigator', error);
+    failTest('navigationController.init() exception');
+  }
+};