1
# frozen_string_literal: true
2

3 17
require "spec_helper"
4

5 17
describe Sequel::Seeder do
6 17
  let!(:environment) { "#{Faker::Lorem.word}_#{Faker::Lorem.word}" }
7 17
  let!(:random_word) { Faker::Lorem.word }
8

9 17
  before do
10 17
    Sequel.extension :seed
11 17
    Sequel.extension :pg_array
12 17
    ArraySpecModel.dataset.delete
13 17
    Sequel::Seed::Base.descendants.clear
14
  end
15

16 17
  before(:all) do
17 15
    dsn = begin
18 17
      if RUBY_PLATFORM == "java"
19 0
        "jdbc:postgresql://localhost/sequel_seed_test"
20
      else
21 17
        "postgres://localhost/sequel_seed_test"
22
      end
23
    end
24 17
    @db = Sequel.connect(dsn)
25 17
    @db.extension(:pg_array)
26 17
    @db.drop_table?(:array_spec_models)
27 17
    @db.create_table(:array_spec_models) do
28 17
      primary_key :id, :serial
29 17
      column :selectors, "text[]"
30 17
      String :sentence
31
    end
32 17
    class ArraySpecModel < Sequel::Model(@db); end
33 17
    ArraySpecModel.dataset = @db[:array_spec_models]
34
    #Sequel::Model.db = @db
35
  end
36

37 17
  after(:each) do
38 17
    ArraySpecModel.dataset.delete
39 17
    Sequel::Seed::Base.descendants.clear
40
  end
41

42 17
  it "should raise an error when there is not any seed file to apply" do
43 17
    Sequel::Seed.setup environment
44

45 17
    expect(Sequel::Seed::Base.descendants.length).to be 0
46 17
    expect { Sequel::Seeder.apply(@db, "/") }.to raise_error("seeder not available for files; please check the configured seed directory \"/\". Also ensure seed files are in YYYYMMDD_seed_file.rb format.")
47 17
    expect(ArraySpecModel.dataset.all.length).to be 0
48
  end
49

50 17
  describe "Seeds defined using Ruby code (.rb extension)" do
51 17
    describe "environment references should be indistinguishable between Symbol and String" do
52 17
      context "when the environment is defined using a String" do
53 17
        it "should apply the Seed accordingly" do
54 17
          Sequel::Seed.setup environment
55

56 17
          File.open("#{seed_test_dir}/#{seed_file_name}.rb", "w+") do |f|
57 17
            f.puts "Sequel.seed(:#{environment}) do"
58 17
            f.puts "  def run"
59 17
            f.puts "    ArraySpecModel.create \\"
60 17
            f.puts "      :sentence => \"environment defined by String\","
61 17
            f.puts "      :selectors => [\".body\", \".header\", \".string\"]"
62 17
            f.puts "  end"
63 17
            f.puts "end"
64
          end
65

66 17
          expect(Sequel::Seed::Base.descendants.length).to be 0
67 17
          expect(Sequel::Seeder.seeder_class(seed_test_dir)).to be Sequel::TimestampSeeder
68 17
          expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
69 17
          expect(Sequel::Seed::Base.descendants.length).to be 1
70 17
          expect(ArraySpecModel.dataset.all.length).to be 1
71 16
          expect(ArraySpecModel.dataset.first.sentence).to eq "environment defined by String"
72 16
          expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".string")
73
        end
74
      end
75

76 17
      context "when the Seed is defined using a String" do
77 17
        it "should apply the Seed accordingly" do
78 17
          Sequel::Seed.setup environment.to_sym
79

80 17
          File.open("#{seed_test_dir}/#{seed_file_name}.rb", "w+") do |f|
81 17
            f.puts "Sequel.seed(\"#{environment}\") do"
82 17
            f.puts "  def run"
83 17
            f.puts "    ArraySpecModel.create \\"
84 17
            f.puts "      :sentence => \"Seed defined by String\","
85 17
            f.puts "      :selectors => [\".body\", \".header\", \".environment\"]"
86 17
            f.puts "  end"
87 17
            f.puts "end"
88
          end
89

90 17
          expect(Sequel::Seed::Base.descendants.length).to be 0
91 17
          expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
92 17
          expect(Sequel::Seed::Base.descendants.length).to be 1
