Add DomainMapping conformance test

pkg/apis/serving/v1alpha1/domainmapping_lifecycle.go

@@ -37,6 +37,11 @@ func (dm *DomainMapping) GetGroupVersionKind() schema.GroupVersionKind {
 	return SchemeGroupVersion.WithKind("DomainMapping")
 }
 
+// IsReady returns true if the DomainMapping is ready.
+func (dms *DomainMappingStatus) IsReady() bool {
+	return domainMappingCondSet.Manage(dms).IsHappy()
+}
+
 // InitializeConditions sets the initial values to the conditions.
 func (dms *DomainMappingStatus) InitializeConditions() {
 	domainMappingCondSet.Manage(dms).InitializeConditions()

pkg/apis/serving/v1alpha1/domainmapping_lifecycle_test.go

@@ -110,3 +110,105 @@ func TestPropagateIngressStatus(t *testing.T) {
 	apistest.CheckConditionOngoing(dms, DomainMappingConditionIngressReady, t)
 	apistest.CheckConditionOngoing(dms, DomainMappingConditionReady, t)
 }
+
+func TestDomainMappingIsReady(t *testing.T) {
+	cases := []struct {
+		name    string
+		status  DomainMappingStatus
+		isReady bool
+	}{{
+		name:    "empty status should not be ready",
+		status:  DomainMappingStatus{},
+		isReady: false,
+	}, {
+		name: "Different condition type should not be ready",
+		status: DomainMappingStatus{
+			Status: duckv1.Status{
+				Conditions: duckv1.Conditions{{
+					Type:   DomainMappingConditionIngressReady,
+					Status: corev1.ConditionTrue,
+				}},
+			},
+		},
+		isReady: false,
+	}, {
+		name: "False condition status should not be ready",
+		status: DomainMappingStatus{
+			Status: duckv1.Status{
+				Conditions: duckv1.Conditions{{
+					Type:   DomainMappingConditionReady,
+					Status: corev1.ConditionFalse,
+				}},
+			},
+		},
+		isReady: false,
+	}, {
+		name: "Unknown condition status should not be ready",
+		status: DomainMappingStatus{
+			Status: duckv1.Status{
+				Conditions: duckv1.Conditions{{
+					Type:   DomainMappingConditionReady,
+					Status: corev1.ConditionUnknown,
+				}},
+			},
+		},
+		isReady: false,
+	}, {
+		name: "Missing condition status should not be ready",
+		status: DomainMappingStatus{
+			Status: duckv1.Status{
+				Conditions: duckv1.Conditions{{
+					Type: DomainMappingConditionReady,
+				}},
+			},
+		},
+		isReady: false,
+	}, {
+		name: "True condition status should be ready",
+		status: DomainMappingStatus{
+			Status: duckv1.Status{
+				Conditions: duckv1.Conditions{{
+					Type:   DomainMappingConditionReady,
+					Status: corev1.ConditionTrue,
+				}},
+			},
+		},
+		isReady: true,
+	}, {
+		name: "Multiple conditions with ready status should be ready",
+		status: DomainMappingStatus{
+			Status: duckv1.Status{
+				Conditions: duckv1.Conditions{{
+					Type:   DomainMappingConditionIngressReady,
+					Status: corev1.ConditionTrue,
+				}, {
+					Type:   DomainMappingConditionReady,
+					Status: corev1.ConditionTrue,
+				}},
+			},
+		},
+		isReady: true,
+	}, {
+		name: "Multiple conditions with ready status false should not be ready",
+		status: DomainMappingStatus{
+			Status: duckv1.Status{
+				Conditions: duckv1.Conditions{{
+					Type:   DomainMappingConditionIngressReady,
+					Status: corev1.ConditionTrue,
+				}, {
+					Type:   DomainMappingConditionReady,
+					Status: corev1.ConditionFalse,
+				}},
+			},
+		},
+		isReady: false,
+	}}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if e, a := tc.isReady, tc.status.IsReady(); e != a {
+				t.Errorf("%q expected: %v got: %v", tc.name, e, a)
+			}
+		})
+	}
+}

test/clients.go

@@ -35,20 +35,27 @@ import (
 	"knative.dev/pkg/test"
 	"knative.dev/serving/pkg/client/clientset/versioned"
 	servingv1 "knative.dev/serving/pkg/client/clientset/versioned/typed/serving/v1"
+	servingv1alpha1 "knative.dev/serving/pkg/client/clientset/versioned/typed/serving/v1alpha1"
 
 	// Every E2E test requires this, so add it here.
 	_ "knative.dev/pkg/metrics/testing"
 )
 
 // Clients holds instances of interfaces for making requests to Knative Serving.
 type Clients struct {
-	KubeClient       *test.KubeClient
-	ServingClient    *ServingClients
-	NetworkingClient *NetworkingClients
-	Dynamic          dynamic.Interface
+	KubeClient         *test.KubeClient
+	ServingAlphaClient *ServingAlphaClients
+	ServingClient      *ServingClients
+	NetworkingClient   *NetworkingClients
+	Dynamic            dynamic.Interface
 }
 
