packages/drive-store/store/_shares/useDefaultShare.test.tsx

   1 import { act, renderHook } from '@testing-library/react-hooks';
   2
   3 import { VolumesStateProvider } from '../_volumes/useVolumesState';
   4 import useDefaultShare from './useDefaultShare';
   5
   6 const mockRequest = jest.fn();
   7 const mockCreateVolume = jest.fn();
   8 const mockGetDefaultShareId = jest.fn();
   9 const mockGetShare = jest.fn();
  10 const mockGetShareWithKey = jest.fn();
  11
  12 jest.mock('../_api/useDebouncedRequest', () => {
  13     const useDebouncedRequest = () => {
  14         return mockRequest;
  15     };
  16     return useDebouncedRequest;
  17 });
  18
  19 jest.mock('../_api/useDebouncedRequest', () => {
  20     const useDebouncedRequest = () => {
  21         return mockRequest;
  22     };
  23     return useDebouncedRequest;
  24 });
  25
  26 jest.mock('../_crypto/useDriveCrypto', () => {
  27     const useDriveCrypto = () => {
  28         return {
  29             getOwnAddressAndPrimaryKeys: () => {},
  30         };
  31     };
  32
  33     return useDriveCrypto;
  34 });
  35
  36 jest.mock('../_utils/useDebouncedFunction', () => {
  37     const useDebouncedFunction = () => {
  38         return (wrapper: any) => wrapper();
  39     };
  40     return useDebouncedFunction;
  41 });
  42
  43 jest.mock('./useSharesState', () => {
  44     const useSharesState = () => {
  45         return {
  46             setShares: () => {},
  47             getDefaultShareId: mockGetDefaultShareId,
  48         };
  49     };
  50
  51     return {
  52         ...jest.requireActual('./useSharesState'),
  53         __esModule: true,
  54         default: useSharesState,
  55     };
  56 });
  57
  58 jest.mock('../_shares/useShare', () => {
  59     const useLink = () => {
  60         return {
  61             getShare: mockGetShare,
  62             getShareWithKey: mockGetShareWithKey,
  63         };
  64     };
  65     return useLink;
  66 });
  67
  68 jest.mock('./useVolume', () => {
  69     const useVolume = () => {
  70         return {
  71             createVolume: mockCreateVolume,
  72         };
  73     };
  74     return useVolume;
  75 });
  76
  77 describe('useDefaultShare', () => {
  78     let hook: {
  79         current: ReturnType<typeof useDefaultShare>;
  80     };
  81
  82     const defaultShareId = Symbol('shareId');
  83
  84     const ac = new AbortController();
  85
  86     beforeEach(() => {
  87         jest.resetAllMocks();
  88
  89         mockCreateVolume.mockImplementation(async () => {
  90             return { shareId: defaultShareId };
  91         });
  92
  93         mockRequest.mockImplementation(async () => {
  94             return { Shares: [] };
  95         });
  96
  97         const wrapper = ({ children }: { children: React.ReactNode }) => (
  98             <VolumesStateProvider>{children}</VolumesStateProvider>
  99         );
 100
 101         const { result } = renderHook(() => useDefaultShare(), { wrapper });
 102         hook = result;
 103     });
 104
 105     it('creates a volume if existing shares are locked/soft deleted', async () => {
 106         mockGetDefaultShareId.mockImplementation(() => {
 107             // no valid shares were found
 108             return undefined;
 109         });
 110
 111         await act(async () => {
 112             await hook.current.getDefaultShare();
 113         });
 114
 115         expect(mockCreateVolume.mock.calls.length).toBe(1);
 116         expect(mockGetShareWithKey).toHaveBeenCalledWith(expect.anything(), defaultShareId);
 117     });
 118
 119     it('creates a volume if no shares exist', async () => {
 120         mockRequest.mockImplementation(async () => {
 121             return { Shares: [] };
 122         });
 123
 124         await act(async () => {
 125             await hook.current.getDefaultShare();
 126         });
 127
 128         expect(mockCreateVolume.mock.calls.length).toBe(1);
 129         expect(mockGetShareWithKey).toHaveBeenCalledWith(expect.anything(), defaultShareId);
 130     });
 131
 132     it("creates a volume if default share doesn't exist", async () => {
 133         mockRequest.mockImplementation(async () => {
 134             return {
 135                 Shares: [
 136                     {
 137                         isDefault: false,
 138                     },
 139                 ],
 140             };
 141         });
 142
 143         await act(async () => {
 144             await hook.current.getDefaultShare();
 145         });
 146
 147         expect(mockCreateVolume.mock.calls.length).toBe(1);
 148         expect(mockGetShareWithKey).toHaveBeenCalledWith(expect.anything(), defaultShareId);
 149     });
 150
 151     it('says share is available by default', async () => {
 152         mockGetShare.mockImplementation(async () => ({}));
 153
 154         await act(async () => {
 155             const isAvailable = await hook.current.isShareAvailable(ac.signal, 'shareId');
 156             expect(isAvailable).toBeTruthy();
 157         });
 158     });
 159
 160     it('says share is not available if locked', async () => {
 161         mockGetShare.mockImplementation(async () => {
 162             return {
 163                 isLocked: true,
 164             };
 165         });
 166
 167         await act(async () => {
 168             const isAvailable = await hook.current.isShareAvailable(ac.signal, 'shareId');
 169             expect(isAvailable).toBeFalsy();
 170         });
 171     });
 172
 173     it('says share is not available if soft deleted', async () => {
 174         mockGetShare.mockImplementation(async () => {
 175             return {
 176                 isVolumeSoftDeleted: true,
 177             };
 178         });
 179
 180         await act(async () => {
 181             const isAvailable = await hook.current.isShareAvailable(ac.signal, 'shareId');
 182             expect(isAvailable).toBeFalsy();
 183         });
 184     });
 185 });