Function test_enum

crates/pg/src/encoder.rs:240–294

()

    #[tokio::test]
    async fn test_enum() {
        let some = AlgebraicType::option(AlgebraicType::I64);
        let schema = ProductType::from([some.clone(), some]);
        let value = product![
            AlgebraicValue::sum(0, AlgebraicValue::I64(1)), // Some(1)
            AlgebraicValue::sum(1, AlgebraicValue::unit()), // None
        ];

        let row = run(schema, value).await;
        assert_eq!(row, "\0\0\0\u{b}{\"some\": 1}\0\0\0\u{c}{\"none\": {}}");

        let result = AlgebraicType::result(AlgebraicType::I64, AlgebraicType::String);
        let schema = ProductType::from([result.clone(), result.clone()]);
        let value = product![
            AlgebraicValue::sum(0, AlgebraicValue::I64(1)),                 // Ok(1)
            AlgebraicValue::sum(1, AlgebraicValue::String("error".into())), // Err("error")
        ];
        let row = run(schema, value).await;
        assert_eq!(row, "\0\0\0\t{\"ok\": 1}\0\0\0\u{10}{\"err\": \"error\"}");

        let color = AlgebraicType::Sum([SumTypeVariant::new_named(AlgebraicType::I64, "Gray")].into());
        let nested = AlgebraicType::option(color.clone());
        let schema = ProductType::from([color, nested]);
        // {"Gray": 1}, {"some": {"Gray": 2}}
        let value = product![
            AlgebraicValue::sum(0, AlgebraicValue::I64(1)), // Gray(1)
            AlgebraicValue::sum(0, AlgebraicValue::sum(0, AlgebraicValue::I64(2))), // Some(Gray(2))
        ];
        let row = run(schema.clone(), value.clone()).await;
        assert_eq!(row, "\0\0\0\u{b}{\"Gray\": 1}\0\0\0\u{15}{\"some\": {\"Gray\": 2}}");

        // Now nested product
        let product = AlgebraicType::product([("x", AlgebraicType::Product(schema)), ("y", AlgebraicType::String)]);
        let schema = ProductType::from([product.clone()]);
        let value = product![AlgebraicValue::product(vec![
            value.into(),
            AlgebraicValue::String("a".into()),
        ])];
        let row = run(schema, value).await;
        assert_eq!(
            row,
            "\0\0\0G{\"x\": {\"col_0\": {\"Gray\": 1}, \"col_1\": {\"some\": {\"Gray\": 2}}}, \"y\": \"a\"}"
        );

        // Now a simple enum
        let names = AlgebraicType::simple_enum(["A", "B", "C"].into_iter());
        let schema = ProductType::from([names.clone(), names.clone(), names]);
        let value = product![
            AlgebraicValue::enum_simple(0), // A
            AlgebraicValue::enum_simple(1), // B
            AlgebraicValue::enum_simple(2), // C
        ];
        let row = run(schema, value).await;
        assert_eq!(row, "\0\0\0\u{1}A\0\0\0\u{1}B\0\0\0\u{1}C");
    }

    #[tokio::test]
    async fn test_special_types() {