Module: BetterRecord::Rspec::Extensions

Defined in:
lib/better_record/rspec/extensions.rb,
lib/better_record/rspec/extensions/boolean_column.rb,
lib/better_record/rspec/extensions/optional_column.rb,
lib/better_record/rspec/extensions/required_column.rb,
lib/better_record/rspec/extensions/has_valid_factory.rb

Instance Method Summary collapse

Instance Method Details

#boolean_column(factory_name, column_name, default: false, keep_boolean_strictness: true) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/better_record/rspec/extensions/boolean_column.rb', line 6

def boolean_column(factory_name, column_name, default: false, keep_boolean_strictness: true)
  b_state = BetterRecord.strict_booleans || false
  
  describe column_name.to_s do
    let(:record) { build(*factory_name) }

    it "defaults to '#{default}'" do
      empty_record = record.class.new
      expect(empty_record.__send__ column_name).to be default
    end
    if keep_boolean_strictness
      it "parses to a #{b_state ? 'two' : 'three'}-state boolean" do
        [ nil, 0, 1, "true", "false", true, false ].each do |val|
          record.__send__"#{column_name}=", val

          expect(record.__send__ column_name).to eq(Boolean.__send__(b_state ? :strict_parse : :parse, val))
        end
      end
    else
      context 'loose booleans' do
        before do
          BetterRecord.strict_booleans = false
        end

        after do
          BetterRecord.strict_booleans = b_state
        end

        it "parses to a three-state boolean" do
          [ nil, 0, 1, "true", "false", true, false ].each do |val|
            record.__send__"#{column_name}=", val

            expect(record.__send__ column_name).to eq(Boolean.parse(val))
          end
        end
      end

      context 'strict booleans' do
        before do
          BetterRecord.strict_booleans = true
        end

        after do
          BetterRecord.strict_booleans = b_state
        end

        it "parses to a two-state boolean" do
          [ nil, 0, 1, "true", "false", true, false ].each do |val|
            record.__send__"#{column_name}=", val

            expect(record.__send__ column_name).to eq(Boolean.strict_parse(val))
          end
        end
      end
    end
  end
end

#has_valid_factory(factory_name, count = 10) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/better_record/rspec/extensions/has_valid_factory.rb', line 6

def has_valid_factory(factory_name, count = 10)
  it "has a valid factory" do
    records = []
    count = (count.to_i == 0) ? 1 : count.to_i
    count.times do
      test_factory = build(*factory_name)
      unless test_factory.valid?
        puts test_factory.errors.full_messages
      end
      expect(test_factory.valid?).to be true
      expect(test_factory.save).to be true
      records << test_factory
    end
    records.each {|f| f.destroy}
  end
end

#optional_column(factory_name, column_name, &blk) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/better_record/rspec/extensions/optional_column.rb', line 6

def optional_column(factory_name, column_name, &blk)
  describe column_name.to_s do
    let(:record) { build(*factory_name) }

    it "is optional" do
      record.__send__"#{column_name}=", nil
      expect(record.valid?).to be true
      expect(record.errors[column_name]).to be_empty
    end

    instance_eval(&blk) if block_given?
  end
end

#required_column(factory_name, column_name, unique: false, in_app_only: false, &blk) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/better_record/rspec/extensions/required_column.rb', line 6

def required_column(factory_name, column_name, unique: false, in_app_only: false, &blk)
  describe column_name.to_s do
    let(:record) { build(*factory_name) }

    it "is required" do
      record.__send__"#{column_name}=", nil
      expect(record.valid?).to be false
      expect(record.errors[column_name]).to include("can't be blank")
      unless in_app_only
        expect { record.save(validate: false) }.to raise_error(ActiveRecord::NotNullViolation)
      end
    end

    if unique
      it "must be unique" do
        expect(record.valid?).to be true
        expect(record.save).to be true

        dupped = nil

        begin
          dupped = record.dup(true)
        rescue ArgumentError
          dupped = record.dup
        end

        expect(dupped.valid?).to be false
        expect(dupped.errors[column_name]).to include("has already been taken")
        expect(dupped.save).to be false

        record.destroy
        expect(dupped.valid?).to be true
        expect(dupped.save).to be true
        dupped.destroy
      end
    end

    instance_eval(&blk) if block_given?
  end
end