kind_visitor_test.go

Documentation: k8s.io/kubectl/pkg/apps

     1  /*
     2  Copyright 2017 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package apps
    18  
    19  import (
    20  	. "github.com/onsi/ginkgo/v2"
    21  	. "github.com/onsi/gomega"
    22  )
    23  
    24  var _ = Describe("When KindVisitor accepts a GroupKind", func() {
    25  
    26  	var visitor *TestKindVisitor
    27  
    28  	BeforeEach(func() {
    29  		visitor = &TestKindVisitor{map[string]int{}}
    30  	})
    31  
    32  	It("should Visit DaemonSet iff the Kind is a DaemonSet", func() {
    33  		kind := GroupKindElement{
    34  			Kind:  "DaemonSet",
    35  			Group: "apps",
    36  		}
    37  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
    38  		Expect(visitor.visits).To(Equal(map[string]int{
    39  			"DaemonSet": 1,
    40  		}))
    41  
    42  		kind = GroupKindElement{
    43  			Kind:  "DaemonSet",
    44  			Group: "extensions",
    45  		}
    46  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
    47  		Expect(visitor.visits).To(Equal(map[string]int{
    48  			"DaemonSet": 2,
    49  		}))
    50  	})
    51  
    52  	It("should Visit Deployment iff the Kind is a Deployment", func() {
    53  		kind := GroupKindElement{
    54  			Kind:  "Deployment",
    55  			Group: "apps",
    56  		}
    57  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
    58  		Expect(visitor.visits).To(Equal(map[string]int{
    59  			"Deployment": 1,
    60  		}))
    61  
    62  		kind = GroupKindElement{
    63  			Kind:  "Deployment",
    64  			Group: "extensions",
    65  		}
    66  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
    67  		Expect(visitor.visits).To(Equal(map[string]int{
    68  			"Deployment": 2,
    69  		}))
    70  	})
    71  
    72  	It("should Visit Job iff the Kind is a Job", func() {
    73  		kind := GroupKindElement{
    74  			Kind:  "Job",
    75  			Group: "batch",
    76  		}
    77  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
    78  		Expect(visitor.visits).To(Equal(map[string]int{
    79  			"Job": 1,
    80  		}))
    81  
    82  	})
    83  
    84  	It("should Visit Pod iff the Kind is a Pod", func() {
    85  		kind := GroupKindElement{
    86  			Kind:  "Pod",
    87  			Group: "",
    88  		}
    89  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
    90  		Expect(visitor.visits).To(Equal(map[string]int{
    91  			"Pod": 1,
    92  		}))
    93  
    94  		kind = GroupKindElement{
    95  			Kind:  "Pod",
    96  			Group: "core",
    97  		}
    98  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
    99  		Expect(visitor.visits).To(Equal(map[string]int{
   100  			"Pod": 2,
   101  		}))
   102  	})
   103  
   104  	It("should Visit ReplicationController iff the Kind is a ReplicationController", func() {
   105  		kind := GroupKindElement{
   106  			Kind:  "ReplicationController",
   107  			Group: "",
   108  		}
   109  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
   110  		Expect(visitor.visits).To(Equal(map[string]int{
   111  			"ReplicationController": 1,
   112  		}))
   113  
   114  		kind = GroupKindElement{
   115  			Kind:  "ReplicationController",
   116  			Group: "core",
   117  		}
   118  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
   119  		Expect(visitor.visits).To(Equal(map[string]int{
   120  			"ReplicationController": 2,
   121  		}))
   122  	})
   123  
   124  	It("should Visit ReplicaSet iff the Kind is a ReplicaSet", func() {
   125  		kind := GroupKindElement{
   126  			Kind:  "ReplicaSet",
   127  			Group: "extensions",
   128  		}
   129  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
   130  		Expect(visitor.visits).To(Equal(map[string]int{
   131  			"ReplicaSet": 1,
   132  		}))
   133  	})
   134  
   135  	It("should Visit StatefulSet iff the Kind is a StatefulSet", func() {
   136  		kind := GroupKindElement{
   137  			Kind:  "StatefulSet",
   138  			Group: "apps",
   139  		}
   140  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
   141  		Expect(visitor.visits).To(Equal(map[string]int{
   142  			"StatefulSet": 1,
   143  		}))
   144  	})
   145  
   146  	It("should Visit CronJob iff the Kind is a CronJob", func() {
   147  		kind := GroupKindElement{
   148  			Kind:  "CronJob",
   149  			Group: "batch",
   150  		}
   151  		Expect(kind.Accept(visitor)).ShouldNot(HaveOccurred())
   152  		Expect(visitor.visits).To(Equal(map[string]int{
   153  			"CronJob": 1,
   154  		}))
   155  	})
   156  
   157  	It("should give an error if the Kind is unknown", func() {
   158  		kind := GroupKindElement{
   159  			Kind:  "Unknown",
   160  			Group: "apps",
   161  		}
   162  		Expect(kind.Accept(visitor)).Should(HaveOccurred())
   163  		Expect(visitor.visits).To(Equal(map[string]int{}))
   164  	})
   165  })
   166  
   167  // TestKindVisitor increments a value each time a Visit method was called
   168  type TestKindVisitor struct {
   169  	visits map[string]int
   170  }
   171  
   172  var _ KindVisitor = &TestKindVisitor{}
   173  
   174  func (t *TestKindVisitor) Visit(kind GroupKindElement) { t.visits[kind.Kind]++ }
   175  
   176  func (t *TestKindVisitor) VisitDaemonSet(kind GroupKindElement)             { t.Visit(kind) }
   177  func (t *TestKindVisitor) VisitDeployment(kind GroupKindElement)            { t.Visit(kind) }
   178  func (t *TestKindVisitor) VisitJob(kind GroupKindElement)                   { t.Visit(kind) }
   179  func (t *TestKindVisitor) VisitPod(kind GroupKindElement)                   { t.Visit(kind) }
   180  func (t *TestKindVisitor) VisitReplicaSet(kind GroupKindElement)            { t.Visit(kind) }
   181  func (t *TestKindVisitor) VisitReplicationController(kind GroupKindElement) { t.Visit(kind) }
   182  func (t *TestKindVisitor) VisitStatefulSet(kind GroupKindElement)           { t.Visit(kind) }
   183  func (t *TestKindVisitor) VisitCronJob(kind GroupKindElement)               { t.Visit(kind) }
   184
View as plain text