shakebug-react-native 1.0.14

package/NetInfo/src/__tests__/fetch.spec.ts

@@ -0,0 +1,479 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import fetchMock from 'jest-fetch-mock';
+import NetInfo from '../index';
+import NativeInterface from '../internal/nativeInterface';
+import {NetInfoStateType, NetInfoCellularGeneration} from '../internal/types';
+import {DEVICE_CONNECTIVITY_EVENT} from '../internal/privateTypes';
+
+// Mock modules
+fetchMock.enableMocks();
+jest.mock('../internal/nativeModule');
+const mockNativeModule = jest.requireMock('../internal/nativeModule').default;
+
+beforeEach(() => {
+  mockNativeModule.getCurrentState.mockReset();
+});
+
+describe('@react-native-community/netinfo fetch', () => {
+  describe('with cellular data types', () => {
+    describe('5g cellular generation', () => {
+      function dataProvider() {
+        return [
+          {
+            description:
+              'should resolve the promise correctly with expected 5g settings',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['5g'],
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when 5g returns not connected',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: false,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['5g'],
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when 5g returns internet not reachable',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: false,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['5g'],
+              },
+            },
+          },
+        ];
+      }
+
+      dataProvider().forEach(testCase => {
+        it(testCase.description, () => {
+          mockNativeModule.getCurrentState.mockResolvedValue(
+            testCase.expectedConnectionInfo,
+          );
+
+          NativeInterface.eventEmitter.emit(
+            DEVICE_CONNECTIVITY_EVENT,
+            testCase.expectedConnectionInfo,
+          );
+          expect(NetInfo.fetch()).resolves.toEqual(
+            testCase.expectedConnectionInfo,
+          );
+        });
+      });
+    });
+
+    describe('4g cellular generation', () => {
+      function dataProvider() {
+        return [
+          {
+            description:
+              'should resolve the promise correctly with expected 4g settings',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['4g'],
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when 4g returns not connected',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: false,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['4g'],
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when 4g returns internet not reachable',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: false,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['4g'],
+              },
+            },
+          },
+        ];
+      }
+
+      dataProvider().forEach(testCase => {
+        it(testCase.description, () => {
+          mockNativeModule.getCurrentState.mockResolvedValue(
+            testCase.expectedConnectionInfo,
+          );
+
+          NativeInterface.eventEmitter.emit(
+            DEVICE_CONNECTIVITY_EVENT,
+            testCase.expectedConnectionInfo,
+          );
+          expect(NetInfo.fetch()).resolves.toEqual(
+            testCase.expectedConnectionInfo,
+          );
+        });
+      });
+    });
+
+    describe('3g cellular generation', () => {
+      function dataProvider() {
+        return [
+          {
+            description:
+              'should resolve the promise correctly with expected settings',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['3g'],
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when not connected',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: false,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['3g'],
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when internet is not reachable',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: false,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['3g'],
+              },
+            },
+          },
+        ];
+      }
+
+      dataProvider().forEach(testCase => {
+        it(testCase.description, () => {
+          mockNativeModule.getCurrentState.mockResolvedValue(
+            testCase.expectedConnectionInfo,
+          );
+
+          NativeInterface.eventEmitter.emit(
+            DEVICE_CONNECTIVITY_EVENT,
+            testCase.expectedConnectionInfo,
+          );
+          expect(NetInfo.fetch()).resolves.toEqual(
+            testCase.expectedConnectionInfo,
+          );
+        });
+      });
+    });
+
+    describe('2g cellular generation', () => {
+      function dataProvider() {
+        return [
+          {
+            description:
+              'should resolve the promise correctly with expected settings',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['2g'],
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when not connected',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: false,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['2g'],
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when internet is not reachable',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: false,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: NetInfoCellularGeneration['2g'],
+              },
+            },
+          },
+        ];
+      }
+
+      dataProvider().forEach(testCase => {
+        it(testCase.description, () => {
+          mockNativeModule.getCurrentState.mockResolvedValue(
+            testCase.expectedConnectionInfo,
+          );
+
+          NativeInterface.eventEmitter.emit(
+            DEVICE_CONNECTIVITY_EVENT,
+            testCase.expectedConnectionInfo,
+          );
+          expect(NetInfo.fetch()).resolves.toEqual(
+            testCase.expectedConnectionInfo,
+          );
+        });
+      });
+    });
+
+    describe('null cellular generation', () => {
+      function dataProvider() {
+        return [
+          {
+            description:
+              'should resolve the promise correctly with expected settings',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: null,
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when not connected',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: false,
+              isInternetReachable: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: null,
+              },
+            },
+          },
+          {
+            description:
+              'should resolve the promise correctly when internet is not reachable',
+            expectedConnectionInfo: {
+              type: NetInfoStateType.cellular,
+              isConnected: true,
+              isInternetReachable: false,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: null,
+              },
+            },
+          },
+        ];
+      }
+
+      dataProvider().forEach(testCase => {
+        it(testCase.description, () => {
+          mockNativeModule.getCurrentState.mockResolvedValue(
+            testCase.expectedConnectionInfo,
+          );
+
+          NativeInterface.eventEmitter.emit(
+            DEVICE_CONNECTIVITY_EVENT,
+            testCase.expectedConnectionInfo,
+          );
+          expect(NetInfo.fetch()).resolves.toEqual(
+            testCase.expectedConnectionInfo,
+          );
+        });
+      });
+    });
+  });
+
+  describe('with unknown and no connection data types', () => {
+    function dataProvider() {
+      return [
+        {
+          description:
+            'should resolve the promise correctly when no connection is established (airplane mode)',
+          expectedConnectionInfo: {
+            type: NetInfoStateType.none,
+            isConnected: false,
+            isInternetReachable: true,
+            details: null,
+          },
+        },
+        {
+          description:
+            'should resolve the promise correctly when connection type cannot be determined',
+          expectedConnectionInfo: {
+            type: NetInfoStateType.unknown,
+            isConnected: false,
+            isInternetReachable: true,
+            details: null,
+          },
+        },
+      ];
+    }
+
+    dataProvider().forEach(testCase => {
+      it(testCase.description, () => {
+        mockNativeModule.getCurrentState.mockResolvedValue(
+          testCase.expectedConnectionInfo,
+        );
+
+        NativeInterface.eventEmitter.emit(
+          DEVICE_CONNECTIVITY_EVENT,
+          testCase.expectedConnectionInfo,
+        );
+        expect(NetInfo.fetch()).resolves.toEqual(
+          testCase.expectedConnectionInfo,
+        );
+      });
+    });
+  });
+
+  describe('rejected promises are handled', () => {
+    it('will properly reject a promise if the connection request cannot be resolved', async () => {
+      const rejectionMessage = 'nope, no connection info for you';
+
+      // Mock `_fetchCurrentState` in the State constructor.
+      mockNativeModule.getCurrentState.mockResolvedValueOnce({
+        type: NetInfoStateType.cellular,
+        isConnected: true,
+        isInternetReachable: true,
+        details: {
+          isConnectionExpensive: true,
+          cellularGeneration: NetInfoCellularGeneration['4g'],
+        },
+      });
+
+      mockNativeModule.getCurrentState.mockRejectedValue(
+        new Error(rejectionMessage),
+      );
+
+      try {
+        await NetInfo.fetch();
+      } catch (error) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        expect(error.message).toMatch(rejectionMessage);
+      }
+    });
+  });
+
+  describe('with configuration options', () => {
+    beforeAll(() => {
+      // Prevent `_checkInternetReachability` from rescheduling.
+      jest.useFakeTimers();
+    });
+
+    beforeEach(() => {
+      fetchMock.resetMocks();
+    });
+
+    describe('reachabilityShouldRun', () => {
+      function dataProvider() {
+        return [
+          {
+            description: 'reachabilityShouldRun returns true',
+            configuration: {
+              reachabilityShouldRun: () => true,
+            },
+            expectedConnectionInfo: {
+              type: 'wifi',
+              isConnected: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: 'unknown',
+              },
+            },
+            expectedIsInternetReachable: null,
+            expectFetchToBeCalled: true,
+          },
+          {
+            description: 'reachabilityShouldRun returns false',
+            configuration: {
+              reachabilityShouldRun: () => false,
+            },
+            expectedConnectionInfo: {
+              type: 'wifi',
+              isConnected: true,
+              details: {
+                isConnectionExpensive: true,
+                cellularGeneration: 'unknown',
+              },
+            },
+            expectedIsInternetReachable: false,
+            expectFetchToBeCalled: false,
+          },
+        ];
+      }
+
+      dataProvider().forEach(testCase => {
+        it(testCase.description, async () => {
+          mockNativeModule.getCurrentState.mockResolvedValue(
+            testCase.expectedConnectionInfo,
+          );
+
+          // Configure NetInfo.
+          NetInfo.configure(testCase.configuration);
+
+          await expect(NetInfo.fetch()).resolves.toEqual({
+            ...testCase.expectedConnectionInfo,
+            isInternetReachable: testCase.expectedIsInternetReachable,
+          });
+
+          testCase.expectFetchToBeCalled
+            ? expect(fetchMock).toHaveBeenCalled()
+            : expect(fetchMock).not.toHaveBeenCalled();
+        });
+      });
+    });
+  });
+});

