github-issue-tower-defence-management 2.19.1 → 2.19.2

package/src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts

@@ -1,192 +0,0 @@
-import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { SessionSubAgentActivityRepository } from '../../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
-import { OwnerCallStatusProvider } from '../../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
-import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
-import {
-  NotifySilentLiveSessionsUseCase,
-  HubTaskStatusResolver,
-  DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-  DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
-  DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
-  DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
-  DEFAULT_NOTIFICATION_STAGGER_SECONDS,
-  DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
-  DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
-} from '../../../domain/usecases/NotifySilentLiveSessionsUseCase';
-import { DefaultSilentSessionMessageComposer } from '../../../domain/usecases/DefaultSilentSessionMessageComposer';
-import { LocalProcessLiveSessionProcessSnapshotProvider } from '../../repositories/LocalProcessLiveSessionProcessSnapshotProvider';
-import { ProcFsProcessEnvironReader } from '../../repositories/ProcFsProcessEnvironReader';
-import { FileSystemInteractiveLiveSessionTranscriptResolver } from '../../repositories/FileSystemInteractiveLiveSessionTranscriptResolver';
-import { FileSystemSessionOutputActivityRepository } from '../../repositories/FileSystemSessionOutputActivityRepository';
-import {
-  DEFAULT_SUBMIT_PUSH_OUT_ATTEMPT_LIMIT,
-  DEFAULT_SUBMIT_PUSH_OUT_WAIT_MILLISECONDS,
-  TmuxSilentSessionNotificationRepository,
-} from '../../repositories/TmuxSilentSessionNotificationRepository';
-import { TranscriptRefusalTailStatusProvider } from '../../repositories/TranscriptRefusalTailStatusProvider';
-import { ProcessListSessionSubAgentActivityRepository } from '../../repositories/ProcessListSessionSubAgentActivityRepository';
-import { TranscriptSessionSubAgentActivityRepository } from '../../repositories/TranscriptSessionSubAgentActivityRepository';
-import { FileSystemSubAgentTranscriptDirectoryResolver } from '../../repositories/FileSystemSubAgentTranscriptDirectoryResolver';
-import { FileSystemSubAgentLivenessResolver } from '../../repositories/FileSystemSubAgentLivenessResolver';
-import { NodeSubAgentProcessLister } from '../../repositories/NodeSubAgentProcessLister';
-import { FileSystemSubAgentSilentSecondsResolver } from '../../repositories/FileSystemSubAgentSilentSecondsResolver';
-import {
-  ConfigurableSilentSessionMessageComposer,
-  SilentSessionMessageTemplates,
-} from '../../repositories/ConfigurableSilentSessionMessageComposer';
-import { RealSleeper } from '../../repositories/RealSleeper';
-import { FileSystemSilentSessionCandidateStateRepository } from '../../repositories/FileSystemSilentSessionCandidateStateRepository';
-import { FileSystemSilentSessionHubTaskStatusCacheRepository } from '../../repositories/FileSystemSilentSessionHubTaskStatusCacheRepository';
-
-export type NotifySilentTmuxSessionsParams = {
-  enabled: boolean;
-  localCommandRunner: LocalCommandRunner;
-  processEnvironReader?: ProcessEnvironReader;
-  ownerCallStatusProvider: OwnerCallStatusProvider;
-  subAgentOutputRootDirectory: string | null;
-  subAgentProcessMatchPattern: string | null;
-  subAgentTranscriptRootDirectory: string | null;
-  subAgentRuntimeRootDirectory: string | null;
-  mainSilentThresholdSeconds: number;
-  unansweredOwnerCallGraceSeconds: number;
-  subAgentSilentThresholdSeconds: number;
-  subAgentRunningThresholdSeconds: number;
-  staggerSeconds: number;
-  candidateDebounceRecencyWindowSeconds: number;
-  candidateDebounceStateFilePath: string | null;
-  activeHubTaskStatus: string | null;
-  hubTaskStatusResolver: HubTaskStatusResolver | null;
-  hubTaskStatusCacheStateFilePath: string | null;
-  hubTaskStatusCacheTtlSeconds: number;
-  messageTemplates: SilentSessionMessageTemplates;
-  submitPushOutWaitMilliseconds?: number;
-  now: Date;
-};
-
-const createSubAgentActivityRepository = (
-  subAgentTranscriptRootDirectory: string | null,
-  subAgentRuntimeRootDirectory: string | null,
-  subAgentProcessMatchPattern: string | null,
-  subAgentOutputRootDirectory: string | null,
-  localCommandRunner: LocalCommandRunner,
-  now: Date,
-): SessionSubAgentActivityRepository => {
-  if (subAgentTranscriptRootDirectory !== null) {
-    return new TranscriptSessionSubAgentActivityRepository(
-      new FileSystemSubAgentTranscriptDirectoryResolver(
-        subAgentTranscriptRootDirectory,
-      ),
-      new NodeSubAgentProcessLister(localCommandRunner),
-      now,
-      new FileSystemSubAgentLivenessResolver(subAgentRuntimeRootDirectory),
-      subAgentRuntimeRootDirectory,
-    );
-  }
-  return new ProcessListSessionSubAgentActivityRepository(
-    subAgentProcessMatchPattern,
-    new NodeSubAgentProcessLister(localCommandRunner),
-    new FileSystemSubAgentSilentSecondsResolver(
-      subAgentOutputRootDirectory,
-      now,
-    ),
-  );
-};
-
-export const notifySilentTmuxSessions = async (
-  params: NotifySilentTmuxSessionsParams,
-): Promise<void> => {
-  const {
-    enabled,
-    localCommandRunner,
-    processEnvironReader,
-    ownerCallStatusProvider,
-    subAgentOutputRootDirectory,
-    subAgentProcessMatchPattern,
-    subAgentTranscriptRootDirectory,
-    subAgentRuntimeRootDirectory,
-    mainSilentThresholdSeconds,
-    unansweredOwnerCallGraceSeconds,
-    subAgentSilentThresholdSeconds,
-    subAgentRunningThresholdSeconds,
-    staggerSeconds,
-    candidateDebounceRecencyWindowSeconds,
-    candidateDebounceStateFilePath,
-    activeHubTaskStatus,
-    hubTaskStatusResolver,
-    hubTaskStatusCacheStateFilePath,
-    hubTaskStatusCacheTtlSeconds,
-    messageTemplates,
-    submitPushOutWaitMilliseconds,
-    now,
-  } = params;
-  if (!enabled) {
-    console.log(
-      'Silent live session notification skipped: not enabled (set silentNotificationEnabled or TDPM_SILENT_NOTIFICATION_ENABLED=true to enable).',
-    );
-    return;
-  }
-  const messageComposer = new ConfigurableSilentSessionMessageComposer(
-    messageTemplates,
-    new DefaultSilentSessionMessageComposer(),
-  );
-  const useCase = new NotifySilentLiveSessionsUseCase(
-    new LocalProcessLiveSessionProcessSnapshotProvider(
-      localCommandRunner,
-      processEnvironReader ?? new ProcFsProcessEnvironReader(),
-    ),
-    new FileSystemInteractiveLiveSessionTranscriptResolver(),
-    new FileSystemSessionOutputActivityRepository(),
-    createSubAgentActivityRepository(
-      subAgentTranscriptRootDirectory,
-      subAgentRuntimeRootDirectory,
-      subAgentProcessMatchPattern,
-      subAgentOutputRootDirectory,
-      localCommandRunner,
-      now,
-    ),
-    ownerCallStatusProvider,
-    new TmuxSilentSessionNotificationRepository(
-      localCommandRunner,
-      new RealSleeper(),
-      DEFAULT_SUBMIT_PUSH_OUT_ATTEMPT_LIMIT,
-      submitPushOutWaitMilliseconds ??
-        DEFAULT_SUBMIT_PUSH_OUT_WAIT_MILLISECONDS,
-    ),
-    candidateDebounceStateFilePath !== null
-      ? new FileSystemSilentSessionCandidateStateRepository(
-          candidateDebounceStateFilePath,
-        )
-      : new FileSystemSilentSessionCandidateStateRepository(),
-    messageComposer,
-    new RealSleeper(),
-    hubTaskStatusResolver,
-    hubTaskStatusCacheStateFilePath !== null
-      ? new FileSystemSilentSessionHubTaskStatusCacheRepository(
-          hubTaskStatusCacheStateFilePath,
-        )
-      : new FileSystemSilentSessionHubTaskStatusCacheRepository(),
-    new TranscriptRefusalTailStatusProvider(),
-  );
-  await useCase.run({
-    mainSilentThresholdSeconds,
-    unansweredOwnerCallGraceSeconds,
-    subAgentSilentThresholdSeconds,
-    subAgentRunningThresholdSeconds,
-    staggerSeconds,
-    candidateDebounceRecencyWindowSeconds,
-    activeHubTaskStatus,
-    hubTaskStatusCacheTtlSeconds,
-    now,
-  });
-};
-
-export const DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS = {
-  mainSilentThresholdSeconds: DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
-  unansweredOwnerCallGraceSeconds: DEFAULT_UNANSWERED_OWNER_CALL_GRACE_SECONDS,
-  subAgentSilentThresholdSeconds: DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
-  subAgentRunningThresholdSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
-  staggerSeconds: DEFAULT_NOTIFICATION_STAGGER_SECONDS,
-  candidateDebounceRecencyWindowSeconds:
-    DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
-  hubTaskStatusCacheTtlSeconds: DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
-} as const;

