default_negative.rs

use crate::common::*;

#[test]
fn must_error_if_default_value_for_relation_field() {
    let dml = indoc! {r#"
        model Model {
          id Int @id
          rel A @default("")
        }

        model A {
          id Int @id
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": Cannot set a default value on a relation field.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   rel A @default("")
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_on_list_default_value_for_singular() {
    let dml = indoc! {r#"
        datasource db {
          provider = "postgres"
          url = "postgres://"
        }

        model Model {
          id Int @id
          rel String @default(["hello"])
        }
    "#};

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The default value of a non-list field cannot be a list.
          -->  schema.prisma:8
           | 
         7 |   id Int @id
         8 |   rel String @default(["hello"])
           | 
    "#]];
    expect_error(dml, &expectation);
}

#[test]
fn must_error_on_singular_default_value_for_list() {
    let dml = indoc! {r#"
        datasource db {
          provider = "postgres"
          url = "postgres://"
        }

        model Model {
          id Int @id
          rel String[] @default("hello")
        }
    "#};

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The default value of a list field must be a list.
          -->  schema.prisma:8
           | 
         7 |   id Int @id
         8 |   rel String[] @default("hello")
           | 
    "#]];
    expect_error(dml, &expectation);
}

#[test]
fn must_error_on_bad_value_inside_list_default() {
    let dml = indoc! {r#"
        datasource db {
          provider = "postgres"
          url = "postgres://"
        }

        model Model {
          id Int @id
          rel String[] @default(["hello", 101, "dalmatians"])
        }
    "#};

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": Expected a String value, but found `101`.
          -->  schema.prisma:8
           | 
         7 |   id Int @id
         8 |   rel String[] @default(["hello", 101, "dalmatians"])
           | 
    "#]];
    expect_error(dml, &expectation);
}

#[test]
fn must_error_if_default_value_type_mismatch() {
    let dml = indoc! {r#"
        model Model {
          id Int @id
          rel String @default(3)
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": Expected a String value, but found `3`.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   rel String @default(3)
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn datetime_defaults_must_be_valid_rfc3339() {
    let dml = indoc! {r#"
        model Model {
          id Int @id
          rel DateTime @default("Hugo")
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": Parse error: "Hugo" is not a valid rfc3339 datetime string. (input contains invalid characters)
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   rel DateTime @default("Hugo")
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_unknown_function_is_used() {
    let dml = indoc! {r#"
        model Model {
          id Int @id
          rel DateTime @default(unknown_function())
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Unknown function in @default(): `unknown_function` is not known. You can read about the available functions here: https://pris.ly/d/attribute-functions
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   rel DateTime @default(unknown_function())
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_now_function_is_used_for_fields_that_are_not_datetime() {
    let dml = indoc! {r#"
        model Model {
          id  Int    @id
          foo String @default(now())
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The function `now()` cannot be used on fields of type `String`.
          -->  schema.prisma:3
           | 
         2 |   id  Int    @id
         3 |   foo String @default(now())
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_autoincrement_function_is_used_for_fields_that_are_not_int() {
    let dml = indoc! {r#"
        model Model {
          id  Int    @id
          foo String @default(autoincrement())
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The function `autoincrement()` cannot be used on fields of type `String`.
          -->  schema.prisma:3
           | 
         2 |   id  Int    @id
         3 |   foo String @default(autoincrement())
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_default_value_for_enum_is_not_valid() {
    let dml = indoc! {r#"
        model Model {
          id Int @id
          enum A @default(B)
        }

        enum A {
          A
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The defined default value `B` is not a valid value of the enum specified for the field.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   enum A @default(B)
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_using_non_id_auto_increment_on_sqlite() {
    let dml = indoc! {r#"
        datasource db1 {
          provider = "sqlite"
          url = "file://test.db"
        }

        model Model {
          id      Int @id
          non_id  Int @default(autoincrement()) @unique
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The `autoincrement()` default value is used on a non-id field even though the datasource does not support this.
          -->  schema.prisma:8
           | 
         7 |   id      Int @id
         8 |   non_id  Int @default(autoincrement()) @unique
         9 | }
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_using_multiple_auto_increment_on_mysql() {
    let dml = indoc! {r#"
        datasource db1 {
          provider = "mysql"
          url = "mysql://"
        }

        model Model {
          id      Int @id
          non_id  Int @default(autoincrement()) @unique
          non_id2  Int @default(autoincrement()) @unique
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The `autoincrement()` default value is used multiple times on this model even though the underlying datasource only supports one instance per table.
          -->  schema.prisma:6
           | 
         5 | 
         6 | model Model {
         7 |   id      Int @id
         8 |   non_id  Int @default(autoincrement()) @unique
         9 |   non_id2  Int @default(autoincrement()) @unique
        10 | }
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_using_non_indexed_auto_increment_on_mysql() {
    let dml = indoc! {r#"
        datasource db1 {
          provider = "mysql"
          url = "mysql://"
        }

        model Model {
          id      Int @id
          non_id  Int @default(autoincrement())
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The `autoincrement()` default value is used on a non-indexed field even though the datasource does not support this.
          -->  schema.prisma:8
           | 
         7 |   id      Int @id
         8 |   non_id  Int @default(autoincrement())
         9 | }
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_on_arguments_in_autoincrement() {
    let input = indoc!(
        r#"
        model Category {
          id Int @id @default(autoincrement(name: "meow"))
        }"#
    );

    let expected = expect![[r#"
        error: Error parsing attribute "@default": The `autoincrement` function does not take any argument. Consider changing this default to `autoincrement()`.
          -->  schema.prisma:2
           | 
         1 | model Category {
         2 |   id Int @id @default(autoincrement(name: "meow"))
           | 
    "#]];

    expected.assert_eq(&datamodel::parse_schema(input).map(drop).unwrap_err());
}

#[test]
fn must_error_if_scalar_default_on_unsupported() {
    let dml = indoc! {r#"
        datasource db1 {
          provider = "postgresql"
          url = "postgresql://"
        }

        model Model {
          id      Int @id
          balance Unsupported("some random stuff") @default(12)
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": Only @default(dbgenerated("...")) can be used for Unsupported types.
          -->  schema.prisma:8
           | 
         7 |   id      Int @id
         8 |   balance Unsupported("some random stuff") @default(12)
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_non_string_expression_in_function_default() {
    let dml = indoc! {r#"
        model Model {
          id      Int @id
          balance Int @default(autoincrement(cuid()))
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The `autoincrement` function does not take any argument. Consider changing this default to `autoincrement()`.
          -->  schema.prisma:3
           | 
         2 |   id      Int @id
         3 |   balance Int @default(autoincrement(cuid()))
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_if_non_string_expression_in_function_default_2() {
    let dml = indoc! {r#"
        model Model {
          id      Int @id
          balance Int @default(dbgenerated(5))
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": `dbgenerated()` takes a single String argument
          -->  schema.prisma:3
           | 
         2 |   id      Int @id
         3 |   balance Int @default(dbgenerated(5))
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn must_error_on_empty_string_in_dbgenerated() {
    let dml = indoc! {r#"
        model Model {
          id      Int @id
          balance Int @default(dbgenerated(""))
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": dbgenerated() takes either no argument, or a single nonempty string argument.
          -->  schema.prisma:3
           | 
         2 |   id      Int @id
         3 |   balance Int @default(dbgenerated(""))
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn dbgenerated_default_errors_must_not_cascade_into_other_errors() {
    let dml = indoc! {r#"
        datasource ds {
          provider = "mysql"
          url = "mysql://"
        }

        model User {
          id        Int    @id
          role      Bytes
          role2     Bytes @ds.VarBinary(40) @default(dbgenerated(""))

          @@unique([role2, role])
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": dbgenerated() takes either no argument, or a single nonempty string argument.
          -->  schema.prisma:9
           | 
         8 |   role      Bytes
         9 |   role2     Bytes @ds.VarBinary(40) @default(dbgenerated(""))
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn named_default_constraints_should_not_work_on_non_sql_server() {
    let dml = indoc! { r#"
        datasource test {
          provider = "postgres"
          url = "postgres://"
        }

        generator js {
          provider = "prisma-client-js"
        }

        model A {
          id Int @id @default(autoincrement())
          data String @default("beeb buub", map: "meow")
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": You defined a database name for the default value of a field on the model. This is not supported by the provider.
          -->  schema.prisma:12
           | 
        11 |   id Int @id @default(autoincrement())
        12 |   data String @default("beeb buub", map: "meow")
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn named_default_constraints_are_not_allowed_on_identity() {
    let dml = indoc! { r#"
        datasource test {
          provider = "sqlserver"
          url = "sqlserver://"
        }

        generator js {
          provider = "prisma-client-js"
        }

        model A {
          id Int @id @default(autoincrement(), map: "nope__nope__nope")
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": Naming an autoincrement default value is not allowed.
          -->  schema.prisma:11
           | 
        10 | model A {
        11 |   id Int @id @default(autoincrement(), map: "nope__nope__nope")
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn named_default_constraints_cannot_have_duplicate_names() {
    let dml = indoc! { r#"
        datasource test {
          provider = "sqlserver"
          url = "sqlserver://"
        }

        generator js {
          provider = "prisma-client-js"
        }

        model A {
          id Int @id @default(autoincrement())
          a  String @default("asdf", map: "reserved")
        }

        model B {
          id Int @id @default(autoincrement())
          b  String @default("asdf", map: "reserved")
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The given constraint name `reserved` has to be unique in the following namespace: global for primary keys, foreign keys and default constraints. Please provide a different name using the `map` argument.
          -->  schema.prisma:12
           | 
        11 |   id Int @id @default(autoincrement())
        12 |   a  String @default("asdf", map: "reserved")
           | 
        error: Error parsing attribute "@default": The given constraint name `reserved` has to be unique in the following namespace: global for primary keys, foreign keys and default constraints. Please provide a different name using the `map` argument.
          -->  schema.prisma:17
           | 
        16 |   id Int @id @default(autoincrement())
        17 |   b  String @default("asdf", map: "reserved")
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn named_default_constraints_cannot_clash_with_pk_names() {
    let dml = indoc! { r#"
        datasource test {
          provider = "sqlserver"
          url = "sqlserver://"
        }

        generator js {
          provider = "prisma-client-js"
        }

        model A {
          id Int @id @default(autoincrement())
          a  String @default("asdf", map: "reserved")
        }

        model B {
          id Int @id(map: "reserved") @default(autoincrement())
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The given constraint name `reserved` has to be unique in the following namespace: global for primary keys, foreign keys and default constraints. Please provide a different name using the `map` argument.
          -->  schema.prisma:12
           | 
        11 |   id Int @id @default(autoincrement())
        12 |   a  String @default("asdf", map: "reserved")
           | 
        error: Error parsing attribute "@id": The given constraint name `reserved` has to be unique in the following namespace: global for primary keys, foreign keys and default constraints. Please provide a different name using the `map` argument.
          -->  schema.prisma:16
           | 
        15 | model B {
        16 |   id Int @id(map: "reserved") @default(autoincrement())
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn named_default_constraints_cannot_clash_with_fk_names() {
    let dml = indoc! { r#"
        datasource test {
          provider = "sqlserver"
          url = "sqlserver://"
        }

        model A {
          id  Int @id @default(autoincrement())
          a   String  @default("asdf", map: "reserved")
          b   B       @relation(fields: [bId], references: [id], map: "reserved")
          bId Int
        }

        model B {
          id Int @id @default(autoincrement())
          as A[]
        }
    "#};

    let error = datamodel::parse_schema(dml).map(drop).unwrap_err();

    let expectation = expect![[r#"
        error: Error parsing attribute "@default": The given constraint name `reserved` has to be unique in the following namespace: global for primary keys, foreign keys and default constraints. Please provide a different name using the `map` argument.
          -->  schema.prisma:8
           | 
         7 |   id  Int @id @default(autoincrement())
         8 |   a   String  @default("asdf", map: "reserved")
           | 
        error: Error parsing attribute "@relation": The given constraint name `reserved` has to be unique in the following namespace: global for primary keys, foreign keys and default constraints. Please provide a different name using the `map` argument.
          -->  schema.prisma:9
           | 
         8 |   a   String  @default("asdf", map: "reserved")
         9 |   b   B       @relation(fields: [bId], references: [id], map: "reserved")
           | 
    "#]];

    expectation.assert_eq(&error)
}

#[test]
fn default_on_composite_type_field_errors() {
    let schema = indoc! { r#"
        type Address {
            street String
        }

        model User {
            id Int @id
            address Address? @default("{ \"street\": \"broadway\"}")
        }
    "#};

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    // Error could be better since PG don't support composites yet at all.
    let expected = expect![[r#"
        error: Error validating field `address` in composite type `Address`: Defaults on fields of type composite are not supported. Please remove the `@default` attribute.
          -->  schema.prisma:7
           | 
         6 |     id Int @id
         7 |     address Address? @default("{ \"street\": \"broadway\"}")
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_on_auto_default_on_non_native_type_on_mongodb() {
    let schema = r#"
        datasource db {
            provider = "mongodb"
            url = "mongodb://"
        }

        model User {
            id Int @id @map("_id")
            nickname String @default(auto())
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error validating field `nickname` in model `User`: MongoDB `@default(auto())` fields must have `ObjectId` native type.
          -->  schema.prisma:9
           | 
         8 |             id Int @id @map("_id")
         9 |             nickname String @default(auto())
        10 |         }
           | 
        error: Error validating field `nickname` in model `User`: MongoDB `@default(auto())` fields must have the `@id` attribute.
          -->  schema.prisma:9
           | 
         8 |             id Int @id @map("_id")
         9 |             nickname String @default(auto())
        10 |         }
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_on_auto_default_on_non_object_id_on_mongodb() {
    let schema = r#"
        datasource db {
            provider = "mongodb"
            url = "mongodb://"
        }

        model User {
            id Int @id @map("_id") @default(auto()) @db.Int
            nickname String
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error validating field `id` in model `User`: MongoDB `@default(auto())` fields must have `ObjectId` native type.
          -->  schema.prisma:8
           | 
         7 |         model User {
         8 |             id Int @id @map("_id") @default(auto()) @db.Int
         9 |             nickname String
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_on_auto_default_on_mongodb_composite() {
    let schema = r#"
        datasource db {
            provider = "mongodb"
            url = "mongodb://"
        }

        model User {
            id   String @id @map("_id") @default(auto()) @db.ObjectId
            meow Meow
        }

        type Meow {
            id String @default(auto()) @db.ObjectId
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": The function `auto()` is not supported on composite fields.
          -->  schema.prisma:13
           | 
        12 |         type Meow {
        13 |             id String @default(auto()) @db.ObjectId
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_on_dbgenerated_default_on_mongodb() {
    let schema = r#"
        datasource db {
            provider = "mongodb"
            url = "mongodb://"
        }

        model User {
            id String @id @map("_id") @default(dbgenerated()) @db.ObjectId
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error validating field `id` in model `User`: The `dbgenerated()` function is not allowed with MongoDB. Please use `auto()` instead.
          -->  schema.prisma:8
           | 
         7 |         model User {
         8 |             id String @id @map("_id") @default(dbgenerated()) @db.ObjectId
         9 |         }
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_with_auto_params_on_mongodb() {
    let schema = r#"
        datasource db {
            provider = "mongodb"
            url = "mongodb://"
        }

        model User {
            id String @id @map("_id") @default(auto("meow")) @db.ObjectId
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": `auto()` takes no arguments
          -->  schema.prisma:8
           | 
         7 |         model User {
         8 |             id String @id @map("_id") @default(auto("meow")) @db.ObjectId
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_if_using_auto_with_postgres() {
    let schema = r#"
        datasource db {
            provider = "postgres"
            url = "postgres://"
        }

        model User {
            id String @id @default(auto())
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": The current connector does not support the `auto()` function.
          -->  schema.prisma:8
           | 
         7 |         model User {
         8 |             id String @id @default(auto())
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_if_using_auto_with_mysql() {
    let schema = r#"
        datasource db {
            provider = "mysql"
            url = "mysql://"
        }

        model User {
            id String @id @default(auto())
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": The current connector does not support the `auto()` function.
          -->  schema.prisma:8
           | 
         7 |         model User {
         8 |             id String @id @default(auto())
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_if_using_auto_with_sql_server() {
    let schema = r#"
        datasource db {
            provider = "sqlserver"
            url = "sqlserver://"
        }

        model User {
            id String @id @default(auto())
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": The current connector does not support the `auto()` function.
          -->  schema.prisma:8
           | 
         7 |         model User {
         8 |             id String @id @default(auto())
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_if_using_auto_with_sqlite() {
    let schema = r#"
        datasource db {
            provider = "sqlite"
            url = "file:dev.db"
        }

        model User {
            id String @id @default(auto())
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": The current connector does not support the `auto()` function.
          -->  schema.prisma:8
           | 
         7 |         model User {
         8 |             id String @id @default(auto())
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn must_error_on_auto_default_on_non_id_on_mongodb() {
    let schema = r#"
        datasource db {
            provider = "mongodb"
            url = "mongodb://"
        }

        model User {
            id Int @id @map("_id")
            nickname String @default(auto()) @db.ObjectId
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error validating field `nickname` in model `User`: MongoDB `@default(auto())` fields must have the `@id` attribute.
          -->  schema.prisma:9
           | 
         8 |             id Int @id @map("_id")
         9 |             nickname String @default(auto()) @db.ObjectId
        10 |         }
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn json_defaults_must_be_valid_json() {
    let schema = r#"
        model Test {
            id Int @id
            name Json @default("not json")
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": Parse error: "not json" is not a valid JSON string. (expected ident at line 1 column 2)
          -->  schema.prisma:4
           | 
         3 |             id Int @id
         4 |             name Json @default("not json")
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn bytes_defaults_must_be_base64() {
    let schema = r#"
        model Test {
            id Int @id
            name Bytes @default("not base64")
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": Parse error: "not base64" is not a valid base64 string. (Could not convert from `base64 encoded bytes` to `PrismaValue::Bytes`)
          -->  schema.prisma:4
           | 
         3 |             id Int @id
         4 |             name Bytes @default("not base64")
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn int_defaults_must_not_contain_decimal_point() {
    let schema = r#"
        model Test {
            id Int @id
            score Int @default(3.14)
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": Parse error: "3.14" is not a valid integer. (invalid digit found in string)
          -->  schema.prisma:4
           | 
         3 |             id Int @id
         4 |             score Int @default(3.14)
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn bigint_defaults_must_not_contain_decimal_point() {
    let schema = r#"
        model Test {
            id Int @id
            score BigInt @default(3.14)
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": Parse error: "3.14" is not a valid integer. (invalid digit found in string)
          -->  schema.prisma:4
           | 
         3 |             id Int @id
         4 |             score BigInt @default(3.14)
           | 
    "#]];

    expected.assert_eq(&error)
}

#[test]
fn boolean_defaults_must_be_true_or_false() {
    let schema = r#"
        model Test {
            id Int @id
            isEdible Boolean @default(True)
        }
    "#;

    let error = datamodel::parse_schema(schema).map(drop).unwrap_err();

    let expected = expect![[r#"
        error: Error parsing attribute "@default": A boolean literal must be `true` or `false`.
          -->  schema.prisma:4
           | 
         3 |             id Int @id
         4 |             isEdible Boolean @default(True)
           | 
    "#]];

    expected.assert_eq(&error)
}