package/NetInfo/src/index.ts

@@ -0,0 +1,186 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import {useState, useEffect, useCallback} from 'react';
+import {Platform} from 'react-native';
+import DEFAULT_CONFIGURATION from './internal/defaultConfiguration';
+import NativeInterface from './internal/nativeInterface';
+import State from './internal/state';
+import * as Types from './internal/types';
+
+// Stores the currently used configuration
+let _configuration = DEFAULT_CONFIGURATION;
+
+// Stores the singleton reference to the state manager
+let _state: State | null = null;
+const createState = (): State => {
+  return new State(_configuration);
+};
+
+/**
+ * Configures the library with the given configuration. Note that calling this will stop all
+ * previously added listeners from being called again. It is best to call this right when your
+ * application is started to avoid issues. The configuration sets up a global singleton instance.
+ *
+ * @param configuration The new configuration to set.
+ */
+export function configure(
+  configuration: Partial<Types.NetInfoConfiguration>,
+): void {
+  _configuration = {
+    ...DEFAULT_CONFIGURATION,
+    ...configuration,
+  };
+
+  if (_state) {
+    _state.tearDown();
+    _state = createState();
+  }
+
+  if (Platform.OS === 'ios') {
+    NativeInterface.configure(configuration);
+  }
+}
+
+/**
+ * Returns a `Promise` that resolves to a `NetInfoState` object.
+ * This function operates on the global singleton instance configured using `configure()`
+ *
+ * @param [requestedInterface] interface from which to obtain the information
+ *
+ * @returns A Promise which contains the current connection state.
+ */
+export function fetch(
+  requestedInterface?: string,
+): Promise<Types.NetInfoState> {
+  if (!_state) {
+    _state = createState();
+  }
+  return _state.latest(requestedInterface);
+}
+
+/**
+ * Force-refreshes the internal state of the global singleton managed by this library.
+ *
+ * @returns A Promise which contains the updated connection state.
+ */
+export function refresh(): Promise<Types.NetInfoState> {
+  if (!_state) {
+    _state = createState();
+  }
+  return _state._fetchCurrentState();
+}
+
+/**
+ * Subscribe to the global singleton's connection information. The callback is called with a parameter of type
+ * [`NetInfoState`](README.md#netinfostate) whenever the connection state changes. Your listener
+ * will be called with the latest information soon after you subscribe and then with any
+ * subsequent changes afterwards. You should not assume that the listener is called in the same
+ * way across devices or platforms.
+ *
+ * @param listener The listener which is called when the network state changes.
+ *
+ * @returns A function which can be called to unsubscribe.
+ */
+export function addEventListener(
+  listener: Types.NetInfoChangeHandler,
+): Types.NetInfoSubscription {
+  if (!_state) {
+    _state = createState();
+  }
+
+  _state.add(listener);
+  return (): void => {
+    _state && _state.remove(listener);
+  };
+}
+
+/**
+ * A React Hook into this library's singleton which updates when the connection state changes.
+ *
+ * @param {Partial<Types.NetInfoConfiguration>} configuration - Configure the isolated network checker managed by this hook
+ *
+ * @returns The connection state.
+ */
+export function useNetInfo(
+  configuration?: Partial<Types.NetInfoConfiguration>,
+): Types.NetInfoState {
+  if (configuration) {
+    configure(configuration);
+  }
+
+  const [netInfo, setNetInfo] = useState<Types.NetInfoState>({
+    type: Types.NetInfoStateType.unknown,
+    isConnected: null,
+    isInternetReachable: null,
+    details: null,
+  });
+
+  useEffect((): (() => void) => {
+    return addEventListener(setNetInfo);
+  }, []);
+
+  return netInfo;
+}
+
+/**
+ * A React Hook which manages an isolated instance of the network info manager.
+ * This is not a hook into a singleton shared state. NetInfo.configure, NetInfo.addEventListener,
+ * NetInfo.fetch, NetInfo.refresh are performed on a global singleton and have no affect on this hook.
+ * @param {boolean} isPaused - Pause the internal network checks.
+ * @param {Partial<Types.NetInfoConfiguration>} configuration - Configure the isolated network checker managed by this hook
+ *
+ * @returns the netInfo state and a refresh function
+ */
+export function useNetInfoInstance(
+  isPaused = false,
+  configuration?: Partial<Types.NetInfoConfiguration>,
+) {
+  const [networkInfoManager, setNetworkInfoManager] = useState<State>();
+  const [netInfo, setNetInfo] = useState<Types.NetInfoState>({
+    type: Types.NetInfoStateType.unknown,
+    isConnected: null,
+    isInternetReachable: null,
+    details: null,
+  });
+
+  useEffect(() => {
+    if (isPaused) {
+      return;
+    }
+    const config = {
+      ...DEFAULT_CONFIGURATION,
+      ...configuration,
+    };
+    const state = new State(config);
+    setNetworkInfoManager(state);
+    state.add(setNetInfo);
+    return state.tearDown;
+  }, [isPaused, configuration]);
+
+  const refresh = useCallback(() => {
+    networkInfoManager && networkInfoManager._fetchCurrentState();
+  }, [networkInfoManager]);
+
+  return {
+    netInfo,
+    refresh,
+  };
+}
+
+export * from './internal/types';
+
+export default {
+  configure,
+  fetch,
+  refresh,
+  addEventListener,
+  useNetInfo,
+  useNetInfoInstance,
+};

