Refactor verify_pages_domain_service specs

Add specs for new/disabled pages domain
Extract contexts from examples
Use `let` instead of `set` since domain is being changed
in each example

spec/services/verify_pages_domain_service_spec.rb

@@ -9,88 +9,130 @@ describe VerifyPagesDomainService do
   subject(:service) { described_class.new(domain) }
 
   describe '#execute' do
-    context 'verification code recognition (verified domain)' do
+    where(:domain_sym, :code_sym) do
-      where(:domain_sym, :code_sym) do
+      :domain | :verification_code
-        :domain | :verification_code
+      :domain | :keyed_verification_code
-        :domain | :keyed_verification_code
 
-        :verification_domain | :verification_code
+      :verification_domain | :verification_code
-        :verification_domain | :keyed_verification_code
+      :verification_domain | :keyed_verification_code
-      end
+    end
 
-      with_them do
+    with_them do
-        set(:domain) { create(:pages_domain) }
+      let(:domain_name) { domain.send(domain_sym) }
-
+      let(:verification_code) { domain.send(code_sym) }
-        let(:domain_name) { domain.send(domain_sym) }
-        let(:verification_code) { domain.send(code_sym) }
 
+      shared_examples 'verifies and enables the domain' do
         it 'verifies and enables the domain' do
-          stub_resolver(domain_name => ['something else', verification_code])
-
           expect(service.execute).to eq(status: :success)
+
           expect(domain).to be_verified
           expect(domain).to be_enabled
         end
-
-        it 'verifies and enables when the code is contained partway through a TXT record' do
-          stub_resolver(domain_name => "something #{verification_code} else")
-
-          expect(service.execute).to eq(status: :success)
-          expect(domain).to be_verified
-          expect(domain).to be_enabled
-        end
-
-        it 'does not verify when the code is not present' do
-          stub_resolver(domain_name => 'something else')
-
-          expect(service.execute).to eq(error_status)
-
-          expect(domain).not_to be_verified
-          expect(domain).to be_enabled
-        end
       end
 
-      context 'verified domain' do
+      shared_examples 'successful enablement and verification' do
-        set(:domain) { create(:pages_domain) }
+        context 'when txt record contains verification code' do
+          before do
+            stub_resolver(domain_name => ['something else', verification_code])
+          end
 
-        it 'unverifies (but does not disable) when the right code is not present' do
+          include_examples 'verifies and enables the domain'
-          stub_resolver(domain.domain => 'something else')
-
-          expect(service.execute).to eq(error_status)
-          expect(domain).not_to be_verified
-          expect(domain).to be_enabled
         end
 
-        it 'unverifies (but does not disable) when no records are present' do
+        context 'when txt record contains verification code with other text' do
-          stub_resolver
+          before do
+            stub_resolver(domain_name => "something #{verification_code} else")
+          end
 
-          expect(service.execute).to eq(error_status)
+          include_examples 'verifies and enables the domain'
-          expect(domain).not_to be_verified
-          expect(domain).to be_enabled
         end
       end
 
-      context 'expired domain' do
+      context 'when domain is disabled(or new)' do
-        set(:domain) { create(:pages_domain, :expired) }
+        let(:domain) { create(:pages_domain, :disabled) }
 
-        it 'verifies and enables when the right code is present' do
+        include_examples 'successful enablement and verification'
-          stub_resolver(domain.domain => domain.keyed_verification_code)
 
-          expect(service.execute).to eq(status: :success)
+        shared_examples 'unverifies and disables domain' do
+          it 'unverifies and disables domain' do
+            expect(service.execute).to eq(error_status)
 
-          expect(domain).to be_verified
+            expect(domain).not_to be_verified
-          expect(domain).to be_enabled
+            expect(domain).not_to be_enabled
+          end
         end
 
-        it 'disables when the right code is not present' do
+        context 'when txt record does not contain verification code' do
-          error_status[:message] += '. It is now disabled.'
+          before do
+            stub_resolver(domain_name => 'something else')
+          end
 
-          stub_resolver
+          include_examples 'unverifies and disables domain'
+        end
 
-          expect(service.execute).to eq(error_status)
+        context 'when no txt records are present' do
+          before do
+            stub_resolver
+          end
 
-          expect(domain).not_to be_verified
+          include_examples 'unverifies and disables domain'
-          expect(domain).not_to be_enabled
+        end
+      end
+
+      context 'when domain is verified' do
+        let(:domain) { create(:pages_domain) }
+
+        include_examples 'successful enablement and verification'
+
+        context 'when txt record does not contain verification code' do
+          before do
+            stub_resolver(domain_name => 'something else')
+          end
+
+          it 'unverifies but does not disable domain' do
+            expect(service.execute).to eq(error_status)
+            expect(domain).not_to be_verified
+            expect(domain).to be_enabled
+          end
+        end
+
+        context 'when no txt records are present' do
+          before do
+            stub_resolver
+          end
+
+          it 'unverifies but does not disable domain' do
+            expect(service.execute).to eq(error_status)
+            expect(domain).not_to be_verified
+            expect(domain).to be_enabled
+          end
+        end
+      end
+
+      context 'when domain is expired' do
+        let(:domain) { create(:pages_domain, :expired) }
+
+        context 'when the right code is present' do
+          before do
+            stub_resolver(domain_name => domain.keyed_verification_code)
+          end
+
+          include_examples 'verifies and enables the domain'
+        end
+
+        context 'when the right code is not present' do
+          before do
+            stub_resolver
+          end
+
+          it 'disables domain' do
+            error_status[:message] += '. It is now disabled.'
+
+            expect(service.execute).to eq(error_status)
+
+            expect(domain).not_to be_verified
+            expect(domain).not_to be_enabled
+          end
         end
       end