implement unit testing for new added features

Author: amitamrutiya

lib/Pages/torrent_screen.dart

@@ -23,8 +23,6 @@ class TorrentScreen extends StatefulWidget {
   _TorrentScreenState createState() => _TorrentScreenState();
 }
 
-List<String> trackerURIsList = [];
-
 class _TorrentScreenState extends State<TorrentScreen> {
   String keyword = '';
 

lib/Provider/filter_provider.dart

@@ -16,10 +16,8 @@ class FilterProvider extends ChangeNotifier {
   List<String> statusList = [];
   var mapStatus = {};
   String tagSelected = '';
-  List<String> tagList = [];
   Map<String, dynamic> mapTags = {'Untagged': 0};
   String trackerURISelected = '';
-  List<String> trackerURIsList = [];
   var trackersSizeList = [];
   var tagsSizeList = [];
   var maptrackerURIs = {};

test/api_provider_unit_test.dart

@@ -2,6 +2,7 @@ import 'package:flood_mobile/Provider/api_provider.dart';
 import 'package:flutter_test/flutter_test.dart';
 
 void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
   late ApiProvider sut;
 
   setUp(() {

test/client_provider_test.dart

@@ -0,0 +1,45 @@
+import 'package:flood_mobile/Model/client_settings_model.dart';
+import 'package:flood_mobile/Provider/client_provider.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  late ClientSettingsProvider sut;
+  late ClientSettingsModel newClientSettings;
+
+  setUp(() {
+    sut = ClientSettingsProvider();
+    newClientSettings = ClientSettingsModel(
+      dht: false,
+      dhtPort: 1234,
+      directoryDefault: 'path/to/directory',
+      networkHttpMaxOpen: 10,
+      networkLocalAddress: ['192.168.0.1', '192.168.0.2'],
+      networkMaxOpenFiles: 100,
+      networkPortOpen: true,
+      networkPortRandom: false,
+      networkPortRange: '6881-6889',
+      piecesHashOnCompletion: true,
+      piecesMemoryMax: 512,
+      protocolPex: true,
+      throttleGlobalDownSpeed: 1024,
+      throttleGlobalUpSpeed: 2048,
+      throttleMaxDownloads: 5,
+      throttleMaxDownloadsGlobal: 10,
+      throttleMaxPeersNormal: 50,
+      throttleMaxPeersSeed: 100,
+      throttleMaxUploads: 3,
+      throttleMaxUploadsGlobal: 6,
+      throttleMinPeersNormal: 10,
+      throttleMinPeersSeed: 20,
+      trackersNumWant: 30,
+    );
+  });
+
+  test(
+    "initial values are correct",
+    () {
+      sut.setClientSettings(newClientSettings);
+      expect(sut.clientSettings, newClientSettings);
+    },
+  );
+}

test/color_provider_unit_test.dart

@@ -0,0 +1,26 @@
+import 'package:flood_mobile/Components/onboarding/data/onboard_page_data.dart';
+import 'package:flood_mobile/Provider/color_provider.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('ColorProvider', () {
+    late ColorProvider colorProvider;
+
+    setUp(() {
+      colorProvider = ColorProvider();
+    });
+
+    test(
+        'Initial color should match the first accent color from the onboard data',
+        () {
+      expect(colorProvider.color, equals(onboardData[0].accentColor));
+    });
+
+    test('Setting a new color should update the color value', () {
+      const newColor = Colors.blue;
+      colorProvider.color = newColor;
+      expect(colorProvider.color, equals(newColor));
+    });
+  });
+}

test/filter_provider_unit_test.dart

