// SPDX-License-Identifier: EUPL-1.2

package ratelimit

import (
	"syscall"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestError_SQLiteErrorPaths_Bad(t *testing.T) {
	dbPath := testPath(t.TempDir(), "error.db")
	rl, err := NewWithSQLite(dbPath)
	require.NoError(t, err)

	// Close the underlying DB to trigger errors.
	rl.sqlite.close()

	t.Run("loadQuotas error", func(t *testing.T) {
		_, err := rl.sqlite.loadQuotas()
		assert.Error(t, err)
	})

	t.Run("saveQuotas error", func(t *testing.T) {
		err := rl.sqlite.saveQuotas(map[string]ModelQuota{"test": {}})
		assert.Error(t, err)
	})

	t.Run("saveState error", func(t *testing.T) {
		err := rl.sqlite.saveState(map[string]*UsageStats{"test": {}})
		assert.Error(t, err)
	})

	t.Run("loadState error", func(t *testing.T) {
		_, err := rl.sqlite.loadState()
		assert.Error(t, err)
	})
}

func TestError_SQLiteInitErrors_Bad(t *testing.T) {
	t.Run("WAL pragma failure", func(t *testing.T) {
		// This is hard to trigger without mocking sql.DB, but we can try an invalid connection string
		// modernc.org/sqlite doesn't support all DSN options that might cause PRAGMA to fail but connection to succeed.
	})
}

func TestError_PersistYAML_Good(t *testing.T) {
	t.Run("successful YAML persist and load", func(t *testing.T) {
		tmpDir := t.TempDir()
		path := testPath(tmpDir, "ratelimits.yaml")
		rl, _ := New()
		rl.filePath = path
		rl.Quotas["test"] = ModelQuota{MaxRPM: 1}
		rl.RecordUsage("test", 1, 1)

		require.NoError(t, rl.Persist())

		rl2, _ := New()
		rl2.filePath = path
		require.NoError(t, rl2.Load())
		assert.Equal(t, 1, rl2.Quotas["test"].MaxRPM)
		assert.Equal(t, 1, rl2.State["test"].DayCount)
	})
}

func TestError_SQLiteLoadViaLimiter_Bad(t *testing.T) {
	t.Run("Load returns error when SQLite DB is closed", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "load-err.db")
		rl, err := NewWithSQLite(dbPath)
		require.NoError(t, err)

		// Close the underlying DB to trigger errors on Load.
		rl.sqlite.close()

		err = rl.Load()
		assert.Error(t, err, "Load should fail with closed DB")
	})

	t.Run("Load returns error when loadState fails", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "load-state-err.db")
		rl, err := NewWithSQLite(dbPath)
		require.NoError(t, err)

		// Save some quotas so loadQuotas succeeds, then corrupt the state tables.
		require.NoError(t, rl.Persist())

		// Drop the daily table to cause loadState to fail.
		_, execErr := rl.sqlite.db.Exec("DROP TABLE daily")
		require.NoError(t, execErr)

		err = rl.Load()
		assert.Error(t, err, "Load should fail when loadState fails")
		rl.Close()
	})
}

func TestError_SQLitePersistViaLimiter_Bad(t *testing.T) {
	t.Run("Persist returns error when SQLite saveQuotas fails", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "persist-err.db")
		rl, err := NewWithSQLite(dbPath)
		require.NoError(t, err)

		// Drop the quotas table to cause saveQuotas to fail.
		_, execErr := rl.sqlite.db.Exec("DROP TABLE quotas")
		require.NoError(t, execErr)

		err = rl.Persist()
		assert.Error(t, err, "Persist should fail when saveQuotas fails")
		assert.Contains(t, err.Error(), "ratelimit.Persist")
		rl.Close()
	})

	t.Run("Persist returns error when SQLite saveState fails", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "persist-state-err.db")
		rl, err := NewWithSQLite(dbPath)
		require.NoError(t, err)

		rl.RecordUsage("test-model", 10, 10)

		// Drop a state table to cause saveState to fail.
		_, execErr := rl.sqlite.db.Exec("DROP TABLE requests")
		require.NoError(t, execErr)

		err = rl.Persist()
		assert.Error(t, err, "Persist should fail when saveState fails")
		assert.Contains(t, err.Error(), "ratelimit.Persist")
		rl.Close()
	})
}

