V3: GET /v3/routes?ports=xxxx (filter routes by port)

- Includes `GET /v3/apps/:guid/routes?ports=xxxx`
- The test for TCP routes are non-trivial:
  - make sure to disable k8s
  - a `before do` block enables the setup of the `let`s in a subsequent
    context; don't be tempted to optimize this, it won't work.
    (applies to _request_ and _fetcher_ specs)

[#172664949]

Co-authored-by: Belinda Liu <bliu@pivotal.io>
Co-authored-by: Brian Cunnie <bcunnie@pivotal.io>

Author: belinda-liu

app/fetchers/route_fetcher.rb

@@ -17,6 +17,10 @@ def filter(message, dataset)
           dataset = dataset.where(path: message.paths)
         end
 
+        if message.requested?(:ports)
+          dataset = dataset.where(port: message.ports)
+        end
+
         if message.requested?(:organization_guids)
           space_ids = Organization.where(guid: message.organization_guids).map(&:spaces).flatten.map(&:id)
           dataset = dataset.where(space_id: space_ids)

app/messages/routes_list_message.rb

@@ -11,6 +11,7 @@ class RoutesListMessage < ListMessage
       :app_guids,
       :include,
       :label_selector,
+      :ports,
     ]
 
     validates_with NoAdditionalParamsValidator
@@ -22,9 +23,10 @@ class RoutesListMessage < ListMessage
     validates :space_guids, allow_nil: true, array: true
     validates :organization_guids, allow_nil: true, array: true
     validates :domain_guids, allow_nil: true, array: true
+    validates :ports, allow_nil: true, array: true
 
     def self.from_params(params)
-      super(params, %w(hosts space_guids organization_guids domain_guids app_guids paths include))
+      super(params, %w(hosts space_guids organization_guids domain_guids app_guids paths ports include))
     end
   end
 end

docs/v3/source/includes/resources/routes/_list.md.erb

@@ -35,6 +35,7 @@ Name | Type | Description
 **hosts** | _list of strings_ | Comma-delimited list of hostnames to filter by.
 **organization_guids** | _list of strings_ | Comma-delimited list of organization guids to filter by.
 **paths** | _list of strings_ | Comma-delimited list of paths to filter by (e.g. `/path1,/path2`).
+**ports** | _list of integers_ | Comma-delimited list of ports to filter by (e.g. `3306,5432`).
 **space_guids** | _list of strings_ | Comma-delimited list of space guids to filter by.
 **page** | _integer_ | Page to display. Valid values are integers >= 1.
 **per_page** | _integer_ | Number of results per page. <br>Valid values are 1 through 5000.

docs/v3/source/includes/resources/routes/_list_for_app.md.erb

@@ -30,11 +30,12 @@ Retrieve all routes that have [destinations](#the-destination-object) that point
 
 Name | Type | Description
 ---- | ---- | ------------
+**domain_guids** | _list of strings_ | Comma-delimited list of domain guids to filter by.
 **hosts** | _list of strings_ | Comma-delimited list of hostnames to filter by.
+**organization_guids** | _list of strings_ | Comma-delimited list of organization guids to filter by.
 **paths** | _list of strings_ | Comma-delimited list of paths to filter by (e.g. `/path1,/path2`).
-**domain_guids** | _list of strings_ | Comma-delimited list of domain guids to filter by.
+**ports** | _list of integers_ | Comma-delimited list of ports to filter by (e.g. `3306,5432`).
 **space_guids** | _list of strings_ | Comma-delimited list of space guids to filter by.
-**organization_guids** | _list of strings_ | Comma-delimited list of organization guids to filter by.
 **page** | _integer_ | Page to display. Valid values are integers >= 1.
 **per_page** | _integer_ | Number of results per page. <br>Valid values are 1 through 5000.
 **order_by** | _string_ | Value to sort by. Defaults to ascending. Prepend with `-` to sort descending. <br>Valid values are `created_at`, `updated_at`.

spec/request/routes_spec.rb

@@ -119,17 +119,18 @@
 
         let(:params) do
           {
-            page:   '2',
-            per_page:   '10',
-            order_by:   'updated_at',
+            page: '2',
+            per_page: '10',
+            order_by: 'updated_at',
             space_guids: ['foo', 'bar'],
             organization_guids: ['foo', 'bar'],
             domain_guids: ['foo', 'bar'],
             app_guids: ['foo', 'bar'],
             paths: ['foo', 'bar'],
             hosts: 'foo',
+            ports: 636,
             include: 'domain',
-            label_selector:   'foo,bar',
+            label_selector: 'foo,bar',
           }
         end
       end
@@ -522,6 +523,39 @@
           ).to eq([app_model.guid])
         end
       end