package/src/adapter/entry-points/handlers/ownerCallFileCleaner.test.ts

@@ -1,111 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { Issue } from '../../../domain/entities/Issue';
-import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
-import { cleanClosedIssueOwnerCallFiles } from './ownerCallFileCleaner';
-import { ownerCallFileAppend, ownerCallFilePath } from './ownerCallFileStore';
-
-const makeIssue = (overrides: Partial<Issue> = {}): Issue => ({
-  nameWithOwner: 'demo/repo',
-  number: 1,
-  title: 'Issue 1',
-  state: 'OPEN',
-  status: 'In Tmux by human',
-  story: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  estimationMinutes: null,
-  dependedIssueUrls: [],
-  completionDate50PercentConfidence: null,
-  url: 'https://github.com/demo/repo/issues/1',
-  assignees: ['owner-login'],
-  labels: [],
-  org: 'demo',
-  repo: 'repo',
-  body: '',
-  itemId: 'item-1',
-  isPr: false,
-  isInProgress: false,
-  isClosed: false,
-  createdAt: new Date('2026-08-01T00:00:00.000Z'),
-  author: '',
-  closingIssueReferenceUrls: [],
-  agent: null,
-  stateReason: null,
-  ...overrides,
-});
-
-describe('cleanClosedIssueOwnerCallFiles', () => {
-  let dataDir = '';
-
-  beforeEach(() => {
-    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-cleaner-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(dataDir, { recursive: true, force: true });
-  });
-
-  const appendCallFor = (issue: Issue): string => {
-    const sessionName = toTmuxSessionName(issue.url);
-    ownerCallFileAppend({
-      dataDir,
-      projectCode: 'umino',
-      ownerCall: {
-        sessionName,
-        calledAt: '2026-08-14T04:22:28Z',
-        body: 'an unanswered call\n',
-      },
-    });
-    return ownerCallFilePath(dataDir, 'umino', sessionName);
-  };
-
-  it('deletes the owner call file of a session whose issue is closed', () => {
-    const closedIssue = makeIssue({
-      url: 'https://github.com/demo/repo/issues/7',
-      state: 'CLOSED',
-      isClosed: true,
-    });
-    const filePath = appendCallFor(closedIssue);
-
-    cleanClosedIssueOwnerCallFiles({
-      inTmuxDataOutputDir: dataDir,
-      pjcode: 'umino',
-      issues: [closedIssue],
-    });
-
-    expect(fs.existsSync(filePath)).toBe(false);
-  });
-
-  it('keeps the owner call file of a session whose issue is still open', () => {
-    const openIssue = makeIssue();
-    const filePath = appendCallFor(openIssue);
-
-    cleanClosedIssueOwnerCallFiles({
-      inTmuxDataOutputDir: dataDir,
-      pjcode: 'umino',
-      issues: [openIssue],
-    });
-
-    expect(fs.existsSync(filePath)).toBe(true);
-  });
-
-  it('does nothing when the data directory or the project code is not configured', () => {
-    const closedIssue = makeIssue({ isClosed: true, state: 'CLOSED' });
-    const filePath = appendCallFor(closedIssue);
-
-    cleanClosedIssueOwnerCallFiles({
-      inTmuxDataOutputDir: null,
-      pjcode: 'umino',
-      issues: [closedIssue],
-    });
-    cleanClosedIssueOwnerCallFiles({
-      inTmuxDataOutputDir: dataDir,
-      pjcode: null,
-      issues: [closedIssue],
-    });
-
-    expect(fs.existsSync(filePath)).toBe(true);
-  });
-});

