tc_server_test.go

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

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