func TestError_NewWithSQLite_Bad(t *testing.T) {
	t.Run("NewWithSQLite with invalid path", func(t *testing.T) {
		_, err := NewWithSQLite("/nonexistent/deep/nested/dir/test.db")
		assert.Error(t, err, "should fail with invalid path")
	})

	t.Run("NewWithSQLiteConfig with invalid path", func(t *testing.T) {
		_, err := NewWithSQLiteConfig("/nonexistent/deep/nested/dir/test.db", Config{
			Providers: []Provider{ProviderGemini},
		})
		assert.Error(t, err, "should fail with invalid path")
	})
}

func TestError_SQLiteSaveState_Bad(t *testing.T) {
	t.Run("saveState fails when tokens table is dropped", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "tokens-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		_, execErr := store.db.Exec("DROP TABLE tokens")
		require.NoError(t, execErr)

		state := map[string]*UsageStats{
			"model": {
				Tokens:   []TokenEntry{{Time: time.Now(), Count: 100}},
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		err = store.saveState(state)
		assert.Error(t, err, "saveState should fail when tokens table is missing")
	})

	t.Run("saveState fails when daily table is dropped", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "daily-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		_, execErr := store.db.Exec("DROP TABLE daily")
		require.NoError(t, execErr)

		state := map[string]*UsageStats{
			"model": {
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		err = store.saveState(state)
		assert.Error(t, err, "saveState should fail when daily table is missing")
	})

	t.Run("saveState fails on request insert with renamed column", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "req-insert-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Rename the ts column so INSERT INTO requests (model, ts) fails.
		_, execErr := store.db.Exec("ALTER TABLE requests RENAME COLUMN ts TO timestamp")
		require.NoError(t, execErr)

		state := map[string]*UsageStats{
			"model": {
				Requests: []time.Time{time.Now()},
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		err = store.saveState(state)
		assert.Error(t, err, "saveState should fail on request insert with renamed column")
	})

	t.Run("saveState fails on token insert with renamed column", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "tok-insert-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Rename the count column so INSERT INTO tokens (model, ts, count) fails.
		_, execErr := store.db.Exec("ALTER TABLE tokens RENAME COLUMN count TO amount")
		require.NoError(t, execErr)

		state := map[string]*UsageStats{
			"model": {
				Tokens:   []TokenEntry{{Time: time.Now(), Count: 100}},
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		err = store.saveState(state)
		assert.Error(t, err, "saveState should fail on token insert with renamed column")
	})

	t.Run("saveState fails on daily insert with renamed column", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "day-insert-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Rename day_count column so INSERT INTO daily fails.
		_, execErr := store.db.Exec("ALTER TABLE daily RENAME COLUMN day_count TO total")
		require.NoError(t, execErr)

		state := map[string]*UsageStats{
			"model": {
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		err = store.saveState(state)
		assert.Error(t, err, "saveState should fail on daily insert with renamed column")
	})
}

func TestError_SQLiteLoadState_Bad(t *testing.T) {
	t.Run("loadState fails when requests table is dropped", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "req-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		state := map[string]*UsageStats{
			"model": {
				Requests: []time.Time{time.Now()},
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		require.NoError(t, store.saveState(state))

		_, execErr := store.db.Exec("DROP TABLE requests")
		require.NoError(t, execErr)

		_, err = store.loadState()
		assert.Error(t, err, "loadState should fail when requests table is missing")
	})

	t.Run("loadState fails when tokens table is dropped", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "tok-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		state := map[string]*UsageStats{
			"model": {
				Tokens:   []TokenEntry{{Time: time.Now(), Count: 100}},
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		require.NoError(t, store.saveState(state))

		_, execErr := store.db.Exec("DROP TABLE tokens")
		require.NoError(t, execErr)

		_, err = store.loadState()
		assert.Error(t, err, "loadState should fail when tokens table is missing")
	})

	t.Run("loadState fails when daily table is dropped", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "daily-load-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		state := map[string]*UsageStats{
			"model": {
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		require.NoError(t, store.saveState(state))

		_, execErr := store.db.Exec("DROP TABLE daily")
		require.NoError(t, execErr)

		_, err = store.loadState()
		assert.Error(t, err, "loadState should fail when daily table is missing")
	})
}

func TestError_SQLiteSaveQuotasExec_Bad(t *testing.T) {
	t.Run("saveQuotas fails with renamed column at prepare", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "quota-exec-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Rename column so INSERT fails at prepare.
		_, execErr := store.db.Exec("ALTER TABLE quotas RENAME COLUMN max_rpm TO rpm")
		require.NoError(t, execErr)

		err = store.saveQuotas(map[string]ModelQuota{
			"test": {MaxRPM: 10, MaxTPM: 100, MaxRPD: 50},
		})
		assert.Error(t, err, "saveQuotas should fail with renamed column")
	})

	t.Run("saveQuotas fails at exec via trigger", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "quota-trigger.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Add trigger to abort INSERT.
		_, execErr := store.db.Exec(`CREATE TRIGGER fail_quota BEFORE INSERT ON quotas
			BEGIN SELECT RAISE(ABORT, 'forced quota insert failure'); END`)
		require.NoError(t, execErr)

		err = store.saveQuotas(map[string]ModelQuota{
			"test": {MaxRPM: 10, MaxTPM: 100, MaxRPD: 50},
		})
		assert.Error(t, err, "saveQuotas should fail when trigger fires")
		assert.Contains(t, err.Error(), "exec test")
	})
}

func TestError_SQLiteSaveStateExec_Bad(t *testing.T) {
	t.Run("request insert exec fails via trigger", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "trigger-req.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Add a trigger that aborts INSERT on requests.
		_, execErr := store.db.Exec(`CREATE TRIGGER fail_req_insert BEFORE INSERT ON requests
			BEGIN SELECT RAISE(ABORT, 'forced request insert failure'); END`)
		require.NoError(t, execErr)

		state := map[string]*UsageStats{
			"model": {
				Requests: []time.Time{time.Now()},
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		err = store.saveState(state)
		assert.Error(t, err, "saveState should fail when request insert trigger fires")
		assert.Contains(t, err.Error(), "insert request")
	})

	t.Run("token insert exec fails via trigger", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "trigger-tok.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Add a trigger that aborts INSERT on tokens.
		_, execErr := store.db.Exec(`CREATE TRIGGER fail_tok_insert BEFORE INSERT ON tokens
			BEGIN SELECT RAISE(ABORT, 'forced token insert failure'); END`)
		require.NoError(t, execErr)

		state := map[string]*UsageStats{
			"model": {
				Tokens:   []TokenEntry{{Time: time.Now(), Count: 100}},
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		err = store.saveState(state)
		assert.Error(t, err, "saveState should fail when token insert trigger fires")
		assert.Contains(t, err.Error(), "insert token")
	})

	t.Run("daily insert exec fails via trigger", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "trigger-day.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Add a trigger that aborts INSERT on daily.
		_, execErr := store.db.Exec(`CREATE TRIGGER fail_day_insert BEFORE INSERT ON daily
			BEGIN SELECT RAISE(ABORT, 'forced daily insert failure'); END`)
		require.NoError(t, execErr)

		state := map[string]*UsageStats{
			"model": {
				DayStart: time.Now(),
				DayCount: 1,
			},
		}
		err = store.saveState(state)
		assert.Error(t, err, "saveState should fail when daily insert trigger fires")
		assert.Contains(t, err.Error(), "insert daily")
	})
}

func TestError_SQLiteLoadQuotasScan_Bad(t *testing.T) {
	t.Run("loadQuotas fails with renamed column", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "quota-scan-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Save valid quotas first.
		require.NoError(t, store.saveQuotas(map[string]ModelQuota{
			"test": {MaxRPM: 10},
		}))

		// Rename column so SELECT ... FROM quotas fails.
		_, execErr := store.db.Exec("ALTER TABLE quotas RENAME COLUMN max_rpm TO rpm")
		require.NoError(t, execErr)

		_, err = store.loadQuotas()
		assert.Error(t, err, "loadQuotas should fail with renamed column")
	})
}

func TestError_NewSQLiteStoreInReadOnlyDir_Bad(t *testing.T) {
	if isRootUser() {
		t.Skip("chmod restrictions do not apply to root")
	}

	t.Run("fails when parent directory is read-only", func(t *testing.T) {
		tmpDir := t.TempDir()
		readonlyDir := testPath(tmpDir, "readonly")
		ensureTestDir(t, readonlyDir)
		setPathMode(t, readonlyDir, 0o555)
		defer func() {
			_ = syscall.Chmod(readonlyDir, 0o755)
		}()

		dbPath := testPath(readonlyDir, "test.db")
		_, err := newSQLiteStore(dbPath)
		assert.Error(t, err, "should fail when directory is read-only")
	})
}

func TestError_SQLiteCreateSchema_Bad(t *testing.T) {
	t.Run("createSchema fails on closed DB", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "schema-err.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)

		db := store.db
		store.close()

		err = createSchema(db)
		assert.Error(t, err, "createSchema should fail on closed DB")
		assert.Contains(t, err.Error(), "ratelimit.createSchema")
	})
}

func TestError_SQLiteLoadStateScan_Bad(t *testing.T) {
	t.Run("scan daily fails with NULL values", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "scan-daily.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Recreate daily without NOT NULL constraints so we can insert NULLs.
		_, _ = store.db.Exec("DROP TABLE daily")
		_, execErr := store.db.Exec("CREATE TABLE daily (model TEXT PRIMARY KEY, day_start INTEGER, day_count INTEGER)")
		require.NoError(t, execErr)
		// Insert a NULL day_start; scanning NULL into int64 returns an error.
		_, execErr = store.db.Exec("INSERT INTO daily VALUES ('test', NULL, NULL)")
		require.NoError(t, execErr)

		_, err = store.loadState()
		if err != nil {
			assert.Contains(t, err.Error(), "ratelimit.loadState")
		}
	})

	t.Run("scan requests fails with NULL ts", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "scan-req.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Insert a valid daily entry so loadState gets past the daily phase.
		_, execErr := store.db.Exec("INSERT INTO daily VALUES ('test', 0, 1)")
		require.NoError(t, execErr)

		// Recreate requests without NOT NULL, insert NULL ts.
		_, _ = store.db.Exec("DROP TABLE requests")
		_, execErr = store.db.Exec("CREATE TABLE requests (model TEXT, ts INTEGER)")
		require.NoError(t, execErr)
		_, execErr = store.db.Exec("CREATE INDEX IF NOT EXISTS idx_requests_model_ts ON requests(model, ts)")
		require.NoError(t, execErr)
		_, execErr = store.db.Exec("INSERT INTO requests VALUES ('test', NULL)")
		require.NoError(t, execErr)

		_, err = store.loadState()
		if err != nil {
			assert.Contains(t, err.Error(), "ratelimit.loadState")
		}
	})

	t.Run("scan tokens fails with NULL values", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "scan-tok.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Insert valid daily entry.
		_, execErr := store.db.Exec("INSERT INTO daily VALUES ('test', 0, 1)")
		require.NoError(t, execErr)

		// Recreate tokens without NOT NULL, insert NULL values.
		_, _ = store.db.Exec("DROP TABLE tokens")
		_, execErr = store.db.Exec("CREATE TABLE tokens (model TEXT, ts INTEGER, count INTEGER)")
		require.NoError(t, execErr)
		_, execErr = store.db.Exec("CREATE INDEX IF NOT EXISTS idx_tokens_model_ts ON tokens(model, ts)")
		require.NoError(t, execErr)
		_, execErr = store.db.Exec("INSERT INTO tokens VALUES ('test', NULL, NULL)")
		require.NoError(t, execErr)

		_, err = store.loadState()
		if err != nil {
			assert.Contains(t, err.Error(), "ratelimit.loadState")
		}
	})
}