package/src/adapter/entry-points/handlers/ownerCallFileCleaner.ts

@@ -1,25 +0,0 @@
-import { Issue } from '../../../domain/entities/Issue';
-import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
-import { ownerCallFileDelete } from './ownerCallFileStore';
-
-export type CleanClosedIssueOwnerCallFilesParams = {
-  inTmuxDataOutputDir: string | null | undefined;
-  pjcode: string | null | undefined;
-  issues: Issue[];
-};
-
-export const cleanClosedIssueOwnerCallFiles = (
-  params: CleanClosedIssueOwnerCallFilesParams,
-): void => {
-  const { inTmuxDataOutputDir, pjcode, issues } = params;
-  if (!inTmuxDataOutputDir || !pjcode) {
-    return;
-  }
-  for (const issue of issues.filter((candidate) => candidate.isClosed)) {
-    ownerCallFileDelete({
-      dataDir: inTmuxDataOutputDir,
-      projectCode: pjcode,
-      sessionName: toTmuxSessionName(issue.url),
-    });
-  }
-};

package/src/adapter/entry-points/handlers/ownerCallFileStore.test.ts

@@ -1,286 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { parseAllDocuments } from 'yaml';
-import {
-  ownerCallFileAppend,
-  ownerCallFileDelete,
-  ownerCallFileDeleteInEveryProject,
-  ownerCallFilePath,
-  ownerCallProjectCodeInInTmuxByHumanData,
-} from './ownerCallFileStore';
-import { ownerCallFileRelativePath } from '../../../domain/usecases/intmux/OwnerCallFile';
-import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
-
-const toPlainValue = (document: { toJS: () => unknown }): unknown =>
-  document.toJS();
-
-describe('ownerCallFileStore', () => {
-  let dataDir = '';
-
-  beforeEach(() => {
-    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-store-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(dataDir, { recursive: true, force: true });
-  });
-
-  const sessionName = 'https_//github_com/OWNER/REPO/issues/1';
-
-  it('creates the file and its project directory on the first append', () => {
-    ownerCallFileAppend({
-      dataDir,
-      projectCode: 'umino',
-      ownerCall: {
-        sessionName,
-        calledAt: '2026-08-14T04:22:28Z',
-        body: 'the only call\n',
-      },
-    });
-
-    const filePath = path.join(
-      dataDir,
-      ownerCallFileRelativePath('umino', sessionName),
-    );
-    expect(fs.existsSync(filePath)).toBe(true);
-    const documents = parseAllDocuments(fs.readFileSync(filePath, 'utf-8'));
-    expect(documents).toHaveLength(1);
-    expect(documents[0].toJS()).toEqual({
-      sessionName,
-      calledAt: '2026-08-14T04:22:28Z',
-      body: 'the only call\n',
-    });
-  });
-
-  it('appends a second document after the first one, oldest first', () => {
-    ownerCallFileAppend({
-      dataDir,
-      projectCode: 'umino',
-      ownerCall: {
-        sessionName,
-        calledAt: '2026-08-14T04:22:28Z',
-        body: 'the older call\n',
-      },
-    });
-    ownerCallFileAppend({
-      dataDir,
-      projectCode: 'umino',
-      ownerCall: {
-        sessionName,
-        calledAt: '2026-08-14T05:00:00Z',
-        body: 'the newer call\n',
-      },
-    });
-
-    const documents = parseAllDocuments(
-      fs.readFileSync(
-        ownerCallFilePath(dataDir, 'umino', sessionName),
-        'utf-8',
-      ),
-    );
-    expect(documents.map(toPlainValue)).toEqual([
-      {
-        sessionName,
-        calledAt: '2026-08-14T04:22:28Z',
-        body: 'the older call\n',
-      },
-      {
-        sessionName,
-        calledAt: '2026-08-14T05:00:00Z',
-        body: 'the newer call\n',
-      },
-    ]);
-  });
-
-  it('writes the file of a session that belongs to no project under NA', () => {
-    ownerCallFileAppend({
-      dataDir,
-      projectCode: null,
-      ownerCall: {
-        sessionName: 'secretary',
-        calledAt: '2026-08-14T04:22:28Z',
-        body: 'a call from a long running session\n',
-      },
-    });
-
-    expect(
-      fs.existsSync(
-        path.join(dataDir, ownerCallFileRelativePath(null, 'secretary')),
-      ),
-    ).toBe(true);
-  });
-
-  it('removes the file of the named project', () => {
-    ownerCallFileAppend({
-      dataDir,
-      projectCode: 'umino',
-      ownerCall: {
-        sessionName,
-        calledAt: '2026-08-14T04:22:28Z',
-        body: 'the only call\n',
-      },
-    });
-
-    ownerCallFileDelete({ dataDir, projectCode: 'umino', sessionName });
-
-    expect(
-      fs.existsSync(ownerCallFilePath(dataDir, 'umino', sessionName)),
-    ).toBe(false);
-  });
-
-  it('succeeds when the file to delete is already absent', () => {
-    expect(() =>
-      ownerCallFileDelete({ dataDir, projectCode: 'umino', sessionName }),
-    ).not.toThrow();
-  });
-
-  it('removes the file of a session whose project code the caller does not know', () => {
-    ownerCallFileAppend({
-      dataDir,
-      projectCode: 'umino',
-      ownerCall: {
-        sessionName,
-        calledAt: '2026-08-14T04:22:28Z',
-        body: 'the only call\n',
-      },
-    });
-    ownerCallFileAppend({
-      dataDir,
-      projectCode: 'other',
-      ownerCall: {
-        sessionName: 'other_session',
-        calledAt: '2026-08-14T04:22:28Z',
-        body: 'a call of another session\n',
-      },
-    });
-
-    ownerCallFileDeleteInEveryProject({ dataDir, sessionName });
-
-    expect(
-      fs.existsSync(ownerCallFilePath(dataDir, 'umino', sessionName)),
-    ).toBe(false);
-    expect(
-      fs.existsSync(ownerCallFilePath(dataDir, 'other', 'other_session')),
-    ).toBe(true);
-  });
-
-  it('succeeds when no owner call directory exists at all', () => {
-    expect(() =>
-      ownerCallFileDeleteInEveryProject({ dataDir, sessionName }),
-    ).not.toThrow();
-  });
-});
-
-describe('ownerCallProjectCodeInInTmuxByHumanData', () => {
-  const issueUrl = 'https://github.com/OWNER/REPO/issues/1';
-  const otherIssueUrl = 'https://github.com/OWNER/REPO/issues/2';
-  let dataDir = '';
-
-  beforeEach(() => {
-    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-project-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(dataDir, { recursive: true, force: true });
-  });
-
-  const writeProjectData = (projectCode: string, urls: string[]): void => {
-    fs.writeFileSync(
-      path.join(dataDir, `${projectCode}.v4.json`),
-      `${JSON.stringify({
-        version: 4,
-        overviewUrl: 'https://github.com/orgs/OWNER/projects/1',
-        tdpmConsoleUrl: 'http://localhost/projects/code',
-        newIssueUrl: 'https://github.com/OWNER/REPO/issues/new',
-        groups: [
-          {
-            story: 'a story',
-            sessions: urls.map((url) => ({ name: url, description: 'title' })),
-          },
-        ],
-      })}\n`,
-    );
-  };
-
-  it('gives the code of the project whose session list holds the session', () => {
-    writeProjectData('other', [otherIssueUrl]);
-    writeProjectData('umino', [issueUrl]);
-
-    expect(
-      ownerCallProjectCodeInInTmuxByHumanData(
-        dataDir,
-        toTmuxSessionName(issueUrl),
-      ),
-    ).toBe('umino');
-  });
-
-  it('gives null when no project lists the session', () => {
-    writeProjectData('umino', [otherIssueUrl]);
-
-    expect(
-      ownerCallProjectCodeInInTmuxByHumanData(
-        dataDir,
-        toTmuxSessionName(issueUrl),
-      ),
-    ).toBeNull();
-  });
-
-  it('gives null when the directory holds no in-tmux-by-human data at all', () => {
-    expect(
-      ownerCallProjectCodeInInTmuxByHumanData(
-        dataDir,
-        toTmuxSessionName(issueUrl),
-      ),
-    ).toBeNull();
-  });
-
-  it('gives null when the directory itself is absent', () => {
-    expect(
-      ownerCallProjectCodeInInTmuxByHumanData(
-        path.join(dataDir, 'absent'),
-        toTmuxSessionName(issueUrl),
-      ),
-    ).toBeNull();
-  });
-
-  it('reads neither the project index nor the older versions of the project data', () => {
-    fs.writeFileSync(
-      path.join(dataDir, 'index.v4.json'),
-      `${JSON.stringify({
-        version: 4,
-        projects: [{ name: 'umino', path: '/in-tmux-by-human/umino.v4.json' }],
-      })}\n`,
-    );
-    fs.writeFileSync(
-      path.join(dataDir, 'umino.v3.json'),
-      `${JSON.stringify({
-        version: 3,
-        groups: [{ story: 'a story', urls: [{ url: issueUrl, title: 't' }] }],
-      })}\n`,
-    );
-
-    expect(
-      ownerCallProjectCodeInInTmuxByHumanData(
-        dataDir,
-        toTmuxSessionName(issueUrl),
-      ),
-    ).toBeNull();
-  });
-
-  it('skips a project data file that cannot be read as the expected shape', () => {
-    fs.writeFileSync(path.join(dataDir, 'broken.v4.json'), 'not json at all\n');
-    fs.writeFileSync(
-      path.join(dataDir, 'shapeless.v4.json'),
-      `${JSON.stringify({ version: 4, groups: 'not a list' })}\n`,
-    );
-    writeProjectData('umino', [issueUrl]);
-
-    expect(
-      ownerCallProjectCodeInInTmuxByHumanData(
-        dataDir,
-        toTmuxSessionName(issueUrl),
-      ),
-    ).toBe('umino');
-  });
-});