fuchsia_remote_connection_test.dart 12.3 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4 5
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'package:fuchsia_remote_debug_protocol/fuchsia_remote_debug_protocol.dart';
6
import 'package:test/fake.dart';
7
import 'package:test/test.dart';
8
import 'package:vm_service/vm_service.dart' as vms;
9 10 11

void main() {
  group('FuchsiaRemoteConnection.connect', () {
12
    late List<FakePortForwarder> forwardedPorts;
13
    List<FakeVmService> fakeVmServices;
14
    late List<Uri> uriConnections;
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

    setUp(() {
      final List<Map<String, dynamic>> flutterViewCannedResponses =
          <Map<String, dynamic>>[
        <String, dynamic>{
          'views': <Map<String, dynamic>>[
            <String, dynamic>{
              'type': 'FlutterView',
              'id': 'flutterView0',
            },
          ],
        },
        <String, dynamic>{
          'views': <Map<String, dynamic>>[
            <String, dynamic>{
              'type': 'FlutterView',
              'id': 'flutterView1',
              'isolate': <String, dynamic>{
                'type': '@Isolate',
                'fixedId': 'true',
                'id': 'isolates/1',
                'name': 'file://flutterBinary1',
                'number': '1',
              },
39
            },
40 41 42 43 44 45 46 47 48 49 50 51 52 53
          ],
        },
        <String, dynamic>{
          'views': <Map<String, dynamic>>[
            <String, dynamic>{
              'type': 'FlutterView',
              'id': 'flutterView2',
              'isolate': <String, dynamic>{
                'type': '@Isolate',
                'fixedId': 'true',
                'id': 'isolates/2',
                'name': 'file://flutterBinary2',
                'number': '2',
              },
54
            },
55 56 57 58
          ],
        },
      ];

59 60
      forwardedPorts = <FakePortForwarder>[];
      fakeVmServices = <FakeVmService>[];
61
      uriConnections = <Uri>[];
62
      Future<vms.VmService> fakeVmConnectionFunction(
63
        Uri uri, {
64
        Duration? timeout,
65
      }) {
66
        return Future<vms.VmService>(() async {
67 68
          final FakeVmService service = FakeVmService();
          fakeVmServices.add(service);
69
          uriConnections.add(uri);
70
          service.flutterListViews = vms.Response.parse(flutterViewCannedResponses[uri.port]);
71
          return service;
72 73 74
        });
      }

75
      fuchsiaVmServiceConnectionFunction = fakeVmConnectionFunction;
76 77 78
    });

    tearDown(() {
79
      /// Most tests will fake out the port forwarding and connection
80 81 82 83
      /// functions.
      restoreFuchsiaPortForwardingFunction();
      restoreVmServiceConnectionFunction();
    });
84

85
    test('end-to-end with three vm connections and flutter view query', () async {
86
      int port = 0;
87
      Future<PortForwarder> fakePortForwardingFunction(
88 89
        String address,
        int remotePort, [
90 91
        String? interface = '',
        String? configFile,
92 93
      ]) {
        return Future<PortForwarder>(() {
94
          final FakePortForwarder pf = FakePortForwarder();
95
          forwardedPorts.add(pf);
96 97
          pf.port = port++;
          pf.remotePort = remotePort;
98 99 100 101
          return pf;
        });
      }

102 103
      fuchsiaPortForwardingFunction = fakePortForwardingFunction;
      final FakeSshCommandRunner fakeRunner = FakeSshCommandRunner();
104
      // Adds some extra junk to make sure the strings will be cleaned up.
105 106 107 108
      fakeRunner.findResponse = <String>['/hub/blah/blah/blah/vmservice-port\n'];
      fakeRunner.lsResponse = <String>['123\n\n\n', '456  ', '789'];
      fakeRunner.address = 'fe80::8eae:4cff:fef4:9247';
      fakeRunner.interface = 'eno1';
109

110
      final FuchsiaRemoteConnection connection =
111
          await FuchsiaRemoteConnection.connectWithSshCommandRunner(fakeRunner);
112

113
      // [fakePortForwardingFunction] will have returned three different
114 115 116 117 118 119 120 121 122 123
      // forwarded ports, incrementing the port each time by one. (Just a sanity
      // check that the forwarding port was called).
      expect(forwardedPorts.length, 3);
      expect(forwardedPorts[0].remotePort, 123);
      expect(forwardedPorts[1].remotePort, 456);
      expect(forwardedPorts[2].remotePort, 789);
      expect(forwardedPorts[0].port, 0);
      expect(forwardedPorts[1].port, 1);
      expect(forwardedPorts[2].port, 2);

124
      // VMs should be accessed via localhost ports given by
125
      // [fakePortForwardingFunction].
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
      expect(uriConnections[0],
        Uri(scheme:'ws', host:'[::1]', port:0, path:'/ws'));
      expect(uriConnections[1],
        Uri(scheme:'ws', host:'[::1]', port:1, path:'/ws'));
      expect(uriConnections[2],
        Uri(scheme:'ws', host:'[::1]', port:2, path:'/ws'));

      final List<FlutterView> views = await connection.getFlutterViews();
      expect(views, isNot(null));
      expect(views.length, 3);
      // Since name can be null, check for the ID on all of them.
      expect(views[0].id, 'flutterView0');
      expect(views[1].id, 'flutterView1');
      expect(views[2].id, 'flutterView2');

      expect(views[0].name, equals(null));
      expect(views[1].name, 'file://flutterBinary1');
      expect(views[2].name, 'file://flutterBinary2');

      // Ensure the ports are all closed after stop was called.
      await connection.stop();
147 148 149
      expect(forwardedPorts[0].stopped, true);
      expect(forwardedPorts[1].stopped, true);
      expect(forwardedPorts[2].stopped, true);
150 151 152 153
    });

    test('end-to-end with three vms and remote open port', () async {
      int port = 0;
154
      Future<PortForwarder> fakePortForwardingFunction(
155 156
        String address,
        int remotePort, [
157 158
        String? interface = '',
        String? configFile,
159 160
      ]) {
        return Future<PortForwarder>(() {
161
          final FakePortForwarder pf = FakePortForwarder();
162
          forwardedPorts.add(pf);
163 164 165
          pf.port = port++;
          pf.remotePort = remotePort;
          pf.openPortAddress = 'fe80::1:2%eno2';
166 167 168 169
          return pf;
        });
      }

170 171
      fuchsiaPortForwardingFunction = fakePortForwardingFunction;
      final FakeSshCommandRunner fakeRunner = FakeSshCommandRunner();
172
      // Adds some extra junk to make sure the strings will be cleaned up.
173 174 175 176
      fakeRunner.findResponse = <String>['/hub/blah/blah/blah/vmservice-port\n'];
      fakeRunner.lsResponse = <String>['123\n\n\n', '456  ', '789'];
      fakeRunner.address = 'fe80::8eae:4cff:fef4:9247';
      fakeRunner.interface = 'eno1';
177
      final FuchsiaRemoteConnection connection =
178
          await FuchsiaRemoteConnection.connectWithSshCommandRunner(fakeRunner);
179

180
      // [fakePortForwardingFunction] will have returned three different
181 182 183 184 185 186 187 188 189 190
      // forwarded ports, incrementing the port each time by one. (Just a sanity
      // check that the forwarding port was called).
      expect(forwardedPorts.length, 3);
      expect(forwardedPorts[0].remotePort, 123);
      expect(forwardedPorts[1].remotePort, 456);
      expect(forwardedPorts[2].remotePort, 789);
      expect(forwardedPorts[0].port, 0);
      expect(forwardedPorts[1].port, 1);
      expect(forwardedPorts[2].port, 2);

191
      // VMs should be accessed via the alternate address given by
192
      // [fakePortForwardingFunction].
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
      expect(uriConnections[0],
        Uri(scheme:'ws', host:'[fe80::1:2%25eno2]', port:0, path:'/ws'));
      expect(uriConnections[1],
        Uri(scheme:'ws', host:'[fe80::1:2%25eno2]', port:1, path:'/ws'));
      expect(uriConnections[2],
        Uri(scheme:'ws', host:'[fe80::1:2%25eno2]', port:2, path:'/ws'));

      final List<FlutterView> views = await connection.getFlutterViews();
      expect(views, isNot(null));
      expect(views.length, 3);
      // Since name can be null, check for the ID on all of them.
      expect(views[0].id, 'flutterView0');
      expect(views[1].id, 'flutterView1');
      expect(views[2].id, 'flutterView2');

      expect(views[0].name, equals(null));
      expect(views[1].name, 'file://flutterBinary1');
      expect(views[2].name, 'file://flutterBinary2');

      // Ensure the ports are all closed after stop was called.
      await connection.stop();
214 215 216
      expect(forwardedPorts[0].stopped, true);
      expect(forwardedPorts[1].stopped, true);
      expect(forwardedPorts[2].stopped, true);
217 218 219 220
    });

    test('end-to-end with three vms and ipv4', () async {
      int port = 0;
221
      Future<PortForwarder> fakePortForwardingFunction(
222 223
        String address,
        int remotePort, [
224 225
        String? interface = '',
        String? configFile,
226 227
      ]) {
        return Future<PortForwarder>(() {
228
          final FakePortForwarder pf = FakePortForwarder();
229
          forwardedPorts.add(pf);
230 231
          pf.port = port++;
          pf.remotePort = remotePort;
232 233 234 235
          return pf;
        });
      }

236 237
      fuchsiaPortForwardingFunction = fakePortForwardingFunction;
      final FakeSshCommandRunner fakeRunner = FakeSshCommandRunner();
238
      // Adds some extra junk to make sure the strings will be cleaned up.
239 240 241
      fakeRunner.findResponse = <String>['/hub/blah/blah/blah/vmservice-port\n'];
      fakeRunner.lsResponse = <String>['123\n\n\n', '456  ', '789'];
      fakeRunner.address = '196.168.1.4';
242 243

      final FuchsiaRemoteConnection connection =
244
          await FuchsiaRemoteConnection.connectWithSshCommandRunner(fakeRunner);
245

246
      // [fakePortForwardingFunction] will have returned three different
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
      // forwarded ports, incrementing the port each time by one. (Just a sanity
      // check that the forwarding port was called).
      expect(forwardedPorts.length, 3);
      expect(forwardedPorts[0].remotePort, 123);
      expect(forwardedPorts[1].remotePort, 456);
      expect(forwardedPorts[2].remotePort, 789);
      expect(forwardedPorts[0].port, 0);
      expect(forwardedPorts[1].port, 1);
      expect(forwardedPorts[2].port, 2);

      // VMs should be accessed via the ipv4 loopback.
      expect(uriConnections[0],
        Uri(scheme:'ws', host:'127.0.0.1', port:0, path:'/ws'));
      expect(uriConnections[1],
        Uri(scheme:'ws', host:'127.0.0.1', port:1, path:'/ws'));
      expect(uriConnections[2],
        Uri(scheme:'ws', host:'127.0.0.1', port:2, path:'/ws'));

265 266 267 268 269 270 271 272 273 274 275 276 277 278
      final List<FlutterView> views = await connection.getFlutterViews();
      expect(views, isNot(null));
      expect(views.length, 3);
      // Since name can be null, check for the ID on all of them.
      expect(views[0].id, 'flutterView0');
      expect(views[1].id, 'flutterView1');
      expect(views[2].id, 'flutterView2');

      expect(views[0].name, equals(null));
      expect(views[1].name, 'file://flutterBinary1');
      expect(views[2].name, 'file://flutterBinary2');

      // Ensure the ports are all closed after stop was called.
      await connection.stop();
279 280 281
      expect(forwardedPorts[0].stopped, true);
      expect(forwardedPorts[1].stopped, true);
      expect(forwardedPorts[2].stopped, true);
282
    });
283 284

    test('env variable test without remote addr', () async {
285
      Future<void> failingFunction() async {
286 287 288 289 290
        await FuchsiaRemoteConnection.connect();
      }

      // Should fail as no env variable has been passed.
      expect(failingFunction,
Dan Field's avatar
Dan Field committed
291
          throwsA(isA<FuchsiaRemoteConnectionError>()));
292
    });
293 294 295
  });
}

