Read about our upcoming Code of Conduct on this issue

database_spec.rb 11.1 KB
Newer Older
1
2
require 'spec_helper'

3
describe Gitlab::Database do
Yorick Peterse's avatar
Yorick Peterse committed
4
5
6
7
8
9
10
11
12
13
  before do
    stub_const('MigrationTest', Class.new { include Gitlab::Database })
  end

  describe '.config' do
    it 'returns a Hash' do
      expect(described_class.config).to be_an_instance_of(Hash)
    end
  end

14
15
16
17
18
19
  describe '.adapter_name' do
    it 'returns the name of the adapter' do
      expect(described_class.adapter_name).to be_an_instance_of(String)
    end
  end

20
21
22
23
24
25
26
27
28
29
30
31
32
  # These are just simple smoke tests to check if the methods work (regardless
  # of what they may return).
  describe '.mysql?' do
    subject { described_class.mysql? }

    it { is_expected.to satisfy { |val| val == true || val == false } }
  end

  describe '.postgresql?' do
    subject { described_class.postgresql? }

    it { is_expected.to satisfy { |val| val == true || val == false } }
  end
33
34

  describe '.version' do
35
36
37
38
39
40
    around do |example|
      described_class.instance_variable_set(:@version, nil)
      example.run
      described_class.instance_variable_set(:@version, nil)
    end

41
42
    context "on mysql" do
      it "extracts the version number" do
43
44
        allow(described_class).to receive(:database_version)
          .and_return("5.7.12-standard")
45
46
47
48
49
50
51

        expect(described_class.version).to eq '5.7.12-standard'
      end
    end

    context "on postgresql" do
      it "extracts the version number" do
52
53
        allow(described_class).to receive(:database_version)
          .and_return("PostgreSQL 9.4.4 on x86_64-apple-darwin14.3.0")
54
55
56
57

        expect(described_class.version).to eq '9.4.4'
      end
    end
58
59
60
61
62
63
64
65

    it 'memoizes the result' do
      count = ActiveRecord::QueryRecorder
        .new { 2.times { described_class.version } }
        .count

      expect(count).to eq(1)
    end
66
  end
67

68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
  describe '.join_lateral_supported?' do
    it 'returns false when using MySQL' do
      allow(described_class).to receive(:postgresql?).and_return(false)

      expect(described_class.join_lateral_supported?).to eq(false)
    end

    it 'returns false when using PostgreSQL 9.2' do
      allow(described_class).to receive(:postgresql?).and_return(true)
      allow(described_class).to receive(:version).and_return('9.2.1')

      expect(described_class.join_lateral_supported?).to eq(false)
    end

    it 'returns true when using PostgreSQL 9.3.0 or newer' do
      allow(described_class).to receive(:postgresql?).and_return(true)
      allow(described_class).to receive(:version).and_return('9.3.0')

      expect(described_class.join_lateral_supported?).to eq(true)
    end
  end

90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
  describe '.replication_slots_supported?' do
    it 'returns false when using MySQL' do
      allow(described_class).to receive(:postgresql?).and_return(false)

      expect(described_class.replication_slots_supported?).to eq(false)
    end

    it 'returns false when using PostgreSQL 9.3' do
      allow(described_class).to receive(:postgresql?).and_return(true)
      allow(described_class).to receive(:version).and_return('9.3.1')

      expect(described_class.replication_slots_supported?).to eq(false)
    end

    it 'returns true when using PostgreSQL 9.4.0 or newer' do
      allow(described_class).to receive(:postgresql?).and_return(true)
      allow(described_class).to receive(:version).and_return('9.4.0')

      expect(described_class.replication_slots_supported?).to eq(true)
    end
  end

112
113
  describe '.nulls_last_order' do
    context 'when using PostgreSQL' do
114
115
116
      before do
        expect(described_class).to receive(:postgresql?).and_return(true)
      end
117
118
119
120
121
122

      it { expect(described_class.nulls_last_order('column', 'ASC')).to eq 'column ASC NULLS LAST'}
      it { expect(described_class.nulls_last_order('column', 'DESC')).to eq 'column DESC NULLS LAST'}
    end

    context 'when using MySQL' do
