query tests added

packages/fl_query/test/query_test.dart

@@ -2,23 +2,38 @@ import 'dart:math';
 
 import 'package:fl_query/src/models/query_job.dart';
 import 'package:fl_query/src/query.dart';
+import 'package:fl_query/src/query_bowl.dart';
 import 'package:flutter_test/flutter_test.dart';
-import 'package:mocktail/mocktail.dart';
-
-class MockQueryJob extends Mock implements QueryJob {}
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'query_test.mocks.dart';
 
+@GenerateMocks(
+  [QueryBowl],
+  customMocks: [
+    MockSpec<QueryJob<Object, void>>(
+      as: #MockQueryJobVoidObject,
+      returnNullOnMissingStub: true,
+    ),
+  ],
+)
 void main() {
   // for testing query without external data
   late Query query;
-  late QueryJob queryJob;
+  late MockQueryJobVoidObject queryJob;
+  late MockQueryBowl queryBowl;
   setUp(() {
-    queryJob = MockQueryJob();
-    when(() => queryJob.queryKey).thenReturn("test");
-    when(() => queryJob.task("test", null))
-        .thenAnswer((_) => (_, __) => "test");
+    queryJob = MockQueryJobVoidObject();
+    queryBowl = MockQueryBowl();
+    when(queryJob.queryKey).thenReturn("test");
+    when(queryJob.task).thenAnswer(
+      (_) =>
+          (_, __) => Future.delayed(Duration(milliseconds: 300), () => "test"),
+    );
     query = Query.fromOptions(
       queryJob,
       externalData: null,
+      queryBowl: queryBowl,
     );
   });
 
@@ -30,11 +45,11 @@ void main() {
       expect(query.retryAttempts, 0);
       expect(query.fetched, isFalse);
       expect(query.retryDelay, Duration(milliseconds: 200));
-      expect(query.status, QueryStatus.loading);
+      expect(query.status, QueryStatus.idle);
       expect(query.isStale, isFalse);
-      expect(query.isIdle, isFalse);
+      expect(query.isIdle, true);
       expect(query.isInactive, isTrue);
-      expect(query.isLoading, isTrue);
+      expect(query.isLoading, isFalse);
       expect(query.isSuccess, isFalse);
       expect(query.hasError, isFalse);
       expect(query.hasData, isFalse);
@@ -42,10 +57,9 @@ void main() {
 
     test("calling fetch for the first time runs the _execute method", () async {
       final data = await query.fetch();
-
       expect(data, "test");
       expect(query.fetched, isTrue);
-      verify(() => queryJob.task("test", null)).called(1);
+      verify(queryJob.task).called(1);
     });
 
     test(
@@ -57,21 +71,87 @@ void main() {
       await query.fetch();
       await query.fetch();
       expect(data1, data2);
-      verify(() => queryJob.task("test", null)).called(1);
+      verify(queryJob.task).called(1);
     });
 
     test('calling refetch should return new data', () async {
       reset(queryJob);
-      when(() => queryJob.queryKey).thenReturn("test-1");
-      when(() => queryJob.task("test-1", null)).thenAnswer((_) => (_, __) {
-            return Future.value(Random().nextInt(100).toString());
-          });
-      final data = await query.fetch();
-      await Future.delayed(Duration(milliseconds: 100));
-      final refetchData = await query.refetch();
+      when(queryJob.queryKey).thenReturn("test");
+      when(queryJob.task).thenAnswer(
+        (_) => (_, __) => Future.value(Random().nextInt(100)),
+      );
+      query = Query.fromOptions(
+        queryJob,
+        externalData: null,
+        queryBowl: queryBowl,
+      );
 
-      expect(data, isNot(equals(refetchData)));
-      verify(() => queryJob.task("test-1", null)).called(2);
+      await Future.delayed(Duration(milliseconds: 100));
+      await query.fetch().then((data) async {
+        final refetchData = await query.refetch();
+        expect(data, isNot(equals(refetchData)));
+      });
     });
+
+    test(
+      "refetch should not run When another refetch is already running",
+      () async {
+        await query.fetch();
+        await Future.delayed(Duration(milliseconds: 100));
+        await Future.wait([
+          query.refetch(),
+          query.refetch(),
+        ]);
+        expect(query.refetchCount, 1);
+      },
+    );
+    test(
+      "failing task should be retried the amount of times passed as retries parameter",
+      () async {
+        reset(queryJob);
+        when(queryJob.queryKey).thenReturn("test");
+        when(queryJob.task).thenAnswer(
+          (_) => (_, __) => Future.error("Error"),
+        );
+        query = Query.fromOptions(
+          queryJob,
+          externalData: null,
+          queryBowl: queryBowl,
+        );
+
+        await query.fetch();
+
+        expect(query.retryAttempts, 3);
+        expect(query.isError, true);
+      },
+    );
+    test(
+      "onData listeners are called When new data is fetched and set",
+      () async {
+        int count = 0;
+        query.onDataListeners.add((_) {
+          count++;
+        });
+        await query.fetch();
+        expect(count, 1);
+      },
+    );
+    test(
+      "onError listeners are called When any error occurs",
+      () {},
+    );
+    test("query should become stale after defined amount time", () {});
+    test(
+      "query should refetch in interval When refetchInterval is specified",
+      () {},
+    );
+    test(
+      "query should revalidate When a new caller gets mounted",
+      () {},
+    );
+    test(
+      "query should not revalidate When there's no Internet Connectivity and a new caller gets mounted",
+      () {},
+    );
   });
 }