test(firebase_database): migrate to integration_test package

tests/integration_test/e2e_test.dart

@@ -11,6 +11,7 @@ import 'firebase_app_installations/firebase_app_installations_e2e_test.dart'
 import 'firebase_analytics/firebase_analytics_e2e_test.dart'
     as firebase_analytics;
 import 'firebase_core/firebase_core_e2e_test.dart' as firebase_core;
+import 'firebase_database/firebase_database_e2e_test.dart' as firebase_database;
 import 'firebase_dynamic_links/firebase_dynamic_links_e2e_test.dart'
     as firebase_dynamic_links;
 import 'firebase_in_app_messaging/firebase_in_app_messaging_e2e_test.dart'
@@ -27,6 +28,7 @@ void main() {
     firebase_app_installations.main();
     firebase_analytics.main();
     firebase_core.main();
+    firebase_database.main();
     firebase_dynamic_links.main();
     firebase_in_app_messaging.main();
     firebase_crashlytics.main();

tests/integration_test/firebase_database/data_snapshot_e2e.dart

@@ -0,0 +1,150 @@
+import 'package:firebase_database/firebase_database.dart';
+import 'package:drive/drive.dart';
+
+void setupDataSnapshotTests() {
+  group('DataSnapshot', () {
+    late DatabaseReference ref;
+
+    setUp(() async {
+      ref = FirebaseDatabase.instance.ref('tests');
+
+      // Wipe the database before each test
+      await ref.remove();
+    });
+
+    test('it returns the correct key', () async {
+      final s = await ref.get();
+      expect(s.key, 'tests');
+    });
+
+    test('it returns a string value', () async {
+      await ref.set('foo');
+      final s = await ref.get();
+      expect(s.value, 'foo');
+    });
+
+    test('it returns a number value', () async {
+      await ref.set(123);
+      final s = await ref.get();
+      expect(s.value, 123);
+    });
+
+    test('it returns a bool value', () async {
+      await ref.set(false);
+      final s = await ref.get();
+      expect(s.value, false);
+    });
+
+    test('it returns a null value', () async {
+      await ref.set(null);
+      final s = await ref.get();
+      expect(s.value, isNull);
+    });
+
+    test('it returns a List value', () async {
+      final data = [
+        'a',
+        2,
+        true,
+        ['foo'],
+        {
+          0: 'hello',
+          1: 'foo',
+        }
+      ];
+      await ref.set(data);
+      final s = await ref.get();
+      expect(
+        s.value,
+        equals([
+          'a',
+          2,
+          true,
+          ['foo'],
+          ['hello', 'foo']
+        ]),
+      );
+    });
+
+    test('it returns a Map value', () async {
+      final data = {'foo': 'bar'};
+      await ref.set(data);
+      final s = await ref.get();
+      expect(s.value, equals(data));
+    });
+
+    test('non-string Map keys are converted to strings', () async {
+      final data = {1: 'foo', 2: 'bar', 'foo': 'bar'};
+      await ref.set(data);
+      final s = await ref.get();
+      expect(s.value, equals({'1': 'foo', '2': 'bar', 'foo': 'bar'}));
+    });
+
+    test('setWithPriority returns the correct priority', () async {
+      await ref.setWithPriority('foo', 1);
+      final s = await ref.get();
+      expect(s.priority, 1);
+    });
+
+    test('setPriority returns the correct priority', () async {
+      await ref.set('foo');
+      await ref.setPriority(2);
+      final s = await ref.get();
+      expect(s.priority, 2);
+    });
+
+    test('exists returns true', () async {
+      await ref.set('foo');
+      final s = await ref.get();
+      expect(s.exists, isTrue);
+    });
+
+    test('exists returns false', () async {
+      final s = await ref.get();
+      expect(s.exists, isFalse);
+    });
+
+    test('hasChild returns false', () async {
+      final s = await ref.get();
+      expect(s.hasChild('bar'), isFalse);
+    });
+
+    test('hasChild returns true', () async {
+      await ref.set({
+        'foo': {'bar': 'baz'}
+      });
+      final s = await ref.get();
+      expect(s.hasChild('bar'), isFalse);
+    });
+
+    test('child returns the correct snapshot for lists', () async {
+      await ref.set([0, 1]);
+      final s = await ref.get();
+      expect(s.child('1'), isA<DataSnapshot>());
+      expect(s.child('1').value, 1);
+    });
+
+    test('child returns the correct snapshot', () async {
+      await ref.set({
+        'foo': {'bar': 'baz'}
+      });
+      final s = await ref.get();
+      expect(s.child('foo/bar'), isA<DataSnapshot>());
+      expect(s.child('foo/bar').value, 'baz');
+    });
+
+    test('children returns the children in order', () async {
+      await ref.set({
+        'a': 3,
+        'b': 2,
+        'c': 1,
+      });
+      final s = await ref.orderByValue().get();
+
+      List<DataSnapshot> children = s.children.toList();
+      expect(children[0].value, 1);
+      expect(children[1].value, 2);
+      expect(children[2].value, 3);
+    });
+  });
+}

tests/integration_test/firebase_database/database_e2e.dart

@@ -0,0 +1,86 @@
+import 'package:drive/drive.dart';
+import 'firebase_database_e2e_test.dart';
+
+void setupDatabaseTests() {
+  group('FirebaseDatabase.ref()', () {
+    setUpAll(() async {
+      await database.ref('tests/flutterfire').set(0);
+    });
+
+    test('returns a correct reference', () async {
+      final ref = database.ref('tests/flutterfire');
+      expect(ref.key, 'flutterfire');
+      expect(ref.parent, isNotNull);
+      expect(ref.parent!.key, 'tests');
+      expect(ref.parent!.parent, isNotNull);
+      expect(ref.parent!.parent?.key, isNull);
+
+      final snapshot = await ref.get();
+      expect(snapshot.key, 'flutterfire');
+      expect(snapshot.value, 0);
+    });
+
+    test(
+      'root reference path returns as "/"',
+      () async {
+        final rootRef = database.ref();
+        expect(rootRef.path, '/');
+        expect(rootRef.key, isNull);
+        expect(rootRef.parent, isNull);
+      },
+    );
+
+    test(
+      'returns a reference to the root of the database if no path specified',
+      () async {
+        final rootRef = database.ref();
+        expect(rootRef.key, isNull);
+        expect(rootRef.parent, isNull);
+
+        final childRef = rootRef.child('tests/flutterfire');
+        final snapshot = await childRef.get();
+        expect(snapshot.key, 'flutterfire');
+        expect(snapshot.value, 0);
+      },
+    );
+  });
+
+  group('FirebaseDatabase.refFromURL()', () {
+    test('correctly returns a ref for database root', () async {
+      final ref = database.refFromURL(
+        'https://flutterfire-e2e-tests-default-rtdb.europe-west1.firebasedatabase.app',
+      );
+      expect(ref.key, isNull);
+
+      final refWithTrailingSlash = database.refFromURL(
+        'https://flutterfire-e2e-tests-default-rtdb.europe-west1.firebasedatabase.app/',
+      );
+      expect(refWithTrailingSlash.key, isNull);
+    });
+
+    test('correctly returns a ref for any database path', () async {
+      final ref = database.refFromURL(
+        'https://flutterfire-e2e-tests-default-rtdb.europe-west1.firebasedatabase.app/foo',
+      );
+      expect(ref.key, 'foo');
+
+      final refWithNestedPath = database.refFromURL(
+        'https://flutterfire-e2e-tests-default-rtdb.europe-west1.firebasedatabase.app/foo/bar',
+      );
+      expect(refWithNestedPath.parent?.key, 'foo');
+      expect(refWithNestedPath.key, 'bar');
+    });
+
+    test('throws [ArgumentError] if not a valid https:// url', () async {
+      expect(() => database.refFromURL('foo'), throwsArgumentError);
+    });
+
+    test('throws [ArgumentError] if database url does not match instance url',
+        () async {
+      expect(
+        () => database.refFromURL('https://some-other-database.firebaseio.com'),
+        throwsArgumentError,
+      );
+    });
+  });
+}