github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/caas/kubernetes/provider/resources/pod_test.go

// Copyright 2020 Canonical Ltd.
// Licensed under the AGPLv3, see LICENCE file for details.

package resources_test

import (
	"context"
	"testing"
	"time"

	"github.com/juju/errors"
	jc "github.com/juju/testing/checkers"
	gc "gopkg.in/check.v1"
	corev1 "k8s.io/api/core/v1"
	k8serrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"github.com/juju/juju/caas/kubernetes/provider/resources"
	"github.com/juju/juju/core/status"
)

type podSuite struct {
	resourceSuite
}

var _ = gc.Suite(&podSuite{})

func (s *podSuite) TestApply(c *gc.C) {
	ds := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "ds1",
			Namespace: "test",
		},
	}
	// Create.
	dsResource := resources.NewPod("ds1", "test", ds)
	c.Assert(dsResource.Apply(context.TODO(), s.client), jc.ErrorIsNil)
	result, err := s.client.CoreV1().Pods("test").Get(context.TODO(), "ds1", metav1.GetOptions{})
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(len(result.GetAnnotations()), gc.Equals, 0)

	// Update.
	ds.SetAnnotations(map[string]string{"a": "b"})
	dsResource = resources.NewPod("ds1", "test", ds)
	c.Assert(dsResource.Apply(context.TODO(), s.client), jc.ErrorIsNil)

	result, err = s.client.CoreV1().Pods("test").Get(context.TODO(), "ds1", metav1.GetOptions{})
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(result.GetName(), gc.Equals, `ds1`)
	c.Assert(result.GetNamespace(), gc.Equals, `test`)
	c.Assert(result.GetAnnotations(), gc.DeepEquals, map[string]string{"a": "b"})
}

func (s *podSuite) TestGet(c *gc.C) {
	template := corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "ds1",
			Namespace: "test",
		},
	}
	ds1 := template
	ds1.SetAnnotations(map[string]string{"a": "b"})
	_, err := s.client.CoreV1().Pods("test").Create(context.TODO(), &ds1, metav1.CreateOptions{})
	c.Assert(err, jc.ErrorIsNil)

	dsResource := resources.NewPod("ds1", "test", &template)
	c.Assert(len(dsResource.GetAnnotations()), gc.Equals, 0)
	err = dsResource.Get(context.TODO(), s.client)
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(dsResource.GetName(), gc.Equals, `ds1`)
	c.Assert(dsResource.GetNamespace(), gc.Equals, `test`)
	c.Assert(dsResource.GetAnnotations(), gc.DeepEquals, map[string]string{"a": "b"})
}

func (s *podSuite) TestDelete(c *gc.C) {
	ds := corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "ds1",
			Namespace: "test",
		},
	}
	_, err := s.client.CoreV1().Pods("test").Create(context.TODO(), &ds, metav1.CreateOptions{})
	c.Assert(err, jc.ErrorIsNil)

	result, err := s.client.CoreV1().Pods("test").Get(context.TODO(), "ds1", metav1.GetOptions{})
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(result.GetName(), gc.Equals, `ds1`)

	dsResource := resources.NewPod("ds1", "test", &ds)
	err = dsResource.Delete(context.TODO(), s.client)
	c.Assert(err, jc.ErrorIsNil)

	err = dsResource.Get(context.TODO(), s.client)
	c.Assert(err, jc.Satisfies, errors.IsNotFound)

	_, err = s.client.CoreV1().Pods("test").Get(context.TODO(), "ds1", metav1.GetOptions{})
	c.Assert(err, jc.Satisfies, k8serrors.IsNotFound)
}

