tc_server_test.go

Documentation: github.com/chaos-mesh/chaos-mesh/pkg/chaosdaemon

     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 chaosdaemon
    17  
    18  import (
    19  	"testing"
    20  
    21  	. "github.com/onsi/gomega"
    22  
    23  	pb "github.com/chaos-mesh/chaos-mesh/pkg/chaosdaemon/pb"
    24  )
    25  
    26  func Test_generateQdiscArgs(t *testing.T) {
    27  	g := NewWithT(t)
    28  
    29  	typ := "netem"
    30  
    31  	t.Run("without parent and handle", func(t *testing.T) {
    32  
    33  		args, err := generateQdiscArgs("add", &pb.Qdisc{Type: typ})
    34  
    35  		g.Expect(err).To(BeNil())
    36  		g.Expect(args).To(Equal([]string{"qdisc", "add", "dev", "eth0", "root", "handle", "1:0", typ}))
    37  	})
    38  
    39  	t.Run("with parent and handle", func(t *testing.T) {
    40  		args, err := generateQdiscArgs("add", &pb.Qdisc{
    41  			Type: typ,
    42  			Parent: &pb.TcHandle{
    43  				Major: 1,
    44  				Minor: 1,
    45  			},
    46  			Handle: &pb.TcHandle{
    47  				Major: 10,
    48  				Minor: 0,
    49  			},
    50  		})
    51  
    52  		g.Expect(err).To(BeNil())
    53  		g.Expect(args).To(Equal([]string{"qdisc", "add", "dev", "eth0", "parent", "1:1", "handle", "10:0", typ}))
    54  	})
    55  }
    56  
    57  func Test_convertNetemToArgs(t *testing.T) {
    58  	g := NewWithT(t)
    59  
    60  	t.Run("convert network delay", func(t *testing.T) {
    61  		args := convertNetemToArgs(&pb.Netem{
    62  			Time: 1000,
    63  		})
    64  		g.Expect(args).To(Equal("delay 1000"))
    65  
    66  		args = convertNetemToArgs(&pb.Netem{
    67  			Time:      1000,
    68  			DelayCorr: 25,
    69  		})
    70  		g.Expect(args).To(Equal("delay 1000"))
    71  
    72  		args = convertNetemToArgs(&pb.Netem{
    73  			Time:      1000,
    74  			Jitter:    10000,
    75  			DelayCorr: 25,
    76  		})
    77  		g.Expect(args).To(Equal("delay 1000 10000 25.000000"))
    78  	})
    79  
    80  	t.Run("convert packet limit", func(t *testing.T) {
    81  		args := convertNetemToArgs(&pb.Netem{
    82  			Limit: 1000,
    83  		})
    84  		g.Expect(args).To(Equal("limit 1000"))
    85  	})
    86  
    87  	t.Run("convert packet loss", func(t *testing.T) {
    88  		args := convertNetemToArgs(&pb.Netem{
    89  			Loss: 100,
    90  		})
    91  		g.Expect(args).To(Equal("loss 100.000000"))
    92  
    93  		args = convertNetemToArgs(&pb.Netem{
    94  			Loss:     50,
    95  			LossCorr: 12,
    96  		})
    97  		g.Expect(args).To(Equal("loss 50.000000 12.000000"))
    98  	})
    99  
   100  	t.Run("convert packet reorder", func(t *testing.T) {
   101  		args := convertNetemToArgs(&pb.Netem{
   102  			Reorder:     5,
   103  			ReorderCorr: 10,
   104  		})
   105  		g.Expect(args).To(Equal(""))
   106  
   107  		args = convertNetemToArgs(&pb.Netem{
   108  			Time:        1000,
   109  			Jitter:      10000,
   110  			DelayCorr:   25,
   111  			Reorder:     5,
   112  			ReorderCorr: 10,
   113  			Gap:         10,
   114  		})
   115  		g.Expect(args).To(Equal("delay 1000 10000 25.000000 reorder 5.000000 10.000000 gap 10"))
   116  
   117  		args = convertNetemToArgs(&pb.Netem{
   118  			Time:        1000,
   119  			Jitter:      10000,
   120  			DelayCorr:   25,
   121  			Reorder:     5,
   122  			ReorderCorr: 10,
   123  			Gap:         10,
   124  		})
   125  		g.Expect(args).To(Equal("delay 1000 10000 25.000000 reorder 5.000000 10.000000 gap 10"))
   126  
   127  		args = convertNetemToArgs(&pb.Netem{
   128  			Time:      1000,
   129  			Jitter:    10000,
   130  			DelayCorr: 25,
   131  			Reorder:   5,
   132  			Gap:       10,
   133  		})
   134  		g.Expect(args).To(Equal("delay 1000 10000 25.000000 reorder 5.000000 gap 10"))
   135  	})
   136  
   137  	t.Run("convert packet duplication", func(t *testing.T) {
   138  		args := convertNetemToArgs(&pb.Netem{
   139  			Duplicate: 10,
   140  		})
   141  		g.Expect(args).To(Equal("duplicate 10.000000"))
   142  
   143  		args = convertNetemToArgs(&pb.Netem{
   144  			Duplicate:     10,
   145  			DuplicateCorr: 50,
   146  		})
   147  		g.Expect(args).To(Equal("duplicate 10.000000 50.000000"))
   148  	})
   149  
   150  	t.Run("convert packet corrupt", func(t *testing.T) {
   151  		args := convertNetemToArgs(&pb.Netem{
   152  			Corrupt: 10,
   153  		})
   154  		g.Expect(args).To(Equal("corrupt 10.000000"))
   155  
   156  		args = convertNetemToArgs(&pb.Netem{
   157  			Corrupt:     10,
   158  			CorruptCorr: 50,
   159  		})
   160  		g.Expect(args).To(Equal("corrupt 10.000000 50.000000"))
   161  	})
   162  
   163  	t.Run("complicate cases", func(t *testing.T) {
   164  		args := convertNetemToArgs(&pb.Netem{
   165  			Time:        1000,
   166  			Jitter:      10000,
   167  			Reorder:     5,
   168  			Gap:         10,
   169  			Corrupt:     10,
   170  			CorruptCorr: 50,
   171  		})
   172  		g.Expect(args).To(Equal("delay 1000 10000 reorder 5.000000 gap 10 corrupt 10.000000 50.000000"))
   173  	})
   174  
   175  	t.Run("delay with rate", func(t *testing.T) {
   176  		args := convertNetemToArgs(&pb.Netem{
   177  			Time:   1000,
   178  			Jitter: 10000,
   179  			Rate:   "8000bit",
   180  		})
   181  		g.Expect(args).To(Equal("delay 1000 10000 rate 8000bit"))
   182  	})
   183  }
   184