require 'spec_helper'
require 'flydata-core/postgresql/compatibility_checker'

module FlydataCore
  module Postgresql
    describe 'CompatibilityChecker' do
      let(:database) { 'test_db' }
      let(:tables) { %w(table_1 table_2 table_3) }
      let(:option) do
        { database: database, tables: tables }
      end

      describe SnapshotFunctionChecker do
        let(:subject_object) { described_class.new(option) }

        describe '#check_reesult' do
          let(:result) { [] }
          subject { subject_object.check_result(result) }

          context 'when the function exists' do
            let(:result) do
              [ {'proname' => 'txid_current_snapshot'} ]
            end
            it { expect{subject}.not_to raise_error }
          end

          context 'when the function does not exist' do
            let(:result) do
              []
            end
            it do
              expect{subject}.to raise_error(
                FlydataCore::PostgresqlCompatibilityError,
                /Unsupported PostgreSQL version/
              )
            end
          end
        end
      end



      describe TableExistenceChecker do
        let(:subject_object) { described_class.new(option) }

        describe '#create_query' do
          subject { subject_object.create_query }

          context 'when schema is not set' do
            it { is_expected.to eq <<EOT
SELECT
  table_schema,
  table_name
FROM
  information_schema.tables
WHERE
  table_catalog = 'test_db'
  AND
  table_schema = (select current_schema)
  AND
  table_name in ('table_1','table_2','table_3')
UNION
  SELECT (select current_schema), '';
EOT
            }
          end
          context 'when schema is set' do
            before { option.merge!(schema: 'test_schema') }
            it { is_expected.to eq <<EOT
SELECT
  table_schema,
  table_name
FROM
  information_schema.tables
WHERE
  table_catalog = 'test_db'
  AND
  table_schema = 'test_schema'
  AND
  table_name in ('table_1','table_2','table_3')
UNION
  SELECT 'test_schema', '';
EOT
            }
          end

        end

        describe '#check_reesult' do
          let(:result) { [] }
          subject { subject_object.check_result(result) }

          context 'when all tables exist' do
            let(:result) do
              [ {'table_name' => 'table_1'},
                {'table_name' => 'table_2'},
                {'table_name' => 'table_3'}, ]
            end
            it { expect{subject}.not_to raise_error }
          end

          context 'when some tables does not exist' do
            let(:result) do
              [{"table_name" => "table_2"}]
            end
            it do
              expect{subject}.to raise_error {|e|
                expect(e).to be_kind_of(FlydataCore::PostgresqlCompatibilityError)
                expect(e.to_s.include?("table_1")).to be_truthy
                expect(e.to_s.include?("table_2")).to be_falsey
                expect(e.to_s.include?("table_3")).to be_truthy
              }
            end
          end
        end
      end

      describe PrimaryKeyChecker do
        let(:subject_object) { described_class.new(option) }

        describe '#create_query' do
          subject { subject_object.create_query }

          context 'when schema is not set' do
            it { is_expected.to eq <<EOT
SELECT
  c.table_schema,
  c.table_name
FROM
  pg_index i
  JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
  RIGHT JOIN
    (SELECT
      (table_schema ||'.'|| table_name)::regclass AS regid,
      *
     FROM information_schema.columns
     WHERE
       table_catalog = 'test_db'
       AND table_schema = (select current_schema)
       AND table_name IN ('table_1','table_2','table_3')
    ) c
  ON i.indrelid = c.regid AND a.attname = c.column_name
WHERE
  c.table_catalog = 'test_db'
  AND c.table_schema = (select current_schema)
  AND c.table_name IN ('table_1','table_2','table_3')
GROUP BY
  c.table_schema, c.table_name
HAVING
  SUM(CASE WHEN i.indisprimary='t' THEN 1 ELSE 0 END) = 0 AND
  SUM(CASE WHEN i.indisunique='t' THEN 1 ELSE 0 END) = 0;
EOT
            }
          end

          context 'when schema is set' do
            before { option.merge!(schema: 'test_schema') }
            it { is_expected.to eq <<EOT
SELECT
  c.table_schema,
  c.table_name
FROM
  pg_index i
  JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
  RIGHT JOIN
    (SELECT
      (table_schema ||'.'|| table_name)::regclass AS regid,
      *
     FROM information_schema.columns
     WHERE
       table_catalog = 'test_db'
       AND table_schema = 'test_schema'
       AND table_name IN ('table_1','table_2','table_3')
    ) c
  ON i.indrelid = c.regid AND a.attname = c.column_name
WHERE
  c.table_catalog = 'test_db'
  AND c.table_schema = 'test_schema'
  AND c.table_name IN ('table_1','table_2','table_3')
GROUP BY
  c.table_schema, c.table_name
HAVING
  SUM(CASE WHEN i.indisprimary='t' THEN 1 ELSE 0 END) = 0 AND
  SUM(CASE WHEN i.indisunique='t' THEN 1 ELSE 0 END) = 0;
EOT
            }
          end
        end

        describe '#check_result' do
          let(:result) { [] }
          subject { subject_object.check_result(result) }

          context 'when all tables have pk' do
            let(:result) do
              []
            end
            it { expect{subject}.not_to raise_error }
          end

          context 'when some tables does not have pk' do
            let(:result) do
              [{"table_name" => "table_1"}, {"table_name" => "table_3"}]
            end
            it do
              skip "Primary key check for postgresql currenlty not raises error due to false alarm"
              expect{subject}.to raise_error {|e|
                expect(e).to be_kind_of(FlydataCore::PostgresqlCompatibilityError)
                expect(e.to_s.include?("table_1")).to be_truthy
                expect(e.to_s.include?("table_2")).to be_falsey
                expect(e.to_s.include?("table_3")).to be_truthy
              }
            end
          end
        end
      end

      describe PkOverrideChecker do
        let(:subject_object) { described_class.new(option) }

        describe '#create_query' do
          subject { subject_object.create_query }

          context 'when pk_override is given' do
            before do
              option[:pk_override] = {
                'table_1' => ['id'],
                'table_2' => ['name'],
              }
            end
            it { is_expected.to eq <<EOT
SELECT
  t.table_schema,
  t.table_name,
  col.column_name
FROM
  (select * from information_schema.tables where table_catalog = 'test_db' AND table_schema = (select current_schema) AND table_name in ('table_1','table_2')) t
  LEFT JOIN
  (select * from information_schema.columns where table_catalog = 'test_db' AND table_schema = (select current_schema) AND table_name in ('table_1','table_2')) col
  ON t.table_catalog = col.table_catalog AND t.table_schema = col.table_schema AND t.table_name = col.table_name
ORDER BY
  t.table_name;
EOT
            }
          end

          context 'when no pk override' do
            let(:tables) { %w(table_2) }
            before do
              option.delete(:pk_override)
            end
            it { is_expected.to be_nil }
          end
        end

        describe '#check_reesult' do
          subject { subject_object.check_result(result) }
          let(:result) { [
            {"table_name" => "table_1", "column_name" => "id"},
            {"table_name" => "table_1", "column_name" => "value"},
            {"table_name" => "table_2", "column_name" => "name"},
            {"table_name" => "table_2", "column_name" => "age"},
          ] }

          before do
            option[:pk_override] = pk_override
          end

          context 'when given pk_override exist' do
            let(:pk_override) { {
              'table_1' => ['id'],
              'table_2' => ['name'],
            } }
            it { expect{subject}.not_to raise_error }
          end

          context 'when some columns do not exist' do
            let(:pk_override) { {
              'table_1' => ['id'],
              'table_2' => ['id'],
            } }
            it do
              expect{subject}.to raise_error {|e|
                expect(e).to be_kind_of(FlydataCore::PostgresqlCompatibilityError)
                expect(e.to_s.include?("table_1")).to be_falsey
                expect(e.to_s.include?("table_2")).to be_truthy
              }
            end
          end
        end
      end
    end
  end
end