Fix test failures: complete terminology rebrand in specs

- Fix require statement in route_policy_create_message_spec.rb
- Update all test references from old to new terminology:
  * selectors → sources
  * selector_resource_guids → source_guids
  * selector_resource → source (in include parameters)
  * enforce_access_rules → enforce_route_policies
  * access_rules_scope → route_policies_scope
  * route_access_rules → route_policies (table name)
- Fix Rubocop indentation in route_policies_list_message_spec.rb

Addresses CI/CD test failures in PR #4910.

Author: rkoster

spec/request/route_policies_spec.rb

@@ -9,8 +9,8 @@
   let(:mtls_domain) do
     VCAP::CloudController::PrivateDomain.make(
       owning_organization: org,
-      enforce_access_rules: true,
-      access_rules_scope: 'space'
+      enforce_route_policies: true,
+      route_policies_scope: 'space'
     )
   end
   let(:regular_domain) do
@@ -82,7 +82,7 @@ def expected_rule_json(rule)
       end
     end
 
-    context 'when the domain does not have enforce_access_rules enabled' do
+    context 'when the domain does not have enforce_route_policies enabled' do
       let(:request_body) do
         {
           source: "cf:app:#{valid_uuid}",
@@ -212,7 +212,7 @@ def expected_rule_json(rule)
         # Simulate a race condition where the DB unique constraint catches the duplicate
         # after validation passes but before the insert commits
         allow_any_instance_of(VCAP::CloudController::RoutePolicy).to receive(:save).and_raise(
-          Sequel::UniqueConstraintViolation.new('UNIQUE constraint failed: route_access_rules.route_id, route_access_rules.source')
+          Sequel::UniqueConstraintViolation.new('UNIQUE constraint failed: route_policies.route_id, route_policies.source')
         )
 
         post '/v3/route_policies', {
@@ -236,11 +236,11 @@ def expected_rule_json(rule)
     end
 
     it 'returns the access rule' do
-      get "/v3/route_policies/#{access_rule.guid}", nil, admin_header
+      get "/v3/route_policies/#{route_policy.guid}", nil, admin_header
 
       expect(last_response.status).to eq(200)
       parsed = Oj.load(last_response.body)
-      expect(parsed['guid']).to eq(access_rule.guid)
+      expect(parsed['guid']).to eq(route_policy.guid)
       expect(parsed['source']).to eq("cf:app:#{valid_uuid}")
     end
 
@@ -303,8 +303,8 @@ def expected_rule_json(rule)
       let(:other_mtls_domain) do
         VCAP::CloudController::PrivateDomain.make(
           owning_organization: other_org,
-          enforce_access_rules: true,
-          access_rules_scope: 'space'
+          enforce_route_policies: true,
+          route_policies_scope: 'space'
         )
       end
       let(:other_route) { VCAP::CloudController::Route.make(space: other_space, domain: other_mtls_domain) }
@@ -369,8 +369,8 @@ def expected_rule_json(rule)
       let(:other_mtls_domain) do
         VCAP::CloudController::PrivateDomain.make(
           owning_organization: other_org,
-          enforce_access_rules: true,
-          access_rules_scope: 'space'
+          enforce_route_policies: true,
+          route_policies_scope: 'space'
         )
       end
       let(:other_route) { VCAP::CloudController::Route.make(space: other_space, domain: other_mtls_domain) }
@@ -398,17 +398,17 @@ def expected_rule_json(rule)
       end
     end
 
-    describe 'filtering by selector_resource_guids' do
+    describe 'filtering by source_guids' do
       it 'escapes % so it does not act as a LIKE wildcard' do
-        get '/v3/route_policies?selector_resource_guids=%25', nil, admin_header
+        get '/v3/route_policies?source_guids=%25', nil, admin_header
 
         expect(last_response.status).to eq(200)
         parsed = Oj.load(last_response.body)
         expect(parsed['resources'].length).to eq(0)
       end
 
       it 'escapes _ so it does not act as a LIKE single-char wildcard' do
-        get '/v3/route_policies?selector_resource_guids=cf_app', nil, admin_header
+        get '/v3/route_policies?source_guids=cf_app', nil, admin_header
 
         expect(last_response.status).to eq(200)
         parsed = Oj.load(last_response.body)
@@ -417,15 +417,15 @@ def expected_rule_json(rule)
       end
 
       it 'escapes backslash so it does not act as a LIKE escape character' do
-        get '/v3/route_policies?selector_resource_guids=cf%5Capp', nil, admin_header
+        get '/v3/route_policies?source_guids=cf%5Capp', nil, admin_header
 
         expect(last_response.status).to eq(200)
         parsed = Oj.load(last_response.body)
         expect(parsed['resources'].length).to eq(0)
       end
     end
 
-    context 'with include=selector_resource' do
+    context 'with include=source' do
       let!(:frontend_app) { VCAP::CloudController::AppModel.make(space: space, name: 'frontend-app') }
       let!(:other_space) { VCAP::CloudController::Space.make(organization: org, name: 'other-space') }
       let!(:other_org) { VCAP::CloudController::Organization.make(name: 'other-org') }
@@ -455,7 +455,7 @@ def expected_rule_json(rule)
       end
 
       it 'includes resolved selector resources' do
-        get '/v3/route_policies?include=selector_resource', nil, admin_header
+        get '/v3/route_policies?include=source', nil, admin_header
 
         expect(last_response.status).to eq(200)
         parsed = Oj.load(last_response.body)
@@ -491,7 +491,7 @@ def expected_rule_json(rule)
           route_id: mtls_route.id
         )
 
-        get '/v3/route_policies?include=selector_resource', nil, admin_header
+        get '/v3/route_policies?include=source', nil, admin_header
 
         expect(last_response.status).to eq(200)
         parsed = Oj.load(last_response.body)
@@ -509,7 +509,7 @@ def expected_rule_json(rule)
           route_id: VCAP::CloudController::Route.make(space: space, domain: mtls_domain).id
         )
 
