kasy-cli 1.2.1

package/templates/firebase/test/core/states/user_state_notifier_test.dart

@@ -0,0 +1,244 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:kasy_kit/core/data/api/http_client.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/core/data/repositories/user_repository.dart';
+import 'package:kasy_kit/core/states/user_state_notifier.dart';
+import 'package:kasy_kit/environnements.dart';
+import 'package:kasy_kit/features/authentication/repositories/authentication_repository.dart';
+import 'package:kasy_kit/features/notifications/repositories/device_repository.dart';
+import 'package:kasy_kit/features/subscription/repositories/subscription_repository.dart';
+import 'package:logger/logger.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import '../../features/authentication/data/api/auth_api_fake.dart';
+import '../../features/authentication/data/api/user_api_fake.dart';
+import '../../features/notifications/data/device_api_fake.dart';
+import '../../features/subscription/api/fake_inapp_subscription_api.dart';
+import '../../features/subscription/api/fake_subscription_api.dart';
+import '../data/api/storage_api_fake.dart';
+import '../security/secured_storage_fake.dart';
+
+void main() {
+  group('authRequired AuthenticationMode', () {
+    final authRepository = HttpAuthenticationRepository(
+      logger: Logger(),
+      authenticationApi: FakeAuthenticationApi(),
+      storage: FakeAuthSecuredStorage.empty(),
+      userApi: FakeUserApi(storageApi: FakeStorageApi()),
+      httpClient: HttpClient(baseUrl: ''),
+    );
+
+    final fakeStorageApi = FakeStorageApi();
+
+    Future<ProviderContainer> initTestContainer() async {
+      SharedPreferences.setMockInitialValues({});
+      final sharedPrefs = await SharedPreferences.getInstance();
+      final deviceRepository = DeviceRepository(
+        deviceApi: FakeDeviceApi(),
+        prefs: sharedPrefs,
+      );
+
+      final subscriptionRepository = SubscriptionRepository(
+        subscriptionApi: SubscriptionApiFake(),
+        inAppSubscriptionApi: InAppSubscriptionApiFake(),
+        prefs: sharedPrefs,
+      );
+
+      final userRepository = UserRepository(
+        userApi: FakeUserApi(storageApi: fakeStorageApi),
+        subscriptionRepository: subscriptionRepository,
+      );
+
+      const env = Environment.dev(
+        name: 'dev',
+        backendUrl: 'https://example.com',
+        authenticationMode: AuthenticationMode.authRequired,
+      );
+
+      final container = ProviderContainer.test(
+        overrides: [
+          environmentProvider.overrideWithValue(env),
+          authRepositoryProvider.overrideWithValue(authRepository),
+          userRepositoryProvider.overrideWithValue(userRepository),
+          deviceRepositoryProvider.overrideWithValue(deviceRepository),
+          subscriptionRepositoryProvider.overrideWithValue(subscriptionRepository),
+        ],
+      );
+
+      return container;
+    }
+
+    test(
+      'Should load user at startup, user is not connected => user should be in unauth state',
+      () async {
+        final testContainer = await initTestContainer();
+        final userStateNotifier = testContainer.read(
+          userStateNotifierProvider.notifier,
+        );
+
+        expect(
+          userStateNotifier.state.user,
+          isA<LoadingUserData>(),
+          reason: 'user should be in loading state at the beginning',
+        );
+        await userStateNotifier.init();
+        expect(
+          userStateNotifier.state.user,
+          isA<AnonymousUserData>(),
+          reason: 'user should be in unauthenticated state',
+        );
+      },
+    );
+
+    test(
+      'Should load user at startup, user signin => state user is connected',
+      () async {
+        final testContainer = await initTestContainer();
+        final userStateNotifier = testContainer.read(
+          userStateNotifierProvider.notifier,
+        );
+        await userStateNotifier.init();
+
+        await authRepository.signup('email', 'password');
+        await userStateNotifier.onSignin();
+        expect(
+          userStateNotifier.state.user,
+          isA<AuthenticatedUserData>(),
+          reason: 'user should be authenticated',
+        );
+      },
+    );
+
+    test('on logout -> user state is anonymous', () async {
+      final testContainer = await initTestContainer();
+      final userStateNotifier = testContainer.read(
+        userStateNotifierProvider.notifier,
+      );
+      await userStateNotifier.init();
+      await authRepository.signup('email', 'password');
+      await userStateNotifier.onSignin();
+      await authRepository.logout();
+      await userStateNotifier.onLogout();
+
+      expect(
+        userStateNotifier.state.user,
+        isA<AnonymousUserData>(),
+        reason: 'user should be anonymous',
+      );
+    });
+  });
+
+  group('authRequired anonymous', () {
+    final authRepository = HttpAuthenticationRepository(
+      logger: Logger(),
+      authenticationApi: FakeAuthenticationApi(),
+      storage: FakeAuthSecuredStorage.empty(),
+      userApi: FakeUserApi(storageApi: FakeStorageApi()),
+      httpClient: HttpClient(baseUrl: ''),
+    );
+
+    final fakeStorageApi = FakeStorageApi();
+
+    Future<ProviderContainer> initTestContainer() async {
+      SharedPreferences.setMockInitialValues({});
+      final sharedPrefs = await SharedPreferences.getInstance();
+      final deviceRepository = DeviceRepository(
+        deviceApi: FakeDeviceApi(),
+        prefs: sharedPrefs,
+      );
+
+      final subscriptionRepository = SubscriptionRepository(
+        subscriptionApi: SubscriptionApiFake(),
+        inAppSubscriptionApi: InAppSubscriptionApiFake(),
+        prefs: sharedPrefs,
+      );
+
+      final userRepository = UserRepository(
+        userApi: FakeUserApi(storageApi: fakeStorageApi),
+        subscriptionRepository: subscriptionRepository,
+      );
+
+      const env = Environment.dev(
+        name: 'dev',
+        backendUrl: 'https://example.com',
+        authenticationMode: AuthenticationMode.anonymous,
+      );
+
+      final container = ProviderContainer.test(
+        overrides: [
+          environmentProvider.overrideWithValue(env),
+          authRepositoryProvider.overrideWithValue(authRepository),
+          subscriptionRepositoryProvider.overrideWithValue(subscriptionRepository),
+          userRepositoryProvider.overrideWithValue(userRepository),
+          deviceRepositoryProvider.overrideWithValue(deviceRepository),
+        ],
+      );
+
+      return container;
+    }
+
+    test(
+      'Should load user at startup, user is not connected => login user anonymously with id',
+      () async {
+        final testContainer = await initTestContainer();
+        final userStateNotifier = testContainer.read(
+          userStateNotifierProvider.notifier,
+        );
+        expect(
+          userStateNotifier.state.user,
+          isA<LoadingUserData>(),
+          reason: 'user should be in loading state at the beginning',
+        );
+        await userStateNotifier.init();
+        expect(
+          userStateNotifier.state.user,
+          isA<AnonymousUserData>(),
+          reason: 'user should be in unauthenticated state',
+        );
+        expect(
+          userStateNotifier.state.user.idOrThrow,
+          'fake-user-id-anonymous',
+        );
+      },
+    );
+
+    test(
+      'Should load user at startup, user signin => state user is connected',
+      () async {
+        final testContainer = await initTestContainer();
+        final userStateNotifier = testContainer.read(
+          userStateNotifierProvider.notifier,
+        );
+        await userStateNotifier.init();
+
+        await authRepository.signup('email', 'password');
+        await userStateNotifier.onSignin();
+        expect(
+          userStateNotifier.state.user,
+          isA<AuthenticatedUserData>(),
+          reason: 'user should be authenticated',
+        );
+      },
+    );
+
+    test('on logout -> user state is anonymous with id', () async {
+      final testContainer = await initTestContainer();
+      final userStateNotifier = testContainer.read(
+        userStateNotifierProvider.notifier,
+      );
+      await userStateNotifier.init();
+      await authRepository.signup('email', 'password');
+      await userStateNotifier.onSignin();
+      await authRepository.logout();
+      await userStateNotifier.onLogout();
+
+      expect(
+        userStateNotifier.state.user,
+        isA<AnonymousUserData>(),
+        reason: 'user should be anonymous',
+      );
+      expect(userStateNotifier.state.user.idOrThrow, 'fake-user-id-anonymous');
+    });
+  });
+}

