Change test cases

test-server/server.js

@@ -148,12 +148,25 @@ app.post('/upload', bodyParser.urlencoded({ extended : true }), (req, res) => {
   res.status(200).send(req.body)
 })
 
-app.all('/timeout408', (req, res) => {
+app.all('/timeout408/:time', (req, res) => {
   setTimeout(function() {
     res.status(408).send('request timed out.')
   }, 5000)
 })
 
+app.all('/long', (req, res) => {
+  var count = 0;
+  var it = setInterval(() => {
+    console.log('write data', count)
+    res.write('a')
+    if(++count >60){
+      clearInterval(it)
+      res.end()
+    }
+  }, 1000);
+
+})
+
 app.all('/timeout', (req, res) => {
 })
 

test/test-0.8.2.js

@@ -41,7 +41,6 @@ describe('#73 unicode response BASE64 content test', (report, done) => {
     return res.json()
   })
   .then((data) => {
-    console.log(data)
     report(<Assert key="data should correct" expect={'你好!'} actual={data.data}/>)
     done()
   })
@@ -63,25 +62,48 @@ describe('#73 unicode response content test', (report, done) => {
     })
 })
 
-RNTest.config({
+describe = RNTest.config({
   group : '0.8.2',
   run : true,
   expand : true,
   timeout : 24000
-})('request should not retry after timed out', (report, done) => {
+})
+
+describe('request should not retry after timed out', (report, done) => {
 
   let count = 0
-  RNFetchBlob
-    // .config({timeout : 2000})
-    .fetch('GET', `${TEST_SERVER_URL}/timeout408`)
-    .then((res) => {
-      report(<Assert key="request should not success" expect={true} actual={false}/>)
-    })
-    .catch(() => {
-      count ++
-    })
+  let task = RNFetchBlob
+    .fetch('GET', `${TEST_SERVER_URL}/timeout408/${Date.now()}`)
+  task.then((res) => {
+    report(<Assert key="request should not success" expect={true} actual={false}/>)
+  })
+  .catch(() => {
+    task.cancel()
+    count ++
+  })
   setTimeout(() => {
     report(<Assert key="request does not retry" expect={1} actual={count}/>)
     done()
-  }, 8000)
+  }, 12000)
+})
+
+describe = RNTest.config({
+  group : '0.8.2',
+  run : true,
+  expand : true,
+  timeout : 65000
+})
+
+describe('long live download or upload task won\'t timeout', (report, done) => {
+
+  RNFetchBlob.config({timeout : 0})
+  .fetch('GET', `${TEST_SERVER_URL}/long/`)
+  .then((res) => {
+    report(
+      <Assert key="download not terminated" expect={true} actual={true}/>,
+      <Info key={res.text()}/>)
+    done()
+  })
+
+
 })

test/test-fetch.js

@@ -0,0 +1,73 @@
+import RNTest from './react-native-testkit/'
+import React from 'react'
+import RNFetchBlob from 'react-native-fetch-blob'
+
+import {
+  StyleSheet,
+  Text,
+  View,
+  ScrollView,
+  Platform,
+  Dimensions,
+  Image,
+} from 'react-native';
+
+window.Blob = RNFetchBlob.polyfill.Blob
+window.fetch = new RNFetchBlob.polyfill.Fetch({
+  auto : true,
+  binaryContentTypes : ['image/', 'video/', 'audio/']
+}).build()
+
+const fs = RNFetchBlob.fs
+const { Assert, Comparer, Info, prop } = RNTest
+const describe = RNTest.config({
+  group : 'Fetch polyfill',
+  run : true,
+  expand : true,
+  timeout : 10000,
+})
+const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, FILENAME, DROPBOX_TOKEN, styles } = prop()
+const dirs = RNFetchBlob.fs.dirs
+
+let prefix = ((Platform.OS === 'android') ? 'file://' : '')
+
+describe('GET request test : text -> any', (report, done) => {
+
+  function get(fn1, fn2) {
+    return fetch(`${TEST_SERVER_URL}/unicode`, { method : 'GET'})
+    .then((res) => fn1(res))
+    .then((data) => fn2(data))
+  }
+  let promises =
+  [
+    get((res) => res.json(), (json) => {
+      report(<Assert key="json data correct" expect={'你好!'} actual={json.data}/>)
+    }),
+    get((res) => res.text(), (text) => {
+      report(<Assert key="text data correct" expect={'你好!'} actual={JSON.parse(text).data}/>)
+    }),
+    get((res) => res.blob(), (blob) => {
+      let path = blob.getRNFetchBlobRef()
+      return fs.readFile(path, 'utf8').then((text) => {
+        console.log(text)
+        report(<Assert key="blob data correct" expect={'你好!'} actual={JSON.parse(text).data}/>)
+      })
+    }),
+    // get((res) => res.arrayBuffer(), (text) => {
+    //   report(<Assert key="text data correct" expect={'你好!'} actual={JSON.parse(text).data}/>)
+    // })
+  ]
+
+  Promise.all(promises).then(() => {
+    done()
+  })
+
+})
+
+describe('GET request which has json response', (report, done) => {
+
+})
+
+describe('GET request which has blob response', (report, done) => {
+
+})

