feat: Buat business logic fitur delete track user

Sekalian dengan unit test-nya.

Author: CoderJava

lib/feature/presentation/bloc/tracking/tracking_bloc.dart

@@ -5,6 +5,7 @@ import 'package:bloc_concurrency/bloc_concurrency.dart';
 import 'package:dipantau_desktop_client/core/util/helper.dart';
 import 'package:dipantau_desktop_client/feature/data/model/create_track/create_track_body.dart';
 import 'package:dipantau_desktop_client/feature/domain/usecase/create_track/create_track.dart';
+import 'package:dipantau_desktop_client/feature/domain/usecase/delete_track_user/delete_track_user.dart';
 
 part 'tracking_event.dart';
 
@@ -13,12 +14,16 @@ part 'tracking_state.dart';
 class TrackingBloc extends Bloc<TrackingEvent, TrackingState> {
   final CreateTrack createTrack;
   final Helper helper;
+  final DeleteTrackUser deleteTrackUser;
 
   TrackingBloc({
     required this.createTrack,
     required this.helper,
+    required this.deleteTrackUser,
   }) : super(InitialTrackingState()) {
     on<CreateTimeTrackingEvent>(_onCreateTimeTrackingEvent, transformer: sequential());
+
+    on<DeleteTrackUserTrackingEvent>(_onDeleteTrackUserTrackingEvent);
   }
 
   FutureOr<void> _onCreateTimeTrackingEvent(
@@ -42,4 +47,31 @@ class TrackingBloc extends Bloc<TrackingEvent, TrackingState> {
     final errorMessage = helper.getErrorMessageFromFailure(failure);
     emit(FailureTrackingState(errorMessage: errorMessage));
   }
+
+  FutureOr<void> _onDeleteTrackUserTrackingEvent(
+    DeleteTrackUserTrackingEvent event,
+    Emitter<TrackingState> emit,
+  ) async {
+    emit(LoadingTrackingState());
+    await Future.delayed(const Duration(seconds: 3));
+    final trackId = event.trackId;
+    final result = await deleteTrackUser(
+      ParamsDeleteTrackUser(
+        trackId: event.trackId,
+      ),
+    );
+    final response = result.response;
+    final failure = result.failure;
+    if (response != null) {
+      emit(
+        SuccessDeleteTrackUserTrackingState(
+          trackId: trackId,
+        ),
+      );
+      return;
+    }
+
+    final errorMessage = helper.getErrorMessageFromFailure(failure);
+    emit(FailureTrackingState(errorMessage: errorMessage));
+  }
 }

lib/feature/presentation/bloc/tracking/tracking_event.dart

@@ -17,4 +17,15 @@ class CreateTimeTrackingEvent extends TrackingEvent {
   String toString() {
     return 'CreateTimeTrackingEvent{body: $body, trackEntityId: $trackEntityId}';
   }
+}
+
+class DeleteTrackUserTrackingEvent extends TrackingEvent {
+  final int trackId;
+
+  DeleteTrackUserTrackingEvent({required this.trackId});
+
+  @override
+  String toString() {
+    return 'DeleteTrackUserTrackingEvent{trackId: $trackId}';
+  }
 }

lib/feature/presentation/bloc/tracking/tracking_state.dart

@@ -32,4 +32,15 @@ class SuccessCreateTimeTrackingState extends TrackingState {
   String toString() {
     return 'SuccessCreateTimeTrackingState{files: $files, trackEntityId: $trackEntityId}';
   }
-}
+}
+
+class SuccessDeleteTrackUserTrackingState extends TrackingState {
+  final int trackId;
+
+  SuccessDeleteTrackUserTrackingState({required this.trackId});
+
+  @override
+  String toString() {
+    return 'SuccessDeleteTrackUserTrackingState{trackId: $trackId}';
+  }
+}

test/feature/presentation/bloc/tracking/tracking_bloc_test.dart

@@ -5,6 +5,7 @@ import 'package:dipantau_desktop_client/core/error/failure.dart';
 import 'package:dipantau_desktop_client/feature/data/model/create_track/create_track_body.dart';
 import 'package:dipantau_desktop_client/feature/data/model/general/general_response.dart';
 import 'package:dipantau_desktop_client/feature/domain/usecase/create_track/create_track.dart';
+import 'package:dipantau_desktop_client/feature/domain/usecase/delete_track_user/delete_track_user.dart';
 import 'package:dipantau_desktop_client/feature/presentation/bloc/tracking/tracking_bloc.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:mockito/mockito.dart';
@@ -16,13 +17,16 @@ void main() {
   late TrackingBloc bloc;
   late MockCreateTrack mockCreateTrack;
   late MockHelper mockHelper;
+  late MockDeleteTrackUser mockDeleteTrackUser;
 
   setUp(() {
     mockCreateTrack = MockCreateTrack();
     mockHelper = MockHelper();
+    mockDeleteTrackUser = MockDeleteTrackUser();
     bloc = TrackingBloc(
       createTrack: mockCreateTrack,
       helper: mockHelper,
+      deleteTrackUser: mockDeleteTrackUser,
     );
   });
 
@@ -134,4 +138,99 @@ void main() {
       },
     );
   });
