test: use proper matchers in tests (#1437)

## What kind of change does this PR introduce?

Test quality cleanup. No production code changes; only test files are
touched.

## What is the current behavior?

Several test suites used non-idiomatic assertions:

- boolean-literal expectations, e.g. `expect(x, true)` / `expect(x,
false)`
- equality checks done inside the actual argument, e.g. `expect(a == b,
true)`
- length-zero emptiness checks, e.g. `expect(x.length, 0)`
- exception assertions written as `try { await ...; fail('...'); } catch
(e) { expect(e, ...) }`

## What is the new behavior?

These are replaced with the proper matchers across all packages:

- `expect(x, isTrue)` / `expect(x, isFalse)`
- `expect(a, b)` / `expect(a, isNot(b))`
- `expect(x, isEmpty)`
- `expectLater(() => ..., throwsA(isA<T>().having((e) => e.field,
'field', value)))`

Approximate counts: ~47 boolean matchers, ~22 direct equality, ~8
emptiness, ~43 exception conversions across 22 test files in
functions_client, gotrue, postgrest, realtime_client, storage_client,
supabase, and supabase_flutter.

A few `fail()` calls were intentionally left in place because they are
not exception-testing patterns (one sits inside an `await for` stream
loop, two assert that a download succeeds after copy/move).

## How was the change verified?

- `dart analyze` / `flutter analyze` on every affected package's `test/`
directory: no issues.
- `dart format` on all changed files: already conformant.
- All mock-based suites pass. Server-dependent integration suites were
not run locally but analyze cleanly; the conversions are mechanical and
preserve assertion meaning.

Author: spydon

packages/functions_client/test/functions_dart_test.dart

@@ -20,12 +20,11 @@ void main() {
           FunctionsClient("", {}, httpClient: customHttpClient);
     });
     test('function throws', () async {
-      try {
-        await functionsCustomHttpClient.invoke('error-function');
-        fail('should throw');
-      } on FunctionException catch (e) {
-        expect(e.status, 420);
-      }
+      await expectLater(
+        () => functionsCustomHttpClient.invoke('error-function'),
+        throwsA(
+            isA<FunctionException>().having((e) => e.status, 'status', 420)),
+      );
     });
 
     test('function call', () async {
@@ -411,15 +410,14 @@ void main() {
 
     group('Error handling', () {
       test('FunctionException contains all error details', () async {
-        try {
-          await functionsCustomHttpClient.invoke('error-function');
-          fail('should throw');
-        } on FunctionException catch (e) {
-          expect(e.status, 420);
-          expect(e.details, isNotNull);
-          expect(e.reasonPhrase, isNotNull);
-          expect(e.toString(), contains('420'));
-        }
+        await expectLater(
+          () => functionsCustomHttpClient.invoke('error-function'),
+          throwsA(isA<FunctionException>()
+              .having((e) => e.status, 'status', 420)
+              .having((e) => e.details, 'details', isNotNull)
+              .having((e) => e.reasonPhrase, 'reasonPhrase', isNotNull)
+              .having((e) => e.toString(), 'toString()', contains('420'))),
+        );
       });
     });
 

packages/gotrue/test/client_test.dart

@@ -104,15 +104,11 @@ void main() {
     test(
       'signUp() with weak password throws AuthWeakPasswordException',
       () async {
-        try {
-          await client.signUp(email: newEmail, password: '123');
-          fail('signUp with weak password should throw exception');
-        } on AuthException catch (error) {
-          expect(error, isA<AuthWeakPasswordException>());
-          expect(error.code, ErrorCode.weakPassword.code);
-        } catch (error) {
-          fail('signUp threw ${error.runtimeType} instead of AuthException');
-        }
+        await expectLater(
+          () => client.signUp(email: newEmail, password: '123'),
+          throwsA(isA<AuthWeakPasswordException>()
+              .having((e) => e.code, 'code', ErrorCode.weakPassword.code)),
+        );
       },
     );
 
@@ -125,10 +121,10 @@ void main() {
       final urlWithoutAccessToken = Uri.parse(
         'http://my-callback-url.com/welcome#expires_in=$expiresIn&refresh_token=$refreshToken&token_type=$tokenType&provider_token=$providerToken',
       );
-      try {
-        await client.getSessionFromUrl(urlWithoutAccessToken);
-        fail('getSessionFromUrl did not throw exception');
-      } catch (_) {}
+      await expectLater(
+        () => client.getSessionFromUrl(urlWithoutAccessToken),
+        throwsA(anything),
+      );
     });
 
     test('Parsing an error URL should throw', () async {
@@ -138,18 +134,13 @@ void main() {
       final urlWithoutAccessToken = Uri.parse(
         'http://my-callback-url.com/#error=unauthorized_client&error_code=401&error_description=${Uri.encodeComponent(errorMessage)}',
       );
-      try {
-        await client.getSessionFromUrl(urlWithoutAccessToken);
-        fail('getSessionFromUrl did not throw exception');
-      } on AuthException catch (error) {
-        expect(error.message, errorMessage);
-        expect(error.statusCode, '401');
-        expect(error.code, 'unauthorized_client');
-      } catch (error) {
-        fail(
-          'getSessionFromUrl threw ${error.runtimeType} instead of AuthException',
-        );
-      }
+      await expectLater(
+        () => client.getSessionFromUrl(urlWithoutAccessToken),
+        throwsA(isA<AuthException>()
+            .having((e) => e.message, 'message', errorMessage)
+            .having((e) => e.statusCode, 'statusCode', '401')
+            .having((e) => e.code, 'code', 'unauthorized_client')),
+      );
     });
 
     test('Subscribe a listener', () async {
@@ -442,12 +433,11 @@ void main() {
 
     test('Update user with the same password throws AuthException', () async {
       await client.signInWithPassword(email: email1, password: password);
-      try {
-        await client.updateUser(UserAttributes(password: password));
-        fail('updateUser did not throw');
-      } on AuthException catch (error) {
-        expect(error.code, ErrorCode.samePassword.code);
-      }
+      await expectLater(
+        () => client.updateUser(UserAttributes(password: password)),
+        throwsA(isA<AuthException>()
+            .having((e) => e.code, 'code', ErrorCode.samePassword.code)),
+      );
     });
 
     test('signOut', () async {
@@ -473,15 +463,14 @@ void main() {
     });
 
     test('signIn() with the wrong password', () async {
-      try {
-        await client.signInWithPassword(
+      await expectLater(
+        () => client.signInWithPassword(
           email: email1,
           password: 'wrong_$password',
-        );
-        fail('signInWithPassword did not throw');
-      } on AuthException catch (error) {
-        expect(error.message, isNotEmpty);
-      }
+        ),
+        throwsA(isA<AuthException>()
+            .having((e) => e.message, 'message', isNotNull)),
+      );
     });
 
     group('The auth client can signin with third-party oAuth providers', () {
@@ -686,16 +675,11 @@ void main() {
       final urlWithoutAccessToken = Uri.parse(
         'http://my-callback-url.com/#error=unauthorized_client&error_code=401&error_description=${Uri.encodeComponent(errorMessage)}',
       );
-      try {
-        await client.getSessionFromUrl(urlWithoutAccessToken);
-        fail('getSessionFromUrl did not throw exception');
-      } on AuthException catch (error) {
-        expect(error.message, errorMessage);
-      } catch (error) {
-        fail(
-          'getSessionFromUrl threw ${error.runtimeType} instead of AuthException',
-        );
-      }
+      await expectLater(
+        () => client.getSessionFromUrl(urlWithoutAccessToken),
+        throwsA(isA<AuthException>()
+            .having((e) => e.message, 'message', errorMessage)),
+      );
     });
 
     test(

packages/gotrue/test/fetch_test.dart

@@ -72,12 +72,10 @@ void main() {
 
 Future<void> _testFetchRequest(Client client) async {
   final GotrueFetch fetch = GotrueFetch(client);
-  try {
-    await fetch.request(_mockUrl, RequestMethodType.get);
-  } on AuthException catch (error) {
-    expect(error.code, 'weak_password');
-    expect(error.message, 'error_message');
-  } catch (error) {
-    fail('Should have thrown AuthException');
-  }
+  await expectLater(
+    () => fetch.request(_mockUrl, RequestMethodType.get),
+    throwsA(isA<AuthException>()
+        .having((e) => e.code, 'code', 'weak_password')
+        .having((e) => e.message, 'message', 'error_message')),
+  );
 }