package/templates/firebase/test/core/widgets/responsive_layout_test.dart

@@ -0,0 +1,50 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:kasy_kit/core/widgets/responsive_layout.dart';
+
+import '../../device_test_utils.dart';
+
+void main() {
+  group('Small device', () {
+    testWidgets('Add a small child widget => shows correctly', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: ResponsiveLayout(
+            small: Text('small'),
+          ),
+        ),
+      );
+      expect(find.text('small'), findsOneWidget);
+    });
+  });
+
+  group('desktop device', () {
+    testWidgets('Add small, medium, large child widget only => shows large',
+        (tester) async {
+      await tester.setScreenSize(desktopDeviceSpec);
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: ResponsiveLayout(
+            small: Text('small'),
+            medium: Text('medium'),
+            large: Text('large'),
+          ),
+        ),
+      );
+      expect(find.text('large'), findsOneWidget);
+    });
+
+    testWidgets('Add a small child widget only => shows correctly',
+        (tester) async {
+      await tester.setScreenSize(desktopDeviceSpec);
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: ResponsiveLayout(
+            small: Text('small'),
+          ),
+        ),
+      );
+      expect(find.text('small'), findsOneWidget);
+    });
+  });
+}

package/templates/firebase/test/device_test_utils.dart

@@ -0,0 +1,98 @@
+import 'dart:ui';
+
+import 'package:flutter_test/flutter_test.dart';
+
+const iphone8Plus = Device(
+  name: 'iPhone 8 Plus',
+  width: 414,
+  height: 736,
+  pixelDensity: 3,
+);
+const iphone11Pro = Device(
+  name: 'iPhone 11 Pro',
+  width: 375,
+  height: 812,
+  pixelDensity: 3,
+);
+const iphone15ProMax = Device(
+  name: 'iPhone 15 Pro Max',
+  width: 428,
+  height: 926,
+  pixelDensity: 3,
+);
+const googlePixel4 = Device(
+  name: 'Google Pixel 4',
+  width: 393,
+  height: 851,
+  pixelDensity: 2.7,
+);
+const googlePixel7 = Device(
+  name: 'Google Pixel 7',
+  width: 411,
+  height: 823,
+  pixelDensity: 3.5,
+);
+const desktopDeviceSpec = Device(
+  name: 'Desktop',
+  width: 1400,
+  height: 900,
+  pixelDensity: 1,
+);
+
+final deviceVariants = ValueVariant<Device>({
+  iphone8Plus,
+  iphone11Pro,
+  iphone15ProMax,
+  googlePixel4,
+  googlePixel7,
+});
+
+/// A device to use in tests
+class Device {
+  final String name;
+  final double width;
+  final double height;
+  final double pixelDensity;
+
+  const Device({
+    required this.name,
+    required this.width,
+    required this.height,
+    required this.pixelDensity,
+  });
+
+  @override
+  String toString() {
+    return 'Device(name: $name, width: $width, height: $height, pixelDensity: $pixelDensity)';
+  }
+}
+
+/// Use this extension to set the screen size of the device in tests
+/// This allows to test the UI on different devices and check for some overflow
+///
+/// example:
+/// ```dart
+/// testWidgets('should show the page', (tester) async {
+///   await tester.setScreenSize(iphone8Plus);
+///   await tester.pumpWidget(MyApp());
+///   expect(find.byType(MyPage), findsOneWidget);
+/// });
+/// ```
+extension ScreenSize on WidgetTester {
+  Future<void> setScreenSize(Device device) => _setScreenSize(
+        width: device.width,
+        height: device.height,
+        pixelDensity: device.pixelDensity,
+      );
+
+  Future<void> _setScreenSize({
+    double width = 450,
+    double height = 800,
+    double pixelDensity = 1,
+  }) async {
+    final size = Size(width, height);
+    await binding.setSurfaceSize(size);
+    view.physicalSize = size;
+    view.devicePixelRatio = pixelDensity;
+  }
+}

