Add test cases for #45

test/react-native-testkit/animate-text.js

+/**
+ * @author wkh237
+ * @version 0.1.1
+ */
+
+// @flow
+
+import React, { Component } from 'react';
+import {
+  Text,
+  View
+} from 'react-native';
+import Timer from 'react-timer-mixin';
+
+const HALF_RAD = Math.PI/2
+
+export default class AnimateNumber extends Component {
+
+  props : {
+    countBy? : ?number,
+    interval? : ?number,
+    steps? : ?number,
+    value : number,
+    timing : 'linear' | 'easeOut' | 'easeIn' | () => number,
+    formatter : () => {},
+    onProgress : () => {},
+    onFinish : () => {}
+  };
+
+  static defaultProps = {
+    interval : 14,
+    timing : 'linear',
+    steps : 45,
+    value : 0,
+    formatter : (val) => val,
+    onFinish : () => {}
+  };
+
+  static TimingFunctions = {
+
+    linear : (interval:number, progress:number):number => {
+      return interval
+    },
+
+    easeOut : (interval:number, progress:number):number => {
+      return interval * Math.sin(HALF_RAD*progress) * 5
+    },
+
+    easeIn : (interval:number, progress:number):number => {
+      return interval * Math.sin((HALF_RAD - HALF_RAD*progress)) * 5
+    },
+
+  };
+
+  state : {
+    value? : ?number,
+    displayValue? : ?number
+  };
+
+  /**
+   * Animation direction, true means positive, false means negative.
+   * @type {bool}
+   */
+  direction : bool;
+  /**
+   * Start value of last animation.
+   * @type {number}
+   */
+  startFrom : number;
+  /**
+  * End value of last animation.
+  * @type {number}
+   */
+  endWith : number;
+
+  constructor(props:any) {
+    super(props);
+    // default values of state and non-state variables
+    this.state = {
+      value : 0,
+      displayValue : 0
+    }
+    this.dirty = false;
+    this.startFrom = 0;
+    this.endWith = 0;
+  }
+
+  componentDidMount() {
+    this.startFrom = this.state.value
+    this.endWith = this.props.value
+    this.dirty = true
+    this.startAnimate()
+  }
+
+  componentWillUpdate(nextProps, nextState) {
+
+    // check if start an animation
+    if(this.props.value !== nextProps.value) {
+      this.startFrom = this.props.value
+      this.endWith = nextProps.value
+      this.dirty = true
+      this.startAnimate()
+      return
+    }
+    // Check if iterate animation frame
+    if(!this.dirty) {
+      return
+    }
+    if (this.direction === true) {
+      if(parseFloat(this.state.value) <= parseFloat(this.props.value)) {
+        this.startAnimate();
+      }
+    }
+    else if(this.direction === false){
+      if (parseFloat(this.state.value) >= parseFloat(this.props.value)) {
+        this.startAnimate();
+      }
+    }
+
+  }
+
+  render() {
+    return (
+      <Text {...this.props}>
+        {this.state.displayValue}
+      </Text>)
+  }
+
+  startAnimate() {
+
+    let progress = this.getAnimationProgress()
+
+    Timer.setTimeout(() => {
+
+      let value = (this.endWith - this.startFrom)/this.props.steps
+      if(this.props.countBy)
+        value = Math.sign(value)*Math.abs(this.props.countBy)
+      let total = parseFloat(this.state.value) + parseFloat(value)
+
+      this.direction = (value > 0)
+      // animation terminate conditions
+      if (((this.direction) ^ (total <= this.endWith)) === 1) {
+        this.dirty = false
+        total = this.endWith
+        this.props.onFinish(total, this.props.formatter(total))
+      }
+
+      if(this.props.onProgress)
+        this.props.onProgress(this.state.value, total)
+
+      this.setState({
+        value : total,
+        displayValue : this.props.formatter(total)
+      })
+
+    }, this.getTimingFunction(this.props.interval, progress))
+
+  }
+
+  getAnimationProgress():number {
+    return (this.state.value - this.startFrom) / (this.endWith - this.startFrom)
+  }
+
+  getTimingFunction(interval:number, progress:number) {
+    if(typeof this.props.timing === 'string') {
+      let fn = AnimateNumber.TimingFunctions[this.props.timing]
+      return fn(interval, progress)
+    } else if(typeof this.props.timing === 'function')
+      return this.props.timing(interval, progress)
+    else
+      return AnimateNumber.TimingFunctions['linear'](interval, progress)
+  }
+
+}

