kasy-cli 1.2.1

package/templates/firebase/test/features/notifications/providers/device_repository_test.dart

@@ -0,0 +1,68 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:kasy_kit/features/notifications/repositories/device_repository.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import '../data/device_api_fake.dart';
+
+void main() {
+  final fakeDeviceApi = FakeDeviceApi();
+
+  Future<DeviceRepository> init() async {
+    SharedPreferences.setMockInitialValues({});
+    final sharedPrefs = await SharedPreferences.getInstance();
+    return DeviceRepository(
+      deviceApi: fakeDeviceApi,
+      prefs: sharedPrefs,
+    );
+  }
+
+  test(
+    'register device should register a new device with an id',
+    () async {
+      final deviceRepository = await init();
+      await deviceRepository.register('fake_user_id');
+      final device = await deviceRepository.get();
+      expect(device, isNotNull);
+      expect(device!.id, isNotNull);
+    },
+  );
+
+  test(
+    'register device, then unregister should remove the device',
+    () async {
+      final deviceRepository = await init();
+      await deviceRepository.register('fake_user_id');
+      await deviceRepository.unregister('fake_user_id');
+      final device = await deviceRepository.get();
+      expect(device, isNull);
+    },
+  );
+
+  test(
+    'on token refresh, should update the device',
+    () async {
+      final deviceRepository = await init();
+      await deviceRepository.register('fake_user_id');
+      deviceRepository.onTokenUpdate(
+        (device) => deviceRepository.updateToken(device.token),
+      );
+      expect(fakeDeviceApi.refreshTokenCallback, isNotNull);
+      fakeDeviceApi.refreshTokenCallback!("updated_token");
+      await Future.delayed(const Duration(milliseconds: 100));
+      final updatedDevice = await deviceRepository.get();
+      expect(updatedDevice!.token, 'updated_token');
+    },
+  );
+
+  test(
+    'should update token correctly',
+    () async {
+      final deviceRepository = await init();
+      await deviceRepository.register('fake_user_id');
+      await deviceRepository.updateToken('updated_token');
+      await Future.delayed(const Duration(milliseconds: 100));
+      final updatedDevice = await deviceRepository.get();
+      expect(updatedDevice!.token, 'updated_token');
+    },
+  );
+}

package/templates/firebase/test/features/notifications/providers/notifications_repository_test.dart

@@ -0,0 +1,74 @@
+import 'package:firebase_messaging/firebase_messaging.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:kasy_kit/core/states/notifications_dispatcher.dart';
+import 'package:kasy_kit/features/notifications/providers/models/notification.dart';
+import 'package:kasy_kit/features/notifications/repositories/notifications_repository.dart';
+
+import '../data/fake_facebook_api.dart';
+import '../data/local_notifier_fake.dart';
+import '../data/notifications_api_fake.dart';
+import '../data/notifications_settings_fake.dart';
+
+void main() {
+  final dispatcher = NotificationDispatcher();
+  final fakeNotificationsApi = FakeNotificationsApi();
+  final fakeLocalNotificationsApi = FakeLocalNotifier();
+  final fakeNotificationsSettings = NotificationsSettingsFake();
+  final fakeFacebookEventApi = FakeFacebookEventApi();
+
+  final repository = AppNotificationsRepository(
+    notificationsApi: fakeNotificationsApi,
+    notificationPublisher: dispatcher,
+    localNotifier: fakeLocalNotificationsApi,
+    notificationSettings: fakeNotificationsSettings,
+    facebookEventApi: fakeFacebookEventApi,
+  );
+
+  test('on receive message, should dispatch as a notification', () async {
+    await repository.init();
+
+    Notification? receivedNotification;
+    dispatcher.subscribe((notification) => receivedNotification = notification);
+    fakeNotificationsApi.sendForegroundMessage(
+      const RemoteMessage(
+        notification: RemoteNotification(
+          title: 'title',
+          body: 'example body',
+        ),
+        data: {
+          'type': 'my type',
+        },
+      ),
+    );
+    await Future.delayed(const Duration(milliseconds: 100));
+    expect(receivedNotification, isNotNull);
+    expect(receivedNotification!.title, 'title');
+    expect(receivedNotification!.body, 'example body');
+  });
+
+  test('fetch notifications, should return 20 notifications', () async {
+    final notifications = await repository.get('userId');
+    expect(notifications.length, 20);
+    final firstNotif = notifications.first;
+    expect(firstNotif.id, isNotNull);
+    expect(firstNotif.title, isNotNull);
+    expect(firstNotif.body, isNotNull);
+    expect(firstNotif.createdAt, isNotNull);
+  });
+
+  test('read notification', () async {
+    final notifications = await repository.get('userId');
+    final readNotification = await repository.read(
+      'userId',
+      notifications.first,
+    );
+    expect(readNotification, isNotNull);
+    expect(readNotification.seen, isTrue);
+  });
+
+  test('listen to user notifications count', () async {
+    final count$ = repository.listenToUnreadNotificationsCount('userId');
+    final count = await count$.first;
+    expect(count, 1);
+  });
+}

