UNPKG

29 kBJavaScriptView Raw
1"use strict";
2
3var dataType = require('../src/dataType.js')
4, transformers = require('../src/transformers.js')
5, defines = require('../src/defines.js')
6, chai = require('chai')
7, chaiAsPromised = require('chai-as-promised');
8
9chai.Should();
10chai.use(chaiAsPromised);
11require("mocha-as-promised")();
12
13describe('dataType', function() {
14
15 var datasetTransformer, pgsqlTransformer;
16
17 before(function() {
18 datasetTransformer = transformers.getDataSetTransformer();
19 pgsqlTransformer = transformers.getPgSqlTransformer();
20 });
21
22 describe('#isStringInteger()', function() {
23 it('should correctly identify integers', function() {
24 dataType.isStringInteger(datasetTransformer, '1').should.be.true;
25 dataType.isStringInteger(datasetTransformer, '01').should.be.true;
26 dataType.isStringInteger(datasetTransformer, '-1').should.be.true;
27 dataType.isStringInteger(datasetTransformer, '-9').should.be.true;
28 // Handle cases where excel appends .0 to the end of integers
29 dataType.isStringInteger(datasetTransformer, '1.0').should.be.true;
30 dataType.isStringInteger(datasetTransformer, '-1.0').should.be.true;
31 });
32 it('should fail to find integers', function() {
33 dataType.isStringInteger(datasetTransformer, 'hello').should.be.false;
34 dataType.isStringInteger(datasetTransformer, '2010-10-10').should.be.false;
35 });
36 it('should fail to find integers (leading zero flag)', function() {
37 dataType.isStringInteger(datasetTransformer, '01', true).should.be.false;
38 });
39 it('should fail to find integers (ignore types)', function() {
40 var testTransformer = transformers.getDataSetTransformer({
41 ignoreTypes: [defines.INTEGER]
42 });
43 dataType.isStringInteger(testTransformer, '1').should.be.false;
44 });
45 it('should handle e notation', function() {
46 dataType.isStringInteger(datasetTransformer, '1.5e1').should.be.true;
47 });
48 });
49
50 describe('#isStringBigInteger()', function() {
51 it('should detect that integers greater than +2147483647 are big', function() {
52 dataType.isStringBigInteger(datasetTransformer, '2147483647').should.be.false;
53 dataType.isStringBigInteger(datasetTransformer, '2147483648').should.be.true;
54 });
55 it('should detect that integers less than -2147483648 are big', function() {
56 dataType.isStringBigInteger(datasetTransformer, '-2147483648').should.be.false;
57 dataType.isStringBigInteger(datasetTransformer, '-2147483649').should.be.true;
58 });
59 it('should fail to find big integers (ignore types)', function() {
60 var testTransformer = transformers.getDataSetTransformer({
61 ignoreTypes: [defines.BIGINTEGER]
62 });
63 dataType.isStringInteger(testTransformer, '1').should.be.true;
64 dataType.isStringBigInteger(testTransformer, '2147483648').should.be.false;
65 });
66 it('should fail to find big integers', function() {
67 dataType.isStringBigInteger(datasetTransformer, '2010-10-10').should.be.false;
68 });
69 it('should handle e notation', function() {
70 dataType.isStringBigInteger(datasetTransformer, '214748364.8e1').should.be.true;
71 });
72 });
73
74 describe('#isStringNumeric()', function() {
75 it('should correctly identify numerics', function() {
76 dataType.isStringNumeric(datasetTransformer, '.0').should.be.true;
77 dataType.isStringNumeric(datasetTransformer, '0.0').should.be.true;
78 dataType.isStringNumeric(datasetTransformer, '1.0').should.be.true;
79 dataType.isStringNumeric(datasetTransformer, '-1.0').should.be.true;
80 });
81 it('should fail to find numerics', function() {
82 dataType.isStringNumeric(datasetTransformer, 'hello').should.be.false;
83 dataType.isStringNumeric(datasetTransformer, '1').should.be.false;
84 dataType.isStringNumeric(datasetTransformer, '2010-10-10').should.be.false;
85 });
86 it('should fail to find numeric (ignore types)', function() {
87 var testTransformer = transformers.getDataSetTransformer({
88 ignoreTypes: [defines.NUMERIC]
89 });
90 dataType.isStringNumeric(testTransformer, '1.7').should.be.false;
91 });
92 it('should handle e notation', function() {
93 dataType.isStringNumeric(datasetTransformer, '1.55555e1').should.be.true;
94 });
95 });
96
97 describe('#isStringNumber()', function() {
98 it('should correctly identify numbers (ints + decimals)', function() {
99 dataType.isStringNumber(datasetTransformer, '.0').should.be.true;
100 dataType.isStringNumber(datasetTransformer, '0').should.be.true;
101 dataType.isStringNumber(datasetTransformer, '11').should.be.true;
102 dataType.isStringNumber(datasetTransformer, '1.0').should.be.true;
103 });
104 it('should fail to find numbers', function() {
105 dataType.isStringNumber(datasetTransformer, 'hello').should.be.false;
106 dataType.isStringNumber(datasetTransformer, 'true').should.be.false;
107 dataType.isStringNumber(datasetTransformer, '2010-10-10').should.be.false;
108 });
109 it('should fail to find numbers (ignore types)', function() {
110 var testTransformer = transformers.getDataSetTransformer({
111 ignoreTypes: [defines.NUMERIC]
112 });
113 dataType.isStringNumber(testTransformer, '1.7').should.be.false;
114 dataType.isStringNumber(testTransformer, '1').should.be.true;
115 });
116 it('should handle e notation', function() {
117 dataType.isStringNumber(datasetTransformer, '1e1').should.be.true;
118 });
119 });
120
121 describe('#isStringBoolean()', function() {
122 it('should correctly identify booleans (DATASET defaults)', function() {
123 dataType.isStringBoolean(datasetTransformer, '1').should.be.true;
124 dataType.isStringBoolean(datasetTransformer, '0').should.be.true;
125 dataType.isStringBoolean(datasetTransformer, 'true').should.be.true;
126 dataType.isStringBoolean(datasetTransformer, 'TRUE').should.be.true;
127 dataType.isStringBoolean(datasetTransformer, 'false').should.be.true;
128 dataType.isStringBoolean(datasetTransformer, 'FALSE').should.be.true;
129 dataType.isStringBoolean(datasetTransformer, 't').should.be.true;
130 dataType.isStringBoolean(datasetTransformer, 'T').should.be.true;
131 dataType.isStringBoolean(datasetTransformer, 'f').should.be.true;
132 dataType.isStringBoolean(datasetTransformer, 'F').should.be.true;
133 dataType.isStringBoolean(datasetTransformer, 'yes').should.be.true;
134 dataType.isStringBoolean(datasetTransformer, 'YES').should.be.true;
135 dataType.isStringBoolean(datasetTransformer, 'no').should.be.true;
136 dataType.isStringBoolean(datasetTransformer, 'NO').should.be.true;
137 dataType.isStringBoolean(datasetTransformer, 'y').should.be.true;
138 dataType.isStringBoolean(datasetTransformer, 'Y').should.be.true;
139 dataType.isStringBoolean(datasetTransformer, 'n').should.be.true;
140 dataType.isStringBoolean(datasetTransformer, 'N').should.be.true;
141 });
142 it('should fail to find booleans', function() {
143 dataType.isStringBoolean(datasetTransformer, 'hello').should.be.false;
144 dataType.isStringBoolean(datasetTransformer, '2').should.be.false;
145 dataType.isStringBoolean(datasetTransformer, '4').should.be.false;
146 });
147 it('should fail to find boolean (ignore types)', function() {
148 var testTransformer = transformers.getDataSetTransformer({
149 ignoreTypes: [defines.BOOLEAN]
150 });
151 dataType.isStringBoolean(testTransformer, 'true').should.be.false;
152 });
153 it('should fail to find boolean (old string is not a boolean)', function() {
154 dataType.isStringBoolean(datasetTransformer, 'true').should.be.true;
155 dataType.isStringBoolean(datasetTransformer, 'true', 'foo').should.be.false;
156 });
157 });
158
159 describe('#isStringEmpty()', function() {
160 it('should detect empty strings', function() {
161 dataType.isStringEmpty(datasetTransformer, ' ').should.be.true;
162 dataType.isStringEmpty(datasetTransformer, '').should.be.true;
163 dataType.isStringEmpty(datasetTransformer, '\n').should.be.true;
164 dataType.isStringEmpty(datasetTransformer, ' \n ').should.be.true;
165 });
166 it('should fail to detect empty strings', function() {
167 dataType.isStringEmpty(datasetTransformer, ' hello ')
168 .should.be.false;
169 });
170 it('should detect weird Google Doc strings', function() {
171 dataType.isStringEmpty(datasetTransformer, '#REF!:emptyRange')
172 .should.be.true;
173 });
174 });
175
176 describe('#isStringZip()', function() {
177 it('should detect zip codes', function() {
178 dataType.isStringZip(datasetTransformer, '00000').should.be.true;
179 dataType.isStringZip(datasetTransformer, '00000-0000').should.be.true;
180 dataType.isStringZip(datasetTransformer, '000000000').should.be.true;
181 dataType.isStringZip(datasetTransformer, '12345').should.be.true;
182 dataType.isStringZip(datasetTransformer, '12345-6789').should.be.true;
183 dataType.isStringZip(datasetTransformer, '123456789').should.be.true;
184 });
185 it('should fail to detect zip codes', function() {
186 dataType.isStringZip(datasetTransformer, '1234567890').should.be.false;
187 dataType.isStringZip(datasetTransformer, '1234').should.be.false;
188 dataType.isStringZip(datasetTransformer, ' not a zip code ').should.be.false;
189 dataType.isStringZip(datasetTransformer, '').should.be.false;
190 });
191 it('should fail to find zip (ignore types)', function() {
192 var testTransformer = transformers.getDataSetTransformer({
193 ignoreTypes: [defines.ZIP]
194 });
195 dataType.isStringZip(testTransformer, '12345').should.be.false;
196 });
197 });
198
199 describe('#isStringLat()', function() {
200 it('should detect latitudes', function() {
201 dataType.isStringLat(datasetTransformer, '0.0').should.be.true;
202 dataType.isStringLat(datasetTransformer, '90.0').should.be.true;
203 dataType.isStringLat(datasetTransformer, '-90.0').should.be.true;
204 dataType.isStringLat(datasetTransformer, '89.99').should.be.true;
205 });
206 it('should fail to detect latitudes', function() {
207 dataType.isStringLat(datasetTransformer, '85').should.be.false; // missing decimal
208 dataType.isStringLat(datasetTransformer, '90.1').should.be.false;
209 dataType.isStringLat(datasetTransformer, '-90.1').should.be.false;
210 dataType.isStringLat(datasetTransformer, '').should.be.false;
211 dataType.isStringLat(datasetTransformer, 'hello').should.be.false;
212 });
213 it('should fail to find latitudes (ignore types)', function() {
214 var testTransformer = transformers.getDataSetTransformer({
215 ignoreTypes: [defines.LAT]
216 });
217 dataType.isStringLat(testTransformer, '90.0').should.be.false;
218 });
219 });
220
221 describe('#isStringLong()', function() {
222 it('should detect longitudes', function() {
223 dataType.isStringLong(datasetTransformer, '0.0').should.be.true;
224 dataType.isStringLong(datasetTransformer, '90.0').should.be.true;
225 dataType.isStringLong(datasetTransformer, '-90.0').should.be.true;
226 dataType.isStringLong(datasetTransformer, '180.0').should.be.true;
227 dataType.isStringLong(datasetTransformer, '-180.0').should.be.true;
228 dataType.isStringLong(datasetTransformer, '-179.9999').should.be.true;
229 });
230 it('should fail to detect longitudes', function() {
231 dataType.isStringLong(datasetTransformer, '85').should.be.false; // missing decimal
232 dataType.isStringLong(datasetTransformer, '180.1').should.be.false;
233 dataType.isStringLong(datasetTransformer, '-180.1').should.be.false;
234 dataType.isStringLong(datasetTransformer, '').should.be.false;
235 dataType.isStringLong(datasetTransformer, 'hello').should.be.false;
236 });
237 it('should fail to find longitudes (ignore types)', function() {
238 var testTransformer = transformers.getDataSetTransformer({
239 ignoreTypes: [defines.LONG]
240 });
241 dataType.isStringLong(testTransformer, '90.0').should.be.false;
242 });
243 });
244
245 describe('#isStringPrimaryInteger', function() {
246 it('should be a primary integer', function() {
247 dataType.isStringPrimaryInteger(datasetTransformer, '1').should.be.true;
248 dataType.isStringPrimaryInteger(datasetTransformer, '2', '1').should.be.true;
249 dataType.isStringPrimaryInteger(datasetTransformer, '500', '100').should.be.true;
250 dataType.isStringPrimaryInteger(datasetTransformer, '-500', '-1000').should.be.true;
251 });
252 it('should not be a primary integer', function() {
253 dataType.isStringPrimaryInteger(datasetTransformer, '2147483648').should.be.false;
254 dataType.isStringPrimaryInteger(datasetTransformer, '1', '300').should.be.false;
255 dataType.isStringPrimaryInteger(datasetTransformer, 'hello', '300').should.be.false;
256 dataType.isStringPrimaryInteger(datasetTransformer, 'hello').should.be.false;
257 });
258 it('should fail to find primary integer (ignore types)', function() {
259 var testTransformer = transformers.getDataSetTransformer({
260 ignoreTypes: [defines.PRIMARY_INTEGER]
261 });
262 dataType.isStringPrimaryInteger(testTransformer, '500').should.be.false;
263 });
264 });
265
266 describe('#getNewDataType', function() {
267 it('should return type PRIMARY_INT (empty)', function() {
268 dataType.getNewDataType(datasetTransformer, undefined, '1')
269 .should.eql(defines.PRIMARY_INTEGER);
270 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '1')
271 .should.eql(defines.PRIMARY_INTEGER);
272 });
273 it('should return type LAT (empty)', function() {
274 dataType.getNewDataType(datasetTransformer, undefined, '89.99')
275 .should.eql(defines.LAT);
276 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '-89.99')
277 .should.eql(defines.LAT);
278 });
279 it('should return type LONG (empty)', function() {
280 dataType.getNewDataType(datasetTransformer, undefined, '179.99')
281 .should.eql(defines.LONG);
282 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '-179.99')
283 .should.eql(defines.LONG);
284 });
285 // Can't test this anymore due to adding in PRIMARY_INT
286 // PRIMARY_INT always assumes that any starting integer is primary
287 it.skip('should return type ZIP (empty)', function() {
288 dataType.getNewDataType(datasetTransformer, undefined, '12345')
289 .should.eql(defines.ZIP);
290 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '000000000')
291 .should.eql(defines.ZIP);
292 dataType.getNewDataType(datasetTransformer, undefined, '12345-6789')
293 .should.eql(defines.ZIP);
294 });
295 it('should return type BIGINTEGER (empty)', function() {
296 dataType.getNewDataType(datasetTransformer, undefined, '2147483648')
297 .should.eql(defines.BIGINTEGER);
298 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '2147483648')
299 .should.eql(defines.BIGINTEGER);
300 dataType.getNewDataType(datasetTransformer, undefined, '-2147483649')
301 .should.eql(defines.BIGINTEGER);
302 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '-2147483649')
303 .should.eql(defines.BIGINTEGER);
304 });
305 // Can't test this anymore due to adding in PRIMARY_INT
306 // PRIMARY_INT always assumes that any starting integer is primary
307 it.skip('should return type INTEGER (empty)', function() {
308 dataType.getNewDataType(datasetTransformer, undefined, '100')
309 .should.eql(defines.INTEGER);
310 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '100')
311 .should.eql(defines.INTEGER);
312 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '2147483647')
313 .should.eql(defines.INTEGER);
314 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '2147483647')
315 .should.eql(defines.INTEGER);
316 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '-2147483648')
317 .should.eql(defines.INTEGER);
318 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '-2147483648')
319 .should.eql(defines.INTEGER);
320 });
321 it('should return type NUMERIC (empty)', function() {
322 dataType.getNewDataType(datasetTransformer, undefined, '1000.1')
323 .should.eql(defines.NUMERIC);
324 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, '1000.2')
325 .should.eql(defines.NUMERIC);
326 });
327 it('should return type BOOLEAN (empty)', function() {
328 dataType.getNewDataType(datasetTransformer, undefined, 'true')
329 .should.eql(defines.BOOLEAN);
330 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, 'false')
331 .should.eql(defines.BOOLEAN);
332 });
333 it('should return type TEXT (empty)', function() {
334 dataType.getNewDataType(datasetTransformer, undefined, 'hello')
335 .should.eql(defines.TEXT);
336 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, 'test')
337 .should.eql(defines.TEXT);
338 });
339
340 it('should keep BOOLEAN type', function() {
341 dataType.getNewDataType(datasetTransformer, defines.BOOLEAN, 'false')
342 .should.eql(defines.BOOLEAN);
343 });
344 it('should keep BOOLEAN type (empty string)', function() {
345 dataType.getNewDataType(datasetTransformer, defines.BOOLEAN, '')
346 .should.eql(defines.BOOLEAN);
347 dataType.getNewDataType(datasetTransformer, defines.BOOLEAN, '\n')
348 .should.eql(defines.BOOLEAN);
349 });
350 it('should convert BOOLEAN to INTEGER', function() {
351 dataType.getNewDataType(datasetTransformer, defines.BOOLEAN, '100')
352 .should.eql(defines.INTEGER);
353 });
354 it('should convert BOOLEAN to BIGINTEGER', function() {
355 dataType.getNewDataType(datasetTransformer, defines.BOOLEAN, '2147483648')
356 .should.eql(defines.BIGINTEGER);
357 });
358 it('should convert BOOLEAN to TEXT', function() {
359 dataType.getNewDataType(datasetTransformer, defines.BOOLEAN, 'hello')
360 .should.eql(defines.TEXT);
361 });
362
363 it('should keep INTEGER type', function() {
364 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '100')
365 .should.eql(defines.INTEGER);
366 // shouldn't care about boolean types of "0" and "1"
367 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '1')
368 .should.eql(defines.INTEGER);
369 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '0')
370 .should.eql(defines.INTEGER);
371 });
372 it('should keep INTEGER type (empty string)', function() {
373 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '')
374 .should.eql(defines.INTEGER);
375 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '\n')
376 .should.eql(defines.INTEGER);
377 });
378 it('should convert INTEGER to BIGINTEGER', function() {
379 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '2147483648')
380 .should.eql(defines.BIGINTEGER);
381 });
382 it('should convert INTEGER to NUMERIC', function() {
383 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '1550.1')
384 .should.eql(defines.NUMERIC);
385 });
386 it('should convert INTEGER to LAT', function() {
387 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '85.1')
388 .should.eql(defines.LAT);
389 });
390 it('should convert INTEGER to LONG', function() {
391 dataType.getNewDataType(datasetTransformer, defines.INTEGER, '179.1')
392 .should.eql(defines.LONG);
393 });
394 it('should convert INTEGER to TEXT', function() {
395 dataType.getNewDataType(datasetTransformer, defines.INTEGER, 'hello')
396 .should.eql(defines.TEXT);
397 });
398
399 it('should keep BIGINTEGER type', function() {
400 dataType.getNewDataType(datasetTransformer, defines.BIGINTEGER, '2147483648')
401 .should.eql(defines.BIGINTEGER);
402 dataType.getNewDataType(datasetTransformer, defines.BIGINTEGER, '100')
403 .should.eql(defines.BIGINTEGER);
404 dataType.getNewDataType(datasetTransformer, defines.BIGINTEGER, '1')
405 .should.eql(defines.BIGINTEGER);
406 });
407 it('should keep BIGINTEGER type (empty string)', function() {
408 dataType.getNewDataType(datasetTransformer, defines.BIGINTEGER, '')
409 .should.eql(defines.BIGINTEGER);
410 dataType.getNewDataType(datasetTransformer, defines.BIGINTEGER, '\n')
411 .should.eql(defines.BIGINTEGER);
412 });
413 it('should convert BIGINTEGER to NUMERIC', function() {
414 dataType.getNewDataType(datasetTransformer, defines.BIGINTEGER, '10.1')
415 .should.eql(defines.NUMERIC);
416 });
417 it('should convert BIGINTEGER to TEXT', function() {
418 dataType.getNewDataType(datasetTransformer, defines.BIGINTEGER, 'hello')
419 .should.eql(defines.TEXT);
420 });
421
422 it('should keep NUMERIC type', function() {
423 dataType.getNewDataType(datasetTransformer, defines.NUMERIC, '5.5')
424 .should.eql(defines.NUMERIC);
425 // Keep numeric even though we ran into an integer
426 dataType.getNewDataType(datasetTransformer, defines.NUMERIC, '5')
427 .should.eql(defines.NUMERIC);
428 });
429 it('should keep NUMERIC type (empty string)', function() {
430 dataType.getNewDataType(datasetTransformer, defines.NUMERIC, '')
431 .should.eql(defines.NUMERIC);
432 dataType.getNewDataType(datasetTransformer, defines.NUMERIC, '\n')
433 .should.eql(defines.NUMERIC);
434 });
435 it('should convert NUMERIC to TEXT', function() {
436 dataType.getNewDataType(datasetTransformer, defines.NUMERIC, 'hello')
437 .should.eql(defines.TEXT);
438 });
439
440 it('should keep TEXT type', function() {
441 dataType.getNewDataType(datasetTransformer, defines.TEXT, 'hello')
442 .should.eql(defines.TEXT);
443 // Keep text even though we've encountered an integer
444 dataType.getNewDataType(datasetTransformer, defines.TEXT, '1')
445 .should.eql(defines.TEXT);
446 // Keep text even though we've encountered a numeric
447 dataType.getNewDataType(datasetTransformer, defines.TEXT, '1.1')
448 .should.eql(defines.TEXT);
449 });
450 it('should keep TEXT type (empty string)', function() {
451 dataType.getNewDataType(datasetTransformer, defines.TEXT, '')
452 .should.eql(defines.TEXT);
453 dataType.getNewDataType(datasetTransformer, defines.TEXT, '\n')
454 .should.eql(defines.TEXT);
455 });
456
457 it('should keep ZIP type', function() {
458 dataType.getNewDataType(datasetTransformer, defines.ZIP, '12345')
459 .should.eql(defines.ZIP);
460 });
461 it('should keep ZIP type (empty string)', function() {
462 dataType.getNewDataType(datasetTransformer, defines.ZIP, '')
463 .should.eql(defines.ZIP);
464 dataType.getNewDataType(datasetTransformer, defines.ZIP, '\n')
465 .should.eql(defines.ZIP);
466 });
467 it('should convert ZIP to INTEGER', function() {
468 dataType.getNewDataType(datasetTransformer, defines.ZIP, '100')
469 .should.eql(defines.INTEGER);
470 dataType.getNewDataType(datasetTransformer, defines.ZIP, '001')
471 .should.eql(defines.INTEGER);
472 });
473 it('should convert ZIP to BIGINTEGER', function() {
474 dataType.getNewDataType(datasetTransformer, defines.ZIP, '2147483648')
475 .should.eql(defines.BIGINTEGER);
476 });
477 it('should convert ZIP to TEXT', function() {
478 dataType.getNewDataType(datasetTransformer, defines.ZIP, 'hello')
479 .should.eql(defines.TEXT);
480 });
481
482 it('should keep LAT type', function() {
483 dataType.getNewDataType(datasetTransformer, defines.LAT, '89.99')
484 .should.eql(defines.LAT);
485 });
486 it('should keep LAT type (empty string)', function() {
487 dataType.getNewDataType(datasetTransformer, defines.LAT, '')
488 .should.eql(defines.LAT);
489 dataType.getNewDataType(datasetTransformer, defines.LAT, '\n')
490 .should.eql(defines.LAT);
491 });
492 it('should keep LAT type (numeric -> integer within lat range)', function() {
493 dataType.getNewDataType(datasetTransformer, defines.LAT, '75')
494 .should.eql(defines.LAT);
495 dataType.getNewDataType(datasetTransformer, defines.LAT, '-75')
496 .should.eql(defines.LAT);
497 });
498 it('should convert LAT to LONG', function() {
499 dataType.getNewDataType(datasetTransformer, defines.LAT, '150.00')
500 .should.eql(defines.LONG);
501 });
502 it('should convert LAT to TEXT', function() {
503 dataType.getNewDataType(datasetTransformer, defines.LAT, 'hello')
504 .should.eql(defines.TEXT);
505 });
506
507 it('should keep LONG type', function() {
508 dataType.getNewDataType(datasetTransformer, defines.LONG, '179.99')
509 .should.eql(defines.LONG);
510 });
511 it('should keep LONG type (empty string)', function() {
512 dataType.getNewDataType(datasetTransformer, defines.LONG, '')
513 .should.eql(defines.LONG);
514 dataType.getNewDataType(datasetTransformer, defines.LONG, '\n')
515 .should.eql(defines.LONG);
516 });
517 it('should keep LONG type (numeric -> integer within lat range)', function() {
518 dataType.getNewDataType(datasetTransformer, defines.LONG, '150')
519 .should.eql(defines.LONG);
520 dataType.getNewDataType(datasetTransformer, defines.LONG, '-150')
521 .should.eql(defines.LONG);
522 });
523 it('should convert LONG to TEXT', function() {
524 dataType.getNewDataType(datasetTransformer, defines.LONG, 'hello')
525 .should.eql(defines.TEXT);
526 });
527
528 it('should keep PRIMARY_INTEGER type (incrementing)', function() {
529 dataType.getNewDataType(datasetTransformer, defines.PRIMARY_INTEGER, '2', '1')
530 .should.eql(defines.PRIMARY_INTEGER);
531 dataType.getNewDataType(datasetTransformer, defines.PRIMARY_INTEGER, '500', '100')
532 .should.eql(defines.PRIMARY_INTEGER);
533 });
534 it('should convert PRIMARY_INTEGER to INTEGER', function() {
535 dataType.getNewDataType(datasetTransformer, defines.PRIMARY_INTEGER, '5', '2')
536 .should.eql(defines.PRIMARY_INTEGER);
537 dataType.getNewDataType(datasetTransformer, defines.PRIMARY_INTEGER, '100', '500')
538 .should.eql(defines.INTEGER);
539 });
540 it('should convert PRIMARY_INTEGER to BOOLEAN', function() {
541 dataType.getNewDataType(datasetTransformer, defines.PRIMARY_INTEGER, '1', '0')
542 .should.eql(defines.PRIMARY_INTEGER);
543 dataType.getNewDataType(datasetTransformer, defines.PRIMARY_INTEGER, '0', '1')
544 .should.eql(defines.BOOLEAN);
545 });
546 it('should NOT convert PRIMARY_INTEGER to BOOLEAN (edge case)', function() {
547 dataType.getNewDataType(datasetTransformer, defines.PRIMARY_INTEGER, '1', '0')
548 .should.eql(defines.PRIMARY_INTEGER);
549 dataType.getNewDataType(datasetTransformer, defines.PRIMARY_INTEGER, '1', '4')
550 .should.eql(defines.INTEGER);
551 });
552
553 it('should keep UNKNWON type', function() {
554 dataType.getNewDataType(datasetTransformer, undefined, ' ')
555 .should.eql(defines.UNKNOWN);
556 dataType.getNewDataType(datasetTransformer, undefined, '\n')
557 .should.eql(defines.UNKNOWN);
558 dataType.getNewDataType(datasetTransformer, defines.UNKNOWN, ' ')
559 .should.eql(defines.UNKNOWN);
560 });
561 });
562
563 describe('#getNewDataTypes()', function() {
564 it('should get the new data types', function() {
565 var dataTypes = [
566 defines.BOOLEAN, defines.INTEGER,
567 defines.NUMERIC, defines.TEXT,
568 defines.LAT, defines.LONG,
569 defines.ZIP
570 ];
571 dataType.getNewDataTypes(datasetTransformer, dataTypes, [
572 'true', '5',
573 '35.0', 'hello',
574 '89.99', '179.99',
575 '12345'
576 ]).should.eql(dataTypes);
577 });
578 it('should get NUMERIC instead of LAT', function() {
579 var dataTypes = [];
580 dataType.getNewDataTypes(datasetTransformer, dataTypes, [
581 '5.5'
582 ]).should.eql([
583 defines.NUMERIC
584 ]);
585 });
586 it('should get NUMERIC instead of LONG', function() {
587 var dataTypes = [];
588 dataType.getNewDataTypes(datasetTransformer, dataTypes, [
589 '155.5'
590 ]).should.eql([
591 defines.NUMERIC
592 ]);
593 });
594 it('should get LAT/LONG pair', function() {
595 var dataTypes = [];
596 dataType.getNewDataTypes(datasetTransformer, dataTypes, [
597 '5.5', '155.5'
598 ]).should.eql([
599 defines.LAT, defines.LONG
600 ]);
601 });
602 it('should get LAT/LONG pair', function() {
603 var dataTypes = [];
604 dataType.getNewDataTypes(datasetTransformer, dataTypes, [
605 '5.5', '5.5'
606 ]).should.eql([
607 defines.LAT, defines.LONG
608 ]);
609 });
610 it('should convert other types into text', function() {
611 var dataTypes = [
612 defines.BOOLEAN, defines.INTEGER,
613 defines.NUMERIC, defines.TEXT
614 ];
615 dataType.getNewDataTypes(datasetTransformer, dataTypes, [
616 'hello', 'there', 'fellow', 'testers'
617 ]).should.eql([
618 defines.TEXT, defines.TEXT, defines.TEXT, defines.TEXT
619 ]);
620 });
621 });
622
623 describe('#getAdjustedDataRow()', function() {
624
625 it('should change values based on the output type (BOOLEAN)', function() {
626 dataType.getAdjustedDataRow(datasetTransformer,
627 [defines.BOOLEAN], ['false']).should.eql([false]);
628 dataType.getAdjustedDataRow(
629 datasetTransformer,
630 [defines.BOOLEAN, defines.BOOLEAN,
631 defines.BOOLEAN, defines.BOOLEAN],
632 ['TRUE', 'true', 'yes', 'n'])
633 .should.eql([true, true, true, false]);
634 });
635
636 it('should change values based on the output type (INTEGER)', function() {
637 dataType.getAdjustedDataRow(
638 datasetTransformer,
639 [defines.INTEGER, defines.INTEGER],
640 ['1', '2'])
641 .should.eql([1, 2]);
642 });
643
644 it('should change values based on the output type (NUMERIC)', function() {
645 dataType.getAdjustedDataRow(
646 datasetTransformer,
647 [defines.NUMERIC, defines.NUMERIC],
648 ['1.5', '2.5'])
649 .should.eql([1.5, 2.5]);
650 });
651
652 it('should change values based on the output type (TEXT)', function() {
653 dataType.getAdjustedDataRow(
654 datasetTransformer,
655 [defines.TEXT, defines.TEXT],
656 ['hello', 'world'])
657 .should.eql(['hello', 'world']);
658 });
659
660 it('should change values based on the output type (UNKNWON)', function() {
661 dataType.getAdjustedDataRow(
662 datasetTransformer,
663 [defines.UNKNOWN, defines.UNKNOWN],
664 ['', '\n'])
665 .should.eql([null, null]);
666 });
667
668 it('should properly insert NULL values in when missing data', function() {
669 dataType.getAdjustedDataRow(datasetTransformer,
670 [defines.BOOLEAN, defines.BOOLEAN, defines.BOOLEAN],
671 ['', ' ', '\n'])
672 .should.eql([null, null, null]);
673 dataType.getAdjustedDataRow(datasetTransformer,
674 [defines.INTEGER, defines.INTEGER, defines.INTEGER],
675 ['', ' ', '\n'])
676 .should.eql([null, null, null]);
677 dataType.getAdjustedDataRow(datasetTransformer,
678 [defines.NUMERIC, defines.NUMERIC, defines.NUMERIC],
679 ['', ' ', '\n'])
680 .should.eql([null, null, null]);
681 dataType.getAdjustedDataRow(datasetTransformer,
682 [defines.TEXT, defines.TEXT, defines.TEXT],
683 ['', ' ', '\n'])
684 .should.eql([null, null, null]);
685 });
686
687 });
688
689});