Add test cases for fs API #18

test/react-native-testkit/lib/comparer.js

   instanceOf : (a, b) => a instanceof b,
   typeof : (a, b) => typeof a === b,
   IsNull : (a, b) => a === null,
-  exists : (a, b) => a,
+  exists : (a, b) => {
+    return a !== null && a !== void 0
+  },
   equalToArray : (a, b) => {
     if(!Array.isArray(a) && Array.isArray(b))
       return false

test/react-native-testkit/lib/test-context.js

    *         should return a promise.
    * @return {void}
    */
-  static describe (desc:string, fn:Promise<any>) {
+  static describe (...args) {
     let { group, timeout, expand, run } = this || {}
-
+    let desc, config, fn
+    if([...args].length === 2) {
+      [desc, fn] = [...args]
+    }
+    else if ([...args].length === 3) {
+      [desc, config, fn] = [...args]
+      group = config.group || group
+      timeout = config.timeout || timeout
+      expand = config.expand || expand
+      run = config.run || run
+    }
     let ctx = {
       group : group || 'common',
       status : 'waiting',

test/test-0.5.x.js

   Image,
 } from 'react-native';
 
+const fs = RNFetchBlob.fs
 const { Assert, Comparer, Info, prop } = RNTest
 const describe = RNTest.config({
   group : '0.5.x',
+  run : false,
   expand : false,
 })
 const { TEST_SERVER_URL, FILENAME, DROPBOX_TOKEN, styles } = prop()
 
 describe('Read cached file via file stream', (report, done) => {
   let data = 'data:image/png;base64, '
-  let stream = RNFetchBlob.readStream(tmpFilePath, 'base64')
+  let stream = fs.readStream(tmpFilePath, 'base64')
   stream.onData((chunk) => {
     data += chunk
   })
 })
 
 describe('File stream reader error should be able to handled', (report, done) => {
-  let stream = RNFetchBlob.readStream('^_^ not exists', 'base64')
+  let stream = fs.readStream('^_^ not exists', 'base64')
   stream.onError((err) => {
     report(<Info key="error message">
       <Text>
 describe('Upload from file storage', (report, done) => {
   let filename = ''
   let filepath = ''
-  RNFetchBlob.getSystemDirs().then((dirs) => {
+  fs.getSystemDirs().then((dirs) => {
     sysDirs = dirs
     filename = Platform.OS + '0.5.0-' + Date.now() + '-from-storage.png'
     filepath = dirs.DocumentDir + '/' + filename
 
   let sessionName = 'test-session-' + Date.now()
   let baseDir = sysDirs.DocumentDir + '/' + sessionName
-  RNFetchBlob.mkdir(sysDirs.DocumentDir + '/' + sessionName).then(() => {
+  fs.mkdir(sysDirs.DocumentDir + '/' + sessionName).then(() => {
     let promises = [0,1,2,3,4,5,6,7,8,9].map((p) => {
       return RNFetchBlob.config({
           session : sessionName,
         actual={s.list()}/>)
 
     s.dispose().then(() => {
-      RNFetchBlob.ls(baseDir).then((lsRes) => {
+      fs.ls(baseDir).then((lsRes) => {
         report(
           <Assert
             key="dispose() should work correctly"

test/test-fs.js

   Image,
 } from 'react-native';
 const { Assert, Comparer, Info, prop } = RNTest
+const fs = RNFetchBlob.fs
 const describe = RNTest.config({
   group : 'fs',
   expand : false,
 })
 
 let { TEST_SERVER_URL, FILENAME, DROPBOX_TOKEN, styles, image } = prop()
+let dirs = null
 
 describe('Get storage folders', (report, done) => {
-
-  RNFetchBlob.getSystemDirs().then((dirs) => {
+  fs.getSystemDirs().then((resp) => {
+    dirs = resp
     report(
-      <Assert key="system folders should exists" expect={dirs} comparer={Comparer.exists} />,
+      <Assert key="system folders should exists" expect={resp} comparer={Comparer.exists} />,
       <Assert key="check properties"
-        expect={dirs}
+        expect={resp}
         comparer={Comparer.hasProperties}
         actual={['DocumentDir', 'CacheDir', 'DCIMDir', 'DownloadDir']}
       />,
   })
 
 })
+
+describe('ls API test', (report, done) => {
+  fs.ls(dirs.DocumentDir).then((list) => {
+    report(<Assert key="result must be an Array" expect={true} actual={Array.isArray(list)} />)
+    return fs.ls('hh87h8uhi')
+  })
+  .then(()=>{})
+  .catch((err) => {
+    report(<Assert key="Wrong path should have error"
+      expect={err}
+      comparer={Comparer.exists}/>)
+    done()
+  })
+})
+
+describe('exists API test', (report, done) => {
+  let exists = fs.exists
+  exists(dirs.DocumentDir).then((exist, isDir) => {
+    report(
+      <Assert key="document dir should exist" expect={true} actual={exist}/>
+    )
+    return exists('blabajsdio')
+  })
+  .then((exist, isDir) => {
+    report(
+      <Assert key="path should not exist" expect={false} actual={exist}/>
+    )
+    done()
+  })
+})
+
+describe('create file API test', (report, done) => {
+  let p = dirs.DocumentDir + '/test-' + Date.now()
+  let raw = 'hello ' + Date.now()
+  let base64 = RNFetchBlob.base64.encode(raw)
+
+  fs.createFile(p, raw, 'utf8')
+    .then(() => {
+      let stream = fs.readStream(p, 'utf8')
+      let d = ''
+      stream.onData((chunk) => {
+        d += chunk
+      })
+      stream.onEnd(() => {
+        report(<Assert key="utf8 content test"  expect={raw} actual={d}/>)
+        testBase64()
+      })
+    })
+  function testBase64() {
+    fs.createFile(p + '-base64', RNFetchBlob.base64.encode(raw), 'base64')
+      .then(() => {
+        let stream = fs.readStream(p + '-base64', 'utf8')
+        let d = ''
+        stream.onData((chunk) => {
+          d += chunk
+        })
+        stream.onEnd(() => {
+          report(<Assert
+            key="base64 content test"
+            expect={raw}
+            actual={d}/>)
+          testASCII()
+        })
+      })
+      .catch((err) => {
+        console.log(err)
+      })
+  }
+  function testASCII() {
+    fs.createFile(p + '-ascii', raw, 'ascii')
+      .then(() => {
+        let stream = fs.readStream(p + '-ascii', 'ascii')
+        let d = ''
+        stream.onData((chunk) => {
+          d += chunk
+        })
+        stream.onEnd(() => {
+          report(<Assert
+            key="ASCII content test"
+            expect={raw}
+            actual={d}/>)
+          done()
+        })
+      })
+      .catch((err) => {
+        console.log(err)
+      })
+  }
+
+})
+
+describe('mkdir and isDir API test', (report, done) => {
+  let p = dirs.DocumentDir + '/mkdir-test-' + Date.now()
+  fs.mkdir(p + '/mkdir').then((err) => {
+    report(<Assert key="folder should be created without error"
+      expect={undefined}
+      actual={err} />)
+    return fs.isDir(p + '/mkdir')
+  })
+  .then((isDir) => {
+    report(<Assert key="isDir should work correctly" expect={true} actual={isDir} />)
+    return fs.mkdir(p + '/mkdir')
+  })
+  .then()
+  .catch((err) => {
+    report(<Assert key="isDir should not work when folder exists"
+      expect={err}
+      comparer={Comparer.hasValue}/>)
+    done()
+  })
+})
+
+describe('unlink and mkdir API test', (report, done) => {
+  let p = dirs.DocumentDir + '/unlink-test-' + Date.now()
+  fs.createFile(p, 'write' + Date.now(), 'utf8').then(() => {
+    return fs.exists(p)
+  })
+  .then((exist) => {
+    report(<Assert key="file created" expect={true} actual={exist} />)
+    return fs.unlink(p).then(() => {
+      return fs.exists(p)
+    })
+  })
+  .then((exist) => {
+    report(<Assert key="file removed" expect={false} actual={exist} />)
+    return fs.mkdir(p + '/dir')
+  })
+  .then((err) => fs.exists(p + '/dir'))
+  .then((exist) => {
+    report(<Assert key="mkdir should success" expect={true} actual={exist} />)
+    return fs.unlink(p + '/dir')
+  })
+  .then(() => fs.exists(p + '/dir'))
+  .then((exist) => {
+    report(<Assert key="folder should be removed" expect={false} actual={exist} />)
+    done()
+  })
+})
+
+describe('write stream API test', (report, done) => {
+
+  let p = dirs.DocumentDir + '/write-stream' + Date.now()
+  let expect = ''
+  fs.createFile(p, '1234567890', 'utf8')
+    .then(() => fs.writeStream(p, 'utf8', true))
+    .then((ws) => {
+      ws.write('11')
+      ws.write('12')
+      ws.write('13')
+      ws.write('14')
+      return ws.close()
+    })
+    .then(() => {
+      let rs = fs.readStream(p, 'utf8')
+      let d1 = ''
+      rs.onData((chunk) => {
+        d1 += chunk
+      })
+      rs.onEnd(() => {
+        report(
+          <Assert key="write data async test"
+            expect={'123456789011121314'}
+            actual={d1}/>)
+          base64Test()
+      })
+    })
+  function base64Test() {
+    fs.writeStream(p, 'base64', false)
+    .then((ws) => {
+      for(let i = 0; i< 100; i++) {
+        expect += RNFetchBlob.base64.encode(i)
+        ws.write(RNFetchBlob.base64.encode(i))
+      }
+      return ws.close()
+    })
+    .then(() => {
+      let rs = fs.readStream(p, 'base64')
+      let d2 = ''
+      rs.onData((chunk) => {
+        d2 += chunk
+      })
+      rs.onEnd(() => {
+        report(
+          <Assert key="file should be overwritten by base64 encoded data"
+            expect={expect}
+            actual={RNFetchBlob.base64.decode(d2)} />)
+        done()
+      })
+    })
+  }
+})
+
+describe('mv API test', {timeout : 10000},(report, done) => {
+  let p = dirs.DocumentDir + '/mvTest' + Date.now()
+  let dest = p + '-dest-' + Date.now()
+  let content = Date.now() + '-test'
+  fs.createFile(p, content, 'utf8')
+  .then(() => fs.mkdir(dest))
+  .then(() => fs.mv(p, dest +'/moved'))
+  .then(() => fs.exists(p))
+  .then((exist) => {
+    report(<Assert key="file should not exist in old path" expect={false} actual={exist}/>)
+    return fs.exists(dest + '/moved')
+  })
+  .then((exist) => {
+    report(<Assert key="file should be moved to destination" expect={true} actual={exist}/>)
+    return fs.ls(dest)
+  })
+  .then((files) => {
+    report(<Assert key="file name should be correct" expect={'moved'} actual={files[0]}/>)
+    let rs = fs.readStream(dest + '/moved')
+    let actual = ''
+    rs.onData((chunk) => {
+      actual += chunk
+    })
+    rs.onEnd(() => {
+      report(<Assert key="file content should be correct" expect={content} actual={actual}/>)
+      done()
+    })
+  })
+})
+
+describe('cp API test', {timeout : 10000},(report, done) => {
+  let p = dirs.DocumentDir + '/cpTest' + Date.now()
+  let dest = p + '-dest-' + Date.now()
+  let content = Date.now() + '-test'
+  fs.createFile(p, content, 'utf8')
+  .then(() => fs.mkdir(dest))
+  .then(() => fs.cp(p, dest +'/cp'))
+  .then(() => fs.exists(dest +'/cp'))
+  .then((exist) => {
+    report(<Assert key="file should be copy to destination" expect={true} actual={exist}/>)
+    return fs.ls(dest)
+  })
+  .then((files) => {
+    report(<Assert key="file name should be correct" expect={'cp'} actual={files[0]}/>)
+    let rs = fs.readStream(dest + '/cp')
+    let actual = ''
+    rs.onData((chunk) => {
+      actual += chunk
+    })
+    rs.onEnd(() => {
+      report(<Assert key="file content should be correct" expect={content} actual={actual}/>)
+      done()
+    })
+  })
+})

test/test-init.js

 // test environment variables
 
 prop('FILENAME', `${Platform.OS}-0.5.0-${Date.now()}.png`)
-prop('TEST_SERVER_URL', 'http://192.168.0.14:8123')
+prop('TEST_SERVER_URL', 'http://192.168.16.70:8123')
 prop('DROPBOX_TOKEN', 'fsXcpmKPrHgAAAAAAAAAoXZhcXYWdgLpQMan6Tb_bzJ237DXhgQSev12hA-gUXt4')
 prop('styles', {
   image : {
     })
 })
 
+require('./test-fs')
 require('./test-0.1.x-0.4.x')
 require('./test-0.5.x')