test/react-native-testkit/components/reporter.js

   RecyclerViewBackedScrollView,
 } from 'react-native';
 
+import AnimateNumber from '../animate-text.js'
 import Assert from './assert.js'
 import RNTEST from '../index.js'
 
         passed += tests[i].status === 'pass' ? 1 : 0
     }
     let percent = passed / count
-    let color = `rgb(${Math.floor((1-percent) *255)},${Math.floor(percent *255)}, 0)`
+    let color = `rgb(${Math.floor((1-percent) *255)},${Math.floor(percent *192)}, 0)`
 
     return (
       <View style={{flex : 1}}>
           <Text>{`${executed} tests executed`}</Text>
           <Text>{`${passed} test cases passed`}</Text>
           <Text>{`${count} test cases`}</Text>
-          <Text style={{color, fontSize : 120, textAlign : 'center'}} >{`${Math.floor(percent*100)}`}</Text>
-          <Text style={{color, fontSize : 30, textAlign :'right', marginTop : -54, marginRight : 40, backgroundColor : 'transparent'}} >{`%`}</Text>
+          <View style={{flexDirection : 'row', alignSelf : 'center', alignItems : 'flex-end'}}>
+            <AnimateNumber style={{
+              color,
+              fontSize : 100,
+              textAlign : 'right'
+            }}
+              value={Math.floor(passed / count*100)}
+              countBy={1}/>
+            <Text style={{color, fontSize : 30, textAlign : 'left'}} >{`%`}</Text>
+          </View>
         </View>
         <ListView
           style={[styles.container]}
       t.status = 'waiting'
 
     return (
-      // <TouchableOpacity onPress={()=>{
-      //   t.start(t.sn)
-      // }}>
         <View key={'rn-test-' + t.desc} style={{
           borderBottomWidth : 1.5,
           borderColor : '#DDD',
             {t.expand ? t.result : (t.status === 'pass' ? null : t.result)}
           </View>
         </View>)
-        {/*</TouchableOpacity>)*/}
   }
 
   updateDataSource() {

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

           })
           resolve(...res)
         }