package/templates/firebase/test/features/notifications/ui/notifications_page_test.dart

@@ -0,0 +1,69 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/core/states/models/user_state.dart';
+import 'package:kasy_kit/features/notifications/ui/components/notification_tile.dart';
+import 'package:kasy_kit/features/notifications/ui/notifications_page.dart';
+import 'package:kasy_kit/features/notifications/ui/widgets/notification_tile.dart';
+
+import '../../../test_utils.dart';
+
+void main() {
+  group('User is connected', () {
+    testWidgets(
+      'Load notifications => should show 20 notifications',
+      (tester) async {
+        await tester.pumpPage(
+          userState: UserState(
+            user: User.authenticated(
+              id: '1',
+              email: 'user@email.com',
+              name: 'user name',
+              onboarded: true,
+              creationDate: DateTime.now().subtract(const Duration(days: 4)),
+            ),
+          ),
+          home: NotificationsPage(),
+        );
+        await tester.pump(const Duration(seconds: 3));
+        await tester.pumpAndSettle();
+        expect(find.byType(NotificationsPage), findsOneWidget);
+        expect(find.text("Notifications"), findsOneWidget);
+        expect(find.byType(NotificationTile), findsAtLeastNWidgets(3));
+      },
+    );
+
+    testWidgets(
+      'Load notifications, wait 3 seconds => all notifications are now read',
+      (tester) async {
+        await tester.pumpPage(
+          userState: UserState(
+            user: User.authenticated(
+              id: '1',
+              email: 'user@email.com',
+              name: 'user name',
+              onboarded: true,
+              creationDate: DateTime.now().subtract(const Duration(days: 4)),
+            ),
+          ),
+          home: NotificationsPage(),
+        );
+        var firstNotification = tester.firstWidget<NotificationTileComponent>(
+          find.byType(NotificationTileComponent),
+        );
+        expect(firstNotification.notification.readAt, isNull);
+
+        await tester.pump(const Duration(seconds: 3));
+        await tester.pumpAndSettle();
+        firstNotification = tester.firstWidget<NotificationTileComponent>(
+          find.byType(NotificationTileComponent),
+        );
+
+        expect(
+          firstNotification.notification.readAt,
+          isNotNull,
+          reason: "All notifications should be read after 3 seconds",
+        );
+      },
+    );
+  });
+}

package/templates/firebase/test/features/subscription/api/fake_inapp_subscription_api.dart