123
124
125
      before do
        expect(described_class).to receive(:postgresql?).and_return(false)
      end
126
127
128
129
130
131

      it { expect(described_class.nulls_last_order('column', 'ASC')).to eq 'column IS NULL, column ASC'}
      it { expect(described_class.nulls_last_order('column', 'DESC')).to eq 'column DESC'}
    end
  end

132
133
  describe '.nulls_first_order' do
    context 'when using PostgreSQL' do
134
135
136
      before do
        expect(described_class).to receive(:postgresql?).and_return(true)
      end
137
138
139
140
141
142

      it { expect(described_class.nulls_first_order('column', 'ASC')).to eq 'column ASC NULLS FIRST'}
      it { expect(described_class.nulls_first_order('column', 'DESC')).to eq 'column DESC NULLS FIRST'}
    end

    context 'when using MySQL' do
143
144
145
      before do
        expect(described_class).to receive(:postgresql?).and_return(false)
      end
146
147
148
149
150
151

      it { expect(described_class.nulls_first_order('column', 'ASC')).to eq 'column ASC'}
      it { expect(described_class.nulls_first_order('column', 'DESC')).to eq 'column IS NULL, column DESC'}
    end
  end

152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
  describe '.with_connection_pool' do
    it 'creates a new connection pool and disconnect it after used' do
      closed_pool = nil

      described_class.with_connection_pool(1) do |pool|
        pool.with_connection do |connection|
          connection.execute('SELECT 1 AS value')
        end

        expect(pool).to be_connected

        closed_pool = pool
      end

      expect(closed_pool).not_to be_connected
    end

    it 'disconnects the pool even an exception was raised' do
      error = Class.new(RuntimeError)
      closed_pool = nil

      begin
        described_class.with_connection_pool(1) do |pool|
          pool.with_connection do |connection|
            connection.execute('SELECT 1 AS value')
          end

          closed_pool = pool

          raise error.new('boom')
        end
      rescue error
      end

      expect(closed_pool).not_to be_connected
    end
  end

190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
  describe '.bulk_insert' do
    before do
      allow(described_class).to receive(:connection).and_return(connection)
      allow(connection).to receive(:quote_column_name, &:itself)
      allow(connection).to receive(:quote, &:itself)
      allow(connection).to receive(:execute)
    end

    let(:connection) { double(:connection) }

    let(:rows) do
      [
        { a: 1, b: 2, c: 3 },
        { c: 6, a: 4, b: 5 }
      ]
    end

    it 'does nothing with empty rows' do
      expect(connection).not_to receive(:execute)

      described_class.bulk_insert('test', [])
    end

    it 'uses the ordering from the first row' do
      expect(connection).to receive(:execute) do |sql|
        expect(sql).to include('(1, 2, 3)')
        expect(sql).to include('(4, 5, 6)')
      end

      described_class.bulk_insert('test', rows)
    end

    it 'quotes column names' do
      expect(connection).to receive(:quote_column_name).with(:a)
      expect(connection).to receive(:quote_column_name).with(:b)
      expect(connection).to receive(:quote_column_name).with(:c)

      described_class.bulk_insert('test', rows)
    end

    it 'quotes values' do
      1.upto(6) do |i|
        expect(connection).to receive(:quote).with(i)
      end

      described_class.bulk_insert('test', rows)
    end
237

238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
    it 'does not quote values of a column in the disable_quote option' do
      [1, 2, 4, 5].each do |i|
        expect(connection).to receive(:quote).with(i)
      end

      described_class.bulk_insert('test', rows, disable_quote: :c)
    end

    it 'does not quote values of columns in the disable_quote option' do
      [2, 5].each do |i|
        expect(connection).to receive(:quote).with(i)
      end

      described_class.bulk_insert('test', rows, disable_quote: [:a, :c])
    end

