warn about outdated Flutter installations (#9163)

packages/flutter_tools/lib/src/cache.dart

@@ -74,6 +74,16 @@ class Cache {
     _lock = null;
   }
 
+  /// Checks if the current process owns the lock for the cache directory at
+  /// this very moment; throws a [StateError] if it doesn't.
+  static void checkLockAcquired() {
+    if (_lockEnabled && _lock == null) {
+      throw new StateError(
+        'The current process does not own the lock for the cache directory. This is a bug in Flutter CLI tools.',
+      );
+    }
+  }
+
   static String _dartSdkVersion;
 
   static String get dartSdkVersion {

packages/flutter_tools/lib/src/runner/flutter_command_runner.dart

@@ -236,6 +236,7 @@ class FlutterCommandRunner extends CommandRunner<Null> {
       flutterUsage.suppressAnalytics = true;
 
     _checkFlutterCopy();
+    await FlutterVersion.instance.checkFlutterVersionFreshness();
 
     if (globalResults.wasParsed('packages'))
       PackageMap.globalPackagesPath = fs.path.normalize(fs.path.absolute(globalResults['packages']));

packages/flutter_tools/pubspec.yaml

@@ -10,6 +10,7 @@ environment:
 dependencies:
   archive: ^1.0.20
   args: ^0.13.4
+  collection: '>=1.9.1 <2.0.0'
   coverage: ^0.8.0
   crypto: '>=1.1.1 <3.0.0'
   file: 2.3.2
@@ -23,6 +24,7 @@ dependencies:
   package_config: '>=0.1.5 <2.0.0'
   platform: 1.1.1
   process: 2.0.1
+  quiver: ^0.24.0
   stack_trace: ^1.4.0
   usage: ^3.0.1
   vm_service_client: '0.2.2+4'

packages/flutter_tools/test/src/context.dart

@@ -20,6 +20,7 @@ import 'package:flutter_tools/src/ios/mac.dart';
 import 'package:flutter_tools/src/ios/simulators.dart';
 import 'package:flutter_tools/src/run_hot.dart';
 import 'package:flutter_tools/src/usage.dart';
+import 'package:flutter_tools/src/version.dart';
 import 'package:mockito/mockito.dart';
 import 'package:process/process.dart';
 import 'package:test/test.dart';
@@ -53,7 +54,8 @@ void _defaultInitializeContext(AppContext testContext) {
       return mock;
     })
     ..putIfAbsent(SimControl, () => new MockSimControl())
-    ..putIfAbsent(Usage, () => new MockUsage());
+    ..putIfAbsent(Usage, () => new MockUsage())
+    ..putIfAbsent(FlutterVersion, () => new MockFlutterVersion());
 }
 
 void testUsingContext(String description, dynamic testMethod(), {
@@ -230,3 +232,5 @@ class _MockUsageTimer implements UsageTimer {
   @override
   void finish() { }
 }
+
+class MockFlutterVersion extends Mock implements FlutterVersion {}

packages/flutter_tools/test/src/runner/flutter_command_runner_test.dart

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:mockito/mockito.dart';
+import 'package:test/test.dart';
+
+import 'package:flutter_tools/src/version.dart';
+
+import '../context.dart';
+import '../common.dart';
+import 'flutter_command_test.dart';
+
+void main() {
+  group('FlutterCommandRunner', () {
+    testUsingContext('checks that Flutter installation is up-to-date', () async {
+      final MockFlutterVersion version = FlutterVersion.instance;
+      bool versionChecked = false;
+      when(version.checkFlutterVersionFreshness()).thenAnswer((_) async {
+        versionChecked = true;
+      });
+
+      await createTestCommandRunner(new DummyFlutterCommand(shouldUpdateCache: false))
+          .run(<String>['dummy']);
+
+      expect(versionChecked, isTrue);
+    });
+  });
+}

packages/flutter_tools/test/src/version_test.dart

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:convert';
+
+import 'package:collection/collection.dart';
+import 'package:meta/meta.dart';
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+import 'package:quiver/time.dart';
+import 'package:test/test.dart';
+
+import 'package:flutter_tools/src/base/context.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/logger.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/version.dart';
+
+import 'context.dart';
+
+const JsonEncoder _kPrettyJsonEncoder = const JsonEncoder.withIndent('  ');
+final Clock _testClock = new Clock.fixed(new DateTime(2015, 1, 1));
+final DateTime _upToDateVersion = _testClock.agoBy(FlutterVersion.kVersionAgeConsideredUpToDate ~/ 2);
+final DateTime _outOfDateVersion = _testClock.agoBy(FlutterVersion.kVersionAgeConsideredUpToDate * 2);
+final DateTime _stampUpToDate = _testClock.agoBy(FlutterVersion.kCheckAgeConsideredUpToDate ~/ 2);
+final DateTime _stampOutOfDate = _testClock.agoBy(FlutterVersion.kCheckAgeConsideredUpToDate * 2);
+const String _stampMissing = '____stamp_missing____';
+
+void main() {
+  group('FlutterVersion', () {
+    setUpAll(() {
+      Cache.disableLocking();
+    });
+
+    testFlutterVersion('prints nothing when Flutter installation looks fresh', () async {
+      fakeData(localCommitDate: _upToDateVersion);
+      await FlutterVersion.instance.checkFlutterVersionFreshness();
+      _expectVersionMessage('');
+    });
+
+    testFlutterVersion('prints nothing when Flutter installation looks out-of-date by is actually up-to-date', () async {
+      final FlutterVersion version = FlutterVersion.instance;
+
+      fakeData(
+        localCommitDate: _outOfDateVersion,
+        versionCheckStamp: _testStamp(
+          lastTimeVersionWasChecked: _stampOutOfDate,
+          lastKnownRemoteVersion: _outOfDateVersion,
+        ),
+        remoteCommitDate: _outOfDateVersion,
+        expectSetStamp: true,
+      );
+
+      await version.checkFlutterVersionFreshness();
+      _expectVersionMessage('');
+    });
+
+    testFlutterVersion('does not ping server when version stamp is up-to-date', () async {
+      final FlutterVersion version = FlutterVersion.instance;
+
+      fakeData(
+        localCommitDate: _outOfDateVersion,
+        versionCheckStamp: _testStamp(
+          lastTimeVersionWasChecked: _stampUpToDate,
+          lastKnownRemoteVersion: _upToDateVersion,
+        ),
+      );
+
+      await version.checkFlutterVersionFreshness();
+      _expectVersionMessage(FlutterVersion.versionOutOfDateMessage(_testClock.now().difference(_outOfDateVersion)));
+    });
+
+    testFlutterVersion('pings server when version stamp is missing', () async {
+      final FlutterVersion version = FlutterVersion.instance;
+
+      fakeData(
+          localCommitDate: _outOfDateVersion,
+          versionCheckStamp: _stampMissing,
+          remoteCommitDate: _upToDateVersion,
+          expectSetStamp: true,
+      );
+
+      await version.checkFlutterVersionFreshness();
+      _expectVersionMessage(FlutterVersion.versionOutOfDateMessage(_testClock.now().difference(_outOfDateVersion)));
+    });
+
+    testFlutterVersion('pings server when version stamp is out-of-date', () async {
+      final FlutterVersion version = FlutterVersion.instance;
+
+      fakeData(
+          localCommitDate: _outOfDateVersion,
+          versionCheckStamp: _testStamp(
+              lastTimeVersionWasChecked: _stampOutOfDate,
+              lastKnownRemoteVersion: _testClock.ago(days: 2),
+          ),
+          remoteCommitDate: _upToDateVersion,
+          expectSetStamp: true,
+      );
+
+      await version.checkFlutterVersionFreshness();
+      _expectVersionMessage(FlutterVersion.versionOutOfDateMessage(_testClock.now().difference(_outOfDateVersion)));
+    });
+
+    testFlutterVersion('ignores network issues', () async {
+      final FlutterVersion version = FlutterVersion.instance;
+
+      fakeData(
+          localCommitDate: _outOfDateVersion,
+          versionCheckStamp: _stampMissing,
+          errorOnFetch: true,
+      );
+
+      await version.checkFlutterVersionFreshness();
+      _expectVersionMessage('');
+    });
+  });
+}
+
+void _expectVersionMessage(String message) {
+  final BufferLogger logger = context[Logger];
+  expect(logger.statusText.trim(), message.trim());
+}
+
+String _testStamp({@required DateTime lastTimeVersionWasChecked, @required DateTime lastKnownRemoteVersion}) {
+  return _kPrettyJsonEncoder.convert(<String, String>{
+    'lastTimeVersionWasChecked': '$lastTimeVersionWasChecked',
+    'lastKnownRemoteVersion': '$lastKnownRemoteVersion',
+  });
+}
+
+void testFlutterVersion(String description, dynamic testMethod()) {
+  testUsingContext(
+    description,
+    testMethod,
+    overrides: <Type, Generator>{
+      FlutterVersion: () => new FlutterVersion(_testClock),
+      ProcessManager: () => new MockProcessManager(),
+      Cache: () => new MockCache(),
+    },
+  );
+}
+
+void fakeData({
+  @required DateTime localCommitDate,
+  DateTime remoteCommitDate,
+  String versionCheckStamp,
+  bool expectSetStamp: false,
+  bool errorOnFetch: false,
+}) {
+  final MockProcessManager pm = context[ProcessManager];
+  final MockCache cache = context[Cache];
+
+  ProcessResult success(String standardOutput) {
+    return new ProcessResult(1, 0, standardOutput, '');
+  }
+
+  ProcessResult failure(int exitCode) {
+    return new ProcessResult(1, exitCode, '', 'error');
+  }
+
+  when(cache.getStampFor(any)).thenAnswer((Invocation invocation) {
+    expect(invocation.positionalArguments.single, FlutterVersion.kFlutterVersionCheckStampFile);
+
+    if (versionCheckStamp == _stampMissing) {
+      return null;
+    }
+
+    if (versionCheckStamp != null) {
+      return versionCheckStamp;
+    }
+
+    throw new StateError('Unexpected call to Cache.getStampFor(${invocation.positionalArguments}, ${invocation.namedArguments})');
+  });
+
+  when(cache.setStampFor(any, any)).thenAnswer((Invocation invocation) {
+    expect(invocation.positionalArguments.first, FlutterVersion.kFlutterVersionCheckStampFile);
+
+    if (expectSetStamp) {
+      expect(invocation.positionalArguments[1], _testStamp(
+        lastKnownRemoteVersion: remoteCommitDate,
+        lastTimeVersionWasChecked: _testClock.now(),
+      ));
+      return null;
+    }
+
+    throw new StateError('Unexpected call to Cache.setStampFor(${invocation.positionalArguments}, ${invocation.namedArguments})');
+  });
+
+  final Answering syncAnswer = (Invocation invocation) {
+    bool argsAre(String a1, [String a2, String a3, String a4, String a5, String a6, String a7, String a8]) {
+      const ListEquality<String> equality = const ListEquality<String>();
+      final List<String> args = invocation.positionalArguments.single;
+      final List<String> expectedArgs =
+      <String>[a1, a2, a3, a4, a5, a6, a7, a8]
+          .where((String arg) => arg != null)
+          .toList();
+      return equality.equals(args, expectedArgs);
+    }
+
+    if (argsAre('git', 'log', '-n', '1', '--pretty=format:%ad', '--date=iso')) {
+      return success(localCommitDate.toString());
+    } else if (argsAre('git', 'remote')) {
+      return success('');
+    } else if (argsAre('git', 'remote', 'add', '__flutter_version_check__', 'https://github.com/flutter/flutter.git')) {
+      return success('');
+    } else if (argsAre('git', 'fetch', '__flutter_version_check__', 'master')) {
+      return errorOnFetch ? failure(128) : success('');
+    } else if (remoteCommitDate != null && argsAre('git', 'log', '__flutter_version_check__/master', '-n', '1', '--pretty=format:%ad', '--date=iso')) {
+      return success(remoteCommitDate.toString());
+    }
+
+    throw new StateError('Unexpected call to ProcessManager.run(${invocation.positionalArguments}, ${invocation.namedArguments})');
+  };
+
+  when(pm.runSync(any, workingDirectory: any)).thenAnswer(syncAnswer);
+  when(pm.run(any, workingDirectory: any)).thenAnswer((Invocation invocation) async {
+    return syncAnswer(invocation);
+  });
+}
+
+class MockProcessManager extends Mock implements ProcessManager {}
+class MockCache extends Mock implements Cache {}