[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: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
      });
      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:15: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('12:15:78');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

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

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

    it('carry hidden correctly', (done) => {
      const picker = renderPicker({
        disabledMinutes: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22],
        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 = '12:15: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('12:15:78');
        expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');

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

        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) => {
	125	const picker = renderPicker({
	126	disabledMinutes: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
	127	});
	128	expect(picker.state.open).not.to.be.ok();
	129	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	130	let header;
	131	async.series([(next) => {
	132	Simulate.click(input);
	133	setTimeout(next, 100);
	134	}, (next) => {
	135	expect(picker.state.open).to.be(true);
	136	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	137	expect(header).to.be.ok();
	138	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	139	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	140
	141	ReactDOM.findDOMNode(header).value = '12:15:78';
	142	Simulate.change(header);
	143	setTimeout(next, 100);
	144	}, (next) => {
	145	expect(picker.state.open).to.be(true);
	146	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	147	expect(ReactDOM.findDOMNode(header).value).to.be('12:15:78');
	148	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	149
	150	ReactDOM.findDOMNode(header).value = '12:10:78';
	151	Simulate.change(header);
	152	setTimeout(next, 100);
	153	}, (next) => {
	154	expect(picker.state.open).to.be(true);
	155	expect(ReactDOM.findDOMNode(header).value).to.be('12:11:18');
	156	expect(ReactDOM.findDOMNode(input).value).to.be('12:11:18');
	157
	158	next();
	159	}], () => {
	160	done();
	161	});
	162	});
	163
	164	it('carry hidden correctly', (done) => {
	165	const picker = renderPicker({
	166	disabledMinutes: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22],
	167	hideDisabledOptions: true
	168	});
	169	expect(picker.state.open).not.to.be.ok();
	170	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	171	let header;
	172	async.series([(next) => {
	173	Simulate.click(input);
	174	setTimeout(next, 100);
	175	}, (next) => {
	176	expect(picker.state.open).to.be(true);
	177	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	178	expect(header).to.be.ok();
	179	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	180	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	181
	182	ReactDOM.findDOMNode(header).value = '12:15:78';
	183	Simulate.change(header);
	184	setTimeout(next, 100);
	185	}, (next) => {
	186	expect(picker.state.open).to.be(true);
	187	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
188	expect(ReactDOM.findDOMNode(header).value).to.be('12:15:78');
189	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
190
191	ReactDOM.findDOMNode(header).value = '12:10:78';
192	Simulate.change(header);
193	setTimeout(next, 100);
194	}, (next) => {
195	expect(picker.state.open).to.be(true);
196	expect(ReactDOM.findDOMNode(header).value).to.be('12:11:18');
197	expect(ReactDOM.findDOMNode(input).value).to.be('12:11:18');
198
199	next();
200	}], () => {
201	done();
202	});
203	});
204
e9060dda	205	it('check correctly', (done) => {
e9060dda	206	const picker = renderPicker();
02d1b455	207	expect(picker.state.open).not.to.be.ok();
e9060dda	208	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	209	let header;
	210	async.series([(next) => {
02d1b455 M	211	Simulate.click(input);
02d1b455 M	212	setTimeout(next, 100);
e9060dda	213	}, (next) => {
02d1b455 M	214	expect(picker.state.open).to.be(true);
	215	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	216	expect(header).to.be.ok();
	217	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	218	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	219
	220	ReactDOM.findDOMNode(header).value = '3:34:56';
	221	Simulate.change(header);
	222	setTimeout(next, 100);
e9060dda	223	}, (next) => {
02d1b455 M	224	expect(picker.state.open).to.be(true);
	225	expect(ReactDOM.findDOMNode(header).value).to.be('3:34:56');
	226	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	227	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	228
	229	ReactDOM.findDOMNode(header).value = '13:3:56';
	230	Simulate.change(header);
	231	setTimeout(next, 100);
e9060dda	232	}, (next) => {
02d1b455 M	233	expect(picker.state.open).to.be(true);
	234	expect(ReactDOM.findDOMNode(header).value).to.be('13:3:56');
	235	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	236	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	237
	238	ReactDOM.findDOMNode(header).value = '13:34:5';
	239	Simulate.change(header);
	240	setTimeout(next, 100);
e9060dda	241	}, (next) => {
02d1b455 M	242	expect(picker.state.open).to.be(true);
	243	expect(ReactDOM.findDOMNode(header).value).to.be('13:34:5');
	244	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	245	expect(ReactDOM.findDOMNode(header).className).to.contain('rc-time-picker-panel-input-invalid');
	246	next();
e9060dda	247	}], () => {
02d1b455 M	248	done();
	249	});
	250	});
02d1b455 M	251	});
02d1b455 M	252
e9060dda	253	describe('other operations', () => {
	254	it('clear correctly', (done) => {
	255	let change;
	256	const picker = renderPicker({
	257	onChange(v) {
02d1b455	258	change = v;
e9060dda	259	},
02d1b455 M	260	});
02d1b455 M	261	expect(picker.state.open).not.to.be.ok();
e9060dda	262	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	263	let header;
	264	async.series([(next) => {
02d1b455 M	265	expect(picker.state.open).to.be(false);
	266
	267	Simulate.click(input);
	268	setTimeout(next, 100);
e9060dda	269	}, (next) => {
02d1b455 M	270	expect(picker.state.open).to.be(true);
02d1b455 M	271	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
e9060dda	272	const clearButton = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-clear-btn')[0];
02d1b455 M	273	expect(header).to.be.ok();
	274	expect(clearButton).to.be.ok();
	275	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	276	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	277
	278	Simulate.mouseDown(clearButton);
	279	setTimeout(next, 100);
e9060dda	280	}, (next) => {
02d1b455 M	281	expect(picker.state.open).to.be(false);
	282	expect(change).to.be(null);
	283	expect(ReactDOM.findDOMNode(header).value).to.be('');
	284	expect(ReactDOM.findDOMNode(input).value).to.be('');
	285
	286	next();
e9060dda	287	}], () => {
02d1b455 M	288	done();
	289	});
	290	});
	291
e9060dda	292	it('exit correctly', (done) => {
e9060dda	293	const picker = renderPicker();
02d1b455	294	expect(picker.state.open).not.to.be.ok();
e9060dda	295	const input = TestUtils.scryRenderedDOMComponentsWithClass(picker, 'rc-time-picker-input')[0];
	296	let header;
	297	async.series([(next) => {
02d1b455 M	298	expect(picker.state.open).to.be(false);
	299
	300	Simulate.click(input);
	301	setTimeout(next, 100);
e9060dda	302	}, (next) => {
02d1b455 M	303	expect(picker.state.open).to.be(true);
	304	header = TestUtils.scryRenderedDOMComponentsWithClass(picker.panelInstance, 'rc-time-picker-panel-input')[0];
	305	expect(header).to.be.ok();
	306	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	307	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	308
	309	Simulate.keyDown(ReactDOM.findDOMNode(header), {
e9060dda	310	keyCode: KeyCode.ESC,
02d1b455 M	311	});
02d1b455 M	312	setTimeout(next, 100);
e9060dda	313	}, (next) => {
02d1b455 M	314	expect(picker.state.open).to.be(false);
	315	expect(ReactDOM.findDOMNode(header).value).to.be('01:02:03');
	316	expect(ReactDOM.findDOMNode(input).value).to.be('01:02:03');
	317
	318	next();
e9060dda	319	}], () => {
02d1b455 M	320	done();
	321	});
	322	});
02d1b455 M	323	});
02d1b455 M	324	});