test/test-xmlhttp.js

@@ -39,241 +39,241 @@ let file = RNTest.prop('image')
  * {@link https://github.com/w3c/web-platform-tests/blob/master/XMLHttpRequest/}
  */
 
-// describe('unsent state test', (report, done) => {
-//
-//   let xhr = new XMLHttpRequest()
-//
-//   try {
-//     xhr.setRequestHeader('x-test', 'test')
-//   } catch(err) {
-//     report(
-//       <Assert key="should throw InvalidState if setRequestHeader()"
-//         actual={/invalidstate/i.test(err)}
-//         expect={true}
-//       />)
-//   }
-//
-//   try {
-//     let xhr = new XMLHttpRequest()
-//     xhr.send(null)
-//   } catch(err) {
-//     report(
-//       <Assert key="should throw InvalidState if send()"
-//         actual={/invalidstate/i.test(err)}
-//         expect={true}
-//       />)
-//   }
-//   try {
-//     report(
-//       <Assert key="status is 0"
-//         expect={0}
-//         actual={xhr.status} />,
-//       <Assert key="statusText is empty"
-//         expect={''}
-//         actual={xhr.statusText} />,
-//       <Assert key="responseHeaders is empty"
-//         expect={''}
-//         actual={xhr.getAllResponseHeaders()} />,
-//       <Assert key="response header should not be set"
-//         expect={null}
-//         actual={xhr.getResponseHeader('x-test')} />,
-//       <Assert key="readyState should correct"
-//         expect={XMLHttpRequest.UNSENT}
-//         actual={xhr.readyState} />
-//     )
-//     done()
-//   } catch(err) {
-//     console.log(err.stack)
-//   }
-// })
-//
-// describe('HTTP error should not throw error event', (report, done) => {
-//
-//   onError('GET', 200)
-//   onError('GET', 400)
-//   onError('GET', 401)
-//   onError('GET', 404)
-//   onError('GET', 410)
-//   onError('GET', 500)
-//   onError('GET', 699)
-//
-//   onError('HEAD', 200)
-//   onError('HEAD', 404)
-//   onError('HEAD', 500)
-//   onError('HEAD', 699)
-//
-//   onError('POST', 200)
-//   onError('POST', 404)
-//   onError('POST', 500)
-//   onError('POST', 699)
-//
-//   onError('PUT', 200)
-//   onError('PUT', 404)
-//   onError('PUT', 500)
-//   onError('PUT', 699)
-//
-//   done()
-//
-//   let count = 0
-//   function onError(method, code) {
-//     let xhr = new XMLHttpRequest()
-//     xhr.open(method, `${TEST_SERVER_URL}/xhr-code/${code}`)
-//     xhr.onreadystatechange = function() {
-//       count++
-//       if(this.readyState == XMLHttpRequest.DONE) {
-//         report(
-//           <Assert
-//             key={`#${count} response data of ${method} ${code} should be empty`}
-//             expect=""
-//             actual={xhr.response}/>,
-//           <Assert
-//             key={`#${count} status of ${method} ${code} should be ${code}`}
-//             expect={code}
-//             actual={xhr.status}/>
-//         )
-//       }
-//     }
-//     xhr.onerror = function() {
-//       report(
-//         <Assert
-//           key={`HTTP error ${code} should not throw error event`}
-//           expect={false}
-//           actual={true}/>)
-//     }
-//     xhr.send()
-//   }
-//
-// })
-//
-// describe('request headers records should be cleared by open()', (report, done) => {
-//   let xhr = new XMLHttpRequest()
-//   xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
-//   xhr.setRequestHeader('value', '100')
-//   xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
-//   xhr.setRequestHeader('value', '200')
-//   xhr.send()
-//   xhr.onreadystatechange = function() {
-//     if(this.readyState == 4) {
-//       report(<Assert key="headers should be cleared by open()"
-//         expect={'200'}
-//         actual={this.response['value']}/>)
-//       done()
-//     }
-//   }
-// })
-//
-// /**
-//  *  {@link https://github.com/w3c/web-platform-tests/blob/master/XMLHttpRequest/setrequestheader-bogus-name.htm}
-//  */
-// describe('invalid characters should not exists in header field', (report, done) => {
-//   function try_name(name) {
-//     try {
-//       let client = new XMLHttpRequest()
-//       client.open("GET", `${TEST_SERVER_URL}/public/github.png`)
-//       client.setRequestHeader(name, '123')
-//     } catch(err) {
-//       report(
-//         <Assert key={`invalid header type ${name} should throw SyntaxError`}
-//           actual={/syntaxerror/i.test(err)}
-//           expect={true}
-//         />)
-//     }
-//   }
-//   function try_byte_string(name) {
-//     try {
-//       let client = new XMLHttpRequest()
-//       client.open("GET", `${TEST_SERVER_URL}/public/github.png`)
-//       client.setRequestHeader(name, '123')
-//     } catch(err) {
-//       report(
-//         <Assert key={`invalid header field ${name} type should throw TypeError`}
-//           actual={/typeerror/i.test(err)}
-//           expect={true}
-//         />)
-//     }
-//   }
-//   var invalid_headers = ["(", ")", "<", ">", "@", ",", ";", ":", "\\",
-//                          "\"", "/", "[", "]", "?", "=", "{", "}", " ",
-//                          "\u007f", "", "t\rt", "t\nt", "t: t", "t:t",
-//                          "t<t", "t t", " tt", ":tt", "\ttt", "\vtt", "t\0t",
-//                          "t\"t", "t,t", "t;t", "()[]{}", "a?B", "a=B"]
-//   var invalid_byte_strings = ["ﾃｽﾄ", "X-ﾃｽﾄ"]
-//   for (var i = 0; i < 32; ++i) {
-//     invalid_headers.push(String.fromCharCode(i))
-//   }
-//   for (var i = 0; i < invalid_headers.length; ++i) {
-//     try_name(invalid_headers[i])
-//   }
-//   for (var i = 0; i < invalid_byte_strings.length; ++i) {
-//     try_byte_string(invalid_byte_strings[i])
-//   }
-//   done()
-//
-// })
-//
-// describe('invoke setRequestHeader() before open()', (report, done) => {
-//   try {
-//     let xhr = new XMLHttpRequest()
-//     xhr.setRequestHeader('foo', 'bar')
-//   } catch(err) {
-//     report(
-//       <Info key="error message">
-//         <Text>{err}</Text>
-//       </Info>,
-//       <Assert key="should throw InvalidStateError"
-//         expect={true}
-//         actual={/invalidstateerror/i.test(err)}/>)
-//       done()
-//   }
-// })
-//
-// describe('upload progress event test', (report, done) => {
-//   let xhr = new XMLHttpRequest()
-//   let time = Date.now()
-//   let msg =  `time=${time}`
-//   xhr.upload.onprogress = function(e) {
-//     report(
-//       <Assert key="event object is an instance of ProgressEvent"
-//         expect={true}
-//         actual={e instanceof ProgressEvent}/>)
-//   }
-//   xhr.onreadystatechange = function() {
-//     if(this.readyState == XMLHttpRequest.DONE) {
-//       console.log(xhr)
-//       report(
-//         <Assert key="reponse should correct"
-//           expect={time}
-//           actual={parseInt(xhr.response.time)}/>,
-//         <Assert key="responseType should correct"
-//           expect={'json'}
-//           actual={xhr.responseType}/>)
-//         done()
-//     }
-//   }
-//   xhr.open('POST', `${TEST_SERVER_URL}/upload`)
-//   xhr.overrideMimeType('application/x-www-form-urlencoded')
-//   xhr.send(msg)
-//
-// })
-//
-// describe('timeout event catchable', (report, done) => {
-//   let xhr = new XMLHttpRequest()
-//   let count = 0
-//   xhr.timeout = 1
-//   xhr.ontimeout = function() {
-//     report(
-//       <Info key="event should only trigger once" uid="1000">
-//         <Text>{count}</Text>
-//       </Info>,
-//       <Assert key="event catchable"
-//         expect={true}
-//         actual={true}/>)
-//       done()
-//   }
-//   xhr.open('GET', `${TEST_SERVER_URL}/timeout/`)
-//   xhr.send()
-//
-// })
+describe('unsent state test', (report, done) => {
+
+  let xhr = new XMLHttpRequest()
+
+  try {
+    xhr.setRequestHeader('x-test', 'test')
+  } catch(err) {
+    report(
+      <Assert key="should throw InvalidState if setRequestHeader()"
+        actual={/invalidstate/i.test(err)}
+        expect={true}
+      />)
+  }
+
+  try {
+    let xhr = new XMLHttpRequest()
+    xhr.send(null)
+  } catch(err) {
+    report(
+      <Assert key="should throw InvalidState if send()"
+        actual={/invalidstate/i.test(err)}
+        expect={true}
+      />)
+  }
+  try {
+    report(
+      <Assert key="status is 0"
+        expect={0}
+        actual={xhr.status} />,
+      <Assert key="statusText is empty"
+        expect={''}
+        actual={xhr.statusText} />,
+      <Assert key="responseHeaders is empty"
+        expect={''}
+        actual={xhr.getAllResponseHeaders()} />,
+      <Assert key="response header should not be set"
+        expect={null}
+        actual={xhr.getResponseHeader('x-test')} />,
+      <Assert key="readyState should correct"
+        expect={XMLHttpRequest.UNSENT}
+        actual={xhr.readyState} />
+    )
+    done()
+  } catch(err) {
+    console.log(err.stack)
+  }
+})
+
+describe('HTTP error should not throw error event', (report, done) => {
+
+  onError('GET', 200)
+  onError('GET', 400)
+  onError('GET', 401)
+  onError('GET', 404)
+  onError('GET', 410)
+  onError('GET', 500)
+  onError('GET', 699)
+
+  onError('HEAD', 200)
+  onError('HEAD', 404)
+  onError('HEAD', 500)
+  onError('HEAD', 699)
+
+  onError('POST', 200)
+  onError('POST', 404)
+  onError('POST', 500)
+  onError('POST', 699)
+
+  onError('PUT', 200)
+  onError('PUT', 404)
+  onError('PUT', 500)
+  onError('PUT', 699)
+
+  done()
+
+  let count = 0
+  function onError(method, code) {
+    let xhr = new XMLHttpRequest()
+    xhr.open(method, `${TEST_SERVER_URL}/xhr-code/${code}`)
+    xhr.onreadystatechange = function() {
+      count++
+      if(this.readyState == XMLHttpRequest.DONE) {
+        report(
+          <Assert
+            key={`#${count} response data of ${method} ${code} should be empty`}
+            expect=""
+            actual={xhr.response}/>,
+          <Assert
+            key={`#${count} status of ${method} ${code} should be ${code}`}
+            expect={code}
+            actual={xhr.status}/>
+        )
+      }
+    }
+    xhr.onerror = function() {
+      report(
+        <Assert
+          key={`HTTP error ${code} should not throw error event`}
+          expect={false}
+          actual={true}/>)
+    }
+    xhr.send()
+  }
+
+})
+
+describe('request headers records should be cleared by open()', (report, done) => {
+  let xhr = new XMLHttpRequest()
+  xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
+  xhr.setRequestHeader('value', '100')
+  xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
+  xhr.setRequestHeader('value', '200')
+  xhr.send()
+  xhr.onreadystatechange = function() {
+    if(this.readyState == 4) {
+      report(<Assert key="headers should be cleared by open()"
+        expect={'200'}
+        actual={this.response['value']}/>)
+      done()
+    }
+  }
+})
+
+/**
+ *  {@link https://github.com/w3c/web-platform-tests/blob/master/XMLHttpRequest/setrequestheader-bogus-name.htm}
+ */
+describe('invalid characters should not exists in header field', (report, done) => {
+  function try_name(name) {
+    try {
+      let client = new XMLHttpRequest()
+      client.open("GET", `${TEST_SERVER_URL}/public/github.png`)
+      client.setRequestHeader(name, '123')
+    } catch(err) {
+      report(
+        <Assert key={`invalid header type ${name} should throw SyntaxError`}
+          actual={/syntaxerror/i.test(err)}
+          expect={true}
+        />)
+    }
+  }
+  function try_byte_string(name) {
+    try {
+      let client = new XMLHttpRequest()
+      client.open("GET", `${TEST_SERVER_URL}/public/github.png`)
+      client.setRequestHeader(name, '123')
+    } catch(err) {
+      report(
+        <Assert key={`invalid header field ${name} type should throw TypeError`}
+          actual={/typeerror/i.test(err)}
+          expect={true}
+        />)
+    }
+  }
+  var invalid_headers = ["(", ")", "<", ">", "@", ",", ";", ":", "\\",
+                         "\"", "/", "[", "]", "?", "=", "{", "}", " ",
+                         "\u007f", "", "t\rt", "t\nt", "t: t", "t:t",
+                         "t<t", "t t", " tt", ":tt", "\ttt", "\vtt", "t\0t",
+                         "t\"t", "t,t", "t;t", "()[]{}", "a?B", "a=B"]
+  var invalid_byte_strings = ["ﾃｽﾄ", "X-ﾃｽﾄ"]
+  for (var i = 0; i < 32; ++i) {
+    invalid_headers.push(String.fromCharCode(i))
+  }
+  for (var i = 0; i < invalid_headers.length; ++i) {
+    try_name(invalid_headers[i])
+  }
+  for (var i = 0; i < invalid_byte_strings.length; ++i) {
+    try_byte_string(invalid_byte_strings[i])
+  }
+  done()
+
+})
+
+describe('invoke setRequestHeader() before open()', (report, done) => {
+  try {
+    let xhr = new XMLHttpRequest()
+    xhr.setRequestHeader('foo', 'bar')
+  } catch(err) {
+    report(
+      <Info key="error message">
+        <Text>{err}</Text>
+      </Info>,
+      <Assert key="should throw InvalidStateError"
+        expect={true}
+        actual={/invalidstateerror/i.test(err)}/>)
+      done()
+  }
+})
+
+describe('upload progress event test', (report, done) => {
+  let xhr = new XMLHttpRequest()
+  let time = Date.now()
+  let msg =  `time=${time}`
+  xhr.upload.onprogress = function(e) {
+    report(
+      <Assert key="event object is an instance of ProgressEvent"
+        expect={true}
+        actual={e instanceof ProgressEvent}/>)
+  }
+  xhr.onreadystatechange = function() {
+    if(this.readyState == XMLHttpRequest.DONE) {
+      console.log(xhr)
+      report(
+        <Assert key="reponse should correct"
+          expect={time}
+          actual={parseInt(xhr.response.time)}/>,
+        <Assert key="responseType should correct"
+          expect={'json'}
+          actual={xhr.responseType}/>)
+        done()
+    }
+  }
+  xhr.open('POST', `${TEST_SERVER_URL}/upload`)
+  xhr.overrideMimeType('application/x-www-form-urlencoded')
+  xhr.send(msg)
+
+})
+
+describe('timeout event catchable', (report, done) => {
+  let xhr = new XMLHttpRequest()
+  let count = 0
+  xhr.timeout = 1
+  xhr.ontimeout = function() {
+    report(
+      <Info key="event should only trigger once" uid="1000">
+        <Text>{count}</Text>
+      </Info>,
+      <Assert key="event catchable"
+        expect={true}
+        actual={true}/>)
+      done()
+  }
+  xhr.open('GET', `${TEST_SERVER_URL}/timeout/`)
+  xhr.send()
+
+})
 
 describe('upload progress event should not be triggered when body is empty', (report, done) => {
   let xhr = new XMLHttpRequest()