Debian Codegraph @

packages/controls/test/src/widget_datetime_test.ts

raw
1 // Copyright (c) Jupyter Development Team.
2 // Distributed under the terms of the Modified BSD License.
3
4 import { expect } from 'chai';
5
6 import { DummyManager } from './dummy-manager';
7
8 import {
9 createTestModel,
10 createTestView,
11 createTestModelFromSerialized,
12 } from './utils';
13
14 import { DatetimeModel, DatetimeView, NaiveDatetimeModel } from '../../lib';
15
16 describe('Datetime', () => {
17 const date = new Date();
18
19 describe('DatetimeModel', () => {
20 it('should be createable', () => {
21 const model = createTestModel(DatetimeModel);
22 expect(model).to.be.an.instanceof(DatetimeModel);
23 expect(model.get('value')).to.be.a('null');
24 });
25
26 it('should be creatable with a value', () => {
27 const state = { value: date };
28 const model = createTestModel(DatetimeModel, state);
29 expect(model).to.be.instanceof(DatetimeModel);
30 expect(model.get('value')).to.equal(date);
31 });
32
33 it('should serialize as expected', async () => {
34 const state_in = {
35 value: {
36 year: 2002,
37 month: 2,
38 date: 20,
39 hours: 20,
40 minutes: 2,
41 seconds: 20,
42 milliseconds: 2,
43 },
44 };
45
46 const model = await createTestModelFromSerialized(
47 DatetimeModel,
48 state_in
49 );
50 model.widget_manager.register_model(
51 model.model_id,
52 Promise.resolve(model)
53 );
54
55 const state_out = await (
56 model.widget_manager as DummyManager
57 ).get_state();
58 const models = Object.keys(state_out.state).map(
59 (k) => state_out.state[k].state
60 );
61 expect(models.length).to.equal(1);
62 expect(models[0]._model_name).to.equal('DatetimeModel');
63 expect(models[0].value).to.eql(state_in.value);
64 });
65
66 it('should deserialize to Date object', async () => {
67 const state_in = {
68 value: {
69 year: 2002,
70 month: 2,
71 date: 20,
72 hours: 20,
73 minutes: 2,
74 seconds: 20,
75 milliseconds: 2,
76 },
77 };
78
79 const model = await createTestModelFromSerialized(
80 DatetimeModel,
81 state_in
82 );
83 expect(model.get('value')).to.eql(
84 new Date(Date.UTC(2002, 2, 20, 20, 2, 20, 2))
85 );
86 });
87
88 it('should deserialize null', async () => {
89 const state_in = { value: null };
90
91 const model = await createTestModelFromSerialized(
92 DatetimeModel,
93 state_in
94 );
95 expect(model.get('value')).to.be.a('null');
96 });
97
98 it('should deserialize undefined', async () => {
99 const state_in = {};
100 const model = await createTestModelFromSerialized(
101 DatetimeModel,
102 state_in
103 );
104 expect(model.get('value')).to.be.a('null');
105 });
106 });
107
108 describe('DatetimeView', () => {
109 it('should be createable', async () => {
110 const state = {};
111 const model = createTestModel(DatetimeModel, state);
112 const view = await createTestView(model, DatetimeView);
113 expect(view).to.be.an.instanceof(DatetimeView);
114 expect(view.model).to.equal(model);
115 });
116 });
117
118 describe('NaiveDatetimeModel', () => {
119 it('should be createable', () => {
120 const model = createTestModel(NaiveDatetimeModel);
121 expect(model).to.be.an.instanceof(NaiveDatetimeModel);
122 expect(model.get('value')).to.be.a('null');
123 });
124
125 it('should be creatable with a value', () => {
126 const state = { value: date };
127 const model = createTestModel(NaiveDatetimeModel, state);
128 expect(model).to.be.an.instanceof(NaiveDatetimeModel);
129 expect(model.get('value')).to.eql(date);
130 });
131
132 it('should serialize as expected', async () => {
133 const state_in = {
134 value: {
135 year: 2002,
136 month: 2,
137 date: 20,
138 hours: 20,
139 minutes: 2,
140 seconds: 20,
141 milliseconds: 2,
142 },
143 };
144
145 const model = await createTestModelFromSerialized(
146 NaiveDatetimeModel,
147 state_in
148 );
149 model.widget_manager.register_model(
150 model.model_id,
151 Promise.resolve(model)
152 );
153
154 const state_out = await (
155 model.widget_manager as DummyManager
156 ).get_state();
157 const models = Object.keys(state_out.state).map(
158 (k) => state_out.state[k].state
159 );
160 expect(models.length).to.eql(1);
161 expect(models[0]._model_name).to.eql('NaiveDatetimeModel');
162 expect(models[0].value).to.eql(state_in.value);
163 });
164
165 it('should deserialize to Date object', async () => {
166 const state_in = {
167 value: {
168 year: 2002,
169 month: 2,
170 date: 20,
171 hours: 20,
172 minutes: 2,
173 seconds: 20,
174 milliseconds: 2,
175 },
176 };
177
178 const model = await createTestModelFromSerialized(
179 NaiveDatetimeModel,
180 state_in
181 );
182 expect(model.get('value')).to.eql(new Date(2002, 2, 20, 20, 2, 20, 2));
183 });
184
185 it('should deserialize null', async () => {
186 const state_in = { value: null };
187
188 const model = await createTestModelFromSerialized(
189 NaiveDatetimeModel,
190 state_in
191 );
192 expect(model.get('value')).to.be.a('null');
193 });
194
195 it('should deserialize undefined', async () => {
196 const state_in = {};
197 const model = await createTestModelFromSerialized(
198 NaiveDatetimeModel,
199 state_in
200 );
201 expect(model.get('value')).to.be.a('null');
202 });
203 });
204 });