+
+  group('delete track user', () {
+    const trackId = 1;
+    final params = ParamsDeleteTrackUser(trackId: trackId);
+    final response = GeneralResponse.fromJson(
+      json.decode(
+        fixture('general_response.json'),
+      ),
+    );
+    final event = DeleteTrackUserTrackingEvent(trackId: trackId);
+
+    blocTest(
+      'pastikan emit [LoadingTrackingState, SuccessDeleteTrackingUserTrackingState] ketika terima event '
+      'DeleteTrackUserTrackingEvent dengan proses berhasil',
+      build: () {
+        final result = (failure: null, response: response);
+        when(mockDeleteTrackUser(any)).thenAnswer((_) async => result);
+        return bloc;
+      },
+      act: (TrackingBloc bloc) {
+        return bloc.add(event);
+      },
+      wait: const Duration(seconds: 3),
+      expect: () => [
+        isA<LoadingTrackingState>(),
+        isA<SuccessDeleteTrackUserTrackingState>(),
+      ],
+      verify: (_) {
+        verify(mockDeleteTrackUser(params));
+      },
+    );
+
+    blocTest(
+      'pastikan emit [LoadingTrackingState, FailureTrackingState] ketika terima event '
+      'DeleteTrackUserTrackingEvent dengan proses gagal dari API',
+      build: () {
+        final result = (failure: ServerFailure(tErrorMessage), response: null);
+        when(mockDeleteTrackUser(any)).thenAnswer((_) async => result);
+        return bloc;
+      },
+      act: (TrackingBloc bloc) {
+        return bloc.add(event);
+      },
+      wait: const Duration(seconds: 3),
+      expect: () => [
+        isA<LoadingTrackingState>(),
+        isA<FailureTrackingState>(),
+      ],
+      verify: (_) {
+        verify(mockDeleteTrackUser(params));
+      },
+    );
+
+    blocTest(
+      'pastikan emit [LoadingTrackingState, FailureTrackingState] ketika terima event '
+      'DeleteTrackUserTrackingEvent dengan kondisi internet tidak terhubung',
+      build: () {
+        final result = (failure: ConnectionFailure(), response: null);
+        when(mockDeleteTrackUser(any)).thenAnswer((_) async => result);
+        return bloc;
+      },
+      act: (TrackingBloc bloc) {
+        return bloc.add(event);
+      },
+      wait: const Duration(seconds: 3),
+      expect: () => [
+        isA<LoadingTrackingState>(),
+        isA<FailureTrackingState>(),
+      ],
+      verify: (_) {
+        verify(mockDeleteTrackUser(params));
+      },
+    );
+
+    blocTest(
+      'pastikan emit [LoadingTrackingState, FailureTrackingState] ketika terima event '
+      'DeleteTrackUserTrackingEvent dengan proses gagal parsing respon JSON dari API',
+      build: () {
+        final result = (failure: ParsingFailure(tErrorMessage), response: null);
+        when(mockDeleteTrackUser(any)).thenAnswer((_) async => result);
+        return bloc;
+      },
+      act: (TrackingBloc bloc) {
+        return bloc.add(event);
+      },
+      wait: const Duration(seconds: 3),
+      expect: () => [
+        isA<LoadingTrackingState>(),
+        isA<FailureTrackingState>(),
+      ],
+      verify: (_) {
+        verify(mockDeleteTrackUser(params));
+      },
+    );
+  });
 }

test/feature/presentation/bloc/tracking/tracking_event_test.dart

@@ -26,4 +26,19 @@ void main() {
       },
     );
   });
+
+  group('DeleteTrackUserTrackingEvent', () {
+    final tEvent = DeleteTrackUserTrackingEvent(trackId: 1);
+
+    test(
+      'pastikan output dari fungsi toString',
+      () async {
+        // assert
+        expect(
+          tEvent.toString(),
+          'DeleteTrackUserTrackingEvent{trackId: ${tEvent.trackId}}',
+        );
+      },
+    );
+  });
 }

test/feature/presentation/bloc/tracking/tracking_state_test.dart

@@ -34,4 +34,19 @@ void main() {
       },
     );
   });
+
+  group('SuccessDeleteTrackUserTrackingState', () {
+    final tState = SuccessDeleteTrackUserTrackingState(trackId: 1);
+
+    test(
+      'pastikan output dari fungsi toString',
+      () async {
+        // assert
+        expect(
+          tState.toString(),
+          'SuccessDeleteTrackUserTrackingState{trackId: ${tState.trackId}}',
+        );
+      },
+    );
+  });
 }