PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.
Dart airdrop-alternativeclipboardclipboard-sharingclipboard-synccopy-pastecross-platformend-to-end-encryptionfile-syncfile-transferfluttergolanglinuxmacosnat-traversalp2pself-hostedtailscaleuniversal-clipboardwebrtcwindows
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:grpc/grpc.dart';
import 'package:pasteferry_ui/app_state.dart';
import 'package:pasteferry_ui/background_service.dart';
import 'package:pasteferry_ui/daemon_client.dart';
import 'package:pasteferry_ui/gen/pasteferry/v1/daemon.pbgrpc.dart';
class _Service implements BackgroundService {
@override
bool get available => false;
@override
Future<ServiceState> state() async => ServiceState.running;
@override
dynamic noSuchMethod(Invocation invocation) =>
throw StateError('$invocation');
}
class _Daemon extends DaemonServiceBase {
final statusStarted = Completer<void>();
final statusResult = Completer<Status>();
final events = StreamController<Event>.broadcast();
@override
Future<Config> getConfig(ServiceCall call, Empty request) async =>
Config(language: 'zh-Hans', deviceName: 'Windows');
@override
Future<Config> updateConfig(ServiceCall call, Config request) async =>
request;
@override
Future<Status> getStatus(ServiceCall call, Empty request) {
if (!statusStarted.isCompleted) statusStarted.complete();
return statusResult.future;
}
@override
Future<ListHistoryResponse> listHistory(
ServiceCall call,
ListHistoryRequest request,
) async => ListHistoryResponse();
@override
Future<ListDevicesResponse> listDevices(
ServiceCall call,
Empty request,
) async => ListDevicesResponse(self: Device(id: 'self'));
@override
Stream<Event> subscribe(ServiceCall call, SubscribeRequest request) =>
events.stream;
@override
dynamic noSuchMethod(Invocation invocation) =>
throw const GrpcError.unimplemented();
}
void main() {
late _Daemon daemon;
late Server server;
late Directory dir;
setUp(() async {
daemon = _Daemon();
server = Server.create(services: [daemon]);
await server.serve(address: InternetAddress.loopbackIPv4, port: 0);
dir = await Directory.systemTemp.createTemp('pasteferry-connection-');
await File(
'${dir.path}/daemon.json',
).writeAsString(jsonEncode({'port': server.port, 'token': 'test'}));
});
tearDown(() async {
if (!daemon.statusResult.isCompleted) {
daemon.statusResult.complete(Status());
}
await daemon.events.close();
await server.shutdown();
await dir.delete(recursive: true);
});
Future<DaemonConnection> connect({
Duration requestTimeout = const Duration(seconds: 2),
}) => DaemonConnection.connect(
dataDir: dir.path,
requestTimeout: requestTimeout,
);
test(
'settings config appears while status is stalled; timeout permits reconnect',
() async {
final state = AppState(service: _Service(), connectDaemon: () => connect());
addTearDown(state.dispose);
final configReady = Completer<void>();
state.addListener(() {
if (state.config != null && !configReady.isCompleted) {
configReady.complete();
}
});
final first = state.connect();
await configReady.future.timeout(const Duration(seconds: 10));
expect(state.config?.deviceName, 'Windows');
expect(daemon.statusResult.isCompleted, isFalse);
await first.timeout(const Duration(seconds: 10));
expect(state.link, LinkState.offline);
daemon.statusResult.complete(Status(deviceId: 'self'));
await state.connect().timeout(const Duration(seconds: 10));
expect(state.link, LinkState.online);
expect(state.config?.deviceName, 'Windows');
},
);
test('unary calls time out but event streams stay open', () async {
final conn = await connect(requestTimeout: const Duration(milliseconds: 300));
addTearDown(conn.close);
final subscription = conn.client.subscribe(SubscribeRequest());
final event = subscription.first;
await expectLater(
conn.client.getStatus(Empty()),
throwsA(
isA<GrpcError>().having(
(e) => e.code,
'code',
StatusCode.deadlineExceeded,
),
),
);
daemon.events.add(
Event(statusChanged: Status(deviceId: 'still-subscribed')),
);
expect(
(await event.timeout(const Duration(seconds: 10))).statusChanged.deviceId,
'still-subscribed',
);
});
test(
'settings edited during startup are retained when status arrives',
() async {
final state = AppState(service: _Service(), connectDaemon: () => connect());
addTearDown(state.dispose);
final configReady = Completer<void>();
state.addListener(() {
if (state.config != null && !configReady.isCompleted) {
configReady.complete();
}
});
final startup = state.connect();
await configReady.future.timeout(const Duration(seconds: 10));
await state.updateConfig(
state.config!.deepCopy()..deviceName = 'Renamed',
);
daemon.statusResult.complete(Status(deviceId: 'self'));
await startup.timeout(const Duration(seconds: 10));
expect(state.link, LinkState.online);
expect(state.config?.deviceName, 'Renamed');
},
);
test('explicit deadlines override the default timeout', () async {
final conn = await connect(requestTimeout: const Duration(milliseconds: 300));
addTearDown(conn.close);
final response = conn.client.getStatus(
Empty(),
options: CallOptions(timeout: const Duration(seconds: 2)),
);
await daemon.statusStarted.future;
await Future<void>.delayed(const Duration(milliseconds: 450));
daemon.statusResult.complete(Status(deviceId: 'completed'));
expect((await response).deviceId, 'completed');
});
}