93 17
          expect(ArraySpecModel.dataset.all.length).to be 1
94 17
          expect(ArraySpecModel.dataset.first.sentence).to eq "Seed defined by String"
95 17
          expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".environment")
96
        end
97
      end
98

99 17
      context "when both Seed and environment are defined using a String" do
100 17
        it "should apply the Seed accordingly" do
101 17
          Sequel::Seed.setup environment
102

103 17
          File.open("#{seed_test_dir}/#{seed_file_name}.rb", "w+") do |f|
104 17
            f.puts "Sequel.seed(\"#{environment}\") do"
105 17
            f.puts "  def run"
106 17
            f.puts "    ArraySpecModel.create \\"
107 17
            f.puts "      :sentence => \"Seed and environment defined by String\","
108 17
            f.puts "      :selectors => [\".body\", \".header\", \".string\", \".environment\"]"
109 17
            f.puts "  end"
110 17
            f.puts "end"
111
          end
112

113 17
          expect(Sequel::Seed::Base.descendants.length).to be 0
114 17
          expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
115 17
          expect(Sequel::Seed::Base.descendants.length).to be 1
116 17
          expect(ArraySpecModel.dataset.all.length).to be 1
117 17
          expect(ArraySpecModel.dataset.first.sentence).to eq "Seed and environment defined by String"
118 17
          expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".string", ".environment")
119
        end
120
      end
121

122 17
      context "when both Seed and environment are defined using a Symbol" do
123 17
        it "should apply the Seed accordingly" do
124 17
          Sequel::Seed.setup environment.to_sym
125

126 17
          File.open("#{seed_test_dir}/#{seed_file_name}.rb", "w+") do |f|
127 17
            f.puts "Sequel.seed(:#{environment}) do"
128 17
            f.puts "  def run"
129 17
            f.puts "    ArraySpecModel.create \\"
130 17
            f.puts "      :sentence => \"Seed and environment defined by Symbol\","
131 17
            f.puts "      :selectors => [\".body\", \".header\", \".string\", \".environment\", \".symbol\"]"
132 17
            f.puts "  end"
133 17
            f.puts "end"
134
          end
135

136 17
          expect(Sequel::Seed::Base.descendants.length).to be 0
137 17
          expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
138 17
          expect(Sequel::Seed::Base.descendants.length).to be 1
139 17
          expect(ArraySpecModel.dataset.all.length).to be 1
140 16
          expect(ArraySpecModel.dataset.first.sentence).to eq "Seed and environment defined by Symbol"
141 16
          expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".string", ".environment", ".symbol")
142
        end
143
      end
144

145 17
      context "when the environment is defined using a String and we have a wildcard Seed" do
146 17
        it "should apply the Seed accordingly" do
147 17
          Sequel::Seed.setup environment
148

149 17
          File.open("#{seed_test_dir}/#{seed_file_name}.rb", "w+") do |f|
150 17
            f.puts "Sequel.seed do"
151 17
            f.puts "  def run"
152 17
            f.puts "    ArraySpecModel.create \\"
153 17
            f.puts "      :sentence => \"Wildcard Seed and environment defined by String\","
154 17
            f.puts "      :selectors => [\".body\", \".header\", \".string\", \".wildcard\"]"
155 17
            f.puts "  end"
156 17
            f.puts "end"
157
          end
158

159 17
          expect(Sequel::Seed::Base.descendants.length).to be 0
160 17
          expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
161 17
          expect(Sequel::Seed::Base.descendants.length).to be 1
162 17
          expect(ArraySpecModel.dataset.all.length).to be 1
163 17
          expect(ArraySpecModel.dataset.first.sentence).to eq "Wildcard Seed and environment defined by String"
164 17
          expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".string", ".wildcard")
165
        end
166
      end
167
    end
168

169 17
    context "when there\"s a Seed created" do
170 17
      it "should change the database accordingly only once" do
171 17
        Sequel::Seed.setup environment
172

173 17
        File.open("#{seed_test_dir}/#{seed_file_name}.rb", "w+") do |f|
174 17
          f.puts "Sequel.seed do"
175 17
          f.puts "  def run"
176 17
          f.puts "    ArraySpecModel.create \\"
177 17
          f.puts "      :sentence => \"should have changed (from Ruby file)\","
178 17
          f.puts "      :selectors => [\".body\", \".header\", \".string\", \".ruby\"]"
