nico-tools 1.0.0 → 1.1.0

package/templates/react-native/expo-clean-architecture/tests/core/services/local-storage-service-impl.test.ts

@@ -0,0 +1,108 @@
+import { LocalStorageServiceImpl } from "@/core/services/local-storage-service-impl";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+// Mock AsyncStorage
+jest.mock("@react-native-async-storage/async-storage", () => ({
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+  removeItem: jest.fn(),
+  clear: jest.fn(),
+}));
+
+describe("LocalStorageService", () => {
+  let service: LocalStorageServiceImpl;
+
+  beforeEach(() => {
+    // Clear all mocks before each test
+    jest.clearAllMocks();
+    service = new LocalStorageServiceImpl();
+  });
+
+  describe("getItem", () => {
+    it("should return stringified value when item exists", async () => {
+      const mockValue = { test: "data" };
+      (AsyncStorage.getItem as jest.Mock).mockResolvedValue(
+        JSON.stringify(mockValue)
+      );
+
+      const result = await service.getItem("test-key", "");
+      expect(result).toEqual(JSON.stringify(mockValue));
+      expect(AsyncStorage.getItem).toHaveBeenCalledWith("test-key");
+    });
+
+    it("should return default value when item doesn't exist", async () => {
+      (AsyncStorage.getItem as jest.Mock).mockResolvedValue(null);
+      const defaultValue = { default: "value" };
+
+      const result = await service.getItem(
+        "test-key",
+        JSON.stringify(defaultValue)
+      );
+
+      expect(result).toEqual(JSON.stringify(defaultValue));
+      expect(AsyncStorage.getItem).toHaveBeenCalledWith("test-key");
+    });
+  });
+
+  describe("setItem", () => {
+    it("should store stringified value", async () => {
+      const value = { test: "data" };
+      await service.setItem("test-key", JSON.stringify(value));
+
+      expect(AsyncStorage.setItem).toHaveBeenCalledWith(
+        "test-key",
+        JSON.stringify(value)
+      );
+    });
+  });
+
+  describe("removeItem", () => {
+    it("should remove item from storage", async () => {
+      await service.removeItem("test-key");
+      expect(AsyncStorage.removeItem).toHaveBeenCalledWith("test-key");
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear all items from storage", async () => {
+      await service.clear();
+      expect(AsyncStorage.clear).toHaveBeenCalled();
+    });
+  });
+
+  describe("error handling", () => {
+    it("should throw error when getItem fails", async () => {
+      const error = new Error("Storage error");
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(error);
+
+      await expect(service.getItem("test-key", "")).rejects.toThrow(
+        "Storage error"
+      );
+    });
+
+    it("should throw error when setItem fails", async () => {
+      const error = new Error("Storage error");
+      (AsyncStorage.setItem as jest.Mock).mockRejectedValue(error);
+
+      await expect(service.setItem("test-key", "value")).rejects.toThrow(
+        "Storage error"
+      );
+    });
+
+    it("should throw error when removeItem fails", async () => {
+      const error = new Error("Storage error");
+      (AsyncStorage.removeItem as jest.Mock).mockRejectedValue(error);
+
+      await expect(service.removeItem("test-key")).rejects.toThrow(
+        "Storage error"
+      );
+    });
+
+    it("should throw error when clear fails", async () => {
+      const error = new Error("Storage error");
+      (AsyncStorage.clear as jest.Mock).mockRejectedValue(error);
+
+      await expect(service.clear()).rejects.toThrow("Storage error");
+    });
+  });
+});

package/templates/react-native/expo-clean-architecture/tests/core/services/monitoring-service.test.ts

