Skip to content

Commit 7c9c341

Browse files
carpecodeumcarpecodeum
committed
[TEST] add tests for new variant types to json functionality
1 parent 15d0e3a commit 7c9c341

File tree

2 files changed

+420
-10
lines changed

2 files changed

+420
-10
lines changed

‎parquet-variant/src/encoder/variant_to_json.rs‎

Lines changed: 247 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -317,6 +317,7 @@ pub fn variant_to_json_value(variant: &Variant) -> Result<Value, ArrowError> {
317317
mod tests {
318318
use super::*;
319319
use crate::Variant;
320+
use chrono::{DateTime, NaiveDate, Utc};
320321

321322
#[test]
322323
fn test_null_to_json() -> Result<(), ArrowError> {
@@ -358,6 +359,219 @@ mod tests {
358359
Ok(())
359360
}
360361

362+
#[test]
363+
fn test_int16_to_json() -> Result<(), ArrowError> {
364+
let variant = Variant::Int16(32767);
365+
let json = variant_to_json_string(&variant)?;
366+
assert_eq!(json, "32767");
367+
368+
let json_value = variant_to_json_value(&variant)?;
369+
assert_eq!(json_value, Value::Number(32767.into()));
370+
371+
// Test negative value
372+
let negative_variant = Variant::Int16(-32768);
373+
let negative_json = variant_to_json_string(&negative_variant)?;
374+
assert_eq!(negative_json, "-32768");
375+
Ok(())
376+
}
377+
378+
#[test]
379+
fn test_int32_to_json() -> Result<(), ArrowError> {
380+
let variant = Variant::Int32(2147483647);
381+
let json = variant_to_json_string(&variant)?;
382+
assert_eq!(json, "2147483647");
383+
384+
let json_value = variant_to_json_value(&variant)?;
385+
assert_eq!(json_value, Value::Number(2147483647.into()));
386+
387+
// Test negative value
388+
let negative_variant = Variant::Int32(-2147483648);
389+
let negative_json = variant_to_json_string(&negative_variant)?;
390+
assert_eq!(negative_json, "-2147483648");
391+
Ok(())
392+
}
393+
394+
#[test]
395+
fn test_int64_to_json() -> Result<(), ArrowError> {
396+
let variant = Variant::Int64(9223372036854775807);
397+
let json = variant_to_json_string(&variant)?;
398+
assert_eq!(json, "9223372036854775807");
399+
400+
let json_value = variant_to_json_value(&variant)?;
401+
assert_eq!(json_value, Value::Number(9223372036854775807i64.into()));
402+
403+
// Test negative value
404+
let negative_variant = Variant::Int64(-9223372036854775808);
405+
let negative_json = variant_to_json_string(&negative_variant)?;
406+
assert_eq!(negative_json, "-9223372036854775808");
407+
Ok(())
408+
}
409+
410+
#[test]
411+
fn test_float_to_json() -> Result<(), ArrowError> {
412+
let variant = Variant::Float(3.14159);
413+
let json = variant_to_json_string(&variant)?;
414+
assert!(json.starts_with("3.14159"));
415+
416+
let json_value = variant_to_json_value(&variant)?;
417+
assert!(matches!(json_value, Value::Number(_)));
418+
419+
// Test zero
420+
let zero_variant = Variant::Float(0.0);
421+
let zero_json = variant_to_json_string(&zero_variant)?;
422+
assert_eq!(zero_json, "0");
423+
424+
// Test negative
425+
let negative_variant = Variant::Float(-1.5);
426+
let negative_json = variant_to_json_string(&negative_variant)?;
427+
assert_eq!(negative_json, "-1.5");
428+
Ok(())
429+
}
430+
431+
#[test]
432+
fn test_double_to_json() -> Result<(), ArrowError> {
433+
let variant = Variant::Double(2.718281828459045);
434+
let json = variant_to_json_string(&variant)?;
435+
assert!(json.starts_with("2.718281828459045"));
436+
437+
let json_value = variant_to_json_value(&variant)?;
438+
assert!(matches!(json_value, Value::Number(_)));
439+
440+
// Test zero
441+
let zero_variant = Variant::Double(0.0);
442+
let zero_json = variant_to_json_string(&zero_variant)?;
443+
assert_eq!(zero_json, "0");
444+
445+
// Test negative
446+
let negative_variant = Variant::Double(-2.5);
447+
let negative_json = variant_to_json_string(&negative_variant)?;
448+
assert_eq!(negative_json, "-2.5");
449+
Ok(())
450+
}
451+
452+
#[test]
453+
fn test_decimal4_to_json() -> Result<(), ArrowError> {
454+
let variant = Variant::Decimal4 { integer: 12345, scale: 2 };
455+
let json = variant_to_json_string(&variant)?;
456+
assert_eq!(json, "123.45");
457+
458+
let json_value = variant_to_json_value(&variant)?;
459+
assert!(matches!(json_value, Value::Number(_)));
460+
461+
// Test zero scale
462+
let no_scale_variant = Variant::Decimal4 { integer: 42, scale: 0 };
463+
let no_scale_json = variant_to_json_string(&no_scale_variant)?;
464+
assert_eq!(no_scale_json, "42");
465+
466+
// Test negative
467+
let negative_variant = Variant::Decimal4 { integer: -12345, scale: 3 };
468+
let negative_json = variant_to_json_string(&negative_variant)?;
469+
assert_eq!(negative_json, "-12.345");
470+
Ok(())
471+
}
472+
473+
#[test]
474+
fn test_decimal8_to_json() -> Result<(), ArrowError> {
475+
let variant = Variant::Decimal8 { integer: 1234567890, scale: 3 };
476+
let json = variant_to_json_string(&variant)?;
477+
assert_eq!(json, "1234567.89");
478+
479+
let json_value = variant_to_json_value(&variant)?;
480+
assert!(matches!(json_value, Value::Number(_)));
481+
482+
// Test large scale
483+
let large_scale_variant = Variant::Decimal8 { integer: 123456789, scale: 6 };
484+
let large_scale_json = variant_to_json_string(&large_scale_variant)?;
485+
assert_eq!(large_scale_json, "123.456789");
486+
Ok(())
487+
}
488+
489+
#[test]
490+
fn test_decimal16_to_json() -> Result<(), ArrowError> {
491+
let variant = Variant::Decimal16 { integer: 123456789012345, scale: 4 };
492+
let json = variant_to_json_string(&variant)?;
493+
assert_eq!(json, "12345678901.2345");
494+
495+
let json_value = variant_to_json_value(&variant)?;
496+
assert!(matches!(json_value, Value::Number(_)));
497+
498+
// Test very large number
499+
let large_variant = Variant::Decimal16 { integer: 999999999999999999, scale: 2 };
500+
let large_json = variant_to_json_string(&large_variant)?;
501+
// Due to f64 precision limits, very large numbers may lose precision
502+
assert!(large_json.starts_with("9999999999999999") || large_json.starts_with("10000000000000000"));
503+
Ok(())
504+
}
505+
506+
#[test]
507+
fn test_date_to_json() -> Result<(), ArrowError> {
508+
let date = NaiveDate::from_ymd_opt(2023, 12, 25).unwrap();
509+
let variant = Variant::Date(date);
510+
let json = variant_to_json_string(&variant)?;
511+
assert_eq!(json, "\"2023-12-25\"");
512+
513+
let json_value = variant_to_json_value(&variant)?;
514+
assert_eq!(json_value, Value::String("2023-12-25".to_string()));
515+
516+
// Test leap year date
517+
let leap_date = NaiveDate::from_ymd_opt(2024, 2, 29).unwrap();
518+
let leap_variant = Variant::Date(leap_date);
519+
let leap_json = variant_to_json_string(&leap_variant)?;
520+
assert_eq!(leap_json, "\"2024-02-29\"");
521+
Ok(())
522+
}
523+
524+
#[test]
525+
fn test_timestamp_micros_to_json() -> Result<(), ArrowError> {
526+
let timestamp = DateTime::parse_from_rfc3339("2023-12-25T10:30:45Z").unwrap().with_timezone(&Utc);
527+
let variant = Variant::TimestampMicros(timestamp);
528+
let json = variant_to_json_string(&variant)?;
529+
assert!(json.contains("2023-12-25T10:30:45"));
530+
assert!(json.starts_with('"') && json.ends_with('"'));
531+
532+
let json_value = variant_to_json_value(&variant)?;
533+
assert!(matches!(json_value, Value::String(_)));
534+
Ok(())
535+
}
536+
537+
#[test]
538+
fn test_timestamp_ntz_micros_to_json() -> Result<(), ArrowError> {
539+
let naive_timestamp = DateTime::from_timestamp(1703505045, 123456).unwrap().naive_utc();
540+
let variant = Variant::TimestampNtzMicros(naive_timestamp);
541+
let json = variant_to_json_string(&variant)?;
542+
assert!(json.contains("2023-12-25"));
543+
assert!(json.starts_with('"') && json.ends_with('"'));
544+
545+
let json_value = variant_to_json_value(&variant)?;
546+
assert!(matches!(json_value, Value::String(_)));
547+
Ok(())
548+
}
549+
550+
#[test]
551+
fn test_binary_to_json() -> Result<(), ArrowError> {
552+
let binary_data = b"Hello, World!";
553+
let variant = Variant::Binary(binary_data);
554+
let json = variant_to_json_string(&variant)?;
555+
556+
// Should be base64 encoded and quoted
557+
assert!(json.starts_with('"') && json.ends_with('"'));
558+
assert!(json.len() > 2); // Should have content
559+
560+
let json_value = variant_to_json_value(&variant)?;
561+
assert!(matches!(json_value, Value::String(_)));
562+
563+
// Test empty binary
564+
let empty_variant = Variant::Binary(b"");
565+
let empty_json = variant_to_json_string(&empty_variant)?;
566+
assert_eq!(empty_json, "\"\"");
567+
568+
// Test binary with special bytes
569+
let special_variant = Variant::Binary(&[0, 255, 128, 64]);
570+
let special_json = variant_to_json_string(&special_variant)?;
571+
assert!(special_json.starts_with('"') && special_json.ends_with('"'));
572+
Ok(())
573+
}
574+
361575
#[test]
362576
fn test_string_to_json() -> Result<(), ArrowError> {
363577
let variant = Variant::String("hello world");
@@ -391,10 +605,6 @@ mod tests {
391605
Ok(())
392606
}
393607

394-
// TODO: Add tests for objects and arrays once the implementation is complete
395-
// These will be added in the next steps when we implement the missing methods
396-
// in VariantObject and VariantArray
397-
398608
#[test]
399609
fn test_json_buffer_writing() -> Result<(), ArrowError> {
400610
let variant = Variant::Int8(123);
@@ -406,4 +616,37 @@ mod tests {
406616
assert_eq!(result, "123");
407617
Ok(())
408618
}
619+
620+
#[test]
621+
fn test_comprehensive_type_coverage() -> Result<(), ArrowError> {
622+
// Test all supported types to ensure no compilation errors
623+
let test_variants = vec![
624+
Variant::Null,
625+
Variant::BooleanTrue,
626+
Variant::BooleanFalse,
627+
Variant::Int8(1),
628+
Variant::Int16(2),
629+
Variant::Int32(3),
630+
Variant::Int64(4),
631+
Variant::Float(5.0),
632+
Variant::Double(6.0),
633+
Variant::Decimal4 { integer: 7, scale: 0 },
634+
Variant::Decimal8 { integer: 8, scale: 0 },
635+
Variant::Decimal16 { integer: 9, scale: 0 },
636+
Variant::Date(NaiveDate::from_ymd_opt(2023, 1, 1).unwrap()),
637+
Variant::TimestampMicros(DateTime::parse_from_rfc3339("2023-01-01T00:00:00Z").unwrap().with_timezone(&Utc)),
638+
Variant::TimestampNtzMicros(DateTime::from_timestamp(0, 0).unwrap().naive_utc()),
639+
Variant::Binary(b"test"),
640+
Variant::String("test"),
641+
Variant::ShortString("test"),
642+
];
643+
644+
for variant in test_variants {
645+
// Ensure all types can be converted without panicking
646+
let _json_string = variant_to_json_string(&variant)?;
647+
let _json_value = variant_to_json_value(&variant)?;
648+
}
649+
650+
Ok(())
651+
}
409652
}

0 commit comments

Comments
 (0)