[github/fretlink/time-picker.git] / tests / Header.spec.jsx

import ReactDOM from 'react-dom';
import React from 'react';
import TimePicker from '../src/TimePicker';

import TestUtils from 'react-addons-test-utils';
const Simulate = TestUtils.Simulate;
import expect from 'expect.js';
import async from 'async';
import {KeyCode} from 'rc-util';

import DateTimeFormat from 'gregorian-calendar-format';
import zhCn from 'gregorian-calendar/lib/locale/zh_CN';
import TimePickerLocale from '../src/locale/zh_CN';

function formatTime(time, formatter) {
  return formatter.parse(time, {
    locale: zhCn,
    obeyCount: true,
  });
}

describe('Header', () => {
  let container;

  function renderPicker(props) {
    const showSecond = true;
    const formatter = new DateTimeFormat('HH:mm:ss');

    return ReactDOM.render(
      <TimePicker
        formatter={formatter}
        locale={TimePickerLocale}
        showSecond={showSecond}
        defaultValue={formatTime('01:02:03', formatter)}
        {...props}
      />, container);
  }

  beforeEach(() => {
    container = document.createElement('div');
    document.body.appendChild(container);
  });

  afterEach(() => {
    ReactDOM.unmountComponentAtNode(container);
    document.body.removeChild(container);
  });

  describe('input to change value', () => {
    it('input correctly', (done) => {
      const picker = renderPicker();
      expect(picker.state.open).not.to.be.ok();
      const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
      let header;
      async.series([(next) => {
        Simulate.click(input);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
        expect(header).to.be.ok();
        expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        ReactDOM.findDOMNode(header).value = '12:34:56';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('12:34:56');
        expect(ReactDOM.findDOMNode(input).value).to.be('12:34:56');

        next();
      }], () => {
        done();
      });
    });

    it('carry correctly', (done) => {
      const picker = renderPicker();
      expect(picker.state.open).not.to.be.ok();
      const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
      let header;
      async.series([(next) => {
        Simulate.click(input);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
        expect(header).to.be.ok();
        expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        ReactDOM.findDOMNode(header).value = '33:44:55';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('09:44:55');
        expect(ReactDOM.findDOMNode(input).value).to.be('09:44:55');

        ReactDOM.findDOMNode(header).value = '10:90:30';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('11:30:30');
        expect(ReactDOM.findDOMNode(input).value).to.be('11:30:30');

        ReactDOM.findDOMNode(header).value = '34:56:78';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('10:57:18');
        expect(ReactDOM.findDOMNode(input).value).to.be('10:57:18');

        next();
      }], () => {
        done();
      });
    });

    it('carry disabled correctly', (done) => {
      const picker = renderPicker({
        disabledMinutes(h) {
          return [h];
        },
        disabledSeconds(h, m) {
          return [h + m % 60];
        },
      });
      expect(picker.state.open).not.to.be.ok();
      const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
      let header;
      async.series([(next) => {
        Simulate.click(input);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
        expect(header).to.be.ok();
        expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        ReactDOM.findDOMNode(header).value = '10:09:78';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
        expect(ReactDOM.findDOMNode(header).value).to.be('10:09:78');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        ReactDOM.findDOMNode(header).value = '10:10:78';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('10:11:18');
        expect(ReactDOM.findDOMNode(input).value).to.be('10:11:18');

        ReactDOM.findDOMNode(header).value = '10:09:19';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
        expect(ReactDOM.findDOMNode(header).value).to.be('10:09:19');
        expect(ReactDOM.findDOMNode(input).value).to.be('10:11:18');

        ReactDOM.findDOMNode(header).value = '10:09:20';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('10:09:20');
        expect(ReactDOM.findDOMNode(input).value).to.be('10:09:20');

        next();
      }], () => {
        done();
      });
    });

    it('carry hidden correctly', (done) => {
      const picker = renderPicker({
        disabledMinutes(h) {
          return [h];
        },
        disabledSeconds(h, m) {
          return [h + m % 60];
        },
        hideDisabledOptions: true,
      });
      expect(picker.state.open).not.to.be.ok();
      const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
      let header;
      async.series([(next) => {
        Simulate.click(input);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
        expect(header).to.be.ok();
        expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        ReactDOM.findDOMNode(header).value = '10:09:78';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
        expect(ReactDOM.findDOMNode(header).value).to.be('10:09:78');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        ReactDOM.findDOMNode(header).value = '10:10:78';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('10:11:18');
        expect(ReactDOM.findDOMNode(input).value).to.be('10:11:18');

        ReactDOM.findDOMNode(header).value = '10:09:19';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
        expect(ReactDOM.findDOMNode(header).value).to.be('10:09:19');
        expect(ReactDOM.findDOMNode(input).value).to.be('10:11:18');

        ReactDOM.findDOMNode(header).value = '10:09:20';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('10:09:20');
        expect(ReactDOM.findDOMNode(input).value).to.be('10:09:20');

        next();
      }], () => {
        done();
      });
    });

    it('check correctly', (done) => {
      const picker = renderPicker();
      expect(picker.state.open).not.to.be.ok();
      const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
      let header;
      async.series([(next) => {
        Simulate.click(input);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
        expect(header).to.be.ok();
        expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        ReactDOM.findDOMNode(header).value = '3:34:56';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('3:34:56');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');

        ReactDOM.findDOMNode(header).value = '13:3:56';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('13:3:56');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');

        ReactDOM.findDOMNode(header).value = '13:34:5';
        Simulate.change(header);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        expect(ReactDOM.findDOMNode(header).value).to.be('13:34:5');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
        next();
      }], () => {
        done();
      });
    });
  });

  describe('other operations', () => {
    it('clear correctly', (done) => {
      let change;
      const picker = renderPicker({
        onChange(v) {
          change = v;
        },
      });
      expect(picker.state.open).not.to.be.ok();
      const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
      let header;
      async.series([(next) => {
        expect(picker.state.open).to.be(false);

        Simulate.click(input);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
        const clearButton = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-clear-btn')[0];
        expect(header).to.be.ok();
        expect(clearButton).to.be.ok();
        expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        Simulate.mouseDown(clearButton);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(false);
        expect(change).to.be(null);
        expect(ReactDOM.findDOMNode(header).value).to.be('');
        expect(ReactDOM.findDOMNode(input).value).to.be('');

        next();
      }], () => {
        done();
      });
    });

    it('exit correctly', (done) => {
      const picker = renderPicker();
      expect(picker.state.open).not.to.be.ok();
      const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
      let header;
      async.series([(next) => {
        expect(picker.state.open).to.be(false);

        Simulate.click(input);
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(true);
        header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
        expect(header).to.be.ok();
        expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        Simulate.keyDown(ReactDOM.findDOMNode(header), {
          keyCode: KeyCode.ESC,
        });
        setTimeout(next, 100);
      }, (next) => {
        expect(picker.state.open).to.be(false);
        expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

        next();
      }], () => {
        done();
      });
    });
  });
});
Commit	Line	Data
02d1b455 M	1	import ReactDOM from 'react-dom';
	2	import React from 'react';
	3	import TimePicker from '../src/TimePicker';
	4
	5	import TestUtils from 'react-addons-test-utils';