179 17
          f.puts "  end"
180 17
          f.puts "end"
181
        end
182

183 17
        expect(Sequel::Seed::Base.descendants.length).to be 0
184 17
        expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
185 17
        expect(Sequel::Seed::Base.descendants.length).to be 1
186 17
        expect(ArraySpecModel.dataset.all.length).to be 1
187 15
        expect(ArraySpecModel.dataset.first.sentence).to eq "should have changed (from Ruby file)"
188 15
        expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".string", ".ruby")
189
        # Once again
190 15
        expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
191 15
        expect(Sequel::Seed::Base.descendants.length).to be 0
192 15
        expect(ArraySpecModel.dataset.all.length).to be 1
193 15
        expect(ArraySpecModel.dataset.first.sentence).to eq "should have changed (from Ruby file)"
194 15
        expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".string", ".ruby")
195
      end
196
    end
197

198 17
    context "when the specified Seed is not applicable to the given environment" do
199 17
      it "should not make any change to the database" do
200 17
        Sequel::Seed.setup environment
201

202 17
        File.open("#{seed_test_dir}/#{seed_file_name}.rb", "w+") do |f|
203 17
          f.puts "Sequel.seed(:another_#{Faker::Lorem.word}_word) do"
204 17
          f.puts "  def run"
205 17
          f.puts "    ArraySpecModel.create \\"
206 17
          f.puts "      :sentence => \"should not have changed (from Ruby file)\","
207 17
          f.puts "      :selectors => [\".body\", \".header\", \".unchanged\", \".ruby\"]"
208 17
          f.puts "  end"
209 17
          f.puts "end"
210
        end
211

212 17
        expect(Sequel::Seed::Base.descendants.length).to be 0
213 17
        expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
214 17
        expect(ArraySpecModel.dataset.all.length).to be 0
215
      end
216
    end
217
  end
218

219 17
  describe "Seeds defined using YAML code (.{yaml,yml} extension)" do
220 17
    it "should apply a basic YAML Seed if it was specified for the given environment" do
221 17
      Sequel::Seed.setup environment
222

223 17
      File.open("#{seed_test_dir}/#{seed_file_name}.yml", "w+") do |f|
224 17
        f.puts "environment: :#{environment}"
225 17
        f.puts "array_spec_model:"
226 17
        f.puts "  sentence: \"should have changed (from YAML file) #{random_word}\""
227 17
        f.puts "  selectors:"
228 17
        f.puts "    - \".body\""
229 17
        f.puts "    - \".header\""
230 17
        f.puts "    - \".yaml\""
231 17
        f.puts ""
232
      end
233

234 17
      expect(Sequel::Seed::Base.descendants.length).to be 0
235 17
      expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
236 17
      expect(Sequel::Seed::Base.descendants.length).to be 1
237 17
      expect(ArraySpecModel.dataset.all.length).to be 1
238 17
      expect(ArraySpecModel.dataset.first.sentence).to eq "should have changed (from YAML file) #{random_word}"
239 17
      expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".yaml")
240
    end
241

242 17
    it "should apply a YAML Seed if it was specified for the given environment" do
243 17
      Sequel::Seed.setup environment
244

245 17
      File.open("#{seed_test_dir}/#{seed_file_name}.yml", "w+") do |f|
246 17
        f.puts "environment: :#{environment}"
247 17
        f.puts "model:"
248 17
        f.puts "  class: \"ArraySpecModel\""
249 17
        f.puts "  entries:"
250 17
        f.puts "    -"
251 17
        f.puts "      sentence: \"should have changed (from YAML file) #{random_word}\""
252 17
        f.puts "      selectors:"
253 17
        f.puts "        - .body"
254 17
        f.puts "        - .header"
255 17
        f.puts "        - .yaml"
256 17
        f.puts ""
257
      end
258

259 17
      expect(Sequel::Seed::Base.descendants.length).to be 0
260 17
      expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
261 17
      expect(Sequel::Seed::Base.descendants.length).to be 1
262 17
      expect(ArraySpecModel.dataset.all.length).to be 1
263 17
      expect(ArraySpecModel.dataset.first.sentence).to eq "should have changed (from YAML file) #{random_word}"
264 17
      expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".yaml")
265
    end
266

