xref: /expo/apps/test-suite/tests/TaskManager.js (revision 22d1e005) 
1import * as BackgroundFetch from 'expo-background-fetch';
2import * as TaskManager from 'expo-task-manager';
3
4const DEFINED_TASK_NAME = 'defined task';
5const UNDEFINED_TASK_NAME = 'undefined task';
6
7export const name = 'TaskManager';
8
9export async function test(t) {
10  const backgroundFetchOptions = {
11    minimumInterval: 15 * 60, // 15min in sec
12    stopOnTerminate: false,
13    startOnBoot: true,
14  };
15
16  t.describe('TaskManager', () => {
17    t.describe('isTaskDefined()', () => {
18      t.it('returns true if task is defined', () => {
19        t.expect(TaskManager.isTaskDefined(DEFINED_TASK_NAME)).toBe(true);
20      });
21      t.it('returns false if task is not defined', () => {
22        t.expect(TaskManager.isTaskDefined(UNDEFINED_TASK_NAME)).toBe(false);
23      });
24    });
25
26    t.describe('isTaskRegisteredAsync()', async () => {
27      t.beforeAll(async () => {
28        await BackgroundFetch.registerTaskAsync(DEFINED_TASK_NAME);
29      });
30
31      t.it('returns true for registered tasks', async () => {
32        t.expect(await TaskManager.isTaskRegisteredAsync(DEFINED_TASK_NAME)).toBe(true);
33      });
34
35      t.it('returns false for unregistered tasks', async () => {
36        t.expect(await TaskManager.isTaskRegisteredAsync(UNDEFINED_TASK_NAME)).toBe(false);
37      });
38
39      t.afterAll(async () => {
40        await BackgroundFetch.unregisterTaskAsync(DEFINED_TASK_NAME);
41      });
42    });
43
44    t.describe('getTaskOptionsAsync()', async () => {
45      let taskOptions;
46
47      t.it('returns null for unregistered tasks', async () => {
48        taskOptions = await TaskManager.getTaskOptionsAsync(DEFINED_TASK_NAME);
49        t.expect(taskOptions).toBe(null);
50      });
51
52      t.it('returns correct options after register', async () => {
53        await BackgroundFetch.registerTaskAsync(DEFINED_TASK_NAME, backgroundFetchOptions);
54        taskOptions = await TaskManager.getTaskOptionsAsync(DEFINED_TASK_NAME);
55        t.expect(taskOptions).toEqual(t.jasmine.objectContaining(backgroundFetchOptions));
56      });
57
58      t.it('returns null when unregistered', async () => {
59        await BackgroundFetch.unregisterTaskAsync(DEFINED_TASK_NAME);
60        taskOptions = await TaskManager.getTaskOptionsAsync(DEFINED_TASK_NAME);
61        t.expect(taskOptions).toBe(null);
62      });
63    });
64
65    t.describe('getRegisteredTasksAsync()', async () => {
66      let registeredTasks;
67
68      t.it('returns empty array if there are no tasks', async () => {
69        registeredTasks = await TaskManager.getRegisteredTasksAsync();
70        t.expect(registeredTasks).toBeDefined();
71        t.expect(registeredTasks.length).toBe(0);
72      });
73
74      t.it('returns correct array after registering the task', async () => {
75        await BackgroundFetch.registerTaskAsync(DEFINED_TASK_NAME, backgroundFetchOptions);
76
77        registeredTasks = await TaskManager.getRegisteredTasksAsync();
78
79        t.expect(registeredTasks).toBeDefined();
80        t.expect(registeredTasks.length).toBe(1);
81        t.expect(registeredTasks.find((task) => task.taskName === DEFINED_TASK_NAME)).toEqual(
82          t.jasmine.objectContaining({
83            taskName: DEFINED_TASK_NAME,
84            taskType: 'backgroundFetch',
85            options: backgroundFetchOptions,
86          })
87        );
88      });
89
90      t.afterAll(async () => {
91        await BackgroundFetch.unregisterTaskAsync(DEFINED_TASK_NAME);
92      });
93    });
94
95    t.describe('unregisterAllTasksAsync()', () => {
96      t.it('unregisters tasks correctly', async () => {
97        await BackgroundFetch.registerTaskAsync(DEFINED_TASK_NAME, backgroundFetchOptions);
98        await TaskManager.unregisterAllTasksAsync();
99
100        t.expect(await TaskManager.isTaskRegisteredAsync(DEFINED_TASK_NAME)).toBe(false);
101        t.expect((await TaskManager.getRegisteredTasksAsync()).length).toBe(0);
102      });
103    });
104
105    t.describe('rejections', () => {
106      t.it('should reject when trying to unregister non-existing tasks', async () => {
107        await BackgroundFetch.registerTaskAsync(DEFINED_TASK_NAME, backgroundFetchOptions);
108
109        let error;
110        try {
111          await BackgroundFetch.unregisterTaskAsync(UNDEFINED_TASK_NAME);
112        } catch (e) {
113          error = e;
114        }
115        t.expect(error).toBeDefined();
116        t.expect(error.message).toMatch(/not found/);
117
118        await BackgroundFetch.unregisterTaskAsync(DEFINED_TASK_NAME);
119      });
120    });
121  });
122}
123
124// Empty task so we can properly test some methods.
125// We are telling iOS that we successfully fetched new data, to prevent possible throttle from iOS
126TaskManager.defineTask(DEFINED_TASK_NAME, () => BackgroundFetch.BackgroundFetchResult.NewData);
127