glancer 1.0.0

data/spec/lib/glancer/workflow/ar_sanitizer_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::ARSanitizer do
+  describe ".ensure_safe!" do
+    context "with safe read-only expressions" do
+      it "passes User.all" do
+        expect { described_class.ensure_safe!("User.all") }.not_to raise_error
+      end
+
+      it "passes a where chain" do
+        expect { described_class.ensure_safe!("User.where(active: true).count") }.not_to raise_error
+      end
+
+      it "passes joins + select" do
+        code = "Order.joins(:items).select('orders.id, count(items.id) as item_count').group('orders.id')"
+        expect { described_class.ensure_safe!(code) }.not_to raise_error
+      end
+
+      it "passes pluck" do
+        expect { described_class.ensure_safe!("User.pluck(:email)") }.not_to raise_error
+      end
+
+      it "passes aggregate methods" do
+        expect { described_class.ensure_safe!("Order.sum(:total)") }.not_to raise_error
+        expect { described_class.ensure_safe!("Order.average(:amount)") }.not_to raise_error
+        expect { described_class.ensure_safe!("Order.minimum(:created_at)") }.not_to raise_error
+      end
+
+      it "does not block .update_at (column-like word in a scope)" do
+        # .updated_at is a column accessor, not the .update write method
+        expect { described_class.ensure_safe!("User.order(:updated_at)") }.not_to raise_error
+      end
+
+      it "does not block .created_at" do
+        expect { described_class.ensure_safe!("User.where('created_at > ?', 1.week.ago)") }.not_to raise_error
+      end
+    end
+
+    context "with destructive ActiveRecord methods" do
+      it "blocks .destroy" do
+        expect { described_class.ensure_safe!("User.first.destroy") }
+          .to raise_error(Glancer::Error, /destroy/)
+      end
+
+      it "blocks .destroy_all" do
+        expect { described_class.ensure_safe!("User.where(active: false).destroy_all") }
+          .to raise_error(Glancer::Error, /destroy/)
+      end
+
+      it "blocks .delete" do
+        expect { described_class.ensure_safe!("User.first.delete") }
+          .to raise_error(Glancer::Error, /delete/)
+      end
+
+      it "blocks .delete_all" do
+        expect { described_class.ensure_safe!("User.delete_all") }
+          .to raise_error(Glancer::Error, /delete/)
+      end
+
+      it "blocks .update (write form)" do
+        expect { described_class.ensure_safe!("User.first.update(name: 'x')") }
+          .to raise_error(Glancer::Error, /update/)
+      end
+
+      it "blocks .update! (bang form)" do
+        expect { described_class.ensure_safe!("User.first.update!(name: 'x')") }
+          .to raise_error(Glancer::Error, /update/)
+      end
+
+      it "blocks .update_all" do
+        expect { described_class.ensure_safe!("User.update_all(active: false)") }
+          .to raise_error(Glancer::Error, /update_all/)
+      end
+
+      it "blocks .save" do
+        expect { described_class.ensure_safe!("u = User.first; u.name = 'x'; u.save") }
+          .to raise_error(Glancer::Error, /save/)
+      end
+
+      it "blocks .save!" do
+        expect { described_class.ensure_safe!("User.first.save!") }
+          .to raise_error(Glancer::Error, /save/)
+      end
+
+      it "blocks .create" do
+        expect { described_class.ensure_safe!("User.create(name: 'Eve')") }
+          .to raise_error(Glancer::Error, /create/)
+      end
+
+      it "blocks .create!" do
+        expect { described_class.ensure_safe!("User.create!(name: 'Eve')") }
+          .to raise_error(Glancer::Error, /create/)
+      end
+
+      it "blocks .insert" do
+        expect { described_class.ensure_safe!("User.insert(name: 'Eve')") }
+          .to raise_error(Glancer::Error, /insert/)
+      end
+
+      it "blocks .upsert" do
+        expect { described_class.ensure_safe!("User.upsert(id: 1, name: 'Eve')") }
+          .to raise_error(Glancer::Error, /upsert/)
+      end
+
+      it "blocks .touch" do
+        expect { described_class.ensure_safe!("User.first.touch") }
+          .to raise_error(Glancer::Error, /touch/)
+      end
+    end
+
+    context "with shell / OS execution" do
+      it "blocks backtick shell execution" do
+        expect { described_class.ensure_safe!("`ls -la`") }
+          .to raise_error(Glancer::Error, /shell/)
+      end
+
+      it "blocks system() call" do
+        expect { described_class.ensure_safe!("system('rm -rf /')") }
+          .to raise_error(Glancer::Error, /shell/)
+      end
+
+      it "blocks exec()" do
+        expect { described_class.ensure_safe!("exec('cat /etc/passwd')") }
+          .to raise_error(Glancer::Error, /shell/)
+      end
+    end
+
+    context "with eval" do
+      it "blocks eval()" do
+        expect { described_class.ensure_safe!("eval('User.where(1=1)')") }
+          .to raise_error(Glancer::Error, /eval/)
+      end
+
+      it "blocks instance_eval" do
+        expect { described_class.ensure_safe!("User.instance_eval { delete_all }") }
+          .to raise_error(Glancer::Error, /eval/)
+      end
+    end
+
+    context "with file writes" do
+      it "blocks FileUtils" do
+        expect { described_class.ensure_safe!("FileUtils.rm_rf('/')") }
+          .to raise_error(Glancer::Error, /file write/)
+      end
+
+      it "blocks File.write" do
+        expect { described_class.ensure_safe!("File.write('/etc/hosts', 'evil')") }
+          .to raise_error(Glancer::Error, /file write/)
+      end
+    end
+
+    context "with dynamic loading" do
+      it "blocks require" do
+        expect { described_class.ensure_safe!("require 'open3'") }
+          .to raise_error(Glancer::Error, /load/)
+      end
+
+      it "blocks load" do
+        expect { described_class.ensure_safe!("load '/evil.rb'") }
+          .to raise_error(Glancer::Error, /load/)
+      end
+    end
+
+    context "when an unexpected StandardError occurs during sanitization" do
+      it "wraps the error in Glancer::Error" do
+        allow(described_class).to receive(:ensure_safe!).and_call_original
+        allow_any_instance_of(String).to receive(:match?).and_raise(StandardError, "regex engine failure")
+        expect { described_class.ensure_safe!("User.count") }
+          .to raise_error(Glancer::Error, /AR sanitization failed/)
+      end
+    end
+  end
+end