func TestTerminatedPodJujuStatus(t *testing.T) {
	pod := corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			DeletionTimestamp: &metav1.Time{Time: time.Now()},
		},
		Status: corev1.PodStatus{
			Message: "test",
		},
	}

	testTime := time.Now()
	message, poStatus, now, err := resources.PodToJujuStatus(
		pod,
		testTime,
		func() ([]corev1.Event, error) {
			return []corev1.Event{}, nil
		},
	)

	if err != nil {
		t.Fatalf("unexpected error getting pod status: %v", err)
	}

	if message != pod.Status.Message {
		t.Errorf("pod status messages not equal %q != %q", message, pod.Status.Message)
	}

	if poStatus != status.Terminated {
		t.Errorf("expected status %q got %q", status.Terminated, poStatus)
	}

	if !testTime.Equal(now) {
		t.Errorf("unexpected status time received, got %q wanted %q", now, testTime)
	}
}

func TestPodConditionListJujuStatus(t *testing.T) {
	tests := []struct {
		Name    string
		Pod     corev1.Pod
		Status  status.Status
		Message string
	}{
		{
			// We are testing the juju status here when a pod is considered
			// unschedulable. We want to see a juju status of blocked and
			// the scheduling message echoed as this will provide the best
			// reason.
			Name: "pod scheduling status unschedulable",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:    corev1.PodScheduled,
							Status:  corev1.ConditionFalse,
							Reason:  corev1.PodReasonUnschedulable,
							Message: "not enough resources",
						},
					},
				},
			},
			Status:  status.Blocked,
			Message: "not enough resources",
		},
		{
			// We are testing the juju status here when pod scheduling is still
			// occurring. Kubernetes is still organising where to put our pod
			// so we expect a juju status of allocating and the pod scheduling
			// message to be echoed.
			Name: "pod scheduling status waiting",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:    corev1.PodScheduled,
							Status:  corev1.ConditionFalse,
							Reason:  "waiting",
							Message: "waiting to be scheduled",
						},
					},
				},
			},
			Status:  status.Allocating,
			Message: "waiting to be scheduled",
		},
		{
			// We expect that every pod has a pod scheduling condition. If it's
			// missing our juju status should be Unknown as it's not safe for
			// us to test anymore of the pod conditions.
			Name: "pod scheduling status missing",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{},
				},
			},
			Status:  status.Unknown,
			Message: "",
		},
		{
			// We are testing here that when the pod is in it's init stage
			// the correct juju status of maintenance is being reported.
			Name: "pod init status waiting",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:    corev1.PodInitialized,
							Status:  corev1.ConditionFalse,
							Reason:  resources.PodReasonContainersNotInitialized,
							Message: "initializing containers",
						},
					},
				},
			},
			Status:  status.Maintenance,
			Message: "initializing containers",
		},
		{
			// We are testing here that when the pod is running the init steps
			// the correct status of maintenance is being reported.
			Name: "pod init status running",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:    corev1.PodInitialized,
							Status:  corev1.ConditionFalse,
							Reason:  resources.PodReasonInitializing,
							Message: "initializing containers",
						},
					},
				},
			},
			Status:  status.Maintenance,
			Message: "initializing containers",
		},
		{
			// We are testing here that when the pod is in it's init stage
			// the correct juju status of error is displayed as one of the
			// pods is in a crash loop backoff.
			Name: "pod init status error",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:    corev1.PodInitialized,
							Status:  corev1.ConditionFalse,
							Reason:  resources.PodReasonContainersNotInitialized,
							Message: "initializing containers",
						},
					},
					InitContainerStatuses: []corev1.ContainerStatus{
						{
							Name: "test-init-container",
							State: corev1.ContainerState{
								Waiting: &corev1.ContainerStateWaiting{
									Reason:  resources.PodReasonCrashLoopBackoff,
									Message: "I am broken",
								},
							},
						},
					},
				},
			},
			Status:  status.Error,
			Message: "crash loop backoff: I am broken",
		},
		{
			// We are testing here that while the main containers of the pod
			// are still being spun up and the juju status of maintenance is
			// still being reported
			Name: "pod container status waiting",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:    corev1.ContainersReady,
							Status:  corev1.ConditionFalse,
							Reason:  resources.PodReasonContainersNotReady,
							Message: "starting containers",
						},
					},
				},
			},
			Status:  status.Maintenance,
			Message: "starting containers",
		},
		{
			// We want to test here that when a container in the pod goes into
			// an error state like a crash loop backoff the subsequent juju
			// status is error
			Name: "pod container status error",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:    corev1.ContainersReady,
							Status:  corev1.ConditionFalse,
							Reason:  resources.PodReasonContainersNotReady,
							Message: "starting containers",
						},
					},
					ContainerStatuses: []corev1.ContainerStatus{
						{
							Name: "test-container",
							State: corev1.ContainerState{
								Waiting: &corev1.ContainerStateWaiting{
									Reason:  resources.PodReasonCrashLoopBackoff,
									Message: "I am broken",
								},
							},
						},
					},
				},
			},
			Status:  status.Error,
			Message: "crash loop backoff: I am broken",
		},
		{
			// We want to  test here the pod container creating message for init
			// containers. This addresses lp-1914088
			Name: "pod container status creating init",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:    corev1.PodInitialized,
							Status:  corev1.ConditionFalse,
							Reason:  resources.PodReasonContainersNotInitialized,
							Message: "initializing containers",
						},
					},
					InitContainerStatuses: []corev1.ContainerStatus{
						{
							Name: "test-container",
							State: corev1.ContainerState{
								Waiting: &corev1.ContainerStateWaiting{
									Reason: resources.PodReasonContainerCreating,
								},
							},
						},
					},
				},
			},
			Status:  status.Maintenance,
			Message: "initializing containers",
		},
		{
			// We want to  test here the pod container creating message on pod
			// containers. This addresses lp-1914088
			Name: "pod container status creating",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:    corev1.ContainersReady,
							Status:  corev1.ConditionFalse,
							Reason:  resources.PodReasonContainersNotReady,
							Message: "creating containers",
						},
					},
					ContainerStatuses: []corev1.ContainerStatus{
						{
							Name: "test-container",
							State: corev1.ContainerState{
								Waiting: &corev1.ContainerStateWaiting{
									Reason: resources.PodReasonContainerCreating,
								},
							},
						},
					},
				},
			},
			Status:  status.Maintenance,
			Message: "creating containers",
		},
		{
			// We want to test that when the container reason is unknown we
			// report Juju status of error and propagate the message
			Name: "pod container unknown reason",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:    corev1.ContainersReady,
							Status:  corev1.ConditionFalse,
							Reason:  resources.PodReasonContainersNotReady,
							Message: "starting containers",
						},
					},
					ContainerStatuses: []corev1.ContainerStatus{
						{
							Name: "test-container",
							State: corev1.ContainerState{
								Waiting: &corev1.ContainerStateWaiting{
									Reason:  "bad-reason",
									Message: "I am broken",
								},
							},
						},
					},
				},
			},
			Status:  status.Error,
			Message: "unknown container reason \"bad-reason\": I am broken",
		},
		{
			// We want to test here that when the pod ready condition the juju
			// status is running
			Name: "pod container status running",
			Pod: corev1.Pod{
				Status: corev1.PodStatus{
					Conditions: []corev1.PodCondition{
						{
							Type:   corev1.PodScheduled,
							Status: corev1.ConditionTrue,
						},
						{
							Type:   corev1.ContainersReady,
							Status: corev1.ConditionTrue,
						},
						{
							Type:   corev1.PodReady,
							Status: corev1.ConditionTrue,
						},
					},
				},
			},
			Status:  status.Running,
			Message: "",
		},
	}

	for _, test := range tests {
		t.Run(test.Name, func(t *testing.T) {
			testTime := time.Now()
			eventGetter := func() ([]corev1.Event, error) {
				return []corev1.Event{}, nil
			}
			message, poStatus, _, err := resources.PodToJujuStatus(
				test.Pod, testTime, eventGetter)

			if err != nil {
				t.Fatalf("unexpected error getting pod status: %v", err)
			}

			if message != test.Message {
				t.Errorf("pod status messages not equal %q != %q", message, test.Message)
			}

			if poStatus != test.Status {
				t.Errorf("expected status %q got %q", test.Status, poStatus)
			}
		})
	}
}