254
255
256
    it 'handles non-UTF-8 data' do
      expect { described_class.bulk_insert('test', [{ a: "\255" }]) }.not_to raise_error
    end
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276

    context 'when using PostgreSQL' do
      before do
        allow(described_class).to receive(:mysql?).and_return(false)
      end

      it 'allows the returning of the IDs of the inserted rows' do
        result = double(:result, values: [['10']])

        expect(connection)
          .to receive(:execute)
          .with(/RETURNING id/)
          .and_return(result)

        ids = described_class
          .bulk_insert('test', [{ number: 10 }], return_ids: true)

        expect(ids).to eq([10])
      end
    end
277
278
  end

279
280
281
282
  describe '.create_connection_pool' do
    it 'creates a new connection pool with specific pool size' do
      pool = described_class.create_connection_pool(5)

283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
      begin
        expect(pool)
          .to be_kind_of(ActiveRecord::ConnectionAdapters::ConnectionPool)

        expect(pool.spec.config[:pool]).to eq(5)
      ensure
        pool.disconnect!
      end
    end

    it 'allows setting of a custom hostname' do
      pool = described_class.create_connection_pool(5, '127.0.0.1')

      begin
        expect(pool.spec.config[:host]).to eq('127.0.0.1')
      ensure
        pool.disconnect!
      end
301
302
303
    end
  end

304
305
306
307
308
309
310
311
312
313
314
  describe '.cached_column_exists?' do
    it 'only retrieves data once' do
      expect(ActiveRecord::Base.connection).to receive(:columns).once.and_call_original

      2.times do
        expect(described_class.cached_column_exists?(:projects, :id)).to be_truthy
        expect(described_class.cached_column_exists?(:projects, :bogus_column)).to be_falsey
      end
    end
  end

315
316
  describe '.cached_table_exists?' do
    it 'only retrieves data once per table' do
317
318
319
320
321
322
323
      if Gitlab.rails5?
        expect(ActiveRecord::Base.connection).to receive(:data_source_exists?).with(:projects).once.and_call_original
        expect(ActiveRecord::Base.connection).to receive(:data_source_exists?).with(:bogus_table_name).once.and_call_original
      else
        expect(ActiveRecord::Base.connection).to receive(:table_exists?).with(:projects).once.and_call_original
        expect(ActiveRecord::Base.connection).to receive(:table_exists?).with(:bogus_table_name).once.and_call_original
      end
324
325
326
327
328
329
330
331

      2.times do
        expect(described_class.cached_table_exists?(:projects)).to be_truthy
        expect(described_class.cached_table_exists?(:bogus_table_name)).to be_falsey
      end
    end
  end

332
333
334
335
  describe '#true_value' do
    it 'returns correct value for PostgreSQL' do
      expect(described_class).to receive(:postgresql?).and_return(true)

336
      expect(described_class.true_value).to eq "'t'"
337
338
339
340
341
    end

    it 'returns correct value for MySQL' do
      expect(described_class).to receive(:postgresql?).and_return(false)

342
      expect(described_class.true_value).to eq 1
343
344
345
346
347
348
349
    end
  end

  describe '#false_value' do
    it 'returns correct value for PostgreSQL' do
      expect(described_class).to receive(:postgresql?).and_return(true)

350
      expect(described_class.false_value).to eq "'f'"
351
352
353
354
355
    end

    it 'returns correct value for MySQL' do
      expect(described_class).to receive(:postgresql?).and_return(false)

356
      expect(described_class.false_value).to eq 0
357
358
    end
  end
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380

  describe '#sanitize_timestamp' do
    let(:max_timestamp) { Time.at((1 << 31) - 1) }

    subject { described_class.sanitize_timestamp(timestamp) }

    context 'with a timestamp smaller than MAX_TIMESTAMP_VALUE' do
      let(:timestamp) { max_timestamp - 10.years }

      it 'returns the given timestamp' do
        expect(subject).to eq(timestamp)
      end
    end

    context 'with a timestamp larger than MAX_TIMESTAMP_VALUE' do
      let(:timestamp) { max_timestamp + 1.second }

      it 'returns MAX_TIMESTAMP_VALUE' do
        expect(subject).to eq(max_timestamp)
      end
    end
  end
381
end