data/spec/lib/glancer/workflow/builder_spec.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::Builder do
+  let(:fake_response) { double("Response", content: "SELECT * FROM users") }
+  let(:fake_chat) do
+    double("Chat").tap do |c|
+      allow(c).to receive(:ask).and_return(fake_response)
+      allow(c).to receive(:with_instructions).and_return(c)
+    end
+  end
+
+  before do
+    allow(RubyLLM).to receive(:chat).and_return(fake_chat)
+  end
+
+  # ── .build_sql ────────────────────────────────────────────────────────────
+
+  describe ".build_sql" do
+    let(:question)   { "Show all users" }
+    let(:embeddings) { [] }
+
+    it "returns the SQL content from the LLM response" do
+      result = described_class.build_sql(question, embeddings)
+      expect(result).to eq("SELECT * FROM users")
+    end
+
+    it "calls RubyLLM.chat with the configured provider and model" do
+      expect(RubyLLM).to receive(:chat).with(
+        hash_including(provider: Glancer.configuration.resolved_code_provider,
+                       model: Glancer.configuration.resolved_code_model)
+      ).and_return(fake_chat)
+      described_class.build_sql(question, embeddings)
+    end
+
+    it "passes history to the prompt builder" do
+      chat = Glancer::Chat.create!(title: "C")
+      msg  = Glancer::Message.create!(chat: chat, role: "user", content: "previous Q")
+      described_class.build_sql(question, embeddings, history: [msg])
+      # No error means history was processed
+    end
+
+    it "raises Glancer::Error when the LLM call fails" do
+      allow(RubyLLM).to receive(:chat).and_raise(StandardError, "network error")
+      expect { described_class.build_sql(question, embeddings) }
+        .to raise_error(Glancer::Error, /code generation failed/)
+    end
+
+    it "includes recent audit examples as few-shot examples" do
+      Glancer::Audit.create!(
+        question: "How many users?",
+        code: "SELECT COUNT(*) FROM users /*glancer,run_id:abc*/",
+        adapter: Glancer.configuration.resolved_adapter.to_s,
+        run_id: SecureRandom.uuid,
+        executed_at: Time.current
+      )
+      expect(fake_chat).to receive(:ask).and_return(fake_response)
+      described_class.build_sql(question, embeddings)
+    end
+  end
+
+  # ── .recent_examples ──────────────────────────────────────────────────────
+
+  describe ".recent_examples" do
+    it "returns an empty array when no audits exist" do
+      expect(described_class.recent_examples).to eq([])
+    end
+
+    it "returns up to 3 most recent audit pairs [question, code]" do
+      4.times do |i|
+        Glancer::Audit.create!(
+          question: "Q#{i}",
+          code: "SELECT #{i}",
+          adapter: Glancer.configuration.resolved_adapter.to_s,
+          run_id: SecureRandom.uuid,
+          executed_at: Time.current - (4 - i).seconds
+        )
+      end
+      examples = described_class.recent_examples
+      expect(examples.size).to eq(3)
+      # Most recent first
+      expect(examples.first[0]).to eq("Q3")
+    end
+
+    it "only returns audits matching the current adapter" do
+      Glancer::Audit.create!(
+        question: "PostgreSQL Q",
+        code: "SELECT 1",
+        adapter: "postgres",
+        run_id: SecureRandom.uuid,
+        executed_at: Time.current
+      )
+      # SQLite adapter in tests — postgres audit should NOT appear
+      expect(described_class.recent_examples).to be_empty
+    end
+
+    it "returns [] when the Audit query raises (rescue path)" do
+      allow(Glancer::Audit).to receive(:where).and_raise(StandardError, "DB unavailable")
+      expect(described_class.recent_examples).to eq([])
+    end
+
+    it "excludes audits without a question" do
+      Glancer::Audit.create!(
+        question: nil,
+        code: "SELECT 1",
+        adapter: Glancer.configuration.resolved_adapter.to_s,
+        run_id: SecureRandom.uuid,
+        executed_at: Time.current
+      )
+      expect(described_class.recent_examples).to be_empty
+    end
+  end
+
+  # ── .build_ar_code ────────────────────────────────────────────────────────
+
+  describe ".build_ar_code" do
+    let(:ar_response) { double("Response", content: "```ruby\nUser.count\n```") }
+    let(:ar_chat) do
+      double("Chat").tap { |c| allow(c).to receive(:ask).and_return(ar_response) }
+    end
+
+    before { allow(RubyLLM).to receive(:chat).and_return(ar_chat) }
+
+    it "returns the AR code content from the LLM response" do
+      result = described_class.build_ar_code("count users", [])
+      expect(result).to eq("```ruby\nUser.count\n```")
+    end
+
+    it "calls RubyLLM.chat with the configured code provider and model" do
+      expect(RubyLLM).to receive(:chat).with(
+        hash_including(provider: Glancer.configuration.resolved_code_provider,
+                       model: Glancer.configuration.resolved_code_model)
+      ).and_return(ar_chat)
+      described_class.build_ar_code("count users", [])
+    end
+
+    it "raises Glancer::Error when the LLM call fails" do
+      allow(RubyLLM).to receive(:chat).and_raise(StandardError, "timeout")
+      expect { described_class.build_ar_code("count users", []) }
+        .to raise_error(Glancer::Error, /AR code generation failed/)
+    end
+  end
+
+  # ── .fix_ar_code ──────────────────────────────────────────────────────────
+
+  describe ".fix_ar_code" do
+    let(:fixed_ar_response) { double("Response", content: "```ruby\nGlancer::Chat.count\n```") }
+    let(:fix_ar_chat) do
+      double("Chat").tap { |c| allow(c).to receive(:ask).and_return(fixed_ar_response) }
+    end
+
+    before { allow(RubyLLM).to receive(:chat).and_return(fix_ar_chat) }
+
+    it "returns the extracted AR code from the LLM correction" do
+      result = described_class.fix_ar_code("BadModel.all", "uninitialized constant")
+      expect(result).to eq("Glancer::Chat.count")
+    end
+
+    it "calls RubyLLM.chat to get the correction" do
+      expect(RubyLLM).to receive(:chat).and_return(fix_ar_chat)
+      described_class.fix_ar_code("BadModel.all", "uninitialized constant")
+    end
+
+    it "raises Glancer::Error when the LLM call fails" do
+      allow(RubyLLM).to receive(:chat).and_raise(StandardError, "LLM down")
+      expect { described_class.fix_ar_code("BadModel.all", "error") }
+        .to raise_error(Glancer::Error, /AR code correction failed/)
+    end
+  end
+
+  # ── .fix_sql ─────────────────────────────────────────────────────────────
+
+  describe ".fix_sql" do
+    let(:failed_sql)     { "SELCT * FROM users" }
+    let(:error_message)  { "syntax error near SELCT" }
+    let(:fixed_response) { double("Response", content: "```sql\nSELECT * FROM users\n```") }
+    let(:fix_chat) do
+      double("Chat").tap do |c|
+        allow(c).to receive(:ask).and_return(fixed_response)
+      end
+    end
+
+    before do
+      allow(RubyLLM).to receive(:chat).and_return(fix_chat)
+    end
+
+    it "returns extracted SQL from the LLM's corrected response" do
+      result = described_class.fix_sql(failed_sql, error_message)
+      expect(result).to eq("SELECT * FROM users")
+    end
+
+    it "calls RubyLLM.chat to get the correction" do
+      expect(RubyLLM).to receive(:chat).and_return(fix_chat)
+      described_class.fix_sql(failed_sql, error_message)
+    end
+
+    it "raises Glancer::Error when the LLM call fails" do
+      allow(RubyLLM).to receive(:chat).and_raise(StandardError, "LLM down")
+      expect { described_class.fix_sql(failed_sql, error_message) }
+        .to raise_error(Glancer::Error, /code correction workflow failed/)
+    end
+  end
+end