@@ -0,0 +1,85 @@
+import 'package:kasy_kit/core/data/models/subscription.dart';
+import 'package:kasy_kit/features/subscription/api/inapp_subscription_api.dart';
+import 'package:purchases_flutter/purchases_flutter.dart';
+
+import 'fake_revenuecat_product.dart';
+
+/// Fake implementation of [RevenueCatPaymentApi]
+/// This helps us to test the UI without having to rely on the real RevenueCat API
+/// We implement this once and then we can use it in all our tests
+/// If we need to change something one day in the API, we just have to change it here
+/// If you need to write any other test you don't need to understand the real API and
+/// just rely on this fake implementation
+class InAppSubscriptionApiFake implements RevenueCatPaymentApi {
+  String? userId;
+  List<SubscriptionProduct> activeSubscriptions = [];
+
+  @override
+  Future<void> disconnectUser() async {}
+
+  @override
+  Future<List<SubscriptionProduct>> getActiveSubscription() async {
+    return activeSubscriptions;
+  }
+
+  @override
+  Future<List<Package>> getLastPurchase() {
+    // TODO: implement getLastPurchase
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<List<SubscriptionProduct>> getOffers(String? offerId) async {
+    return [
+      FakeRevenueCatProduct.month(),
+      FakeRevenueCatProduct.year(),
+    ];
+  }
+
+  @override
+  Future<List<EntitlementInfo>> getPermissions() {
+    // TODO: implement getPermissions
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<void> init() async {}
+
+  @override
+  Future<void> initUser(String userId) async {
+    this.userId = userId;
+  }
+
+  @override
+  Future<void> purchase(StoreProduct storeProduct) {
+    return Future.value();
+  }
+
+  @override
+  Future<void> purchasePackage(Package package) async {
+    activeSubscriptions.add(FakeRevenueCatProduct.month());
+  }
+
+  @override
+  Future<void> restorePurchase() async {}
+
+  @override
+  Future<void> unsubscribe() async {}
+
+  @override
+  Future<SubscriptionProduct?> getFromProductId(String productId) async {
+    return FakeRevenueCatProduct.month();
+  }
+
+  @override
+  Future<void> presentCodeRedemptionSheet() {
+    return Future.value();
+  }
+
+  @override
+  Future<List<EntitlementInfo>?> getEntitlements() {
+    return Future.value([]);
+  }
+
+  
+}

package/templates/firebase/test/features/subscription/api/fake_revenuecat_product.dart

@@ -0,0 +1,186 @@
+// ignore_for_file: avoid_implementing_value_types
+
+import 'package:flutter/widgets.dart';
+import 'package:kasy_kit/core/data/models/subscription.dart';
+import 'package:purchases_flutter/purchases_flutter.dart';
+
+/// Fake implementation of [RevenueCatProduct]
+/// This helps us to test the UI without having to rely on the real RevenueCat API
+class FakeRevenueCatProduct implements RevenueCatProduct {
+  @override
+  final String skuId;
+
+  @override
+  final String id;
+
+  @override
+  final String description;
+
+  @override
+  final String label;
+
+  @override
+  final double price;
+
+  @override
+  final Duration duration;
+
+  @override
+  final DurationType durationType;
+
+  @override
+  final String? promotion;
+
+  @override
+  final int? trialDays;
+
+  FakeRevenueCatProduct({
+    required this.skuId,
+    required this.id,
+    required this.description,
+    required this.label,
+    required this.price,
+    required this.duration,
+    required this.durationType,
+    this.promotion,
+    this.trialDays,
+  });
+
+  factory FakeRevenueCatProduct.month() => FakeRevenueCatProduct(
+    skuId: 'premium-sku-month',
+    id: 'premium',
+    description: 'Premium subscription',
+    label: 'GOLD',
+    price: 10,
+    duration: const Duration(days: 30),
+    durationType: DurationType.month,
+  );
+
+  factory FakeRevenueCatProduct.year() => FakeRevenueCatProduct(
+    skuId: 'premium-sku-year',
+    id: 'premium',
+    description: 'Premium subscription',
+    label: 'GOLD',
+    price: 100,
+    duration: const Duration(days: 365),
+    durationType: DurationType.year,
+  );
+
+  @override
+  String formattedPrice(BuildContext context) {
+    return "$price€/$durationType";
+  }
+
+  @override
+  Offering get revenueCatOffer => FakeOffering();
+
+  @override
+  Package get revenueCatPackage => FakePackage();
+
+  @override
+  List<String>? get features => ["Feature 1", "Feature 2", "Feature 3"];
+
+  @override
+  String pricePerMonth(BuildContext context) {
+    return "$price€/$durationType";
+  }
+
+  @override
+  String? pricePerYear(BuildContext context) {
+    return "$price€/$durationType";
+  }
+
+  @override
+  String? get title => "Premium subscription";
+
+  @override
+  String get currency => 'EUR';
+
+  @override
+  String get priceString => "$price€";
+}
+
+/// This is a fake implementation of [Package]
+/// Just for test purposes
+class FakePackage implements Package {
+  @override
+  String get identifier => throw UnimplementedError();
+
+  @override
+  PackageType get packageType => throw UnimplementedError();
+
+  @override
+  StoreProduct get storeProduct => throw UnimplementedError();
+
+  Map<String, dynamic> toJson() {
+    throw UnimplementedError();
+  }
+
+  @override
+  PresentedOfferingContext get presentedOfferingContext =>
+      throw UnimplementedError();
+
+  @override
+  List<Object> get props => throw UnimplementedError();
+
+  @override
+  bool? get stringify => throw UnimplementedError();
+
+  @override
+  String? get webCheckoutUrl => null;
+}
+
+/// This is a fake implementation of [Offering]
+/// Just for test purposes
+class FakeOffering implements Offering {
+  @override
+  Package? get annual => throw UnimplementedError();
+
+  @override
+  List<Package> get availablePackages => throw UnimplementedError();
+
+  @override
+  Package? getPackage(String identifier) {
+    throw UnimplementedError();
+  }
+
+  @override
+  String get identifier => throw UnimplementedError();
+
+  @override
+  Package? get lifetime => throw UnimplementedError();
+
+  @override
+  Map<String, Object> get metadata => throw UnimplementedError();
+
+  @override
+  Package? get monthly => throw UnimplementedError();
+
+  @override
+  String get serverDescription => throw UnimplementedError();
+
+  @override
+  Package? get sixMonth => throw UnimplementedError();
+
+  @override
+  Package? get threeMonth => throw UnimplementedError();
+
+  Map<String, dynamic> toJson() {
+    throw UnimplementedError();
+  }
+
+  @override
+  Package? get twoMonth => throw UnimplementedError();
+
+  @override
+  Package? get weekly => throw UnimplementedError();
+
+  @override
+  List<Object?> get props => throw UnimplementedError();
+
+  @override
+  bool? get stringify => throw UnimplementedError();
+
+  @override
+  String? get webCheckoutUrl => null;
+}

package/templates/firebase/test/features/subscription/api/fake_subscription_api.dart

@@ -0,0 +1,11 @@
+import 'package:kasy_kit/features/subscription/api/entities/subscription_entity.dart';
+import 'package:kasy_kit/features/subscription/api/subscription_api.dart';
+
+class SubscriptionApiFake implements SubscriptionApi {
+  SubscriptionEntity? currentFake;
+
+  @override
+  Future<SubscriptionEntity?> get(String userId) {
+    return Future(() => currentFake);
+  }
+}

package/templates/firebase/test/features/subscription/subscription_page_test.dart

@@ -0,0 +1,119 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:kasy_kit/core/data/models/subscription.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/core/states/models/user_state.dart';
+import 'package:kasy_kit/features/subscription/ui/component/active_premium_content.dart';
+import 'package:kasy_kit/features/subscription/ui/component/premium_content.dart';
+import 'package:kasy_kit/features/subscription/ui/component/premium_page_factory.dart';
+import 'package:kasy_kit/features/subscription/ui/premium_page.dart';
+
+import '../../test_utils.dart';
+import 'api/fake_inapp_subscription_api.dart';
+import 'api/fake_revenuecat_product.dart';
+import 'api/fake_subscription_api.dart';
+
+void main() {
+  final subscriptionApiFake = SubscriptionApiFake();
+  final inAppSubscriptionApiFake = InAppSubscriptionApiFake();
+
+  testWidgets(
+    'user is logged in, has a subscription and is premium => should show active premium page',
+    (tester) async {
+      await tester.pumpPage(
+        userState: UserState(
+          user: User.authenticated(
+            id: '1',
+            email: 'user@email.com',
+            name: 'user name',
+            onboarded: true,
+            creationDate: DateTime.now().subtract(const Duration(days: 4)),
+            subscription: Subscription.active(
+              activeOffer: FakeRevenueCatProduct.month(),
+            ),
+          ),
+        ),
+        subscriptionApiFakeOverride: subscriptionApiFake,
+        inAppSubscriptionApiFakeOverride: inAppSubscriptionApiFake,
+        home: const PremiumPage(),
+      );
+      expect(find.byType(ActivePremiumContent), findsOneWidget);
+    },
+  );
+
+  testWidgets(
+    'user is logged in, no subscription => should show premium selection page',
+    (tester) async {
+      await tester.pumpPage(
+        userState: UserState(
+          user: User.authenticated(
+            id: '1',
+            email: 'user@email.com',
+            name: 'user name',
+            onboarded: true,
+            creationDate: DateTime.now().subtract(const Duration(days: 4)),
+            subscription: const Subscription.inactive(
+              hoursBetweenTwoRequests: 24,
+            ),
+          ),
+        ),
+        subscriptionApiFakeOverride: subscriptionApiFake,
+        inAppSubscriptionApiFakeOverride: inAppSubscriptionApiFake,
+        home: const PremiumPage(paywall: PaywallFactory.basic),
+      );
+      expect(find.byType(BasicPaywall), findsOneWidget);
+    },
+  );
+
+  testWidgets(
+    'user is logged in, no subscription, subscribe => should show premium active page',
+    (tester) async {
+      await tester.pumpPage(
+        userState: UserState(
+          user: User.authenticated(
+            id: '1',
+            email: 'user@email.com',
+            name: 'user name',
+            onboarded: true,
+            creationDate: DateTime.now().subtract(const Duration(days: 4)),
+            subscription: const Subscription.inactive(
+              hoursBetweenTwoRequests: 24,
+            ),
+          ),
+        ),
+        subscriptionApiFakeOverride: subscriptionApiFake,
+        inAppSubscriptionApiFakeOverride: inAppSubscriptionApiFake,
+        home: const PremiumPage(paywall: PaywallFactory.basic),
+      );
+      final subscribeBtn = find.byKey(const ValueKey<String>('premium_subscribe_button'));
+      expect(subscribeBtn, findsOneWidget);
+      await tester.tap(subscribeBtn);
+      await tester.pump(const Duration(milliseconds: 2000));
+
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pumpAndSettle();
+      expect(find.byType(ActivePremiumContent), findsOneWidget);
+    },
+  );
+
+  testWidgets(
+    'user is anonymously logged with id => should show a premium selection',
+    (tester) async {
+      await tester.pumpPage(
+        userState: const UserState(
+          user: User.anonymous(
+            id: "Test",
+            subscription: Subscription.inactive(
+              hoursBetweenTwoRequests: 24,
+            ),
+          ),
+        ),
+        subscriptionApiFakeOverride: subscriptionApiFake,
+        inAppSubscriptionApiFakeOverride: inAppSubscriptionApiFake,
+        home: const PremiumPage(paywall: PaywallFactory.basic),
+      );
+
+      expect(find.byType(BasicPaywall), findsOneWidget);
+    },
+  );
+}

package/templates/firebase/test/firebase_test_utils.dart

@@ -0,0 +1,25 @@
+import 'package:firebase_core/firebase_core.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+typedef Callback = void Function(MethodCall call);
+
+Future<FirebaseApp> initFirebaseForTest([int? counter]) async {
+  try {
+    setupFirebaseAuthMocks();
+    return await Firebase.initializeApp(
+      name: 'DEFAULT',
+      options: const FirebaseOptions(
+        apiKey: '',
+        appId: '',
+        messagingSenderId: '',
+        projectId: '',
+      ),
+    );
+  } catch (_) {}
+  return Firebase.app();
+}
+
+void setupFirebaseAuthMocks([Callback? customHandlers]) {
+  TestWidgetsFlutterBinding.ensureInitialized();
+}