1/*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
17import { agent } from '@ohos.request';
18import featureAbility from '@ohos.ability.featureAbility'
19import fs from '@ohos.file.fs';
20
21describe('RequestTaskTest', function () {
22    beforeAll(function () {
23        console.info('beforeAll called')
24    })
25
26    afterAll(function () {
27        console.info('afterAll called')
28    })
29
30    beforeEach(function () {
31        console.info('beforeEach called')
32    })
33
34    afterEach(async function () {
35        console.info('afterEach called')
36        if (fs.accessSync(cacheDir + '/test.txt')) {
37            fs.unlinkSync(cacheDir + '/test.txt')
38        }
39        if (fs.accessSync(cacheDir + '/test.apk')) {
40            fs.unlinkSync(cacheDir + '/test.apk')
41        }
42        if (task !== undefined) {
43            await agent.remove(context, task.tid)
44            task = undefined
45        }
46    })
47
48    function sleep(ms) {
49        return new Promise(resolve => setTimeout(resolve, ms))
50    }
51
52    let task;
53    let context = featureAbility.getContext();
54    let cacheDir = '/data/storage/el2/base/haps/entry/files';
55    let fileSpec = {
56        path: `${cacheDir}/test.txt`
57    }
58    let formItem = [{
59        name: 'test',
60        type: `${cacheDir}`,
61        value: [fileSpec]
62    }]
63
64    function errorParamCreate(conf, code) {
65        agent.create(conf, (err) => {
66            if (err) {
67                expect(err.code).assertEqual(code)
68                done()
69            } else {
70                expect(false).assertTrue();
71                done()
72            }
73        })
74    }
75
76    function createLamdaApi10(conf, isError, isNotError) {
77        agent.create(conf, (err) => {
78            if (err) {
79                expect(isError).assertTrue()
80                done()
81            } else {
82                expect(isNotError).assertTrue();
83                done()
84            }
85        })
86    }
87
88    async function createApi10Task(conf) {
89        task = await agent.create(conf);
90        task.start().then(() => {
91            expect(true).assertTrue()
92            done()
93        }).catch((err) => {
94            expect(false).assertTrue()
95            done()
96        })
97    }
98
99    async function createApi10GetTask(conf) {
100        task = await agent.create(conf);
101        task.start().then(() => {
102            expect(task.conf.method).assertEqual('GET')
103            done()
104        }).catch((err) => {
105            expect(false).assertTrue()
106            done()
107        })
108    }
109
110    function wrapTryCatch(conf, code) {
111        try {
112            errorParamCreate(conf, code)
113        } catch (err) {
114            expect(err.code).assertEqual(code)
115            done()
116        }
117    }
118
119    let globalConf = {
120        action: agent.Action.UPLOAD,
121        url: 'http://127.0.0.1',
122        data: {
123            name: 'test',
124            value: {
125                path: `${cacheDir}/test.txt`
126            },
127        }
128    }
129
130    function openSyncFile(fileName) {
131        let file = fs.openSync(cacheDir + '/' + fileName, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
132        fs.closeSync(file);
133    }
134
135    /**
136     * @tc.number: testTaskAction001
137     * @tc.name: testTaskAction001
138     * @tc.desc: Test create task when lack action
139     * @tc.size: MediumTest
140     * @tc.type: Function
141     * @tc.level: Level 1
142     * @tc.require:
143     */
144    it('testTaskAction001', function (done) {
145        let conf = {
146            url: 'http://127.0.0.1',
147        }
148        expect(true).assertTrue();
149        wrapTryCatch(conf, 401);
150    })
151
152    /**
153     * @tc.number: testTaskAction002
154     * @tc.name: testTaskAction002
155     * @tc.desc: Test create task when action is string
156     * @tc.size: MediumTest
157     * @tc.type: Function
158     * @tc.level: Level 1
159     * @tc.require:
160     */
161    it('testTaskAction002', async function (done) {
162        let conf = {
163            action: 'UPLOAD',
164            url: 'http://127.0.0.1'
165        }
166        expect(true).assertTrue();
167        wrapTryCatch(conf, 401);
168    })
169
170    /**
171     * @tc.number: testTaskAction003
172     * @tc.name: testTaskAction003
173     * @tc.desc: Test create task when action is 2
174     * @tc.size: MediumTest
175     * @tc.type: Function
176     * @tc.level: Level 1
177     * @tc.require:
178     */
179    it('testTaskAction003', function (done) {
180        let conf = {
181            action: 2,
182            url: 'http://127.0.0.1'
183        }
184        expect(true).assertTrue();
185        createLamdaApi10(conf, true, false)
186    })
187
188    /**
189     * @tc.number: testTaskAction004
190     * @tc.name: testTaskAction004
191     * @tc.desc: Test create task when action is UPLOAD
192     * @tc.size: MediumTest
193     * @tc.type: Function
194     * @tc.level: Level 1
195     * @tc.require:
196     */
197    it('testTaskAction004', function (done) {
198        openSyncFile('test.txt');
199        let conf = {
200            action: agent.Action.UPLOAD,
201            url: 'http://127.0.0.1',
202            data: formItem
203        }
204        agent.create(conf, async (err, data) => {
205            if (err) {
206                expect(false).assertTrue()
207                done()
208            }
209            expect(true).assertTrue()
210            done()
211        })
212    })
213
214    /**
215     * @tc.number: testTaskAction005
216     * @tc.name: testTaskAction005
217     * @tc.desc: Test create task when action is DOWNLOAD
218     * @tc.size: MediumTest
219     * @tc.type: Function
220     * @tc.level: Level 1
221     * @tc.require:
222     */
223    it('testTaskAction005', function (done) {
224        let conf = {
225            action: agent.Action.DOWNLOAD,
226            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
227            saveas: `${cacheDir}`
228        }
229        agent.create(conf, async (err, data) => {
230            if (err) {
231                expect(false).assertTrue()
232                done()
233            }
234            data.on('completed', function (progress) {
235                if (fs.accessSync(`${cacheDir}/test.txt`)) {
236                    expect(true).assertTrue()
237                    done()
238                }
239            })
240        })
241    })
242
243    /**
244     * @tc.number: testTaskUrl001
245     * @tc.name: testTaskUrl001
246     * @tc.desc: Test create task when lack url
247     * @tc.size: MediumTest
248     * @tc.type: Function
249     * @tc.level: Level 1
250     * @tc.require:
251     */
252    it('testTaskUrl001', function (done) {
253        let conf = {
254            action: agent.Action.DOWNLOAD,
255        }
256        expect(true).assertTrue();
257        wrapTryCatch(conf, 401);
258    })
259
260    /**
261     * @tc.number: testTaskUrl002
262     * @tc.name: testTaskUrl002
263     * @tc.desc: Test create task when url is empty
264     * @tc.size: MediumTest
265     * @tc.type: Function
266     * @tc.level: Level 1
267     * @tc.require:
268     */
269    it('testTaskUrl002', function (done) {
270        let conf = {
271            action: agent.Action.DOWNLOAD,
272            url: '',
273        };
274        expect(true).assertTrue();
275        createLamdaApi10(conf, true, false);
276    })
277
278    /**
279     * @tc.number: testTaskUrl003
280     * @tc.name: testTaskUrl003
281     * @tc.desc: Test create task when url is not support download
282     * @tc.size: MediumTest
283     * @tc.type: Function
284     * @tc.level: Level 1
285     * @tc.require:
286     */
287    it('testTaskUrl003', function (done) {
288        let conf = {
289            action: agent.Action.DOWNLOAD,
290            url: 'https://gitee.com/openharmony/request_request',
291        }
292        expect(true).assertTrue();
293        errorParamCreate(conf, 13400003)
294    })
295
296    /**
297     * @tc.number: testTaskUrl004
298     * @tc.name: testTaskUrl004
299     * @tc.desc: Test create task when url is not support upload
300     * @tc.size: MediumTest
301     * @tc.type: Function
302     * @tc.level: Level 1
303     * @tc.require:
304     */
305    it('testTaskUrl004', function (done) {
306        openSyncFile('test.txt');
307        let conf = {
308            action: agent.Action.UPLOAD,
309            url: 'https://gitee.com/openharmony/request_request',
310            data: formItem
311        }
312        expect(true).assertTrue();
313        errorParamCreate(conf, 13400003)
314    })
315
316    /**
317     * @tc.number: testTaskTitle001
318     * @tc.name: testTaskTitle001
319     * @tc.desc: Test create task when title is given
320     * @tc.size: MediumTest
321     * @tc.type: Function
322     * @tc.level: Level 1
323     * @tc.require:
324     */
325    it('testTaskTitle001', async function (done) {
326        openSyncFile('test.txt')
327        let tmpConf = JSON.parse(JSON.stringify(globalConf));
328        tmpConf.title = 'upload test.txt';
329        task = await agent.create(tmpConf);
330        expect(task.title).assertEqual('upload test.txt')
331        done()
332    })
333
334    /**
335     * @tc.number: testTaskTitle002
336     * @tc.name: testTaskTitle002
337     * @tc.desc: Test create task when title is number
338     * @tc.size: MediumTest
339     * @tc.type: Function
340     * @tc.level: Level 1
341     * @tc.require:
342     */
343    it('testTaskTitle002', async function (done) {
344        let tmpConf = JSON.parse(JSON.stringify(globalConf));
345        tmpConf.title = 123;
346        task = await agent.create(tmpConf);
347        expect(task.title).assertEqual("")
348        done()
349    })
350
351    /**
352     * @tc.number: testTaskDescription001
353     * @tc.name: testTaskDescription001
354     * @tc.desc: Test create task when description is given
355     * @tc.size: MediumTest
356     * @tc.type: Function
357     * @tc.level: Level 1
358     * @tc.require:
359     */
360    it('testTaskDescription001', async function (done) {
361        openSyncFile('test.txt')
362        let tmpConf = JSON.parse(JSON.stringify(globalConf));
363        tmpConf.description = 'test upload'
364        task = await agent.create(tmpConf);
365        expect(task.description).assertEqual('test upload')
366        expect(task.conf.mode).assertEqual(agent.Mode.BACKGROUND)
367        done()
368    })
369
370    /**
371     * @tc.number: testTaskDescription002
372     * @tc.name: testTaskDescription002
373     * @tc.desc: Test create task when description is number
374     * @tc.size: MediumTest
375     * @tc.type: Function
376     * @tc.level: Level 1
377     * @tc.require:
378     */
379    it('testTaskDescription002', async function (done) {
380        let tmpConf = JSON.parse(JSON.stringify(globalConf));
381        tmpConf.title = 123;
382        task = await agent.create(tmpConf);
383        expect(task.description).assertEqual("")
384        done()
385    })
386
387    /**
388     * @tc.number: testTaskMode001
389     * @tc.name: testTaskMode001
390     * @tc.desc: Test create task when mode is FRONTEND
391     * @tc.size: MediumTest
392     * @tc.type: Function
393     * @tc.level: Level 1
394     * @tc.require:
395     */
396    it('testTaskMode001', async function (done) {
397        let conf = {
398            action: agent.Action.UPLOAD,
399            url: 'http://127.0.0.1',
400            data: {
401                name: 'test',
402                value: {
403                    path: `${cacheDir}/test.txt`
404                },
405            },
406            mode: agent.Mode.FRONTEND
407        }
408        task = await agent.create(conf);
409        task.start().then(() => {
410            agent.remove(context, task.tid)
411            expect(true).assertTrue()
412            done()
413        }).catch((err) => {
414            expect(false).assertTrue()
415            done()
416        })
417    })
418
419    /**
420     * @tc.number: testTaskMode002
421     * @tc.name: testTaskMode002
422     * @tc.desc: Test create task when mode is BACKGROUND
423     * @tc.size: MediumTest
424     * @tc.type: Function
425     * @tc.level: Level 1
426     * @tc.require:
427     */
428    it('testTaskMode002', async function (done) {
429        let conf = JSON.parse(JSON.stringify(globalConf));
430        conf.mode = agent.Mode.BACKGROUND;
431        expect(true).assertTrue();
432        await createApi10Task(conf);
433    })
434
435    /**
436     * @tc.number: testTaskMode003
437     * @tc.name: testTaskMode003
438     * @tc.desc: Test create task when mode is string
439     * @tc.size: MediumTest
440     * @tc.type: Function
441     * @tc.level: Level 1
442     * @tc.require:
443     */
444    it('testTaskMode003', async function (done) {
445        let conf = {
446            action: agent.Action.UPLOAD,
447            url: 'http://127.0.0.1',
448            data: {
449                name: 'test',
450                value: {
451                    path: `${cacheDir}/test.txt`
452                },
453            },
454            mode: "BACKGROUND"
455        }
456        task = await agent.create(conf);
457        task.start().then(() => {
458            expect(task.conf.mode).assertEqual(agent.Mode.BACKGROUND)
459            done()
460        }).catch((err) => {
461            expect(false).assertTrue()
462            done()
463        })
464    })
465
466    /**
467     * @tc.number: testTaskCover001
468     * @tc.name: testTaskCover001
469     * @tc.desc: Test create task when cover is true and file exists
470     * @tc.size: MediumTest
471     * @tc.type: Function
472     * @tc.level: Level 1
473     * @tc.require:
474     */
475    it('testTaskCover001', async function (done) {
476        openSyncFile('test.txt')
477        let conf = JSON.parse(JSON.stringify(globalConf));
478        conf.url = 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt';
479        conf.action = agent.Action.DOWNLOAD;
480        conf.saveas = 'testTaskCover001.txt';
481        conf.cover = true;
482        expect(true).assertTrue()
483        await createApi10Task(conf);
484    })
485
486    /**
487     * @tc.number: testTaskCover002
488     * @tc.name: testTaskCover002
489     * @tc.desc: Test create task when cover is true and file not exists
490     * @tc.size: MediumTest
491     * @tc.type: Function
492     * @tc.level: Level 1
493     * @tc.require:
494     */
495    it('testTaskCover002', async function (done) {
496        let conf = JSON.parse(JSON.stringify(globalConf));
497        conf.url = 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt';
498        conf.action = agent.Action.DOWNLOAD;
499        conf.saveas = 'testTaskCover002.txt';
500        conf.cover = true;
501        expect(true).assertTrue()
502        await createApi10Task(conf);
503    })
504
505    /**
506     * @tc.number: testTaskCover003
507     * @tc.name: testTaskCover003
508     * @tc.desc: Test create task when cover is false and file exists
509     * @tc.size: MediumTest
510     * @tc.type: Function
511     * @tc.level: Level 1
512     * @tc.require:
513     */
514    it('testTaskCover003', async function (done) {
515        openSyncFile('test.txt')
516        let conf = JSON.parse(JSON.stringify(globalConf));
517        conf.url = 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt';
518        conf.action = agent.Action.DOWNLOAD;
519        conf.saveas = 'testTaskCover003.txt';
520        conf.cover = false;
521        expect(true).assertTrue()
522        await createApi10Task(conf);
523    })
524
525    /**
526     * @tc.number: testTaskCover004
527     * @tc.name: testTaskCover004
528     * @tc.desc: Test create task when cover is false and file not exists
529     * @tc.size: MediumTest
530     * @tc.type: Function
531     * @tc.level: Level 1
532     * @tc.require:
533     */
534    it('testTaskCover004', async function (done) {
535        let conf = JSON.parse(JSON.stringify(globalConf));
536        conf.url = 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt';
537        conf.action = agent.Action.DOWNLOAD;
538        conf.saveas = 'testTaskCover004.txt';
539        conf.cover = false;
540        expect(true).assertTrue()
541        await createApi10Task(conf);
542    })
543
544    /**
545     * @tc.number: testTaskCover005
546     * @tc.name: testTaskCover005
547     * @tc.desc: Test create task when cover is string
548     * @tc.size: MediumTest
549     * @tc.type: Function
550     * @tc.level: Level 1
551     * @tc.require:
552     */
553    it('testTaskCover005', async function (done) {
554        let conf = {
555            action: agent.Action.DOWNLOAD,
556            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
557            data: {
558                name: 'test',
559                value: {
560                    path: `${cacheDir}/test.txt`
561                },
562            },
563            cover: "true"
564        }
565        task = await agent.create(conf);
566        task.start().then(() => {
567            expect(task.conf.cover).assertEqual(true)
568            done()
569        }).catch((err) => {
570            expect(false).assertTrue()
571            done()
572        })
573    })
574
575    /**
576     * @tc.number: testTaskMethod001
577     * @tc.name: testTaskMethod001
578     * @tc.desc: Test create task when method is POST for upload
579     * @tc.size: MediumTest
580     * @tc.type: Function
581     * @tc.level: Level 1
582     * @tc.require:
583     */
584    it('testTaskMethod001', async function (done) {
585        openSyncFile('test.txt');
586        let tmpConf = JSON.parse(JSON.stringify(globalConf));
587        tmpConf.method = 'POST';
588        expect(true).assertTrue()
589        await createApi10Task(conf);
590    })
591
592    /**
593     * @tc.number: testTaskMethod002
594     * @tc.name: testTaskMethod002
595     * @tc.desc: Test create task when method is POST for download
596     * @tc.size: MediumTest
597     * @tc.type: Function
598     * @tc.level: Level 1
599     * @tc.require:
600     */
601    it('testTaskMethod002', async function (done) {
602        let conf = {
603            action: agent.Action.DOWNLOAD,
604            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
605            saveas: `${cacheDir}/testTaskMethod002.txt`,
606            method: 'POST'
607        }
608        expect(true).assertTrue()
609        await createApi10Task(conf);
610    })
611
612    /**
613     * @tc.number: testTaskMethod003
614     * @tc.name: testTaskMethod003
615     * @tc.desc: Test create task when method is number
616     * @tc.size: MediumTest
617     * @tc.type: Function
618     * @tc.level: Level 1
619     * @tc.require:
620     */
621    it('testTaskMethod003', async function (done) {
622        let conf = {
623            action: agent.Action.DOWNLOAD,
624            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
625            saveas: `${cacheDir}/testTaskMethod003.txt`,
626            method: 123
627        }
628        expect(true).assertTrue()
629        await createApi10GetTask(conf)
630    })
631
632    /**
633     * @tc.number: testTaskMethod004
634     * @tc.name: testTaskMethod004
635     * @tc.desc: Test create task when method is empty
636     * @tc.size: MediumTest
637     * @tc.type: Function
638     * @tc.level: Level 1
639     * @tc.require:
640     */
641    it('testTaskMethod004', async function (done) {
642        let conf = {
643            action: agent.Action.DOWNLOAD,
644            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
645            saveas: `${cacheDir}/testTaskMethod004.txt`,
646            method: ''
647        }
648        expect(true).assertTrue()
649        await createApi10GetTask(conf)
650    })
651
652    /**
653     * @tc.number: testTaskMethod005
654     * @tc.name: testTaskMethod005
655     * @tc.desc: Test create task when method is GET for upload
656     * @tc.size: MediumTest
657     * @tc.type: Function
658     * @tc.level: Level 1
659     * @tc.require:
660     */
661    it('testTaskMethod005', async function (done) {
662        openSyncFile('test.txt');
663        let tmpConf = JSON.parse(JSON.stringify(globalConf));
664        tmpConf.method = 'GET';
665        expect(true).assertTrue()
666        await createApi10Task(conf);
667    })
668
669    /**
670     * @tc.number: testTaskMethod006
671     * @tc.name: testTaskMethod006
672     * @tc.desc: Test create task when method is PUT for download
673     * @tc.size: MediumTest
674     * @tc.type: Function
675     * @tc.level: Level 1
676     * @tc.require:
677     */
678    it('testTaskMethod006', async function (done) {
679        let conf = {
680            action: agent.Action.DOWNLOAD,
681            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
682            saveas: `${cacheDir}/testTaskMethod006.txt`,
683            method: 'PUT'
684        }
685        expect(true).assertTrue()
686        await createApi10Task(conf);
687    })
688
689    /**
690     * @tc.number: testTaskHeaders001
691     * @tc.name: testTaskHeaders001
692     * @tc.desc: Test create task when headers content-type is application/json but data is file for upload
693     * @tc.size: MediumTest
694     * @tc.type: Function
695     * @tc.level: Level 1
696     * @tc.require:
697     */
698    it('testTaskHeaders001', async function (done) {
699        openSyncFile('test.txt');
700        let tmpConf = JSON.parse(JSON.stringify(globalConf));
701        tmpConf.headers = JSON.stringify({ 'content-type': 'application/json' });
702        expect(true).assertTrue()
703        await createApi10Task(conf);
704    })
705
706    /**
707     * @tc.number: testTaskHeaders002
708     * @tc.name: testTaskHeaders002
709     * @tc.desc: Test create task when lack headers for upload
710     * @tc.size: MediumTest
711     * @tc.type: Function
712     * @tc.level: Level 1
713     * @tc.require:
714     */
715    it('testTaskHeaders002', async function (done) {
716        openSyncFile('test.txt');
717        let tmpConf = JSON.parse(JSON.stringify(globalConf));
718        task = await agent.create(tmpConf);
719        task.start().then(() => {
720            expect(task.conf.headers).assertEqual('multipart/form-data')
721            done()
722        }).catch((err) => {
723            expect(false).assertTrue()
724            done()
725        })
726    })
727
728    /**
729     * @tc.number: testTaskHeaders003
730     * @tc.name: testTaskHeaders003
731     * @tc.desc: Test create task when lack headers for download
732     * @tc.size: MediumTest
733     * @tc.type: Function
734     * @tc.level: Level 1
735     * @tc.require:
736     */
737    it('testTaskHeaders003', async function (done) {
738        let conf = {
739            action: agent.Action.DOWNLOAD,
740            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
741            saveas: 'testTaskHeaders003.txt',
742        }
743        task = await agent.create(conf);
744        task.start().then(() => {
745            expect(task.conf.headers).assertEqual('application/json')
746            done()
747        }).catch((err) => {
748            expect(false).assertTrue()
749            done()
750        })
751    })
752
753    /**
754     * @tc.number: testTaskSaveas001
755     * @tc.name: testTaskSaveas001
756     * @tc.desc: Test create task when lack saveas is number for download
757     * @tc.size: MediumTest
758     * @tc.type: Function
759     * @tc.level: Level 1
760     * @tc.require:
761     */
762    it('testTaskSaveas001', async function (done) {
763        let conf = {
764            action: agent.Action.DOWNLOAD,
765            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
766            saveas: 123
767        }
768        task = await agent.create(conf);
769        task.on('completed', function () {
770            if (fs.accessSync(`${cacheDir}/test.txt`)) {
771                expect(true).assertTrue()
772                done()
773            }
774        })
775        task.start()
776    })
777
778    /**
779     * @tc.number: testTaskData001
780     * @tc.name: testTaskData001
781     * @tc.desc: Test create task when data lack name
782     * @tc.size: MediumTest
783     * @tc.type: Function
784     * @tc.level: Level 1
785     * @tc.require:
786     */
787    it('testTaskData001', function (done) {
788        openSyncFile('test.txt');
789        let conf = JSON.parse(JSON.stringify(globalConf));
790        conf.data = {
791            value: {
792                path: `${cacheDir}/test.txt`
793            },
794        };
795        expect(true).assertTrue()
796        wrapTryCatch(conf, 401);
797    })
798
799    /**
800     * @tc.number: testTaskData002
801     * @tc.name: testTaskData002
802     * @tc.desc: Test create task when data name is number
803     * @tc.size: MediumTest
804     * @tc.type: Function
805     * @tc.level: Level 1
806     * @tc.require:
807     */
808    it('testTaskData002', function (done) {
809        openSyncFile('test.txt');
810        let conf = JSON.parse(JSON.stringify(globalConf));
811        conf.data.name = 123;
812        expect(true).assertTrue()
813        wrapTryCatch(conf, 401);
814    })
815
816    /**
817     * @tc.number: testTaskData003
818     * @tc.name: testTaskData003
819     * @tc.desc: Test create task when data lack value
820     * @tc.size: MediumTest
821     * @tc.type: Function
822     * @tc.level: Level 1
823     * @tc.require:
824     */
825    it('testTaskData003', function (done) {
826        openSyncFile('test.txt');
827        let conf = {
828            action: agent.Action.UPLOAD,
829            url: 'http://127.0.0.1',
830            data: {
831                name: 'test'
832            }
833        }
834        expect(true).assertTrue()
835        wrapTryCatch(conf, 401);
836    })
837
838    /**
839     * @tc.number: testTaskData004
840     * @tc.name: testTaskData004
841     * @tc.desc: Test create task when data value is number
842     * @tc.size: MediumTest
843     * @tc.type: Function
844     * @tc.level: Level 1
845     * @tc.require:
846     */
847    it('testTaskData004', function (done) {
848        openSyncFile('test.txt');
849        let conf = {
850            action: agent.Action.UPLOAD,
851            url: 'http://127.0.0.1',
852            data: {
853                name: 'test',
854                value: 123
855            }
856        }
857        expect(true).assertTrue()
858        wrapTryCatch(conf, 401);
859    })
860
861    /**
862     * @tc.number: testTaskData005
863     * @tc.name: testTaskData005
864     * @tc.desc: Test create task when data path is '', path is not exits
865     * @tc.size: MediumTest
866     * @tc.type: Function
867     * @tc.level: Level 1
868     * @tc.require:
869     */
870    it('testTaskData005', function (done) {
871        openSyncFile('test.txt');
872        let conf = {
873            action: agent.Action.UPLOAD,
874            url: 'http://127.0.0.1',
875            data: {
876                name: 'test',
877                value: {
878                    path: ''
879                }
880            }
881        }
882        expect(true).assertTrue()
883        wrapTryCatch(conf, 401);
884    })
885
886    /**
887     * @tc.number: testTaskData006
888     * @tc.name: testTaskData006
889     * @tc.desc: Test create task when data path is number
890     * @tc.size: MediumTest
891     * @tc.type: Function
892     * @tc.level: Level 1
893     * @tc.require:
894     */
895    it('testTaskData006', function (done) {
896        openSyncFile('test.txt');
897        let conf = {
898            action: agent.Action.UPLOAD,
899            url: 'http://127.0.0.1',
900            data: {
901                name: 'test',
902                value: {
903                    path: 123
904                }
905            }
906        }
907        expect(true).assertTrue()
908        wrapTryCatch(conf, 401);
909    })
910
911
912    /**
913     * @tc.number: testTaskData007
914     * @tc.name: testTaskData007
915     * @tc.desc: Test create task when data path is not access permission
916     * @tc.size: MediumTest
917     * @tc.type: Function
918     * @tc.level: Level 1
919     * @tc.require:
920     */
921    it('testTaskData007', function (done) {
922        openSyncFile('test.txt');
923        let conf = {
924            action: agent.Action.UPLOAD,
925            url: 'http://127.0.0.1',
926            data: {
927                name: 'test',
928                value: {
929                    path: 'system/etc/init.cfg'
930                }
931            }
932        }
933        expect(true).assertTrue()
934        errorParamCreate(conf, 13400001);
935    })
936
937    /**
938     * @tc.number: testTaskData008
939     * @tc.name: testTaskData008
940     * @tc.desc: Test create task when data filename is number
941     * @tc.size: MediumTest
942     * @tc.type: Function
943     * @tc.level: Level 1
944     * @tc.require:
945     */
946    it('testTaskData008', function (done) {
947        openSyncFile('test.txt');
948        let conf = JSON.parse(JSON.stringify(globalConf));
949        conf.data.value.fileName = 123;
950        expect(true).assertTrue()
951        createLamdaApi10(conf, false, true)
952    })
953
954
955    /**
956     * @tc.number: testTaskData009
957     * @tc.name: testTaskData009
958     * @tc.desc: Test create task when data mimetype is number
959     * @tc.size: MediumTest
960     * @tc.type: Function
961     * @tc.level: Level 1
962     * @tc.require:
963     */
964    it('testTaskData009', function (done) {
965        openSyncFile('test.txt');
966        let conf = JSON.parse(JSON.stringify(globalConf));
967        conf.data.value.mimetype = 123;
968        expect(true).assertTrue()
969        createLamdaApi10(conf, false, true)
970    })
971
972    /**
973     * @tc.number: testTaskData010
974     * @tc.name: testTaskData010
975     * @tc.desc: Test create task when data path and filename is different
976     * @tc.size: MediumTest
977     * @tc.type: Function
978     * @tc.level: Level 1
979     * @tc.require:
980     */
981    it('testTaskData010', function (done) {
982        openSyncFile('test.txt');
983        let conf = JSON.parse(JSON.stringify(globalConf));
984        conf.data.value.fileName = 'a.txt';
985        expect(true).assertTrue()
986        createLamdaApi10(conf, false, true)
987    })
988
989    /**
990     * @tc.number: testTaskData011
991     * @tc.name: testTaskData011
992     * @tc.desc: Test create task when data two files for upload
993     * @tc.size: MediumTest
994     * @tc.type: Function
995     * @tc.level: Level 1
996     * @tc.require:
997     */
998    it('testTaskData011', function (done) {
999        openSyncFile('test.txt');
1000        let conf = JSON.parse(JSON.stringify(globalConf));
1001        conf.data.value = [
1002            {
1003                path: `${cacheDir}/test.txt`,
1004            },
1005            {
1006                path: `${cacheDir}/test.txt`,
1007            },
1008        ];
1009        expect(true).assertTrue()
1010        createLamdaApi10(conf, false, true)
1011    })
1012
1013    /**
1014     * @tc.number: testTaskData012
1015     * @tc.name: testTaskData012
1016     * @tc.desc: Test create task when data value is string
1017     * @tc.size: MediumTest
1018     * @tc.type: Function
1019     * @tc.level: Level 1
1020     * @tc.require:
1021     */
1022    it('testTaskData012', function (done) {
1023        openSyncFile('test.txt');
1024        let conf = JSON.parse(JSON.stringify(globalConf));
1025        conf.data.value = 'test';
1026        expect(true).assertTrue()
1027        createLamdaApi10(conf, false, true)
1028    })
1029
1030    /**
1031     * @tc.number: testTaskData013
1032     * @tc.name: testTaskData013
1033     * @tc.desc: Test create task when data path and filename is same
1034     * @tc.size: MediumTest
1035     * @tc.type: Function
1036     * @tc.level: Level 1
1037     * @tc.require:
1038     */
1039    it('testTaskData013', function (done) {
1040        openSyncFile('test.txt');
1041        let conf = JSON.parse(JSON.stringify(globalConf));
1042        conf.data.value.fileName = 'test.txt';
1043        expect(true).assertTrue()
1044        createLamdaApi10(conf, false, true)
1045    })
1046
1047    /**
1048     * @tc.number: testTaskNetwork001
1049     * @tc.name: testTaskNetwork001
1050     * @tc.desc: Test create task when network is 3
1051     * @tc.size: MediumTest
1052     * @tc.type: Function
1053     * @tc.level: Level 1
1054     * @tc.require:
1055     */
1056    it('testTaskNetwork001', async function (done) {
1057        openSyncFile('test.txt');
1058        let conf = JSON.parse(JSON.stringify(globalConf));
1059        conf.network = 3;
1060        task.create(context, conf).then(() => {
1061            expect(true).assertTrue()
1062            done()
1063        }).catch((err) => {
1064            expect(false).assertTrue()
1065            done()
1066        })
1067    })
1068
1069    /**
1070     * @tc.number: testTaskNetwork002
1071     * @tc.name: testTaskNetwork002
1072     * @tc.desc: Test create task when network is string
1073     * @tc.size: MediumTest
1074     * @tc.type: Function
1075     * @tc.level: Level 1
1076     * @tc.require:
1077     */
1078    it('testTaskNetwork002', async function (done) {
1079        let conf = JSON.parse(JSON.stringify(globalConf));
1080        conf.network = "ANY";
1081        task.create(context, conf).then(() => {
1082            expect(true).assertTrue()
1083            done()
1084        }).catch((err) => {
1085            expect(false).assertTrue()
1086            done()
1087        })
1088    })
1089
1090    /**
1091     * @tc.number: testTaskNetwork003
1092     * @tc.name: testTaskNetwork003
1093     * @tc.desc: Test create task when network is WIFI for DOWNLOAD
1094     * @tc.size: MediumTest
1095     * @tc.type: Function
1096     * @tc.level: Level 1
1097     * @tc.require:
1098     */
1099    it('testTaskNetwork003', async function (done) {
1100        let conf = {
1101            action: agent.Action.DOWNLOAD,
1102            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
1103            saveas: 'testTaskNetwork003.txt',
1104            network: agent.NetWork.WIFI
1105        }
1106        task.create(context, conf).then(() => {
1107            expect(true).assertTrue()
1108            done()
1109        }).catch((err) => {
1110            expect(false).assertTrue()
1111            done()
1112        })
1113    })
1114
1115    /**
1116     * @tc.number: testTaskNetwork004
1117     * @tc.name: testTaskNetwork004
1118     * @tc.desc: Test create task when network is WIFI for UPLOAD
1119     * @tc.size: MediumTest
1120     * @tc.type: Function
1121     * @tc.level: Level 1
1122     * @tc.require:
1123     */
1124    it('testTaskNetwork004', async function (done) {
1125        let conf = JSON.parse(JSON.stringify(globalConf));
1126        conf.network = agent.NetWork.WIFI;
1127        expect(true).assertTrue()
1128        await createApi10Task(conf);
1129    })
1130
1131    /**
1132     * @tc.number: testTaskRetry001
1133     * @tc.name: testTaskRetry001
1134     * @tc.desc: Test create task when retry is true for frontend
1135     * @tc.size: MediumTest
1136     * @tc.type: Function
1137     * @tc.level: Level 1
1138     * @tc.require:
1139     */
1140    it('testTaskRetry001', async function (done) {
1141        let conf = {
1142            action: agent.Action.DOWNLOAD,
1143            url: 'xxx',
1144            mode: agent.Mode.FRONTEND,
1145            retry: true
1146        }
1147        task = await agent.create(context, conf);
1148        task.on('failed', function () {
1149            expect(true).assertTrue()
1150            done()
1151        })
1152        task.start()
1153    })
1154
1155    /**
1156     * @tc.number: testTaskRetry002
1157     * @tc.name: testTaskRetry002
1158     * @tc.desc: Test create task when retry is true for background
1159     * @tc.size: MediumTest
1160     * @tc.type: Function
1161     * @tc.level: Level 1
1162     * @tc.require:
1163     */
1164    it('testTaskRetry002', async function (done) {
1165        let conf = {
1166            action: agent.Action.DOWNLOAD,
1167            url: 'https://gitee.com/tiga-ultraman/downloadTests/releases/download/v1.01/test.txt',
1168            mode: agent.Mode.BACKGROUND,
1169            saveas: 'testTaskRetry002.txt',
1170            retry: true
1171        }
1172        task = await agent.create(conf);
1173        task.on('progress', function (progress) {
1174            if (progress.state === agent.State.RETRYING) {
1175                expect(true).assertTrue()
1176                done()
1177            }
1178        })
1179        task.start()
1180    })
1181
1182    /**
1183     * @tc.number: testTaskRetry003
1184     * @tc.name: testTaskRetry003
1185     * @tc.desc: Test create task when retry is string
1186     * @tc.size: MediumTest
1187     * @tc.type: Function
1188     * @tc.level: Level 1
1189     * @tc.require:
1190     */
1191    it('testTaskRetry003', async function (done) {
1192        let conf = {
1193            action: agent.Action.DOWNLOAD,
1194            url: 'xxx',
1195            mode: agent.Mode.FRONTEND,
1196            retry: 'true'
1197        }
1198        task = await agent.create(context, conf);
1199        task.on('failed', function () {
1200            expect(true).assertTrue()
1201            done()
1202        })
1203        task.start()
1204    })
1205
1206    /**
1207     * @tc.number: testTaskRetry004
1208     * @tc.name: testTaskRetry004
1209     * @tc.desc: Test create task when retry is false for frontend
1210     * @tc.size: MediumTest
1211     * @tc.type: Function
1212     * @tc.level: Level 1
1213     * @tc.require:
1214     */
1215    it('testTaskRetry004', async function (done) {
1216        let conf = {
1217            action: agent.Action.DOWNLOAD,
1218            url: 'https://gitee.com/chenzhixue/downloadTest/releases/download/v1.0/test1.txt',
1219            mode: agent.Mode.FRONTEND,
1220            retry: false
1221        }
1222        task = await agent.create(conf);
1223        task.on('failed', function () {
1224            expect(true).assertTrue()
1225            done()
1226        })
1227        task.start()
1228    })
1229
1230    /**
1231     * @tc.number: testTaskRetry005
1232     * @tc.name: testTaskRetry005
1233     * @tc.desc: Test create task when retry is false for background
1234     * @tc.size: MediumTest
1235     * @tc.type: Function
1236     * @tc.level: Level 1
1237     * @tc.require:
1238     */
1239    it('testTaskRetry005', async function (done) {
1240        let conf = {
1241            action: agent.Action.DOWNLOAD,
1242            url: 'https://gitee.com/chenzhixue/downloadTest/releases/download/v1.0/test1.txt',
1243            mode: agent.Mode.FRONTEND,
1244            retry: false
1245        }
1246        task.on('failed', function () {
1247            expect(true).assertTrue()
1248            done()
1249        })
1250        task = await agent.create(conf);
1251        task.start()
1252    })
1253})