309 lines
11 KiB
Dart
309 lines
11 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:dio/dio.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:jinzhi_flutter_app/common/storage/secure_identity_storage.dart';
|
|
import 'package:jinzhi_flutter_app/common/storage/storage_keys.dart';
|
|
import 'package:jinzhi_flutter_app/common/storage/preferences_storage.dart';
|
|
import 'package:jinzhi_flutter_app/features/auth/application/auth_controller.dart';
|
|
import 'package:jinzhi_flutter_app/features/auth/application/auth_session_coordinator.dart';
|
|
import 'package:jinzhi_flutter_app/features/auth/data/auth_models.dart';
|
|
import 'package:jinzhi_flutter_app/features/assets/data/mock_asset_repository.dart';
|
|
import 'package:jinzhi_flutter_app/models/pb/jinzhi/v1/account.pb.dart' as pb;
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
|
|
void main() {
|
|
TestWidgetsFlutterBinding.ensureInitialized();
|
|
|
|
setUp(() => SharedPreferences.setMockInitialValues({}));
|
|
|
|
test('restores a token by loading the real profile', () async {
|
|
final fixture = await _Fixture.create();
|
|
await fixture.identity.saveJwt('token');
|
|
|
|
await fixture.controller.retryBootstrap();
|
|
|
|
final auth = fixture.controller.state.value! as LoggedInAuthState;
|
|
expect(auth.token, 'token');
|
|
expect(auth.user.id, 'user-1');
|
|
expect(auth.user.phone, '13800138000');
|
|
expect(fixture.preferences.getString(storageUserId), 'user-1');
|
|
});
|
|
|
|
test('deletes the server account before clearing local identity', () async {
|
|
final fixture = await _Fixture.create();
|
|
await fixture.identity.saveJwt('token');
|
|
await fixture.controller.retryBootstrap();
|
|
|
|
await fixture.controller.deleteAccount('123456');
|
|
|
|
expect(fixture.deletedWithCode, '123456');
|
|
expect(fixture.controller.state.value, isA<GuestAuthState>());
|
|
expect(await fixture.identity.readJwt(), isNull);
|
|
expect(fixture.preferences.getString(storageUserId), isNull);
|
|
});
|
|
|
|
test('keeps the local session when server deletion fails', () async {
|
|
final fixture = await _Fixture.create();
|
|
await fixture.identity.saveJwt('token');
|
|
await fixture.controller.retryBootstrap();
|
|
fixture.failDeletion = true;
|
|
|
|
await expectLater(
|
|
fixture.controller.deleteAccount('123456'),
|
|
throwsA(isA<DioException>()),
|
|
);
|
|
|
|
expect(fixture.controller.state.value, isA<LoggedInAuthState>());
|
|
expect(await fixture.identity.readJwt(), 'token');
|
|
expect(fixture.preferences.getString(storageUserId), 'user-1');
|
|
});
|
|
|
|
test('clears an unauthorized restored session', () async {
|
|
final fixture = await _Fixture.create();
|
|
await fixture.identity.saveJwt('expired');
|
|
fixture.profileUnauthorized = true;
|
|
|
|
await fixture.controller.retryBootstrap();
|
|
|
|
expect(fixture.controller.state.value, isA<SessionExpiredAuthState>());
|
|
expect(await fixture.identity.readJwt(), isNull);
|
|
});
|
|
|
|
test('keeps a valid token and cached profile on a network failure', () async {
|
|
final fixture = await _Fixture.create();
|
|
await fixture.identity.saveJwt('token');
|
|
await fixture.preferences.setString('jinzhi_mock_logged_in', '13900139000');
|
|
fixture.failProfile = true;
|
|
|
|
await fixture.controller.retryBootstrap();
|
|
|
|
final auth = fixture.controller.state.value! as LoggedInAuthState;
|
|
expect(auth.user.id, isEmpty);
|
|
expect(auth.user.phone, '13900139000');
|
|
expect(await fixture.identity.readJwt(), 'token');
|
|
expect(fixture.preferences.getString(storageUserPhone), '13900139000');
|
|
expect(fixture.preferences.containsKey('jinzhi_mock_logged_in'), isFalse);
|
|
});
|
|
|
|
test('restores cached profile before the background profile reply', () async {
|
|
final fixture = await _Fixture.create();
|
|
await fixture.identity.saveJwt('token');
|
|
await fixture.preferences.setString(storageUserId, 'cached-user');
|
|
await fixture.preferences.setString(storageUserPhone, '13900139000');
|
|
fixture.profileCompleter = Completer<void>();
|
|
|
|
final bootstrap = fixture.controller.retryBootstrap();
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
final stale = fixture.controller.state.value! as LoggedInAuthState;
|
|
expect(stale.user.id, 'cached-user');
|
|
expect(stale.isVerified, isFalse);
|
|
|
|
fixture.profileCompleter!.complete();
|
|
await bootstrap;
|
|
expect(
|
|
(fixture.controller.state.value! as LoggedInAuthState).isVerified,
|
|
isTrue,
|
|
);
|
|
});
|
|
|
|
test('keeps cached login on 403, 429, 5xx, and decode failures', () async {
|
|
for (final failure in [403, 429, 503, -1]) {
|
|
final fixture = await _Fixture.create();
|
|
await fixture.identity.saveJwt('token');
|
|
await fixture.preferences.setString(storageUserId, 'cached-user');
|
|
fixture.profileFailureStatus = failure;
|
|
|
|
await fixture.controller.retryBootstrap();
|
|
|
|
expect(fixture.controller.state.value, isA<LoggedInAuthState>());
|
|
expect(await fixture.identity.readJwt(), 'token');
|
|
}
|
|
});
|
|
|
|
test('logout preserves assets while account deletion removes them', () async {
|
|
final logoutFixture = await _Fixture.create();
|
|
await logoutFixture.identity.saveJwt('token');
|
|
await logoutFixture.preferences.setString(storageJinzhiHoldings, 'assets');
|
|
await logoutFixture.controller.logout();
|
|
expect(
|
|
logoutFixture.preferences.getString(storageJinzhiHoldings),
|
|
'assets',
|
|
);
|
|
|
|
final deleteFixture = await _Fixture.create();
|
|
await deleteFixture.identity.saveJwt('token');
|
|
await deleteFixture.preferences.setString(storageJinzhiHoldings, 'assets');
|
|
await deleteFixture.controller.deleteAccount('123456');
|
|
expect(deleteFixture.preferences.getString(storageJinzhiHoldings), isNull);
|
|
});
|
|
|
|
test('keeps the verified one-key login state shape', () async {
|
|
final fixture = await _Fixture.create();
|
|
|
|
await fixture.controller.verifyOneKeyLogin('umeng-token');
|
|
|
|
final auth = fixture.controller.state.value! as LoggedInAuthState;
|
|
expect(auth.token, 'one-key-token');
|
|
expect(auth.user.phone, '13800138000');
|
|
expect(await fixture.identity.readJwt(), 'one-key-token');
|
|
});
|
|
}
|
|
|
|
class _Fixture {
|
|
_Fixture({
|
|
required this.preferences,
|
|
required this.identity,
|
|
required this.controller,
|
|
});
|
|
|
|
final SharedPreferences preferences;
|
|
final SecureIdentityStorage identity;
|
|
final AuthController controller;
|
|
bool failDeletion = false;
|
|
bool failProfile = false;
|
|
bool profileUnauthorized = false;
|
|
int? profileFailureStatus;
|
|
Completer<void>? profileCompleter;
|
|
String? deletedWithCode;
|
|
|
|
static Future<_Fixture> create() async {
|
|
final preferences = await SharedPreferences.getInstance();
|
|
final identity = SecureIdentityStorage(
|
|
PreferencesStorage(preferences),
|
|
secureStorage: _MemorySecureStorage(),
|
|
);
|
|
late _Fixture fixture;
|
|
final dio = Dio()
|
|
..interceptors.add(
|
|
InterceptorsWrapper(
|
|
onRequest: (options, handler) async {
|
|
if (options.path == '/api/v1/me' && options.method == 'GET') {
|
|
if (fixture.profileCompleter case final completer?) {
|
|
await completer.future;
|
|
}
|
|
if (fixture.profileFailureStatus case final status?) {
|
|
if (status == -1) {
|
|
handler.resolve(
|
|
Response<List<int>>(
|
|
requestOptions: options,
|
|
statusCode: 200,
|
|
data: const [255],
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
handler.reject(
|
|
DioException(
|
|
requestOptions: options,
|
|
response: Response<void>(
|
|
requestOptions: options,
|
|
statusCode: status,
|
|
),
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
if (fixture.failProfile) {
|
|
handler.reject(DioException(requestOptions: options));
|
|
return;
|
|
}
|
|
if (fixture.profileUnauthorized) {
|
|
handler.reject(
|
|
DioException(
|
|
requestOptions: options,
|
|
response: Response<void>(
|
|
requestOptions: options,
|
|
statusCode: 401,
|
|
),
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
handler.resolve(
|
|
Response<List<int>>(
|
|
requestOptions: options,
|
|
statusCode: 200,
|
|
data: pb.ProfileReply(
|
|
user: pb.UserInfo(
|
|
id: 'user-1',
|
|
phone: '13800138000',
|
|
createdAt: '2026-09-08T00:00:00Z',
|
|
),
|
|
).writeToBuffer(),
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
if (options.path == '/api/v1/me' && options.method == 'DELETE') {
|
|
fixture.deletedWithCode = pb.DeleteAccountRequest.fromBuffer(
|
|
options.data as List<int>,
|
|
).smsCode;
|
|
if (fixture.failDeletion) {
|
|
handler.reject(DioException(requestOptions: options));
|
|
} else {
|
|
handler.resolve(
|
|
Response<List<int>>(
|
|
requestOptions: options,
|
|
statusCode: 200,
|
|
data: const <int>[],
|
|
),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
if (options.path == '/api/v1/auth/onekey/verify') {
|
|
handler.resolve(
|
|
Response<List<int>>(
|
|
requestOptions: options,
|
|
statusCode: 200,
|
|
data: pb.VerifySmsCodeReply(
|
|
accessToken: 'one-key-token',
|
|
user: pb.UserInfo(phone: '13800138000'),
|
|
).writeToBuffer(),
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
handler.next(options);
|
|
},
|
|
),
|
|
);
|
|
final preferencesStorage = PreferencesStorage(preferences);
|
|
final sessionStorage = AuthSessionStorage(identity);
|
|
final coordinator = AuthSessionCoordinator(
|
|
sessionStorage,
|
|
preferencesStorage,
|
|
MockAssetRepository(preferencesStorage),
|
|
);
|
|
final controller = AuthController(
|
|
dio,
|
|
preferences: preferencesStorage,
|
|
coordinator: coordinator,
|
|
autoBootstrap: false,
|
|
);
|
|
fixture = _Fixture(
|
|
preferences: preferences,
|
|
identity: identity,
|
|
controller: controller,
|
|
);
|
|
return fixture;
|
|
}
|
|
}
|
|
|
|
class _MemorySecureStorage implements SecureKeyValueStorage {
|
|
final Map<String, String> _values = {};
|
|
|
|
@override
|
|
Future<void> delete(String key) async => _values.remove(key);
|
|
|
|
@override
|
|
Future<String?> read(String key) async => _values[key];
|
|
|
|
@override
|
|
Future<void> write(String key, String value) async {
|
|
_values[key] = value;
|
|
}
|
|
}
|