git.giacomolli.uk - onechat/blob - voice_transcriber_test.go

   1 package main
   2
   3 import (
   4         "bytes"
   5         "context"
   6         "os"
   7         "path/filepath"
   8         "strings"
   9         "testing"
  10         "time"
  11
  12         "github.com/stretchr/testify/require"
  13 )
  14
  15 func TestVoiceStoresPrivateAudioAndUsesPlainTextWithInternalTimestamps(t *testing.T) {
  16         store, transcriber := voiceTestInput(t, `
  17 output=
  18 context=
  19 while [ "$#" -gt 0 ]; do
  20  case "$1" in
  21  --no-timestamps) exit 2 ;;
  22  --max-context) shift; context=$1 ;;
  23  --output-file) shift; output=$1 ;;
  24  esac
  25  shift
  26 done
  27 [ "$context" = 0 ]
  28 printf '  A made-up voice transcript.\n' > "$output.txt"
  29 printf 'private speech in process output'
  30 printf 'private speech in process errors' >&2
  31 `)
  32         data := []byte("made-up audio")
  33         text := transcriber.Text(t.Context(), store, data)
  34         require.Contains(t, text, "[voice ")
  35         require.True(t, strings.HasSuffix(text, "]\nA made-up voice transcript."))
  36         require.Equal(t, text, transcriber.Text(t.Context(), store, data))
  37
  38         files, err := os.ReadDir(store.dir)
  39         require.NoError(t, err)
  40         require.Len(t, files, 1)
  41
  42         saved, err := os.ReadFile(filepath.Join(store.dir, files[0].Name()))
  43         require.NoError(t, err)
  44         require.Equal(t, data, saved)
  45
  46         info, err := os.Stat(filepath.Join(store.dir, files[0].Name()))
  47         require.NoError(t, err)
  48         require.Equal(t, os.FileMode(0o600), info.Mode().Perm())
  49
  50         info, err = os.Stat(store.dir)
  51         require.NoError(t, err)
  52         require.Equal(t, os.FileMode(0o700), info.Mode().Perm())
  53 }
  54
  55 func TestVoiceFailuresKeepStoredAudioAndSafeMarkers(t *testing.T) {
  56         testCases := []struct {
  57                 name   string
  58                 script string
  59         }{
  60                 {name: "failed process does not expose its errors", script: "echo secret-speech >&2; exit 1"},
  61                 {name: "missing transcript gets a marker", script: "exit 0"},
  62                 {name: "empty transcript gets a marker", script: "while [ \"$1\" != --output-file ]; do shift; done; shift; touch \"$1.txt\""},
  63         }
  64         for _, tc := range testCases {
  65                 t.Run(tc.name, func(t *testing.T) {
  66                         store, transcriber := voiceTestInput(t, tc.script)
  67                         text := transcriber.Text(t.Context(), store, []byte("made-up audio"))
  68                         require.Contains(t, text, "[voice ")
  69                         require.Contains(t, text, "(voice not transcribed: local transcription failed)")
  70                         require.NotContains(t, text, "secret-speech")
  71
  72                         files, err := os.ReadDir(store.dir)
  73                         require.NoError(t, err)
  74                         require.Len(t, files, 1)
  75                 })
  76         }
  77 }
  78
  79 func TestVoiceCancellationAndCallerDeadlineStopTheProcess(t *testing.T) {
  80         store, transcriber := voiceTestInput(t, "exec sleep 60")
  81         ctx, cancel := context.WithTimeout(t.Context(), 20*time.Millisecond)
  82         defer cancel()
  83
  84         text := transcriber.Text(ctx, store, []byte("made-up audio"))
  85         require.Contains(t, text, "context deadline exceeded")
  86
  87         ctx, cancel = context.WithCancel(t.Context())
  88         cancel()
  89
  90         text = transcriber.Text(ctx, store, []byte("made-up audio"))
  91         require.Contains(t, text, "context canceled")
  92 }
  93
  94 func TestVoiceUnavailableAndStorageFailuresDoNotStopIntake(t *testing.T) {
  95         store, transcriber := voiceTestInput(t, "exit 0")
  96         transcriber.config.Model = filepath.Join(t.TempDir(), "missing")
  97         text := transcriber.Text(t.Context(), store, []byte("made-up audio"))
  98         require.Contains(t, text, "[voice ")
  99         require.Contains(t, text, "transcriber or model is not available")
 100         require.Equal(t, "(voice not stored)", transcriber.Text(t.Context(), store, nil))
 101         require.Equal(t, "(voice not stored)", transcriber.Text(t.Context(), store, bytes.Repeat([]byte{0}, voiceMaxBytes+1)))
 102
 103         blocked := filepath.Join(t.TempDir(), "blocked")
 104         require.NoError(t, os.WriteFile(blocked, nil, 0o600))
 105
 106         store.dir = filepath.Join(blocked, "child")
 107         require.Equal(t, "(voice not stored)", transcriber.Text(t.Context(), store, []byte("audio")))
 108 }
 109
 110 func TestVoiceBackupsKeepAudioButNotTemporaryTranscripts(t *testing.T) {
 111         root := t.TempDir()
 112         store := &VoiceStore{dir: filepath.Join(root, voiceDirName)}
 113         name, err := store.Save([]byte("made-up backed-up audio"))
 114         require.NoError(t, err)
 115
 116         temp := filepath.Join(store.dir, ".transcript-in-progress")
 117         require.NoError(t, os.Mkdir(temp, 0o700))
 118         require.NoError(t, os.WriteFile(filepath.Join(temp, "text.txt"), []byte("private temporary text"), 0o600))
 119
 120         target := t.TempDir()
 121         require.NoError(t, backupCopy(t.Context(), root, target, filepath.Join(t.TempDir(), "backup.tar.gz")))
 122         require.FileExists(t, filepath.Join(target, voiceDirName, name))
 123         require.NoDirExists(t, filepath.Join(target, voiceDirName, ".transcript-in-progress"))
 124
 125         archive := filepath.Join(t.TempDir(), "voice.tar.gz")
 126         _, err = backupArchive(t.Context(), target, archive)
 127         require.NoError(t, err)
 128
 129         restored := t.TempDir()
 130         require.NoError(t, backupExtract(t.Context(), archive, restored))
 131
 132         audio, err := os.ReadFile(filepath.Join(restored, voiceDirName, name))
 133         require.NoError(t, err)
 134         require.Equal(t, []byte("made-up backed-up audio"), audio)
 135
 136         info, err := os.Stat(filepath.Join(restored, voiceDirName, name))
 137         require.NoError(t, err)
 138         require.Equal(t, os.FileMode(0o600), info.Mode().Perm())
 139 }
 140
 141 func TestVoiceConfigReadsExplicitLocalPaths(t *testing.T) {
 142         dir := t.TempDir()
 143         configWriteTest(t, dir, `{"voice":{"transcriber":"local-whisper","model":"model.bin"}}`)
 144
 145         config, err := loadConfig(dir)
 146         require.NoError(t, err)
 147         require.Equal(t, VoiceConfig{Transcriber: "local-whisper", Model: "model.bin"}, config.Voice)
 148 }
 149
 150 func TestVoiceLookupHonorsExplicitThenNixThenPath(t *testing.T) {
 151         _, transcriber := voiceTestInput(t, "exit 0")
 152         valid := transcriber.config
 153         t.Setenv("PATH", filepath.Dir(valid.Transcriber))
 154
 155         testCases := []struct {
 156                 name      string
 157                 config    VoiceConfig
 158                 program   string
 159                 model     string
 160                 available bool
 161         }{
 162                 {
 163                         name:      "explicit paths override invalid built paths",
 164                         config:    valid,
 165                         program:   "missing",
 166                         model:     "missing",
 167                         available: true,
 168                 },
 169                 {
 170                         name:      "built paths supply absent settings",
 171                         program:   valid.Transcriber,
 172                         model:     valid.Model,
 173                         available: true,
 174                 },
 175                 {
 176                         name:      "PATH supplies absent executable",
 177                         config:    VoiceConfig{Model: valid.Model},
 178                         available: true,
 179                 },
 180                 {
 181                         name:    "invalid explicit executable does not fall back",
 182                         config:  VoiceConfig{Transcriber: "missing", Model: valid.Model},
 183                         program: valid.Transcriber,
 184                 },
 185                 {
 186                         name:    "invalid explicit model does not fall back",
 187                         config:  VoiceConfig{Model: "missing"},
 188                         program: valid.Transcriber,
 189                         model:   valid.Model,
 190                 },
 191                 {
 192                         name:    "missing model leaves input unavailable",
 193                         program: valid.Transcriber,
 194                 },
 195         }
 196         for _, tc := range testCases {
 197                 t.Run(tc.name, func(t *testing.T) {
 198                         program, model, err := voiceLookup(tc.config, tc.program, tc.model)
 199                         if !tc.available {
 200                                 require.ErrorIs(t, err, errVoiceUnavailable)
 201
 202                                 return
 203                         }
 204
 205                         require.NoError(t, err)
 206                         require.Equal(t, valid.Transcriber, program)
 207                         require.Equal(t, valid.Model, model)
 208                 })
 209         }
 210 }