tasks_test.go

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

     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 tasks
    17  
    18  import (
    19  	"fmt"
    20  	"testing"
    21  
    22  	"github.com/go-logr/logr"
    23  	"github.com/go-logr/zapr"
    24  	"github.com/pkg/errors"
    25  	"github.com/stretchr/testify/assert"
    26  	"go.uber.org/zap"
    27  
    28  	"github.com/chaos-mesh/chaos-mesh/pkg/cerr"
    29  )
    30  
    31  type FakeConfig struct {
    32  	i int
    33  }
    34  
    35  func (f *FakeConfig) Merge(a Mergeable) error {
    36  	A, OK := a.(*FakeConfig)
    37  	if OK {
    38  		f.i += A.i
    39  		return nil
    40  	}
    41  	return cerr.NotType[*FakeConfig]().WrapInput(a).Err()
    42  }
    43  
    44  func (f *FakeConfig) DeepCopy() Object {
    45  	temp := *f
    46  	return &temp
    47  }
    48  
    49  func (f *FakeConfig) Assign(c Injectable) error {
    50  	C, OK := c.(*FakeChaos)
    51  	if OK {
    52  		C.C.i = f.i
    53  		return nil
    54  	}
    55  	return cerr.NotType[*FakeConfig]().WrapInput(c).Err()
    56  }
    57  
    58  func (f *FakeConfig) New(immutableValues interface{}) (Injectable, error) {
    59  	temp := immutableValues.(*FakeChaos)
    60  	f.Assign(temp)
    61  	return temp, nil
    62  }
    63  
    64  type FakeChaos struct {
    65  	C              FakeConfig
    66  	ErrWhenRecover bool
    67  	ErrWhenInject  bool
    68  	logger         logr.Logger
    69  }
    70  
    71  func (f *FakeChaos) Inject(pid IsID) error {
    72  	if f.ErrWhenInject {
    73  		return cerr.NotImpl[Injectable]().Err()
    74  	}
    75  	return nil
    76  }
    77  
    78  func (f *FakeChaos) Recover(pid IsID) error {
    79  	if f.ErrWhenRecover {
    80  		return cerr.NotImpl[Recoverable]().Err()
    81  	}
    82  	return nil
    83  }
    84  
    85  func TestTasksManager(t *testing.T) {
    86  	var log logr.Logger
    87  
    88  	zapLog, err := zap.NewDevelopment()
    89  	if err != nil {
    90  		panic(fmt.Sprintf("who watches the watchmen (%v)?", err))
    91  	}
    92  	log = zapr.NewLogger(zapLog)
    93  
    94  	m := NewTaskManager(log)
    95  
    96  	chaos := FakeChaos{
    97  		ErrWhenRecover: false,
    98  		ErrWhenInject:  false,
    99  		logger:         log,
   100  	}
   101  	task1 := FakeConfig{i: 1}
   102  	uid1 := "1"
   103  	err = m.Create(uid1, SysPID(1), &task1, &chaos)
   104  	chaosInterface, err := m.GetTaskWithPID(SysPID(1))
   105  	assert.NoError(t, err)
   106  	chaoso := chaosInterface.(*FakeChaos)
   107  	assert.Equal(t, chaoso.C, task1)
   108  	assert.Equal(t, chaoso, &chaos)
   109  
   110  	task2 := FakeConfig{i: 1}
   111  	uid2 := "2"
   112  	err = m.Apply(uid2, SysPID(1), &task2)
   113  	chaosInterface, err = m.GetTaskWithPID(SysPID(1))
   114  	assert.NoError(t, err)
   115  	chaoso = chaosInterface.(*FakeChaos)
   116  	assert.Equal(t, chaoso.C, FakeConfig{i: 2})
   117  	assert.Equal(t, chaos.C, FakeConfig{i: 2})
   118  
   119  	assert.Equal(t, task1, FakeConfig{1})
   120  	assert.Equal(t, task2, FakeConfig{1})
   121  }
   122  
   123  func TestTasksManagerError(t *testing.T) {
   124  	var log logr.Logger
   125  
   126  	zapLog, err := zap.NewDevelopment()
   127  	if err != nil {
   128  		panic(fmt.Sprintf("who watches the watchmen (%v)?", err))
   129  	}
   130  	log = zapr.NewLogger(zapLog)
   131  
   132  	m := NewTaskManager(log)
   133  
   134  	chaos := FakeChaos{
   135  		ErrWhenRecover: false,
   136  		ErrWhenInject:  false,
   137  		logger:         log,
   138  	}
   139  	task1 := FakeConfig{i: 1}
   140  	uid1 := "1"
   141  	err = m.Create(uid1, SysPID(1), &task1, &chaos)
   142  	assert.NoError(t, err)
   143  	err = m.Apply(uid1, SysPID(1), &task1)
   144  	assert.Equal(t, errors.Cause(err), cerr.ErrDuplicateEntity)
   145  	err = m.Recover(uid1, SysPID(1))
   146  	assert.NoError(t, err)
   147  	err = m.Recover(uid1, SysPID(1))
   148  	assert.Equal(t, errors.Cause(err), ErrNotFoundTaskID.Err())
   149  
   150  	chaos.ErrWhenInject = true
   151  	tasks2 := FakeConfig{i: 1}
   152  	err = m.Create(uid1, SysPID(1), &tasks2, &chaos)
   153  	assert.Equal(t, errors.Cause(err).Error(), cerr.NotImpl[Injectable]().Err().Error())
   154  	_, err = m.GetConfigWithUID(uid1)
   155  	assert.Equal(t, errors.Cause(err), ErrNotFoundTaskID.Err())
   156  
   157  	chaos.ErrWhenInject = false
   158  	chaos.ErrWhenRecover = true
   159  	tasks3 := FakeConfig{i: 1}
   160  	err = m.Create(uid1, SysPID(1), &tasks3, &chaos)
   161  	assert.NoError(t, err)
   162  	err = m.Recover(uid1, SysPID(1))
   163  	assert.Equal(t, errors.Cause(err).Error(), cerr.NotImpl[Recoverable]().Err().Error())
   164  	p, err := m.GetTaskWithPID(SysPID(1))
   165  	inner := p.(*FakeChaos)
   166  	inner.ErrWhenRecover = false
   167  	err = m.Recover(uid1, SysPID(1))
   168  	assert.NoError(t, err)
   169  }
   170