193 lines
7.1 KiB
Go
193 lines
7.1 KiB
Go
package controller
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
|
|
databasev1alpha1 "git.ddupan.top/panxiao81/ayatori/api/database/v1alpha1"
|
|
"git.ddupan.top/panxiao81/ayatori/internal/database/adapter/kubernetes"
|
|
"git.ddupan.top/panxiao81/ayatori/internal/database/application"
|
|
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/instance"
|
|
apierrors "k8s.io/apimachinery/pkg/api/errors"
|
|
"k8s.io/apimachinery/pkg/api/meta"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
ctrl "sigs.k8s.io/controller-runtime"
|
|
"sigs.k8s.io/controller-runtime/pkg/client"
|
|
"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
|
|
)
|
|
|
|
type instanceBackend struct {
|
|
checks instance.ManagementChecks
|
|
err error
|
|
inspect func()
|
|
closed int
|
|
}
|
|
|
|
func (b *instanceBackend) Read(context.Context, instance.CredentialReference) (application.Credentials, error) {
|
|
return application.NewCredentials("fixture", "test-only-instance-password")
|
|
}
|
|
|
|
func (b *instanceBackend) Connect(context.Context, instance.Endpoint, application.Credentials) (application.Database, error) {
|
|
return b, nil
|
|
}
|
|
|
|
func (b *instanceBackend) InspectMetadata(context.Context) (application.DatabaseMetadata, error) {
|
|
return application.DatabaseMetadata{Version: "18"}, nil
|
|
}
|
|
|
|
func (b *instanceBackend) InspectManagement(context.Context) (application.DatabaseMetadata, error) {
|
|
if b.inspect != nil {
|
|
b.inspect()
|
|
}
|
|
return application.DatabaseMetadata{Version: "18", Management: b.checks}, b.err
|
|
}
|
|
|
|
func (b *instanceBackend) Close() { b.closed++ }
|
|
|
|
func newInstanceReconciler(t *testing.T, apiClient client.Client, backend *instanceBackend) *InstanceReconciler {
|
|
t.Helper()
|
|
service, err := application.NewInstanceService(backend, backend)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(service.Close)
|
|
return &InstanceReconciler{Client: apiClient, Reader: apiClient, Observer: service}
|
|
}
|
|
|
|
func reconcileInstance(t *testing.T, reconciler *InstanceReconciler, object *databasev1alpha1.PostgreSQLInstance) {
|
|
t.Helper()
|
|
if _, err := reconciler.Reconcile(t.Context(), ctrl.Request{NamespacedName: client.ObjectKeyFromObject(object)}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func assertInstanceReason(t *testing.T, object *databasev1alpha1.PostgreSQLInstance, reason string) {
|
|
t.Helper()
|
|
condition := meta.FindStatusCondition(object.Status.Conditions, "Ready")
|
|
if condition == nil || condition.Reason != reason || condition.ObservedGeneration != object.Generation {
|
|
t.Fatalf("Instance 状态不是当前 generation 的 %s", reason)
|
|
}
|
|
if reason != "ManagementReady" && condition.Status != metav1.ConditionFalse {
|
|
t.Fatal("失败状态仍为 Ready")
|
|
}
|
|
}
|
|
|
|
func TestInstanceObservationAPI(t *testing.T) {
|
|
apiClient, _, _ := bindingEnvironment(t)
|
|
backend := &instanceBackend{checks: instance.ManagementChecks{
|
|
Connection: instance.CheckPassed, Metadata: instance.CheckPassed,
|
|
Roles: instance.CheckPassed, Databases: instance.CheckPassed,
|
|
Grants: instance.CheckPassed, Extensions: instance.CheckPassed,
|
|
}}
|
|
reconciler := newInstanceReconciler(t, apiClient, backend)
|
|
object := readyInstance(t, apiClient, "observed-instance")
|
|
backend.inspect = func() {
|
|
current := &databasev1alpha1.PostgreSQLInstance{}
|
|
current.Name = object.Name
|
|
reload(t, apiClient, current)
|
|
if !controllerutil.ContainsFinalizer(current, kubernetes.InstanceFinalizer) {
|
|
t.Fatal("观察早于 finalizer 持久化")
|
|
}
|
|
}
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
assertInstanceReason(t, object, "ManagementReady")
|
|
if object.Status.Phase != string(instance.PhaseReady) || object.Status.PostgreSQLVersion != "18" {
|
|
t.Fatal("当前成功观察未呈现")
|
|
}
|
|
before := object.ResourceVersion
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
if object.ResourceVersion != before {
|
|
t.Fatal("相同观察不应反复写入 status")
|
|
}
|
|
backend.err = application.ErrAuthentication
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
assertInstanceReason(t, object, "AuthenticationFailed")
|
|
if backend.closed != 1 || object.Status.PostgreSQLVersion != "" {
|
|
t.Fatal("观察失败应释放连接并清除旧版本结果")
|
|
}
|
|
backend.err = nil
|
|
backend.checks.Grants = instance.CheckUnobserved
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
assertInstanceReason(t, object, "ObservationIncomplete")
|
|
backend.checks.Grants = instance.CheckPassed
|
|
// 用新 service/reconciler 恢复；不依赖上轮领域对象或 Ready。
|
|
reconciler = newInstanceReconciler(t, apiClient, backend)
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
assertInstanceReason(t, object, "ManagementReady")
|
|
|
|
backend.inspect = func() {
|
|
reload(t, apiClient, object)
|
|
object.Annotations = map[string]string{"concurrent": "kept-by-instance-test"}
|
|
if err := apiClient.Update(t.Context(), object); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
_, err := reconciler.Reconcile(t.Context(), ctrl.Request{NamespacedName: client.ObjectKeyFromObject(object)})
|
|
if !apierrors.IsConflict(err) {
|
|
t.Fatal("旧观察不应覆盖在途 API 修改")
|
|
}
|
|
backend.inspect = nil
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
if object.Annotations["concurrent"] != "kept-by-instance-test" {
|
|
t.Fatal("重试覆盖了其他字段")
|
|
}
|
|
}
|
|
|
|
type failedReferenceReader struct{ client.Reader }
|
|
|
|
func (*failedReferenceReader) List(context.Context, client.ObjectList, ...client.ListOption) error {
|
|
return errors.New("injected reference list failure")
|
|
}
|
|
|
|
func TestInstanceDeletionProtection(t *testing.T) {
|
|
apiClient, _, _ := bindingEnvironment(t)
|
|
backend := &instanceBackend{}
|
|
reconciler := newInstanceReconciler(t, apiClient, backend)
|
|
object := readyInstance(t, apiClient, "protected-instance")
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
database := availableDatabase(t, apiClient, "retained-database", object)
|
|
database.Status.Phase = "Released"
|
|
if err := apiClient.Status().Update(t.Context(), database); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tenant := provisionTenant("pending-request", object.Name)
|
|
requireCreate(t, apiClient, tenant)
|
|
if err := apiClient.Delete(t.Context(), object); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
backend.inspect = func() { t.Fatal("删除中不应连接 PostgreSQL") }
|
|
reconciler.Reader = &failedReferenceReader{Reader: apiClient}
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
assertInstanceReason(t, object, reasonDependency)
|
|
reconciler.Reader = apiClient
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
assertInstanceReason(t, object, "InstanceInUse")
|
|
if object.Status.Phase != string(instance.PhaseDeleting) || backend.closed != 1 {
|
|
t.Fatal("删除没有停止本地观察")
|
|
}
|
|
if err := apiClient.Delete(t.Context(), database); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
reconcileInstance(t, reconciler, object)
|
|
reload(t, apiClient, object)
|
|
assertInstanceReason(t, object, "InstanceInUse")
|
|
if err := apiClient.Delete(t.Context(), tenant); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
reconcileInstance(t, reconciler, object)
|
|
if err := apiClient.Get(t.Context(), client.ObjectKeyFromObject(object), object); !apierrors.IsNotFound(err) {
|
|
t.Fatal("最后一个引用解除后 Instance 应可删除")
|
|
}
|
|
reconcileInstance(t, reconciler, object)
|
|
}
|