data/spec/lib/glancer/workflow/cache_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::Cache do
+  let(:question) { "How many users are there?" }
+  let(:result)   { { question: question, content: "42 users", code: "SELECT COUNT(*) FROM users", successful: true } }
+
+  before { described_class.clear }
+
+  describe ".fetch" do
+    context "when the cache is empty" do
+      it "returns nil for an unknown question" do
+        expect(described_class.fetch(question)).to be_nil
+      end
+    end
+
+    context "when the cache has a fresh entry" do
+      before { described_class.write(question, result) }
+
+      it "returns the cached entry" do
+        entry = described_class.fetch(question)
+        expect(entry).not_to be_nil
+        expect(entry[:content]).to eq("42 users")
+      end
+
+      it "includes the cached_at timestamp" do
+        entry = described_class.fetch(question)
+        expect(entry[:cached_at]).to be_a(Time)
+      end
+    end
+
+    context "when the cache entry is expired" do
+      before do
+        described_class.write(question, result)
+      end
+
+      it "returns nil and removes the expired entry" do
+        Glancer.configuration.workflow_cache_ttl = 1 # 1 second TTL
+        # Simulate time passing beyond TTL
+        old_time = Time.now - 10
+        allow(Time).to receive(:current).and_return(old_time + 2)
+
+        # Write with 'old' cached_at by manipulating after the fact
+        described_class.clear
+        described_class.write(question, result)
+        # Now override Time.current to be far in the future
+        allow(Time).to receive(:current).and_return(Time.now + 3600)
+
+        expect(described_class.fetch(question)).to be_nil
+      end
+    end
+  end
+
+  describe ".write" do
+    it "stores the result merged with cached_at" do
+      described_class.write(question, result)
+      entry = described_class.fetch(question)
+      expect(entry).not_to be_nil
+      expect(entry[:cached_at]).to be_a(Time)
+      expect(entry[:code]).to eq("SELECT COUNT(*) FROM users")
+    end
+
+    it "overwrites an existing entry for the same question" do
+      described_class.write(question, result)
+      new_result = result.merge(content: "Updated content")
+      described_class.write(question, new_result)
+      entry = described_class.fetch(question)
+      expect(entry[:content]).to eq("Updated content")
+    end
+  end
+
+  describe ".clear" do
+    it "removes all cached entries" do
+      described_class.write(question, result)
+      described_class.write("another question", result)
+      described_class.clear
+      expect(described_class.fetch(question)).to be_nil
+      expect(described_class.fetch("another question")).to be_nil
+    end
+  end
+
+  # ── rescue paths ─────────────────────────────────────────────────────────
+
+  describe "rescue paths" do
+    it "fetch returns nil when an internal error occurs (e.g. expired? raises)" do
+      described_class.write(question, result)
+      allow(described_class).to receive(:expired?).and_raise(RuntimeError, "unexpected")
+      expect(described_class.fetch(question)).to be_nil
+    end
+
+    it "write handles errors gracefully without raising" do
+      store_mock = double("store")
+      allow(store_mock).to receive(:[]=).and_raise(StandardError, "write error")
+      allow(store_mock).to receive(:clear)
+      allow(store_mock).to receive(:[]).and_return(nil)
+      Glancer::Workflow::Cache.class_variable_set(:@@store, store_mock)
+      allow(Glancer::Utils::Logger).to receive(:error)
+      allow(Glancer::Utils::Logger).to receive(:debug)
+      expect { described_class.write(question, result) }.not_to raise_error
+    ensure
+      Glancer::Workflow::Cache.class_variable_set(:@@store, {})
+    end
+
+    it "clear handles unexpected errors gracefully" do
+      store_mock = double("store")
+      allow(store_mock).to receive(:clear).and_raise(StandardError, "cannot clear")
+      Glancer::Workflow::Cache.class_variable_set(:@@store, store_mock)
+      allow(Glancer::Utils::Logger).to receive(:error)
+      allow(Glancer::Utils::Logger).to receive(:debug)
+      expect { described_class.clear }.not_to raise_error
+    ensure
+      Glancer::Workflow::Cache.class_variable_set(:@@store, {})
+    end
+  end
+
+  describe ".expired?" do
+    context "with a fresh entry" do
+      it "returns false" do
+        entry = { cached_at: Time.now }
+        allow(Time).to receive(:current).and_return(Time.now)
+        Glancer.configuration.workflow_cache_ttl = 300
+        expect(described_class.expired?(entry)).to be(false)
+      end
+    end
+
+    context "with an old entry beyond TTL" do
+      it "returns true" do
+        Glancer.configuration.workflow_cache_ttl = 1
+        entry = { cached_at: Time.now - 60 }
+        expect(described_class.expired?(entry)).to be(true)
+      end
+    end
+
+    context "when entry has no cached_at" do
+      it "returns true (safe default)" do
+        entry = {}
+        expect(described_class.expired?(entry)).to be(true)
+      end
+    end
+  end
+end