package/NetInfo/src/internal/__mocks__/nativeModule.ts

@@ -0,0 +1,13 @@
+/**
+ * @format
+ */
+/* eslint-env jest */
+
+const RNCNetInfoMock = {
+  configure: jest.fn(),
+  getCurrentState: jest.fn(),
+  addListener: jest.fn(),
+  removeListeners: jest.fn(),
+};
+
+export default RNCNetInfoMock;

package/NetInfo/src/internal/defaultConfiguration.ts

@@ -0,0 +1,17 @@
+import * as Types from './types';
+
+const DEFAULT_CONFIGURATION: Types.NetInfoConfiguration = {
+  reachabilityUrl: 'https://clients3.google.com/generate_204',
+  reachabilityMethod: 'HEAD',
+  reachabilityHeaders: {},
+  reachabilityTest: (response: Response): Promise<boolean> =>
+    Promise.resolve(response.status === 204),
+  reachabilityShortTimeout: 5 * 1000, // 5s
+  reachabilityLongTimeout: 60 * 1000, // 60s
+  reachabilityRequestTimeout: 15 * 1000, // 15s
+  reachabilityShouldRun: (): boolean => true,
+  shouldFetchWiFiSSID: false,
+  useNativeReachability: true
+};
+
+export default DEFAULT_CONFIGURATION;

package/NetInfo/src/internal/defaultConfiguration.web.ts

@@ -0,0 +1,17 @@
+import * as Types from './types';
+
+const DEFAULT_CONFIGURATION: Types.NetInfoConfiguration = {
+  reachabilityUrl: '/',
+  reachabilityMethod: "HEAD",
+  reachabilityHeaders: {},
+  reachabilityTest: (response: Response): Promise<boolean> =>
+    Promise.resolve(response.status === 200),
+  reachabilityShortTimeout: 5 * 1000, // 5s
+  reachabilityLongTimeout: 60 * 1000, // 60s
+  reachabilityRequestTimeout: 15 * 1000, // 15s
+  reachabilityShouldRun: (): boolean => true,
+  shouldFetchWiFiSSID: true,
+  useNativeReachability: true
+};
+
+export default DEFAULT_CONFIGURATION