Use validation matchers for DomainValidator spec (#37662)

spec/validators/domain_validator_spec.rb

@@ -3,73 +3,45 @@
 require 'rails_helper'
 
 RSpec.describe DomainValidator do
-  let(:record) { record_class.new }
+  subject { record_class.new }
 
   context 'with no options' do
     let(:record_class) do
       Class.new do
         include ActiveModel::Validations
 
+        def self.name = 'Record'
+
         attr_accessor :domain
 
         validates :domain, domain: true
       end
     end
 
-    describe '#validate_each' do
+    context 'with a nil value' do
-      context 'with a nil value' do
+      it { is_expected.to allow_value(nil).for(:domain) }
-        it 'does not add errors' do
+    end
-          record.domain = nil
 
-          expect(record).to be_valid
+    context 'with a valid domain' do
-          expect(record.errors).to be_empty
+      it { is_expected.to allow_value('host.example').for(:domain) }
-        end
+    end
-      end
 
-      context 'with a valid domain' do
+    context 'with a domain that is too long' do
-        it 'does not add errors' do
+      let(:long_hostname) { "#{'a' * 300}.com" }
-          record.domain = 'example.com'
 
-          expect(record).to be_valid
+      it { is_expected.to_not allow_value(long_hostname).for(:domain) }
-          expect(record.errors).to be_empty
+    end
-        end
-      end
 
-      context 'with a domain that is too long' do
+    context 'with a domain with an empty segment' do
-        it 'adds an error' do
+      it { is_expected.to_not allow_value('.example.com').for(:domain) }
-          record.domain = "#{'a' * 300}.com"
+    end
 
-          expect(record).to_not be_valid
+    context 'with a domain with an invalid character' do
-          expect(record.errors.where(:domain)).to_not be_empty
+      it { is_expected.to_not allow_value('*.example.com').for(:domain) }
-        end
+    end
-      end
 
-      context 'with a domain with an empty segment' do
+    context 'with a domain that would fail parsing' do
-        it 'adds an error' do
+      it { is_expected.to_not allow_value('/').for(:domain) }
-          record.domain = '.example.com'
-
-          expect(record).to_not be_valid
-          expect(record.errors.where(:domain)).to_not be_empty
-        end
-      end
-
-      context 'with a domain with an invalid character' do
-        it 'adds an error' do
-          record.domain = '*.example.com'
-
-          expect(record).to_not be_valid
-          expect(record.errors.where(:domain)).to_not be_empty
-        end
-      end
-
-      context 'with a domain that would fail parsing' do
-        it 'adds an error' do
-          record.domain = '/'
-
-          expect(record).to_not be_valid
-          expect(record.errors.where(:domain)).to_not be_empty
-        end
-      end
     end
   end
 
@@ -78,48 +50,28 @@ RSpec.describe DomainValidator do
       Class.new do
         include ActiveModel::Validations
 
+        def self.name = 'Record'
+
         attr_accessor :acct
 
         validates :acct, domain: { acct: true }
       end
     end
 
-    describe '#validate_each' do
+    context 'with a nil value' do
-      context 'with a nil value' do
+      it { is_expected.to allow_value(nil).for(:acct) }
-        it 'does not add errors' do
+    end
-          record.acct = nil
 
-          expect(record).to be_valid
+    context 'with no domain' do
-          expect(record.errors).to be_empty
+      it { is_expected.to allow_value('hoge_123').for(:acct) }
-        end
+    end
-      end
 
-      context 'with no domain' do
+    context 'with a valid domain' do
-        it 'does not add errors' do
+      it { is_expected.to allow_value('hoge_123@example.com').for(:acct) }
-          record.acct = 'hoge_123'
+    end
 
-          expect(record).to be_valid
+    context 'with an invalid domain' do
-          expect(record.errors).to be_empty
+      it { is_expected.to_not allow_value('hoge_123@.example.com').for(:acct) }
-        end
-      end
-
-      context 'with a valid domain' do
-        it 'does not add errors' do
-          record.acct = 'hoge_123@example.com'
-
-          expect(record).to be_valid
-          expect(record.errors).to be_empty
-        end
-      end
-
-      context 'with an invalid domain' do
-        it 'adds an error' do
-          record.acct = 'hoge_123@.example.com'
-
-          expect(record).to_not be_valid
-          expect(record.errors.where(:acct)).to_not be_empty
-        end
-      end
     end
   end
 end