Branch data Line data Source code
1 [ + ]: 1 : /**
2 : 1 : * @module weather-test
3 : 1 : * @desc Testing module for the {@link module:weather weather} module.
4 : 1 : * @version 1.0.0
5 : 1 : * @author Essam A. El-Sherif
6 : 1 : */
7 : 1 :
8 : 1 : /* Import node.js core modules */
9 : 1 : import assert from 'node:assert/strict';
10 : 1 : import fs from 'node:fs';
11 : 1 : import { fileURLToPath } from 'node:url';
12 : 1 : import { dirname, join } from 'node:path';
13 : 1 :
14 : 1 : /* Import the tested module */
15 : 1 : import { Weather } from '../lib/weather.js';
16 : 1 :
17 : 1 : /* Emulate commonJS __filename and __dirname constants */
18 : 1 : const __filename = fileURLToPath(import.meta.url);
19 : 1 : const __dirname = dirname(__filename);
20 : 1 :
21 : 1 : /* Prepare test environment */
22 : 1 : let testCount = 1;
23 : 1 : let passCount = 0;
24 : 1 : let failCount = 0;
25 : 1 : let cancelCount = 0;
26 : 1 : let skipCount = 0;
27 : 1 : let todoCount = 0;
28 : 1 : let startTime = Date.now();
29 : 1 :
30 : 1 : const suites = new Map();
31 : 1 :
32 : 1 : /** @const {object} cmdOptions - Testing options. */
33 : 1 : const cmdOptions = {
34 : 1 : node : true,
35 : 1 : verbose : false,
36 : 1 : };
37 : 1 :
38 : 1 : /**
39 : 1 : * @func Main
40 : 1 : * @desc The application entry point function.
41 : 1 : */
42 [ + ]: 1 : (() => {
43 : 1 : loadTestData();
44 : 1 :
45 : 1 : if(cmdOptions.node){
46 : 1 : import('node:test')
47 [ + ]: 1 : .then(runner => {
48 : 1 : cmdOptions.verbose = false;
49 : 1 : nodeRunner(runner);
50 : 1 : }) /* node:coverage disable */
51 : : .catch((e) => {
52 : : defRunner();
53 : : });
54 [ - ]: : }
55 : : else{
56 : : defRunner();
57 : : } /* node:coverage enable */
58 : 1 : })('Main Function');
59 : 1 :
60 : 1 : /**
61 : 1 : * @func loadTestData
62 : 1 : * @desc Load test data.
63 : 1 : */
64 [ + ]: 1 : function loadTestData(){
65 : 1 :
66 : 1 : let testData = null;
67 : 1 : let suiteDesc = '';
68 : 1 :
69 : 1 : let key = join(__dirname, '../.api-key');
70 : 1 : try{
71 : 1 : key = fs.readFileSync(key, {encoding: 'utf8'});
72 : 1 : }
73 [ - ]: 1 : catch(e){
74 : 0 : key = '';
75 : 0 : }
76 : 1 :
77 : 1 : let sample_01_url = join(__dirname, './fixtures/sample_01.url');
78 : 1 : sample_01_url = fs.readFileSync(sample_01_url, {encoding: 'utf8'});
79 : 1 :
80 : 1 : let sample_01 = join(__dirname, './fixtures/sample_01.json');
81 : 1 : sample_01 = fs.readFileSync(sample_01, {encoding: 'utf8'});
82 : 1 :
83 : 1 : let sample_02_url = join(__dirname, './fixtures/sample_02.url');
84 : 1 : sample_02_url = fs.readFileSync(sample_02_url, {encoding: 'utf8'});
85 : 1 :
86 : 1 : let sample_02 = join(__dirname, './fixtures/sample_02.json');
87 : 1 : sample_02 = fs.readFileSync(sample_02, {encoding: 'utf8'});
88 : 1 :
89 : 1 : let sampleActive = sample_01;
90 : 1 :
91 : 1 : // TEST SUITE #1 - Test Weather Static Methods
92 : 1 : suiteDesc = 'Test Weather Static Methods';
93 : 1 : suites.set(suiteDesc, []);
94 : 1 :
95 : 1 : // TEST #01 - Static method Weather.filterItemByDatetimeVal()...test#1
96 : 1 : testData = {};
97 : 1 :
98 [ + ]: 1 : testData.method = async () => {
99 : 1 : let sample = JSON.parse(sampleActive);
100 : 1 :
101 : 1 : let datetime1 = sample.days[0].datetime;
102 : 1 : let res1 = Weather.filterItemByDatetimeVal(sample.days, datetime1);
103 : 1 :
104 : 1 : assert.strictEqual(typeof res1, 'object');
105 : 1 : assert.strictEqual(res1.datetime, datetime1);
106 : 1 :
107 : 1 : let datetime2 = sample.days[0].hours[0].datetime;
108 : 1 : let res2 = Weather.filterItemByDatetimeVal(res1.hours, datetime2);
109 : 1 :
110 : 1 : assert.strictEqual(typeof res2, 'object');
111 : 1 : assert.strictEqual(res2.datetime, datetime2);
112 : 1 :
113 : 1 : assert.strictEqual(Weather.filterItemByDatetimeVal(sample.days, '1970-01-01'), null);
114 : 1 : assert.throws(
115 [ + ]: 1 : () => {
116 : 1 : Weather.filterItemByDatetimeVal(sample.days, false);
117 : 1 : },
118 [ + ]: 1 : (err) => {
119 : 1 : assert(err instanceof TypeError);
120 : 1 : assert.strictEqual(err.message, `Weather.filterItemByDatetimeVal: Invalid input datetime value 'false'.`);
121 : 1 : return true;
122 : 1 : }
123 : 1 : );
124 : 1 : };
125 : 1 : testData.desc = 'Static method Weather.filterItemByDatetimeVal()...test#1';
126 : 1 :
127 : 1 : testData.skip = false;
128 : 1 : suites.get(suiteDesc).push(testData);
129 : 1 :
130 : 1 : // TEST #02 - Static method Weather.setItemByDatetimeVal()...test#1
131 : 1 : testData = {};
132 : 1 :
133 [ + ]: 1 : testData.method = async () => {
134 : 1 : let sample = JSON.parse(sampleActive);
135 : 1 :
136 : 1 : let datetime1 = sample.days[0].datetime;
137 : 1 : Weather.setItemByDatetimeVal(sample.days, datetime1, { datetimeISO: new Date(datetime1).toISOString() });
138 : 1 :
139 : 1 : assert.strictEqual(sample.days[0].datetimeISO, new Date(datetime1).toISOString());
140 : 1 :
141 : 1 : let datetime2 = 0;
142 : 1 : Weather.setItemByDatetimeVal(sample.days, datetime2, { datetimeGMT: new Date(datetime1).toGMTString() });
143 : 1 :
144 : 1 : assert.strictEqual(sample.days[0].datetimeGMT, new Date(datetime1).toGMTString());
145 : 1 :
146 : 1 : assert.throws(
147 [ + ]: 1 : () => {
148 : 1 : Weather.setItemByDatetimeVal(sample.days, datetime1, false);
149 : 1 : },
150 [ + ]: 1 : (err) => {
151 : 1 : assert(err instanceof TypeError);
152 : 1 : assert.strictEqual(err.message, `Weather.setItemByDatetimeVal: Invalid input data value 'false'.`);
153 : 1 : return true;
154 : 1 : }
155 : 1 : );
156 : 1 :
157 : 1 : assert.throws(
158 [ + ]: 1 : () => {
159 : 1 : Weather.setItemByDatetimeVal(sample.days, false, {});
160 : 1 : },
161 [ + ]: 1 : (err) => {
162 : 1 : assert(err instanceof TypeError);
163 : 1 : assert.strictEqual(err.message, `Weather.setItemByDatetimeVal: Invalid input datetime value 'false'.`);
164 : 1 : return true;
165 : 1 : }
166 : 1 : );
167 : 1 : };
168 : 1 : testData.desc = 'Static method Weather.setItemByDatetimeVal()...test#1';
169 : 1 :
170 : 1 : testData.skip = false;
171 : 1 : suites.get(suiteDesc).push(testData);
172 : 1 :
173 : 1 : // TEST #03 - Static method Weather.updateItemByDatetimeVal()...test#1
174 : 1 : testData = {};
175 : 1 :
176 [ + ]: 1 : testData.method = async () => {
177 : 1 : let sample = JSON.parse(sampleActive);
178 : 1 :
179 : 1 : let datetime1 = sample.days[0].datetime;
180 : 1 : Weather.updateItemByDatetimeVal(sample.days, datetime1, { datetimeISO: new Date(datetime1).toISOString() });
181 : 1 :
182 : 1 : let datetime2 = 0;
183 : 1 : Weather.updateItemByDatetimeVal(sample.days, datetime2, { datetimeGMT: new Date(datetime1).toGMTString() });
184 : 1 :
185 : 1 : assert.strictEqual(sample.days[0].datetimeGMT, new Date(datetime1).toGMTString());
186 : 1 :
187 : 1 : assert.throws(
188 [ + ]: 1 : () => {
189 : 1 : Weather.updateItemByDatetimeVal(sample.days, datetime1, false);
190 : 1 : },
191 [ + ]: 1 : (err) => {
192 : 1 : assert(err instanceof TypeError);
193 : 1 : assert.strictEqual(err.message, `Weather.updateItemByDatetimeVal: Invalid input data value 'false'.`);
194 : 1 : return true;
195 : 1 : }
196 : 1 : );
197 : 1 :
198 : 1 : assert.throws(
199 [ + ]: 1 : () => {
200 : 1 : Weather.updateItemByDatetimeVal(sample.days, false, {});
201 : 1 : },
202 [ + ]: 1 : (err) => {
203 : 1 : assert(err instanceof TypeError);
204 : 1 : assert.strictEqual(err.message, `Weather.updateItemByDatetimeVal: Invalid input datetime value 'false'.`);
205 : 1 : return true;
206 : 1 : }
207 : 1 : );
208 : 1 : };
209 : 1 : testData.desc = 'Static method Weather.updateItemByDatetimeVal()...test#1';
210 : 1 :
211 : 1 : testData.skip = false;
212 : 1 : suites.get(suiteDesc).push(testData);
213 : 1 :
214 : 1 : // TEST #04 - Static method Weather.validateParamDate()...test#1
215 : 1 : testData = {};
216 : 1 :
217 [ + ]: 1 : testData.method = async () => {
218 : 1 :
219 : 1 : // validate dynamic dates
220 : 1 : [
221 : 1 : 'today',
222 : 1 : 'tomorrow',
223 : 1 : 'yesterday',
224 : 1 : 'yeartodate',
225 : 1 : 'monthtodate',
226 : 1 : 'lastyear',
227 : 1 : 'last24hours',
228 : 1 : 'nextweekend',
229 : 1 : 'lastweekend',
230 : 1 : 'next10days',
231 : 1 : 'last10days',
232 : 1 : 'nextsunday',
233 : 1 : 'lastsaturday',
234 : 1 :
235 [ + ]: 1 : ].forEach(param => { assert.strictEqual(Weather.validateParamDate(param), param) });
236 : 1 :
237 : 1 : // validate date and datetime formats
238 : 1 : [
239 : 1 : '2024-03-07',
240 : 1 : '2024-03-07T04:30:00',
241 : 1 :
242 [ + ]: 1 : ].forEach(param => { assert.strictEqual(Weather.validateParamDate(param), param) });
243 : 1 :
244 : 1 : // validate datetimeEpoch
245 : 1 : assert.strictEqual(Weather.validateParamDate(Date.parse('2025-03-07')), Date.parse('2025-03-07'));
246 : 1 :
247 : 1 : // invalid date parameter
248 : 1 : assert.throws(
249 [ + ]: 1 : () => {
250 : 1 : Weather.validateParamDate(false);
251 : 1 : },
252 [ + ]: 1 : (err) => {
253 : 1 : assert(err instanceof TypeError);
254 : 1 : assert.strictEqual(err.message, `Weather.validateParamDate: Invalid date type 'boolean'.`);
255 : 1 : return true;
256 : 1 : }
257 : 1 : );
258 : 1 :
259 : 1 : assert.throws(
260 [ + ]: 1 : () => {
261 : 1 : Weather.validateParamDate('TODAY');
262 : 1 : },
263 [ + ]: 1 : (err) => {
264 : 1 : assert(err instanceof Error);
265 : 1 : assert.strictEqual(err.message, `Weather.validateParamDate: Invalid date 'TODAY'.`);
266 : 1 : return true;
267 : 1 : }
268 : 1 : );
269 : 1 :
270 : 1 : assert.throws(
271 [ + ]: 1 : () => {
272 : 1 : Weather.validateParamDate('25-03-07');
273 : 1 : },
274 [ + ]: 1 : (err) => {
275 : 1 : assert(err instanceof Error);
276 : 1 : assert.strictEqual(err.message, `Weather.validateParamDate: Invalid date '25-03-07'.`);
277 : 1 : return true;
278 : 1 : }
279 : 1 : );
280 : 1 :
281 : 1 : assert.throws(
282 [ + ]: 1 : () => {
283 : 1 : Weather.validateParamDate('2025-03-07T04:00');
284 : 1 : },
285 [ + ]: 1 : (err) => {
286 : 1 : assert(err instanceof Error);
287 : 1 : assert.strictEqual(err.message, `Weather.validateParamDate: Invalid date '2025-03-07T04:00'.`);
288 : 1 : return true;
289 : 1 : }
290 : 1 : );
291 : 1 : };
292 : 1 : testData.desc = 'Static method Weather.validateParamDate()...test#1';
293 : 1 :
294 : 1 : testData.skip = false;
295 : 1 : suites.get(suiteDesc).push(testData);
296 : 1 :
297 : 1 : // TEST #05 - Static method Weather.validateParamUnitGroup()...test#1
298 : 1 : testData = {};
299 : 1 :
300 [ + ]: 1 : testData.method = async () => {
301 : 1 :
302 : 1 : // validate dynamic dates
303 : 1 : ['us', 'uk', 'metric', 'base'].
304 [ + ]: 1 : forEach(param => { assert.strictEqual(Weather.validateParamUnitGroup(param), param) });
305 : 1 :
306 : 1 : // invalid unitGroup parameter
307 : 1 : assert.throws(
308 [ + ]: 1 : () => {
309 : 1 : Weather.validateParamUnitGroup(false);
310 : 1 : },
311 [ + ]: 1 : (err) => {
312 : 1 : assert(err instanceof TypeError);
313 : 1 : assert.strictEqual(err.message, `Weather.validateParamUnitGroup: Invalid unitGroup type 'boolean'.`);
314 : 1 : return true;
315 : 1 : }
316 : 1 : );
317 : 1 :
318 : 1 : assert.throws(
319 [ + ]: 1 : () => {
320 : 1 : Weather.validateParamUnitGroup('TODAY');
321 : 1 : },
322 [ + ]: 1 : (err) => {
323 : 1 : assert(err instanceof Error);
324 : 1 : assert.strictEqual(err.message, `Weather.validateParamUnitGroup: Invalid unitGroup value 'TODAY'.`);
325 : 1 : return true;
326 : 1 : }
327 : 1 : );
328 : 1 : };
329 : 1 : testData.desc = 'Static method Weather.validateParamUnitGroup()...test#1';
330 : 1 :
331 : 1 : testData.skip = false;
332 : 1 : suites.get(suiteDesc).push(testData);
333 : 1 :
334 : 1 : // TEST #06 - Static method Weather.validateParamInclude()...test#1
335 : 1 : testData = {};
336 : 1 :
337 [ + ]: 1 : testData.method = async () => {
338 : 1 :
339 : 1 : // validate include params
340 : 1 : let params = ['days', 'alerts', 'events'];
341 : 1 : assert.strictEqual(Weather.validateParamInclude(...params), params.join(','));
342 : 1 :
343 : 1 : // invalid include parameters
344 : 1 : assert.throws(
345 [ + ]: 1 : () => {
346 : 1 : Weather.validateParamInclude('days', false);
347 : 1 : },
348 [ + ]: 1 : (err) => {
349 : 1 : assert(err instanceof TypeError);
350 : 1 : assert.strictEqual(err.message, `Weather.validateParamInclude: Invalid include parameter type 'boolean'.`);
351 : 1 : return true;
352 : 1 : }
353 : 1 : );
354 : 1 :
355 : 1 : assert.throws(
356 [ + ]: 1 : () => {
357 : 1 : Weather.validateParamInclude('days', 'HOURS');
358 : 1 : },
359 [ + ]: 1 : (err) => {
360 : 1 : assert(err instanceof Error);
361 : 1 : assert.strictEqual(err.message, `Weather.validateParamInclude: Invalid include parameter 'HOURS'.`);
362 : 1 : return true;
363 : 1 : }
364 : 1 : );
365 : 1 : };
366 : 1 : testData.desc = 'Static method Weather.validateParamInclude()...test#1';
367 : 1 :
368 : 1 : testData.skip = false;
369 : 1 : suites.get(suiteDesc).push(testData);
370 : 1 :
371 : 1 : // TEST #07 - Static method Weather.validateParamElements()...test#1
372 : 1 : testData = {};
373 : 1 :
374 [ + ]: 1 : testData.method = async () => {
375 : 1 :
376 : 1 : // validate elents params
377 : 1 : let params = ['temp', 'tempmin', 'tempmax'];
378 : 1 : assert.strictEqual(Weather.validateParamElements(...params), params.join(','));
379 : 1 :
380 : 1 : // invalid elements parameters
381 : 1 : assert.throws(
382 [ + ]: 1 : () => {
383 : 1 : Weather.validateParamElements('temp', false);
384 : 1 : },
385 [ + ]: 1 : (err) => {
386 : 1 : assert(err instanceof TypeError);
387 : 1 : assert.strictEqual(err.message, `Weather.validateParamElements: Invalid elements parameter type 'boolean'.`);
388 : 1 : return true;
389 : 1 : }
390 : 1 : );
391 : 1 :
392 : 1 : assert.throws(
393 [ + ]: 1 : () => {
394 : 1 : Weather.validateParamElements('temp', 'TEMP');
395 : 1 : },
396 [ + ]: 1 : (err) => {
397 : 1 : assert(err instanceof Error);
398 : 1 : assert.strictEqual(err.message, `Weather.validateParamElements: Invalid elements parameter 'TEMP'.`);
399 : 1 : return true;
400 : 1 : }
401 : 1 : );
402 : 1 : };
403 : 1 : testData.desc = 'Static method Weather.validateParamElements()...test#1';
404 : 1 :
405 : 1 : testData.skip = false;
406 : 1 : suites.get(suiteDesc).push(testData);
407 : 1 :
408 : 1 : // TEST SUITE #2 - Test Weather Instance Method fetchWeatherData
409 : 1 : suiteDesc = 'Test Weather Instance Method fetchWeatherData';
410 : 1 : suites.set(suiteDesc, []);
411 : 1 :
412 : 1 : // TEST #01 - Method fetchWeatherData()...test#1
413 : 1 : testData = {};
414 : 1 :
415 [ + ]: 1 : testData.method = async () => {
416 : 1 : let weather = new Weather();
417 : 1 :
418 : 1 : try{
419 [ - ]: 1 : await weather.fetchWeatherData('Alexandria', '2025-03-07');
420 : 0 : assert(false);
421 : 0 : }
422 : 1 : catch(error){
423 : 1 : assert.strictEqual(error.message, 'Weather.fetchWeatherData: No API key or session found.');
424 : 1 : }
425 : 1 : };
426 : 1 : testData.desc = 'Method fetchWeatherData()...test#1';
427 : 1 :
428 : 1 : testData.skip = false;
429 : 1 : suites.get(suiteDesc).push(testData);
430 : 1 :
431 : 1 : // TEST #02 - Method fetchWeatherData()...test#2
432 : 1 : testData = {};
433 : 1 :
434 [ + ]: 1 : testData.method = async () => {
435 : 1 : let weather = new Weather(key);
436 : 1 :
437 : 1 : try{
438 [ - ]: 1 : await weather.fetchWeatherData('', '2025-03-07');
439 : 0 : assert(false);
440 : 0 : }
441 : 1 : catch(error){
442 : 1 : assert.strictEqual(error.message, 'Weather.fetchWeatherData: Bad API Request:A location must be specified.');
443 : 1 : }
444 : 1 : };
445 : 1 : testData.desc = 'Method fetchWeatherData()...test#2';
446 : 1 :
447 : 1 : testData.skip = false;
448 : 1 : suites.get(suiteDesc).push(testData);
449 : 1 :
450 : 1 : // TEST #03 - Method fetchWeatherData()...test#3
451 : 1 : testData = {};
452 : 1 :
453 [ + ]: 1 : testData.method = async () => {
454 : 1 : let weather = new Weather(key);
455 : 1 :
456 : 1 : try{
457 [ - ]: 1 : await weather.fetchWeatherData('xxx', '2025-03-07');
458 : 0 : assert(false);
459 : 0 : }
460 : 1 : catch(error){
461 : 1 : }
462 : 1 : };
463 : 1 : testData.desc = 'Method fetchWeatherData()...test#3';
464 : 1 :
465 : 1 : testData.skip = !key; // skip test if no key
466 : 1 : suites.get(suiteDesc).push(testData);
467 : 1 :
468 : 1 : // TEST #04 - Method fetchWeatherData()...test#4
469 : 1 : testData = {};
470 : 1 :
471 [ + ]: 1 : testData.method = async () => {
472 : 1 : let weather = new Weather(key);
473 : 1 : let fetch = globalThis.fetch;
474 : 1 : globalThis.fetch = null;
475 : 1 :
476 : 1 : try{
477 [ - ]: 1 : await weather.fetchWeatherData('xxx', '2025-03-07');
478 : 0 : assert(false);
479 : 0 : }
480 : 1 : catch(error){
481 : 1 : }
482 : 1 :
483 : 1 : globalThis.fetch = fetch;
484 : 1 : };
485 : 1 : testData.desc = 'Method fetchWeatherData()...test#4';
486 : 1 :
487 : 1 : testData.skip = !key; // skip test if no key
488 : 1 : suites.get(suiteDesc).push(testData);
489 : 1 :
490 : 1 : // TEST #05 - Method fetchWeatherData()...test#5
491 : 1 : testData = {};
492 : 1 :
493 [ + ]: 1 : testData.method = async () => {
494 : 1 : let sample = JSON.parse(sampleActive);
495 : 1 :
496 : 1 : let weather = new Weather(key);
497 : 1 : let actual = await weather.fetchWeatherData(sample.address, sample.days[0].datetime, undefined, undefined, 'days');
498 : 1 :
499 : 1 : [
500 : 1 : "latitude",
501 : 1 : "longitude",
502 : 1 : "resolvedAddress",
503 : 1 : "address",
504 : 1 : "timezone",
505 : 1 : "tzoffset",
506 : 1 :
507 [ + ]: 1 : ].forEach(key => {
508 : 6 : assert.strictEqual(actual[key], sample[key])
509 : 1 : });
510 : 1 : };
511 : 1 : testData.desc = 'Method fetchWeatherData()...test#5';
512 : 1 :
513 : 1 : testData.skip = !key; // skip test if no key
514 : 1 : suites.get(suiteDesc).push(testData);
515 : 1 :
516 : 1 : // TEST #06 - Method fetchWeatherData()...test#6
517 : 1 : testData = {};
518 : 1 :
519 [ + ]: 1 : testData.method = async () => {
520 : 1 : let sample = JSON.parse(sampleActive);
521 : 1 : let fetch = globalThis.fetch;
522 : 1 : globalThis.fetch = null;
523 : 1 :
524 : 1 : let weather = new Weather(key);
525 : 1 : let actual = await weather.fetchWeatherData(sample.address, sample.days[0].datetime, undefined, undefined, 'days');
526 : 1 :
527 : 1 : [
528 : 1 : "latitude",
529 : 1 : "longitude",
530 : 1 : "resolvedAddress",
531 : 1 : "address",
532 : 1 : "timezone",
533 : 1 : "tzoffset",
534 : 1 :
535 [ + ]: 1 : ].forEach(key => {
536 : 6 : assert.strictEqual(actual[key], sample[key])
537 : 1 : });
538 : 1 :
539 : 1 : globalThis.fetch = fetch;
540 : 1 : };
541 : 1 : testData.desc = 'Method fetchWeatherData()...test#6';
542 : 1 :
543 : 1 : testData.skip = !key; // skip test if no key
544 : 1 : suites.get(suiteDesc).push(testData);
545 : 1 :
546 : 1 : // TEST #07 - Method fetchWeatherData()...test#7
547 : 1 : testData = {};
548 : 1 :
549 [ + ]: 1 : testData.method = async () => {
550 : 1 : let sample = JSON.parse(sampleActive);
551 : 1 : let fetch = globalThis.fetch;
552 : 1 : globalThis.fetch = null;
553 : 1 :
554 : 1 : let weather = new Weather(key);
555 : 1 : let actual = await weather.fetchWeatherData(sample.address, undefined, undefined, undefined, 'days');
556 : 1 :
557 : 1 : [
558 : 1 : "latitude",
559 : 1 : "longitude",
560 : 1 : "resolvedAddress",
561 : 1 : "address",
562 : 1 : "timezone",
563 : 1 : "tzoffset",
564 : 1 :
565 [ + ]: 1 : ].forEach(key => {
566 : 6 : assert.strictEqual(actual[key], sample[key])
567 : 1 : });
568 : 1 :
569 : 1 : globalThis.fetch = fetch;
570 : 1 : };
571 : 1 : testData.desc = 'Method fetchWeatherData()...test#7';
572 : 1 :
573 : 1 : testData.skip = !key; // skip test if no key
574 : 1 : suites.get(suiteDesc).push(testData);
575 : 1 :
576 : 1 : // TEST SUITE #3 - Test Weather Instance Methods - Data elements
577 : 1 : suiteDesc = 'Test Weather Instance Methods - Data elements';
578 : 1 : suites.set(suiteDesc, []);
579 : 1 :
580 : 1 : // TEST #01 - Method [get/set]WeatherData()...test#1
581 : 1 : testData = {};
582 : 1 :
583 [ + ]: 1 : testData.method = async () => {
584 : 1 : let sample = JSON.parse(sampleActive);
585 : 1 :
586 : 1 : let weather = new Weather();
587 : 1 : weather.setWeatherData(sample);
588 : 1 :
589 : 1 : assert.deepStrictEqual(weather.getWeatherData(), sample);
590 : 1 :
591 : 1 : let elements = ['address', 'days', 'latitude', 'longitude'];
592 : 1 : let res = weather.getWeatherData(elements);
593 : 1 :
594 [ + ]: 1 : elements.forEach(e => { res[e] === sample[e] });
595 : 1 :
596 : 1 : assert(weather.getWeatherData('invalid arg') === null);
597 : 1 : };
598 : 1 : testData.desc = 'Method [get/set]WeatherData()...test#1';
599 : 1 :
600 : 1 : testData.skip = false;
601 : 1 : suites.get(suiteDesc).push(testData);
602 : 1 :
603 : 1 : // TEST #02 - Method [get/clear]WeatherData()...test#1
604 : 1 : testData = {};
605 : 1 :
606 [ + ]: 1 : testData.method = async () => {
607 : 1 :
608 : 1 : let weather = new Weather();
609 : 1 : weather.clearWeatherData();
610 : 1 :
611 : 1 : assert.deepStrictEqual(weather.getWeatherData(), {});
612 : 1 : };
613 : 1 : testData.desc = 'Method [get/clear]WeatherData()...test#1';
614 : 1 :
615 : 1 : testData.skip = false;
616 : 1 : suites.get(suiteDesc).push(testData);
617 : 1 :
618 : 1 : // TEST #03 - Method [get/set]WeatherDailyData()...test#1
619 : 1 : testData = {};
620 : 1 :
621 [ + ]: 1 : testData.method = async () => {
622 : 1 : let sample = JSON.parse(sampleActive);
623 : 1 :
624 : 1 : let weather = new Weather();
625 : 1 : weather.setWeatherData(sample);
626 : 1 :
627 : 1 : assert.deepStrictEqual(weather.getWeatherDailyData(), sample.days);
628 : 1 :
629 : 1 : let elements = ['tempmax', 'tempmin', 'temp'];
630 : 1 : let res = weather.getWeatherDailyData(elements);
631 : 1 :
632 : 1 : for(let i = 0; i < res.length; i++)
633 : 1 : for(let p in res[i])
634 [ + ]: 1 : assert.strictEqual(res[i][p], sample.days[i][p]);
635 : 1 :
636 : 1 : assert(weather.getWeatherDailyData('invalid arg') === null);
637 : 1 :
638 : 1 : let arr = [];
639 : 1 : weather.setWeatherDailyData(arr);
640 : 1 : assert(weather.getWeatherDailyData() === arr);
641 : 1 : };
642 : 1 : testData.desc = 'Method [get/set]WeatherDailyData()...test#1';
643 : 1 :
644 : 1 : testData.skip = false;
645 : 1 : suites.get(suiteDesc).push(testData);
646 : 1 :
647 : 1 : // TEST #04 - Method getWeatherHourlyData()...test#1
648 : 1 : testData = {};
649 : 1 :
650 [ + ]: 1 : testData.method = async () => {
651 : 1 : let sample = JSON.parse(sampleActive);
652 : 1 :
653 : 1 : let weather = new Weather();
654 : 1 : weather.setWeatherData(sample);
655 : 1 :
656 : 1 : let res = weather.getWeatherHourlyData();
657 : 1 :
658 : 1 : for(let i = 0, j = 0; i < sample.days.length; i++)
659 : 1 : for(let k = 0; k < sample.days[i].hours.length; k++, j++)
660 [ + ]: 1 : assert.deepStrictEqual(res[j], sample.days[i].hours[k]);
661 : 1 :
662 : 1 : res = weather.getWeatherHourlyData(['datetime']);
663 : 1 :
664 : 1 : for(let i = 0, j = 0; i < sample.days.length; i++)
665 : 1 : for(let k = 0; k < sample.days[i].hours.length; k++, j++)
666 [ + ]: 1 : assert.strictEqual(res[j].datetime, sample.days[i].hours[k].datetime);
667 : 1 :
668 : 1 : assert(weather.getWeatherHourlyData('invalid arg') === null);
669 : 1 : };
670 : 1 : testData.desc = 'Method getWeatherHourlyData()...test#1';
671 : 1 :
672 : 1 : testData.skip = false;
673 : 1 : suites.get(suiteDesc).push(testData);
674 : 1 :
675 : 1 : // TEST #05 - Method getDataOnDay()...test#1
676 : 1 : testData = {};
677 : 1 :
678 [ + ]: 1 : testData.method = async () => {
679 : 1 : let sample = JSON.parse(sampleActive);
680 : 1 :
681 : 1 : let weather = new Weather();
682 : 1 : weather.setWeatherData(sample);
683 : 1 :
684 : 1 : let datetime = sample.days[0].datetime;
685 : 1 :
686 [ + ]: 1 : assert.deepStrictEqual(weather.getDataOnDay(datetime), sample.days.find((data) => data.datetime === datetime));
687 : 1 : assert.deepStrictEqual(weather.getDataOnDay(0), sample.days[0]);
688 : 1 : assert(weather.getDataOnDay('1970-01-01') === undefined);
689 : 1 :
690 : 1 : let elements = ['tempmax', 'tempmin', 'temp'];
691 : 1 : let res = weather.getDataOnDay(0, elements);
692 : 1 :
693 : 1 : for(let p in res)
694 [ + ]: 1 : assert.strictEqual(res[p], sample.days[0][p]);
695 : 1 :
696 : 1 : assert(weather.getDataOnDay(false) === null);
697 : 1 : };
698 : 1 : testData.desc = 'Method getDataOnDay()...test#1';
699 : 1 :
700 : 1 : testData.skip = false;
701 : 1 : suites.get(suiteDesc).push(testData);
702 : 1 :
703 : 1 : // TEST #06 - Method [get/set]DataOnDay()...test#1
704 : 1 : testData = {};
705 : 1 :
706 [ + ]: 1 : testData.method = async () => {
707 : 1 : let sample = JSON.parse(sampleActive);
708 : 1 :
709 : 1 : let weather = new Weather();
710 : 1 : weather.setWeatherData(sample);
711 : 1 :
712 : 1 : let datetime = sample.days[0].datetime;
713 : 1 : let data = {datetime: datetime};
714 : 1 :
715 : 1 : weather.setDataOnDay(datetime, data);
716 : 1 : assert(weather.getDataOnDay(datetime) === data);
717 : 1 :
718 : 1 : weather.setDataOnDay(0, data);
719 : 1 : assert(weather.getDataOnDay(0) === data);
720 : 1 :
721 : 1 : assert.throws(
722 [ + ]: 1 : () => {
723 : 1 : weather.setDataOnDay(false, data);
724 : 1 : },
725 [ + ]: 1 : (err) => {
726 : 1 : assert(err instanceof TypeError);
727 : 1 : assert.strictEqual(err.message, `Weather.setDataOnDay: Invalid input day value 'false'.`);
728 : 1 : return true;
729 : 1 : }
730 : 1 : );
731 : 1 : };
732 : 1 : testData.desc = 'Method [get/set]DataOnDay()...test#1';
733 : 1 :
734 : 1 : testData.skip = false;
735 : 1 : suites.get(suiteDesc).push(testData);
736 : 1 :
737 : 1 : // TEST #07 - Method getHourlyDataOnDay()...test#1
738 : 1 : testData = {};
739 : 1 :
740 [ + ]: 1 : testData.method = async () => {
741 : 1 : let sample = JSON.parse(sampleActive);
742 : 1 :
743 : 1 : let weather = new Weather();
744 : 1 : weather.setWeatherData(sample);
745 : 1 :
746 : 1 : let datetime = sample.days[0].datetime;
747 : 1 :
748 [ + ]: 1 : assert.deepStrictEqual(weather.getHourlyDataOnDay(datetime), sample.days.find((data) => data.datetime === datetime)?.hours);
749 : 1 : assert.deepStrictEqual(weather.getHourlyDataOnDay('1970-01-01'), []);
750 : 1 :
751 : 1 : assert.deepStrictEqual(weather.getHourlyDataOnDay(0), sample.days[0]?.hours);
752 : 1 : assert.deepStrictEqual(weather.getHourlyDataOnDay(50), []);
753 : 1 :
754 : 1 : let res = weather.getHourlyDataOnDay(datetime, ['datetime']);
755 : 1 : for(let i = 0; i < res.length; i++)
756 [ + ][ + ]: 1 : assert.strictEqual(res[i].datetime, sample.days.find((data) => data.datetime === datetime)?.hours[i].datetime);
757 : 24 :
758 : 24 : assert.throws(
759 [ + ]: 24 : () => {
760 : 1 : weather.getHourlyDataOnDay(false);
761 : 24 : },
762 [ + ]: 24 : (err) => {
763 : 1 : assert(err instanceof TypeError);
764 : 1 : assert.strictEqual(err.message, `Weather.getHourlyDataOnDay: Invalid input day value 'false'.`);
765 : 1 : return true;
766 : 1 : }
767 : 24 : );
768 : 1 : };
769 : 1 : testData.desc = 'Method getHourlyDataOnDay()...test#1';
770 : 1 :
771 : 1 : testData.skip = false;
772 : 1 : suites.get(suiteDesc).push(testData);
773 : 1 :
774 : 1 : // TEST #08 - Method [get/set]HourlyDataOnDay()...test#1
775 : 1 : testData = {};
776 : 1 :
777 [ + ]: 1 : testData.method = async () => {
778 : 1 : let sample = JSON.parse(sampleActive);
779 : 1 :
780 : 1 : let weather = new Weather();
781 : 1 : weather.setWeatherData(sample);
782 : 1 :
783 : 1 : let datetime, testObj;
784 : 1 :
785 : 1 : datetime = sample.days[0].datetime;
786 : 1 : testObj = {datetime: 'NA#1'};
787 : 1 : weather.setHourlyDataOnDay(datetime, testObj);
788 : 1 :
789 : 1 : assert.deepStrictEqual(weather.getHourlyDataOnDay(datetime), testObj);
790 : 1 :
791 : 1 : datetime = 0;
792 : 1 : testObj = {datetime: 'NA#2'};
793 : 1 : weather.setHourlyDataOnDay(datetime, testObj);
794 : 1 :
795 : 1 : assert.deepStrictEqual(weather.getHourlyDataOnDay(datetime), testObj);
796 : 1 :
797 : 1 : assert.throws(
798 [ + ]: 1 : () => {
799 : 1 : weather.setHourlyDataOnDay(false, {});
800 : 1 : },
801 [ + ]: 1 : (err) => {
802 : 1 : assert(err instanceof TypeError);
803 : 1 : assert.strictEqual(err.message, `Weather.setHourlyDataOnDay: Invalid input day value 'false'.`);
804 : 1 : return true;
805 : 1 : }
806 : 1 : );
807 : 1 : };
808 : 1 : testData.desc = 'Method [get/set]HourlyDataOnDay()...test#1';
809 : 1 :
810 : 1 : testData.skip = false;
811 : 1 : suites.get(suiteDesc).push(testData);
812 : 1 :
813 : 1 : // TEST #09 - Method [get/set/update]DataAtDatetime()...test#1
814 : 1 : testData = {};
815 : 1 :
816 [ + ]: 1 : testData.method = async () => {
817 : 1 : let sample = JSON.parse(sampleActive);
818 : 1 :
819 : 1 : let weather = new Weather();
820 : 1 : weather.setWeatherData(sample);
821 : 1 :
822 : 1 : let datetime = sample.days[0].datetime;
823 : 1 : let testObj = {data: 'test'};
824 : 1 : weather.setDataAtDatetime(datetime, '00:00:00', testObj);
825 : 1 : assert.strictEqual(weather.getDataAtDatetime(datetime, '00:00:00').data, testObj.data);
826 : 1 :
827 : 1 : testObj = {temp: 333};
828 : 1 : weather.updateDataAtDatetime(datetime, '00:00:00', testObj);
829 : 1 : assert.strictEqual(weather.getDataAtDatetime(datetime, '00:00:00').temp, testObj.temp);
830 : 1 :
831 : 1 : assert.deepStrictEqual(weather.getDataAtDatetime(datetime, '00:00:00', ['temp']), testObj);
832 : 1 :
833 : 1 : assert.throws(
834 [ + ]: 1 : () => {
835 : 1 : weather.getDataAtDatetime(false, false);
836 : 1 : },
837 [ + ]: 1 : (err) => {
838 : 1 : assert(err instanceof TypeError);
839 : 1 : return true;
840 : 1 : }
841 : 1 : );
842 : 1 :
843 : 1 : assert.throws(
844 [ + ]: 1 : () => {
845 : 1 : weather.setDataAtDatetime(false, false, {});
846 : 1 : },
847 [ + ]: 1 : (err) => {
848 : 1 : assert(err instanceof TypeError);
849 : 1 : return true;
850 : 1 : }
851 : 1 : );
852 : 1 :
853 : 1 : assert.throws(
854 [ + ]: 1 : () => {
855 : 1 : weather.updateDataAtDatetime(false, false, {});
856 : 1 : },
857 [ + ]: 1 : (err) => {
858 : 1 : assert(err instanceof TypeError);
859 : 1 : return true;
860 : 1 : }
861 : 1 : );
862 : 1 : };
863 : 1 : testData.desc = 'Method [get/set/update]DataAtDatetime()...test#1';
864 : 1 :
865 : 1 : testData.skip = false;
866 : 1 : suites.get(suiteDesc).push(testData);
867 : 1 :
868 : 1 : // TEST #10 - Method [get/set]DatetimeEpochAtDatetime()...test#1
869 : 1 : testData = {};
870 : 1 :
871 [ + ]: 1 : testData.method = async () => {
872 : 1 : let sample = JSON.parse(sampleActive);
873 : 1 :
874 : 1 : let weather = new Weather();
875 : 1 : weather.setWeatherData(sample);
876 : 1 :
877 : 1 : let datetime = sample.days[0].datetime;
878 : 1 : let datetimeEpoch = 77;
879 : 1 : weather.setDatetimeEpochAtDatetime(datetime, '00:00:00', datetimeEpoch);
880 : 1 :
881 : 1 : assert.strictEqual(weather.getDatetimeEpochAtDatetime(datetime, '00:00:00'), datetimeEpoch);
882 : 1 :
883 : 1 : assert.throws(
884 [ + ]: 1 : () => {
885 : 1 : weather.getDatetimeEpochAtDatetime(datetime, false);
886 : 1 : },
887 [ + ]: 1 : (err) => {
888 : 1 : assert(err instanceof TypeError);
889 : 1 : return true;
890 : 1 : }
891 : 1 : );
892 : 1 :
893 : 1 : assert.throws(
894 [ + ]: 1 : () => {
895 : 1 : weather.getDatetimeEpochAtDatetime(false, '00:00:00');
896 : 1 : },
897 [ + ]: 1 : (err) => {
898 : 1 : assert(err instanceof TypeError);
899 : 1 : return true;
900 : 1 : }
901 : 1 : );
902 : 1 :
903 : 1 : assert.throws(
904 [ + ]: 1 : () => {
905 : 1 : weather.setDatetimeEpochAtDatetime(datetime, false, datetimeEpoch);
906 : 1 : },
907 [ + ]: 1 : (err) => {
908 : 1 : assert(err instanceof TypeError);
909 : 1 : return true;
910 : 1 : }
911 : 1 : );
912 : 1 :
913 : 1 : assert.throws(
914 [ + ]: 1 : () => {
915 : 1 : weather.setDatetimeEpochAtDatetime(false, '00:00:00', datetimeEpoch);
916 : 1 : },
917 [ + ]: 1 : (err) => {
918 : 1 : assert(err instanceof TypeError);
919 : 1 : return true;
920 : 1 : }
921 : 1 : );
922 : 1 : };
923 : 1 : testData.desc = 'Method [get/set]DatetimeEpochAtDatetime()...test#1';
924 : 1 :
925 : 1 : testData.skip = false;
926 : 1 : suites.get(suiteDesc).push(testData);
927 : 1 :
928 : 1 : // TEST #11 - Method getDailyDatetimes()...test#1
929 : 1 : testData = {};
930 : 1 :
931 [ + ]: 1 : testData.method = async () => {
932 : 1 : let sample = JSON.parse(sampleActive);
933 : 1 :
934 : 1 : let weather = new Weather();
935 : 1 : weather.setWeatherData(sample);
936 : 1 :
937 [ + ]: 1 : assert.deepStrictEqual(weather.getDailyDatetimes(), sample.days.map(day => new Date(day.datetime)));
938 : 1 : };
939 : 1 : testData.desc = 'Method getDailyDatetimes()...test#1';
940 : 1 :
941 : 1 : testData.skip = false;
942 : 1 : suites.get(suiteDesc).push(testData);
943 : 1 :
944 : 1 : // TEST #12 - Method getHourlyDatetimes()...test#1
945 : 1 : testData = {};
946 : 1 :
947 [ + ]: 1 : testData.method = async () => {
948 : 1 : let sample = JSON.parse(sampleActive);
949 : 1 :
950 : 1 : let weather = new Weather();
951 : 1 : weather.setWeatherData(sample);
952 : 1 :
953 [ + ][ + ]: 1 : let exp = sample.days.flatMap(day => day.hours.map(hour => new Date(`${day.datetime}T${hour.datetime}`)));
954 : 1 : assert.deepStrictEqual(weather.getHourlyDatetimes(), exp);
955 : 1 : };
956 : 1 : testData.desc = 'Method getHourlyDatetimes()...test#1';
957 : 1 :
958 : 1 : testData.skip = false;
959 : 1 : suites.get(suiteDesc).push(testData);
960 : 1 :
961 : 1 : // TEST SUITE #4 - Test Weather Instance Methods - Location elements
962 : 1 : suiteDesc = 'Test Weather Instance Methods - Location elements';
963 : 1 : suites.set(suiteDesc, []);
964 : 1 :
965 : 1 : // TEST #01 - Method [get/set]Latitude()...test#1
966 : 1 : testData = {};
967 : 1 :
968 [ + ]: 1 : testData.method = async () => {
969 : 1 : let sample = JSON.parse(sampleActive);
970 : 1 :
971 : 1 : let weather = new Weather();
972 : 1 : weather.setWeatherData(sample);
973 : 1 :
974 : 1 : let testData = 0;
975 : 1 : weather.setLatitude(testData);
976 : 1 : assert.strictEqual(weather.getLatitude(), testData);
977 : 1 :
978 : 1 : assert.throws(
979 [ + ]: 1 : () => {
980 : 1 : weather.setLatitude(-100);
981 : 1 : },
982 [ + ]: 1 : (err) => {
983 : 1 : assert(err instanceof RangeError);
984 : 1 : return true;
985 : 1 : }
986 : 1 : );
987 : 1 : };
988 : 1 : testData.desc = 'Method [get/set]Latitude()...test#1';
989 : 1 :
990 : 1 : testData.skip = false;
991 : 1 : suites.get(suiteDesc).push(testData);
992 : 1 :
993 : 1 : // TEST #02 - Method [get/set]Longitude()...test#1
994 : 1 : testData = {};
995 : 1 :
996 [ + ]: 1 : testData.method = async () => {
997 : 1 : let sample = JSON.parse(sampleActive);
998 : 1 :
999 : 1 : let weather = new Weather();
1000 : 1 : weather.setWeatherData(sample);
1001 : 1 :
1002 : 1 : let testData = 0;
1003 : 1 : weather.setLongitude(testData);
1004 : 1 : assert.strictEqual(weather.getLongitude(), testData);
1005 : 1 :
1006 : 1 : assert.throws(
1007 [ + ]: 1 : () => {
1008 : 1 : weather.setLongitude(-200);
1009 : 1 : },
1010 [ + ]: 1 : (err) => {
1011 : 1 : assert(err instanceof RangeError);
1012 : 1 : return true;
1013 : 1 : }
1014 : 1 : );
1015 : 1 : };
1016 : 1 : testData.desc = 'Method [get/set]Longitude()...test#1';
1017 : 1 :
1018 : 1 : testData.skip = false;
1019 : 1 : suites.get(suiteDesc).push(testData);
1020 : 1 :
1021 : 1 : // TEST #03 - Method [get/set]ResolvedAddress()...test#1
1022 : 1 : testData = {};
1023 : 1 :
1024 [ + ]: 1 : testData.method = async () => {
1025 : 1 : let sample = JSON.parse(sampleActive);
1026 : 1 :
1027 : 1 : let weather = new Weather();
1028 : 1 : weather.setWeatherData(sample);
1029 : 1 :
1030 : 1 : let testData = 'Resolved Address';
1031 : 1 : weather.setResolvedAddress(testData);
1032 : 1 : assert.strictEqual(weather.getResolvedAddress(), testData);
1033 : 1 : };
1034 : 1 : testData.desc = 'Method [get/set]ResolvedAddress()...test#1';
1035 : 1 :
1036 : 1 : testData.skip = false;
1037 : 1 : suites.get(suiteDesc).push(testData);
1038 : 1 :
1039 : 1 : // TEST #04 - Method [get/set]Address()...test#1
1040 : 1 : testData = {};
1041 : 1 :
1042 [ + ]: 1 : testData.method = async () => {
1043 : 1 : let sample = JSON.parse(sampleActive);
1044 : 1 :
1045 : 1 : let weather = new Weather();
1046 : 1 : weather.setWeatherData(sample);
1047 : 1 :
1048 : 1 : let testData = 'Address';
1049 : 1 : weather.setAddress(testData);
1050 : 1 : assert.strictEqual(weather.getAddress(), testData);
1051 : 1 : };
1052 : 1 : testData.desc = 'Method [get/set]Address()...test#1';
1053 : 1 :
1054 : 1 : testData.skip = false;
1055 : 1 : suites.get(suiteDesc).push(testData);
1056 : 1 :
1057 : 1 : // TEST #05 - Method [get/set]Timezone()...test#1
1058 : 1 : testData = {};
1059 : 1 :
1060 [ + ]: 1 : testData.method = async () => {
1061 : 1 : let sample = JSON.parse(sampleActive);
1062 : 1 :
1063 : 1 : let weather = new Weather();
1064 : 1 : weather.setWeatherData(sample);
1065 : 1 :
1066 : 1 : let testData = 'Timezone';
1067 : 1 : weather.setTimezone(testData);
1068 : 1 : assert.strictEqual(weather.getTimezone(), testData);
1069 : 1 : };
1070 : 1 : testData.desc = 'Method [get/set]Timezone()...test#1';
1071 : 1 :
1072 : 1 : testData.skip = false;
1073 : 1 : suites.get(suiteDesc).push(testData);
1074 : 1 :
1075 : 1 : // TEST #06 - Method [get/set]Tzoffset()...test#1
1076 : 1 : testData = {};
1077 : 1 :
1078 [ + ]: 1 : testData.method = async () => {
1079 : 1 : let sample = JSON.parse(sampleActive);
1080 : 1 :
1081 : 1 : let weather = new Weather();
1082 : 1 : weather.setWeatherData(sample);
1083 : 1 :
1084 : 1 : let testData = 0;
1085 : 1 : weather.setTzoffset(testData);
1086 : 1 : assert.strictEqual(weather.getTzoffset(), testData);
1087 : 1 : };
1088 : 1 : testData.desc = 'Method [get/set]Tzoffset()...test#1';
1089 : 1 :
1090 : 1 : testData.skip = false;
1091 : 1 : suites.get(suiteDesc).push(testData);
1092 : 1 :
1093 : 1 : // TEST SUITE #5 - Test Weather Instance Methods - Request elements
1094 : 1 : suiteDesc = 'Test Weather Instance Methods - Request elements';
1095 : 1 : suites.set(suiteDesc, []);
1096 : 1 :
1097 : 1 : // TEST #01 - Method [get/set]QueryCost()...test#1
1098 : 1 : testData = {};
1099 : 1 :
1100 [ + ]: 1 : testData.method = async () => {
1101 : 1 : let sample = JSON.parse(sampleActive);
1102 : 1 :
1103 : 1 : let weather = new Weather();
1104 : 1 : weather.setWeatherData(sample);
1105 : 1 :
1106 : 1 : let testQueryCost;
1107 : 1 :
1108 : 1 : testQueryCost = 1;
1109 : 1 : weather.setQueryCost(testQueryCost);
1110 : 1 : assert.strictEqual(weather.getQueryCost(), testQueryCost);
1111 : 1 :
1112 : 1 : testQueryCost = 0;
1113 : 1 : weather.setQueryCost(testQueryCost);
1114 : 1 : assert.strictEqual(weather.getQueryCost(), null);
1115 : 1 : };
1116 : 1 : testData.desc = 'Method [get/set]QueryCost()...test#1';
1117 : 1 :
1118 : 1 : testData.skip = false;
1119 : 1 : suites.get(suiteDesc).push(testData);
1120 : 1 :
1121 : 1 : // TEST #02 - Method [get/set]Stations()...test#1
1122 : 1 : testData = {};
1123 : 1 :
1124 [ + ]: 1 : testData.method = async () => {
1125 : 1 : let sample = JSON.parse(sampleActive);
1126 : 1 :
1127 : 1 : let weather = new Weather();
1128 : 1 : weather.setWeatherData(sample);
1129 : 1 :
1130 : 1 : let testStations;
1131 : 1 :
1132 : 1 : testStations = ['TestStation'];
1133 : 1 : weather.setStations(testStations);
1134 : 1 : assert.deepStrictEqual(weather.getStations(), testStations);
1135 : 1 :
1136 : 1 : testStations = null;
1137 : 1 : weather.setStations(testStations);
1138 : 1 : assert.deepStrictEqual(weather.getStations(), []);
1139 : 1 : };
1140 : 1 : testData.desc = 'Method [get/set]Stations()...test#1';
1141 : 1 :
1142 : 1 : testData.skip = false;
1143 : 1 : suites.get(suiteDesc).push(testData);
1144 : 1 :
1145 : 1 : // TEST SUITE #6 - Test Weather Instance Methods - Core Weather elements on day
1146 : 1 : suiteDesc = 'Test Weather Instance Methods - Core Weather elements on day';
1147 : 1 : suites.set(suiteDesc, []);
1148 : 1 :
1149 : 1 : // TEST #01 - Method [get/set]TempOnDay()...test#1
1150 : 1 : testData = {};
1151 : 1 :
1152 [ + ]: 1 : testData.method = async () => {
1153 : 1 : let sample = JSON.parse(sampleActive);
1154 : 1 :
1155 : 1 : let weather = new Weather();
1156 : 1 : weather.setWeatherData(sample);
1157 : 1 :
1158 : 1 : let testDay, testTemp;
1159 : 1 :
1160 : 1 : testDay = sample.days[0].datetime;
1161 : 1 : testTemp = 0;
1162 : 1 : weather.setTempOnDay(testDay, testTemp);
1163 : 1 : assert.strictEqual(weather.getTempOnDay(testDay), testTemp);
1164 : 1 :
1165 : 1 : testDay = 0;
1166 : 1 : testTemp = 10;
1167 : 1 : weather.setTempOnDay(testDay, testTemp);
1168 : 1 : assert.strictEqual(weather.getTempOnDay(testDay), testTemp);
1169 : 1 :
1170 : 1 : assert.strictEqual(weather.getTempOnDay(), null);
1171 : 1 : assert.strictEqual(weather.getTempOnDay('1970-01-01'), null);
1172 : 1 : assert.throws(
1173 [ + ]: 1 : () => {
1174 : 1 : weather.setTempOnDay(false, testTemp);
1175 : 1 : },
1176 [ + ]: 1 : (err) => {
1177 : 1 : assert(err instanceof TypeError);
1178 : 1 : assert.strictEqual(err.message, `Weather.setTempOnDay: Invalid input day value 'false'.`);
1179 : 1 : return true;
1180 : 1 : }
1181 : 1 : );
1182 : 1 : };
1183 : 1 : testData.desc = 'Method [get/set]TempOnDay()...test#1';
1184 : 1 :
1185 : 1 : testData.skip = false;
1186 : 1 : suites.get(suiteDesc).push(testData);
1187 : 1 :
1188 : 1 : // TEST #02 - Method [get/set]TempmaxOnDay()...test#1
1189 : 1 : testData = {};
1190 : 1 :
1191 [ + ]: 1 : testData.method = async () => {
1192 : 1 : let sample = JSON.parse(sampleActive);
1193 : 1 :
1194 : 1 : let weather = new Weather();
1195 : 1 : weather.setWeatherData(sample);
1196 : 1 :
1197 : 1 : let testDay, testTemp;
1198 : 1 :
1199 : 1 : testDay = sample.days[0].datetime;
1200 : 1 : testTemp = 0;
1201 : 1 : weather.setTempmaxOnDay(testDay, testTemp);
1202 : 1 : assert.strictEqual(weather.getTempmaxOnDay(testDay), testTemp);
1203 : 1 :
1204 : 1 : testDay = 0;
1205 : 1 : testTemp = 10;
1206 : 1 : weather.setTempmaxOnDay(testDay, testTemp);
1207 : 1 : assert.strictEqual(weather.getTempmaxOnDay(testDay), testTemp);
1208 : 1 :
1209 : 1 : assert.strictEqual(weather.getTempmaxOnDay(), null);
1210 : 1 : assert.strictEqual(weather.getTempmaxOnDay('1970-01-01'), null);
1211 : 1 : assert.throws(
1212 [ + ]: 1 : () => {
1213 : 1 : weather.setTempmaxOnDay(false, testTemp);
1214 : 1 : },
1215 [ + ]: 1 : (err) => {
1216 : 1 : assert(err instanceof TypeError);
1217 : 1 : assert.strictEqual(err.message, `Weather.setTempmaxOnDay: Invalid input day value 'false'.`);
1218 : 1 : return true;
1219 : 1 : }
1220 : 1 : );
1221 : 1 : };
1222 : 1 : testData.desc = 'Method [get/set]TempmaxOnDay()...test#1';
1223 : 1 :
1224 : 1 : testData.skip = false;
1225 : 1 : suites.get(suiteDesc).push(testData);
1226 : 1 :
1227 : 1 : // TEST #03 - Method [get/set]TempminOnDay()...test#1
1228 : 1 : testData = {};
1229 : 1 :
1230 [ + ]: 1 : testData.method = async () => {
1231 : 1 : let sample = JSON.parse(sampleActive);
1232 : 1 :
1233 : 1 : let weather = new Weather();
1234 : 1 : weather.setWeatherData(sample);
1235 : 1 :
1236 : 1 : let testDay, testTemp;
1237 : 1 :
1238 : 1 : testDay = sample.days[0].datetime;
1239 : 1 : testTemp = 0;
1240 : 1 : weather.setTempminOnDay(testDay, testTemp);
1241 : 1 : assert.strictEqual(weather.getTempminOnDay(testDay), testTemp);
1242 : 1 :
1243 : 1 : testDay = 0;
1244 : 1 : testTemp = 10;
1245 : 1 : weather.setTempminOnDay(testDay, testTemp);
1246 : 1 : assert.strictEqual(weather.getTempminOnDay(testDay), testTemp);
1247 : 1 :
1248 : 1 : assert.strictEqual(weather.getTempminOnDay(), null);
1249 : 1 : assert.strictEqual(weather.getTempminOnDay('1970-01-01'), null);
1250 : 1 : assert.throws(
1251 [ + ]: 1 : () => {
1252 : 1 : weather.setTempminOnDay(false, testTemp);
1253 : 1 : },
1254 [ + ]: 1 : (err) => {
1255 : 1 : assert(err instanceof TypeError);
1256 : 1 : assert.strictEqual(err.message, `Weather.setTempminOnDay: Invalid input day value 'false'.`);
1257 : 1 : return true;
1258 : 1 : }
1259 : 1 : );
1260 : 1 : };
1261 : 1 : testData.desc = 'Method [get/set]TempminOnDay()...test#1';
1262 : 1 :
1263 : 1 : testData.skip = false;
1264 : 1 : suites.get(suiteDesc).push(testData);
1265 : 1 :
1266 : 1 : // TEST #04 - Method [get/set]FeelslikeOnDay()...test#1
1267 : 1 : testData = {};
1268 : 1 :
1269 [ + ]: 1 : testData.method = async () => {
1270 : 1 : let sample = JSON.parse(sampleActive);
1271 : 1 :
1272 : 1 : let weather = new Weather();
1273 : 1 : weather.setWeatherData(sample);
1274 : 1 :
1275 : 1 : let testDay, testFeelslike;
1276 : 1 :
1277 : 1 : testDay = sample.days[0].datetime;
1278 : 1 : testFeelslike = 0;
1279 : 1 : weather.setFeelslikeOnDay(testDay, testFeelslike);
1280 : 1 : assert.strictEqual(weather.getFeelslikeOnDay(testDay), testFeelslike);
1281 : 1 :
1282 : 1 : testDay = 0;
1283 : 1 : testFeelslike = 10;
1284 : 1 : weather.setFeelslikeOnDay(testDay, testFeelslike);
1285 : 1 : assert.strictEqual(weather.getFeelslikeOnDay(testDay), testFeelslike);
1286 : 1 :
1287 : 1 : assert.strictEqual(weather.getFeelslikeOnDay(), null);
1288 : 1 : assert.strictEqual(weather.getFeelslikeOnDay('1970-01-01'), null);
1289 : 1 : assert.throws(
1290 [ + ]: 1 : () => {
1291 : 1 : weather.setFeelslikeOnDay(false, testFeelslike);
1292 : 1 : },
1293 [ + ]: 1 : (err) => {
1294 : 1 : assert(err instanceof TypeError);
1295 : 1 : assert.strictEqual(err.message, `Weather.setFeelslikeOnDay: Invalid input day value 'false'.`);
1296 : 1 : return true;
1297 : 1 : }
1298 : 1 : );
1299 : 1 : };
1300 : 1 : testData.desc = 'Method [get/set]FeelslikeOnDay()...test#1';
1301 : 1 :
1302 : 1 : testData.skip = false;
1303 : 1 : suites.get(suiteDesc).push(testData);
1304 : 1 :
1305 : 1 : // TEST #05 - Method [get/set]FeelslikemaxOnDay()...test#1
1306 : 1 : testData = {};
1307 : 1 :
1308 [ + ]: 1 : testData.method = async () => {
1309 : 1 : let sample = JSON.parse(sampleActive);
1310 : 1 :
1311 : 1 : let weather = new Weather();
1312 : 1 : weather.setWeatherData(sample);
1313 : 1 :
1314 : 1 : let testDay, testFeelslikemax;
1315 : 1 :
1316 : 1 : testDay = sample.days[0].datetime;
1317 : 1 : testFeelslikemax = 0;
1318 : 1 : weather.setFeelslikemaxOnDay(testDay, testFeelslikemax);
1319 : 1 : assert.strictEqual(weather.getFeelslikemaxOnDay(testDay), testFeelslikemax);
1320 : 1 :
1321 : 1 : testDay = 0;
1322 : 1 : testFeelslikemax = 10;
1323 : 1 : weather.setFeelslikemaxOnDay(testDay, testFeelslikemax);
1324 : 1 : assert.strictEqual(weather.getFeelslikemaxOnDay(testDay), testFeelslikemax);
1325 : 1 :
1326 : 1 : assert.strictEqual(weather.getFeelslikemaxOnDay(), null);
1327 : 1 : assert.strictEqual(weather.getFeelslikemaxOnDay('1970-01-01'), null);
1328 : 1 : assert.throws(
1329 [ + ]: 1 : () => {
1330 : 1 : weather.setFeelslikemaxOnDay(false, testFeelslikemax);
1331 : 1 : },
1332 [ + ]: 1 : (err) => {
1333 : 1 : assert(err instanceof TypeError);
1334 : 1 : assert.strictEqual(err.message, `Weather.setFeelslikemaxOnDay: Invalid input day value 'false'.`);
1335 : 1 : return true;
1336 : 1 : }
1337 : 1 : );
1338 : 1 : };
1339 : 1 : testData.desc = 'Method [get/set]FeelslikemaxOnDay()...test#1';
1340 : 1 :
1341 : 1 : testData.skip = false;
1342 : 1 : suites.get(suiteDesc).push(testData);
1343 : 1 :
1344 : 1 : // TEST #06 - Method [get/set]FeelslikeminOnDay()...test#1
1345 : 1 : testData = {};
1346 : 1 :
1347 [ + ]: 1 : testData.method = async () => {
1348 : 1 : let sample = JSON.parse(sampleActive);
1349 : 1 :
1350 : 1 : let weather = new Weather();
1351 : 1 : weather.setWeatherData(sample);
1352 : 1 :
1353 : 1 : let testDay, testFeelslikemin;
1354 : 1 :
1355 : 1 : testDay = sample.days[0].datetime;
1356 : 1 : testFeelslikemin = 0;
1357 : 1 : weather.setFeelslikeminOnDay(testDay, testFeelslikemin);
1358 : 1 : assert.strictEqual(weather.getFeelslikeminOnDay(testDay), testFeelslikemin);
1359 : 1 :
1360 : 1 : testDay = 0;
1361 : 1 : testFeelslikemin = 10;
1362 : 1 : weather.setFeelslikeminOnDay(testDay, testFeelslikemin);
1363 : 1 : assert.strictEqual(weather.getFeelslikeminOnDay(testDay), testFeelslikemin);
1364 : 1 :
1365 : 1 : assert.strictEqual(weather.getFeelslikeminOnDay(), null);
1366 : 1 : assert.strictEqual(weather.getFeelslikeminOnDay('1970-01-01'), null);
1367 : 1 : assert.throws(
1368 [ + ]: 1 : () => {
1369 : 1 : weather.setFeelslikeminOnDay(false, testFeelslikemin);
1370 : 1 : },
1371 [ + ]: 1 : (err) => {
1372 : 1 : assert(err instanceof TypeError);
1373 : 1 : assert.strictEqual(err.message, `Weather.setFeelslikeminOnDay: Invalid input day value 'false'.`);
1374 : 1 : return true;
1375 : 1 : }
1376 : 1 : );
1377 : 1 : };
1378 : 1 : testData.desc = 'Method [get/set]FeelslikeminOnDay()...test#1';
1379 : 1 :
1380 : 1 : testData.skip = false;
1381 : 1 : suites.get(suiteDesc).push(testData);
1382 : 1 :
1383 : 1 : // TEST #07 - Method [get/set]DewOnDay()...test#1
1384 : 1 : testData = {};
1385 : 1 :
1386 [ + ]: 1 : testData.method = async () => {
1387 : 1 : let sample = JSON.parse(sampleActive);
1388 : 1 :
1389 : 1 : let weather = new Weather();
1390 : 1 : weather.setWeatherData(sample);
1391 : 1 :
1392 : 1 : let testDay, testDew;
1393 : 1 :
1394 : 1 : testDay = sample.days[0].datetime;
1395 : 1 : testDew = 0;
1396 : 1 : weather.setDewOnDay(testDay, testDew);
1397 : 1 : assert.strictEqual(weather.getDewOnDay(testDay), testDew);
1398 : 1 :
1399 : 1 : testDay = 0;
1400 : 1 : testDew = 10;
1401 : 1 : weather.setDewOnDay(testDay, testDew);
1402 : 1 : assert.strictEqual(weather.getDewOnDay(testDay), testDew);
1403 : 1 :
1404 : 1 : assert.strictEqual(weather.getDewOnDay(), null);
1405 : 1 : assert.strictEqual(weather.getDewOnDay('1970-01-01'), null);
1406 : 1 : assert.throws(
1407 [ + ]: 1 : () => {
1408 : 1 : weather.setDewOnDay(false, testDew);
1409 : 1 : },
1410 [ + ]: 1 : (err) => {
1411 : 1 : assert(err instanceof TypeError);
1412 : 1 : assert.strictEqual(err.message, `Weather.setDewOnDay: Invalid input day value 'false'.`);
1413 : 1 : return true;
1414 : 1 : }
1415 : 1 : );
1416 : 1 : };
1417 : 1 : testData.desc = 'Method [get/set]DewOnDay()...test#1';
1418 : 1 :
1419 : 1 : testData.skip = false;
1420 : 1 : suites.get(suiteDesc).push(testData);
1421 : 1 :
1422 : 1 : // TEST #08 - Method [get/set]HumidityOnDay()...test#1
1423 : 1 : testData = {};
1424 : 1 :
1425 [ + ]: 1 : testData.method = async () => {
1426 : 1 : let sample = JSON.parse(sampleActive);
1427 : 1 :
1428 : 1 : let weather = new Weather();
1429 : 1 : weather.setWeatherData(sample);
1430 : 1 :
1431 : 1 : let testDay, testHumidity;
1432 : 1 :
1433 : 1 : testDay = sample.days[0].datetime;
1434 : 1 : testHumidity = 0;
1435 : 1 : weather.setHumidityOnDay(testDay, testHumidity);
1436 : 1 : assert.strictEqual(weather.getHumidityOnDay(testDay), testHumidity);
1437 : 1 :
1438 : 1 : testDay = 0;
1439 : 1 : testHumidity = 10;
1440 : 1 : weather.setHumidityOnDay(testDay, testHumidity);
1441 : 1 : assert.strictEqual(weather.getHumidityOnDay(testDay), testHumidity);
1442 : 1 :
1443 : 1 : assert.strictEqual(weather.getHumidityOnDay(), null);
1444 : 1 : assert.strictEqual(weather.getHumidityOnDay('1970-01-01'), null);
1445 : 1 : assert.throws(
1446 [ + ]: 1 : () => {
1447 : 1 : weather.setHumidityOnDay(false, testHumidity);
1448 : 1 : },
1449 [ + ]: 1 : (err) => {
1450 : 1 : assert(err instanceof TypeError);
1451 : 1 : assert.strictEqual(err.message, `Weather.setHumidityOnDay: Invalid input day value 'false'.`);
1452 : 1 : return true;
1453 : 1 : }
1454 : 1 : );
1455 : 1 : };
1456 : 1 : testData.desc = 'Method [get/set]HumidityOnDay()...test#1';
1457 : 1 :
1458 : 1 : testData.skip = false;
1459 : 1 : suites.get(suiteDesc).push(testData);
1460 : 1 :
1461 : 1 : // TEST #09 - Method [get/set]PrecipOnDay()...test#1
1462 : 1 : testData = {};
1463 : 1 :
1464 [ + ]: 1 : testData.method = async () => {
1465 : 1 : let sample = JSON.parse(sampleActive);
1466 : 1 :
1467 : 1 : let weather = new Weather();
1468 : 1 : weather.setWeatherData(sample);
1469 : 1 :
1470 : 1 : let testDay, testPrecip;
1471 : 1 :
1472 : 1 : testDay = sample.days[0].datetime;
1473 : 1 : testPrecip = 0;
1474 : 1 : weather.setPrecipOnDay(testDay, testPrecip);
1475 : 1 : assert.strictEqual(weather.getPrecipOnDay(testDay), testPrecip);
1476 : 1 :
1477 : 1 : testDay = 0;
1478 : 1 : testPrecip = 10;
1479 : 1 : weather.setPrecipOnDay(testDay, testPrecip);
1480 : 1 : assert.strictEqual(weather.getPrecipOnDay(testDay), testPrecip);
1481 : 1 :
1482 : 1 : assert.strictEqual(weather.getPrecipOnDay(), null);
1483 : 1 : assert.strictEqual(weather.getPrecipOnDay('1970-01-01'), null);
1484 : 1 : assert.throws(
1485 [ + ]: 1 : () => {
1486 : 1 : weather.setPrecipOnDay(false, testPrecip);
1487 : 1 : },
1488 [ + ]: 1 : (err) => {
1489 : 1 : assert(err instanceof TypeError);
1490 : 1 : assert.strictEqual(err.message, `Weather.setPrecipOnDay: Invalid input day value 'false'.`);
1491 : 1 : return true;
1492 : 1 : }
1493 : 1 : );
1494 : 1 : };
1495 : 1 : testData.desc = 'Method [get/set]PrecipOnDay()...test#1';
1496 : 1 :
1497 : 1 : testData.skip = false;
1498 : 1 : suites.get(suiteDesc).push(testData);
1499 : 1 :
1500 : 1 : // TEST #10 - Method [get/set]PrecipprobOnDay()...test#1
1501 : 1 : testData = {};
1502 : 1 :
1503 [ + ]: 1 : testData.method = async () => {
1504 : 1 : let sample = JSON.parse(sampleActive);
1505 : 1 :
1506 : 1 : let weather = new Weather();
1507 : 1 : weather.setWeatherData(sample);
1508 : 1 :
1509 : 1 : let testDay, testPrecipprob;
1510 : 1 :
1511 : 1 : testDay = sample.days[0].datetime;
1512 : 1 : testPrecipprob = 0;
1513 : 1 : weather.setPrecipprobOnDay(testDay, testPrecipprob);
1514 : 1 : assert.strictEqual(weather.getPrecipprobOnDay(testDay), testPrecipprob);
1515 : 1 :
1516 : 1 : testDay = 0;
1517 : 1 : testPrecipprob = 10;
1518 : 1 : weather.setPrecipprobOnDay(testDay, testPrecipprob);
1519 : 1 : assert.strictEqual(weather.getPrecipprobOnDay(testDay), testPrecipprob);
1520 : 1 :
1521 : 1 : assert.strictEqual(weather.getPrecipprobOnDay(), null);
1522 : 1 : assert.strictEqual(weather.getPrecipprobOnDay('1970-01-01'), null);
1523 : 1 : assert.throws(
1524 [ + ]: 1 : () => {
1525 : 1 : weather.setPrecipprobOnDay(false, testPrecipprob);
1526 : 1 : },
1527 [ + ]: 1 : (err) => {
1528 : 1 : assert(err instanceof TypeError);
1529 : 1 : assert.strictEqual(err.message, `Weather.setPrecipprobOnDay: Invalid input day value 'false'.`);
1530 : 1 : return true;
1531 : 1 : }
1532 : 1 : );
1533 : 1 : };
1534 : 1 : testData.desc = 'Method [get/set]PrecipprobOnDay()...test#1';
1535 : 1 :
1536 : 1 : testData.skip = false;
1537 : 1 : suites.get(suiteDesc).push(testData);
1538 : 1 :
1539 : 1 : // TEST #11 - Method [get/set]PrecipcoverOnDay()...test#1
1540 : 1 : testData = {};
1541 : 1 :
1542 [ + ]: 1 : testData.method = async () => {
1543 : 1 : let sample = JSON.parse(sampleActive);
1544 : 1 :
1545 : 1 : let weather = new Weather();
1546 : 1 : weather.setWeatherData(sample);
1547 : 1 :
1548 : 1 : let testDay, testPrecipcover;
1549 : 1 :
1550 : 1 : testDay = sample.days[0].datetime;
1551 : 1 : testPrecipcover = 0;
1552 : 1 : weather.setPrecipcoverOnDay(testDay, testPrecipcover);
1553 : 1 : assert.strictEqual(weather.getPrecipcoverOnDay(testDay), testPrecipcover);
1554 : 1 :
1555 : 1 : testDay = 0;
1556 : 1 : testPrecipcover = 10;
1557 : 1 : weather.setPrecipcoverOnDay(testDay, testPrecipcover);
1558 : 1 : assert.strictEqual(weather.getPrecipcoverOnDay(testDay), testPrecipcover);
1559 : 1 :
1560 : 1 : assert.strictEqual(weather.getPrecipcoverOnDay(), null);
1561 : 1 : assert.strictEqual(weather.getPrecipcoverOnDay('1970-01-01'), null);
1562 : 1 : assert.throws(
1563 [ + ]: 1 : () => {
1564 : 1 : weather.setPrecipcoverOnDay(false, testPrecipcover);
1565 : 1 : },
1566 [ + ]: 1 : (err) => {
1567 : 1 : assert(err instanceof TypeError);
1568 : 1 : assert.strictEqual(err.message, `Weather.setPrecipcoverOnDay: Invalid input day value 'false'.`);
1569 : 1 : return true;
1570 : 1 : }
1571 : 1 : );
1572 : 1 : };
1573 : 1 : testData.desc = 'Method [get/set]PrecipcoverOnDay()...test#1';
1574 : 1 :
1575 : 1 : testData.skip = false;
1576 : 1 : suites.get(suiteDesc).push(testData);
1577 : 1 :
1578 : 1 : // TEST #12 - Method [get/set]PreciptypeOnDay()...test#1
1579 : 1 : testData = {};
1580 : 1 :
1581 [ + ]: 1 : testData.method = async () => {
1582 : 1 : let sample = JSON.parse(sampleActive);
1583 : 1 :
1584 : 1 : let weather = new Weather();
1585 : 1 : weather.setWeatherData(sample);
1586 : 1 :
1587 : 1 : let testDay, testPreciptype;
1588 : 1 :
1589 : 1 : testDay = sample.days[0].datetime;
1590 : 1 : testPreciptype = 'type1';
1591 : 1 : weather.setPreciptypeOnDay(testDay, testPreciptype);
1592 : 1 : assert.strictEqual(weather.getPreciptypeOnDay(testDay), testPreciptype);
1593 : 1 :
1594 : 1 : testDay = 0;
1595 : 1 : testPreciptype = 'type2';
1596 : 1 : weather.setPreciptypeOnDay(testDay, testPreciptype);
1597 : 1 : assert.strictEqual(weather.getPreciptypeOnDay(testDay), testPreciptype);
1598 : 1 :
1599 : 1 : assert.strictEqual(weather.getPreciptypeOnDay(), null);
1600 : 1 : assert.strictEqual(weather.getPreciptypeOnDay('1970-01-01'), null);
1601 : 1 : assert.throws(
1602 [ + ]: 1 : () => {
1603 : 1 : weather.setPreciptypeOnDay(false, testPreciptype);
1604 : 1 : },
1605 [ + ]: 1 : (err) => {
1606 : 1 : assert(err instanceof TypeError);
1607 : 1 : assert.strictEqual(err.message, `Weather.setPreciptypeOnDay: Invalid input day value 'false'.`);
1608 : 1 : return true;
1609 : 1 : }
1610 : 1 : );
1611 : 1 : };
1612 : 1 : testData.desc = 'Method [get/set]PreciptypeOnDay()...test#1';
1613 : 1 :
1614 : 1 : testData.skip = false;
1615 : 1 : suites.get(suiteDesc).push(testData);
1616 : 1 :
1617 : 1 : // TEST #13 - Method [get/set]SnowOnDay()...test#1
1618 : 1 : testData = {};
1619 : 1 :
1620 [ + ]: 1 : testData.method = async () => {
1621 : 1 : let sample = JSON.parse(sampleActive);
1622 : 1 :
1623 : 1 : let weather = new Weather();
1624 : 1 : weather.setWeatherData(sample);
1625 : 1 :
1626 : 1 : let testDay, testSnow;
1627 : 1 :
1628 : 1 : testDay = sample.days[0].datetime;
1629 : 1 : testSnow = 0;
1630 : 1 : weather.setSnowOnDay(testDay, testSnow);
1631 : 1 : assert.strictEqual(weather.getSnowOnDay(testDay), testSnow);
1632 : 1 :
1633 : 1 : testDay = 0;
1634 : 1 : testSnow = 10;
1635 : 1 : weather.setSnowOnDay(testDay, testSnow);
1636 : 1 : assert.strictEqual(weather.getSnowOnDay(testDay), testSnow);
1637 : 1 :
1638 : 1 : assert.strictEqual(weather.getSnowOnDay(), null);
1639 : 1 : assert.strictEqual(weather.getSnowOnDay('1970-01-01'), null);
1640 : 1 : assert.throws(
1641 [ + ]: 1 : () => {
1642 : 1 : weather.setSnowOnDay(false, testSnow);
1643 : 1 : },
1644 [ + ]: 1 : (err) => {
1645 : 1 : assert(err instanceof TypeError);
1646 : 1 : assert.strictEqual(err.message, `Weather.setSnowOnDay: Invalid input day value 'false'.`);
1647 : 1 : return true;
1648 : 1 : }
1649 : 1 : );
1650 : 1 : };
1651 : 1 : testData.desc = 'Method [get/set]SnowOnDay()...test#1';
1652 : 1 :
1653 : 1 : testData.skip = false;
1654 : 1 : suites.get(suiteDesc).push(testData);
1655 : 1 :
1656 : 1 : // TEST #14 - Method [get/set]SnowdepthOnDay()...test#1
1657 : 1 : testData = {};
1658 : 1 :
1659 [ + ]: 1 : testData.method = async () => {
1660 : 1 : let sample = JSON.parse(sampleActive);
1661 : 1 :
1662 : 1 : let weather = new Weather();
1663 : 1 : weather.setWeatherData(sample);
1664 : 1 :
1665 : 1 : let testDay, testSnowdepth;
1666 : 1 :
1667 : 1 : testDay = sample.days[0].datetime;
1668 : 1 : testSnowdepth = 0;
1669 : 1 : weather.setSnowdepthOnDay(testDay, testSnowdepth);
1670 : 1 : assert.strictEqual(weather.getSnowdepthOnDay(testDay), testSnowdepth);
1671 : 1 :
1672 : 1 : testDay = 0;
1673 : 1 : testSnowdepth = 10;
1674 : 1 : weather.setSnowdepthOnDay(testDay, testSnowdepth);
1675 : 1 : assert.strictEqual(weather.getSnowdepthOnDay(testDay), testSnowdepth);
1676 : 1 :
1677 : 1 : assert.strictEqual(weather.getSnowdepthOnDay(), null);
1678 : 1 : assert.strictEqual(weather.getSnowdepthOnDay('1970-01-01'), null);
1679 : 1 : assert.throws(
1680 [ + ]: 1 : () => {
1681 : 1 : weather.setSnowdepthOnDay(false, testSnowdepth);
1682 : 1 : },
1683 [ + ]: 1 : (err) => {
1684 : 1 : assert(err instanceof TypeError);
1685 : 1 : assert.strictEqual(err.message, `Weather.setSnowdepthOnDay: Invalid input day value 'false'.`);
1686 : 1 : return true;
1687 : 1 : }
1688 : 1 : );
1689 : 1 : };
1690 : 1 : testData.desc = 'Method [get/set]SnowdepthOnDay()...test#1';
1691 : 1 :
1692 : 1 : testData.skip = false;
1693 : 1 : suites.get(suiteDesc).push(testData);
1694 : 1 :
1695 : 1 : // TEST #15 - Method [get/set]WindgustOnDay()...test#1
1696 : 1 : testData = {};
1697 : 1 :
1698 [ + ]: 1 : testData.method = async () => {
1699 : 1 : let sample = JSON.parse(sampleActive);
1700 : 1 :
1701 : 1 : let weather = new Weather();
1702 : 1 : weather.setWeatherData(sample);
1703 : 1 :
1704 : 1 : let testDay, testWindgust;
1705 : 1 :
1706 : 1 : testDay = sample.days[0].datetime;
1707 : 1 : testWindgust = 0;
1708 : 1 : weather.setWindgustOnDay(testDay, testWindgust);
1709 : 1 : assert.strictEqual(weather.getWindgustOnDay(testDay), testWindgust);
1710 : 1 :
1711 : 1 : testDay = 0;
1712 : 1 : testWindgust = 10;
1713 : 1 : weather.setWindgustOnDay(testDay, testWindgust);
1714 : 1 : assert.strictEqual(weather.getWindgustOnDay(testDay), testWindgust);
1715 : 1 :
1716 : 1 : assert.strictEqual(weather.getWindgustOnDay(), null);
1717 : 1 : assert.strictEqual(weather.getWindgustOnDay('1970-01-01'), null);
1718 : 1 : assert.throws(
1719 [ + ]: 1 : () => {
1720 : 1 : weather.setWindgustOnDay(false, testWindgust);
1721 : 1 : },
1722 [ + ]: 1 : (err) => {
1723 : 1 : assert(err instanceof TypeError);
1724 : 1 : assert.strictEqual(err.message, `Weather.setWindgustOnDay: Invalid input day value 'false'.`);
1725 : 1 : return true;
1726 : 1 : }
1727 : 1 : );
1728 : 1 : };
1729 : 1 : testData.desc = 'Method [get/set]WindgustOnDay()...test#1';
1730 : 1 :
1731 : 1 : testData.skip = false;
1732 : 1 : suites.get(suiteDesc).push(testData);
1733 : 1 :
1734 : 1 : // TEST #16 - Method [get/set]WindspeedOnDay()...test#1
1735 : 1 : testData = {};
1736 : 1 :
1737 [ + ]: 1 : testData.method = async () => {
1738 : 1 : let sample = JSON.parse(sampleActive);
1739 : 1 :
1740 : 1 : let weather = new Weather();
1741 : 1 : weather.setWeatherData(sample);
1742 : 1 :
1743 : 1 : let testDay, testWindspeed;
1744 : 1 :
1745 : 1 : testDay = sample.days[0].datetime;
1746 : 1 : testWindspeed = 0;
1747 : 1 : weather.setWindspeedOnDay(testDay, testWindspeed);
1748 : 1 : assert.strictEqual(weather.getWindspeedOnDay(testDay), testWindspeed);
1749 : 1 :
1750 : 1 : testDay = 0;
1751 : 1 : testWindspeed = 10;
1752 : 1 : weather.setWindspeedOnDay(testDay, testWindspeed);
1753 : 1 : assert.strictEqual(weather.getWindspeedOnDay(testDay), testWindspeed);
1754 : 1 :
1755 : 1 : assert.strictEqual(weather.getWindspeedOnDay(), null);
1756 : 1 : assert.strictEqual(weather.getWindspeedOnDay('1970-01-01'), null);
1757 : 1 : assert.throws(
1758 [ + ]: 1 : () => {
1759 : 1 : weather.setWindspeedOnDay(false, testWindspeed);
1760 : 1 : },
1761 [ + ]: 1 : (err) => {
1762 : 1 : assert(err instanceof TypeError);
1763 : 1 : assert.strictEqual(err.message, `Weather.setWindspeedOnDay: Invalid input day value 'false'.`);
1764 : 1 : return true;
1765 : 1 : }
1766 : 1 : );
1767 : 1 : };
1768 : 1 : testData.desc = 'Method [get/set]WindspeedOnDay()...test#1';
1769 : 1 :
1770 : 1 : testData.skip = false;
1771 : 1 : suites.get(suiteDesc).push(testData);
1772 : 1 :
1773 : 1 : // TEST #17 - Method [get/set]WinddirOnDay()...test#1
1774 : 1 : testData = {};
1775 : 1 :
1776 [ + ]: 1 : testData.method = async () => {
1777 : 1 : let sample = JSON.parse(sampleActive);
1778 : 1 :
1779 : 1 : let weather = new Weather();
1780 : 1 : weather.setWeatherData(sample);
1781 : 1 :
1782 : 1 : let testDay, testWinddir;
1783 : 1 :
1784 : 1 : testDay = sample.days[0].datetime;
1785 : 1 : testWinddir = 0;
1786 : 1 : weather.setWinddirOnDay(testDay, testWinddir);
1787 : 1 : assert.strictEqual(weather.getWinddirOnDay(testDay), testWinddir);
1788 : 1 :
1789 : 1 : testDay = 0;
1790 : 1 : testWinddir = 10;
1791 : 1 : weather.setWinddirOnDay(testDay, testWinddir);
1792 : 1 : assert.strictEqual(weather.getWinddirOnDay(testDay), testWinddir);
1793 : 1 :
1794 : 1 : assert.strictEqual(weather.getWinddirOnDay(), null);
1795 : 1 : assert.strictEqual(weather.getWinddirOnDay('1970-01-01'), null);
1796 : 1 : assert.throws(
1797 [ + ]: 1 : () => {
1798 : 1 : weather.setWinddirOnDay(false, testWinddir);
1799 : 1 : },
1800 [ + ]: 1 : (err) => {
1801 : 1 : assert(err instanceof TypeError);
1802 : 1 : assert.strictEqual(err.message, `Weather.setWinddirOnDay: Invalid input day value 'false'.`);
1803 : 1 : return true;
1804 : 1 : }
1805 : 1 : );
1806 : 1 : };
1807 : 1 : testData.desc = 'Method [get/set]WinddirOnDay()...test#1';
1808 : 1 :
1809 : 1 : testData.skip = false;
1810 : 1 : suites.get(suiteDesc).push(testData);
1811 : 1 :
1812 : 1 : // TEST #18 - Method [get/set]PressureOnDay()...test#1
1813 : 1 : testData = {};
1814 : 1 :
1815 [ + ]: 1 : testData.method = async () => {
1816 : 1 : let sample = JSON.parse(sampleActive);
1817 : 1 :
1818 : 1 : let weather = new Weather();
1819 : 1 : weather.setWeatherData(sample);
1820 : 1 :
1821 : 1 : let testDay, testPressure;
1822 : 1 :
1823 : 1 : testDay = sample.days[0].datetime;
1824 : 1 : testPressure = 0;
1825 : 1 : weather.setPressureOnDay(testDay, testPressure);
1826 : 1 : assert.strictEqual(weather.getPressureOnDay(testDay), testPressure);
1827 : 1 :
1828 : 1 : testDay = 0;
1829 : 1 : testPressure = 10;
1830 : 1 : weather.setPressureOnDay(testDay, testPressure);
1831 : 1 : assert.strictEqual(weather.getPressureOnDay(testDay), testPressure);
1832 : 1 :
1833 : 1 : assert.strictEqual(weather.getPressureOnDay(), null);
1834 : 1 : assert.strictEqual(weather.getPressureOnDay('1970-01-01'), null);
1835 : 1 : assert.throws(
1836 [ + ]: 1 : () => {
1837 : 1 : weather.setPressureOnDay(false, testPressure);
1838 : 1 : },
1839 [ + ]: 1 : (err) => {
1840 : 1 : assert(err instanceof TypeError);
1841 : 1 : assert.strictEqual(err.message, `Weather.setPressureOnDay: Invalid input day value 'false'.`);
1842 : 1 : return true;
1843 : 1 : }
1844 : 1 : );
1845 : 1 : };
1846 : 1 : testData.desc = 'Method [get/set]PressureOnDay()...test#1';
1847 : 1 :
1848 : 1 : testData.skip = false;
1849 : 1 : suites.get(suiteDesc).push(testData);
1850 : 1 :
1851 : 1 : // TEST #19 - Method [get/set]CloudcoverOnDay()...test#1
1852 : 1 : testData = {};
1853 : 1 :
1854 [ + ]: 1 : testData.method = async () => {
1855 : 1 : let sample = JSON.parse(sampleActive);
1856 : 1 :
1857 : 1 : let weather = new Weather();
1858 : 1 : weather.setWeatherData(sample);
1859 : 1 :
1860 : 1 : let testDay, testCloudcover;
1861 : 1 :
1862 : 1 : testDay = sample.days[0].datetime;
1863 : 1 : testCloudcover = 0;
1864 : 1 : weather.setCloudcoverOnDay(testDay, testCloudcover);
1865 : 1 : assert.strictEqual(weather.getCloudcoverOnDay(testDay), testCloudcover);
1866 : 1 :
1867 : 1 : testDay = 0;
1868 : 1 : testCloudcover = 10;
1869 : 1 : weather.setCloudcoverOnDay(testDay, testCloudcover);
1870 : 1 : assert.strictEqual(weather.getCloudcoverOnDay(testDay), testCloudcover);
1871 : 1 :
1872 : 1 : assert.strictEqual(weather.getCloudcoverOnDay(), null);
1873 : 1 : assert.strictEqual(weather.getCloudcoverOnDay('1970-01-01'), null);
1874 : 1 : assert.throws(
1875 [ + ]: 1 : () => {
1876 : 1 : weather.setCloudcoverOnDay(false, testCloudcover);
1877 : 1 : },
1878 [ + ]: 1 : (err) => {
1879 : 1 : assert(err instanceof TypeError);
1880 : 1 : assert.strictEqual(err.message, `Weather.setCloudcoverOnDay: Invalid input day value 'false'.`);
1881 : 1 : return true;
1882 : 1 : }
1883 : 1 : );
1884 : 1 : };
1885 : 1 : testData.desc = 'Method [get/set]CloudcoverOnDay()...test#1';
1886 : 1 :
1887 : 1 : testData.skip = false;
1888 : 1 : suites.get(suiteDesc).push(testData);
1889 : 1 :
1890 : 1 : // TEST #20 - Method [get/set]VisibilityOnDay()...test#1
1891 : 1 : testData = {};
1892 : 1 :
1893 [ + ]: 1 : testData.method = async () => {
1894 : 1 : let sample = JSON.parse(sampleActive);
1895 : 1 :
1896 : 1 : let weather = new Weather();
1897 : 1 : weather.setWeatherData(sample);
1898 : 1 :
1899 : 1 : let testDay, testVisibility;
1900 : 1 :
1901 : 1 : testDay = sample.days[0].datetime;
1902 : 1 : testVisibility = 0;
1903 : 1 : weather.setVisibilityOnDay(testDay, testVisibility);
1904 : 1 : assert.strictEqual(weather.getVisibilityOnDay(testDay), testVisibility);
1905 : 1 :
1906 : 1 : testDay = 0;
1907 : 1 : testVisibility = 10;
1908 : 1 : weather.setVisibilityOnDay(testDay, testVisibility);
1909 : 1 : assert.strictEqual(weather.getVisibilityOnDay(testDay), testVisibility);
1910 : 1 :
1911 : 1 : assert.strictEqual(weather.getVisibilityOnDay(), null);
1912 : 1 : assert.strictEqual(weather.getVisibilityOnDay('1970-01-01'), null);
1913 : 1 : assert.throws(
1914 [ + ]: 1 : () => {
1915 : 1 : weather.setVisibilityOnDay(false, testVisibility);
1916 : 1 : },
1917 [ + ]: 1 : (err) => {
1918 : 1 : assert(err instanceof TypeError);
1919 : 1 : assert.strictEqual(err.message, `Weather.setVisibilityOnDay: Invalid input day value 'false'.`);
1920 : 1 : return true;
1921 : 1 : }
1922 : 1 : );
1923 : 1 : };
1924 : 1 : testData.desc = 'Method [get/set]VisibilityOnDay()...test#1';
1925 : 1 :
1926 : 1 : testData.skip = false;
1927 : 1 : suites.get(suiteDesc).push(testData);
1928 : 1 :
1929 : 1 : // TEST #21 - Method [get/set]SolarradiationOnDay()...test#1
1930 : 1 : testData = {};
1931 : 1 :
1932 [ + ]: 1 : testData.method = async () => {
1933 : 1 : let sample = JSON.parse(sampleActive);
1934 : 1 :
1935 : 1 : let weather = new Weather();
1936 : 1 : weather.setWeatherData(sample);
1937 : 1 :
1938 : 1 : let testDay, testSolarradiation;
1939 : 1 :
1940 : 1 : testDay = sample.days[0].datetime;
1941 : 1 : testSolarradiation = 0;
1942 : 1 : weather.setSolarradiationOnDay(testDay, testSolarradiation);
1943 : 1 : assert.strictEqual(weather.getSolarradiationOnDay(testDay), testSolarradiation);
1944 : 1 :
1945 : 1 : testDay = 0;
1946 : 1 : testSolarradiation = 10;
1947 : 1 : weather.setSolarradiationOnDay(testDay, testSolarradiation);
1948 : 1 : assert.strictEqual(weather.getSolarradiationOnDay(testDay), testSolarradiation);
1949 : 1 :
1950 : 1 : assert.strictEqual(weather.getSolarradiationOnDay(), null);
1951 : 1 : assert.strictEqual(weather.getSolarradiationOnDay('1970-01-01'), null);
1952 : 1 : assert.throws(
1953 [ + ]: 1 : () => {
1954 : 1 : weather.setSolarradiationOnDay(false, testSolarradiation);
1955 : 1 : },
1956 [ + ]: 1 : (err) => {
1957 : 1 : assert(err instanceof TypeError);
1958 : 1 : assert.strictEqual(err.message, `Weather.setSolarradiationOnDay: Invalid input day value 'false'.`);
1959 : 1 : return true;
1960 : 1 : }
1961 : 1 : );
1962 : 1 : };
1963 : 1 : testData.desc = 'Method [get/set]SolarradiationOnDay()...test#1';
1964 : 1 :
1965 : 1 : testData.skip = false;
1966 : 1 : suites.get(suiteDesc).push(testData);
1967 : 1 :
1968 : 1 : // TEST #22 - Method [get/set]SolarenergyOnDay()...test#1
1969 : 1 : testData = {};
1970 : 1 :
1971 [ + ]: 1 : testData.method = async () => {
1972 : 1 : let sample = JSON.parse(sampleActive);
1973 : 1 :
1974 : 1 : let weather = new Weather();
1975 : 1 : weather.setWeatherData(sample);
1976 : 1 :
1977 : 1 : let testDay, testSolarenergy;
1978 : 1 :
1979 : 1 : testDay = sample.days[0].datetime;
1980 : 1 : testSolarenergy = 0;
1981 : 1 : weather.setSolarenergyOnDay(testDay, testSolarenergy);
1982 : 1 : assert.strictEqual(weather.getSolarenergyOnDay(testDay), testSolarenergy);
1983 : 1 :
1984 : 1 : testDay = 0;
1985 : 1 : testSolarenergy = 10;
1986 : 1 : weather.setSolarenergyOnDay(testDay, testSolarenergy);
1987 : 1 : assert.strictEqual(weather.getSolarenergyOnDay(testDay), testSolarenergy);
1988 : 1 :
1989 : 1 : assert.strictEqual(weather.getSolarenergyOnDay(), null);
1990 : 1 : assert.strictEqual(weather.getSolarenergyOnDay('1970-01-01'), null);
1991 : 1 : assert.throws(
1992 [ + ]: 1 : () => {
1993 : 1 : weather.setSolarenergyOnDay(false, testSolarenergy);
1994 : 1 : },
1995 [ + ]: 1 : (err) => {
1996 : 1 : assert(err instanceof TypeError);
1997 : 1 : assert.strictEqual(err.message, `Weather.setSolarenergyOnDay: Invalid input day value 'false'.`);
1998 : 1 : return true;
1999 : 1 : }
2000 : 1 : );
2001 : 1 : };
2002 : 1 : testData.desc = 'Method [get/set]SolarenergyOnDay()...test#1';
2003 : 1 :
2004 : 1 : testData.skip = false;
2005 : 1 : suites.get(suiteDesc).push(testData);
2006 : 1 :
2007 : 1 : // TEST #23 - Method [get/set]UvindexOnDay()...test#1
2008 : 1 : testData = {};
2009 : 1 :
2010 [ + ]: 1 : testData.method = async () => {
2011 : 1 : let sample = JSON.parse(sampleActive);
2012 : 1 :
2013 : 1 : let weather = new Weather();
2014 : 1 : weather.setWeatherData(sample);
2015 : 1 :
2016 : 1 : let testDay, testUvindex;
2017 : 1 :
2018 : 1 : testDay = sample.days[0].datetime;
2019 : 1 : testUvindex = 0;
2020 : 1 : weather.setUvindexOnDay(testDay, testUvindex);
2021 : 1 : assert.strictEqual(weather.getUvindexOnDay(testDay), testUvindex);
2022 : 1 :
2023 : 1 : testDay = 0;
2024 : 1 : testUvindex = 10;
2025 : 1 : weather.setUvindexOnDay(testDay, testUvindex);
2026 : 1 : assert.strictEqual(weather.getUvindexOnDay(testDay), testUvindex);
2027 : 1 :
2028 : 1 : assert.strictEqual(weather.getUvindexOnDay(), null);
2029 : 1 : assert.strictEqual(weather.getUvindexOnDay('1970-01-01'), null);
2030 : 1 : assert.throws(
2031 [ + ]: 1 : () => {
2032 : 1 : weather.setUvindexOnDay(false, testUvindex);
2033 : 1 : },
2034 [ + ]: 1 : (err) => {
2035 : 1 : assert(err instanceof TypeError);
2036 : 1 : assert.strictEqual(err.message, `Weather.setUvindexOnDay: Invalid input day value 'false'.`);
2037 : 1 : return true;
2038 : 1 : }
2039 : 1 : );
2040 : 1 : };
2041 : 1 : testData.desc = 'Method [get/set]UvindexOnDay()...test#1';
2042 : 1 :
2043 : 1 : testData.skip = false;
2044 : 1 : suites.get(suiteDesc).push(testData);
2045 : 1 :
2046 : 1 : // TEST #24 - Method [get/set]SevereriskOnDay()...test#1
2047 : 1 : testData = {};
2048 : 1 :
2049 [ + ]: 1 : testData.method = async () => {
2050 : 1 : let sample = JSON.parse(sampleActive);
2051 : 1 :
2052 : 1 : let weather = new Weather();
2053 : 1 : weather.setWeatherData(sample);
2054 : 1 :
2055 : 1 : let testDay, testSevererisk;
2056 : 1 :
2057 : 1 : testDay = sample.days[0].datetime;
2058 : 1 : testSevererisk = 0;
2059 : 1 : weather.setSevereriskOnDay(testDay, testSevererisk);
2060 : 1 : assert.strictEqual(weather.getSevereriskOnDay(testDay), testSevererisk);
2061 : 1 :
2062 : 1 : testDay = 0;
2063 : 1 : testSevererisk = 10;
2064 : 1 : weather.setSevereriskOnDay(testDay, testSevererisk);
2065 : 1 : assert.strictEqual(weather.getSevereriskOnDay(testDay), testSevererisk);
2066 : 1 :
2067 : 1 : assert.strictEqual(weather.getSevereriskOnDay(), null);
2068 : 1 : assert.strictEqual(weather.getSevereriskOnDay('1970-01-01'), null);
2069 : 1 : assert.throws(
2070 [ + ]: 1 : () => {
2071 : 1 : weather.setSevereriskOnDay(false, testSevererisk);
2072 : 1 : },
2073 [ + ]: 1 : (err) => {
2074 : 1 : assert(err instanceof TypeError);
2075 : 1 : assert.strictEqual(err.message, `Weather.setSevereriskOnDay: Invalid input day value 'false'.`);
2076 : 1 : return true;
2077 : 1 : }
2078 : 1 : );
2079 : 1 : };
2080 : 1 : testData.desc = 'Method [get/set]SevereriskOnDay()...test#1';
2081 : 1 :
2082 : 1 : testData.skip = false;
2083 : 1 : suites.get(suiteDesc).push(testData);
2084 : 1 :
2085 : 1 : // TEST #25 - Method [get/set]StationsOnDay()...test#1
2086 : 1 : testData = {};
2087 : 1 :
2088 [ + ]: 1 : testData.method = async () => {
2089 : 1 : let sample = JSON.parse(sampleActive);
2090 : 1 :
2091 : 1 : let weather = new Weather();
2092 : 1 : weather.setWeatherData(sample);
2093 : 1 :
2094 : 1 : let testDay, testStations;
2095 : 1 :
2096 : 1 : testDay = sample.days[0].datetime;
2097 : 1 : testStations = ['stattion#1'];
2098 : 1 : weather.setStationsOnDay(testDay, testStations);
2099 : 1 : assert.deepStrictEqual(weather.getStationsOnDay(testDay), testStations);
2100 : 1 :
2101 : 1 : testDay = 0;
2102 : 1 : testStations = ['stattion#2'];
2103 : 1 : weather.setStationsOnDay(testDay, testStations);
2104 : 1 : assert.deepStrictEqual(weather.getStationsOnDay(testDay), testStations);
2105 : 1 :
2106 : 1 : assert.strictEqual(weather.getStationsOnDay(), null);
2107 : 1 : assert.strictEqual(weather.getStationsOnDay('1970-01-01'), null);
2108 : 1 : assert.throws(
2109 [ + ]: 1 : () => {
2110 : 1 : weather.setStationsOnDay(false, testStations);
2111 : 1 : },
2112 [ + ]: 1 : (err) => {
2113 : 1 : assert(err instanceof TypeError);
2114 : 1 : assert.strictEqual(err.message, `Weather.setStationsOnDay: Invalid input day value 'false'.`);
2115 : 1 : return true;
2116 : 1 : }
2117 : 1 : );
2118 : 1 : };
2119 : 1 : testData.desc = 'Method [get/set]StationsOnDay()...test#1';
2120 : 1 :
2121 : 1 : testData.skip = false;
2122 : 1 : suites.get(suiteDesc).push(testData);
2123 : 1 :
2124 : 1 : // TEST SUITE #7 - Test Weather Instance Methods - Astronomy elements
2125 : 1 : suiteDesc = 'Test Weather Instance Methods - Astronomy elements';
2126 : 1 : suites.set(suiteDesc, []);
2127 : 1 :
2128 : 1 : // TEST #01 - Method [get/set]SunriseOnDay()...test#1
2129 : 1 : testData = {};
2130 : 1 :
2131 [ + ]: 1 : testData.method = async () => {
2132 : 1 : let sample = JSON.parse(sampleActive);
2133 : 1 :
2134 : 1 : let weather = new Weather();
2135 : 1 : weather.setWeatherData(sample);
2136 : 1 :
2137 : 1 : let testDay, testSunrise;
2138 : 1 :
2139 : 1 : testDay = sample.days[0].datetime;
2140 : 1 : testSunrise = '06:00:00';
2141 : 1 : weather.setSunriseOnDay(testDay, testSunrise);
2142 : 1 : assert.strictEqual(weather.getSunriseOnDay(testDay), testSunrise);
2143 : 1 :
2144 : 1 : testDay = 0;
2145 : 1 : testSunrise = '06:30:00';
2146 : 1 : weather.setSunriseOnDay(testDay, testSunrise);
2147 : 1 : assert.strictEqual(weather.getSunriseOnDay(testDay), testSunrise);
2148 : 1 :
2149 : 1 : assert.strictEqual(weather.getSunriseOnDay(), null);
2150 : 1 : assert.strictEqual(weather.getSunriseOnDay('1970-01-01'), null);
2151 : 1 : assert.throws(
2152 [ + ]: 1 : () => {
2153 : 1 : weather.setSunriseOnDay(false, testSunrise);
2154 : 1 : },
2155 [ + ]: 1 : (err) => {
2156 : 1 : assert(err instanceof TypeError);
2157 : 1 : assert.strictEqual(err.message, `Weather.setSunriseOnDay: Invalid input day value 'false'.`);
2158 : 1 : return true;
2159 : 1 : }
2160 : 1 : );
2161 : 1 : };
2162 : 1 : testData.desc = 'Method [get/set]SunriseOnDay()...test#1';
2163 : 1 :
2164 : 1 : testData.skip = false;
2165 : 1 : suites.get(suiteDesc).push(testData);
2166 : 1 :
2167 : 1 : // TEST #02 - Method [get/set]SunriseEpochOnDay()...test#1
2168 : 1 : testData = {};
2169 : 1 :
2170 [ + ]: 1 : testData.method = async () => {
2171 : 1 : let sample = JSON.parse(sampleActive);
2172 : 1 :
2173 : 1 : let weather = new Weather();
2174 : 1 : weather.setWeatherData(sample);
2175 : 1 :
2176 : 1 : let testDay, testSunriseEpoch;
2177 : 1 :
2178 : 1 : testDay = sample.days[0].datetime;
2179 : 1 : testSunriseEpoch = 1741327200000;
2180 : 1 : weather.setSunriseEpochOnDay(testDay, testSunriseEpoch);
2181 : 1 : assert.strictEqual(weather.getSunriseEpochOnDay(testDay), testSunriseEpoch);
2182 : 1 :
2183 : 1 : testDay = 0;
2184 : 1 : testSunriseEpoch = 1741329000000;
2185 : 1 : weather.setSunriseEpochOnDay(testDay, testSunriseEpoch);
2186 : 1 : assert.strictEqual(weather.getSunriseEpochOnDay(testDay), testSunriseEpoch);
2187 : 1 :
2188 : 1 : assert.strictEqual(weather.getSunriseEpochOnDay(), null);
2189 : 1 : assert.strictEqual(weather.getSunriseEpochOnDay('1970-01-01'), null);
2190 : 1 : assert.throws(
2191 [ + ]: 1 : () => {
2192 : 1 : weather.setSunriseEpochOnDay(false, testSunriseEpoch);
2193 : 1 : },
2194 [ + ]: 1 : (err) => {
2195 : 1 : assert(err instanceof TypeError);
2196 : 1 : assert.strictEqual(err.message, `Weather.setSunriseEpochOnDay: Invalid input day value 'false'.`);
2197 : 1 : return true;
2198 : 1 : }
2199 : 1 : );
2200 : 1 : };
2201 : 1 : testData.desc = 'Method [get/set]SunriseEpochOnDay()...test#1';
2202 : 1 :
2203 : 1 : testData.skip = false;
2204 : 1 : suites.get(suiteDesc).push(testData);
2205 : 1 :
2206 : 1 : // TEST #03 - Method [get/set]SunsetOnDay()...test#1
2207 : 1 : testData = {};
2208 : 1 :
2209 [ + ]: 1 : testData.method = async () => {
2210 : 1 : let sample = JSON.parse(sampleActive);
2211 : 1 :
2212 : 1 : let weather = new Weather();
2213 : 1 : weather.setWeatherData(sample);
2214 : 1 :
2215 : 1 : let testDay, testSunset;
2216 : 1 :
2217 : 1 : testDay = sample.days[0].datetime;
2218 : 1 : testSunset = '06:00:00';
2219 : 1 : weather.setSunsetOnDay(testDay, testSunset);
2220 : 1 : assert.strictEqual(weather.getSunsetOnDay(testDay), testSunset);
2221 : 1 :
2222 : 1 : testDay = 0;
2223 : 1 : testSunset = '06:30:00';
2224 : 1 : weather.setSunsetOnDay(testDay, testSunset);
2225 : 1 : assert.strictEqual(weather.getSunsetOnDay(testDay), testSunset);
2226 : 1 :
2227 : 1 : assert.strictEqual(weather.getSunsetOnDay(), null);
2228 : 1 : assert.strictEqual(weather.getSunsetOnDay('1970-01-01'), null);
2229 : 1 : assert.throws(
2230 [ + ]: 1 : () => {
2231 : 1 : weather.setSunsetOnDay(false, testSunset);
2232 : 1 : },
2233 [ + ]: 1 : (err) => {
2234 : 1 : assert(err instanceof TypeError);
2235 : 1 : assert.strictEqual(err.message, `Weather.setSunsetOnDay: Invalid input day value 'false'.`);
2236 : 1 : return true;
2237 : 1 : }
2238 : 1 : );
2239 : 1 : };
2240 : 1 : testData.desc = 'Method [get/set]SunsetOnDay()...test#1';
2241 : 1 :
2242 : 1 : testData.skip = false;
2243 : 1 : suites.get(suiteDesc).push(testData);
2244 : 1 :
2245 : 1 : // TEST #04 - Method [get/set]SunsetEpochOnDay()...test#1
2246 : 1 : testData = {};
2247 : 1 :
2248 [ + ]: 1 : testData.method = async () => {
2249 : 1 : let sample = JSON.parse(sampleActive);
2250 : 1 :
2251 : 1 : let weather = new Weather();
2252 : 1 : weather.setWeatherData(sample);
2253 : 1 :
2254 : 1 : let testDay, testSunsetEpoch;
2255 : 1 :
2256 : 1 : testDay = sample.days[0].datetime;
2257 : 1 : testSunsetEpoch = sample.days[0].sunsetEpoch;
2258 : 1 : weather.setSunsetEpochOnDay(testDay, testSunsetEpoch);
2259 : 1 : assert.strictEqual(weather.getSunsetEpochOnDay(testDay), testSunsetEpoch);
2260 : 1 :
2261 : 1 : testDay = 0;
2262 : 1 : testSunsetEpoch = sample.days[0].sunsetEpoch;
2263 : 1 : weather.setSunsetEpochOnDay(testDay, testSunsetEpoch);
2264 : 1 : assert.strictEqual(weather.getSunsetEpochOnDay(testDay), testSunsetEpoch);
2265 : 1 :
2266 : 1 : assert.strictEqual(weather.getSunsetEpochOnDay(), null);
2267 : 1 : assert.strictEqual(weather.getSunsetEpochOnDay('1970-01-01'), null);
2268 : 1 : assert.throws(
2269 [ + ]: 1 : () => {
2270 : 1 : weather.setSunsetEpochOnDay(false, testSunsetEpoch);
2271 : 1 : },
2272 [ + ]: 1 : (err) => {
2273 : 1 : assert(err instanceof TypeError);
2274 : 1 : assert.strictEqual(err.message, `Weather.setSunsetEpochOnDay: Invalid input day value 'false'.`);
2275 : 1 : return true;
2276 : 1 : }
2277 : 1 : );
2278 : 1 : };
2279 : 1 : testData.desc = 'Method [get/set]SunsetEpochOnDay()...test#1';
2280 : 1 :
2281 : 1 : testData.skip = false;
2282 : 1 : suites.get(suiteDesc).push(testData);
2283 : 1 :
2284 : 1 : // TEST #05 - Method [get/set]MoonphaseOnDay()...test#1
2285 : 1 : testData = {};
2286 : 1 :
2287 [ + ]: 1 : testData.method = async () => {
2288 : 1 : let sample = JSON.parse(sampleActive);
2289 : 1 :
2290 : 1 : let weather = new Weather();
2291 : 1 : weather.setWeatherData(sample);
2292 : 1 :
2293 : 1 : let testDay, testMoonphase;
2294 : 1 :
2295 : 1 : testDay = sample.days[0].datetime;
2296 : 1 : testMoonphase = 0;
2297 : 1 : weather.setMoonphaseOnDay(testDay, testMoonphase);
2298 : 1 : assert.strictEqual(weather.getMoonphaseOnDay(testDay), testMoonphase);
2299 : 1 :
2300 : 1 : testDay = 0;
2301 : 1 : testMoonphase = 0.25;
2302 : 1 : weather.setMoonphaseOnDay(testDay, testMoonphase);
2303 : 1 : assert.strictEqual(weather.getMoonphaseOnDay(testDay), testMoonphase);
2304 : 1 :
2305 : 1 : assert.strictEqual(weather.getMoonphaseOnDay(), null);
2306 : 1 : assert.strictEqual(weather.getMoonphaseOnDay('1970-01-01'), null);
2307 : 1 : assert.throws(
2308 [ + ]: 1 : () => {
2309 : 1 : weather.setMoonphaseOnDay(false, testMoonphase);
2310 : 1 : },
2311 [ + ]: 1 : (err) => {
2312 : 1 : assert(err instanceof TypeError);
2313 : 1 : assert.strictEqual(err.message, `Weather.setMoonphaseOnDay: Invalid input day value 'false'.`);
2314 : 1 : return true;
2315 : 1 : }
2316 : 1 : );
2317 : 1 : };
2318 : 1 : testData.desc = 'Method [get/set]MoonphaseOnDay()...test#1';
2319 : 1 :
2320 : 1 : testData.skip = false;
2321 : 1 : suites.get(suiteDesc).push(testData);
2322 : 1 :
2323 : 1 : // TEST SUITE #8 - Test Weather Instance Methods - Description elements
2324 : 1 : suiteDesc = 'Test Weather Instance Methods - Description elements';
2325 : 1 : suites.set(suiteDesc, []);
2326 : 1 :
2327 : 1 : // TEST #01 - Method [get/set]ConditionsOnDay()...test#1
2328 : 1 : testData = {};
2329 : 1 :
2330 [ + ]: 1 : testData.method = async () => {
2331 : 1 : let sample = JSON.parse(sampleActive);
2332 : 1 :
2333 : 1 : let weather = new Weather();
2334 : 1 : weather.setWeatherData(sample);
2335 : 1 :
2336 : 1 : let testDay, testConditions;
2337 : 1 :
2338 : 1 : testDay = sample.days[0].datetime;
2339 : 1 : testConditions = 'conditions#1';
2340 : 1 : weather.setConditionsOnDay(testDay, testConditions);
2341 : 1 : assert.strictEqual(weather.getConditionsOnDay(testDay), testConditions);
2342 : 1 :
2343 : 1 : testDay = 0;
2344 : 1 : testConditions = 'conditions#2';
2345 : 1 : weather.setConditionsOnDay(testDay, testConditions);
2346 : 1 : assert.strictEqual(weather.getConditionsOnDay(testDay), testConditions);
2347 : 1 :
2348 : 1 : assert.strictEqual(weather.getConditionsOnDay(), null);
2349 : 1 : assert.strictEqual(weather.getConditionsOnDay('1970-01-01'), null);
2350 : 1 : assert.throws(
2351 [ + ]: 1 : () => {
2352 : 1 : weather.setConditionsOnDay(false, testConditions);
2353 : 1 : },
2354 [ + ]: 1 : (err) => {
2355 : 1 : assert(err instanceof TypeError);
2356 : 1 : assert.strictEqual(err.message, `Weather.setConditionsOnDay: Invalid input day value 'false'.`);
2357 : 1 : return true;
2358 : 1 : }
2359 : 1 : );
2360 : 1 : };
2361 : 1 : testData.desc = 'Method [get/set]ConditionsOnDay()...test#1';
2362 : 1 :
2363 : 1 : testData.skip = false;
2364 : 1 : suites.get(suiteDesc).push(testData);
2365 : 1 :
2366 : 1 : // TEST #02 - Method [get/set]DescriptionOnDay()...test#1
2367 : 1 : testData = {};
2368 : 1 :
2369 [ + ]: 1 : testData.method = async () => {
2370 : 1 : let sample = JSON.parse(sampleActive);
2371 : 1 :
2372 : 1 : let weather = new Weather();
2373 : 1 : weather.setWeatherData(sample);
2374 : 1 :
2375 : 1 : let testDay, testDescription;
2376 : 1 :
2377 : 1 : testDay = sample.days[0].datetime;
2378 : 1 : testDescription = 'description#1';
2379 : 1 : weather.setDescriptionOnDay(testDay, testDescription);
2380 : 1 : assert.strictEqual(weather.getDescriptionOnDay(testDay), testDescription);
2381 : 1 :
2382 : 1 : testDay = 0;
2383 : 1 : testDescription = 'description#2';
2384 : 1 : weather.setDescriptionOnDay(testDay, testDescription);
2385 : 1 : assert.strictEqual(weather.getDescriptionOnDay(testDay), testDescription);
2386 : 1 :
2387 : 1 : assert.strictEqual(weather.getDescriptionOnDay(), null);
2388 : 1 : assert.strictEqual(weather.getDescriptionOnDay('1970-01-01'), null);
2389 : 1 : assert.throws(
2390 [ + ]: 1 : () => {
2391 : 1 : weather.setDescriptionOnDay(false, testDescription);
2392 : 1 : },
2393 [ + ]: 1 : (err) => {
2394 : 1 : assert(err instanceof TypeError);
2395 : 1 : assert.strictEqual(err.message, `Weather.setDescriptionOnDay: Invalid input day value 'false'.`);
2396 : 1 : return true;
2397 : 1 : }
2398 : 1 : );
2399 : 1 : };
2400 : 1 : testData.desc = 'Method [get/set]DescriptionOnDay()...test#1';
2401 : 1 :
2402 : 1 : testData.skip = false;
2403 : 1 : suites.get(suiteDesc).push(testData);
2404 : 1 :
2405 : 1 : // TEST #03 - Method [get/set]IconOnDay()...test#1
2406 : 1 : testData = {};
2407 : 1 :
2408 [ + ]: 1 : testData.method = async () => {
2409 : 1 : let sample = JSON.parse(sampleActive);
2410 : 1 :
2411 : 1 : let weather = new Weather();
2412 : 1 : weather.setWeatherData(sample);
2413 : 1 :
2414 : 1 : let testDay, testIcon;
2415 : 1 :
2416 : 1 : testDay = sample.days[0].datetime;
2417 : 1 : testIcon = 'icon#1';
2418 : 1 : weather.setIconOnDay(testDay, testIcon);
2419 : 1 : assert.strictEqual(weather.getIconOnDay(testDay), testIcon);
2420 : 1 :
2421 : 1 : testDay = 0;
2422 : 1 : testIcon = 'icon#2';
2423 : 1 : weather.setIconOnDay(testDay, testIcon);
2424 : 1 : assert.strictEqual(weather.getIconOnDay(testDay), testIcon);
2425 : 1 :
2426 : 1 : assert.strictEqual(weather.getIconOnDay(), null);
2427 : 1 : assert.strictEqual(weather.getIconOnDay('1970-01-01'), null);
2428 : 1 : assert.throws(
2429 [ + ]: 1 : () => {
2430 : 1 : weather.setIconOnDay(false, testIcon);
2431 : 1 : },
2432 [ + ]: 1 : (err) => {
2433 : 1 : assert(err instanceof TypeError);
2434 : 1 : assert.strictEqual(err.message, `Weather.setIconOnDay: Invalid input day value 'false'.`);
2435 : 1 : return true;
2436 : 1 : }
2437 : 1 : );
2438 : 1 : };
2439 : 1 : testData.desc = 'Method [get/set]IconOnDay()...test#1';
2440 : 1 :
2441 : 1 : testData.skip = false;
2442 : 1 : suites.get(suiteDesc).push(testData);
2443 : 1 :
2444 : 1 : // TEST SUITE #9 - Test Weather Instance Methods - Core Weather elements at datetime
2445 : 1 : suiteDesc = 'Test Weather Instance Methods - Core Weather elements at datetime';
2446 : 1 : suites.set(suiteDesc, []);
2447 : 1 :
2448 : 1 : // TEST #01 - Method [get/set]TempAtDatetime()...test#1
2449 : 1 : testData = {};
2450 : 1 :
2451 [ + ]: 1 : testData.method = async () => {
2452 : 1 : let sample = JSON.parse(sampleActive);
2453 : 1 :
2454 : 1 : let weather = new Weather();
2455 : 1 : weather.setWeatherData(sample);
2456 : 1 :
2457 : 1 : let testDay, testTime, testTemp;
2458 : 1 :
2459 : 1 : testDay = sample.days[0].datetime;
2460 : 1 : testTime = sample.days[0].hours[0].datetime;
2461 : 1 : testTemp = 0;
2462 : 1 : weather.setTempAtDatetime(testDay, testTime, testTemp);
2463 : 1 : assert.strictEqual(weather.getTempAtDatetime(testDay, testTime), testTemp);
2464 : 1 :
2465 : 1 : testDay = 0;
2466 : 1 : testTime = 0;
2467 : 1 : testTemp = 10;
2468 : 1 : weather.setTempAtDatetime(testDay, testTime, testTemp);
2469 : 1 : assert.strictEqual(weather.getTempAtDatetime(testDay, testTime), testTemp);
2470 : 1 :
2471 : 1 : assert.strictEqual(weather.getTempAtDatetime('2025-03-07', '24:00:00'), null);
2472 : 1 : assert.strictEqual(weather.getTempAtDatetime('1970-01-01', '00:00:00'), null);
2473 : 1 : assert.strictEqual(weather.getTempAtDatetime(0, false), null);
2474 : 1 : assert.strictEqual(weather.getTempAtDatetime(false, false), null);
2475 : 1 :
2476 : 1 : assert.throws(
2477 [ + ]: 1 : () => {
2478 : 1 : weather.setTempAtDatetime(0, false, testTemp);
2479 : 1 : },
2480 [ + ]: 1 : (err) => {
2481 : 1 : assert(err instanceof TypeError);
2482 : 1 : return true;
2483 : 1 : }
2484 : 1 : );
2485 : 1 : assert.throws(
2486 [ + ]: 1 : () => {
2487 : 1 : weather.setTempAtDatetime(false, false, testTemp);
2488 : 1 : },
2489 [ + ]: 1 : (err) => {
2490 : 1 : assert(err instanceof TypeError);
2491 : 1 : return true;
2492 : 1 : }
2493 : 1 : );
2494 : 1 : };
2495 : 1 : testData.desc = 'Method [get/set]TempAtDatetime()...test#1';
2496 : 1 :
2497 : 1 : testData.skip = false;
2498 : 1 : suites.get(suiteDesc).push(testData);
2499 : 1 :
2500 : 1 : // TEST #02 - Method [get/set]FeelsLikeAtDatetime()...test#1
2501 : 1 : testData = {};
2502 : 1 :
2503 [ + ]: 1 : testData.method = async () => {
2504 : 1 : let sample = JSON.parse(sampleActive);
2505 : 1 :
2506 : 1 : let weather = new Weather();
2507 : 1 : weather.setWeatherData(sample);
2508 : 1 :
2509 : 1 : let testDay, testTime, testFeelsLike;
2510 : 1 :
2511 : 1 : testDay = sample.days[0].datetime;
2512 : 1 : testTime = sample.days[0].hours[0].datetime;
2513 : 1 : testFeelsLike = 0;
2514 : 1 : weather.setFeelsLikeAtDatetime(testDay, testTime, testFeelsLike);
2515 : 1 : assert.strictEqual(weather.getFeelsLikeAtDatetime(testDay, testTime), testFeelsLike);
2516 : 1 :
2517 : 1 : testDay = 0;
2518 : 1 : testTime = 0;
2519 : 1 : testFeelsLike = 10;
2520 : 1 : weather.setFeelsLikeAtDatetime(testDay, testTime, testFeelsLike);
2521 : 1 : assert.strictEqual(weather.getFeelsLikeAtDatetime(testDay, testTime), testFeelsLike);
2522 : 1 :
2523 : 1 : assert.strictEqual(weather.getFeelsLikeAtDatetime(0, '24:00:00'), null);
2524 : 1 : assert.strictEqual(weather.getFeelsLikeAtDatetime('1970-01-01', 0), null);
2525 : 1 : assert.strictEqual(weather.getFeelsLikeAtDatetime(0, false), null);
2526 : 1 : assert.strictEqual(weather.getFeelsLikeAtDatetime(false, false), null);
2527 : 1 :
2528 : 1 : assert.throws(
2529 [ + ]: 1 : () => {
2530 : 1 : weather.setFeelsLikeAtDatetime(0, false, testFeelsLike);
2531 : 1 : },
2532 [ + ]: 1 : (err) => {
2533 : 1 : assert(err instanceof TypeError);
2534 : 1 : return true;
2535 : 1 : }
2536 : 1 : );
2537 : 1 : assert.throws(
2538 [ + ]: 1 : () => {
2539 : 1 : weather.setFeelsLikeAtDatetime(false, false, testFeelsLike);
2540 : 1 : },
2541 [ + ]: 1 : (err) => {
2542 : 1 : assert(err instanceof TypeError);
2543 : 1 : return true;
2544 : 1 : }
2545 : 1 : );
2546 : 1 : };
2547 : 1 : testData.desc = 'Method [get/set]FeelsLikeAtDatetime()...test#1';
2548 : 1 :
2549 : 1 : testData.skip = false;
2550 : 1 : suites.get(suiteDesc).push(testData);
2551 : 1 :
2552 : 1 : // TEST #03 - Method [get/set]DewAtDatetime()...test#1
2553 : 1 : testData = {};
2554 : 1 :
2555 [ + ]: 1 : testData.method = async () => {
2556 : 1 : let sample = JSON.parse(sampleActive);
2557 : 1 :
2558 : 1 : let weather = new Weather();
2559 : 1 : weather.setWeatherData(sample);
2560 : 1 :
2561 : 1 : let testDay, testTime, testDew;
2562 : 1 :
2563 : 1 : testDay = sample.days[0].datetime;
2564 : 1 : testTime = sample.days[0].hours[0].datetime;
2565 : 1 : testDew = 0;
2566 : 1 : weather.setDewAtDatetime(testDay, testTime, testDew);
2567 : 1 : assert.strictEqual(weather.getDewAtDatetime(testDay, testTime), testDew);
2568 : 1 :
2569 : 1 : testDay = 0;
2570 : 1 : testTime = 0;
2571 : 1 : testDew = 10;
2572 : 1 : weather.setDewAtDatetime(testDay, testTime, testDew);
2573 : 1 : assert.strictEqual(weather.getDewAtDatetime(testDay, testTime), testDew);
2574 : 1 :
2575 : 1 : assert.strictEqual(weather.getDewAtDatetime(0, '24:00:00'), null);
2576 : 1 : assert.strictEqual(weather.getDewAtDatetime('1970-01-01', 0), null);
2577 : 1 : assert.strictEqual(weather.getDewAtDatetime(0, false), null);
2578 : 1 : assert.strictEqual(weather.getDewAtDatetime(false, false), null);
2579 : 1 :
2580 : 1 : assert.throws(
2581 [ + ]: 1 : () => {
2582 : 1 : weather.setDewAtDatetime(0, false, testDew);
2583 : 1 : },
2584 [ + ]: 1 : (err) => {
2585 : 1 : assert(err instanceof TypeError);
2586 : 1 : return true;
2587 : 1 : }
2588 : 1 : );
2589 : 1 : assert.throws(
2590 [ + ]: 1 : () => {
2591 : 1 : weather.setDewAtDatetime(false, false, testDew);
2592 : 1 : },
2593 [ + ]: 1 : (err) => {
2594 : 1 : assert(err instanceof TypeError);
2595 : 1 : return true;
2596 : 1 : }
2597 : 1 : );
2598 : 1 : };
2599 : 1 : testData.desc = 'Method [get/set]DewAtDatetime()...test#1';
2600 : 1 :
2601 : 1 : testData.skip = false;
2602 : 1 : suites.get(suiteDesc).push(testData);
2603 : 1 :
2604 : 1 : // TEST #04 - Method [get/set]HumidityAtDatetime()...test#1
2605 : 1 : testData = {};
2606 : 1 :
2607 [ + ]: 1 : testData.method = async () => {
2608 : 1 : let sample = JSON.parse(sampleActive);
2609 : 1 :
2610 : 1 : let weather = new Weather();
2611 : 1 : weather.setWeatherData(sample);
2612 : 1 :
2613 : 1 : let testDay, testTime, testHumidity;
2614 : 1 :
2615 : 1 : testDay = sample.days[0].datetime;
2616 : 1 : testTime = sample.days[0].hours[0].datetime;
2617 : 1 : testHumidity = 0;
2618 : 1 : weather.setHumidityAtDatetime(testDay, testTime, testHumidity);
2619 : 1 : assert.strictEqual(weather.getHumidityAtDatetime(testDay, testTime), testHumidity);
2620 : 1 :
2621 : 1 : testDay = 0;
2622 : 1 : testTime = 0;
2623 : 1 : testHumidity = 10;
2624 : 1 : weather.setHumidityAtDatetime(testDay, testTime, testHumidity);
2625 : 1 : assert.strictEqual(weather.getHumidityAtDatetime(testDay, testTime), testHumidity);
2626 : 1 :
2627 : 1 : assert.strictEqual(weather.getHumidityAtDatetime(0, '24:00:00'), null);
2628 : 1 : assert.strictEqual(weather.getHumidityAtDatetime('1970-01-01', 0), null);
2629 : 1 : assert.strictEqual(weather.getHumidityAtDatetime(0, false), null);
2630 : 1 : assert.strictEqual(weather.getHumidityAtDatetime(false, false), null);
2631 : 1 :
2632 : 1 : assert.throws(
2633 [ + ]: 1 : () => {
2634 : 1 : weather.setHumidityAtDatetime(0, false, testHumidity);
2635 : 1 : },
2636 [ + ]: 1 : (err) => {
2637 : 1 : assert(err instanceof TypeError);
2638 : 1 : return true;
2639 : 1 : }
2640 : 1 : );
2641 : 1 : assert.throws(
2642 [ + ]: 1 : () => {
2643 : 1 : weather.setHumidityAtDatetime(false, false, testHumidity);
2644 : 1 : },
2645 [ + ]: 1 : (err) => {
2646 : 1 : assert(err instanceof TypeError);
2647 : 1 : return true;
2648 : 1 : }
2649 : 1 : );
2650 : 1 : };
2651 : 1 : testData.desc = 'Method [get/set]HumidityAtDatetime()...test#1';
2652 : 1 :
2653 : 1 : testData.skip = false;
2654 : 1 : suites.get(suiteDesc).push(testData);
2655 : 1 :
2656 : 1 : // TEST #05 - Method [get/set]PrecipAtDatetime()...test#1
2657 : 1 : testData = {};
2658 : 1 :
2659 [ + ]: 1 : testData.method = async () => {
2660 : 1 : let sample = JSON.parse(sampleActive);
2661 : 1 :
2662 : 1 : let weather = new Weather();
2663 : 1 : weather.setWeatherData(sample);
2664 : 1 :
2665 : 1 : let testDay, testTime, testPrecip;
2666 : 1 :
2667 : 1 : testDay = sample.days[0].datetime;
2668 : 1 : testTime = sample.days[0].hours[0].datetime;
2669 : 1 : testPrecip = 0;
2670 : 1 : weather.setPrecipAtDatetime(testDay, testTime, testPrecip);
2671 : 1 : assert.strictEqual(weather.getPrecipAtDatetime(testDay, testTime), testPrecip);
2672 : 1 :
2673 : 1 : testDay = 0;
2674 : 1 : testTime = 0;
2675 : 1 : testPrecip = 10;
2676 : 1 : weather.setPrecipAtDatetime(testDay, testTime, testPrecip);
2677 : 1 : assert.strictEqual(weather.getPrecipAtDatetime(testDay, testTime), testPrecip);
2678 : 1 :
2679 : 1 : assert.strictEqual(weather.getPrecipAtDatetime(0, '24:00:00'), null);
2680 : 1 : assert.strictEqual(weather.getPrecipAtDatetime('1970-01-01', 0), null);
2681 : 1 : assert.strictEqual(weather.getPrecipAtDatetime(0, false), null);
2682 : 1 : assert.strictEqual(weather.getPrecipAtDatetime(false, false), null);
2683 : 1 :
2684 : 1 : assert.throws(
2685 [ + ]: 1 : () => {
2686 : 1 : weather.setPrecipAtDatetime(0, false, testPrecip);
2687 : 1 : },
2688 [ + ]: 1 : (err) => {
2689 : 1 : assert(err instanceof TypeError);
2690 : 1 : return true;
2691 : 1 : }
2692 : 1 : );
2693 : 1 : assert.throws(
2694 [ + ]: 1 : () => {
2695 : 1 : weather.setPrecipAtDatetime(false, false, testPrecip);
2696 : 1 : },
2697 [ + ]: 1 : (err) => {
2698 : 1 : assert(err instanceof TypeError);
2699 : 1 : return true;
2700 : 1 : }
2701 : 1 : );
2702 : 1 : };
2703 : 1 : testData.desc = 'Method [get/set]PrecipAtDatetime()...test#1';
2704 : 1 :
2705 : 1 : testData.skip = false;
2706 : 1 : suites.get(suiteDesc).push(testData);
2707 : 1 :
2708 : 1 : // TEST #06 - Method [get/set]PrecipProbAtDatetime()...test#1
2709 : 1 : testData = {};
2710 : 1 :
2711 [ + ]: 1 : testData.method = async () => {
2712 : 1 : let sample = JSON.parse(sampleActive);
2713 : 1 :
2714 : 1 : let weather = new Weather();
2715 : 1 : weather.setWeatherData(sample);
2716 : 1 :
2717 : 1 : let testDay, testTime, testPrecipProb;
2718 : 1 :
2719 : 1 : testDay = sample.days[0].datetime;
2720 : 1 : testTime = sample.days[0].hours[0].datetime;
2721 : 1 : testPrecipProb = 0;
2722 : 1 : weather.setPrecipProbAtDatetime(testDay, testTime, testPrecipProb);
2723 : 1 : assert.strictEqual(weather.getPrecipProbAtDatetime(testDay, testTime), testPrecipProb);
2724 : 1 :
2725 : 1 : testDay = 0;
2726 : 1 : testTime = 0;
2727 : 1 : testPrecipProb = 10;
2728 : 1 : weather.setPrecipProbAtDatetime(testDay, testTime, testPrecipProb);
2729 : 1 : assert.strictEqual(weather.getPrecipProbAtDatetime(testDay, testTime), testPrecipProb);
2730 : 1 :
2731 : 1 : assert.strictEqual(weather.getPrecipProbAtDatetime(0, '24:00:00'), null);
2732 : 1 : assert.strictEqual(weather.getPrecipProbAtDatetime('1970-01-01', 0), null);
2733 : 1 : assert.strictEqual(weather.getPrecipProbAtDatetime(0, false), null);
2734 : 1 : assert.strictEqual(weather.getPrecipProbAtDatetime(false, false), null);
2735 : 1 :
2736 : 1 : assert.throws(
2737 [ + ]: 1 : () => {
2738 : 1 : weather.setPrecipProbAtDatetime(0, false, testPrecipProb);
2739 : 1 : },
2740 [ + ]: 1 : (err) => {
2741 : 1 : assert(err instanceof TypeError);
2742 : 1 : return true;
2743 : 1 : }
2744 : 1 : );
2745 : 1 : assert.throws(
2746 [ + ]: 1 : () => {
2747 : 1 : weather.setPrecipProbAtDatetime(false, false, testPrecipProb);
2748 : 1 : },
2749 [ + ]: 1 : (err) => {
2750 : 1 : assert(err instanceof TypeError);
2751 : 1 : return true;
2752 : 1 : }
2753 : 1 : );
2754 : 1 : };
2755 : 1 : testData.desc = 'Method [get/set]PrecipProbAtDatetime()...test#1';
2756 : 1 :
2757 : 1 : testData.skip = false;
2758 : 1 : suites.get(suiteDesc).push(testData);
2759 : 1 :
2760 : 1 : // TEST #07 - Method [get/set]PreciptypeAtDatetime()...test#1
2761 : 1 : testData = {};
2762 : 1 :
2763 [ + ]: 1 : testData.method = async () => {
2764 : 1 : let sample = JSON.parse(sampleActive);
2765 : 1 :
2766 : 1 : let weather = new Weather();
2767 : 1 : weather.setWeatherData(sample);
2768 : 1 :
2769 : 1 : let testDay, testTime, testPreciptype;
2770 : 1 :
2771 : 1 : testDay = sample.days[0].datetime;
2772 : 1 : testTime = sample.days[0].hours[0].datetime;
2773 : 1 : testPreciptype = 'type#1';
2774 : 1 : weather.setPreciptypeAtDatetime(testDay, testTime, testPreciptype);
2775 : 1 : assert.strictEqual(weather.getPreciptypeAtDatetime(testDay, testTime), testPreciptype);
2776 : 1 :
2777 : 1 : testDay = 0;
2778 : 1 : testTime = 0;
2779 : 1 : testPreciptype = 'type#2';
2780 : 1 : weather.setPreciptypeAtDatetime(testDay, testTime, testPreciptype);
2781 : 1 : assert.strictEqual(weather.getPreciptypeAtDatetime(testDay, testTime), testPreciptype);
2782 : 1 :
2783 : 1 : assert.strictEqual(weather.getPreciptypeAtDatetime(0, '24:00:00'), null);
2784 : 1 : assert.strictEqual(weather.getPreciptypeAtDatetime('1970-01-01', 0), null);
2785 : 1 : assert.strictEqual(weather.getPreciptypeAtDatetime(0, false), null);
2786 : 1 : assert.strictEqual(weather.getPreciptypeAtDatetime(false, false), null);
2787 : 1 :
2788 : 1 : assert.throws(
2789 [ + ]: 1 : () => {
2790 : 1 : weather.setPreciptypeAtDatetime(0, false, testPreciptype);
2791 : 1 : },
2792 [ + ]: 1 : (err) => {
2793 : 1 : assert(err instanceof TypeError);
2794 : 1 : return true;
2795 : 1 : }
2796 : 1 : );
2797 : 1 : assert.throws(
2798 [ + ]: 1 : () => {
2799 : 1 : weather.setPreciptypeAtDatetime(false, false, testPreciptype);
2800 : 1 : },
2801 [ + ]: 1 : (err) => {
2802 : 1 : assert(err instanceof TypeError);
2803 : 1 : return true;
2804 : 1 : }
2805 : 1 : );
2806 : 1 : };
2807 : 1 : testData.desc = 'Method [get/set]PreciptypeAtDatetime()...test#1';
2808 : 1 :
2809 : 1 : testData.skip = false;
2810 : 1 : suites.get(suiteDesc).push(testData);
2811 : 1 :
2812 : 1 : // TEST #08 - Method [get/set]SnowAtDatetime()...test#1
2813 : 1 : testData = {};
2814 : 1 :
2815 [ + ]: 1 : testData.method = async () => {
2816 : 1 : let sample = JSON.parse(sampleActive);
2817 : 1 :
2818 : 1 : let weather = new Weather();
2819 : 1 : weather.setWeatherData(sample);
2820 : 1 :
2821 : 1 : let testDay, testTime, testSnow;
2822 : 1 :
2823 : 1 : testDay = sample.days[0].datetime;
2824 : 1 : testTime = sample.days[0].hours[0].datetime;
2825 : 1 : testSnow = 0;
2826 : 1 : weather.setSnowAtDatetime(testDay, testTime, testSnow);
2827 : 1 : assert.strictEqual(weather.getSnowAtDatetime(testDay, testTime), testSnow);
2828 : 1 :
2829 : 1 : testDay = 0;
2830 : 1 : testTime = 0;
2831 : 1 : testSnow = 10;
2832 : 1 : weather.setSnowAtDatetime(testDay, testTime, testSnow);
2833 : 1 : assert.strictEqual(weather.getSnowAtDatetime(testDay, testTime), testSnow);
2834 : 1 :
2835 : 1 : assert.strictEqual(weather.getSnowAtDatetime(0, '24:00:00'), null);
2836 : 1 : assert.strictEqual(weather.getSnowAtDatetime('1970-01-01', 0), null);
2837 : 1 : assert.strictEqual(weather.getSnowAtDatetime(0, false), null);
2838 : 1 : assert.strictEqual(weather.getSnowAtDatetime(false, false), null);
2839 : 1 :
2840 : 1 : assert.throws(
2841 [ + ]: 1 : () => {
2842 : 1 : weather.setSnowAtDatetime(0, false, testSnow);
2843 : 1 : },
2844 [ + ]: 1 : (err) => {
2845 : 1 : assert(err instanceof TypeError);
2846 : 1 : return true;
2847 : 1 : }
2848 : 1 : );
2849 : 1 : assert.throws(
2850 [ + ]: 1 : () => {
2851 : 1 : weather.setSnowAtDatetime(false, false, testSnow);
2852 : 1 : },
2853 [ + ]: 1 : (err) => {
2854 : 1 : assert(err instanceof TypeError);
2855 : 1 : return true;
2856 : 1 : }
2857 : 1 : );
2858 : 1 : };
2859 : 1 : testData.desc = 'Method [get/set]SnowAtDatetime()...test#1';
2860 : 1 :
2861 : 1 : testData.skip = false;
2862 : 1 : suites.get(suiteDesc).push(testData);
2863 : 1 :
2864 : 1 : // TEST #09 - Method [get/set]SnowDepthAtDatetime()...test#1
2865 : 1 : testData = {};
2866 : 1 :
2867 [ + ]: 1 : testData.method = async () => {
2868 : 1 : let sample = JSON.parse(sampleActive);
2869 : 1 :
2870 : 1 : let weather = new Weather();
2871 : 1 : weather.setWeatherData(sample);
2872 : 1 :
2873 : 1 : let testDay, testTime, testSnowDepth;
2874 : 1 :
2875 : 1 : testDay = sample.days[0].datetime;
2876 : 1 : testTime = sample.days[0].hours[0].datetime;
2877 : 1 : testSnowDepth = 0;
2878 : 1 : weather.setSnowDepthAtDatetime(testDay, testTime, testSnowDepth);
2879 : 1 : assert.strictEqual(weather.getSnowDepthAtDatetime(testDay, testTime), testSnowDepth);
2880 : 1 :
2881 : 1 : testDay = 0;
2882 : 1 : testTime = 0;
2883 : 1 : testSnowDepth = 10;
2884 : 1 : weather.setSnowDepthAtDatetime(testDay, testTime, testSnowDepth);
2885 : 1 : assert.strictEqual(weather.getSnowDepthAtDatetime(testDay, testTime), testSnowDepth);
2886 : 1 :
2887 : 1 : assert.strictEqual(weather.getSnowDepthAtDatetime(0, '24:00:00'), null);
2888 : 1 : assert.strictEqual(weather.getSnowDepthAtDatetime('1970-01-01', 0), null);
2889 : 1 : assert.strictEqual(weather.getSnowDepthAtDatetime(0, false), null);
2890 : 1 : assert.strictEqual(weather.getSnowDepthAtDatetime(false, false), null);
2891 : 1 :
2892 : 1 : assert.throws(
2893 [ + ]: 1 : () => {
2894 : 1 : weather.setSnowDepthAtDatetime(0, false, testSnowDepth);
2895 : 1 : },
2896 [ + ]: 1 : (err) => {
2897 : 1 : assert(err instanceof TypeError);
2898 : 1 : return true;
2899 : 1 : }
2900 : 1 : );
2901 : 1 : assert.throws(
2902 [ + ]: 1 : () => {
2903 : 1 : weather.setSnowDepthAtDatetime(false, false, testSnowDepth);
2904 : 1 : },
2905 [ + ]: 1 : (err) => {
2906 : 1 : assert(err instanceof TypeError);
2907 : 1 : return true;
2908 : 1 : }
2909 : 1 : );
2910 : 1 : };
2911 : 1 : testData.desc = 'Method [get/set]SnowDepthAtDatetime()...test#1';
2912 : 1 :
2913 : 1 : testData.skip = false;
2914 : 1 : suites.get(suiteDesc).push(testData);
2915 : 1 :
2916 : 1 : // TEST #10 - Method [get/set]WindgustAtDatetime()...test#1
2917 : 1 : testData = {};
2918 : 1 :
2919 [ + ]: 1 : testData.method = async () => {
2920 : 1 : let sample = JSON.parse(sampleActive);
2921 : 1 :
2922 : 1 : let weather = new Weather();
2923 : 1 : weather.setWeatherData(sample);
2924 : 1 :
2925 : 1 : let testDay, testTime, testWindgust;
2926 : 1 :
2927 : 1 : testDay = sample.days[0].datetime;
2928 : 1 : testTime = sample.days[0].hours[0].datetime;
2929 : 1 : testWindgust = 0;
2930 : 1 : weather.setWindgustAtDatetime(testDay, testTime, testWindgust);
2931 : 1 : assert.strictEqual(weather.getWindgustAtDatetime(testDay, testTime), testWindgust);
2932 : 1 :
2933 : 1 : testDay = 0;
2934 : 1 : testTime = 0;
2935 : 1 : testWindgust = 10;
2936 : 1 : weather.setWindgustAtDatetime(testDay, testTime, testWindgust);
2937 : 1 : assert.strictEqual(weather.getWindgustAtDatetime(testDay, testTime), testWindgust);
2938 : 1 :
2939 : 1 : assert.strictEqual(weather.getWindgustAtDatetime(0, '24:00:00'), null);
2940 : 1 : assert.strictEqual(weather.getWindgustAtDatetime('1970-01-01', 0), null);
2941 : 1 : assert.strictEqual(weather.getWindgustAtDatetime(0, false), null);
2942 : 1 : assert.strictEqual(weather.getWindgustAtDatetime(false, false), null);
2943 : 1 :
2944 : 1 : assert.throws(
2945 [ + ]: 1 : () => {
2946 : 1 : weather.setWindgustAtDatetime(0, false, testWindgust);
2947 : 1 : },
2948 [ + ]: 1 : (err) => {
2949 : 1 : assert(err instanceof TypeError);
2950 : 1 : return true;
2951 : 1 : }
2952 : 1 : );
2953 : 1 : assert.throws(
2954 [ + ]: 1 : () => {
2955 : 1 : weather.setWindgustAtDatetime(false, false, testWindgust);
2956 : 1 : },
2957 [ + ]: 1 : (err) => {
2958 : 1 : assert(err instanceof TypeError);
2959 : 1 : return true;
2960 : 1 : }
2961 : 1 : );
2962 : 1 : };
2963 : 1 : testData.desc = 'Method [get/set]WindgustAtDatetime()...test#1';
2964 : 1 :
2965 : 1 : testData.skip = false;
2966 : 1 : suites.get(suiteDesc).push(testData);
2967 : 1 :
2968 : 1 : // TEST #11 - Method [get/set]WindspeedAtDatetime()...test#1
2969 : 1 : testData = {};
2970 : 1 :
2971 [ + ]: 1 : testData.method = async () => {
2972 : 1 : let sample = JSON.parse(sampleActive);
2973 : 1 :
2974 : 1 : let weather = new Weather();
2975 : 1 : weather.setWeatherData(sample);
2976 : 1 :
2977 : 1 : let testDay, testTime, testWindspeed;
2978 : 1 :
2979 : 1 : testDay = sample.days[0].datetime;
2980 : 1 : testTime = sample.days[0].hours[0].datetime;
2981 : 1 : testWindspeed = 0;
2982 : 1 : weather.setWindspeedAtDatetime(testDay, testTime, testWindspeed);
2983 : 1 : assert.strictEqual(weather.getWindspeedAtDatetime(testDay, testTime), testWindspeed);
2984 : 1 :
2985 : 1 : testDay = 0;
2986 : 1 : testTime = 0;
2987 : 1 : testWindspeed = 10;
2988 : 1 : weather.setWindspeedAtDatetime(testDay, testTime, testWindspeed);
2989 : 1 : assert.strictEqual(weather.getWindspeedAtDatetime(testDay, testTime), testWindspeed);
2990 : 1 :
2991 : 1 : assert.strictEqual(weather.getWindspeedAtDatetime(0, '24:00:00'), null);
2992 : 1 : assert.strictEqual(weather.getWindspeedAtDatetime('1970-01-01', 0), null);
2993 : 1 : assert.strictEqual(weather.getWindspeedAtDatetime(0, false), null);
2994 : 1 : assert.strictEqual(weather.getWindspeedAtDatetime(false, false), null);
2995 : 1 :
2996 : 1 : assert.throws(
2997 [ + ]: 1 : () => {
2998 : 1 : weather.setWindspeedAtDatetime(0, false, testWindspeed);
2999 : 1 : },
3000 [ + ]: 1 : (err) => {
3001 : 1 : assert(err instanceof TypeError);
3002 : 1 : return true;
3003 : 1 : }
3004 : 1 : );
3005 : 1 : assert.throws(
3006 [ + ]: 1 : () => {
3007 : 1 : weather.setWindspeedAtDatetime(false, false, testWindspeed);
3008 : 1 : },
3009 [ + ]: 1 : (err) => {
3010 : 1 : assert(err instanceof TypeError);
3011 : 1 : return true;
3012 : 1 : }
3013 : 1 : );
3014 : 1 : };
3015 : 1 : testData.desc = 'Method [get/set]WindspeedAtDatetime()...test#1';
3016 : 1 :
3017 : 1 : testData.skip = false;
3018 : 1 : suites.get(suiteDesc).push(testData);
3019 : 1 :
3020 : 1 : // TEST #12 - Method [get/set]WinddirAtDatetime()...test#1
3021 : 1 : testData = {};
3022 : 1 :
3023 [ + ]: 1 : testData.method = async () => {
3024 : 1 : let sample = JSON.parse(sampleActive);
3025 : 1 :
3026 : 1 : let weather = new Weather();
3027 : 1 : weather.setWeatherData(sample);
3028 : 1 :
3029 : 1 : let testDay, testTime, testWinddir;
3030 : 1 :
3031 : 1 : testDay = sample.days[0].datetime;
3032 : 1 : testTime = sample.days[0].hours[0].datetime;
3033 : 1 : testWinddir = 0;
3034 : 1 : weather.setWinddirAtDatetime(testDay, testTime, testWinddir);
3035 : 1 : assert.strictEqual(weather.getWinddirAtDatetime(testDay, testTime), testWinddir);
3036 : 1 :
3037 : 1 : testDay = 0;
3038 : 1 : testTime = 0;
3039 : 1 : testWinddir = 10;
3040 : 1 : weather.setWinddirAtDatetime(testDay, testTime, testWinddir);
3041 : 1 : assert.strictEqual(weather.getWinddirAtDatetime(testDay, testTime), testWinddir);
3042 : 1 :
3043 : 1 : assert.strictEqual(weather.getWinddirAtDatetime(0, '24:00:00'), null);
3044 : 1 : assert.strictEqual(weather.getWinddirAtDatetime('1970-01-01', 0), null);
3045 : 1 : assert.strictEqual(weather.getWinddirAtDatetime(0, false), null);
3046 : 1 : assert.strictEqual(weather.getWinddirAtDatetime(false, false), null);
3047 : 1 :
3048 : 1 : assert.throws(
3049 [ + ]: 1 : () => {
3050 : 1 : weather.setWinddirAtDatetime(0, false, testWinddir);
3051 : 1 : },
3052 [ + ]: 1 : (err) => {
3053 : 1 : assert(err instanceof TypeError);
3054 : 1 : return true;
3055 : 1 : }
3056 : 1 : );
3057 : 1 : assert.throws(
3058 [ + ]: 1 : () => {
3059 : 1 : weather.setWinddirAtDatetime(false, false, testWinddir);
3060 : 1 : },
3061 [ + ]: 1 : (err) => {
3062 : 1 : assert(err instanceof TypeError);
3063 : 1 : return true;
3064 : 1 : }
3065 : 1 : );
3066 : 1 : };
3067 : 1 : testData.desc = 'Method [get/set]WinddirAtDatetime()...test#1';
3068 : 1 :
3069 : 1 : testData.skip = false;
3070 : 1 : suites.get(suiteDesc).push(testData);
3071 : 1 :
3072 : 1 : // TEST #13 - Method [get/set]PressureAtDatetime()...test#1
3073 : 1 : testData = {};
3074 : 1 :
3075 [ + ]: 1 : testData.method = async () => {
3076 : 1 : let sample = JSON.parse(sampleActive);
3077 : 1 :
3078 : 1 : let weather = new Weather();
3079 : 1 : weather.setWeatherData(sample);
3080 : 1 :
3081 : 1 : let testDay, testTime, testPressure;
3082 : 1 :
3083 : 1 : testDay = sample.days[0].datetime;
3084 : 1 : testTime = sample.days[0].hours[0].datetime;
3085 : 1 : testPressure = 0;
3086 : 1 : weather.setPressureAtDatetime(testDay, testTime, testPressure);
3087 : 1 : assert.strictEqual(weather.getPressureAtDatetime(testDay, testTime), testPressure);
3088 : 1 :
3089 : 1 : testDay = 0;
3090 : 1 : testTime = 0;
3091 : 1 : testPressure = 10;
3092 : 1 : weather.setPressureAtDatetime(testDay, testTime, testPressure);
3093 : 1 : assert.strictEqual(weather.getPressureAtDatetime(testDay, testTime), testPressure);
3094 : 1 :
3095 : 1 : assert.strictEqual(weather.getPressureAtDatetime(0, '24:00:00'), null);
3096 : 1 : assert.strictEqual(weather.getPressureAtDatetime('1970-01-01', 0), null);
3097 : 1 : assert.strictEqual(weather.getPressureAtDatetime(0, false), null);
3098 : 1 : assert.strictEqual(weather.getPressureAtDatetime(false, false), null);
3099 : 1 :
3100 : 1 : assert.throws(
3101 [ + ]: 1 : () => {
3102 : 1 : weather.setPressureAtDatetime(0, false, testPressure);
3103 : 1 : },
3104 [ + ]: 1 : (err) => {
3105 : 1 : assert(err instanceof TypeError);
3106 : 1 : return true;
3107 : 1 : }
3108 : 1 : );
3109 : 1 : assert.throws(
3110 [ + ]: 1 : () => {
3111 : 1 : weather.setPressureAtDatetime(false, false, testPressure);
3112 : 1 : },
3113 [ + ]: 1 : (err) => {
3114 : 1 : assert(err instanceof TypeError);
3115 : 1 : return true;
3116 : 1 : }
3117 : 1 : );
3118 : 1 : };
3119 : 1 : testData.desc = 'Method [get/set]PressureAtDatetime()...test#1';
3120 : 1 :
3121 : 1 : testData.skip = false;
3122 : 1 : suites.get(suiteDesc).push(testData);
3123 : 1 :
3124 : 1 : // TEST #14 - Method [get/set]CloudcoverAtDatetime()...test#1
3125 : 1 : testData = {};
3126 : 1 :
3127 [ + ]: 1 : testData.method = async () => {
3128 : 1 : let sample = JSON.parse(sampleActive);
3129 : 1 :
3130 : 1 : let weather = new Weather();
3131 : 1 : weather.setWeatherData(sample);
3132 : 1 :
3133 : 1 : let testDay, testTime, testCloudcover;
3134 : 1 :
3135 : 1 : testDay = sample.days[0].datetime;
3136 : 1 : testTime = sample.days[0].hours[0].datetime;
3137 : 1 : testCloudcover = 0;
3138 : 1 : weather.setCloudcoverAtDatetime(testDay, testTime, testCloudcover);
3139 : 1 : assert.strictEqual(weather.getCloudcoverAtDatetime(testDay, testTime), testCloudcover);
3140 : 1 :
3141 : 1 : testDay = 0;
3142 : 1 : testTime = 0;
3143 : 1 : testCloudcover = 10;
3144 : 1 : weather.setCloudcoverAtDatetime(testDay, testTime, testCloudcover);
3145 : 1 : assert.strictEqual(weather.getCloudcoverAtDatetime(testDay, testTime), testCloudcover);
3146 : 1 :
3147 : 1 : assert.strictEqual(weather.getCloudcoverAtDatetime(0, '24:00:00'), null);
3148 : 1 : assert.strictEqual(weather.getCloudcoverAtDatetime('1970-01-01', 0), null);
3149 : 1 : assert.strictEqual(weather.getCloudcoverAtDatetime(0, false), null);
3150 : 1 : assert.strictEqual(weather.getCloudcoverAtDatetime(false, false), null);
3151 : 1 :
3152 : 1 : assert.throws(
3153 [ + ]: 1 : () => {
3154 : 1 : weather.setCloudcoverAtDatetime(0, false, testCloudcover);
3155 : 1 : },
3156 [ + ]: 1 : (err) => {
3157 : 1 : assert(err instanceof TypeError);
3158 : 1 : return true;
3159 : 1 : }
3160 : 1 : );
3161 : 1 : assert.throws(
3162 [ + ]: 1 : () => {
3163 : 1 : weather.setCloudcoverAtDatetime(false, false, testCloudcover);
3164 : 1 : },
3165 [ + ]: 1 : (err) => {
3166 : 1 : assert(err instanceof TypeError);
3167 : 1 : return true;
3168 : 1 : }
3169 : 1 : );
3170 : 1 : };
3171 : 1 : testData.desc = 'Method [get/set]CloudcoverAtDatetime()...test#1';
3172 : 1 :
3173 : 1 : testData.skip = false;
3174 : 1 : suites.get(suiteDesc).push(testData);
3175 : 1 :
3176 : 1 : // TEST #15 - Method [get/set]VisibilityAtDatetime()...test#1
3177 : 1 : testData = {};
3178 : 1 :
3179 [ + ]: 1 : testData.method = async () => {
3180 : 1 : let sample = JSON.parse(sampleActive);
3181 : 1 :
3182 : 1 : let weather = new Weather();
3183 : 1 : weather.setWeatherData(sample);
3184 : 1 :
3185 : 1 : let testDay, testTime, testVisibility;
3186 : 1 :
3187 : 1 : testDay = sample.days[0].datetime;
3188 : 1 : testTime = sample.days[0].hours[0].datetime;
3189 : 1 : testVisibility = 0;
3190 : 1 : weather.setVisibilityAtDatetime(testDay, testTime, testVisibility);
3191 : 1 : assert.strictEqual(weather.getVisibilityAtDatetime(testDay, testTime), testVisibility);
3192 : 1 :
3193 : 1 : testDay = 0;
3194 : 1 : testTime = 0;
3195 : 1 : testVisibility = 10;
3196 : 1 : weather.setVisibilityAtDatetime(testDay, testTime, testVisibility);
3197 : 1 : assert.strictEqual(weather.getVisibilityAtDatetime(testDay, testTime), testVisibility);
3198 : 1 :
3199 : 1 : assert.strictEqual(weather.getVisibilityAtDatetime(0, '24:00:00'), null);
3200 : 1 : assert.strictEqual(weather.getVisibilityAtDatetime('1970-01-01', 0), null);
3201 : 1 : assert.strictEqual(weather.getVisibilityAtDatetime(0, false), null);
3202 : 1 : assert.strictEqual(weather.getVisibilityAtDatetime(false, false), null);
3203 : 1 :
3204 : 1 : assert.throws(
3205 [ + ]: 1 : () => {
3206 : 1 : weather.setVisibilityAtDatetime(0, false, testVisibility);
3207 : 1 : },
3208 [ + ]: 1 : (err) => {
3209 : 1 : assert(err instanceof TypeError);
3210 : 1 : return true;
3211 : 1 : }
3212 : 1 : );
3213 : 1 : assert.throws(
3214 [ + ]: 1 : () => {
3215 : 1 : weather.setVisibilityAtDatetime(false, false, testVisibility);
3216 : 1 : },
3217 [ + ]: 1 : (err) => {
3218 : 1 : assert(err instanceof TypeError);
3219 : 1 : return true;
3220 : 1 : }
3221 : 1 : );
3222 : 1 : };
3223 : 1 : testData.desc = 'Method [get/set]VisibilityAtDatetime()...test#1';
3224 : 1 :
3225 : 1 : testData.skip = false;
3226 : 1 : suites.get(suiteDesc).push(testData);
3227 : 1 :
3228 : 1 : // TEST #16 - Method [get/set]SolarradiationAtDatetime()...test#1
3229 : 1 : testData = {};
3230 : 1 :
3231 [ + ]: 1 : testData.method = async () => {
3232 : 1 : let sample = JSON.parse(sampleActive);
3233 : 1 :
3234 : 1 : let weather = new Weather();
3235 : 1 : weather.setWeatherData(sample);
3236 : 1 :
3237 : 1 : let testDay, testTime, testSolarradiation;
3238 : 1 :
3239 : 1 : testDay = sample.days[0].datetime;
3240 : 1 : testTime = sample.days[0].hours[0].datetime;
3241 : 1 : testSolarradiation = 0;
3242 : 1 : weather.setSolarradiationAtDatetime(testDay, testTime, testSolarradiation);
3243 : 1 : assert.strictEqual(weather.getSolarradiationAtDatetime(testDay, testTime), testSolarradiation);
3244 : 1 :
3245 : 1 : testDay = 0;
3246 : 1 : testTime = 0;
3247 : 1 : testSolarradiation = 10;
3248 : 1 : weather.setSolarradiationAtDatetime(testDay, testTime, testSolarradiation);
3249 : 1 : assert.strictEqual(weather.getSolarradiationAtDatetime(testDay, testTime), testSolarradiation);
3250 : 1 :
3251 : 1 : assert.strictEqual(weather.getSolarradiationAtDatetime(0, '24:00:00'), null);
3252 : 1 : assert.strictEqual(weather.getSolarradiationAtDatetime('1970-01-01', 0), null);
3253 : 1 : assert.strictEqual(weather.getSolarradiationAtDatetime(0, false), null);
3254 : 1 : assert.strictEqual(weather.getSolarradiationAtDatetime(false, false), null);
3255 : 1 :
3256 : 1 : assert.throws(
3257 [ + ]: 1 : () => {
3258 : 1 : weather.setSolarradiationAtDatetime(0, false, testSolarradiation);
3259 : 1 : },
3260 [ + ]: 1 : (err) => {
3261 : 1 : assert(err instanceof TypeError);
3262 : 1 : return true;
3263 : 1 : }
3264 : 1 : );
3265 : 1 : assert.throws(
3266 [ + ]: 1 : () => {
3267 : 1 : weather.setSolarradiationAtDatetime(false, false, testSolarradiation);
3268 : 1 : },
3269 [ + ]: 1 : (err) => {
3270 : 1 : assert(err instanceof TypeError);
3271 : 1 : return true;
3272 : 1 : }
3273 : 1 : );
3274 : 1 : };
3275 : 1 : testData.desc = 'Method [get/set]SolarradiationAtDatetime()...test#1';
3276 : 1 :
3277 : 1 : testData.skip = false;
3278 : 1 : suites.get(suiteDesc).push(testData);
3279 : 1 :
3280 : 1 : // TEST #17 - Method [get/set]SolarenergyAtDatetime()...test#1
3281 : 1 : testData = {};
3282 : 1 :
3283 [ + ]: 1 : testData.method = async () => {
3284 : 1 : let sample = JSON.parse(sampleActive);
3285 : 1 :
3286 : 1 : let weather = new Weather();
3287 : 1 : weather.setWeatherData(sample);
3288 : 1 :
3289 : 1 : let testDay, testTime, testSolarenergy;
3290 : 1 :
3291 : 1 : testDay = sample.days[0].datetime;
3292 : 1 : testTime = sample.days[0].hours[0].datetime;
3293 : 1 : testSolarenergy = 0;
3294 : 1 : weather.setSolarenergyAtDatetime(testDay, testTime, testSolarenergy);
3295 : 1 : assert.strictEqual(weather.getSolarenergyAtDatetime(testDay, testTime), testSolarenergy);
3296 : 1 :
3297 : 1 : testDay = 0;
3298 : 1 : testTime = 0;
3299 : 1 : testSolarenergy = 10;
3300 : 1 : weather.setSolarenergyAtDatetime(testDay, testTime, testSolarenergy);
3301 : 1 : assert.strictEqual(weather.getSolarenergyAtDatetime(testDay, testTime), testSolarenergy);
3302 : 1 :
3303 : 1 : assert.strictEqual(weather.getSolarenergyAtDatetime(0, '24:00:00'), null);
3304 : 1 : assert.strictEqual(weather.getSolarenergyAtDatetime('1970-01-01', 0), null);
3305 : 1 : assert.strictEqual(weather.getSolarenergyAtDatetime(0, false), null);
3306 : 1 : assert.strictEqual(weather.getSolarenergyAtDatetime(false, false), null);
3307 : 1 :
3308 : 1 : assert.throws(
3309 [ + ]: 1 : () => {
3310 : 1 : weather.setSolarenergyAtDatetime(0, false, testSolarenergy);
3311 : 1 : },
3312 [ + ]: 1 : (err) => {
3313 : 1 : assert(err instanceof TypeError);
3314 : 1 : return true;
3315 : 1 : }
3316 : 1 : );
3317 : 1 : assert.throws(
3318 [ + ]: 1 : () => {
3319 : 1 : weather.setSolarenergyAtDatetime(false, false, testSolarenergy);
3320 : 1 : },
3321 [ + ]: 1 : (err) => {
3322 : 1 : assert(err instanceof TypeError);
3323 : 1 : return true;
3324 : 1 : }
3325 : 1 : );
3326 : 1 : };
3327 : 1 : testData.desc = 'Method [get/set]SolarenergyAtDatetime()...test#1';
3328 : 1 :
3329 : 1 : testData.skip = false;
3330 : 1 : suites.get(suiteDesc).push(testData);
3331 : 1 :
3332 : 1 : // TEST #18 - Method [get/set]UvindexAtDatetime()...test#1
3333 : 1 : testData = {};
3334 : 1 :
3335 [ + ]: 1 : testData.method = async () => {
3336 : 1 : let sample = JSON.parse(sampleActive);
3337 : 1 :
3338 : 1 : let weather = new Weather();
3339 : 1 : weather.setWeatherData(sample);
3340 : 1 :
3341 : 1 : let testDay, testTime, testUvindex;
3342 : 1 :
3343 : 1 : testDay = sample.days[0].datetime;
3344 : 1 : testTime = sample.days[0].hours[0].datetime;
3345 : 1 : testUvindex = 0;
3346 : 1 : weather.setUvindexAtDatetime(testDay, testTime, testUvindex);
3347 : 1 : assert.strictEqual(weather.getUvindexAtDatetime(testDay, testTime), testUvindex);
3348 : 1 :
3349 : 1 : testDay = 0;
3350 : 1 : testTime = 0;
3351 : 1 : testUvindex = 10;
3352 : 1 : weather.setUvindexAtDatetime(testDay, testTime, testUvindex);
3353 : 1 : assert.strictEqual(weather.getUvindexAtDatetime(testDay, testTime), testUvindex);
3354 : 1 :
3355 : 1 : assert.strictEqual(weather.getUvindexAtDatetime(0, '24:00:00'), null);
3356 : 1 : assert.strictEqual(weather.getUvindexAtDatetime('1970-01-01', 0), null);
3357 : 1 : assert.strictEqual(weather.getUvindexAtDatetime(0, false), null);
3358 : 1 : assert.strictEqual(weather.getUvindexAtDatetime(false, false), null);
3359 : 1 :
3360 : 1 : assert.throws(
3361 [ + ]: 1 : () => {
3362 : 1 : weather.setUvindexAtDatetime(0, false, testUvindex);
3363 : 1 : },
3364 [ + ]: 1 : (err) => {
3365 : 1 : assert(err instanceof TypeError);
3366 : 1 : return true;
3367 : 1 : }
3368 : 1 : );
3369 : 1 : assert.throws(
3370 [ + ]: 1 : () => {
3371 : 1 : weather.setUvindexAtDatetime(false, false, testUvindex);
3372 : 1 : },
3373 [ + ]: 1 : (err) => {
3374 : 1 : assert(err instanceof TypeError);
3375 : 1 : return true;
3376 : 1 : }
3377 : 1 : );
3378 : 1 : };
3379 : 1 : testData.desc = 'Method [get/set]UvindexAtDatetime()...test#1';
3380 : 1 :
3381 : 1 : testData.skip = false;
3382 : 1 : suites.get(suiteDesc).push(testData);
3383 : 1 :
3384 : 1 : // TEST #19 - Method [get/set]SevereriskAtDatetime()...test#1
3385 : 1 : testData = {};
3386 : 1 :
3387 [ + ]: 1 : testData.method = async () => {
3388 : 1 : let sample = JSON.parse(sampleActive);
3389 : 1 :
3390 : 1 : let weather = new Weather();
3391 : 1 : weather.setWeatherData(sample);
3392 : 1 :
3393 : 1 : let testDay, testTime, testSevererisk;
3394 : 1 :
3395 : 1 : testDay = sample.days[0].datetime;
3396 : 1 : testTime = sample.days[0].hours[0].datetime;
3397 : 1 : testSevererisk = 0;
3398 : 1 : weather.setSevereriskAtDatetime(testDay, testTime, testSevererisk);
3399 : 1 : assert.strictEqual(weather.getSevereriskAtDatetime(testDay, testTime), testSevererisk);
3400 : 1 :
3401 : 1 : testDay = 0;
3402 : 1 : testTime = 0;
3403 : 1 : testSevererisk = 10;
3404 : 1 : weather.setSevereriskAtDatetime(testDay, testTime, testSevererisk);
3405 : 1 : assert.strictEqual(weather.getSevereriskAtDatetime(testDay, testTime), testSevererisk);
3406 : 1 :
3407 : 1 : assert.strictEqual(weather.getSevereriskAtDatetime(0, '24:00:00'), null);
3408 : 1 : assert.strictEqual(weather.getSevereriskAtDatetime('1970-01-01', 0), null);
3409 : 1 : assert.strictEqual(weather.getSevereriskAtDatetime(0, false), null);
3410 : 1 : assert.strictEqual(weather.getSevereriskAtDatetime(false, false), null);
3411 : 1 :
3412 : 1 : assert.throws(
3413 [ + ]: 1 : () => {
3414 : 1 : weather.setSevereriskAtDatetime(0, false, testSevererisk);
3415 : 1 : },
3416 [ + ]: 1 : (err) => {
3417 : 1 : assert(err instanceof TypeError);
3418 : 1 : return true;
3419 : 1 : }
3420 : 1 : );
3421 : 1 : assert.throws(
3422 [ + ]: 1 : () => {
3423 : 1 : weather.setSevereriskAtDatetime(false, false, testSevererisk);
3424 : 1 : },
3425 [ + ]: 1 : (err) => {
3426 : 1 : assert(err instanceof TypeError);
3427 : 1 : return true;
3428 : 1 : }
3429 : 1 : );
3430 : 1 : };
3431 : 1 : testData.desc = 'Method [get/set]SevereriskAtDatetime()...test#1';
3432 : 1 :
3433 : 1 : testData.skip = false;
3434 : 1 : suites.get(suiteDesc).push(testData);
3435 : 1 :
3436 : 1 : // TEST #20 - Method [get/set]StationsAtDatetime()...test#1
3437 : 1 : testData = {};
3438 : 1 :
3439 [ + ]: 1 : testData.method = async () => {
3440 : 1 : let sample = JSON.parse(sampleActive);
3441 : 1 :
3442 : 1 : let weather = new Weather();
3443 : 1 : weather.setWeatherData(sample);
3444 : 1 :
3445 : 1 : let testDay, testTime, testStations;
3446 : 1 :
3447 : 1 : testDay = sample.days[0].datetime;
3448 : 1 : testTime = sample.days[0].hours[0].datetime;
3449 : 1 : testStations = ['station#1'];
3450 : 1 : weather.setStationsAtDatetime(testDay, testTime, testStations);
3451 : 1 : assert.strictEqual(weather.getStationsAtDatetime(testDay, testTime), testStations);
3452 : 1 :
3453 : 1 : testDay = 0;
3454 : 1 : testTime = 0;
3455 : 1 : testStations = ['station#2'];
3456 : 1 : weather.setStationsAtDatetime(testDay, testTime, testStations);
3457 : 1 : assert.strictEqual(weather.getStationsAtDatetime(testDay, testTime), testStations);
3458 : 1 :
3459 : 1 : assert.strictEqual(weather.getStationsAtDatetime(0, '24:00:00'), null);
3460 : 1 : assert.strictEqual(weather.getStationsAtDatetime('1970-01-01', 0), null);
3461 : 1 : assert.strictEqual(weather.getStationsAtDatetime(0, false), null);
3462 : 1 : assert.strictEqual(weather.getStationsAtDatetime(false, false), null);
3463 : 1 :
3464 : 1 : assert.throws(
3465 [ + ]: 1 : () => {
3466 : 1 : weather.setStationsAtDatetime(0, false, testStations);
3467 : 1 : },
3468 [ + ]: 1 : (err) => {
3469 : 1 : assert(err instanceof TypeError);
3470 : 1 : return true;
3471 : 1 : }
3472 : 1 : );
3473 : 1 : assert.throws(
3474 [ + ]: 1 : () => {
3475 : 1 : weather.setStationsAtDatetime(false, false, testStations);
3476 : 1 : },
3477 [ + ]: 1 : (err) => {
3478 : 1 : assert(err instanceof TypeError);
3479 : 1 : return true;
3480 : 1 : }
3481 : 1 : );
3482 : 1 : };
3483 : 1 : testData.desc = 'Method [get/set]StationsAtDatetime()...test#1';
3484 : 1 :
3485 : 1 : testData.skip = false;
3486 : 1 : suites.get(suiteDesc).push(testData);
3487 : 1 :
3488 : 1 : // TEST #21 - Method [get/set]SourceAtDatetime()...test#1
3489 : 1 : testData = {};
3490 : 1 :
3491 [ + ]: 1 : testData.method = async () => {
3492 : 1 : let sample = JSON.parse(sampleActive);
3493 : 1 :
3494 : 1 : let weather = new Weather();
3495 : 1 : weather.setWeatherData(sample);
3496 : 1 :
3497 : 1 : let testDay, testTime, testSource;
3498 : 1 :
3499 : 1 : testDay = sample.days[0].datetime;
3500 : 1 : testTime = sample.days[0].hours[0].datetime;
3501 : 1 : testSource = 'source#1';
3502 : 1 : weather.setSourceAtDatetime(testDay, testTime, testSource);
3503 : 1 : assert.strictEqual(weather.getSourceAtDatetime(testDay, testTime), testSource);
3504 : 1 :
3505 : 1 : testDay = 0;
3506 : 1 : testTime = 0;
3507 : 1 : testSource = 'source#2';
3508 : 1 : weather.setSourceAtDatetime(testDay, testTime, testSource);
3509 : 1 : assert.strictEqual(weather.getSourceAtDatetime(testDay, testTime), testSource);
3510 : 1 :
3511 : 1 : assert.strictEqual(weather.getSourceAtDatetime(0, '24:00:00'), null);
3512 : 1 : assert.strictEqual(weather.getSourceAtDatetime('1970-01-01', 0), null);
3513 : 1 : assert.strictEqual(weather.getSourceAtDatetime(0, false), null);
3514 : 1 : assert.strictEqual(weather.getSourceAtDatetime(false, false), null);
3515 : 1 :
3516 : 1 : assert.throws(
3517 [ + ]: 1 : () => {
3518 : 1 : weather.setSourceAtDatetime(0, false, testSource);
3519 : 1 : },
3520 [ + ]: 1 : (err) => {
3521 : 1 : assert(err instanceof TypeError);
3522 : 1 : return true;
3523 : 1 : }
3524 : 1 : );
3525 : 1 : assert.throws(
3526 [ + ]: 1 : () => {
3527 : 1 : weather.setSourceAtDatetime(false, false, testSource);
3528 : 1 : },
3529 [ + ]: 1 : (err) => {
3530 : 1 : assert(err instanceof TypeError);
3531 : 1 : return true;
3532 : 1 : }
3533 : 1 : );
3534 : 1 : };
3535 : 1 : testData.desc = 'Method [get/set]SourceAtDatetime()...test#1';
3536 : 1 :
3537 : 1 : testData.skip = false;
3538 : 1 : suites.get(suiteDesc).push(testData);
3539 : 1 :
3540 : 1 : // TEST SUITE #10 - Test Weather Instance Methods - Description elements at datetime
3541 : 1 : suiteDesc = 'Test Weather Instance Methods - Description elements at datetime';
3542 : 1 : suites.set(suiteDesc, []);
3543 : 1 :
3544 : 1 : // TEST #01 - Method [get/set]ConditionsAtDatetime()...test#1
3545 : 1 : testData = {};
3546 : 1 :
3547 [ + ]: 1 : testData.method = async () => {
3548 : 1 : let sample = JSON.parse(sampleActive);
3549 : 1 :
3550 : 1 : let weather = new Weather();
3551 : 1 : weather.setWeatherData(sample);
3552 : 1 :
3553 : 1 : let testDay, testTime, testConditions;
3554 : 1 :
3555 : 1 : testDay = sample.days[0].datetime;
3556 : 1 : testTime = sample.days[0].hours[0].datetime;
3557 : 1 : testConditions = 'cond#1';
3558 : 1 : weather.setConditionsAtDatetime(testDay, testTime, testConditions);
3559 : 1 : assert.strictEqual(weather.getConditionsAtDatetime(testDay, testTime), testConditions);
3560 : 1 :
3561 : 1 : testDay = 0;
3562 : 1 : testTime = 0;
3563 : 1 : testConditions = 'cond#2';
3564 : 1 : weather.setConditionsAtDatetime(testDay, testTime, testConditions);
3565 : 1 : assert.strictEqual(weather.getConditionsAtDatetime(testDay, testTime), testConditions);
3566 : 1 :
3567 : 1 : assert.strictEqual(weather.getConditionsAtDatetime(0, '24:00:00'), null);
3568 : 1 : assert.strictEqual(weather.getConditionsAtDatetime('1970-01-01', 0), null);
3569 : 1 : assert.strictEqual(weather.getConditionsAtDatetime(0, false), null);
3570 : 1 : assert.strictEqual(weather.getConditionsAtDatetime(false, false), null);
3571 : 1 :
3572 : 1 : assert.throws(
3573 [ + ]: 1 : () => {
3574 : 1 : weather.setConditionsAtDatetime(0, false, testConditions);
3575 : 1 : },
3576 [ + ]: 1 : (err) => {
3577 : 1 : assert(err instanceof TypeError);
3578 : 1 : return true;
3579 : 1 : }
3580 : 1 : );
3581 : 1 : assert.throws(
3582 [ + ]: 1 : () => {
3583 : 1 : weather.setConditionsAtDatetime(false, false, testConditions);
3584 : 1 : },
3585 [ + ]: 1 : (err) => {
3586 : 1 : assert(err instanceof TypeError);
3587 : 1 : return true;
3588 : 1 : }
3589 : 1 : );
3590 : 1 : };
3591 : 1 : testData.desc = 'Method [get/set]ConditionsAtDatetime()...test#1';
3592 : 1 :
3593 : 1 : testData.skip = false;
3594 : 1 : suites.get(suiteDesc).push(testData);
3595 : 1 :
3596 : 1 : // TEST #02 - Method [get/set]IconAtDatetime()...test#1
3597 : 1 : testData = {};
3598 : 1 :
3599 [ + ]: 1 : testData.method = async () => {
3600 : 1 : let sample = JSON.parse(sampleActive);
3601 : 1 :
3602 : 1 : let weather = new Weather();
3603 : 1 : weather.setWeatherData(sample);
3604 : 1 :
3605 : 1 : let testDay, testTime, testIcon;
3606 : 1 :
3607 : 1 : testDay = sample.days[0].datetime;
3608 : 1 : testTime = sample.days[0].hours[0].datetime;
3609 : 1 : testIcon = 'icon#1';
3610 : 1 : weather.setIconAtDatetime(testDay, testTime, testIcon);
3611 : 1 : assert.strictEqual(weather.getIconAtDatetime(testDay, testTime), testIcon);
3612 : 1 :
3613 : 1 : testDay = 0;
3614 : 1 : testTime = 0;
3615 : 1 : testIcon = 'icon#2';
3616 : 1 : weather.setIconAtDatetime(testDay, testTime, testIcon);
3617 : 1 : assert.strictEqual(weather.getIconAtDatetime(testDay, testTime), testIcon);
3618 : 1 :
3619 : 1 : assert.strictEqual(weather.getIconAtDatetime(0, '24:00:00'), null);
3620 : 1 : assert.strictEqual(weather.getIconAtDatetime('1970-01-01', 0), null);
3621 : 1 : assert.strictEqual(weather.getIconAtDatetime(0, false), null);
3622 : 1 : assert.strictEqual(weather.getIconAtDatetime(false, false), null);
3623 : 1 :
3624 : 1 : assert.throws(
3625 [ + ]: 1 : () => {
3626 : 1 : weather.setIconAtDatetime(0, false, testIcon);
3627 : 1 : },
3628 [ + ]: 1 : (err) => {
3629 : 1 : assert(err instanceof TypeError);
3630 : 1 : return true;
3631 : 1 : }
3632 : 1 : );
3633 : 1 : assert.throws(
3634 [ + ]: 1 : () => {
3635 : 1 : weather.setIconAtDatetime(false, false, testIcon);
3636 : 1 : },
3637 [ + ]: 1 : (err) => {
3638 : 1 : assert(err instanceof TypeError);
3639 : 1 : return true;
3640 : 1 : }
3641 : 1 : );
3642 : 1 : };
3643 : 1 : testData.desc = 'Method [get/set]IconAtDatetime()...test#1';
3644 : 1 :
3645 : 1 : testData.skip = false;
3646 : 1 : suites.get(suiteDesc).push(testData);
3647 : 1 : }
3648 : 1 :
3649 : 1 : /**
3650 : 1 : * @func nodeRunner
3651 : 1 : * @param {object} runner - The node core module 'node:test' object.
3652 : 1 : * @desc Carry out the loaded tests using node test runner.
3653 : 1 : */
3654 [ + ]: 1 : function nodeRunner(runner){
3655 : 1 :
3656 [ + ]: 1 : for(let [suiteDesc, suiteTests] of suites){
3657 [ + ]: 10 : runner.suite(suiteDesc, () => {
3658 [ + ]: 10 : for(let cmdObj of suiteTests){
3659 [ + ]: 90 : runner.test(cmdObj.desc, {skip: cmdObj.skip}, async () => {
3660 : 90 : await makeTest(cmdObj);
3661 : 90 : });
3662 : 90 : }
3663 : 10 : });
3664 : 10 : }
3665 : 1 : }
3666 : 1 : /* node:coverage disable */
3667 : :
3668 : : /**
3669 : : * @func defRunner
3670 : : * @desc Carry out the loaded tests using this developed test runner.
3671 : : */
3672 : : function defRunner(){
3673 : :
3674 : : cmdOptions.verbose && process.on('exit', () => {
3675 : : console.log();
3676 : : console.log('▶ tests', --testCount);
3677 : : console.log('▶ suites', suites.size);
3678 : : console.log('▶ pass', passCount);
3679 : : console.log('▶ fail', failCount);
3680 : : console.log('▶ cancelled', cancelCount);
3681 : : console.log('▶ skipped', skipCount);
3682 : : console.log('▶ todo', todoCount);
3683 : : console.log('▶ duration_ms', Math.round(Date.now() - startTime));
3684 : : });
3685 : :
3686 : : cmdOptions.verbose && console.error();
3687 : : for(let [suiteDesc, suiteTests] of suites)
3688 : : for(let cmdObj of suiteTests)
3689 : : if(!cmdObj.skip){
3690 : : (async() => {
3691 : : await makeTest(cmdObj);
3692 : : })();
3693 : : }
3694 : :
3695 : : cmdOptions.verbose && console.log();
3696 : : }
3697 : : /* node:coverage enable */
3698 : 1 :
3699 : 1 : /**
3700 : 1 : * @func makeTest
3701 : 1 : * @async
3702 : 1 : * @param {object} obj - The test data object.
3703 : 1 : * @desc Carry out a single test.
3704 : 1 : */
3705 [ + ]: 90 : async function makeTest(obj){
3706 : 90 :
3707 : 90 : const testID = testCount++;
3708 : 90 :
3709 : 90 : let preMsg = `Test#${(testID).toString().padStart(3, '0')} ... `;
3710 : 90 : let postMsg = preMsg;
3711 : 90 :
3712 : 90 : preMsg += `Initiate ... ${obj.desc}`;
3713 [ - ]: 90 : cmdOptions.verbose && console.error(preMsg);
3714 : 90 :
3715 : 90 : if(!cmdOptions.verbose){
3716 : 90 : await obj.method();
3717 [ - ]: 90 : } /* node:coverage disable */
3718 : : else{
3719 : : try{
3720 : : await obj.method();
3721 : : passCount++;
3722 : :
3723 : : postMsg += `Success ... ${obj.desc}`;
3724 : : cmdOptions.verbose && console.error(postMsg);
3725 : : }
3726 : : catch(e){
3727 : : failCount++;
3728 : :
3729 : : postMsg += `Failure ... ${obj.desc}`;
3730 : : cmdOptions.verbose && console.error(postMsg);
3731 : : }
3732 : : } /* node:coverage enable */
3733 : 90 : }
|