@@ -0,0 +1,74 @@
+import { MonitoringServiceImpl } from "@/core/services/monitoring-service-impl";
+import {
+  recordError,
+  getCrashlytics,
+} from "@react-native-firebase/crashlytics";
+
+// Mock @react-native-firebase/crashlytics
+jest.mock("@react-native-firebase/crashlytics", () => ({
+  getCrashlytics: jest.fn(),
+  recordError: jest.fn(),
+}));
+
+describe("MonitoringServiceImpl", () => {
+  let monitoringService: MonitoringServiceImpl;
+  let mockCrashlytics: any;
+
+  beforeEach(() => {
+    // Reset all mocks before each test
+    jest.clearAllMocks();
+
+    // Setup mock crashlytics instance
+    mockCrashlytics = {};
+    (getCrashlytics as jest.Mock).mockReturnValue(mockCrashlytics);
+
+    monitoringService = new MonitoringServiceImpl();
+  });
+
+  describe("report", () => {
+    it("should report error to crashlytics", () => {
+      const testError = new Error("Test error");
+
+      monitoringService.report(testError);
+
+      expect(getCrashlytics).toHaveBeenCalledTimes(1);
+      expect(recordError).toHaveBeenCalledWith(mockCrashlytics, testError);
+    });
+
+    it("should handle different types of errors", () => {
+      // Test with TypeError
+      const typeError = new TypeError("Type error");
+      monitoringService.report(typeError);
+      expect(recordError).toHaveBeenCalledWith(mockCrashlytics, typeError);
+
+      // Test with ReferenceError
+      const referenceError = new ReferenceError("Reference error");
+      monitoringService.report(referenceError);
+      expect(recordError).toHaveBeenCalledWith(mockCrashlytics, referenceError);
+
+      // Test with custom error
+      const customError = new Error("Custom error");
+      customError.name = "CustomError";
+      monitoringService.report(customError);
+      expect(recordError).toHaveBeenCalledWith(mockCrashlytics, customError);
+    });
+
+    it("should handle error with additional properties", () => {
+      const error = new Error("Error with properties");
+      (error as any).code = "TEST_ERROR";
+      (error as any).metadata = { userId: "123" };
+
+      monitoringService.report(error);
+
+      expect(recordError).toHaveBeenCalledWith(mockCrashlytics, error);
+      // Verify that the error object with additional properties is passed as is
+      expect(recordError).toHaveBeenCalledWith(
+        mockCrashlytics,
+        expect.objectContaining({
+          code: "TEST_ERROR",
+          metadata: { userId: "123" },
+        })
+      );
+    });
+  });
+});

package/templates/react-native/expo-clean-architecture/tests/core/services/network-service.test.ts