+
+      context 'ports filter' do
+        # Don't even think of converting the following hash to symbols ('type' => 'tcp' NOT type: 'tcp'), and you need to set the GUID
+        let(:router_group) { VCAP::CloudController::RoutingApi::RouterGroup.new({ 'type' => 'tcp', 'reservable_ports' => '7777,8888,9999', 'guid' => 'some-guid' }) }
+        let(:routing_api_client) { instance_double(VCAP::CloudController::RoutingApi::Client) }
+
+        before do
+          allow_any_instance_of(CloudController::DependencyLocator).to receive(:routing_api_client).and_return(routing_api_client)
+          allow(routing_api_client).to receive(:enabled?).and_return(true)
+          allow(routing_api_client).to receive(:router_group).and_return(router_group)
+        end
+
+        context 'when there are multiple TCP routes with different ports' do
+          # The following `let`s depend on the above `before do`
+          let(:domain_tcp) { VCAP::CloudController::SharedDomain.make(router_group_guid: router_group.guid, name: 'my.domain') }
+          let!(:route_with_ports_0) do
+            VCAP::CloudController::Route.make(host: '', space: space, domain: domain_tcp, guid: 'route-with-port-0', port: 7777)
+          end
+          let!(:route_with_ports_1) do
+            VCAP::CloudController::Route.make(host: '', space: space, domain: domain_tcp, guid: 'route-with-port-1', port: 8888)
+          end
+          let!(:route_with_ports_2) do
+            VCAP::CloudController::Route.make(host: '', space: space, domain: domain_tcp, guid: 'route-with-port-2', port: 9999)
+          end
+
+          it 'returns routes filtered by ports' do
+            get '/v3/routes?ports=7777,8888', nil, admin_header
+            expect(last_response).to have_status_code(200)
+            expect(parsed_response['resources'].size).to eq(2)
+            expect(parsed_response['resources'].map { |resource| resource['port'] }).to contain_exactly(route_with_ports_0.port, route_with_ports_1.port)
+          end
+        end
+      end
     end
 
     describe 'labels' do
@@ -2448,6 +2482,41 @@
       it_behaves_like 'permissions for list endpoint', ALL_PERMISSIONS
     end
 
