From f63c135e1fe5c443eae47f6b7f1d04cb0ba2a71a Mon Sep 17 00:00:00 2001 From: Shiming Zhang Date: Tue, 28 Sep 2021 16:23:52 +0800 Subject: [PATCH 1/2] Update comments --- .../client-go/kubernetes/typed/core/v1/event_expansion.go | 1 + .../kubernetes/typed/events/v1beta1/event_expansion.go | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/staging/src/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion.go b/staging/src/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion.go index 31e4c386386..a3fdf57a987 100644 --- a/staging/src/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion.go +++ b/staging/src/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion.go @@ -34,6 +34,7 @@ type EventExpansion interface { CreateWithEventNamespace(event *v1.Event) (*v1.Event, error) // UpdateWithEventNamespace is the same as a Update, except that it sends the request to the event.Namespace. UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error) + // PatchWithEventNamespace is the same as a Patch, except that it sends the request to the event.Namespace. PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.Event, error) // Search finds events about the specified object Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.EventList, error) diff --git a/staging/src/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion.go b/staging/src/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion.go index e0ae41dfe75..7213193bf1b 100644 --- a/staging/src/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion.go +++ b/staging/src/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion.go @@ -33,7 +33,7 @@ type EventExpansion interface { // UpdateWithEventNamespace is the same as a Update // except that it sends the request to the event.Namespace. UpdateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error) - // PatchWithEventNamespace is the same as an Update + // PatchWithEventNamespace is the same as a Patch // except that it sends the request to the event.Namespace. PatchWithEventNamespace(event *v1beta1.Event, data []byte) (*v1beta1.Event, error) } From 13fe94f136a15dd45b75262517a36b14d1e094a9 Mon Sep 17 00:00:00 2001 From: Shiming Zhang Date: Tue, 28 Sep 2021 18:07:34 +0800 Subject: [PATCH 2/2] Add unit test coverage for events expansion --- .../typed/core/v1/event_expansion_test.go | 176 ++++++++++++++++++ .../events/v1beta1/event_expansion_test.go | 176 ++++++++++++++++++ 2 files changed, 352 insertions(+) create mode 100644 staging/src/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion_test.go create mode 100644 staging/src/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion_test.go diff --git a/staging/src/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion_test.go b/staging/src/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion_test.go new file mode 100644 index 00000000000..14fa12bf089 --- /dev/null +++ b/staging/src/k8s.io/client-go/kubernetes/typed/core/v1/event_expansion_test.go @@ -0,0 +1,176 @@ +/* +Copyright 2021 The Kubernetes 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 v1 + +import ( + "io" + "net/http" + "strings" + "testing" + + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/scheme" + restfake "k8s.io/client-go/rest/fake" +) + +func TestCreateWithEventNamespace(t *testing.T) { + event := &v1.Event{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Namespace: "default", + }, + } + cli := &restfake.RESTClient{ + Client: restfake.CreateHTTPClient(func(request *http.Request) (*http.Response, error) { + resp := &http.Response{ + StatusCode: http.StatusOK, + Body: io.NopCloser(strings.NewReader("{}")), + } + return resp, nil + }), + NegotiatedSerializer: scheme.Codecs.WithoutConversion(), + } + + tests := []struct { + name string + ns string + event *v1.Event + wantErr bool + }{ + { + name: "create event", + ns: "default", + event: event, + }, + { + name: "create event with different namespace", + ns: "other", + event: event, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + e := newEvents(New(cli), tt.ns) + _, err := e.CreateWithEventNamespace(tt.event) + if (err != nil) != tt.wantErr { + t.Errorf("CreateWithEventNamespace() error = %v, wantErr %v", err, tt.wantErr) + return + } + }) + } +} + +func TestPatchWithEventNamespace(t *testing.T) { + event := &v1.Event{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Namespace: "default", + }, + } + cli := &restfake.RESTClient{ + Client: restfake.CreateHTTPClient(func(request *http.Request) (*http.Response, error) { + resp := &http.Response{ + StatusCode: http.StatusOK, + Body: io.NopCloser(strings.NewReader("{}")), + } + return resp, nil + }), + NegotiatedSerializer: scheme.Codecs.WithoutConversion(), + } + + tests := []struct { + name string + ns string + event *v1.Event + data []byte + wantErr bool + }{ + { + name: "patch event", + ns: "default", + event: event, + data: []byte{}, + }, + { + name: "patch event with different namespace", + ns: "other", + event: event, + data: []byte{}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + e := newEvents(New(cli), tt.ns) + _, err := e.PatchWithEventNamespace(tt.event, tt.data) + if (err != nil) != tt.wantErr { + t.Errorf("PatchWithEventNamespace() error = %v, wantErr %v", err, tt.wantErr) + return + } + }) + } +} + +func TestUpdateWithEventNamespace(t *testing.T) { + event := &v1.Event{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Namespace: "default", + }, + } + cli := &restfake.RESTClient{ + Client: restfake.CreateHTTPClient(func(request *http.Request) (*http.Response, error) { + resp := &http.Response{ + StatusCode: http.StatusOK, + Body: io.NopCloser(strings.NewReader("{}")), + } + return resp, nil + }), + NegotiatedSerializer: scheme.Codecs.WithoutConversion(), + } + + tests := []struct { + name string + ns string + event *v1.Event + wantErr bool + }{ + { + name: "patch event", + ns: "default", + event: event, + }, + { + name: "patch event with different namespace", + ns: "other", + event: event, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + e := newEvents(New(cli), tt.ns) + _, err := e.UpdateWithEventNamespace(tt.event) + if (err != nil) != tt.wantErr { + t.Errorf("UpdateWithEventNamespace() error = %v, wantErr %v", err, tt.wantErr) + return + } + }) + } +} diff --git a/staging/src/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion_test.go b/staging/src/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion_test.go new file mode 100644 index 00000000000..6e69ee6638c --- /dev/null +++ b/staging/src/k8s.io/client-go/kubernetes/typed/events/v1beta1/event_expansion_test.go @@ -0,0 +1,176 @@ +/* +Copyright 2021 The Kubernetes 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 v1beta1 + +import ( + "io" + "net/http" + "strings" + "testing" + + "k8s.io/api/events/v1beta1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes/scheme" + restfake "k8s.io/client-go/rest/fake" +) + +func TestCreateWithEventNamespace(t *testing.T) { + event := &v1beta1.Event{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Namespace: "default", + }, + } + cli := &restfake.RESTClient{ + Client: restfake.CreateHTTPClient(func(request *http.Request) (*http.Response, error) { + resp := &http.Response{ + StatusCode: http.StatusOK, + Body: io.NopCloser(strings.NewReader("{}")), + } + return resp, nil + }), + NegotiatedSerializer: scheme.Codecs.WithoutConversion(), + } + + tests := []struct { + name string + ns string + event *v1beta1.Event + wantErr bool + }{ + { + name: "create event", + ns: "default", + event: event, + }, + { + name: "create event with different namespace", + ns: "other", + event: event, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + e := newEvents(New(cli), tt.ns) + _, err := e.CreateWithEventNamespace(tt.event) + if (err != nil) != tt.wantErr { + t.Errorf("CreateWithEventNamespace() error = %v, wantErr %v", err, tt.wantErr) + return + } + }) + } +} + +func TestPatchWithEventNamespace(t *testing.T) { + event := &v1beta1.Event{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Namespace: "default", + }, + } + cli := &restfake.RESTClient{ + Client: restfake.CreateHTTPClient(func(request *http.Request) (*http.Response, error) { + resp := &http.Response{ + StatusCode: http.StatusOK, + Body: io.NopCloser(strings.NewReader("{}")), + } + return resp, nil + }), + NegotiatedSerializer: scheme.Codecs.WithoutConversion(), + } + + tests := []struct { + name string + ns string + event *v1beta1.Event + data []byte + wantErr bool + }{ + { + name: "patch event", + ns: "default", + event: event, + data: []byte{}, + }, + { + name: "patch event with different namespace", + ns: "other", + event: event, + data: []byte{}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + e := newEvents(New(cli), tt.ns) + _, err := e.PatchWithEventNamespace(tt.event, tt.data) + if (err != nil) != tt.wantErr { + t.Errorf("PatchWithEventNamespace() error = %v, wantErr %v", err, tt.wantErr) + return + } + }) + } +} + +func TestUpdateWithEventNamespace(t *testing.T) { + event := &v1beta1.Event{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Namespace: "default", + }, + } + cli := &restfake.RESTClient{ + Client: restfake.CreateHTTPClient(func(request *http.Request) (*http.Response, error) { + resp := &http.Response{ + StatusCode: http.StatusOK, + Body: io.NopCloser(strings.NewReader("{}")), + } + return resp, nil + }), + NegotiatedSerializer: scheme.Codecs.WithoutConversion(), + } + + tests := []struct { + name string + ns string + event *v1beta1.Event + wantErr bool + }{ + { + name: "patch event", + ns: "default", + event: event, + }, + { + name: "patch event with different namespace", + ns: "other", + event: event, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + e := newEvents(New(cli), tt.ns) + _, err := e.UpdateWithEventNamespace(tt.event) + if (err != nil) != tt.wantErr { + t.Errorf("UpdateWithEventNamespace() error = %v, wantErr %v", err, tt.wantErr) + return + } + }) + } +}