func TestError_SQLiteLoadQuotasScanWithBadSchema_Bad(t *testing.T) {
	t.Run("scan fails with NULL quota values", func(t *testing.T) {
		dbPath := testPath(t.TempDir(), "scan-quota.db")
		store, err := newSQLiteStore(dbPath)
		require.NoError(t, err)
		defer store.close()

		// Recreate quotas without NOT NULL constraints.
		_, _ = store.db.Exec("DROP TABLE quotas")
		_, execErr := store.db.Exec("CREATE TABLE quotas (model TEXT PRIMARY KEY, max_rpm INTEGER, max_tpm INTEGER, max_rpd INTEGER)")
		require.NoError(t, execErr)
		_, execErr = store.db.Exec("INSERT INTO quotas VALUES ('test', NULL, NULL, NULL)")
		require.NoError(t, execErr)

		_, err = store.loadQuotas()
		if err != nil {
			assert.Contains(t, err.Error(), "ratelimit.loadQuotas")
		}
	})
}

func TestError_MigrateYAMLToSQLiteWithSaveErrors_Bad(t *testing.T) {
	t.Run("saveQuotas failure during migration via trigger", func(t *testing.T) {
		tmpDir := t.TempDir()
		yamlPath := testPath(tmpDir, "with-quotas.yaml")
		sqlitePath := testPath(tmpDir, "migrate-quota-err.db")

		// Write a YAML file with quotas.
		yamlData := `quotas:
  test-model:
    max_rpm: 10
    max_tpm: 100
    max_rpd: 50
`
		writeTestFile(t, yamlPath, yamlData)

		// Pre-create DB with a trigger that aborts quota inserts.
		store, err := newSQLiteStore(sqlitePath)
		require.NoError(t, err)
		_, execErr := store.db.Exec(`CREATE TRIGGER fail_quota_migrate BEFORE INSERT ON quotas
			BEGIN SELECT RAISE(ABORT, 'forced quota failure'); END`)
		require.NoError(t, execErr)
		store.close()

		// Migration re-opens the DB; tables already exist, trigger persists.
		err = MigrateYAMLToSQLite(yamlPath, sqlitePath)
		assert.Error(t, err, "migration should fail when saveQuotas fails")
	})

	t.Run("saveState failure during migration via trigger", func(t *testing.T) {
		tmpDir := t.TempDir()
		yamlPath := testPath(tmpDir, "with-state.yaml")
		sqlitePath := testPath(tmpDir, "migrate-state-err.db")

		// Write YAML with state.
		yamlData := `state:
  test-model:
    requests:
      - time: 2026-01-01T00:00:00Z
    day_start: 2026-01-01T00:00:00Z
    day_count: 1
`
		writeTestFile(t, yamlPath, yamlData)

		// Pre-create DB with a trigger that aborts daily inserts.
		store, err := newSQLiteStore(sqlitePath)
		require.NoError(t, err)
		_, execErr := store.db.Exec(`CREATE TRIGGER fail_daily_migrate BEFORE INSERT ON daily
			BEGIN SELECT RAISE(ABORT, 'forced daily failure'); END`)
		require.NoError(t, execErr)
		store.close()

		err = MigrateYAMLToSQLite(yamlPath, sqlitePath)
		assert.Error(t, err, "migration should fail when saveState fails")
	})
}

