halkyon/packages/halkyon_base_server/test/integration/support/fixtures.dart

import 'package:halkyon_base_server/base.dart';
import 'package:serverpod/serverpod.dart';
import 'package:serverpod_auth_idp_server/core.dart';

import '../test_tools/serverpod_test_tools.dart';

/// The app the tests' host is.
const testAppName = 'Halkyon Test';

/// The id of the app the tests' host serves.
const testApp = 'test';

/// Where the tests' host says its project publishes its source.
const testUpstreamSourceCodeUrl = 'https://code.example.org/halkyon_test';

/// The oldest app build the tests' host works with.
const testMinimumAppBuild = 7;

/// Sets the module up on the pod [sessionBuilder]'s sessions run on, as a
/// host does before its pod starts, with [deletePersonData] as its
/// deletions and [profilePageNote] at the foot of profile pages, and
/// authentication exactly as hosts run it
/// (`auth_config.dart`). Not on `Serverpod.instance`: that is the pod made
/// last, and a test file with several `withServerpod` groups has a pod each.
void useBase(
  TestSessionBuilder sessionBuilder, {
  List<PersonDataDeletion> deletePersonData = const [],
  ProfilePageNote? profilePageNote,
  AccountsMode accounts = const HoldsRegister(),
}) {
  final pod = sessionBuilder.build().serverpod;
  HalkyonBase.configure(
    pod,
    HalkyonBase(
      app: testApp,
      appName: testAppName,
      upstreamSourceCodeUrl: testUpstreamSourceCodeUrl,
      minimumAppBuild: testMinimumAppBuild,
      deletePersonData: deletePersonData,
      profilePageNote: profilePageNote,
      accounts: accounts,
    ),
  );
  AuthServices.set(
    tokenManagerBuilders: tokenManagerBuilders,
    identityProviderBuilders: identityProviderBuilders(pod),
  );
  // No password sign-in unless a test gives it keys, whatever the test
  // run's passwords hold.
  usePasswordKeys(pod, null);
}

/// Signs [person] in on a new device and returns the new session's id.
Future<UuidValue> signInNewDevice(
  Session session,
  UuidValue person, {
  Set<Scope> scopes = const {},
  String method = 'test',
}) async {
  Future<Set<UuidValue>> sessionIds() async => {
    for (final serverSideSession in await ServerSideSession.db.find(
      session,
      where: (t) => t.authUserId.equals(person),
    ))
      serverSideSession.id!,
  };

  final before = await sessionIds();
  await AuthServices.instance.tokenManager.createToken(
    session,
    authUserId: person,
    method: method,
    scopes: scopes,
  );
  return (await sessionIds()).difference(before).single;
}

/// A person as an app's first launch creates them: anonymous.
Future<UuidValue> newAnonymousPerson(
  Session session, {
  DateTime? createdAt,
}) async {
  final person = (await AuthServices.instance.authUsers.create(session)).id;
  await AnonymousAccount.db.insertRow(
    session,
    AnonymousAccount(authUserId: person, createdAt: createdAt),
  );
  return person;
}