e9060dda	6	const Simulate = TestUtils.Simulate;
02d1b455 M	7	import expect from 'expect.js';
	8	import async from 'async';
	9	import {KeyCode} from 'rc-util';
	10
	11	import DateTimeFormat from 'gregorian-calendar-format';
02d1b455 M	12	import zhCn from 'gregorian-calendar/lib/locale/zh_CN';
	13	import TimePickerLocale from '../src/locale/zh_CN';
	14
e9060dda	15	function formatTime(time, formatter) {
	16	return formatter.parse(time, {
	17	locale: zhCn,
	18	obeyCount: true,
	19	});
	20	}
	21
	22	describe('Header', () => {
	23	let container;
02d1b455 M	24
02d1b455 M	25	function renderPicker(props) {
e9060dda	26	const showSecond = true;
e9060dda	27	const formatter = new DateTimeFormat('HH:mm:ss');
02d1b455 M	28
	29	return ReactDOM.render(
	30	<TimePicker
	31	formatter={formatter}
	32	locale={TimePickerLocale}
	33	showSecond={showSecond}
	34	defaultValue={formatTime('01:02:03', formatter)}
	35	{...props}
	36	/>, container);
	37	}
	38
e9060dda	39	beforeEach(() => {
02d1b455 M	40	container = document.createElement('div');
	41	document.body.appendChild(container);
	42	});
	43
e9060dda	44	afterEach(() => {
02d1b455 M	45	ReactDOM.unmountComponentAtNode(container);
	46	document.body.removeChild(container);
	47	});
	48
e9060dda	49	describe('input to change value', () => {
	50	it('input correctly', (done) => {
	51	const picker = renderPicker();
02d1b455	52	expect(picker.state.open).not.to.be.ok();
e9060dda	53	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	54	let header;
	55	async.series([(next) => {
02d1b455 M	56	Simulate.click(input);
02d1b455 M	57	setTimeout(next, 100);
e9060dda	58	}, (next) => {
02d1b455 M	59	expect(picker.state.open).to.be(true);
	60	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	61	expect(header).to.be.ok();
	62	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	63	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	64
	65	ReactDOM.findDOMNode(header).value = '12:34:56';
	66	Simulate.change(header);
	67	setTimeout(next, 100);
e9060dda	68	}, (next) => {
02d1b455 M	69	expect(picker.state.open).to.be(true);
	70	expect(ReactDOM.findDOMNode(header).value).to.be('12:34:56');
	71	expect(ReactDOM.findDOMNode(input).value).to.be('12:34:56');
	72
	73	next();
e9060dda	74	}], () => {
02d1b455 M	75	done();
	76	});
	77	});
	78
e9060dda	79	it('carry correctly', (done) => {
e9060dda	80	const picker = renderPicker();
02d1b455	81	expect(picker.state.open).not.to.be.ok();
e9060dda	82	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	83	let header;
	84	async.series([(next) => {
02d1b455 M	85	Simulate.click(input);
02d1b455 M	86	setTimeout(next, 100);
e9060dda	87	}, (next) => {
02d1b455 M	88	expect(picker.state.open).to.be(true);
	89	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	90	expect(header).to.be.ok();
	91	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	92	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	93
	94	ReactDOM.findDOMNode(header).value = '33:44:55';
	95	Simulate.change(header);
	96	setTimeout(next, 100);
e9060dda	97	}, (next) => {
02d1b455 M	98	expect(picker.state.open).to.be(true);
	99	expect(ReactDOM.findDOMNode(header).value).to.be('09:44:55');
	100	expect(ReactDOM.findDOMNode(input).value).to.be('09:44:55');
	101
	102	ReactDOM.findDOMNode(header).value = '10:90:30';
	103	Simulate.change(header);
	104	setTimeout(next, 100);
e9060dda	105	}, (next) => {
02d1b455 M	106	expect(picker.state.open).to.be(true);
	107	expect(ReactDOM.findDOMNode(header).value).to.be('11:30:30');
	108	expect(ReactDOM.findDOMNode(input).value).to.be('11:30:30');
	109
	110	ReactDOM.findDOMNode(header).value = '34:56:78';
	111	Simulate.change(header);
	112	setTimeout(next, 100);
e9060dda	113	}, (next) => {
02d1b455 M	114	expect(picker.state.open).to.be(true);
	115	expect(ReactDOM.findDOMNode(header).value).to.be('10:57:18');
	116	expect(ReactDOM.findDOMNode(input).value).to.be('10:57:18');
	117
	118	next();
e9060dda	119	}], () => {
02d1b455 M	120	done();
	121	});
	122	});
	123
0e62bf0b M	124	it('carry disabled correctly', (done) => {
0e62bf0b M	125	const picker = renderPicker({
71bd9bc1 M	126	disabledMinutes(h) {
	127	return [h];
	128	},
	129	disabledSeconds(h, m) {
	130	return [h + m % 60];
	131	},
0e62bf0b M	132	});
	133	expect(picker.state.open).not.to.be.ok();
	134	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	135	let header;
	136	async.series([(next) => {
	137	Simulate.click(input);
	138	setTimeout(next, 100);
	139	}, (next) => {
	140	expect(picker.state.open).to.be(true);
	141	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	142	expect(header).to.be.ok();
	143	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	144	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	145
71bd9bc1	146	ReactDOM.findDOMNode(header).value = '10:09:78';
0e62bf0b M	147	Simulate.change(header);
	148	setTimeout(next, 100);
	149	}, (next) => {
	150	expect(picker.state.open).to.be(true);
	151	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
71bd9bc1	152	expect(ReactDOM.findDOMNode(header).value).to.be('10:09:78');
0e62bf0b M	153	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
0e62bf0b M	154
71bd9bc1	155	ReactDOM.findDOMNode(header).value = '10:10:78';
0e62bf0b M	156	Simulate.change(header);
	157	setTimeout(next, 100);
	158	}, (next) => {
	159	expect(picker.state.open).to.be(true);
71bd9bc1 M	160	expect(ReactDOM.findDOMNode(header).value).to.be('10:11:18');
	161	expect(ReactDOM.findDOMNode(input).value).to.be('10:11:18');
	162
	163	ReactDOM.findDOMNode(header).value = '10:09:19';
	164	Simulate.change(header);
	165	setTimeout(next, 100);
	166	}, (next) => {
	167	expect(picker.state.open).to.be(true);
	168	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	169	expect(ReactDOM.findDOMNode(header).value).to.be('10:09:19');
	170	expect(ReactDOM.findDOMNode(input).value).to.be('10:11:18');
	171
	172	ReactDOM.findDOMNode(header).value = '10:09:20';
	173	Simulate.change(header);
	174	setTimeout(next, 100);
	175	}, (next) => {
	176	expect(picker.state.open).to.be(true);
	177	expect(ReactDOM.findDOMNode(header).value).to.be('10:09:20');
	178	expect(ReactDOM.findDOMNode(input).value).to.be('10:09:20');
0e62bf0b M	179
	180	next();
	181	}], () => {
	182	done();
	183	});
	184	});
	185
	186	it('carry hidden correctly', (done) => {
	187	const picker = renderPicker({
71bd9bc1 M	188	disabledMinutes(h) {
	189	return [h];
	190	},
	191	disabledSeconds(h, m) {
	192	return [h + m % 60];
	193	},
	194	hideDisabledOptions: true,
0e62bf0b M	195	});
	196	expect(picker.state.open).not.to.be.ok();
	197	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	198	let header;
	199	async.series([(next) => {
	200	Simulate.click(input);
	201	setTimeout(next, 100);
	202	}, (next) => {
	203	expect(picker.state.open).to.be(true);
	204	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	205	expect(header).to.be.ok();
	206	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	207	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	208
71bd9bc1	209	ReactDOM.findDOMNode(header).value = '10:09:78';
0e62bf0b M	210	Simulate.change(header);
	211	setTimeout(next, 100);
	212	}, (next) => {
	213	expect(picker.state.open).to.be(true);
	214	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
71bd9bc1	215	expect(ReactDOM.findDOMNode(header).value).to.be('10:09:78');
0e62bf0b M	216	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
0e62bf0b M	217
71bd9bc1 M	218	ReactDOM.findDOMNode(header).value = '10:10:78';
	219	Simulate.change(header);
	220	setTimeout(next, 100);
	221	}, (next) => {
	222	expect(picker.state.open).to.be(true);
	223	expect(ReactDOM.findDOMNode(header).value).to.be('10:11:18');
	224	expect(ReactDOM.findDOMNode(input).value).to.be('10:11:18');
	225
	226	ReactDOM.findDOMNode(header).value = '10:09:19';
	227	Simulate.change(header);
	228	setTimeout(next, 100);
	229	}, (next) => {
	230	expect(picker.state.open).to.be(true);
	231	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	232	expect(ReactDOM.findDOMNode(header).value).to.be('10:09:19');
	233	expect(ReactDOM.findDOMNode(input).value).to.be('10:11:18');
	234
	235	ReactDOM.findDOMNode(header).value = '10:09:20';
0e62bf0b M	236	Simulate.change(header);
	237	setTimeout(next, 100);
	238	}, (next) => {
	239	expect(picker.state.open).to.be(true);
71bd9bc1 M	240	expect(ReactDOM.findDOMNode(header).value).to.be('10:09:20');
71bd9bc1 M	241	expect(ReactDOM.findDOMNode(input).value).to.be('10:09:20');
0e62bf0b M	242
	243	next();
	244	}], () => {
	245	done();
	246	});
	247	});
	248
e9060dda	249	it('check correctly', (done) => {
e9060dda	250	const picker = renderPicker();
02d1b455	251	expect(picker.state.open).not.to.be.ok();
e9060dda	252	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	253	let header;
	254	async.series([(next) => {
02d1b455 M	255	Simulate.click(input);
02d1b455 M	256	setTimeout(next, 100);
e9060dda	257	}, (next) => {
02d1b455 M	258	expect(picker.state.open).to.be(true);
	259	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	260	expect(header).to.be.ok();
	261	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	262	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	263
	264	ReactDOM.findDOMNode(header).value = '3:34:56';
	265	Simulate.change(header);
	266	setTimeout(next, 100);
e9060dda	267	}, (next) => {
02d1b455 M	268	expect(picker.state.open).to.be(true);
	269	expect(ReactDOM.findDOMNode(header).value).to.be('3:34:56');
	270	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	271	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	272
	273	ReactDOM.findDOMNode(header).value = '13:3:56';
	274	Simulate.change(header);
	275	setTimeout(next, 100);
e9060dda	276	}, (next) => {
02d1b455 M	277	expect(picker.state.open).to.be(true);
	278	expect(ReactDOM.findDOMNode(header).value).to.be('13:3:56');
	279	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	280	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	281
	282	ReactDOM.findDOMNode(header).value = '13:34:5';
	283	Simulate.change(header);
	284	setTimeout(next, 100);
e9060dda	285	}, (next) => {
02d1b455 M	286	expect(picker.state.open).to.be(true);
	287	expect(ReactDOM.findDOMNode(header).value).to.be('13:34:5');
	288	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	289	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	290	next();
e9060dda	291	}], () => {
02d1b455 M	292	done();
	293	});
	294	});
02d1b455 M	295	});
02d1b455 M	296
e9060dda	297	describe('other operations', () => {
	298	it('clear correctly', (done) => {
	299	let change;
	300	const picker = renderPicker({
	301	onChange(v) {
02d1b455	302	change = v;
e9060dda	303	},
02d1b455 M	304	});
02d1b455 M	305	expect(picker.state.open).not.to.be.ok();
e9060dda	306	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	307	let header;
	308	async.series([(next) => {
02d1b455 M	309	expect(picker.state.open).to.be(false);
	310
	311	Simulate.click(input);
	312	setTimeout(next, 100);
e9060dda	313	}, (next) => {
02d1b455 M	314	expect(picker.state.open).to.be(true);
02d1b455 M	315	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
e9060dda	316	const clearButton = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-clear-btn')[0];
02d1b455 M	317	expect(header).to.be.ok();
	318	expect(clearButton).to.be.ok();
	319	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	320	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	321
	322	Simulate.mouseDown(clearButton);
	323	setTimeout(next, 100);
e9060dda	324	}, (next) => {
02d1b455 M	325	expect(picker.state.open).to.be(false);
	326	expect(change).to.be(null);
	327	expect(ReactDOM.findDOMNode(header).value).to.be('');
	328	expect(ReactDOM.findDOMNode(input).value).to.be('');
	329
	330	next();
e9060dda	331	}], () => {
02d1b455 M	332	done();
	333	});
	334	});
	335
e9060dda	336	it('exit correctly', (done) => {
e9060dda	337	const picker = renderPicker();
02d1b455	338	expect(picker.state.open).not.to.be.ok();
e9060dda	339	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	340	let header;
	341	async.series([(next) => {
02d1b455 M	342	expect(picker.state.open).to.be(false);
	343
	344	Simulate.click(input);
	345	setTimeout(next, 100);
e9060dda	346	}, (next) => {
02d1b455 M	347	expect(picker.state.open).to.be(true);
	348	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	349	expect(header).to.be.ok();
	350	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	351	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	352
	353	Simulate.keyDown(ReactDOM.findDOMNode(header), {
e9060dda	354	keyCode: KeyCode.ESC,
02d1b455 M	355	});
02d1b455 M	356	setTimeout(next, 100);
e9060dda	357	}, (next) => {
02d1b455 M	358	expect(picker.state.open).to.be(false);
	359	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	360	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	361
	362	next();
e9060dda	363	}], () => {
02d1b455 M	364	done();
	365	});
	366	});
02d1b455 M	367	});
02d1b455 M	368	});