Add missing data tests

Author: Kamil Klyta

lib/src/controller.dart

@@ -142,6 +142,9 @@ class IndicatorController extends ChangeNotifier {
 
   bool _shouldStopDrag;
 
+  /// Should the dragging be stopped
+  bool get shouldStopDrag => _shouldStopDrag;
+
   /// Whether custom refresh indicator can change [IndicatorState] from `idle` to `dragging`
   bool get isRefreshEnabled => _isRefreshEnabled;
   bool _isRefreshEnabled;

test/src/controller_test.dart

@@ -187,4 +187,102 @@ void main() {
     expect(controller.isScrollingReverse, isTrue);
     expect(controller.isScrollIdle, isFalse);
   });
+
+  group('IndicatorSide -', () {
+    test('AxisDirection.up - start edge', () {
+      final controller = IndicatorController()
+        ..setAxisDirection(AxisDirection.up)
+        ..setIndicatorEdge(IndicatorEdge.start);
+
+      expect(controller.side, IndicatorSide.bottom);
+    });
+    test('AxisDirection.up - end edge', () {
+      final controller = IndicatorController()
+        ..setAxisDirection(AxisDirection.up)
+        ..setIndicatorEdge(IndicatorEdge.end);
+
+      expect(controller.side, IndicatorSide.top);
+    });
+
+    test('AxisDirection.down - start edge', () {
+      final controller = IndicatorController()
+        ..setAxisDirection(AxisDirection.down)
+        ..setIndicatorEdge(IndicatorEdge.start);
+
+      expect(controller.side, IndicatorSide.top);
+    });
+    test('AxisDirection.down - end edge', () {
+      final controller = IndicatorController()
+        ..setAxisDirection(AxisDirection.down)
+        ..setIndicatorEdge(IndicatorEdge.end);
+
+      expect(controller.side, IndicatorSide.bottom);
+    });
+
+    test('AxisDirection.left - start edge', () {
+      final controller = IndicatorController()
+        ..setAxisDirection(AxisDirection.left)
+        ..setIndicatorEdge(IndicatorEdge.start);
+
+      expect(controller.side, IndicatorSide.left);
+    });
+    test('AxisDirection.left - end edge', () {
+      final controller = IndicatorController()
+        ..setAxisDirection(AxisDirection.left)
+        ..setIndicatorEdge(IndicatorEdge.end);
+
+      expect(controller.side, IndicatorSide.right);
+    });
+    test('AxisDirection.right - start edge', () {
+      final controller = IndicatorController()
+        ..setAxisDirection(AxisDirection.right)
+        ..setIndicatorEdge(IndicatorEdge.start);
+
+      expect(controller.side, IndicatorSide.right);
+    });
+    test('AxisDirection.right - end edge', () {
+      final controller = IndicatorController()
+        ..setAxisDirection(AxisDirection.right)
+        ..setIndicatorEdge(IndicatorEdge.end);
+
+      expect(controller.side, IndicatorSide.left);
+    });
+
+    test('AxisDirection.right - end none', () {
+      final controller = IndicatorController()..setIndicatorEdge(null);
+
+      expect(controller.side, IndicatorSide.none);
+    });
+  });
+
+  test('stopDrag - changes the shouldStopDrag - valid state', () {
+    var controller = IndicatorController()
+      ..setIndicatorState(IndicatorState.dragging);
+    expect(controller.shouldStopDrag, isFalse);
+    controller.stopDrag();
+    expect(controller.shouldStopDrag, isTrue);
+
+    controller = IndicatorController()..setIndicatorState(IndicatorState.armed);
+    expect(controller.shouldStopDrag, isFalse);
+    controller.stopDrag();
+    expect(controller.shouldStopDrag, isTrue);
+  });
+
+  test('stopDrag - changes the shouldStopDrag - invalid state', () {
+    var controller = IndicatorController()
+      ..setIndicatorState(IndicatorState.idle);
+    expect(() => controller.stopDrag(), throwsA(isA<StateError>()));
+
+    controller = IndicatorController()
+      ..setIndicatorState(IndicatorState.loading);
+    expect(() => controller.stopDrag(), throwsA(isA<StateError>()));
+
+    controller = IndicatorController()
+      ..setIndicatorState(IndicatorState.complete);
+    expect(() => controller.stopDrag(), throwsA(isA<StateError>()));
+
+    controller = IndicatorController()
+      ..setIndicatorState(IndicatorState.hiding);
+    expect(() => controller.stopDrag(), throwsA(isA<StateError>()));
+  });
 }

test/src/data/data_test.dart

@@ -58,6 +58,22 @@ void main() {
     );
   });
 
+  test('Equality operator works correctly', () async {
+    // ignore: prefer_const_constructors
+    final a = IndicatorStateChange(
+      IndicatorState.idle,
+      IndicatorState.dragging,
+    );
+    // ignore: prefer_const_constructors
+    final b = IndicatorStateChange(
+      IndicatorState.idle,
+      IndicatorState.dragging,
+    );
+
+    expect(a, equals(b));
+    expect(a.hashCode, equals(b.hashCode));
+  });
+
   test("toString method works correctly", () {
     var change = const IndicatorStateChange(
       IndicatorState.dragging,

test/src/data/indicator_edge_test.dart

@@ -0,0 +1,16 @@
+import 'package:custom_refresh_indicator/src/data/indicator_edge.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  test('IndicatorEdgeGetters - end', () async {
+    const end = IndicatorEdge.end;
+    expect(end.isStart, isFalse);
+    expect(end.isEnd, isTrue);
+  });
+
+  test('IndicatorEdgeGetters - start', () async {
+    const start = IndicatorEdge.start;
+    expect(start.isStart, isTrue);
+    expect(start.isEnd, isFalse);
+  });
+}

test/src/data/indicator_side_test.dart

@@ -0,0 +1,49 @@
+import 'package:custom_refresh_indicator/custom_refresh_indicator.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  test('IndicatorSideGetters - left', () async {
+    const left = IndicatorSide.left;
+    expect(left.isLeft, isTrue);
+    expect(left.isTop, isFalse);
+    expect(left.isRight, isFalse);
+    expect(left.isBottom, isFalse);
+    expect(left.isNone, isFalse);
+  });
+
+  test('IndicatorSideGetters - right', () async {
+    const right = IndicatorSide.right;
+    expect(right.isLeft, isFalse);
+    expect(right.isTop, isFalse);
+    expect(right.isRight, isTrue);
+    expect(right.isBottom, isFalse);
+    expect(right.isNone, isFalse);
+  });
+
+  test('IndicatorSideGetters - top', () async {
+    const right = IndicatorSide.top;
+    expect(right.isLeft, isFalse);
+    expect(right.isTop, isTrue);
+    expect(right.isRight, isFalse);
+    expect(right.isBottom, isFalse);
+    expect(right.isNone, isFalse);
+  });
+
+  test('IndicatorSideGetters - bottom', () async {
+    const right = IndicatorSide.bottom;
+    expect(right.isLeft, isFalse);
+    expect(right.isTop, isFalse);
+    expect(right.isRight, isFalse);
+    expect(right.isBottom, isTrue);
+    expect(right.isNone, isFalse);
+  });
+
+  test('IndicatorSideGetters - none', () async {
+    const none = IndicatorSide.none;
+    expect(none.isLeft, isFalse);
+    expect(none.isTop, isFalse);
+    expect(none.isRight, isFalse);
+    expect(none.isBottom, isFalse);
+    expect(none.isNone, isTrue);
+  });
+}