@@ -0,0 +1,117 @@
+import { NetworkServiceImpl } from "@/core/services/network-service-impl";
+import {
+  getNetworkStateAsync,
+  addNetworkStateListener,
+  NetworkState,
+} from "expo-network";
+
+// Mock expo-network
+jest.mock("expo-network", () => ({
+  getNetworkStateAsync: jest.fn(),
+  addNetworkStateListener: jest.fn(),
+}));
+
+describe("NetworkServiceImpl", () => {
+  let networkService: NetworkServiceImpl;
+  let mockNetworkStateListener: (state: NetworkState) => void;
+
+  beforeEach(() => {
+    // Reset all mocks before each test
+    jest.clearAllMocks();
+
+    // Setup the mock for addNetworkStateListener to capture the callback
+    (addNetworkStateListener as jest.Mock).mockImplementation((callback) => {
+      mockNetworkStateListener = callback;
+    });
+
+    networkService = new NetworkServiceImpl();
+  });
+
+  describe("isOnline", () => {
+    it("should return true when network is reachable", async () => {
+      (getNetworkStateAsync as jest.Mock).mockResolvedValue({
+        isInternetReachable: true,
+      });
+
+      const result = await networkService.isOnline();
+      expect(result).toBe(true);
+      expect(getNetworkStateAsync).toHaveBeenCalledTimes(1);
+    });
+
+    it("should return false when network is not reachable", async () => {
+      (getNetworkStateAsync as jest.Mock).mockResolvedValue({
+        isInternetReachable: false,
+      });
+
+      const result = await networkService.isOnline();
+      expect(result).toBe(false);
+      expect(getNetworkStateAsync).toHaveBeenCalledTimes(1);
+    });
+
+    it("should return false when isInternetReachable is null", async () => {
+      (getNetworkStateAsync as jest.Mock).mockResolvedValue({
+        isInternetReachable: null,
+      });
+
+      const result = await networkService.isOnline();
+      expect(result).toBe(false);
+      expect(getNetworkStateAsync).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("subscribe", () => {
+    it("should call callback with initial network state", async () => {
+      const mockCallback = jest.fn();
+      (getNetworkStateAsync as jest.Mock).mockResolvedValue({
+        isInternetReachable: true,
+      });
+
+      networkService.subscribe(mockCallback);
+
+      // Wait for the initial state check
+      await new Promise(process.nextTick);
+
+      expect(mockCallback).toHaveBeenCalledWith(true);
+      expect(getNetworkStateAsync).toHaveBeenCalledTimes(1);
+    });
+
+    it("should notify subscribers when network state changes", async () => {
+      const mockCallback1 = jest.fn();
+      const mockCallback2 = jest.fn();
+
+      networkService.subscribe(mockCallback1);
+      networkService.subscribe(mockCallback2);
+
+      // Simulate network state change
+      mockNetworkStateListener({ isInternetReachable: true });
+      expect(mockCallback1).toHaveBeenCalledWith(true);
+      expect(mockCallback2).toHaveBeenCalledWith(true);
+
+      // Simulate another network state change
+      mockNetworkStateListener({ isInternetReachable: false });
+      expect(mockCallback1).toHaveBeenCalledWith(false);
+      expect(mockCallback2).toHaveBeenCalledWith(false);
+
+      // Simulate network state change with undefined isInternetReachable
+      mockNetworkStateListener({ isInternetReachable: undefined });
+      expect(mockCallback1).toHaveBeenCalledWith(false);
+      expect(mockCallback2).toHaveBeenCalledWith(false);
+    });
+
+    it("should allow unsubscribing from network state changes", async () => {
+      const mockCallback = jest.fn();
+      const unsubscribe = networkService.subscribe(mockCallback);
+
+      // Simulate network state change
+      mockNetworkStateListener({ isInternetReachable: true });
+      expect(mockCallback).toHaveBeenCalledWith(true);
+
+      // Unsubscribe
+      unsubscribe();
+
+      // Simulate another network state change
+      mockNetworkStateListener({ isInternetReachable: false });
+      expect(mockCallback).not.toHaveBeenCalledWith(false);
+    });
+  });
+});

package/templates/react-native/expo-clean-architecture/tests/features/auth/presentation/hooks/use-session.test.ts

@@ -0,0 +1,69 @@
+import { useSession } from "@/features/auth/presentation/hooks/use-session";
+import { SessionStatus } from "@/features/auth/@types/session-status-enum";
+
+describe("useSession", () => {
+  beforeEach(() => {
+    // Reset the store to its initial state before each test
+    useSession.setState({
+      status: SessionStatus.UNAUTHENTICATED,
+      isInitialized: false,
+    });
+  });
+
+  describe("initial state", () => {
+    it("should have correct initial state", () => {
+      const state = useSession.getState();
+
+      expect(state.status).toBe(SessionStatus.UNAUTHENTICATED);
+      expect(state.isInitialized).toBe(false);
+      expect(state.isAuthenticated()).toBe(false);
+    });
+  });
+
+  describe("login", () => {
+    it("should update status to AUTHENTICATED when login is called", async () => {
+      await useSession.getState().login();
+
+      const state = useSession.getState();
+      expect(state.status).toBe(SessionStatus.AUTHENTICATED);
+      expect(state.isAuthenticated()).toBe(true);
+    });
+  });
+
+  describe("logout", () => {
+    it("should update status to UNAUTHENTICATED when logout is called", async () => {
+      // First login to set authenticated state
+      await useSession.getState().login();
+      expect(useSession.getState().status).toBe(SessionStatus.AUTHENTICATED);
+
+      // Then logout
+      await useSession.getState().logout();
+
+      const state = useSession.getState();
+      expect(state.status).toBe(SessionStatus.UNAUTHENTICATED);
+      expect(state.isAuthenticated()).toBe(false);
+    });
+  });
+
+  describe("silentLogin", () => {
+    it("should update status to AUTHENTICATED when silentLogin is called", async () => {
+      await useSession.getState().silentLogin();
+
+      const state = useSession.getState();
+      expect(state.status).toBe(SessionStatus.AUTHENTICATED);
+      expect(state.isAuthenticated()).toBe(true);
+    });
+  });
+
+  describe("isAuthenticated", () => {
+    it("should return true when status is AUTHENTICATED", () => {
+      useSession.setState({ status: SessionStatus.AUTHENTICATED });
+      expect(useSession.getState().isAuthenticated()).toBe(true);
+    });
+
+    it("should return false when status is UNAUTHENTICATED", () => {
+      useSession.setState({ status: SessionStatus.UNAUTHENTICATED });
+      expect(useSession.getState().isAuthenticated()).toBe(false);
+    });
+  });
+});

package/templates/react-native/expo-clean-architecture/tests/features/favorites/data/datasources/favorites-datasource.test.ts

@@ -0,0 +1,69 @@
+import { LocalStorageService } from "@/core/services/local-storage-service";
+import { STORAGE_KEYS } from "@/core/constants/storage-keys";
+import { FavoritesDatasourceImpl } from "@/features/favorites/data/datasources/favorites-datasource-impl";
+
+describe("FavoritesDatasourceImpl", () => {
+  let datasource: FavoritesDatasourceImpl;
+  let mockLocalStorageService: jest.Mocked<LocalStorageService>;
+
+  beforeEach(() => {
+    mockLocalStorageService = {
+      getItem: jest.fn(),
+      setItem: jest.fn(),
+      removeItem: jest.fn(),
+      clear: jest.fn(),
+    } as unknown as jest.Mocked<LocalStorageService>;
+
+    datasource = new FavoritesDatasourceImpl(mockLocalStorageService);
+  });
+
+  describe("getFavorites", () => {
+    it("should return favorites from localStorage with default empty array", async () => {
+      const mockFavorites = '["movie1", "movie2"]';
+      mockLocalStorageService.getItem.mockResolvedValue(mockFavorites);
+
+      const result = await datasource.getFavorites();
+
+      expect(mockLocalStorageService.getItem).toHaveBeenCalledWith(
+        STORAGE_KEYS.FAVORITES,
+        "[]"
+      );
+      expect(result).toBe(mockFavorites);
+    });
+
+    it("should return default empty array when no favorites exist", async () => {
+      mockLocalStorageService.getItem.mockResolvedValue("[]");
+
+      const result = await datasource.getFavorites();
+
+      expect(mockLocalStorageService.getItem).toHaveBeenCalledWith(
+        STORAGE_KEYS.FAVORITES,
+        "[]"
+      );
+      expect(result).toBe("[]");
+    });
+  });
+
+  describe("setFavorites", () => {
+    it("should save favorites to localStorage", async () => {
+      const mockFavorites = '["movie1", "movie2"]';
+
+      await datasource.setFavorites(mockFavorites);
+
+      expect(mockLocalStorageService.setItem).toHaveBeenCalledWith(
+        STORAGE_KEYS.FAVORITES,
+        mockFavorites
+      );
+    });
+  });
+
+  describe("clearFavorites", () => {
+    it("should remove favorites from localStorage", async () => {
+      await datasource.clearFavorites();
+
+      expect(mockLocalStorageService.removeItem).toHaveBeenCalledWith(
+        STORAGE_KEYS.FAVORITES
+      );
+    });
+  });
+});

package/templates/react-native/expo-clean-architecture/tests/features/favorites/data/repositories/favorites-repository-impl.test.ts

@@ -0,0 +1,124 @@
+import { FavoritesRepositoryImpl } from "@/features/favorites/data/repositories/favorites-repository-impl";
+import { FavoritesDatasource } from "@/features/favorites/data/datasources/favorites-datasource";
+import { MovieEntity } from "@/features/movies/domain/entities/movie-entity";
+
+describe("FavoritesRepositoryImpl", () => {
+  let repository: FavoritesRepositoryImpl;
+  let mockFavoritesDatasource: jest.Mocked<FavoritesDatasource>;
+
+  const mockMovie: MovieEntity = {
+    id: "1",
+    title: "Test Movie",
+    description: "Test Description",
+    image: "/test.jpg",
+  };
+
+  const mockFavorites = [mockMovie];
+
+  beforeEach(() => {
+    mockFavoritesDatasource = {
+      getFavorites: jest.fn(),
+      setFavorites: jest.fn(),
+      clearFavorites: jest.fn(),
+    } as jest.Mocked<FavoritesDatasource>;
+
+    repository = new FavoritesRepositoryImpl(mockFavoritesDatasource);
+  });
+
+  describe("addFavorite", () => {
+    it("should add a movie to favorites", async () => {
+      mockFavoritesDatasource.getFavorites.mockResolvedValue(
+        JSON.stringify([])
+      );
+      mockFavoritesDatasource.setFavorites.mockResolvedValue();
+
+      await repository.addFavorite(mockMovie);
+
+      expect(mockFavoritesDatasource.getFavorites).toHaveBeenCalled();
+      expect(mockFavoritesDatasource.setFavorites).toHaveBeenCalledWith(
+        JSON.stringify([mockMovie])
+      );
+    });
+
+    it("should append movie to existing favorites", async () => {
+      const existingMovie: MovieEntity = {
+        ...mockMovie,
+        id: "2",
+        title: "Existing Movie",
+      };
+
+      mockFavoritesDatasource.getFavorites.mockResolvedValue(
+        JSON.stringify([existingMovie])
+      );
+      mockFavoritesDatasource.setFavorites.mockResolvedValue();
+
+      await repository.addFavorite(mockMovie);
+
+      expect(mockFavoritesDatasource.setFavorites).toHaveBeenCalledWith(
+        JSON.stringify([existingMovie, mockMovie])
+      );
+    });
+  });
+
+  describe("removeFavorite", () => {
+    it("should remove a movie from favorites", async () => {
+      mockFavoritesDatasource.getFavorites.mockResolvedValue(
+        JSON.stringify(mockFavorites)
+      );
+      mockFavoritesDatasource.setFavorites.mockResolvedValue();
+
+      await repository.removeFavorite(mockMovie.id);
+
+      expect(mockFavoritesDatasource.getFavorites).toHaveBeenCalled();
+      expect(mockFavoritesDatasource.setFavorites).toHaveBeenCalledWith(
+        JSON.stringify([])
+      );
+    });
+
+    it("should not modify favorites if movie is not found", async () => {
+      mockFavoritesDatasource.getFavorites.mockResolvedValue(
+        JSON.stringify(mockFavorites)
+      );
+      mockFavoritesDatasource.setFavorites.mockResolvedValue();
+
+      await repository.removeFavorite("non-existent-id");
+
+      expect(mockFavoritesDatasource.setFavorites).toHaveBeenCalledWith(
+        JSON.stringify(mockFavorites)
+      );
+    });
+  });
+
+  describe("getFavorites", () => {
+    it("should return all favorites", async () => {
+      mockFavoritesDatasource.getFavorites.mockResolvedValue(
+        JSON.stringify(mockFavorites)
+      );
+
+      const result = await repository.getFavorites();
+
+      expect(mockFavoritesDatasource.getFavorites).toHaveBeenCalled();
+      expect(result).toEqual(mockFavorites);
+    });
+
+    it("should return empty array when no favorites exist", async () => {
+      mockFavoritesDatasource.getFavorites.mockResolvedValue(
+        JSON.stringify([])
+      );
+
+      const result = await repository.getFavorites();
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("clearFavorites", () => {
+    it("should clear all favorites", async () => {
+      mockFavoritesDatasource.clearFavorites.mockResolvedValue();
+
+      await repository.clearFavorites();
+
+      expect(mockFavoritesDatasource.clearFavorites).toHaveBeenCalled();
+    });
+  });
+});

package/templates/react-native/expo-clean-architecture/tests/features/favorites/domain/usecases/add-to-favorites-usecase.test.ts

@@ -0,0 +1,54 @@
+import { AddToFavoritesUsecase } from "@/features/favorites/domain/usecases/add-to-favorites-usecase";
+import { FavoritesRepository } from "@/features/favorites/domain/repositories/favorites-repository";
+import { MovieEntity } from "@/features/movies/domain/entities/movie-entity";
+
+describe("AddToFavoritesUsecase", () => {
+  let usecase: AddToFavoritesUsecase;
+  let mockFavoritesRepository: jest.Mocked<FavoritesRepository>;
+
+  const mockMovie: MovieEntity = {
+    id: "123",
+    title: "Test Movie",
+    description: "Test Description",
+    image: "test-image.jpg",
+  };
+
+  beforeEach(() => {
+    mockFavoritesRepository = {
+      getFavorites: jest.fn(),
+      addFavorite: jest.fn(),
+      removeFavorite: jest.fn(),
+      clearFavorites: jest.fn(),
+    };
+
+    usecase = new AddToFavoritesUsecase(mockFavoritesRepository);
+  });
+
+  it("should successfully add a movie to favorites", async () => {
+    // Arrange
+    mockFavoritesRepository.addFavorite.mockResolvedValue();
+
+    // Act
+    const result = await usecase.execute(mockMovie);
+
+    // Assert
+    expect(result.isSuccess).toBe(true);
+    expect(mockFavoritesRepository.addFavorite).toHaveBeenCalledWith(mockMovie);
+    expect(mockFavoritesRepository.addFavorite).toHaveBeenCalledTimes(1);
+  });
+
+  it("should return failure when repository throws an error", async () => {
+    // Arrange
+    const error = new Error("Failed to add favorite");
+    mockFavoritesRepository.addFavorite.mockRejectedValue(error);
+
+    // Act
+    const result = await usecase.execute(mockMovie);
+
+    // Assert
+    expect(result.isFailure).toBe(true);
+    expect(result.error).toBe(error);
+    expect(mockFavoritesRepository.addFavorite).toHaveBeenCalledWith(mockMovie);
+    expect(mockFavoritesRepository.addFavorite).toHaveBeenCalledTimes(1);
+  });
+});

package/templates/react-native/expo-clean-architecture/tests/features/favorites/domain/usecases/clear-favorites-usecase.test.ts

@@ -0,0 +1,44 @@
+import { ClearFavoritesUsecase } from "@/features/favorites/domain/usecases/clear-favorites-usecase";
+import { FavoritesRepository } from "@/features/favorites/domain/repositories/favorites-repository";
+
+describe("ClearFavoritesUsecase", () => {
+  let usecase: ClearFavoritesUsecase;
+  let mockFavoritesRepository: jest.Mocked<FavoritesRepository>;
+
+  beforeEach(() => {
+    mockFavoritesRepository = {
+      getFavorites: jest.fn(),
+      addFavorite: jest.fn(),
+      removeFavorite: jest.fn(),
+      clearFavorites: jest.fn(),
+    };
+
+    usecase = new ClearFavoritesUsecase(mockFavoritesRepository);
+  });
+
+  it("should successfully clear all favorites", async () => {
+    // Arrange
+    mockFavoritesRepository.clearFavorites.mockResolvedValue();
+
+    // Act
+    const result = await usecase.execute();
+
+    // Assert
+    expect(result.isSuccess).toBe(true);
+    expect(mockFavoritesRepository.clearFavorites).toHaveBeenCalledTimes(1);
+  });
+
+  it("should return failure when repository throws an error", async () => {
+    // Arrange
+    const error = new Error("Failed to clear favorites");
+    mockFavoritesRepository.clearFavorites.mockRejectedValue(error);
+
+    // Act
+    const result = await usecase.execute();
+
+    // Assert
+    expect(result.isFailure).toBe(true);
+    expect(result.error).toBe(error);
+    expect(mockFavoritesRepository.clearFavorites).toHaveBeenCalledTimes(1);
+  });
+});