267 17
    it "should apply a YAML file with multiple Seeds descriptors if they were specified for the given environment" do
268 17
      Sequel::Seed.setup environment
269

270 17
      File.open("#{seed_test_dir}/#{seed_file_name}.yml", "w+") do |f|
271 17
        f.puts "-"
272 17
        f.puts "  environment: :#{environment}"
273 17
        f.puts "  model:"
274 17
        f.puts "    class: \"ArraySpecModel\""
275 17
        f.puts "    entries:"
276 17
        f.puts "      -"
277 17
        f.puts "        sentence: \"should have changed (from YAML file) #{random_word}\""
278 17
        f.puts "        selectors:"
279 17
        f.puts "          - .body"
280 17
        f.puts "          - .header"
281 17
        f.puts "          - .yaml"
282 17
        f.puts "          - .environment"
283 17
        f.puts "-"
284 17
        f.puts "  environment: :another_#{environment}"
285 17
        f.puts "  array_spec_model:"
286 17
        f.puts "    sentence: \"should not have changed (from YAML file) #{random_word}\""
287 17
        f.puts "    selectors:"
288 17
        f.puts "      - .body"
289 17
        f.puts "      - .header"
290 17
        f.puts "      - .yaml"
291 17
        f.puts "      - .another_environment"
292 17
        f.puts ""
293
      end
294

295 17
      expect(Sequel::Seed::Base.descendants.length).to be 0
296 17
      expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
297 17
      expect(Sequel::Seed::Base.descendants.length).to be 1
298 17
      expect(ArraySpecModel.dataset.all.length).to be 1
299 17
      expect(ArraySpecModel.dataset.first.sentence).to eq "should have changed (from YAML file) #{random_word}"
300 17
      expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".yaml", ".environment")
301
    end
302

303 17
    it "should not apply a basic Seed if it was not specified for the given environment" do
304 17
      Sequel::Seed.setup environment
305

306 17
      File.open("#{seed_test_dir}/#{seed_file_name}.yml", "w+") do |f|
307 17
        f.puts "environment: :another_environment_#{Faker::Lorem.word}"
308 17
        f.puts "array_spec_model:"
309 17
        f.puts "  sentence: \"should not have changed (from YAML file)\""
310 17
        f.puts "  selectors:"
311 17
        f.puts "    - .body"
312 17
        f.puts "    - .header"
313 17
        f.puts "    - .yaml"
314 17
        f.puts ""
315
      end
316

317 17
      expect(Sequel::Seed::Base.descendants.length).to be 0
318 17
      expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
319 17
      expect(Sequel::Seed::Base.descendants.length).to be 1
320 17
      expect(ArraySpecModel.dataset.all.length).to be 0
321
    end
322
  end
323

324 17
  describe "Seeds defined using JSON code (.json extension)" do
325 17
    it "should apply a basic JSON Seed if it was specified for the given environment" do
326 17
      Sequel::Seed.setup environment
327

328 17
      File.open("#{seed_test_dir}/#{seed_file_name}.json", "w+") do |f|
329 17
        f.puts "{"
330 17
        f.puts "  \"environment\": \"#{environment}\","
331 17
        f.puts "  \"array_spec_model\": {"
332 17
        f.puts "    \"sentence\": \"should have changed (from JSON file) #{random_word}\","
333 17
        f.puts "    \"selectors\": [\".body\", \".header\", \".json\"]"
334 17
        f.puts "  }"
335 17
        f.puts "}"
336 17
        f.puts ""
337
      end
338

339 17
      expect(Sequel::Seed::Base.descendants.length).to be 0
340 17
      expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
341 17
      expect(Sequel::Seed::Base.descendants.length).to be 1
342 17
      expect(ArraySpecModel.dataset.all.length).to be 1
343 17
      expect(ArraySpecModel.dataset.first.sentence).to eq "should have changed (from JSON file) #{random_word}"
344 17
      expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".json")
345
    end
346

347 17
    it "should apply a JSON Seed if it was specified for the given environment" do
348 17
      Sequel::Seed.setup environment
349

350 17
      File.open("#{seed_test_dir}/#{seed_file_name}.json", "w+") do |f|
351 17
        f.puts "{"
352 17
        f.puts "  \"environment\": \"#{environment}\","
353 17
        f.puts "  \"model\": {"
