sql_query_spec.rb

# frozen_string_literal: true

require 'spec_helper'

describe SqlQuery do
  let(:options) { { email: 'e@mail.dev' } }
  let(:file_name) { :get_player_by_email }
  let(:query) { described_class.new(file_name, options) }

  class Model < ActiveRecord::Base
    self.abstract_class = true
  end

  describe '#initialize' do
    it 'sets instance variables for all options' do
      expect(query.instance_variable_get(:@email)).to eq 'e@mail.dev'
    end

    context 'when options are set not in parentheses' do
      let(:query) { described_class.new(file_name, email: 'e@mail.dev') }

      it 'sets instance variables for all options' do
        expect(query.instance_variable_get(:@email)).to eq 'e@mail.dev'
      end
    end

    context 'when file_name argument is not Symbol or String' do
      let(:file_name) { { do: 'something' } }

      it 'raises ArgumentError' do
        expect { query }
          .to raise_error(ArgumentError,
                          'SQL file name should be String or Symbol')
      end
    end

    context 'with db_connection option' do
      let(:options) { { db_connection: Model.connection } }

      it 'sets connection to requested' do
        expect(query.connection).to eq(Model.connection)
      end
    end
  end

  describe '#file_path' do
    context 'when there is only one file with name' do
      it 'returns path to it' do
        expect(query.send(:file_path)).to include('get_player_by_email.sql.erb')
      end
    end
    context 'when there are no files' do
      let(:file_name) { :not_exists }

      it 'raises error' do
        expect { query.send(:file_path) }
          .to raise_error('File not found: not_exists')
      end
    end

    context 'when there are more than one matching files' do
      let(:file_name) { :duplicated }

      it 'raises error' do
        expect { query.send(:file_path) }
          .to raise_error.with_message(/More than one file found:/)
      end
    end
  end

  describe '#path' do
    context 'when there is sql_file_path option' do
      let(:options) { { sql_file_path: '/path_to_file' } }
      let(:file_name) { 'fname' }

      it 'sets it as dir for file' do
        expect(query.send(:path)).to eq('/path_to_file/fname.{sql.erb,erb.sql}')
      end
    end
  end

  describe '#sql' do
    it 'returns query string' do
      expect(query.sql)
        .to eq("SELECT *\nFROM players\nWHERE email = 'e@mail.dev'\n")
    end

    context 'when file is .erb.sql' do
      let(:options) { { fake: 12 } }
      let(:file_name) { :erb_sql }

      it 'returns query string' do
        expect(query.sql).to eq "SELECT 12\n"
      end
    end
  end

  describe '#pretty_sql' do
    it 'returns query string' do
      expect(query.pretty_sql)
        .to eq("SELECT *\nFROM players\nWHERE email = 'e@mail.dev'\n")
    end
  end

  describe '#explain' do
    let(:explain) { query.explain }
    it 'returns explain string' do
      expect(explain).to include 'EXPLAIN for:'
      expect(explain).to include 'FROM players'
      expect(explain).to include "WHERE email = 'e@mail.dev'"
      expect(explain).to include 'QUERY PLAN'
      expect(explain).to include 'Seq Scan on players'
    end
  end

  describe '#execute' do
    before do
      ActiveRecord::Base.connection.execute(
        "INSERT INTO players (email) VALUES ('e@mail.dev')"
      )
    end

    after do
      ActiveRecord::Base.connection.execute(
        'DELETE FROM players'
      )
    end

    it 'returns data from database' do
      expect(query.execute).to eq [{ 'email' => 'e@mail.dev' }]
    end

    context 'when prepare argument is true' do
      it 'executes prepared query for logs' do
        expect(query).to receive(:prepared_for_logs) { '' }
        query.execute
      end
    end

    context 'when prepare argument is false' do
      it 'executes unchanged sql query' do
        expect(query).not_to receive(:prepared_for_logs)
        query.execute(false)
      end
    end
  end

  describe '#exec_query' do
    before do
      ActiveRecord::Base.connection.execute(
        "INSERT INTO players (email) VALUES ('e@mail.dev')"
      )
    end

    after do
      ActiveRecord::Base.connection.execute(
        'DELETE FROM players'
      )
    end

    it 'returns data from database' do
      expect(query.exec_query).to eq [{ 'email' => 'e@mail.dev' }]
    end

    context 'when prepare argument is true' do
      it 'executes prepared query for logs' do
        expect(query).to receive(:prepared_for_logs) { '' }
        query.exec_query
      end
    end

    context 'when prepare argument is false' do
      it 'executes unchanged sql query' do
        expect(query).not_to receive(:prepared_for_logs)
        query.exec_query(false)
      end
    end
  end

  describe '#partial' do
    let(:file_name) { :get_player_by_email_with_template }
    it 'resolves partials as parts of sql queries' do
      expect(query.sql)
        .to eq("SELECT *\nFROM players\nWHERE players.email = 'e@mail.dev'\n\n")
    end

    context 'when partial name is string with file path' do
      let(:file_name) { :get_player_by_email }

      it 'should find file by whole path and _name' do
        query
        expect(described_class)
          .to receive(:new).with('some/path/to/_file.sql', options) { query }
        query.partial('some/path/to/file.sql', {})
      end
    end
  end

  describe '#prepared_for_logs' do
    it 'returns string without new lines' do
      expect(query.prepared_for_logs)
        .to eq("SELECT * FROM players WHERE email = 'e@mail.dev' ")
    end

    context 'when embedded params have multiple whitespaces' do
      let(:options) { { email: '   e@mail.dev   ' } }
      let(:query) { described_class.new(file_name, options) }

      it 'returns string without multiple whitespaces except embedded params' do
        expect(query.prepared_for_logs)
          .to eq("SELECT * FROM players WHERE email = '   e@mail.dev   ' ")
      end
    end

    context 'when template has multiline ERB blocks' do
      let(:file_name) { :multiline_erb }
      let(:options) { { email: 'test@dev.com', field1: 'val1', field2: 'val2' } }
      let(:query) { described_class.new(file_name, options) }

      it 'processes multiline ERB correctly without syntax errors' do
        expect { query.prepared_for_logs }.not_to raise_error
      end

      it 'collapses SQL whitespace while preserving ERB processing' do
        result = query.prepared_for_logs
        expect(result).to include("'val1' as field1")
        expect(result).to include("'val2' as field2")
        expect(result).not_to include("\n") # All newlines should be collapsed
      end
    end
  end

  describe 'comment removal integration' do
    after do
      # Reset configuration to defaults
      SqlQuery.configure do |config|
        config.remove_comments = :all
        config.remove_comments_from = :all
      end
    end

    context 'with remove_comments_from: :all' do
      before do
        SqlQuery.configure do |config|
          config.remove_comments = :all
          config.remove_comments_from = :all
        end
      end

      it 'removes comments from sql() method' do
        query = described_class.new(:with_single_line_comments, email: 'test@example.com')
        result = query.sql
        expect(result).not_to include('--')
        expect(result).to include('SELECT * FROM players')
      end

      it 'removes comments from prepared_for_logs() method' do
        query = described_class.new(:with_multiline_comments, email: 'test@example.com')
        result = query.prepared_for_logs
        expect(result).not_to include('/*')
        expect(result).not_to include('*/')
      end
    end

    context 'with remove_comments_from: :prepared_for_logs' do
      before do
        SqlQuery.configure do |config|
          config.remove_comments = :all
          config.remove_comments_from = :prepared_for_logs
        end
      end

      it 'keeps comments in sql() method' do
        query = described_class.new(:with_single_line_comments, email: 'test@example.com')
        result = query.sql
        expect(result).to include('--')
      end

      it 'removes comments from prepared_for_logs() method' do
        query = described_class.new(:with_single_line_comments, email: 'test@example.com')
        result = query.prepared_for_logs
        expect(result).not_to include('--')
      end
    end

    context 'with remove_comments_from: :none' do
      before do
        SqlQuery.configure do |config|
          config.remove_comments = :all
          config.remove_comments_from = :none
        end
      end

      it 'keeps comments in sql() method' do
        query = described_class.new(:with_mixed_comments, email: 'test@example.com')
        result = query.sql
        expect(result).to include('--')
        expect(result).to include('/*')
      end

      it 'keeps comments in prepared_for_logs() method' do
        query = described_class.new(:with_mixed_comments, email: 'test@example.com')
        result = query.prepared_for_logs
        expect(result).to include('--')
        expect(result).to include('/*')
      end
    end

    context 'with remove_comments: :oneline' do
      before do
        SqlQuery.configure do |config|
          config.remove_comments = :oneline
          config.remove_comments_from = :all
        end
      end

      it 'removes only single-line comments' do
        query = described_class.new(:with_mixed_comments, email: 'test@example.com')
        result = query.sql
        expect(result).not_to include('--')
        expect(result).to include('/*')
      end
    end

    context 'with remove_comments: :multiline' do
      before do
        SqlQuery.configure do |config|
          config.remove_comments = :multiline
          config.remove_comments_from = :all
        end
      end

      it 'removes only multi-line comments' do
        query = described_class.new(:with_mixed_comments, email: 'test@example.com')
        result = query.sql
        expect(result).to include('--')
        expect(result).not_to include('/*')
        expect(result).not_to include('*/')
      end
    end

    context 'preserving comments in quoted strings' do
      before do
        SqlQuery.configure do |config|
          config.remove_comments = :all
          config.remove_comments_from = :all
        end
      end

      it 'preserves comment syntax in string literals' do
        query = described_class.new(:with_comments_in_strings, email: 'test@example.com')
        result = query.sql
        expect(result).to include("'-- not a comment'")
        expect(result).to include("'/* also not a comment */'")
        expect(result).to include('"column--name"')
      end
    end
  end

  describe '.config' do
    it 'returns configuration instance' do
      expect(described_class.config).to be_kind_of(SqlQuery::Config)
    end

    it 'has default remove_comments setting' do
      expect(described_class.config.remove_comments).to eq(:all)
    end

    it 'has default remove_comments_from setting' do
      expect(described_class.config.remove_comments_from).to eq(:all)
    end
  end
end