-        get '/v3/route_policies?include=selector_resource', nil, admin_header
+        get '/v3/route_policies?include=source', nil, admin_header
 
         expect(last_response.status).to eq(200)
         parsed = Oj.load(last_response.body)
@@ -526,7 +526,7 @@ def expected_rule_json(rule)
           route_id: VCAP::CloudController::Route.make(space: space, domain: mtls_domain).id
         )
 
-        get '/v3/route_policies?include=selector_resource', nil, admin_header
+        get '/v3/route_policies?include=source', nil, admin_header
 
         expect(last_response.status).to eq(200)
         # Should succeed without error even with cf:any selector
@@ -592,15 +592,15 @@ def expected_rule_json(rule)
         expect(route_count).to eq(1)
       end
 
-      it 'combines include=route with include=selector_resource' do
+      it 'combines include=route with include=source' do
         test_app = VCAP::CloudController::AppModel.make(space: space, name: 'test-app')
         VCAP::CloudController::RoutePolicy.create(
           guid: SecureRandom.uuid,
           source: "cf:app:#{test_app.guid}",
           route_id: mtls_route.id
         )
 
-        get '/v3/route_policies?include=route,selector_resource', nil, admin_header
+        get '/v3/route_policies?include=route,source', nil, admin_header
 
         expect(last_response.status).to eq(200)
         parsed = Oj.load(last_response.body)
@@ -630,10 +630,10 @@ def expected_rule_json(rule)
     end
 
     it 'deletes the access rule and returns 204' do
-      delete "/v3/route_policies/#{access_rule.guid}", nil, admin_header
+      delete "/v3/route_policies/#{route_policy.guid}", nil, admin_header
 
       expect(last_response.status).to eq(204)
-      expect(VCAP::CloudController::RoutePolicy.find(guid: access_rule.guid)).to be_nil
+      expect(VCAP::CloudController::RoutePolicy.find(guid: route_policy.guid)).to be_nil
     end
 
     context 'when the access rule does not exist' do
@@ -655,7 +655,7 @@ def expected_rule_json(rule)
     end
 
     it 'returns 200' do
-      patch "/v3/route_policies/#{access_rule.guid}", {
+      patch "/v3/route_policies/#{route_policy.guid}", {
         metadata: { labels: { env: 'production' } }
       }.to_json, admin_header
 

spec/unit/messages/route_policies_list_message_spec.rb

@@ -9,12 +9,12 @@ module VCAP::CloudController
           'guids' => 'guid1,guid2',
           'route_guids' => 'route1,route2',
           'space_guids' => 'space1,space2',
-          'sources' => 'selector1,selector2',
+          'sources' => 'source1,source2',
           'source_guids' => 'resource1,resource2',
           'page' => 1,
           'per_page' => 5,
           'order_by' => 'created_at',
-          'include' => 'selector_resource,route,app,space,organization'
+          'include' => 'source,route,app,space,organization'
         }
       end
 
@@ -25,12 +25,12 @@ module VCAP::CloudController
         expect(message.guids).to eq(%w[guid1 guid2])
         expect(message.route_guids).to eq(%w[route1 route2])
         expect(message.space_guids).to eq(%w[space1 space2])
-        expect(message.selectors).to eq(%w[selector1 selector2])
-        expect(message.selector_resource_guids).to eq(%w[resource1 resource2])
+        expect(message.sources).to eq(%w[source1 source2])
+        expect(message.source_guids).to eq(%w[resource1 resource2])
         expect(message.page).to eq(1)
         expect(message.per_page).to eq(5)
         expect(message.order_by).to eq('created_at')
-        expect(message.include).to eq(%w[selector_resource route app space organization])
+        expect(message.include).to eq(%w[source route app space organization])
       end
 
       it 'converts requested keys to symbols' do
@@ -54,17 +54,17 @@ module VCAP::CloudController
           guids: %w[guid1 guid2],
           route_guids: %w[route1 route2],
           space_guids: %w[space1 space2],