+    context 'ports filter' do
+      # Don't even think of converting the following hash to symbols ('type' => 'tcp' NOT type: 'tcp'), and you need to set the GUID
+      let(:router_group) { VCAP::CloudController::RoutingApi::RouterGroup.new({ 'type' => 'tcp', 'reservable_ports' => '7777,8888,9999', 'guid' => 'some-guid' }) }
+      let(:routing_api_client) { instance_double(VCAP::CloudController::RoutingApi::Client) }
+
+      before do
+        allow_any_instance_of(CloudController::DependencyLocator).to receive(:routing_api_client).and_return(routing_api_client)
+        allow(routing_api_client).to receive(:enabled?).and_return(true)
+        allow(routing_api_client).to receive(:router_group).and_return(router_group)
+      end
+
+      context 'when there are multiple TCP routes with different ports' do
+        # The following `let`s depend on the above `before do`
+        let(:domain_tcp) { VCAP::CloudController::SharedDomain.make(router_group_guid: router_group.guid, name: 'my.domain') }
+        let!(:route_with_ports_0) do
+          VCAP::CloudController::Route.make(host: '', space: space, domain: domain_tcp, guid: 'route-with-port-0', port: 7777)
+        end
+        let!(:route_with_ports_1) do
+          VCAP::CloudController::Route.make(host: '', space: space, domain: domain_tcp, guid: 'route-with-port-1', port: 8888)
+        end
+        let!(:route_with_ports_2) do
+          VCAP::CloudController::Route.make(host: '', space: space, domain: domain_tcp, guid: 'route-with-port-2', port: 9999)
+        end
+        let!(:route_mapping_1) { VCAP::CloudController::RouteMappingModel.make(app: app_model, route: route_with_ports_1, process_type: 'web') }
+        let!(:route_mapping_2) { VCAP::CloudController::RouteMappingModel.make(app: app_model, route: route_with_ports_2, process_type: 'web') }
+
+        it 'returns routes filtered by ports' do
+          get "/v3/apps/#{app_model.guid}/routes?ports=7777,8888", nil, admin_header
+          expect(last_response).to have_status_code(200)
+          expect(parsed_response['resources'].size).to eq(1)
+          expect(parsed_response['resources'].first['port']).to eq(route_with_ports_1.port)
+        end
+      end
+    end
+
     describe 'eager loading' do
       it 'eager loads associated resources that the presenter specifies' do
         expect(VCAP::CloudController::RouteFetcher).to receive(:fetch).with(

spec/unit/fetchers/route_fetcher_spec.rb

@@ -138,6 +138,41 @@ module VCAP::CloudController
         end
       end
 
+      context 'when fetching routes by ports' do
+        let!(:router_group) { VCAP::CloudController::RoutingApi::RouterGroup.new({ 'type' => 'tcp', 'reservable_ports' => '8888,9999', 'guid' => 'some-guid' }) }
+        let(:routing_api_client) { instance_double(VCAP::CloudController::RoutingApi::Client) }
+
+        before do
+          TestConfig.override(kubernetes: {})
+          allow_any_instance_of(CloudController::DependencyLocator).to receive(:routing_api_client).and_return(routing_api_client)
+          allow(routing_api_client).to receive(:enabled?).and_return(true)
+          allow(routing_api_client).to receive(:router_group).and_return(router_group)
+        end
+
+        context 'when there is a matching route' do
+          let(:domain_tcp) { VCAP::CloudController::SharedDomain.make(router_group_guid: router_group.guid, name: 'my.domain') }
+          let!(:route_with_ports) do
+            VCAP::CloudController::Route.make(host: '', space: space1, domain: domain_tcp, guid: 'route-with-port', port: 8888)
+          end
+          let(:routes_filter) { { ports: '8888' } }
+
+          it 'only returns the matching route' do
+            results = RouteFetcher.fetch(message, [route2.guid, route3.guid, route_with_ports.guid]).all
+            expect(results.length).to eq(1)
+            expect(results[0].guid).to eq(route_with_ports.guid)
+          end
+        end
+
+        context 'when there is no matching route' do
+          let(:routes_filter) { { ports: '123' } }
+
+          it 'returns no routes' do
+            results = RouteFetcher.fetch(message, [route2.guid, route3.guid]).all
+            expect(results.length).to eq(0)
+          end
+        end
+      end
+
       context 'when fetching routes by label selector' do
         let!(:route_label) do
           VCAP::CloudController::RouteLabelModel.make(resource_guid: route1.guid, key_name: 'dog', value: 'scooby-doo')

spec/unit/messages/routes_list_message_spec.rb

@@ -76,6 +76,12 @@ module VCAP::CloudController
         expect(message.domain_guids).to eq(['guid1', 'guid2'])
       end
 
+      it 'accepts a ports param' do
+        message = RoutesListMessage.from_params({ 'ports' => '5900,6000,7000' })
+        expect(message).to be_valid
+        expect(message.ports).to eq(['5900', '6000', '7000'])
+      end
+
       it 'does not accept any other params' do
         message = RoutesListMessage.from_params({ 'app_guid' => 'pants' })