Big merge from experimental to bleeding edge.

pkg/oauth2/test/authorization_code_grant_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library authorization_code_grant_test;
 
 import 'dart:io';
 import 'dart:json';
 import 'dart:uri';
 
@@ skipping 12 matching lines @@
 void createGrant() {
   client = new ExpectClient();
   grant = new oauth2.AuthorizationCodeGrant(
       'identifier',
       'secret',
       new Uri.fromString('https://example.com/authorization'),
       new Uri.fromString('https://example.com/token'),
       httpClient: client);
 }
 
+void expectFutureThrows(future, predicate) {
+  future.catchError(expectAsync1((AsyncError e) {
+    expect(predicate(e.error), isTrue);
+  }));
+}
+
 void main() {
   group('.getAuthorizationUrl', () {
     setUp(createGrant);
 
     test('builds the correct URL', () {
       expect(grant.getAuthorizationUrl(redirectUrl).toString(),
           equals('https://example.com/authorization'
               '?response_type=code'
               '&client_id=identifier'
               '&redirect_uri=http%3A%2F%2Fexample.com%2Fredirect'));
@@ skipping 33 matching lines @@
       expect(authorizationUrl.toString(),
           equals('https://example.com/authorization'
               '?query=value'
               '&response_type=code'
               '&client_id=identifier'
               '&redirect_uri=http%3A%2F%2Fexample.com%2Fredirect'));
     });
 
     test("can't be called twice", () {
       grant.getAuthorizationUrl(redirectUrl);
-      expect(() => grant.getAuthorizationUrl(redirectUrl), throwsStateError);
+      expectFutureThrows(grant.getAuthorizationUrl(redirectUrl),
+                        (e) => e is StateError);
     });
   });
 
   group('.handleAuthorizationResponse', () {
     setUp(createGrant);
 
     test("can't be called before .getAuthorizationUrl", () {
-      expect(grant.handleAuthorizationResponse({}), throwsStateError);
+      expectFutureThrows(grant.handleAuthorizationResponse({}),
+                         (e) => e is StateError);
     });
 
     test("can't be called twice", () {
       grant.getAuthorizationUrl(redirectUrl);
       grant.handleAuthorizationResponse({'code': 'auth code'});
-      expect(grant.handleAuthorizationResponse({'code': 'auth code'}),
-          throwsStateError);
+      expectFutureThrows(
+          grant.handleAuthorizationResponse({'code': 'auth code'}),
+          (e) => e is StateError);
     });
 
     test('must have a state parameter if the authorization URL did', () {
       grant.getAuthorizationUrl(redirectUrl, state: 'state');
-      expect(grant.handleAuthorizationResponse({'code': 'auth code'}),
-          throwsFormatException);
+      expectFutureThrows(
+          grant.handleAuthorizationResponse({'code': 'auth code'}),
+          (e) => e is FormatException);
     });
 
     test('must have the same state parameter the authorization URL did', () {
       grant.getAuthorizationUrl(redirectUrl, state: 'state');
-      expect(grant.handleAuthorizationResponse({
+      expectFutureThrows(grant.handleAuthorizationResponse({
         'code': 'auth code',
         'state': 'other state'
-      }), throwsFormatException);
+      }), (e) => e is FormatException);
     });
 
     test('must have a code parameter', () {
       grant.getAuthorizationUrl(redirectUrl);
-      expect(grant.handleAuthorizationResponse({}), throwsFormatException);
+      expectFutureThrows(grant.handleAuthorizationResponse({}),
+                         (e) => e is FormatException);
     });
 
     test('with an error parameter throws an AuthorizationException', () {
       grant.getAuthorizationUrl(redirectUrl);
-      expect(grant.handleAuthorizationResponse({'error': 'invalid_request'}),
-          throwsAuthorizationException);
+      expectFutureThrows(
+          grant.handleAuthorizationResponse({'error': 'invalid_request'}),
+          (e) => e is AuthorizationException);
     });
 
     test('sends an authorization code request', () {
       grant.getAuthorizationUrl(redirectUrl);
       client.expectRequest((request) {
         expect(request.method, equals('POST'));
         expect(request.url.toString(), equals(grant.tokenEndpoint.toString()));
         expect(request.bodyFields, equals({
           'grant_type': 'authorization_code',
           'code': 'auth code',
@@ skipping 19 matching lines @@
   group('.handleAuthorizationCode', () {
     setUp(createGrant);
 
     test("can't be called before .getAuthorizationUrl", () {
       expect(grant.handleAuthorizationCode('auth code'), throwsStateError);
     });
 
     test("can't be called twice", () {
       grant.getAuthorizationUrl(redirectUrl);
       grant.handleAuthorizationCode('auth code');
-      expect(grant.handleAuthorizationCode('auth code'),
-          throwsStateError);
+      expectFutureThrows(grant.handleAuthorizationCode('auth code'),
+                         (e) => e is StateError);
     });
 
     test('sends an authorization code request', () {
       grant.getAuthorizationUrl(redirectUrl);
       client.expectRequest((request) {
         expect(request.method, equals('POST'));
         expect(request.url.toString(), equals(grant.tokenEndpoint.toString()));
         expect(request.bodyFields, equals({
           'grant_type': 'authorization_code',
           'code': 'auth code',
           'redirect_uri': redirectUrl.toString(),
           'client_id': 'identifier',
           'client_secret': 'secret'
         }));
 
         return new Future.immediate(new http.Response(JSON.stringify({
           'access_token': 'access token',
           'token_type': 'bearer',
         }), 200, headers: {'content-type': 'application/json'}));
       });
 
       expect(grant.handleAuthorizationCode('auth code'),
           completion(predicate((client) {
             expect(client.credentials.accessToken, equals('access token'));
             return true;
           })));
     });
   });
 }