func TestError_MigrateYAMLToSQLiteNilQuotasAndState_Good(t *testing.T) {
	t.Run("YAML with empty quotas and state migrates cleanly", func(t *testing.T) {
		tmpDir := t.TempDir()
		yamlPath := testPath(tmpDir, "empty.yaml")
		writeTestFile(t, yamlPath, "{}")

		sqlitePath := testPath(tmpDir, "empty.db")
		require.NoError(t, MigrateYAMLToSQLite(yamlPath, sqlitePath))

		store, err := newSQLiteStore(sqlitePath)
		require.NoError(t, err)
		defer store.close()

		quotas, err := store.loadQuotas()
		require.NoError(t, err)
		assert.Empty(t, quotas)

		state, err := store.loadState()
		require.NoError(t, err)
		assert.Empty(t, state)
	})
}

func TestError_NewWithConfigHomeUnavailable_Bad(t *testing.T) {
	// Clear all supported home env vars so defaultStatePath cannot resolve a home directory.
	t.Setenv("CORE_HOME", "")
	t.Setenv("HOME", "")
	t.Setenv("home", "")
	t.Setenv("USERPROFILE", "")

	_, err := NewWithConfig(Config{})
	assert.Error(t, err, "should fail when HOME is unset")
}

func TestError_PersistMarshal_Good(t *testing.T) {
	// yaml.Marshal on a struct with map[string]ModelQuota and map[string]*UsageStats
	// should not fail in practice. We test the error path by using a type that
	// yaml.Marshal cannot handle: a channel.
	// Since we cannot inject a channel into the typed struct, this path is
	// unreachable in production. Instead, exercise the Persist YAML path
	// with valid data to confirm coverage of the non-error path.
	rl := newTestLimiter(t)
	rl.RecordUsage("test", 1, 1)
	assert.NoError(t, rl.Persist(), "valid persist should succeed")
}

func TestError_MigrateErrorsExtended_Bad(t *testing.T) {
	t.Run("unmarshal failure", func(t *testing.T) {
		tmpDir := t.TempDir()
		path := testPath(tmpDir, "bad.yaml")
		writeTestFile(t, path, "invalid: yaml: [")
		err := MigrateYAMLToSQLite(path, testPath(tmpDir, "out.db"))
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "ratelimit.MigrateYAMLToSQLite: unmarshal")
	})

	t.Run("sqlite open failure", func(t *testing.T) {
		tmpDir := t.TempDir()
		yamlPath := testPath(tmpDir, "ok.yaml")
		writeTestFile(t, yamlPath, "quotas: {}")
		// Use an invalid sqlite path (dir where file should be)
		err := MigrateYAMLToSQLite(yamlPath, "/dev/null/not-a-db")
		assert.Error(t, err)
	})
}