如何为包含Supabase静态依赖的Dart类编写单元测试？

是否需要Mock Supabase？ #

需要。单元测试的核心是隔离依赖，我们要测试的是SupabaseService的initialize方法是否正确触发了Supabase的初始化逻辑，并且传入了正确的参数，而不是真的去建立Supabase连接。直接调用真实的Supabase.initialize会让测试依赖外部服务，既不稳定也不符合单元测试的原则。

处理静态方法的Mock方案 #

Mocktail本身不支持直接Mock静态方法，所以我们需要给静态方法做一层实例化包装，通过抽象类隔离静态调用，这样就能用Mocktail轻松模拟行为了。

步骤1：创建抽象封装层 #

定义一个抽象类，把Supabase.initialize的静态调用封装成实例方法：

abstract class SupabaseInitializer {
  Future<void> initialize({required String url, required String anonKey});
}

然后实现这个抽象类，调用真实的Supabase静态方法：

@Injectable(as: SupabaseInitializer)
class RealSupabaseInitializer implements SupabaseInitializer {
  @override
  Future<void> initialize({required String url, required String anonKey}) async {
    await Supabase.initialize(url: url, anonKey: anonKey);
  }
}

步骤2：修改SupabaseService依赖 #

把原来直接依赖Supabase静态类的逻辑，改成依赖上面的抽象类SupabaseInitializer：

import 'package:injectable/injectable.dart';
import 'package:wefocus/core/services/env_service.dart';

// 导入你定义的抽象类
import 'supabase_initializer.dart';

@singleton
class SupabaseService {
  final EnvService _envService;
  final SupabaseInitializer _supabaseInitializer;

  // 注入抽象类而不是直接用静态方法
  SupabaseService(this._envService, this._supabaseInitializer);

  Future<void> initialize() async {
    await _supabaseInitializer.initialize(
      url: _envService.supabaseUrl,
      anonKey: _envService.supabaseAnonKey,
    );
  }
}

步骤3：编写Mocktail测试 #

现在可以用Mocktail创建SupabaseInitializer的Mock类，然后验证initialize方法是否被正确调用：

首先，创建Mock类：

import 'package:mocktail/mocktail.dart';
import 'supabase_initializer.dart';

class MockSupabaseInitializer extends Mock implements SupabaseInitializer {}

然后编写测试用例：

import 'package:test/test.dart';
import 'package:mocktail/mocktail.dart';
import 'package:wefocus/core/services/env_service.dart';
import 'package:wefocus/core/services/supabase_service.dart';

// 导入Mock类和抽象类
import 'supabase_initializer.dart';
import 'mock_supabase_initializer.dart';

class MockEnvService extends Mock implements EnvService {}

void main() {
  group('SupabaseService', () {
    late MockEnvService mockEnvService;
    late MockSupabaseInitializer mockSupabaseInitializer;
    late SupabaseService supabaseService;

    setUp(() {
      mockEnvService = MockEnvService();
      mockSupabaseInitializer = MockSupabaseInitializer();
      supabaseService = SupabaseService(mockEnvService, mockSupabaseInitializer);

      // 配置Mock的返回值
      const testUrl = 'test-supabase-url';
      const testAnonKey = 'test-anon-key';
      when(() => mockEnvService.supabaseUrl).thenReturn(testUrl);
      when(() => mockEnvService.supabaseAnonKey).thenReturn(testAnonKey);

      // 模拟initialize方法的行为
      when(() => mockSupabaseInitializer.initialize(
            url: testUrl,
            anonKey: testAnonKey,
          )).thenAnswer((_) async => Future.value());
    });

    test('initialize calls SupabaseInitializer with correct parameters', () async {
      // 执行测试方法
      await supabaseService.initialize();

      // 验证是否调用了正确的方法和参数
      verify(() => mockSupabaseInitializer.initialize(
            url: mockEnvService.supabaseUrl,
            anonKey: mockEnvService.supabaseAnonKey,
          )).called(1);
    });
  });
}

补充说明 #

• 这种封装方式不仅方便测试，还让代码更具扩展性，以后如果要替换Supabase的初始化逻辑，只需要实现新的SupabaseInitializer即可。
• 如果你的项目用了injectable，记得确保RealSupabaseInitializer被正确注册，这样依赖注入才能正常工作。

内容的提问来源于stack exchange，提问作者asimolmez