-// ServingClients holds instances of interfaces for making requests to knative serving clients
+// ServingAlphaClients holds instances of interfaces for making requests to knative serving clients.
+type ServingAlphaClients struct {
+	DomainMappings servingv1alpha1.DomainMappingInterface
+}
+
+// ServingClients holds instances of interfaces for making requests to knative serving clients.
 type ServingClients struct {
 	Routes    servingv1.RouteInterface
 	Configs   servingv1.ConfigurationInterface
@@ -95,6 +102,11 @@ func NewClientsFromConfig(cfg *rest.Config, namespace string) (*Clients, error)
 		return nil, err
 	}
 
+	clients.ServingAlphaClient, err = newServingAlphaClients(cfg, namespace)
+	if err != nil {
+		return nil, err
+	}
+
 	clients.Dynamic, err = dynamic.NewForConfig(cfg)
 	if err != nil {
 		return nil, err
@@ -109,7 +121,7 @@ func NewClientsFromConfig(cfg *rest.Config, namespace string) (*Clients, error)
 }
 
 // newNetworkingClients instantiates and returns the networking clientset required to make requests
-// to Networking resources on the Knative service cluster
+// to Networking resources on the Knative service cluster.
 func newNetworkingClients(cfg *rest.Config, namespace string) (*NetworkingClients, error) {
 	cs, err := netclientset.NewForConfig(cfg)
 	if err != nil {
@@ -122,6 +134,19 @@ func newNetworkingClients(cfg *rest.Config, namespace string) (*NetworkingClient
 	}, nil
 }
 
+// newServingAlphaClients instantiates and returns the serving clientset required to make requests to the
+// knative serving cluster.
+func newServingAlphaClients(cfg *rest.Config, namespace string) (*ServingAlphaClients, error) {
+	cs, err := versioned.NewForConfig(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ServingAlphaClients{
+		DomainMappings: cs.ServingV1alpha1().DomainMappings(namespace),
+	}, nil
+}
+
 // newServingClients instantiates and returns the serving clientset required to make requests to the
 // knative serving cluster.
 func newServingClients(cfg *rest.Config, namespace string) (*ServingClients, error) {

test/conformance/api/v1alpha1/domain_mapping_test.go

@@ -0,0 +1,100 @@
+// +build e2e
+
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1alpha1
+
+import (
+	"context"
+	"net/url"
+	"testing"
+	"time"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	duckv1 "knative.dev/pkg/apis/duck/v1"
+	"knative.dev/serving/pkg/apis/serving/v1alpha1"
+	"knative.dev/serving/test"
+	"knative.dev/serving/test/conformance/api/shared"
+	v1test "knative.dev/serving/test/v1"
+)
+
+func TestDomainMapping(t *testing.T) {
+	if !test.ServingFlags.EnableAlphaFeatures {
+		t.Skip("Alpha features not enabled")
+	}
+
+	t.Parallel()
+	ctx, clients := context.Background(), test.Setup(t)
+
+	names := test.ResourceNames{
+		Service: test.ObjectNameForTest(t),
+		Image:   test.HelloWorld,
+	}
+
+	// Clean up on test failure or interrupt.
+	test.EnsureTearDown(t, clients, &names)
+
+	// Setup initial Service.
+	svc, err := v1test.CreateServiceReady(t, clients, &names)
+	if err != nil {
+		t.Fatalf("Failed to create initial Service %v: %v", names.Service, err)
+	}
+
+	// Using fixed hostnames can lead to conflicts when multiple tests run at
+	// once, so include the svc name to avoid collisions.
+	host := svc.Service.Name + ".mapping.com"
+
+	// Point DomainMapping at our service.
+	dm, err := clients.ServingAlphaClient.DomainMappings.Create(ctx, &v1alpha1.DomainMapping{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      host,
+			Namespace: svc.Service.Namespace,
+		},
+		Spec: v1alpha1.DomainMappingSpec{
+			Ref: duckv1.KReference{
+				Namespace: svc.Service.Namespace,
+				Name:      svc.Service.Name,
+			},
+		},
+	}, metav1.CreateOptions{})
+	if err != nil {
+		t.Fatalf("Create(DomainMapping) = %v, expected no error", err)
+	}
+
+	t.Cleanup(func() {
+		clients.ServingAlphaClient.DomainMappings.Delete(ctx, dm.Name, metav1.DeleteOptions{})
+	})
+
+	// Wait for DomainMapping to go Ready.
+	waitErr := wait.PollImmediate(test.PollInterval, 1*time.Minute, func() (bool, error) {
+		state, err := clients.ServingAlphaClient.DomainMappings.Get(context.Background(), dm.Name, metav1.GetOptions{})
+		if err != nil {
+			return true, err
+		}
+
+		return state.Status.IsReady(), nil
+	})
+	if waitErr != nil {
+		t.Fatalf("The DomainMapping %s was not marked as Ready: %v", dm.Name, waitErr)
+	}
+
+	// Should be able to access the test image text via the mapped domain.
+	if err := shared.CheckDistribution(ctx, t, clients, &url.URL{Host: host, Scheme: "http"}, test.ConcurrentRequests, test.ConcurrentRequests, []string{test.HelloWorldText}); err != nil {
+		t.Errorf("CheckDistribution=%v, expected no error", err)
+	}
+}