@@ -0,0 +1,77 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flood_mobile/Provider/filter_provider.dart';
+
+void main() {
+  group('FilterProvider', () {
+    late FilterProvider filterProvider;
+
+    setUp(() {
+      filterProvider = FilterProvider();
+    });
+
+    test('setFilterSelected should update filterStatus', () {
+      final newFilterStatus = FilterValue.active;
+      expect(filterProvider.filterStatus, equals(FilterValue.all));
+      filterProvider.setFilterSelected(newFilterStatus);
+      expect(filterProvider.filterStatus, equals(newFilterStatus));
+    });
+
+    test('setmapStatus should update mapStatus', () {
+      final newMapStatus = {'status1': true, 'status2': false};
+      expect(filterProvider.mapStatus, isEmpty);
+      filterProvider.setmapStatus(newMapStatus);
+      expect(filterProvider.mapStatus, equals(newMapStatus));
+    });
+
+    test('setstatusList should update statusList', () {
+      final newStatusList = ['status1', 'status2', 'status3'];
+      expect(filterProvider.statusList, isEmpty);
+      filterProvider.setstatusList(newStatusList);
+      expect(filterProvider.statusList, equals(newStatusList));
+    });
+
+    test('setTagSelected should update tagSelected and notify listeners', () {
+      final newTagSelected = 'New Tag';
+      expect(filterProvider.tagSelected, isEmpty);
+      filterProvider.setTagSelected(newTagSelected);
+      expect(filterProvider.tagSelected, equals(newTagSelected));
+    });
+
+    test('setmapTags should update mapTags', () {
+      final newMapTags = {'tag1': 0, 'tag2': 1, 'tag3': 2};
+      expect(filterProvider.mapTags, equals({'Untagged': 0}));
+      filterProvider.setmapTags(newMapTags);
+      expect(filterProvider.mapTags, equals(newMapTags));
+    });
+
+    test('setTagsSizeList should update tagsSizeList', () {
+      final newTagsSizeList = [10, 20, 30];
+      expect(filterProvider.tagsSizeList, isEmpty);
+      filterProvider.setTagsSizeList(newTagsSizeList);
+      expect(filterProvider.tagsSizeList, equals(newTagsSizeList));
+    });
+
+    test(
+        'settrackerURISelected should update trackerURISelected and notify listeners',
+        () {
+      final newTrackerURISelected = 'New Tracker URI';
+      expect(filterProvider.trackerURISelected, isEmpty);
+      filterProvider.settrackerURISelected(newTrackerURISelected);
+      expect(filterProvider.trackerURISelected, equals(newTrackerURISelected));
+    });
+
+    test('setmaptrackerURIs should update maptrackerURIs', () {
+      final newMaptrackerURIs = {'uri1': true, 'uri2': false};
+      expect(filterProvider.maptrackerURIs, isEmpty);
+      filterProvider.setmaptrackerURIs(newMaptrackerURIs);
+      expect(filterProvider.maptrackerURIs, equals(newMaptrackerURIs));
+    });
+
+    test('setTrackersSizeList should update trackersSizeList', () {
+      final newTrackersSizeList = [100, 200, 300];
+      expect(filterProvider.trackersSizeList, isEmpty);
+      filterProvider.setTrackersSizeList(newTrackersSizeList);
+      expect(filterProvider.trackersSizeList, equals(newTrackersSizeList));
+    });
+  });
+}

test/graph_provider_unit_test.dart

@@ -0,0 +1,83 @@
+import 'package:flood_mobile/Provider/graph_provider.dart';
+import 'package:flood_mobile/Provider/home_provider.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('GraphProvider', () {
+    late GraphProvider graphProvider;
+
+    setUp(() {
+      graphProvider = GraphProvider();
+    });
+
+    test('Initial upload graph data should have 30 items with speed 0.00', () {
+      expect(graphProvider.uploadGraphData.length, equals(30));
+
+      for (final item in graphProvider.uploadGraphData) {
+        expect(item.speed, equals(0.00));
+      }
+    });
+
+    test('Initial download graph data should have 30 items with speed 0.00',
+        () {
+      expect(graphProvider.downloadGraphData.length, equals(30));
+
+      for (final item in graphProvider.downloadGraphData) {
+        expect(item.speed, equals(0.00));
+      }
+    });
+
+    test('Initial fake time should be 31', () {
+      expect(graphProvider.fakeTime, equals(31));
+    });
+
+    test('Initial show chart status should be false', () {
+      expect(graphProvider.showChart, isFalse);
+    });
+
+    test('Changing chart status should toggle the show chart status', () {
+      final initialStatus = graphProvider.showChart;
+
+      graphProvider.changChartStatus();
+
+      expect(graphProvider.showChart, isNot(equals(initialStatus)));
+
+      graphProvider.changChartStatus();
+
+      expect(graphProvider.showChart, equals(initialStatus));
+    });
+
+    test('updateDataSource should update the graph data correctly', () {
+      final graphProvider = GraphProvider();
+      final homeProvider = HomeProvider();
+      homeProvider.upSpeed = '100 KB/s';
+      homeProvider.downSpeed = '200 KB/s';
+
+      graphProvider.updateDataSource(homeProvider);
+
+      final uploadGraphData = graphProvider.uploadGraphData;
+      final downloadGraphData = graphProvider.downloadGraphData;
+
+      // Check if the last entry in uploadGraphData is updated correctly
+      expect(uploadGraphData.last.speed, 100.0);
+      expect(uploadGraphData.last.second, 31);
+
+      // Check if the last entry in downloadGraphData is updated correctly
+      expect(downloadGraphData.last.speed, 200.0);
+      expect(downloadGraphData.last.second, 31);
+
+      // Check if the first entry in uploadGraphData is removed
+      expect(uploadGraphData.length, 30);
+      expect(uploadGraphData.first.speed, 0.0);
+      expect(uploadGraphData.first.second, 2);
+
+      // Check if the first entry in downloadGraphData is removed
+      expect(downloadGraphData.length, 30);
+      expect(downloadGraphData.first.speed, 0.0);
+      expect(downloadGraphData.first.second, 2);
+
+      // Check if the fakeTime is incremented
+      expect(graphProvider.fakeTime, 32);
+    });
+  });
+}