github.com/justinjmoses/evergreen@v0.0.0-20170530173719-1d50e381ff0d/agent/comm/mock_communicator.go (about)

     1  package comm
     2  
     3  import (
     4  	"net/http"
     5  	"sync"
     6  
     7  	"github.com/evergreen-ci/evergreen/apimodels"
     8  	"github.com/evergreen-ci/evergreen/model"
     9  	"github.com/evergreen-ci/evergreen/model/distro"
    10  	"github.com/evergreen-ci/evergreen/model/task"
    11  	"github.com/evergreen-ci/evergreen/model/version"
    12  	"github.com/mongodb/grip"
    13  	"github.com/mongodb/grip/slogger"
    14  	"github.com/pkg/errors"
    15  )
    16  
    17  type MockCommunicator struct {
    18  	shouldFailStart     bool
    19  	shouldFailEnd       bool
    20  	shouldFailHeartbeat bool
    21  	abort               bool
    22  	TaskId              string
    23  	TaskSecret          string
    24  	LogChan             chan []model.LogMessage
    25  	Posts               map[string][]interface{}
    26  	sync.RWMutex
    27  }
    28  
    29  func (mc *MockCommunicator) SetTask(taskId, taskSecret string) {
    30  
    31  	mc.TaskId = taskId
    32  	mc.TaskSecret = taskSecret
    33  }
    34  
    35  func (mc *MockCommunicator) GetCurrentTaskId() string {
    36  	return mc.TaskId
    37  }
    38  
    39  func (mc *MockCommunicator) Reset(commSignal chan Signal, timeoutWatcher *TimeoutWatcher) (*APILogger, *StreamLogger, error) {
    40  	return nil, nil, nil
    41  }
    42  
    43  func (*MockCommunicator) TryGet(path string) (*http.Response, error) {
    44  	return nil, nil
    45  }
    46  
    47  func (*MockCommunicator) TryTaskGet(path string) (*http.Response, error) {
    48  	return nil, nil
    49  }
    50  
    51  func (mc *MockCommunicator) TryPostJSON(path string, data interface{}) (*http.Response, error) {
    52  	mc.Lock()
    53  	defer mc.Unlock()
    54  
    55  	if mc.Posts != nil {
    56  		mc.Posts[path] = append(mc.Posts[path], data)
    57  	} else {
    58  		grip.Warningf("post to %s is not persisted in the path")
    59  	}
    60  
    61  	return nil, nil
    62  }
    63  
    64  func (mc *MockCommunicator) TryTaskPost(path string, data interface{}) (*http.Response, error) {
    65  	mc.Lock()
    66  	defer mc.Unlock()
    67  
    68  	if mc.Posts != nil {
    69  		mc.Posts[path] = append(mc.Posts[path], data)
    70  	} else {
    71  		grip.Warningf("post to %s is not persisted in the path")
    72  	}
    73  
    74  	return nil, nil
    75  }
    76  
    77  func (mc *MockCommunicator) Start() error {
    78  	mc.RLock()
    79  	defer mc.RUnlock()
    80  
    81  	if mc.shouldFailStart {
    82  		return errors.New("failed to start")
    83  	}
    84  	return nil
    85  }
    86  
    87  func (mc *MockCommunicator) End(details *apimodels.TaskEndDetail) (*apimodels.EndTaskResponse, error) {
    88  	mc.RLock()
    89  	defer mc.RUnlock()
    90  
    91  	if mc.shouldFailEnd {
    92  		return nil, errors.New("failed to end")
    93  	}
    94  	return nil, nil
    95  }
    96  
    97  func (*MockCommunicator) GetTask() (*task.Task, error) {
    98  	return &task.Task{}, nil
    99  }
   100  
   101  func (*MockCommunicator) GetDistro() (*distro.Distro, error) {
   102  	return &distro.Distro{}, nil
   103  }
   104  
   105  func (*MockCommunicator) GetProjectRef() (*model.ProjectRef, error) {
   106  	return &model.ProjectRef{}, nil
   107  }
   108  
   109  func (*MockCommunicator) GetVersion() (*version.Version, error) {
   110  	return &version.Version{}, nil
   111  }
   112  
   113  func (*MockCommunicator) GetNextTask() (*apimodels.NextTaskResponse, error) {
   114  	return &apimodels.NextTaskResponse{}, nil
   115  }
   116  
   117  func (mc *MockCommunicator) setAbort(b bool) {
   118  	mc.Lock()
   119  	defer mc.Unlock()
   120  
   121  	mc.abort = b
   122  }
   123  
   124  func (mc *MockCommunicator) setShouldFail(b bool) {
   125  	mc.Lock()
   126  	defer mc.Unlock()
   127  
   128  	mc.shouldFailHeartbeat = b
   129  }
   130  
   131  func (mc *MockCommunicator) Log(logMessages []model.LogMessage) error {
   132  	mc.RLock()
   133  	defer mc.RUnlock()
   134  
   135  	if mc.shouldFailEnd {
   136  		return errors.New("failed to end")
   137  	}
   138  
   139  	if mc.LogChan != nil {
   140  		mc.LogChan <- logMessages
   141  	} else {
   142  		grip.Warningf("passing over %d log messages because un-configured channel",
   143  			len(logMessages))
   144  	}
   145  
   146  	return nil
   147  }
   148  
   149  func (mc *MockCommunicator) Heartbeat() (bool, error) {
   150  	mc.RLock()
   151  	defer mc.RUnlock()
   152  
   153  	if mc.shouldFailHeartbeat {
   154  		return false, errors.New("failed to heartbeat")
   155  	}
   156  	return mc.abort, nil
   157  }
   158  
   159  func (*MockCommunicator) FetchExpansionVars() (*apimodels.ExpansionVars, error) {
   160  	return &apimodels.ExpansionVars{}, nil
   161  }
   162  
   163  func (m *MockCommunicator) SetSignalChan(chan Signal) {
   164  	return
   165  }
   166  
   167  func (m *MockCommunicator) SetLogger(*slogger.Logger) {
   168  	return
   169  }