package/templates/firebase/test/features/authentication/data/api/auth_api_fake.dart

@@ -0,0 +1,169 @@
+import 'package:kasy_kit/core/data/entities/user_entity.dart';
+import 'package:kasy_kit/features/authentication/api/authentication_api_interface.dart';
+
+/// Fake implementation of [AuthenticationApi]
+/// This is useful for testing purposes
+class FakeAuthenticationApi implements AuthenticationApi {
+  Credentials? current;
+
+  @override
+  Future<void> init() {
+    return Future.value();
+  }
+
+  @override
+  Future<Credentials> signup(String email, String password) async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<Credentials> signin(String email, String password) async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<Credentials> signinAnonymously() async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id-anonymous',
+      token: 'fake-user-token-1234567898',
+    );
+    return current!;
+  }
+
+  @override
+  Future<void> signout() async {
+    current = null;
+  }
+
+  @override
+  Future<Credentials> signinWithGoogle() async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<Credentials> signinWithGooglePlay() async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<Credentials> signinWithApple() async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<Credentials> signinWithFacebook() async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<void> recoverPassword(String email) async {
+    await Future.delayed(const Duration(milliseconds: 100));
+  }
+
+  @override
+  Future<Credentials?> get() {
+    return Future.value(current);
+  }
+
+  
+  @override
+  Future<Credentials> signupFromAnonymousWithGoogle() async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  
+  @override
+  Future<Credentials> signupFromAnonymousWithApple() async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<Credentials> signupFromAnonymousWithFacebook() async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<String> signinWithPhone(String phoneNumber) {
+    return Future.value('fake-verification-id');
+  }
+
+  @override
+  Future<Credentials> verifyPhoneAuth(String verificationId, String otp) async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<Credentials> confirmLinkPhoneAuth(
+    String verificationId,
+    String otp,
+  ) async {
+    await Future.delayed(const Duration(seconds: 1));
+    current = Credentials(
+      id: 'fake-user-id',
+      token: 'fake-user-token-1234567890',
+    );
+    return current!;
+  }
+
+  @override
+  Future<String> updateAuthPhone(String phoneNumber) {
+    return Future.value('fake-verification-id');
+  }
+
+  @override
+  Future<String?> getCurrentUserEmail() => Future.value(current != null ? 'fake@test.com' : null);
+
+  @override
+  Future<String?> getCurrentUserDisplayName() => Future.value(current != null ? 'Fake User' : null);
+}