+        RCTContext.forceUpdate()
       }).catch((err) => {
         updateInternal({
           executed : true,

test/test-0.5.1.js

   let filename = '22mb-dummy-' + Date.now()
   let begin = -1
   let begin2 = -1
+  let deb = Date.now()
   RNFetchBlob.config({
     fileCache : true
   })
   .fetch('GET', `${TEST_SERVER_URL}/public/22mb-dummy`)
-  // .progress((now, total) => {
-  //   if(begin === -1)
-  //     begin = Date.now()
-  //   report(<Info uid="200" key="progress">
-  //     <Text>
-  //       {`download ${now} / ${total} bytes (${Math.floor(now / (Date.now() - begin))} kb/s)`}
-  //     </Text>
-  //   </Info>)
-  // })
+  .progress((now, total) => {
+    if(begin === -1)
+      begin = Date.now()
+    if(Date.now() - deb < 1000)
+      return
+    deb = Date.now()
+    report(<Info uid="200" key="progress">
+      <Text>
+        {`download ${now} / ${total} bytes (${Math.floor(now / (Date.now() - begin))} kb/s)`}
+      </Text>
+    </Info>)
+  })
   .then((res) => {
+    deb = Date.now()
     return RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
       Authorization : `Bearer ${DROPBOX_TOKEN}`,
       'Dropbox-API-Arg': '{\"path\": \"/rn-upload/'+filename+'\",\"mode\": \"add\",\"autorename\": true,\"mute\": false}',
       'Content-Type' : 'application/octet-stream',
     }, RNFetchBlob.wrap(res.path()))
-    // .progress((now, total) => {
-    //   if(begin2 === -1)
-    //     begin2 = Date.now()
-    //   let speed = Math.floor(now / (Date.now() - begin2))
-    //   report(<Info uid="100"  key="progress">
-    //     <Text>
-    //       {`upload ${now} / ${total} bytes (${speed} kb/s)`}
-    //       {` ${Math.floor((total-now)/speed/1000)} seconds left`}
-    //     </Text>
-    //   </Info>)
-    // })
+    .progress((now, total) => {
+      if(Date.now() - deb < 1000)
+        return
+      deb = Date.now()
+      if(begin2 === -1)
+        begin2 = Date.now()
+      let speed = Math.floor(now / (Date.now() - begin2))
+      report(<Info uid="100"  key="progress">
+        <Text>
+          {`upload ${now} / ${total} bytes (${speed} kb/s)`}
+          {` ${Math.floor((total-now)/speed/1000)} seconds left`}
+        </Text>
+      </Info>)
+    })
   })
   .then((res) => {
     report(<Assert

test/test-0.6.2.js

   group : '0.6.2',
   run : true,
   expand : false,
-  timeout : 12000,
+  timeout : 30000,
 })
 const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, DROPBOX_TOKEN, styles } = prop()
 const  dirs = RNFetchBlob.fs.dirs
 
 describe('upload asset from camera roll', (report, done) => {
   let imgName = `image-from-camera-roll-${Platform.OS}.jpg`
+  let tick = Date.now()
   CameraRoll.getPhotos({first : 10})
     .then((resp) => {
       let url = resp.edges[0].node.image.uri
         'Dropbox-API-Arg': `{\"path\": \"/rn-upload/${imgName}\",\"mode\": \"add\",\"autorename\": false,\"mute\": false}`,
         'Content-Type' : 'application/octet-stream',
       }, RNFetchBlob.wrap(url))
+      .progress((now, total) => {
+        if(Date.now() - tick < 1000)
+        return
+        report(<Info key="progress" uid="pg1">
+          <Text>{`upload ${now} / ${total} ${Math.floor(now/total*100)}% `}</Text>
+        </Info>)
+      })
     })
     .then((resp) => {
       resp = resp.json()
       done()
     })
 })
+
+
+describe('upload file from assets',(report, done) => {
+  let assetName = fs.asset('test-asset1.json')
+  RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
+    Authorization : `Bearer ${DROPBOX_TOKEN}`,
+    'Dropbox-API-Arg': `{\"path\": \"/rn-upload/file-from-asset-${Platform.OS}.json\",\"mode\": \"add\",\"autorename\": false,\"mute\": false}`,
+    'Content-Type' : 'application/octet-stream',
+  }, RNFetchBlob.wrap(assetName))
+  .then((resp) => {
+    resp = resp.json()
+    report(
+      <Assert key="file name check"
+        expect={`file-from-asset-${Platform.OS}.json`}
+        actual={resp.name}/>)
+    done()
+  })
+})
+
+describe('Check custom MIME type correctness',(report, done) => {
+  RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/mime`, null, [
+    { name : 'image', filename : 'image', type : 'image/jpeg', data : RNFetchBlob.base64.encode('123456') },
+    { name : 'mp3', filename : 'mp3', type : 'application/mp3', data : RNFetchBlob.base64.encode('123456') },
+    { name : 'mp3', filename : 'mp3', data : RNFetchBlob.base64.encode('123456') }
+  ])
+  .then((resp) => {
+    resp = resp.json()
+    report(<Assert key="check first mime" expect={'image/jpeg'} actual={resp[0]} />)
+    done()
+  })
+})

test/test-android.js

 const describe = RNTest.config({
   group : 'Android only functions',
   run : Platform.OS === 'android',
-  expand : true,
+  expand : false,
 })
 const { TEST_SERVER_URL, FILENAME, DROPBOX_TOKEN, styles } = prop()
 

test/test-init.js

     })
 })
 
-require('./test-0.1.x-0.4.x')
-require('./test-0.5.1')
-require('./test-0.5.2')
-require('./test-0.6.0')
+
+// require('./test-0.1.x-0.4.x')
+// require('./test-0.5.1')
+// require('./test-0.5.2')
+// require('./test-0.6.0')
 require('./test-0.6.2')
-require('./test-fs')
-require('./test-android')
+// require('./test-fs')
+// require('./test-android')