insertTests method

Implementation

void insertTests() {
  group('Insert', () {
    group('basic funtionality', () {
      final collection = schema;
      late Cursor cursor;

      setUp(() async {
        connection = await connector.connect(_initDb);
        cursor = await connection.cursor();
      });

      tearDown(() async {
        await connection.close();
      });

      test('insert no values', () async {
        final operation = Insert(collection, []);
        await cursor.execute(operation);

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, hasLength(0));
      });

      test('insert single value', () async {
        final obj = {
          "id": "gunslinger",
          "name": "Roland Deschain",
          "age": 999,
        };

        final operation = Insert(collection, [obj]);
        await cursor.execute(operation);

        await cursor.execute(Query(from: collection));
        // Note: assuming autocommit = true
        final fromDb = await cursor.fetchall();

        expect(fromDb[0], equals(obj));
      });
      test('insert multiple values', () async {
        final obj1 = {
          "id": "gunslinger",
          "name": "Roland Deschain",
          "age": 999,
        };

        final obj2 = {
          "id": "detta",
          "name": "Susannah Dean",
          "age": 54,
        };

        final operation = Insert(collection, [obj1, obj2]);
        await cursor.execute(operation);

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, unorderedEquals([obj1, obj2]));
      });
    });

    group('table with pk only', () {
      final collection = schemaIdOnly;
      late Cursor cursor;

      setUp(() async {
        connection = await connector.connect(_initDbPKOnly);
        cursor = await connection.cursor();
      });

      tearDown(() async {
        await connection.close();
      });

      test('insert single value', () async {
        final obj = {
          "id": 123,
        };

        final operation = Insert(collection, [obj]);
        await cursor.execute(operation);

        await cursor.execute(Query(from: collection));
        // Note: assuming autocommit = true
        final fromDb = await cursor.fetchall();

        expect(fromDb[0], equals(obj));
      });
    });

    group('unique constraint on single property', () {
      final collection = schemaUnique;
      late Cursor cursor;

      setUp(() async {
        connection = await connector.connect(_initDbUnique);
        cursor = await connection.cursor();
      });

      tearDown(() async {
        await connection.close();
      });

      test('insert without conflicts', () async {
        final obj1 = {
          "id": "gunslinger",
          "name": "Roland Deschain",
          "age": 999,
        };

        final obj2 = {
          "id": "detta",
          "name": "Susannah Dean",
          "age": 54,
        };

        final operation = Insert(collection, [obj1, obj2]);
        await cursor.execute(operation);

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, unorderedEquals([obj1, obj2]));
      });

      test('single insert with conflicts', () async {
        final obj1 = {
          "id": "gunslinger",
          "name": "Roland Deschain",
          "age": 999,
        };

        final operation = Insert(collection, [obj1]);
        await cursor.execute(operation);

        final obj2 = {
          "id": "detta",
          "name": "Roland Deschain",
          "age": 54,
        };

        final conflictingOperation = Insert(collection, [obj2]);
        final execFuture = cursor.execute(conflictingOperation);
        expectLater(execFuture, throwsA(isA<IntegrityError>()));

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, equals([obj1]));
      });

      test('single insert with pk conflict', () async {
        final obj1 = {
          "id": "gunslinger",
          "name": "Roland Deschain",
          "age": 999,
        };

        final obj2 = {
          "id": "gunslinger",
          "name": "Susannah Dean",
          "age": 54,
        };

        final operation = Insert(collection, [obj1]);
        await cursor.execute(operation);

        final conflictingOperation = Insert(collection, [obj2]);
        final execFuture = cursor.execute(conflictingOperation);
        expectLater(execFuture, throwsA(isA<IntegrityError>()));

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, equals([obj1]));
      });

      test('bulk insert with unique conflicts', () async {
        final obj1 = {
          "id": "gunslinger",
          "name": "Roland Deschain",
          "age": 999,
        };

        final obj2 = {
          "id": "detta",
          "name": "Roland Deschain",
          "age": 54,
        };

        final operation = Insert(collection, [obj1, obj2]);
        final execFuture = cursor.execute(operation);
        expectLater(execFuture, throwsA(isA<IntegrityError>()));

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, equals([]));
      });

      test('bulk insert with pk conflicts', () async {
        final obj1 = {
          "id": "gunslinger",
          "name": "Roland Deschain",
          "age": 999,
        };

        final obj2 = {
          "id": "gunslinger",
          "name": "Susannah Dean",
          "age": 54,
        };

        final operation = Insert(collection, [obj1, obj2]);
        final execFuture = cursor.execute(operation);
        expectLater(execFuture, throwsA(isA<IntegrityError>()));

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, equals([]));
      });
    }, skip: requireFeature(DatabaseFeature.uniqueProperty));

    group('compound primary key', () {
      final collection = schemaMultiPk;
      late Cursor cursor;

      setUp(() async {
        connection = await connector.connect(_initDbMultiPK);
        cursor = await connection.cursor();
      });

      tearDown(() async {
        await connection.close();
      });

      test('insert without conflicts', () async {
        var obj1 = {
          "first_name": "Roland",
          "last_name": "Deschain",
        };

        var obj2 = {
          "first_name": "Susannah",
          "last_name": "Dean",
        };

        var operation = Insert(collection, [obj1, obj2]);
        await cursor.execute(operation);

        var obj3 = {
          "first_name": "Roland",
          "last_name": "Dean",
        };

        operation = Insert(collection, [obj3]);
        await cursor.execute(operation);

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, unorderedEquals([obj1, obj2, obj3]));
      });

      test('single insert with conflicts', () async {
        var obj1 = {
          "first_name": "Roland",
          "last_name": "Deschain",
        };

        var obj2 = {
          "first_name": "Roland",
          "last_name": "Deschain",
        };

        final operation = Insert(collection, [obj1]);
        await cursor.execute(operation);

        final conflictingOperation = Insert(collection, [obj2]);
        final execFuture = cursor.execute(conflictingOperation);
        expectLater(execFuture, throwsA(isA<IntegrityError>()));

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, equals([obj1]));
      });

      test('bulk insert with conflicts', () async {
        var obj1 = {
          "first_name": "Roland",
          "last_name": "Deschain",
        };

        var obj2 = {
          "first_name": "Roland",
          "last_name": "Deschain",
        };

        final operation = Insert(collection, [obj1, obj2]);
        final execFuture = cursor.execute(operation);
        expectLater(execFuture, throwsA(isA<IntegrityError>()));

        await cursor.execute(Query(from: collection));
        final fromDb = await cursor.fetchall();

        expect(fromDb, equals([]));
      });
    }, skip: requireFeature(DatabaseFeature.compoundPK));
  });
}