glancer 1.0.0

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::LLM do
+  let(:fake_response) { double("Response", content: "The query counts all users in the system.") }
+  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
+
+  # ── .humanized_response ───────────────────────────────────────────────────
+
+  describe ".humanized_response" do
+    let(:question) { "How many users are there?" }
+    let(:sql)      { "SELECT COUNT(*) FROM users" }
+    let(:data)     { [{ "count" => 42 }] }
+
+    it "returns the LLM response content" do
+      result = described_class.humanized_response(question, data, sql)
+      expect(result).to eq("The query counts all users in the system.")
+    end
+
+    it "calls RubyLLM.chat with the configured chat provider and model" do
+      expect(RubyLLM).to receive(:chat).with(
+        hash_including(provider: Glancer.configuration.resolved_chat_provider,
+                       model: Glancer.configuration.resolved_chat_model)
+      ).and_return(fake_chat)
+      described_class.humanized_response(question, data, sql)
+    end
+
+    it "returns a fallback string when the LLM raises" do
+      allow(RubyLLM).to receive(:chat).and_raise(StandardError, "timeout")
+      result = described_class.humanized_response(question, data, sql)
+      expect(result).to include("failed to generate")
+    end
+
+    it "appends custom instructions when they exist" do
+      Glancer::Setting.set("custom_instructions", "Always use bullet points")
+      # The system prompt should include the custom instruction;
+      # we verify by checking that with_instructions is called or ask receives the prompt
+      expect(fake_chat).to receive(:ask).and_return(fake_response)
+      described_class.humanized_response(question, data, sql)
+    end
+  end
+
+  # ── .explain_missing_tables ───────────────────────────────────────────────
+
+  describe ".explain_missing_tables" do
+    let(:question)      { "Show all affiliates" }
+    let(:error_message) { "Table validation failed: Missing table(s) in indexed schema: affiliates" }
+
+    it "returns the LLM's explanation" do
+      allow(fake_response).to receive(:content).and_return("The table 'affiliates' was not found.")
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+      result = described_class.explain_missing_tables(question, error_message)
+      expect(result).to eq("The table 'affiliates' was not found.")
+    end
+
+    it "returns a fallback string when the LLM raises" do
+      allow(RubyLLM).to receive(:chat).and_raise(StandardError, "API error")
+      result = described_class.explain_missing_tables(question, error_message)
+      expect(result).to be_a(String)
+      expect(result).not_to be_empty
+    end
+  end
+
+  # ── .generate_title ───────────────────────────────────────────────────────
+
+  describe ".generate_title" do
+    let(:question) { "Show me all revenue by region for last quarter" }
+
+    it "returns the LLM-generated title (truncated to 50 chars)" do
+      allow(fake_response).to receive(:content).and_return("Revenue by Region Last Quarter")
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+      result = described_class.generate_title(question)
+      expect(result).to eq("Revenue by Region Last Quarter")
+      expect(result.length).to be <= 50
+    end
+
+    it "truncates a very long LLM response to 50 characters" do
+      long_title = "A" * 100
+      allow(fake_response).to receive(:content).and_return(long_title)
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+      result = described_class.generate_title(question)
+      expect(result.length).to be <= 50
+    end
+
+    it "falls back to a truncated question when the LLM raises" do
+      allow(RubyLLM).to receive(:chat).and_raise(StandardError, "error")
+      result = described_class.generate_title(question)
+      expect(result).to be_a(String)
+      expect(result.length).to be <= 50
+    end
+  end
+
+  # ── .explain_error ────────────────────────────────────────────────────────
+
+  describe ".explain_error" do
+    let(:question)      { "Count orders by customer" }
+    let(:error_message) { "no such column: customer_id" }
+    let(:sql)           { "SELECT customer_id, COUNT(*) FROM orders GROUP BY customer_id" }
+
+    it "returns the LLM's error explanation" do
+      allow(fake_response).to receive(:content).and_return("We couldn't find the column customer_id.")
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+      result = described_class.explain_error(question, error_message, sql)
+      expect(result).to eq("We couldn't find the column customer_id.")
+    end
+
+    it "calls RubyLLM.chat with the chat provider config" do
+      expect(RubyLLM).to receive(:chat).with(
+        hash_including(provider: Glancer.configuration.resolved_chat_provider)
+      ).and_return(fake_chat)
+      described_class.explain_error(question, error_message, sql)
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::PromptBuilder do
+  let(:question)   { "How many users signed up this month?" }
+  let(:embedding1) do
+    Glancer::Embedding.create!(
+      content: "create_table users ...",
+      embedding: [],
+      source_type: "schema",
+      source_path: "db/schema.rb#users"
+    )
+  end
+  let(:embedding2) do
+    Glancer::Embedding.create!(
+      content: "# Foreign Key Relationships\norders.user_id → users.id",
+      embedding: [],
+      source_type: "schema",
+      source_path: "db/schema.rb#foreign_keys"
+    )
+  end
+  let(:embeddings) { [embedding1, embedding2] }
+
+  let(:chat)    { Glancer::Chat.create!(title: "Test") }
+  let(:history) { [] }
+
+  # Mock DB connection's current_database method
+  before do
+    allow(ActiveRecord::Base.connection).to receive(:current_database).and_return("test_db")
+  end
+
+  # ── .call ─────────────────────────────────────────────────────────────────
+
+  describe ".call" do
+    subject(:prompt) { described_class.call(question, embeddings, history: history) }
+
+    it "returns a String" do
+      expect(prompt).to be_a(String)
+    end
+
+    it "includes the question" do
+      expect(prompt).to include(question)
+    end
+
+    it "includes the adapter type" do
+      expect(prompt).to include("SQLITE")
+    end
+
+    it "includes schema content from embeddings" do
+      expect(prompt).to include("create_table users")
+    end
+
+    it "places foreign key content in the SCHEMA RELATIONSHIPS section" do
+      expect(prompt).to include("orders.user_id → users.id")
+    end
+
+    it "includes OUTPUT SQL ONLY directive" do
+      expect(prompt).to include("OUTPUT SQL ONLY")
+    end
+
+    context "when history contains messages" do
+      let(:user_msg) do
+        Glancer::Message.create!(chat: chat, role: "user", content: "Show orders")
+      end
+      let(:assistant_msg) do
+        Glancer::Message.create!(
+          chat: chat, role: "assistant", content: "Here are the orders",
+          code: "SELECT * FROM orders"
+        )
+      end
+      let(:history) { [user_msg, assistant_msg] }
+
+      it "includes the user message in the conversation history" do
+        expect(prompt).to include("Show orders")
+      end
+
+      it "includes the assistant SQL in the conversation history" do
+        expect(prompt).to include("SELECT * FROM orders")
+      end
+    end
+
+    context "when history is empty" do
+      it "includes a placeholder for no prior messages" do
+        expect(prompt).to include("no prior messages")
+      end
+    end
+
+    context "when custom instructions are set" do
+      before { Glancer::Setting.set("custom_instructions", "Always use LIMIT 100") }
+
+      it "includes the custom instructions" do
+        expect(prompt).to include("Always use LIMIT 100")
+      end
+    end
+
+    it "raises Glancer::Error on unexpected failure" do
+      allow(described_class).to receive(:format_embeddings_with_stats).and_raise(RuntimeError, "boom")
+      expect { described_class.call(question, embeddings) }.to raise_error(Glancer::Error, /Prompt construction failed/)
+    end
+  end
+
+  # ── .custom_instructions_block ────────────────────────────────────────────
+
+  describe ".custom_instructions_block" do
+    it "returns empty string when Glancer::Setting.get raises" do
+      allow(Glancer::Setting).to receive(:get).and_raise(StandardError, "DB error")
+      expect(described_class.custom_instructions_block).to eq("")
+    end
+
+    it "returns an empty string when no custom instructions are set" do
+      expect(described_class.custom_instructions_block).to eq("")
+    end
+
+    it "returns the custom instructions block when set" do
+      Glancer::Setting.set("custom_instructions", "Use snake_case")
+      result = described_class.custom_instructions_block
+      expect(result).to include("Use snake_case")
+      expect(result).to include("CUSTOM RULES")
+    end
+  end
+
+  # ── .partition_embeddings ─────────────────────────────────────────────────
+
+  describe ".partition_embeddings" do
+    it "separates FK embeddings from regular embeddings" do
+      schema_embeds, fk_text = described_class.partition_embeddings(embeddings)
+      expect(schema_embeds).to include(embedding1)
+      expect(schema_embeds).not_to include(embedding2)
+      expect(fk_text).to include("Foreign Key Relationships")
+    end
+
+    it "returns empty FK text when no FK embeddings exist" do
+      _schema_embeds, fk_text = described_class.partition_embeddings([embedding1])
+      expect(fk_text).to eq("")
+    end
+  end
+
+  # ── .format_embeddings_with_stats ─────────────────────────────────────────
+
+  describe ".format_embeddings_with_stats" do
+    it "joins the content of each embedding with double newlines" do
+      result = described_class.format_embeddings_with_stats([embedding1])
+      expect(result).to include("create_table users")
+    end
+  end
+
+  # ── .format_few_shot_examples ─────────────────────────────────────────────
+
+  describe ".format_few_shot_examples" do
+    it "returns empty string for empty examples" do
+      expect(described_class.format_few_shot_examples([])).to eq("")
+    end
+
+    it "formats examples with question and SQL" do
+      examples = [["Count users", "SELECT COUNT(*) FROM users"]]
+      result   = described_class.format_few_shot_examples(examples)
+      expect(result).to include("Count users")
+      expect(result).to include("SELECT COUNT(*) FROM users")
+    end
+
+    it "numbers examples starting from 1" do
+      examples = [
+        ["Q1", "SELECT 1"],
+        ["Q2", "SELECT 2"]
+      ]
+      result = described_class.format_few_shot_examples(examples)
+      expect(result).to include("Example 1:")
+      expect(result).to include("Example 2:")
+    end
+  end
+
+  # ── .example_sql ─────────────────────────────────────────────────────────
+
+  describe ".example_sql" do
+    it "returns MySQL example for mysql adapter" do
+      result = described_class.example_sql("mysql")
+      expect(result).to include("DATE_FORMAT")
+    end
+
+    it "returns MySQL example for mysql2 adapter" do
+      result = described_class.example_sql("mysql2")
+      expect(result).to include("DATE_FORMAT")
+    end
+
+    it "returns PostgreSQL example for postgres adapter" do
+      result = described_class.example_sql("postgres")
+      expect(result).to include("TO_CHAR")
+    end
+
+    it "returns a fallback comment for unsupported adapters" do
+      result = described_class.example_sql("sqlite")
+      expect(result).to include("Example not available")
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::QueryEnricher do
+  let(:fake_response) { double("Response", content: "Show all records from users table") }
+  let(:fake_chat) do
+    double("Chat").tap { |c| allow(c).to receive(:ask).and_return(fake_response) }
+  end
+
+  before do
+    allow(RubyLLM).to receive(:chat).and_return(fake_chat)
+  end
+
+  # ── .enrich ───────────────────────────────────────────────────────────────
+
+  describe ".enrich" do
+    let(:question)    { "Mostre todas as vendas" }
+    let(:table_names) { %w[orders users products] }
+
+    it "returns the LLM-enriched question" do
+      result = described_class.enrich(question, table_names)
+      expect(result).to eq("Show all records from users table")
+    end
+
+    it "passes provider and model from configuration" do
+      expect(RubyLLM).to receive(:chat).with(
+        hash_including(
+          provider: Glancer.configuration.resolved_enrichment_provider,
+          model: Glancer.configuration.resolved_enrichment_model
+        )
+      ).and_return(fake_chat)
+      described_class.enrich(question, table_names)
+    end
+
+    it "returns the original question when table_names is empty" do
+      expect(RubyLLM).not_to receive(:chat)
+      result = described_class.enrich(question, [])
+      expect(result).to eq(question)
+    end
+
+    it "returns the original question when the LLM call fails" do
+      allow(RubyLLM).to receive(:chat).and_raise(StandardError, "network error")
+      result = described_class.enrich(question, table_names)
+      expect(result).to eq(question)
+    end
+
+    it "returns the original question when LLM returns blank content" do
+      allow(fake_chat).to receive(:ask).and_return(double("Response", content: "   "))
+      result = described_class.enrich(question, table_names)
+      expect(result).to eq(question)
+    end
+
+    it "includes the table names in the prompt sent to the LLM" do
+      expect(fake_chat).to receive(:ask) do |prompt|
+        expect(prompt).to include("orders")
+        expect(prompt).to include("users")
+        fake_response
+      end
+      described_class.enrich(question, table_names)
+    end
+
+    it "strips whitespace from the enriched question" do
+      allow(fake_chat).to receive(:ask).and_return(double("Response", content: "  enriched question  "))
+      result = described_class.enrich(question, table_names)
+      expect(result).to eq("enriched question")
+    end
+
+    it "includes assistant messages with code in the history block sent to the LLM" do
+      chat_obj = Glancer::Chat.create!(title: "T")
+      msg = Glancer::Message.create!(
+        chat: chat_obj, role: :assistant, content: "Found 3.",
+        code: "User.count", code_type: "activerecord"
+      )
+      expect(fake_chat).to receive(:ask) do |prompt|
+        expect(prompt).to include("ASSISTANT")
+        expect(prompt).to include("User.count")
+        fake_response
+      end
+      described_class.enrich(question, table_names, history: [msg])
+    end
+
+    it "includes non-code messages in the history block without code format" do
+      chat_obj = Glancer::Chat.create!(title: "T")
+      msg = Glancer::Message.create!(chat: chat_obj, role: :user, content: "What is the count?")
+      expect(fake_chat).to receive(:ask) do |prompt|
+        expect(prompt).to include("USER: What is the count?")
+        fake_response
+      end
+      described_class.enrich(question, table_names, history: [msg])
+    end
+
+    it "includes referenced schema context in prompt when question has @mentioned tables" do
+      Glancer::Embedding.create!(
+        content: "create_table orders ...", embedding: [],
+        source_type: "schema", source_path: "/db/schema.rb#orders"
+      )
+      expect(fake_chat).to receive(:ask) do |prompt|
+        expect(prompt).to include("Referenced Schema")
+        fake_response
+      end
+      described_class.enrich("How many @orders?", ["orders"])
+    end
+
+    it "continues normally when schema context lookup raises (rescue path)" do
+      allow(Glancer::Embedding).to receive(:where).and_raise(StandardError, "db error")
+      result = described_class.enrich("count @orders", ["orders"])
+      expect(result).to be_a(String)
+    end
+
+    it "omits referenced schema block when @mention does not match any table" do
+      expect(fake_chat).to receive(:ask) do |prompt|
+        expect(prompt).not_to include("Referenced Schema")
+        fake_response
+      end
+      described_class.enrich("How many @ghost records?", table_names)
+    end
+  end
+
+  # ── .known_table_names ────────────────────────────────────────────────────
+
+  describe ".known_table_names" do
+    it "returns an empty array when no embeddings exist" do
+      expect(described_class.known_table_names).to eq([])
+    end
+
+    it "extracts table names from schema embedding source_paths" do
+      Glancer::Embedding.create!(
+        content: "create_table users",
+        embedding: [],
+        source_type: "schema",
+        source_path: "/fake/root/db/schema.rb#users"
+      )
+      expect(described_class.known_table_names).to include("users")
+    end
+
+    it "excludes the foreign_keys pseudo-table" do
+      Glancer::Embedding.create!(
+        content: "fk block",
+        embedding: [],
+        source_type: "schema",
+        source_path: "/fake/root/db/schema.rb#foreign_keys"
+      )
+      expect(described_class.known_table_names).not_to include("foreign_keys")
+    end
+
+    it "excludes non-schema embeddings" do
+      Glancer::Embedding.create!(
+        content: "model content",
+        embedding: [],
+        source_type: "model",
+        source_path: "app/models/user.rb"
+      )
+      expect(described_class.known_table_names).to be_empty
+    end
+
+    it "excludes inflections chunks (paths that contain /)" do
+      Glancer::Embedding.create!(
+        content: "inflections",
+        embedding: [],
+        source_type: "schema",
+        source_path: "config/initializers/inflections.rb"
+      )
+      expect(described_class.known_table_names).to be_empty
+    end
+
+    it "deduplicates table names" do
+      2.times do
+        Glancer::Embedding.create!(
+          content: "table",
+          embedding: [],
+          source_type: "schema",
+          source_path: "/fake/db/schema.rb#orders"
+        )
+      end
+      expect(described_class.known_table_names.count("orders")).to eq(1)
+    end
+
+    it "returns [] when the DB query raises" do
+      allow(Glancer::Embedding).to receive(:where).and_raise(StandardError, "db error")
+      expect(described_class.known_table_names).to eq([])
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::SQLExtractor do
+  describe ".extract" do
+    context "when the text contains a ```sql ... ``` code block" do
+      it "extracts the SQL from a fenced sql block" do
+        text = "Here is the query:\n```sql\nSELECT * FROM users\n```"
+        expect(described_class.extract(text)).to eq("SELECT * FROM users")
+      end
+
+      it "handles multi-line SQL inside the block" do
+        text = "```sql\nSELECT id, name\nFROM users\nWHERE active = 1\n```"
+        result = described_class.extract(text)
+        expect(result).to include("SELECT id, name")
+        expect(result).to include("FROM users")
+        expect(result).to include("WHERE active = 1")
+      end
+
+      it "handles SQL blocks with uppercase SQL language hint" do
+        text = "```SQL\nSELECT 1\n```"
+        expect(described_class.extract(text)).to eq("SELECT 1")
+      end
+
+      it "strips surrounding whitespace from the extracted SQL" do
+        text = "```sql\n  SELECT 1  \n```"
+        expect(described_class.extract(text)).to eq("SELECT 1")
+      end
+    end
+
+    context "when the text contains a plain ``` ... ``` block without a language hint" do
+      it "extracts the SQL from a plain fenced block" do
+        text = "Result:\n```\nSELECT 1\n```"
+        expect(described_class.extract(text)).to eq("SELECT 1")
+      end
+    end
+
+    context "when there is no code block but a SELECT keyword exists" do
+      it "finds the SELECT line and takes everything from there" do
+        text = "Sure, I can help.\nSELECT * FROM orders\nWHERE id = 1"
+        result = described_class.extract(text)
+        expect(result).to start_with("SELECT * FROM orders")
+      end
+
+      it "detects a WITH (CTE) keyword as SQL start" do
+        text = "Here's a CTE:\nWITH cte AS (SELECT 1) SELECT * FROM cte"
+        result = described_class.extract(text)
+        expect(result).to start_with("WITH cte AS")
+      end
+
+      it "detects EXPLAIN keyword as SQL start" do
+        text = "Explanation:\nEXPLAIN SELECT * FROM users"
+        result = described_class.extract(text)
+        expect(result).to start_with("EXPLAIN SELECT")
+      end
+
+      it "is case-insensitive for the SQL start pattern" do
+        text = "some text\nselect * from t"
+        result = described_class.extract(text)
+        expect(result).to include("select * from t")
+      end
+    end
+
+    context "when no SQL can be found" do
+      it "returns the raw text joined into a single line (raw join fallback)" do
+        text = "I cannot generate a query for this request."
+        result = described_class.extract(text)
+        expect(result).to include("I cannot generate")
+      end
+    end
+
+    context "error handling" do
+      it "raises Glancer::Error when an unexpected exception occurs" do
+        allow(described_class).to receive(:extract).and_call_original
+        bad_text = double("bad text")
+        allow(bad_text).to receive(:=~).and_raise(RuntimeError, "unexpected")
+        expect { described_class.extract(bad_text) }.to raise_error(Glancer::Error, /SQL extraction failed/)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Workflow::SQLSanitizer do
+  describe ".ensure_safe!" do
+    context "with safe SELECT queries" do
+      it "passes a simple SELECT without raising" do
+        expect { described_class.ensure_safe!("SELECT * FROM users") }.not_to raise_error
+      end
+
+      it "passes a SELECT with a JOIN" do
+        sql = "SELECT u.id, o.total FROM users u JOIN orders o ON u.id = o.user_id"
+        expect { described_class.ensure_safe!(sql) }.not_to raise_error
+      end
+
+      it "passes a WITH (CTE) query" do
+        sql = "WITH cte AS (SELECT id FROM users) SELECT * FROM cte"
+        expect { described_class.ensure_safe!(sql) }.not_to raise_error
+      end
+    end
+
+    context "with forbidden keywords" do
+      %w[DELETE UPDATE INSERT DROP TRUNCATE ALTER CREATE REPLACE].each do |keyword|
+        it "raises Glancer::Error when SQL contains #{keyword}" do
+          sql = "#{keyword} FROM users"
+          expect { described_class.ensure_safe!(sql) }.to raise_error(Glancer::Error, /#{keyword.downcase}/i)
+        end
+
+        it "raises Glancer::Error regardless of case for #{keyword}" do
+          sql = "#{keyword.downcase} FROM users"
+          expect { described_class.ensure_safe!(sql) }.to raise_error(Glancer::Error)
+        end
+      end
+    end
+
+    context "when a forbidden keyword appears inside a string literal" do
+      it "does NOT raise for DELETE inside a string value" do
+        sql = "SELECT * FROM users WHERE action = 'delete this record'"
+        expect { described_class.ensure_safe!(sql) }.not_to raise_error
+      end
+
+      it "does NOT raise for UPDATE inside a string value" do
+        sql = "SELECT notes FROM logs WHERE notes = 'update pending'"
+        expect { described_class.ensure_safe!(sql) }.not_to raise_error
+      end
+
+      it "does NOT raise for DROP inside a string value" do
+        sql = "SELECT * FROM archive WHERE label = 'drop unused'"
+        expect { described_class.ensure_safe!(sql) }.not_to raise_error
+      end
+    end
+
+    context "when a forbidden keyword appears inside an inline comment" do
+      it "does NOT raise for DELETE inside a -- comment" do
+        sql = "SELECT * FROM users -- delete this comment is harmless"
+        expect { described_class.ensure_safe!(sql) }.not_to raise_error
+      end
+
+      it "does NOT raise for DROP inside a /* */ block comment" do
+        sql = "SELECT 1 /* DROP TABLE users */"
+        expect { described_class.ensure_safe!(sql) }.not_to raise_error
+      end
+    end
+
+    context "with mixed-case forbidden keywords" do
+      it "raises for 'Delete' (title case)" do
+        expect { described_class.ensure_safe!("Delete FROM users") }.to raise_error(Glancer::Error)
+      end
+
+      it "raises for 'dRoP'" do
+        expect { described_class.ensure_safe!("dRoP TABLE users") }.to raise_error(Glancer::Error)
+      end
+    end
+  end
+
+  describe ".strip_strings_and_comments" do
+    it "removes single-quoted string literals" do
+      result = described_class.strip_strings_and_comments("select 'hello world' from t")
+      expect(result).not_to include("hello world")
+    end
+
+    it "removes inline -- comments" do
+      result = described_class.strip_strings_and_comments("select 1 -- this is a comment\nfrom t")
+      expect(result).not_to include("this is a comment")
+    end
+
+    it "removes block /* */ comments" do
+      result = described_class.strip_strings_and_comments("select /* drop tables */ 1")
+      expect(result).not_to include("drop tables")
+    end
+
+    it "preserves the SQL structure outside of stripped sections" do
+      result = described_class.strip_strings_and_comments("select id from users")
+      expect(result).to include("select id from users")
+    end
+  end
+end