296
class FakeSshCommandRunner extends Fake implements SshCommandRunner {
297 298
  List<String>? findResponse;
  List<String>? lsResponse;
299 300 301
  @override
  Future<List<String>> run(String command) async {
    if (command.startsWith('/bin/find')) {
302
      return findResponse!;
303 304
    }
    if (command.startsWith('/bin/ls')) {
305
      return lsResponse!;
306 307 308 309 310
    }
    throw UnimplementedError(command);
  }

  @override
311
  String interface = '';
312 313

  @override
314
  String address = '';
315 316 317 318 319 320 321

  @override
  String get sshConfigPath => '~/.ssh';
}

class FakePortForwarder extends Fake implements PortForwarder {
  @override
322
  int port = 0;
323 324

  @override
325
  int remotePort = 0;
326

327
  @override
328
  String? openPortAddress;
329

330 331 332 333 334 335 336 337 338
  bool stopped = false;
  @override
  Future<void> stop() async {
    stopped = true;
  }
}

class FakeVmService extends Fake implements vms.VmService {
  bool disposed = false;
339
  vms.Response? flutterListViews;
340 341 342 343 344 345 346

  @override
  Future<void> dispose() async {
    disposed = true;
  }

  @override
347
  Future<vms.Response> callMethod(String method, {String? isolateId, Map<String, dynamic>? args}) async {
348
    if (method == '_flutter.listViews') {
349
      return flutterListViews!;
350 351 352 353 354
    }
    throw UnimplementedError(method);
  }

  @override
355
  Future<void> onDone = Future<void>.value();
356 357 358 359 360 361

  @override
  Future<vms.Version> getVersion() async {
    return vms.Version(major: -1, minor: -1);
  }
}