clusterIP: {{ .Values.service.clusterIP }}
  {{- end }}
  {{- if or (eq .Values.service.type "LoadBalancer") (eq .Values.service.type "NodePort") }}
  externalTrafficPolicy: {{ .Values.service.externalTrafficPolicy | quote }}
  {{- end }}
  {{- if and (eq .Values.service.type "LoadBalancer") .Values.service.loadBalancerSourceRanges }}
  loadBalancerSourceRanges: {{ .Values.service.loadBalancerSourceRanges }}
  {{ end }}

  clusterIP: {{ .Values.consoleService.clusterIP }}
  {{- end }}
  {{- if or (eq .Values.consoleService.type "LoadBalancer") (eq .Values.consoleService.type "NodePort") }}
  externalTrafficPolicy: {{ .Values.consoleService.externalTrafficPolicy | quote }}
  {{- end }}
  {{- if and (eq .Values.consoleService.type "LoadBalancer") .Values.consoleService.loadBalancerSourceRanges }}

        ChannelInfo first = loadBalancer.selectChannel(readRequest);
        ChannelInfo second = loadBalancer.selectChannel(readRequest);

        assertEquals(first, second);
    }

    @Test
    void testStrategyChange() {
        assertEquals(LoadBalancingStrategy.ADAPTIVE, loadBalancer.getStrategy());

        loadBalancer.setStrategy(LoadBalancingStrategy.ROUND_ROBIN);

  3. mc ls {{ template "minio.fullname" . }}_local

{{- end }}
{{- if eq .Values.service.type "LoadBalancer" }}
MinIO can be accessed via port {{ .Values.service.port }} on an external IP address. Get the service external IP address by:
kubectl get svc --namespace {{ .Release.Namespace }} -l app={{ template "minio.fullname" . }}

        for (LoadBalancingStrategy strategy : strategies) {
            loadBalancer.setStrategy(strategy);
            assertEquals(strategy, loadBalancer.getStrategy());
        }

        // Test channel selection with mock request when no channels available