networkchaos_webhook_test.go

Documentation: github.com/chaos-mesh/chaos-mesh/api/v1alpha1

     1  // Copyright 2021 Chaos Mesh Authors.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  // http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  //
    15  
    16  package v1alpha1
    17  
    18  import (
    19  	. "github.com/onsi/ginkgo/v2"
    20  	. "github.com/onsi/gomega"
    21  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    22  )
    23  
    24  var _ = Describe("networkchaos_webhook", func() {
    25  	Context("Defaulter", func() {
    26  		It("set default namespace selector", func() {
    27  			networkchaos := &NetworkChaos{
    28  				ObjectMeta: metav1.ObjectMeta{Namespace: metav1.NamespaceDefault},
    29  			}
    30  			networkchaos.Default()
    31  			Expect(networkchaos.Spec.Selector.Namespaces[0]).To(Equal(metav1.NamespaceDefault))
    32  		})
    33  
    34  		It("set default DelaySpec", func() {
    35  			networkchaos := &NetworkChaos{
    36  				ObjectMeta: metav1.ObjectMeta{Namespace: metav1.NamespaceDefault},
    37  				Spec: NetworkChaosSpec{
    38  					TcParameter: TcParameter{
    39  						Delay: &DelaySpec{
    40  							Latency: "90ms",
    41  						},
    42  					},
    43  				},
    44  			}
    45  			networkchaos.Default()
    46  			Expect(string(networkchaos.Spec.Delay.Correlation)).To(Equal(DefaultCorrelation))
    47  			Expect(string(networkchaos.Spec.Delay.Jitter)).To(Equal(DefaultJitter))
    48  		})
    49  	})
    50  	Context("webhook.Validator of networkchaos", func() {
    51  		It("Validate", func() {
    52  
    53  			type TestCase struct {
    54  				name    string
    55  				chaos   NetworkChaos
    56  				execute func(chaos *NetworkChaos) error
    57  				expect  string
    58  			}
    59  			tcs := []TestCase{
    60  				{
    61  					name: "simple ValidateCreate",
    62  					chaos: NetworkChaos{
    63  						ObjectMeta: metav1.ObjectMeta{
    64  							Namespace: metav1.NamespaceDefault,
    65  							Name:      "foo1",
    66  						},
    67  					},
    68  					execute: func(chaos *NetworkChaos) error {
    69  						_, err := chaos.ValidateCreate()
    70  						return err
    71  					},
    72  					expect: "",
    73  				},
    74  				{
    75  					name: "simple ValidateUpdate",
    76  					chaos: NetworkChaos{
    77  						ObjectMeta: metav1.ObjectMeta{
    78  							Namespace: metav1.NamespaceDefault,
    79  							Name:      "foo2",
    80  						},
    81  					},
    82  					execute: func(chaos *NetworkChaos) error {
    83  						_, err := chaos.ValidateUpdate(chaos)
    84  						return err
    85  					},
    86  					expect: "",
    87  				},
    88  				{
    89  					name: "simple ValidateDelete",
    90  					chaos: NetworkChaos{
    91  						ObjectMeta: metav1.ObjectMeta{
    92  							Namespace: metav1.NamespaceDefault,
    93  							Name:      "foo3",
    94  						},
    95  					},
    96  					execute: func(chaos *NetworkChaos) error {
    97  						_, err := chaos.ValidateDelete()
    98  						return err
    99  					},
   100  					expect: "",
   101  				},
   102  				{
   103  					name: "validate the delay",
   104  					chaos: NetworkChaos{
   105  						ObjectMeta: metav1.ObjectMeta{
   106  							Namespace: metav1.NamespaceDefault,
   107  							Name:      "foo6",
   108  						},
   109  						Spec: NetworkChaosSpec{
   110  							TcParameter: TcParameter{
   111  								Delay: &DelaySpec{
   112  									Latency:     "1S",
   113  									Jitter:      "1S",
   114  									Correlation: "num",
   115  								},
   116  							},
   117  						},
   118  					},
   119  					execute: func(chaos *NetworkChaos) error {
   120  						_, err := chaos.ValidateCreate()
   121  						return err
   122  					},
   123  					expect: "error",
   124  				},
   125  				{
   126  					name: "validate the reorder",
   127  					chaos: NetworkChaos{
   128  						ObjectMeta: metav1.ObjectMeta{
   129  							Namespace: metav1.NamespaceDefault,
   130  							Name:      "foo7",
   131  						},
   132  						Spec: NetworkChaosSpec{
   133  							TcParameter: TcParameter{
   134  								Delay: &DelaySpec{
   135  									Reorder: &ReorderSpec{
   136  										Reorder:     "num",
   137  										Correlation: "num",
   138  									},
   139  								},
   140  							},
   141  						},
   142  					},
   143  					execute: func(chaos *NetworkChaos) error {
   144  						_, err := chaos.ValidateCreate()
   145  						return err
   146  					},
   147  					expect: "error",
   148  				},
   149  				{
   150  					name: "validate the loss",
   151  					chaos: NetworkChaos{
   152  						ObjectMeta: metav1.ObjectMeta{
   153  							Namespace: metav1.NamespaceDefault,
   154  							Name:      "foo8",
   155  						},
   156  						Spec: NetworkChaosSpec{
   157  							TcParameter: TcParameter{
   158  								Loss: &LossSpec{
   159  									Loss:        "num",
   160  									Correlation: "num",
   161  								},
   162  							},
   163  						},
   164  					},
   165  					execute: func(chaos *NetworkChaos) error {
   166  						_, err := chaos.ValidateCreate()
   167  						return err
   168  					},
   169  					expect: "error",
   170  				},
   171  				{
   172  					name: "validate the duplicate",
   173  					chaos: NetworkChaos{
   174  						ObjectMeta: metav1.ObjectMeta{
   175  							Namespace: metav1.NamespaceDefault,
   176  							Name:      "foo9",
   177  						},
   178  						Spec: NetworkChaosSpec{
   179  							TcParameter: TcParameter{
   180  								Duplicate: &DuplicateSpec{
   181  									Duplicate:   "num",
   182  									Correlation: "num",
   183  								},
   184  							},
   185  						},
   186  					},
   187  					execute: func(chaos *NetworkChaos) error {
   188  						_, err := chaos.ValidateCreate()
   189  						return err
   190  					},
   191  					expect: "error",
   192  				},
   193  				{
   194  					name: "validate the corrupt",
   195  					chaos: NetworkChaos{
   196  						ObjectMeta: metav1.ObjectMeta{
   197  							Namespace: metav1.NamespaceDefault,
   198  							Name:      "foo10",
   199  						},
   200  						Spec: NetworkChaosSpec{
   201  							TcParameter: TcParameter{
   202  								Corrupt: &CorruptSpec{
   203  									Corrupt:     "num",
   204  									Correlation: "num",
   205  								},
   206  							},
   207  						},
   208  					},
   209  					execute: func(chaos *NetworkChaos) error {
   210  						_, err := chaos.ValidateCreate()
   211  						return err
   212  					},
   213  					expect: "error",
   214  				},
   215  				{
   216  					name: "validate the bandwidth",
   217  					chaos: NetworkChaos{
   218  						ObjectMeta: metav1.ObjectMeta{
   219  							Namespace: metav1.NamespaceDefault,
   220  							Name:      "foo11",
   221  						},
   222  						Spec: NetworkChaosSpec{
   223  							TcParameter: TcParameter{
   224  								Bandwidth: &BandwidthSpec{
   225  									Rate: "10",
   226  								},
   227  							},
   228  						},
   229  					},
   230  					execute: func(chaos *NetworkChaos) error {
   231  						_, err := chaos.ValidateCreate()
   232  						return err
   233  					},
   234  					expect: "error",
   235  				},
   236  				{
   237  					name: "validate the rate",
   238  					chaos: NetworkChaos{
   239  						ObjectMeta: metav1.ObjectMeta{
   240  							Namespace: metav1.NamespaceDefault,
   241  							Name:      "foo11",
   242  						},
   243  						Spec: NetworkChaosSpec{
   244  							TcParameter: TcParameter{
   245  								Rate: &RateSpec{
   246  									Rate: "10",
   247  								},
   248  							},
   249  						},
   250  					},
   251  					execute: func(chaos *NetworkChaos) error {
   252  						_, err := chaos.ValidateCreate()
   253  						return err
   254  					},
   255  					expect: "error",
   256  				},
   257  				{
   258  					name: "validate the target",
   259  					chaos: NetworkChaos{
   260  						ObjectMeta: metav1.ObjectMeta{
   261  							Namespace: metav1.NamespaceDefault,
   262  							Name:      "foo12",
   263  						},
   264  						Spec: NetworkChaosSpec{
   265  							Target: &PodSelector{
   266  								Mode:  FixedMode,
   267  								Value: "0",
   268  							},
   269  						},
   270  					},
   271  					execute: func(chaos *NetworkChaos) error {
   272  						_, err := chaos.ValidateCreate()
   273  						return err
   274  					},
   275  					expect: "error",
   276  				},
   277  				{
   278  					name: "validate direction and externalTargets",
   279  					chaos: NetworkChaos{
   280  						ObjectMeta: metav1.ObjectMeta{
   281  							Namespace: metav1.NamespaceDefault,
   282  							Name:      "foo12",
   283  						},
   284  						Spec: NetworkChaosSpec{
   285  							Direction:       From,
   286  							ExternalTargets: []string{"8.8.8.8"},
   287  						},
   288  					},
   289  					execute: func(chaos *NetworkChaos) error {
   290  						_, err := chaos.ValidateCreate()
   291  						return err
   292  					},
   293  					expect: "error",
   294  				},
   295  			}
   296  
   297  			for _, tc := range tcs {
   298  				err := tc.execute(&tc.chaos)
   299  				if tc.expect == "error" {
   300  					Expect(err).To(HaveOccurred())
   301  				} else {
   302  					Expect(err).NotTo(HaveOccurred())
   303  				}
   304  			}
   305  		})
   306  	})
   307  	Context("isValidRateUnit", func() {
   308  		It("mbps unit, should convert number with unit successfully", func() {
   309  			isValid, err := isValidRateUnit("  10   mbPs  ")
   310  			Expect(err).Should(Succeed())
   311  			Expect(isValid).To(Equal(true))
   312  		})
   313  
   314  		It("kbit unit, should convert number with unit successfully", func() {
   315  			isValid, err := isValidRateUnit("  10   kbit  ")
   316  			Expect(err).Should(Succeed())
   317  			Expect(isValid).To(Equal(true))
   318  		})
   319  
   320  		It("should return error with invalid unit", func() {
   321  			isValid, err := isValidRateUnit(" 10 cpbs")
   322  			Expect(err).Should(HaveOccurred())
   323  			Expect(isValid).To(Equal(false))
   324  		})
   325  	})
   326  })
   327