github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/apiserver/undertaker/mock_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package undertaker_test
     5  
     6  import (
     7  	"time"
     8  
     9  	"github.com/juju/errors"
    10  	"github.com/juju/names"
    11  
    12  	"github.com/juju/juju/apiserver/undertaker"
    13  	"github.com/juju/juju/environs/config"
    14  	"github.com/juju/juju/state"
    15  	"github.com/juju/juju/status"
    16  )
    17  
    18  // mockState implements State interface and allows inspection of called
    19  // methods.
    20  type mockState struct {
    21  	env      *mockModel
    22  	removed  bool
    23  	isSystem bool
    24  	machines []undertaker.Machine
    25  	services []undertaker.Service
    26  }
    27  
    28  var _ undertaker.State = (*mockState)(nil)
    29  
    30  func newMockState(envOwner names.UserTag, envName string, isSystem bool) *mockState {
    31  	machine := &mockMachine{
    32  		watcher: &mockWatcher{
    33  			changes: make(chan struct{}, 1),
    34  		},
    35  	}
    36  	service := &mockService{
    37  		watcher: &mockWatcher{
    38  			changes: make(chan struct{}, 1),
    39  		},
    40  	}
    41  
    42  	env := mockModel{
    43  		owner: envOwner,
    44  		name:  envName,
    45  		uuid:  "9d3d3b19-2b0c-4a3f-acde-0b1645586a72",
    46  		life:  state.Alive,
    47  	}
    48  
    49  	m := &mockState{
    50  		env:      &env,
    51  		isSystem: isSystem,
    52  		machines: []undertaker.Machine{machine},
    53  		services: []undertaker.Service{service},
    54  	}
    55  	return m
    56  }
    57  
    58  func (m *mockState) EnsureModelRemoved() error {
    59  	if !m.removed {
    60  		return errors.New("found documents for model")
    61  	}
    62  	return nil
    63  }
    64  
    65  func (m *mockState) RemoveAllModelDocs() error {
    66  	if m.env.life != state.Dead {
    67  		return errors.New("transaction aborted")
    68  	}
    69  	m.removed = true
    70  	return nil
    71  }
    72  
    73  func (m *mockState) ProcessDyingModel() error {
    74  	if m.env.life != state.Dying {
    75  		return errors.New("model is not dying")
    76  	}
    77  	m.env.life = state.Dead
    78  	return nil
    79  }
    80  
    81  func (m *mockState) AllMachines() ([]undertaker.Machine, error) {
    82  	return m.machines, nil
    83  }
    84  
    85  func (m *mockState) AllServices() ([]undertaker.Service, error) {
    86  	return m.services, nil
    87  }
    88  
    89  func (m *mockState) IsController() bool {
    90  	return m.isSystem
    91  }
    92  
    93  func (m *mockState) Model() (undertaker.Model, error) {
    94  	return m.env, nil
    95  }
    96  
    97  func (m *mockState) ModelConfig() (*config.Config, error) {
    98  	return &config.Config{}, nil
    99  }
   100  
   101  func (m *mockState) FindEntity(tag names.Tag) (state.Entity, error) {
   102  	if tag.Kind() == names.ModelTagKind && tag.Id() == m.env.UUID() {
   103  		return m.env, nil
   104  	}
   105  	return nil, errors.NotFoundf("entity with tag %q", tag.String())
   106  }
   107  
   108  // mockModel implements Model interface and allows inspection of called
   109  // methods.
   110  type mockModel struct {
   111  	tod   time.Time
   112  	owner names.UserTag
   113  	life  state.Life
   114  	name  string
   115  	uuid  string
   116  
   117  	status     status.Status
   118  	statusInfo string
   119  	statusData map[string]interface{}
   120  }
   121  
   122  var _ undertaker.Model = (*mockModel)(nil)
   123  
   124  func (m *mockModel) Owner() names.UserTag {
   125  	return m.owner
   126  }
   127  
   128  func (m *mockModel) Life() state.Life {
   129  	return m.life
   130  }
   131  
   132  func (m *mockModel) Tag() names.Tag {
   133  	return names.NewModelTag(m.uuid)
   134  }
   135  
   136  func (m *mockModel) Name() string {
   137  	return m.name
   138  }
   139  
   140  func (m *mockModel) UUID() string {
   141  	return m.uuid
   142  }
   143  
   144  func (m *mockModel) Destroy() error {
   145  	m.life = state.Dying
   146  	return nil
   147  }
   148  
   149  func (m *mockModel) SetStatus(status status.Status, info string, data map[string]interface{}) error {
   150  	m.status = status
   151  	m.statusInfo = info
   152  	m.statusData = data
   153  	return nil
   154  }
   155  
   156  type mockMachine struct {
   157  	watcher state.NotifyWatcher
   158  	err     error
   159  }
   160  
   161  func (m *mockMachine) Watch() state.NotifyWatcher {
   162  	return m.watcher
   163  }
   164  
   165  type mockService struct {
   166  	watcher state.NotifyWatcher
   167  	err     error
   168  }
   169  
   170  func (s *mockService) Watch() state.NotifyWatcher {
   171  	return s.watcher
   172  }
   173  
   174  type mockWatcher struct {
   175  	state.NotifyWatcher
   176  	changes chan struct{}
   177  }
   178  
   179  func (w *mockWatcher) Changes() <-chan struct{} {
   180  	return w.changes
   181  }