354 17
        f.puts "    \"class\": \"ArraySpecModel\","
355 17
        f.puts "    \"entries\": ["
356 17
        f.puts "      {"
357 17
        f.puts "        \"sentence\": \"should have changed (from JSON file) #{random_word}\","
358 17
        f.puts "        \"selectors\": [\".body\", \".header\", \".json\"]"
359 17
        f.puts "      }"
360 17
        f.puts "    ]"
361 17
        f.puts "  }"
362 17
        f.puts "}"
363 17
        f.puts ""
364
      end
365

366 17
      expect(Sequel::Seed::Base.descendants.length).to be 0
367 17
      expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
368 17
      expect(Sequel::Seed::Base.descendants.length).to be 1
369 17
      expect(ArraySpecModel.dataset.all.length).to be 1
370 17
      expect(ArraySpecModel.dataset.first.sentence).to eq "should have changed (from JSON file) #{random_word}"
371 17
      expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".json")
372
    end
373

374 17
    it "should apply a JSON file with multiple Seeds descriptors if they were specified for the given environment" do
375 17
      Sequel::Seed.setup environment
376

377 17
      File.open("#{seed_test_dir}/#{seed_file_name}.json", "w+") do |f|
378 17
        f.puts "["
379 17
        f.puts "  {"
380 17
        f.puts "    \"environment\": \"#{environment}\","
381 17
        f.puts "    \"model\": {"
382 17
        f.puts "      \"class\": \"ArraySpecModel\","
383 17
        f.puts "      \"entries\": ["
384 17
        f.puts "        {"
385 17
        f.puts "          \"sentence\": \"should have changed (from JSON file) #{random_word}\","
386 17
        f.puts "          \"selectors\": [\".body\", \".header\", \".json\", \".environment\"]"
387 17
        f.puts "        }"
388 17
        f.puts "      ]"
389 17
        f.puts "    }"
390 17
        f.puts "  },"
391 17
        f.puts "  {"
392 17
        f.puts "    \"environment\": \"another_#{environment}\","
393 17
        f.puts "    \"model\": {"
394 17
        f.puts "      \"class\": \"ArraySpecModel\","
395 17
        f.puts "      \"entries\": ["
396 17
        f.puts "        {"
397 17
        f.puts "          \"sentence\": \"should have changed (from JSON file) #{random_word}\","
398 17
        f.puts "          \"selectors\": [\".body\", \".header\", \".json\", \".another_environment\"]"
399 17
        f.puts "        }"
400 17
        f.puts "      ]"
401 17
        f.puts "    }"
402 17
        f.puts "  }"
403 17
        f.puts "]"
404 17
        f.puts ""
405
      end
406

407 17
      expect(Sequel::Seed::Base.descendants.length).to be 0
408 17
      expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
409 17
      expect(Sequel::Seed::Base.descendants.length).to be 1
410 17
      expect(ArraySpecModel.dataset.all.length).to be 1
411 17
      expect(ArraySpecModel.dataset.first.sentence).to eq "should have changed (from JSON file) #{random_word}"
412 17
      expect(ArraySpecModel.dataset.first.selectors).to contain_exactly(".body", ".header", ".json", ".environment")
413
    end
414

415 17
    it "should not apply a basic Seed if it was not specified for the given environment" do
416 17
      Sequel::Seed.setup environment
417

418 17
      File.open("#{seed_test_dir}/#{seed_file_name}.json", "w+") do |f|
419 17
        f.puts "{"
420 17
        f.puts "  \"environment\": \"another_#{environment}\","
421 17
        f.puts "  \"array_spec_model\": {"
422 17
        f.puts "    \"sentence\": \"should not changed (from JSON file) #{random_word}\","
423 17
        f.puts "    \"selectors\": [\".body\", \".header\", \".json\"]"
424 17
        f.puts "  }"
425 17
        f.puts "}"
426 17
        f.puts ""
427
      end
428

429 17
      expect(Sequel::Seed::Base.descendants.length).to be 0
430 17
      expect { Sequel::Seeder.apply(@db, seed_test_dir) }.not_to raise_error
431 17
      expect(Sequel::Seed::Base.descendants.length).to be 1
432 17
      expect(ArraySpecModel.dataset.all.length).to be 0
433
    end
434
  end
435
end

Read our documentation on viewing source code .

Loading