github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/state/machine_internal_test.go (about)

     1  // Copyright Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package state
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/juju/mgo/v3/bson"
    10  	"github.com/juju/mgo/v3/txn"
    11  	"github.com/juju/testing"
    12  	jc "github.com/juju/testing/checkers"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/core/model"
    16  )
    17  
    18  type MachineInternalSuite struct {
    19  	testing.IsolationSuite
    20  }
    21  
    22  func (s *MachineInternalSuite) SetUpTest(c *gc.C) {
    23  	s.IsolationSuite.SetUpTest(c)
    24  }
    25  
    26  var _ = gc.Suite(&MachineInternalSuite{})
    27  
    28  func (s *MachineInternalSuite) TestCreateUpgradeLockTxnAssertsMachineAlive(c *gc.C) {
    29  	arbitraryId := "1"
    30  	arbitraryData := &upgradeSeriesLockDoc{}
    31  	var found bool
    32  	for _, op := range createUpgradeSeriesLockTxnOps(arbitraryId, arbitraryData) {
    33  		assertVal, ok := op.Assert.(bson.D)
    34  		if op.C == machinesC && ok && assertVal.Map()["life"] == Alive {
    35  			found = true
    36  			break
    37  		}
    38  	}
    39  	c.Assert(found, jc.IsTrue, gc.Commentf("Transaction does not assert that machines are of status Alive"))
    40  }
    41  
    42  func (s *MachineInternalSuite) TestCreateUpgradeLockTxnAssertsDocDoesNOTExist(c *gc.C) {
    43  	arbitraryId := "1"
    44  	arbitraryData := &upgradeSeriesLockDoc{}
    45  	expectedOp := txn.Op{
    46  		C:      machineUpgradeSeriesLocksC,
    47  		Id:     arbitraryId,
    48  		Assert: txn.DocMissing,
    49  		Insert: arbitraryData,
    50  	}
    51  	assertContainsOP(c, expectedOp, createUpgradeSeriesLockTxnOps(arbitraryId, arbitraryData))
    52  }
    53  
    54  func (s *MachineInternalSuite) TestRemoveUpgradeLockTxnAssertsDocExists(c *gc.C) {
    55  	arbitraryId := "1"
    56  	expectedOp := txn.Op{
    57  		C:      machineUpgradeSeriesLocksC,
    58  		Id:     arbitraryId,
    59  		Assert: txn.DocExists,
    60  		Remove: true,
    61  	}
    62  	assertContainsOP(c, expectedOp, removeUpgradeSeriesLockTxnOps(arbitraryId))
    63  }
    64  
    65  func (s *MachineInternalSuite) TestSetUpgradeSeriesTxnOpsBuildsCorrectUnitTransaction(c *gc.C) {
    66  	arbitraryMachineID := "id"
    67  	arbitraryUnitName := "application/0"
    68  	arbitraryStatus := model.UpgradeSeriesPrepareStarted
    69  	arbitraryUpdateTime := bson.Now()
    70  	arbitraryMessage := "some message"
    71  	arbitraryUpgradeSeriesMessage := newUpgradeSeriesMessage(arbitraryUnitName, arbitraryMessage, arbitraryUpdateTime)
    72  	expectedOp := txn.Op{
    73  		C:  machineUpgradeSeriesLocksC,
    74  		Id: arbitraryMachineID,
    75  		Assert: bson.D{{"$and", []bson.D{
    76  			{{"unit-statuses", bson.D{{"$exists", true}}}},
    77  			{{"unit-statuses.application/0.status", bson.D{{"$ne", arbitraryStatus}}}}}}},
    78  		Update: bson.D{
    79  			{"$set", bson.D{
    80  				{"unit-statuses.application/0.status", arbitraryStatus},
    81  				{"timestamp", arbitraryUpdateTime},
    82  				{"unit-statuses.application/0.timestamp", arbitraryUpdateTime}}},
    83  			{"$push", bson.D{{"messages", arbitraryUpgradeSeriesMessage}}},
    84  		},
    85  	}
    86  	actualOps, err := setUpgradeSeriesTxnOps(arbitraryMachineID, arbitraryUnitName, arbitraryStatus, arbitraryUpdateTime, arbitraryUpgradeSeriesMessage)
    87  	c.Assert(err, jc.ErrorIsNil)
    88  	expectedOpSt := fmt.Sprint(expectedOp.Update)
    89  	actualOpSt := fmt.Sprint(actualOps[1].Update)
    90  	c.Assert(actualOpSt, gc.Equals, expectedOpSt)
    91  }
    92  
    93  func (s *MachineInternalSuite) TestSetUpgradeSeriesTxnOpsShouldAssertAssignedMachineIsAlive(c *gc.C) {
    94  	arbitraryMachineID := "id"
    95  	arbitraryStatus := model.UpgradeSeriesPrepareStarted
    96  	arbitraryUnitName := "application/0"
    97  	arbitraryUpdateTime := bson.Now()
    98  	arbitraryMessage := "message"
    99  	arbitraryUpgradeSeriesMessage := newUpgradeSeriesMessage(arbitraryUnitName, arbitraryMessage, arbitraryUpdateTime)
   100  	expectedOp := txn.Op{
   101  		C:      machinesC,
   102  		Id:     arbitraryMachineID,
   103  		Assert: isAliveDoc,
   104  	}
   105  	actualOps, err := setUpgradeSeriesTxnOps(arbitraryMachineID, arbitraryUnitName, arbitraryStatus, arbitraryUpdateTime, arbitraryUpgradeSeriesMessage)
   106  	c.Assert(err, jc.ErrorIsNil)
   107  	expectedOpSt := fmt.Sprint(expectedOp)
   108  	actualOpSt := fmt.Sprint(actualOps[0])
   109  	c.Assert(actualOpSt, gc.Equals, expectedOpSt)
   110  }
   111  
   112  func (s *MachineInternalSuite) TestStartUpgradeSeriesUnitCompletionTxnOps(c *gc.C) {
   113  	arbitraryMachineID := "id"
   114  	arbitraryTimestamp := bson.Now()
   115  	arbitraryLock := &upgradeSeriesLockDoc{TimeStamp: arbitraryTimestamp}
   116  	expectedOps := []txn.Op{
   117  		{
   118  			C:      machinesC,
   119  			Id:     arbitraryMachineID,
   120  			Assert: isAliveDoc,
   121  		},
   122  		{
   123  			C:      machineUpgradeSeriesLocksC,
   124  			Id:     arbitraryMachineID,
   125  			Assert: bson.D{{"machine-status", model.UpgradeSeriesCompleteStarted}},
   126  			Update: bson.D{{"$set", bson.D{
   127  				{"unit-statuses", map[string]UpgradeSeriesUnitStatus{}},
   128  				{"timestamp", arbitraryTimestamp},
   129  				{"messages", []UpgradeSeriesMessage{}}}}},
   130  		},
   131  	}
   132  	actualOps := startUpgradeSeriesUnitCompletionTxnOps(arbitraryMachineID, arbitraryLock)
   133  	expectedOpsSt := fmt.Sprint(expectedOps)
   134  	actualOpsSt := fmt.Sprint(actualOps)
   135  	c.Assert(actualOpsSt, gc.Equals, expectedOpsSt)
   136  }
   137  
   138  func (s *MachineInternalSuite) TestSetUpgradeSeriesMessageTxnOps(c *gc.C) {
   139  	arbitraryMachineID := "id"
   140  	arbitraryTimestamp := bson.Now()
   141  	arbitraryMessages := []UpgradeSeriesMessage{
   142  		{
   143  			Message:   "arbitraryMessages0",
   144  			Timestamp: arbitraryTimestamp,
   145  			Seen:      false,
   146  		},
   147  		{
   148  			Message:   "arbitraryMessages1",
   149  			Timestamp: arbitraryTimestamp,
   150  			Seen:      false,
   151  		},
   152  	}
   153  	expectedOps := []txn.Op{
   154  		{
   155  			C:      machinesC,
   156  			Id:     arbitraryMachineID,
   157  			Assert: isAliveDoc,
   158  		},
   159  		{
   160  			C:  machineUpgradeSeriesLocksC,
   161  			Id: arbitraryMachineID,
   162  			Update: bson.D{{"$set", bson.D{
   163  				{"messages.0.seen", true},
   164  				{"messages.1.seen", true},
   165  			}}},
   166  		},
   167  	}
   168  	actualOps := setUpgradeSeriesMessageTxnOps(arbitraryMachineID, arbitraryMessages, true)
   169  	expectedOpsSt := fmt.Sprint(expectedOps)
   170  	actualOpsSt := fmt.Sprint(actualOps)
   171  	c.Assert(actualOpsSt, gc.Equals, expectedOpsSt)
   172  }
   173  
   174  func assertContainsOP(c *gc.C, expectedOp txn.Op, actualOps []txn.Op) {
   175  	var found bool
   176  	for _, actualOp := range actualOps {
   177  		if actualOp == expectedOp {
   178  			found = true
   179  			break
   180  		}
   181  	}
   182  	c.Assert(found, jc.IsTrue, gc.Commentf("expected %#v to contain %#v", actualOps, expectedOp))
   183  }