feat: import Chinese-localized Buzz source snapshot

Signed-off-by: cls_宁波本机 <908705107@qq.com>

mobile/test/features/activity/compose_drafts_provider_test.dart

@@ -0,0 +1,219 @@
+import 'package:buzz/features/activity/compose_drafts_provider.dart';
+import 'package:buzz/shared/relay/relay.dart';
+import 'package:buzz/shared/theme/theme_provider.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+class _FixedRelayConfigNotifier extends RelayConfigNotifier {
+  final RelayConfig _config;
+  _FixedRelayConfigNotifier(this._config);
+
+  @override
+  RelayConfig build() => _config;
+}
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  Future<ProviderContainer> containerWithPrefs({
+    String relayUrl = 'https://relay-a.example',
+    String? pubkey = 'pk_a',
+  }) async {
+    final prefs = await SharedPreferences.getInstance();
+    final container = ProviderContainer(
+      overrides: [
+        savedPrefsProvider.overrideWithValue(prefs),
+        relayConfigProvider.overrideWith(
+          () => _FixedRelayConfigNotifier(RelayConfig(baseUrl: relayUrl)),
+        ),
+        myPubkeyProvider.overrideWithValue(pubkey),
+      ],
+    );
+    addTearDown(container.dispose);
+    return container;
+  }
+
+  test(
+    'an invite-joined community keeps its drafts after origin canonicalization',
+    () async {
+      // Written by a build that stored the invite link's wss:// origin
+      // verbatim; RelayConfig now canonicalizes that to https://, so the key
+      // the app computes no longer matches the key on disk.
+      const legacyKey = 'compose_drafts_v1:wss://relay-a.example:pk_a';
+      const canonicalKey = 'compose_drafts_v1:https://relay-a.example:pk_a';
+      SharedPreferences.setMockInitialValues({
+        legacyKey:
+            '[{"key":"ch1","channel_id":"ch1","text":"unsent work",'
+            '"updated_at":1700000000}]',
+      });
+
+      final container = await containerWithPrefs(
+        relayUrl: 'wss://relay-a.example',
+      );
+
+      final drafts = container.read(composeDraftsProvider);
+      expect(drafts, hasLength(1), reason: 'draft survives the upgrade');
+      expect(drafts.single.text, 'unsent work');
+
+      await Future<void>.delayed(Duration.zero);
+      final prefs = await SharedPreferences.getInstance();
+      expect(prefs.getString(canonicalKey), isNotNull);
+      expect(prefs.getString(legacyKey), isNull);
+    },
+  );
+
+  test('composeDraftKey separates channel and thread composers', () {
+    expect(composeDraftKey('ch1'), 'ch1');
+    expect(composeDraftKey('ch1', threadHeadId: 't1'), 'ch1:t1');
+  });
+
+  test('save adds a draft and textFor returns it', () async {
+    SharedPreferences.setMockInitialValues({});
+    final container = await containerWithPrefs();
+    final notifier = container.read(composeDraftsProvider.notifier);
+
+    notifier.save(key: 'ch1', channelId: 'ch1', text: 'hello there');
+
+    final drafts = container.read(composeDraftsProvider);
+    expect(drafts, hasLength(1));
+    expect(drafts.single.text, 'hello there');
+    expect(notifier.textFor('ch1'), 'hello there');
+  });
+
+  test('empty text removes the draft', () async {
+    SharedPreferences.setMockInitialValues({});
+    final container = await containerWithPrefs();
+    final notifier = container.read(composeDraftsProvider.notifier);
+
+    notifier.save(key: 'ch1', channelId: 'ch1', text: 'hello');
+    notifier.save(key: 'ch1', channelId: 'ch1', text: '   ');
+
+    expect(container.read(composeDraftsProvider), isEmpty);
+  });
+
+  test('drafts persist across container restarts', () async {
+    SharedPreferences.setMockInitialValues({});
+    final first = await containerWithPrefs();
+    first
+        .read(composeDraftsProvider.notifier)
+        .save(key: 'ch1:t1', channelId: 'ch1', threadHeadId: 't1', text: 'wip');
+
+    final second = await containerWithPrefs();
+    final restored = second.read(composeDraftsProvider);
+    expect(restored, hasLength(1));
+    expect(restored.single.channelId, 'ch1');
+    expect(restored.single.threadHeadId, 't1');
+    expect(restored.single.text, 'wip');
+  });
+
+  test('remove deletes by key', () async {
+    SharedPreferences.setMockInitialValues({});
+    final container = await containerWithPrefs();
+    final notifier = container.read(composeDraftsProvider.notifier);
+
+    notifier.save(key: 'ch1', channelId: 'ch1', text: 'hello');
+    notifier.remove('ch1');
+
+    expect(container.read(composeDraftsProvider), isEmpty);
+  });
+
+  test('malformed persisted json is ignored', () async {
+    SharedPreferences.setMockInitialValues({
+      'compose_drafts_v1:https://relay-a.example:pk_a': '{not valid',
+    });
+    final container = await containerWithPrefs();
+    expect(container.read(composeDraftsProvider), isEmpty);
+  });
+
+  test('drafts are isolated per community', () async {
+    SharedPreferences.setMockInitialValues({});
+    final communityA = await containerWithPrefs(
+      relayUrl: 'https://relay-a.example',
+    );
+    communityA
+        .read(composeDraftsProvider.notifier)
+        .save(key: 'ch1', channelId: 'ch1', text: 'secret from A');
+
+    // Same channel id in another community must not see A's draft.
+    final communityB = await containerWithPrefs(
+      relayUrl: 'https://relay-b.example',
+    );
+    expect(communityB.read(composeDraftsProvider), isEmpty);
+    expect(
+      communityB.read(composeDraftsProvider.notifier).textFor('ch1'),
+      isNull,
+    );
+
+    // A's own store is untouched.
+    final communityAAgain = await containerWithPrefs(
+      relayUrl: 'https://relay-a.example',
+    );
+    expect(
+      communityAAgain.read(composeDraftsProvider.notifier).textFor('ch1'),
+      'secret from A',
+    );
+  });
+
+  test('drafts are isolated per account pubkey', () async {
+    SharedPreferences.setMockInitialValues({});
+    final accountA = await containerWithPrefs(pubkey: 'pk_a');
+    accountA
+        .read(composeDraftsProvider.notifier)
+        .save(key: 'ch1', channelId: 'ch1', text: 'account A draft');
+
+    // Same relay, different account: a colliding channel id must not
+    // restore the other account's draft.
+    final accountB = await containerWithPrefs(pubkey: 'pk_b');
+    expect(accountB.read(composeDraftsProvider), isEmpty);
+    expect(
+      accountB.read(composeDraftsProvider.notifier).textFor('ch1'),
+      isNull,
+    );
+  });
+
+  test('in-place identity change rebuilds onto the new store', () async {
+    SharedPreferences.setMockInitialValues({});
+    final prefs = await SharedPreferences.getInstance();
+    final container = ProviderContainer(
+      overrides: [
+        savedPrefsProvider.overrideWithValue(prefs),
+        // Real derivation path: myPubkeyProvider derives from the config's
+        // nsec, so an in-place config change simulates an account/community
+        // switch without restarting the container.
+        relayConfigProvider.overrideWith(
+          () => _FixedRelayConfigNotifier(
+            const RelayConfig(baseUrl: 'https://relay-a.example'),
+          ),
+        ),
+      ],
+    );
+    addTearDown(container.dispose);
+
+    // Seed a draft for the initial identity (nsec-less config → 'anon').
+    container
+        .read(composeDraftsProvider.notifier)
+        .save(key: 'ch1', channelId: 'ch1', text: 'first identity draft');
+    expect(container.read(composeDraftsProvider), hasLength(1));
+
+    // Switch community in place: the drafts provider must rebuild against
+    // the new identity's (empty) store, not keep the old state.
+    container
+        .read(relayConfigProvider.notifier)
+        .update(baseUrl: 'https://relay-b.example');
+    expect(container.read(composeDraftsProvider), isEmpty);
+    expect(
+      container.read(composeDraftsProvider.notifier).textFor('ch1'),
+      isNull,
+    );
+
+    // Switching back restores the original identity's draft.
+    container
+        .read(relayConfigProvider.notifier)
+        .update(baseUrl: 'https://relay-a.example');
+    expect(
+      container.read(composeDraftsProvider.notifier).textFor('ch1'),
+      'first identity draft',
+    );
+  });
+}