data/spec/lib/glancer/workflow/executor_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::Executor do
+  let(:valid_sql)  { "SELECT 1 AS n" }
+  let(:update_sql) { "UPDATE users SET name = 'x'" }
+
+  # ── Security guard ────────────────────────────────────────────────────────
+
+  describe ".execute — security guard" do
+    it "raises Glancer::Error for UPDATE SQL" do
+      expect { described_class.execute(update_sql) }
+        .to raise_error(Glancer::Error, /Only SELECT queries are allowed/)
+    end
+
+    it "raises Glancer::Error for DELETE SQL" do
+      expect { described_class.execute("DELETE FROM users") }
+        .to raise_error(Glancer::Error, /Only SELECT queries are allowed/)
+    end
+
+    it "raises Glancer::Error for INSERT SQL" do
+      expect { described_class.execute("INSERT INTO users VALUES (1)") }
+        .to raise_error(Glancer::Error, /Only SELECT queries are allowed/)
+    end
+
+    it "raises Glancer::Error for DROP SQL" do
+      expect { described_class.execute("DROP TABLE users") }
+        .to raise_error(Glancer::Error, /Only SELECT queries are allowed/)
+    end
+
+    it "allows SELECT queries through" do
+      result = described_class.execute(valid_sql)
+      expect(result).to be_an(Array)
+    end
+
+    it "allows WITH (CTE) queries through" do
+      cte_sql = "WITH t AS (SELECT 1 AS x) SELECT x FROM t"
+      expect { described_class.execute(cte_sql) }.not_to raise_error
+    end
+  end
+
+  # ── Successful execution ──────────────────────────────────────────────────
+
+  describe ".execute — successful execution" do
+    it "returns an array of result rows" do
+      result = described_class.execute(valid_sql)
+      expect(result).to be_an(Array)
+      expect(result.first).to include("n" => 1)
+    end
+
+    it "creates a Glancer::Audit record after success" do
+      expect { described_class.execute(valid_sql, original_question: "What is 1?") }
+        .to change(Glancer::Audit, :count).by(1)
+    end
+
+    it "stores the run_id in the audit record" do
+      described_class.execute(valid_sql)
+      audit = Glancer::Audit.last
+      expect(audit.run_id).to be_a(String)
+      expect(audit.run_id).not_to be_empty
+    end
+
+    it "appends the /*glancer,run_id:...*/ comment to the stored code" do
+      described_class.execute(valid_sql)
+      audit = Glancer::Audit.last
+      expect(audit.code).to include("/*glancer,run_id:")
+    end
+
+    it "stores the original_question in the audit record" do
+      described_class.execute(valid_sql, original_question: "count rows")
+      expect(Glancer::Audit.last.question).to eq("count rows")
+    end
+
+    it "stores the message_id when provided" do
+      chat = Glancer::Chat.create!(title: "C")
+      msg  = Glancer::Message.create!(chat: chat, role: "assistant", content: "x")
+      described_class.execute(valid_sql, message_id: msg.id)
+      expect(Glancer::Audit.last.message_id).to eq(msg.id)
+    end
+
+    it "rolls back the transaction (read-only safety) — any DML inside rolled back" do
+      # The executor always rolls back even successful reads
+      # We verify by checking that the glancer_audits table's contents match our expectations
+      # but the executed SELECT 1 has no side-effects in any case; deeper test via custom SQL
+      result = described_class.execute("SELECT COUNT(*) AS cnt FROM glancer_chats")
+      expect(result.first["cnt"]).to eq(0)
+    end
+  end
+
+  # ── Retry on failure ──────────────────────────────────────────────────────
+
+  describe ".execute — retry with Builder.fix_sql" do
+    let(:bad_sql)   { "SELECT * FROM nonexistent_table_xyz" }
+    let(:fixed_sql) { "SELECT 1 AS n" }
+
+    before do
+      allow(Glancer::Workflow::Builder).to receive(:fix_sql).and_return(fixed_sql)
+    end
+
+    it "calls Builder.fix_sql on first failure and retries" do
+      expect(Glancer::Workflow::Builder).to receive(:fix_sql).at_least(:once).and_return(fixed_sql)
+      described_class.execute(bad_sql)
+    end
+
+    it "returns the result from the fixed SQL" do
+      result = described_class.execute(bad_sql)
+      expect(result).to be_an(Array)
+    end
+
+    it "returns an error hash after 3 failed attempts" do
+      allow(Glancer::Workflow::Builder).to receive(:fix_sql).and_return(bad_sql)
+      result = described_class.execute(bad_sql, attempt: 1)
+      expect(result).to be_a(Hash)
+      expect(result[:error]).to be(true)
+      expect(result[:message]).to be_a(String)
+      expect(result[:last_code]).to eq(bad_sql)
+    end
+  end
+
+  # ── apply_statement_timeout ───────────────────────────────────────────────
+
+  describe ".apply_statement_timeout" do
+    let(:connection) { ActiveRecord::Base.connection }
+
+    it "does not raise for sqlite adapter (no timeout command)" do
+      Glancer.configuration.adapter = :sqlite
+      expect { described_class.apply_statement_timeout(connection) }.not_to raise_error
+    end
+
+    it "executes SET statement_timeout for postgres adapter" do
+      Glancer.configuration.adapter = :postgres
+      expect(connection).to receive(:execute).with(/SET statement_timeout/)
+      described_class.apply_statement_timeout(connection)
+    end
+
+    it "executes SET max_execution_time for mysql adapter" do
+      Glancer.configuration.adapter = :mysql2
+      expect(connection).to receive(:execute).with(/SET max_execution_time/)
+      described_class.apply_statement_timeout(connection)
+    end
+
+    it "does not raise when the DB rejects the timeout command" do
+      Glancer.configuration.adapter = :postgres
+      allow(connection).to receive(:execute).and_raise(StandardError, "unsupported")
+      expect { described_class.apply_statement_timeout(connection) }.not_to raise_error
+    end
+  end
+end