package/templates/firebase/test/features/authentication/data/api/user_api_fake.dart

@@ -0,0 +1,86 @@
+import 'dart:typed_data';
+
+import 'package:kasy_kit/core/data/api/storage_api.dart';
+import 'package:kasy_kit/core/data/api/user_api.dart';
+import 'package:kasy_kit/core/data/entities/upload_result.dart';
+import 'package:kasy_kit/core/data/entities/user_entity.dart';
+
+class FakeUserApi implements UserApi {
+  final StorageApi storageApi;
+  UserEntity? getUserResult;
+
+  FakeUserApi({
+    required this.storageApi,
+  });
+
+  @override
+  Future<UserEntity> get(String id) async {
+    if (id == 'fake-user-id-anonymous') {
+      return UserEntity(
+        id: id,
+        creationDate: DateTime.now(),
+        lastUpdateDate: DateTime.now(),
+      );
+    }
+    return getUserResult ??
+        UserEntity(
+          id: 'userid',
+          name: 'Mac Gyver',
+          email: 'mac@gyver.com',
+          avatarPath: 'https://avatar.com/macgyver.png',
+          creationDate: DateTime.now(),
+          lastUpdateDate: DateTime.now(),
+        );
+  }
+
+  @override
+  Future<void> create(UserEntity user) async {
+    getUserResult = user;
+  }
+
+  @override
+  Future<void> delete(String id) {
+    return Future.value();
+  }
+
+  @override
+  Future<void> deleteMe() {
+    return Future.value();
+  }
+
+  @override
+  Future<void> update(UserEntity user) async {
+    getUserResult = user;
+  }
+
+  @override
+  Stream<UploadResult> updateAvatar(String userId, Uint8List data) async* {
+    final task = storageApi.uploadData(
+      data,
+      'users/$userId/avatar',
+      'thumb.jpg',
+      mimeType: 'image/jpg',
+    );
+
+    late UploadResult lastRes;
+    await for (final res in task) {
+      yield res;
+      lastRes = res;
+    }
+    if (lastRes case UploadResultCompleted()) {
+      return;
+    } else {
+      throw Exception('Upload failed');
+    }
+  }
+
+  @override
+  Future<void> deleteAvatar(String userId) {
+    return Future.value();
+  }
+
+  @override
+  Future<void> updateLocale(String userId, String locale) {
+    return Future.value();
+  }
+}

package/templates/firebase/test/features/authentication/lost_password_page_test.dart

@@ -0,0 +1,59 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:go_router/go_router.dart';
+import 'package:kasy_kit/components/components.dart';
+import 'package:kasy_kit/features/authentication/ui/recover_password_page.dart';
+import 'package:kasy_kit/features/authentication/ui/widgets/recover_password_result.dart';
+
+import '../../test_utils.dart';
+
+void main() {
+  Future<void> beforeTest(WidgetTester tester) async {
+    await tester.pumpPage(
+      routerConfig: GoRouter(
+        initialLocation: '/recover_password',
+        routes: [
+          GoRoute(
+            name: 'home',
+            path: '/',
+            builder: (context, state) => const PageFake(Colors.blueAccent),
+          ),
+          GoRoute(
+            name: 'recover_password',
+            path: '/recover_password',
+            builder: (context, state) => const RecoverPasswordPage(),
+          ),
+        ],
+      ),
+    );
+  }
+
+  testWidgets(
+    'Recover password page => should display email input and submit button',
+    (tester) async {
+      await beforeTest(tester);
+
+      expect(find.byType(KasyTextField), findsOneWidget);
+      expect(find.byType(KasyButton), findsOneWidget);
+    },
+  );
+
+  testWidgets(
+    'fill valid email then send => should show recover password sent page',
+    (tester) async {
+      await beforeTest(tester);
+      const email = 'bruce@wayne.com';
+
+      final emailInputFinder = find.byKey(const Key('email_input'));
+      final sendButtonFinder = find.byKey(const Key('recover_button'));
+
+      await tester.enterText(emailInputFinder, email);
+      await tester.pump(const Duration(milliseconds: 1000));
+      await tester.tap(sendButtonFinder);
+      await tester.pump(const Duration(milliseconds: 500));
+      await tester.pumpAndSettle();
+
+      expect(find.byType(RecoverPasswordSent), findsOneWidget);
+    },
+  );
+}