sqlite.rs

use crate::common::*;

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

        model Todo {
          id     Int    @id
          status Status
        }

        enum Status {
          DONE
          NOT_DONE
        }
    "#};

    let error = parse_unwrap_err(dml);

    let expectation = expect![[r#"
        error: Error validating: You defined the enum `Status`. But the current connector does not support enums.
          -->  schema.prisma:11
           | 
        10 | 
        11 | enum Status {
        12 |   DONE
        13 |   NOT_DONE
        14 | }
           | 
    "#]];

    expectation.assert_eq(&error);
}

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

        model Todo {
          id     Int    @id
          val    String[]
        }
    "#};

    let error = parse_unwrap_err(dml);

    let expectation = expect![[r#"
        error: Field "val" in model "Todo" can't be a list. The current connector does not support lists of primitive types.
          -->  schema.prisma:8
           | 
         7 |   id     Int    @id
         8 |   val    String[]
         9 | }
           | 
    "#]];

    expectation.assert_eq(&error);
}

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

        model User {
          id         Int @id
          neighborId Int

          @@index([id], name: "metaId")
        }

        model Post {
          id Int @id
          optionId Int

          @@index([id], name: "metaId")
        }
    "#};

    let error = parse_unwrap_err(dml);

    let expectation = expect![[r#"
        error: Error parsing attribute "@@index": The given constraint name `metaId` has to be unique in the following namespace: global for indexes and unique constraints. Please provide a different name using the `map` argument.
          -->  schema.prisma:10
           | 
         9 | 
        10 |   @@index([id], name: "metaId")
           | 
        error: Error parsing attribute "@@index": The given constraint name `metaId` has to be unique in the following namespace: global for indexes and unique constraints. Please provide a different name using the `map` argument.
          -->  schema.prisma:17
           | 
        16 | 
        17 |   @@index([id], name: "metaId")
           | 
    "#]];

    expectation.assert_eq(&error);
}

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

        model User {
          id   Int @id
          data Json
        }
    "#};

    let error = parse_unwrap_err(dml);

    let expectation = expect![[r#"
        error: Error validating field `data` in model `User`: Field `data` in model `User` can't be of type Json. The current connector does not support the Json type.
          -->  schema.prisma:8
           | 
         7 |   id   Int @id
         8 |   data Json
         9 | }
           | 
    "#]];

    expectation.assert_eq(&error);
}

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

        model Todo {
          id           Int    @id
          assigneeName String
          assignee     User   @relation(fields: [assigneeName], references: [name])
        }

        model User {
          id   Int    @id
          name String
          todos Todo[]
        }
    "#};

    let error = parse_unwrap_err(dml);

    let expectation = expect![[r#"
        error: Error parsing attribute "@relation": The argument `references` must refer to a unique criterion in the related model. Consider adding an `@unique` attribute to the field `name` in the model `User`.
          -->  schema.prisma:9
           | 
         8 |   assigneeName String
         9 |   assignee     User   @relation(fields: [assigneeName], references: [name])
        10 | }
           | 
    "#]];

    expectation.assert_eq(&error);
}

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

        model Todo {
          id           Int    @id
          non_primary  Int    @default(autoincrement()) @unique
        }
    "#};

    let error = parse_unwrap_err(dml);

    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_primary  Int    @default(autoincrement()) @unique
         9 | }
           | 
    "#]];

    expectation.assert_eq(&error);
}

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

        model  Todo {
          id1  Int
          id2  Int
          cats Cat[]

          @@id([id1, id2])
        }

        model Cat {
          id    Int @id
          todo1 Int
          todo2 Int

          rel Todo @relation(fields: [todo1, todo2], references: [id2, id1])
        }
    "#};

    assert_valid(dml)
}

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

        type Address {
            street String
        }
        "#
    );

    let err = parse_unwrap_err(schema);

    let expected = expect![[r#"
        error: Error validating: Composite types are not supported on sqlite.
          -->  schema.prisma:6
           | 
         5 | 
         6 | type Address {
         7 |     street String
         8 | }
           | 
    "#]];

    expected.assert_eq(&err);
}