agones.dev/agones@v1.53.0/test/e2e/ping_test.go (about)

     1  // Copyright 2018 Google LLC All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package e2e
    16  
    17  import (
    18  	"context"
    19  	"fmt"
    20  	"io"
    21  	"net/http"
    22  	"testing"
    23  
    24  	"github.com/pkg/errors"
    25  	"github.com/sirupsen/logrus"
    26  	"github.com/stretchr/testify/assert"
    27  	"github.com/stretchr/testify/require"
    28  	corev1 "k8s.io/api/core/v1"
    29  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    30  	typedv1 "k8s.io/client-go/kubernetes/typed/core/v1"
    31  )
    32  
    33  func TestPingHTTP(t *testing.T) {
    34  	t.Parallel()
    35  	ctx := context.Background()
    36  
    37  	kubeCore := framework.KubeClient.CoreV1()
    38  	svc, err := kubeCore.Services("agones-system").Get(ctx, "agones-ping-http-service", metav1.GetOptions{})
    39  	require.NoError(t, err)
    40  
    41  	ip, err := externalIP(t, kubeCore, svc)
    42  	require.NoError(t, err)
    43  
    44  	port := svc.Spec.Ports[0]
    45  	// gate
    46  	assert.Equal(t, "http", port.Name)
    47  	assert.Equal(t, corev1.ProtocolTCP, port.Protocol)
    48  	p, err := externalPort(svc, port)
    49  	require.NoError(t, err)
    50  
    51  	response, err := http.Get(fmt.Sprintf("http://%s:%d", ip, p))
    52  	require.NoError(t, err)
    53  	defer response.Body.Close() // nolint: errcheck
    54  
    55  	assert.Equal(t, http.StatusOK, response.StatusCode)
    56  	body, err := io.ReadAll(response.Body)
    57  	require.NoError(t, err)
    58  	assert.Equal(t, []byte("ok"), body)
    59  }
    60  
    61  func externalPort(svc *corev1.Service, port corev1.ServicePort) (int32, error) {
    62  	switch svc.Spec.Type {
    63  	case corev1.ServiceTypeNodePort:
    64  		return port.NodePort, nil
    65  
    66  	case corev1.ServiceTypeLoadBalancer:
    67  		return port.Port, nil
    68  	}
    69  
    70  	return 0, errors.New("could not find external port")
    71  }
    72  
    73  func TestPingUDP(t *testing.T) {
    74  	t.Parallel()
    75  	ctx := context.Background()
    76  
    77  	kubeCore := framework.KubeClient.CoreV1()
    78  	svc, err := kubeCore.Services("agones-system").Get(ctx, "agones-ping-udp-service", metav1.GetOptions{})
    79  	require.NoError(t, err)
    80  
    81  	externalIP, err := externalIP(t, kubeCore, svc)
    82  	require.NoError(t, err)
    83  
    84  	port := svc.Spec.Ports[0]
    85  	// gate
    86  	assert.Equal(t, "udp", port.Name)
    87  	assert.Equal(t, corev1.ProtocolUDP, port.Protocol)
    88  	p, err := externalPort(svc, port)
    89  	require.NoError(t, err)
    90  
    91  	expected := "hello"
    92  	reply, err := framework.SendUDP(t, fmt.Sprintf("%s:%d", externalIP, p), expected)
    93  	require.NoError(t, err)
    94  	assert.Equal(t, expected, reply)
    95  }
    96  
    97  func externalIP(t *testing.T, kubeCore typedv1.NodesGetter, svc *corev1.Service) (string, error) {
    98  	externalIP := ""
    99  	ctx := context.Background()
   100  
   101  	logrus.WithField("svc", svc).Info("load balancer")
   102  
   103  	// likely this is minikube, so go get the node ip
   104  	if svc.Spec.Type == corev1.ServiceTypeNodePort {
   105  		nodes, err := kubeCore.Nodes().List(ctx, metav1.ListOptions{})
   106  		assert.Nil(t, err)
   107  		assert.Len(t, nodes.Items, 1, "Should only be 1 node on minikube")
   108  
   109  		addresses := nodes.Items[0].Status.Addresses
   110  		for _, a := range addresses {
   111  			if a.Type == corev1.NodeInternalIP {
   112  				externalIP = a.Address
   113  			}
   114  		}
   115  	} else {
   116  		externalIP = svc.Status.LoadBalancer.Ingress[0].IP
   117  	}
   118  
   119  	var err error
   120  	if externalIP == "" {
   121  		err = errors.New("could not find external ip")
   122  	}
   123  	return externalIP, err
   124  }