-          selectors: %w[selector1 selector2],
-          selector_resource_guids: %w[resource1 resource2],
+          sources: %w[source1 source2],
+          source_guids: %w[resource1 resource2],
           page: 1,
           per_page: 5,
           order_by: 'created_at',
-          include: %w[selector_resource route app space organization]
+          include: %w[source route app space organization]
         }
       end
 
       it 'excludes the pagination keys' do
-        expected_params = %i[guids route_guids space_guids selectors selector_resource_guids include]
+        expected_params = %i[guids route_guids space_guids sources source_guids include]
         expect(RoutePoliciesListMessage.from_params(opts).to_param_hash.keys).to match_array(expected_params)
       end
     end
@@ -73,16 +73,16 @@ module VCAP::CloudController
       it 'accepts a set of fields' do
         expect do
           RoutePoliciesListMessage.from_params({
-                                               guids: [],
-                                               route_guids: [],
-                                               space_guids: [],
-                                               selectors: [],
-                                               selector_resource_guids: [],
-                                               page: 1,
-                                               per_page: 5,
-                                               order_by: 'created_at',
-                                               include: %w[selector_resource route app space organization]
-                                             })
+                                                 guids: [],
+                                                 route_guids: [],
+                                                 space_guids: [],
+                                                 sources: [],
+                                                 source_guids: [],
+                                                 page: 1,
+                                                 per_page: 5,
+                                                 order_by: 'created_at',
+                                                 include: %w[source route app space organization]
+                                               })
         end.not_to raise_error
       end
 
@@ -115,7 +115,7 @@ module VCAP::CloudController
           message = RoutePoliciesListMessage.from_params({ 'include' => 'organization' })
           expect(message).to be_valid
 
-          message = RoutePoliciesListMessage.from_params({ 'include' => 'selector_resource,route,app,space,organization' })
+          message = RoutePoliciesListMessage.from_params({ 'include' => 'source,route,app,space,organization' })
           expect(message).to be_valid
         end
 
@@ -144,22 +144,22 @@ module VCAP::CloudController
           expect(message.space_guids).to eq(%w[space1 space2])
         end
 
-        it 'validates selector_resource_guids is an array' do
-          message = RoutePoliciesListMessage.from_params selector_resource_guids: 'not array'
+        it 'validates source_guids is an array' do
+          message = RoutePoliciesListMessage.from_params source_guids: 'not array'
           expect(message).not_to be_valid
           expect(message.errors[:source_guids].length).to eq 1
         end
 
-        it 'allows selector_resource_guids to be nil' do
+        it 'allows source_guids to be nil' do
           message = RoutePoliciesListMessage.from_params({})
           expect(message).to be_valid
-          expect(message.selector_resource_guids).to be_nil
+          expect(message.source_guids).to be_nil
         end
 
-        it 'allows selector_resource_guids to be an array' do
-          message = RoutePoliciesListMessage.from_params selector_resource_guids: %w[guid1 guid2]
+        it 'allows source_guids to be an array' do
+          message = RoutePoliciesListMessage.from_params source_guids: %w[guid1 guid2]
           expect(message).to be_valid
-          expect(message.selector_resource_guids).to eq(%w[guid1 guid2])
+          expect(message.source_guids).to eq(%w[guid1 guid2])
         end
       end
     end

spec/unit/messages/route_policy_create_message_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'messages/access_rule_create_message'
+require 'messages/route_policy_create_message'
 
 module VCAP::CloudController
   RSpec.describe RoutePolicyCreateMessage do

spec/unit/presenters/v3/domain_presenter_spec.rb

@@ -238,24 +238,24 @@ module VCAP::CloudController::Presenters::V3
           end
         end
 
-        context 'when the domain has enforce_access_rules enabled' do
+        context 'when the domain has enforce_route_policies enabled' do
           let(:org) { VCAP::CloudController::Organization.make }
           let(:domain) do
             VCAP::CloudController::PrivateDomain.make(
               name: 'mtls.domain.com',
               owning_organization: org,
-              enforce_access_rules: true,
-              access_rules_scope: 'space'
+              enforce_route_policies: true,
+              route_policies_scope: 'space'
             )
           end
 
-          it 'includes enforce_access_rules and access_rules_scope in the output' do
+          it 'includes enforce_route_policies and route_policies_scope in the output' do
             expect(subject[:enforce_route_policies]).to be(true)
             expect(subject[:route_policies_scope]).to eq('space')
           end
         end
 
-        context 'when the domain does not have enforce_access_rules enabled' do
+        context 'when the domain does not have enforce_route_policies enabled' do
           let(:domain) do
             VCAP::CloudController::SharedDomain.make(
               name: 'regular.domain.com'
@@ -269,7 +269,7 @@ module VCAP::CloudController::Presenters::V3
             allow(routing_api_client).to receive_messages(enabled?: true, router_group: nil)
           end
 
-          it 'does not include enforce_access_rules or access_rules_scope in the output' do
+          it 'does not include enforce_route_policies or route_policies_scope in the output' do
             expect(subject).not_to have_key(:enforce_route_policies)
             expect(subject).not_to have_key(:route_policies_scope)
           end