go.temporal.io/server@v1.23.0/common/persistence/versionhistory/version_history_test.go (about)

     1  // The MIT License
     2  //
     3  // Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
     4  //
     5  // Copyright (c) 2020 Uber Technologies, Inc.
     6  //
     7  // Permission is hereby granted, free of charge, to any person obtaining a copy
     8  // of this software and associated documentation files (the "Software"), to deal
     9  // in the Software without restriction, including without limitation the rights
    10  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    11  // copies of the Software, and to permit persons to whom the Software is
    12  // furnished to do so, subject to the following conditions:
    13  //
    14  // The above copyright notice and this permission notice shall be included in
    15  // all copies or substantial portions of the Software.
    16  //
    17  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    18  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    19  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    20  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    21  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    22  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    23  // THE SOFTWARE.
    24  
    25  package versionhistory
    26  
    27  import (
    28  	"testing"
    29  
    30  	"github.com/stretchr/testify/suite"
    31  	"go.temporal.io/api/serviceerror"
    32  
    33  	historyspb "go.temporal.io/server/api/history/v1"
    34  	"go.temporal.io/server/common"
    35  )
    36  
    37  type (
    38  	versionHistorySuite struct {
    39  		suite.Suite
    40  	}
    41  
    42  	versionHistoriesSuite struct {
    43  		suite.Suite
    44  	}
    45  )
    46  
    47  func TestVersionHistorySuite(t *testing.T) {
    48  	s := new(versionHistorySuite)
    49  	suite.Run(t, s)
    50  }
    51  
    52  func TestVersionHistoriesSuite(t *testing.T) {
    53  	s := new(versionHistoriesSuite)
    54  	suite.Run(t, s)
    55  }
    56  
    57  func (s *versionHistorySuite) TestDuplicateUntilLCAItem_Success() {
    58  	BranchToken := []byte("some random branch token")
    59  	Items := []*historyspb.VersionHistoryItem{
    60  		{EventId: 3, Version: 0},
    61  		{EventId: 6, Version: 4},
    62  	}
    63  
    64  	history := NewVersionHistory(BranchToken, Items)
    65  
    66  	newHistory, err := CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(2, 0))
    67  	s.NoError(err)
    68  	newBranchToken := []byte("other random branch token")
    69  	SetVersionHistoryBranchToken(newHistory, newBranchToken)
    70  	s.Equal(newBranchToken, newHistory.BranchToken)
    71  	s.Equal(NewVersionHistory(
    72  		newBranchToken,
    73  		[]*historyspb.VersionHistoryItem{{EventId: 2, Version: 0}},
    74  	), newHistory)
    75  
    76  	newHistory, err = CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(5, 4))
    77  	s.NoError(err)
    78  	newBranchToken = []byte("another random branch token")
    79  	SetVersionHistoryBranchToken(newHistory, newBranchToken)
    80  	s.Equal(newBranchToken, newHistory.BranchToken)
    81  	s.Equal(NewVersionHistory(
    82  		newBranchToken,
    83  		[]*historyspb.VersionHistoryItem{
    84  			{EventId: 3, Version: 0},
    85  			{EventId: 5, Version: 4},
    86  		},
    87  	), newHistory)
    88  
    89  	newHistory, err = CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(6, 4))
    90  	s.NoError(err)
    91  	newBranchToken = []byte("yet another random branch token")
    92  	SetVersionHistoryBranchToken(newHistory, newBranchToken)
    93  	s.Equal(newBranchToken, newHistory.BranchToken)
    94  	s.Equal(NewVersionHistory(
    95  		newBranchToken,
    96  		[]*historyspb.VersionHistoryItem{
    97  			{EventId: 3, Version: 0},
    98  			{EventId: 6, Version: 4},
    99  		},
   100  	), newHistory)
   101  }
   102  
   103  func (s *versionHistorySuite) TestDuplicateUntilLCAItem_Failure() {
   104  	BranchToken := []byte("some random branch token")
   105  	Items := []*historyspb.VersionHistoryItem{
   106  		{EventId: 3, Version: 0},
   107  		{EventId: 6, Version: 4},
   108  	}
   109  
   110  	history := NewVersionHistory(BranchToken, Items)
   111  
   112  	_, err := CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(4, 0))
   113  	s.IsType(&serviceerror.Internal{}, err)
   114  
   115  	_, err = CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(2, 1))
   116  	s.IsType(&serviceerror.Internal{}, err)
   117  
   118  	_, err = CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(5, 3))
   119  	s.IsType(&serviceerror.Internal{}, err)
   120  
   121  	_, err = CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(7, 5))
   122  	s.IsType(&serviceerror.Internal{}, err)
   123  
   124  	_, err = CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(4, 0))
   125  	s.IsType(&serviceerror.Internal{}, err)
   126  
   127  	_, err = CopyVersionHistoryUntilLCAVersionHistoryItem(history, NewVersionHistoryItem(7, 4))
   128  	s.IsType(&serviceerror.Internal{}, err)
   129  }
   130  
   131  func (s *versionHistorySuite) TestSetBranchToken() {
   132  	Items := []*historyspb.VersionHistoryItem{
   133  		{EventId: 3, Version: 0},
   134  		{EventId: 6, Version: 4},
   135  	}
   136  	history := NewVersionHistory(nil, Items)
   137  
   138  	SetVersionHistoryBranchToken(history, []byte("some random branch token"))
   139  }
   140  
   141  func (s *versionHistorySuite) TestAddOrUpdateItem_VersionIncrease() {
   142  	BranchToken := []byte("some random branch token")
   143  	Items := []*historyspb.VersionHistoryItem{
   144  		{EventId: 3, Version: 0},
   145  		{EventId: 6, Version: 4},
   146  	}
   147  	history := NewVersionHistory(BranchToken, Items)
   148  
   149  	item := &historyspb.VersionHistoryItem{
   150  		EventId: 8,
   151  		Version: 5,
   152  	}
   153  	err := AddOrUpdateVersionHistoryItem(history, item)
   154  	s.NoError(err)
   155  
   156  	s.Equal(NewVersionHistory(
   157  		BranchToken,
   158  		[]*historyspb.VersionHistoryItem{
   159  			{EventId: 3, Version: 0},
   160  			{EventId: 6, Version: 4},
   161  			{EventId: 8, Version: 5},
   162  		},
   163  	), history)
   164  
   165  }
   166  
   167  func (s *versionHistorySuite) TestAddOrUpdateItem_EventIDIncrease() {
   168  	BranchToken := []byte("some random branch token")
   169  	Items := []*historyspb.VersionHistoryItem{
   170  		{EventId: 3, Version: 0},
   171  		{EventId: 6, Version: 4},
   172  	}
   173  	history := NewVersionHistory(BranchToken, Items)
   174  
   175  	item := &historyspb.VersionHistoryItem{
   176  		EventId: 8,
   177  		Version: 4,
   178  	}
   179  	err := AddOrUpdateVersionHistoryItem(history, item)
   180  	s.NoError(err)
   181  
   182  	s.Equal(NewVersionHistory(
   183  		BranchToken,
   184  		[]*historyspb.VersionHistoryItem{
   185  			{EventId: 3, Version: 0},
   186  			{EventId: 8, Version: 4},
   187  		},
   188  	), history)
   189  }
   190  
   191  func (s *versionHistorySuite) TestAddOrUpdateItem_Failed_LowerVersion() {
   192  	BranchToken := []byte("some random branch token")
   193  	Items := []*historyspb.VersionHistoryItem{
   194  		{EventId: 3, Version: 0},
   195  		{EventId: 6, Version: 4},
   196  	}
   197  	history := NewVersionHistory(BranchToken, Items)
   198  
   199  	err := AddOrUpdateVersionHistoryItem(history, NewVersionHistoryItem(8, 3))
   200  	s.Error(err)
   201  }
   202  
   203  func (s *versionHistorySuite) TestAddOrUpdateItem_Failed_SameVersion_EventIDNotIncreasing() {
   204  	BranchToken := []byte("some random branch token")
   205  	Items := []*historyspb.VersionHistoryItem{
   206  		{EventId: 3, Version: 0},
   207  		{EventId: 6, Version: 4},
   208  	}
   209  	history := NewVersionHistory(BranchToken, Items)
   210  
   211  	err := AddOrUpdateVersionHistoryItem(history, NewVersionHistoryItem(5, 4))
   212  	s.Error(err)
   213  
   214  	err = AddOrUpdateVersionHistoryItem(history, NewVersionHistoryItem(6, 4))
   215  	s.Error(err)
   216  }
   217  
   218  func (s *versionHistorySuite) TestAddOrUpdateItem_Failed_VersionNoIncreasing() {
   219  	BranchToken := []byte("some random branch token")
   220  	Items := []*historyspb.VersionHistoryItem{
   221  		{EventId: 3, Version: 0},
   222  		{EventId: 6, Version: 4},
   223  	}
   224  	history := NewVersionHistory(BranchToken, Items)
   225  
   226  	err := AddOrUpdateVersionHistoryItem(history, NewVersionHistoryItem(6, 3))
   227  	s.Error(err)
   228  
   229  	err = AddOrUpdateVersionHistoryItem(history, NewVersionHistoryItem(2, 3))
   230  	s.Error(err)
   231  
   232  	err = AddOrUpdateVersionHistoryItem(history, NewVersionHistoryItem(7, 3))
   233  	s.Error(err)
   234  }
   235  
   236  func (s *versionHistoriesSuite) TestContainsItem_True() {
   237  	BranchToken := []byte("some random branch token")
   238  	Items := []*historyspb.VersionHistoryItem{
   239  		{EventId: 3, Version: 0},
   240  		{EventId: 6, Version: 4},
   241  	}
   242  	history := NewVersionHistory(BranchToken, Items)
   243  
   244  	prevEventID := common.FirstEventID - 1
   245  	for _, item := range Items {
   246  		for EventID := prevEventID + 1; EventID <= item.GetEventId(); EventID++ {
   247  			s.True(ContainsVersionHistoryItem(history, NewVersionHistoryItem(EventID, item.GetVersion())))
   248  		}
   249  		prevEventID = item.GetEventId()
   250  	}
   251  }
   252  
   253  func (s *versionHistoriesSuite) TestContainsItem_False() {
   254  	BranchToken := []byte("some random branch token")
   255  	Items := []*historyspb.VersionHistoryItem{
   256  		{EventId: 3, Version: 0},
   257  		{EventId: 6, Version: 4},
   258  	}
   259  	history := NewVersionHistory(BranchToken, Items)
   260  
   261  	s.False(ContainsVersionHistoryItem(history, NewVersionHistoryItem(4, 0)))
   262  	s.False(ContainsVersionHistoryItem(history, NewVersionHistoryItem(3, 1)))
   263  
   264  	s.False(ContainsVersionHistoryItem(history, NewVersionHistoryItem(7, 4)))
   265  	s.False(ContainsVersionHistoryItem(history, NewVersionHistoryItem(6, 5)))
   266  }
   267  
   268  func (s *versionHistorySuite) TestIsLCAAppendable_True() {
   269  	BranchToken := []byte("some random branch token")
   270  	Items := []*historyspb.VersionHistoryItem{
   271  		{EventId: 3, Version: 0},
   272  		{EventId: 6, Version: 4},
   273  	}
   274  	history := NewVersionHistory(BranchToken, Items)
   275  
   276  	ret := IsLCAVersionHistoryItemAppendable(history, NewVersionHistoryItem(6, 4))
   277  	s.True(ret)
   278  }
   279  
   280  func (s *versionHistorySuite) TestIsLCAAppendable_False_VersionNotMatch() {
   281  	BranchToken := []byte("some random branch token")
   282  	Items := []*historyspb.VersionHistoryItem{
   283  		{EventId: 3, Version: 0},
   284  		{EventId: 6, Version: 4},
   285  	}
   286  	history := NewVersionHistory(BranchToken, Items)
   287  
   288  	ret := IsLCAVersionHistoryItemAppendable(history, NewVersionHistoryItem(6, 7))
   289  	s.False(ret)
   290  }
   291  
   292  func (s *versionHistorySuite) TestIsLCAAppendable_False_EventIDNotMatch() {
   293  	BranchToken := []byte("some random branch token")
   294  	Items := []*historyspb.VersionHistoryItem{
   295  		{EventId: 3, Version: 0},
   296  		{EventId: 6, Version: 4},
   297  	}
   298  	history := NewVersionHistory(BranchToken, Items)
   299  
   300  	ret := IsLCAVersionHistoryItemAppendable(history, NewVersionHistoryItem(7, 4))
   301  	s.False(ret)
   302  }
   303  
   304  func (s *versionHistorySuite) TestFindLCAItem_ReturnLocal() {
   305  	localBranchToken := []byte("local branch token")
   306  	localItems := []*historyspb.VersionHistoryItem{
   307  		{EventId: 3, Version: 0},
   308  		{EventId: 5, Version: 4},
   309  		{EventId: 7, Version: 6},
   310  		{EventId: 9, Version: 10},
   311  	}
   312  	remoteBranchToken := []byte("remote branch token")
   313  	remoteItems := []*historyspb.VersionHistoryItem{
   314  		{EventId: 3, Version: 0},
   315  		{EventId: 7, Version: 4},
   316  		{EventId: 8, Version: 8},
   317  		{EventId: 11, Version: 12},
   318  	}
   319  	localVersionHistory := NewVersionHistory(localBranchToken, localItems)
   320  	remoteVersionHistory := NewVersionHistory(remoteBranchToken, remoteItems)
   321  
   322  	item, err := FindLCAVersionHistoryItem(localVersionHistory, remoteVersionHistory)
   323  	s.NoError(err)
   324  	s.Equal(NewVersionHistoryItem(5, 4), item)
   325  }
   326  
   327  func (s *versionHistorySuite) TestFindLCAItem_ReturnRemote() {
   328  	localBranchToken := []byte("local branch token")
   329  	localItems := []*historyspb.VersionHistoryItem{
   330  		{EventId: 3, Version: 0},
   331  		{EventId: 5, Version: 4},
   332  		{EventId: 7, Version: 6},
   333  		{EventId: 9, Version: 10},
   334  	}
   335  	remoteBranchToken := []byte("remote branch token")
   336  	remoteItems := []*historyspb.VersionHistoryItem{
   337  		{EventId: 3, Version: 0},
   338  		{EventId: 5, Version: 4},
   339  		{EventId: 6, Version: 6},
   340  		{EventId: 11, Version: 12},
   341  	}
   342  	localVersionHistory := NewVersionHistory(localBranchToken, localItems)
   343  	remoteVersionHistory := NewVersionHistory(remoteBranchToken, remoteItems)
   344  
   345  	item, err := FindLCAVersionHistoryItem(localVersionHistory, remoteVersionHistory)
   346  	s.NoError(err)
   347  	s.Equal(NewVersionHistoryItem(6, 6), item)
   348  }
   349  
   350  func (s *versionHistorySuite) TestFindLCAItem_Error_NoLCA() {
   351  	localBranchToken := []byte("local branch token")
   352  	localItems := []*historyspb.VersionHistoryItem{
   353  		{EventId: 3, Version: 0},
   354  		{EventId: 5, Version: 4},
   355  		{EventId: 7, Version: 6},
   356  		{EventId: 9, Version: 10},
   357  	}
   358  	remoteBranchToken := []byte("remote branch token")
   359  	remoteItems := []*historyspb.VersionHistoryItem{
   360  		{EventId: 3, Version: 1},
   361  		{EventId: 7, Version: 2},
   362  		{EventId: 8, Version: 3},
   363  	}
   364  	localVersionHistory := NewVersionHistory(localBranchToken, localItems)
   365  	remoteVersionHistory := NewVersionHistory(remoteBranchToken, remoteItems)
   366  
   367  	_, err := FindLCAVersionHistoryItem(localVersionHistory, remoteVersionHistory)
   368  	s.Error(err)
   369  }
   370  
   371  func (s *versionHistorySuite) TestGetFirstItem_Success() {
   372  	BranchToken := []byte("some random branch token")
   373  	item := NewVersionHistoryItem(3, 0)
   374  	history := NewVersionHistory(BranchToken, []*historyspb.VersionHistoryItem{item})
   375  
   376  	firstItem, err := GetFirstVersionHistoryItem(history)
   377  	s.NoError(err)
   378  	s.Equal(item, firstItem)
   379  
   380  	item = NewVersionHistoryItem(4, 0)
   381  	err = AddOrUpdateVersionHistoryItem(history, item)
   382  	s.NoError(err)
   383  
   384  	firstItem, err = GetFirstVersionHistoryItem(history)
   385  	s.NoError(err)
   386  	s.Equal(item, firstItem)
   387  
   388  	err = AddOrUpdateVersionHistoryItem(history, NewVersionHistoryItem(7, 1))
   389  	s.NoError(err)
   390  
   391  	firstItem, err = GetFirstVersionHistoryItem(history)
   392  	s.NoError(err)
   393  	s.Equal(item, firstItem)
   394  }
   395  
   396  func (s *versionHistorySuite) TestGetFirstItem_Failure() {
   397  	BranchToken := []byte("some random branch token")
   398  	history := NewVersionHistory(BranchToken, []*historyspb.VersionHistoryItem{})
   399  
   400  	_, err := GetFirstVersionHistoryItem(history)
   401  	s.IsType(&serviceerror.Internal{}, err)
   402  }
   403  
   404  func (s *versionHistorySuite) TestGetLastItem_Success() {
   405  	BranchToken := []byte("some random branch token")
   406  	item := NewVersionHistoryItem(3, 0)
   407  	history := NewVersionHistory(BranchToken, []*historyspb.VersionHistoryItem{item})
   408  
   409  	lastItem, err := GetLastVersionHistoryItem(history)
   410  	s.NoError(err)
   411  	s.Equal(item, lastItem)
   412  
   413  	item = NewVersionHistoryItem(4, 0)
   414  	err = AddOrUpdateVersionHistoryItem(history, item)
   415  	s.NoError(err)
   416  
   417  	lastItem, err = GetLastVersionHistoryItem(history)
   418  	s.NoError(err)
   419  	s.Equal(item, lastItem)
   420  
   421  	item = NewVersionHistoryItem(7, 1)
   422  	err = AddOrUpdateVersionHistoryItem(history, item)
   423  	s.NoError(err)
   424  
   425  	lastItem, err = GetLastVersionHistoryItem(history)
   426  	s.NoError(err)
   427  	s.Equal(item, lastItem)
   428  }
   429  
   430  func (s *versionHistorySuite) TestGetLastItem_Failure() {
   431  	BranchToken := []byte("some random branch token")
   432  	history := NewVersionHistory(BranchToken, []*historyspb.VersionHistoryItem{})
   433  
   434  	_, err := GetLastVersionHistoryItem(history)
   435  	s.IsType(&serviceerror.Internal{}, err)
   436  }
   437  
   438  func (s *versionHistoriesSuite) TestGetVersion_Success() {
   439  	BranchToken := []byte("some random branch token")
   440  	item1 := NewVersionHistoryItem(3, 0)
   441  	item2 := NewVersionHistoryItem(6, 8)
   442  	item3 := NewVersionHistoryItem(8, 12)
   443  	history := NewVersionHistory(BranchToken, []*historyspb.VersionHistoryItem{item1, item2, item3})
   444  
   445  	Version, err := GetVersionHistoryEventVersion(history, 1)
   446  	s.NoError(err)
   447  	s.Equal(item1.GetVersion(), Version)
   448  	Version, err = GetVersionHistoryEventVersion(history, 2)
   449  	s.NoError(err)
   450  	s.Equal(item1.GetVersion(), Version)
   451  	Version, err = GetVersionHistoryEventVersion(history, 3)
   452  	s.NoError(err)
   453  	s.Equal(item1.GetVersion(), Version)
   454  
   455  	Version, err = GetVersionHistoryEventVersion(history, 4)
   456  	s.NoError(err)
   457  	s.Equal(item2.GetVersion(), Version)
   458  	Version, err = GetVersionHistoryEventVersion(history, 5)
   459  	s.NoError(err)
   460  	s.Equal(item2.GetVersion(), Version)
   461  	Version, err = GetVersionHistoryEventVersion(history, 6)
   462  	s.NoError(err)
   463  	s.Equal(item2.GetVersion(), Version)
   464  
   465  	Version, err = GetVersionHistoryEventVersion(history, 7)
   466  	s.NoError(err)
   467  	s.Equal(item3.GetVersion(), Version)
   468  	Version, err = GetVersionHistoryEventVersion(history, 8)
   469  	s.NoError(err)
   470  	s.Equal(item3.GetVersion(), Version)
   471  }
   472  
   473  func (s *versionHistoriesSuite) TestGetVersion_Failure() {
   474  	BranchToken := []byte("some random branch token")
   475  	item1 := NewVersionHistoryItem(3, 0)
   476  	item2 := NewVersionHistoryItem(6, 8)
   477  	item3 := NewVersionHistoryItem(8, 12)
   478  	history := NewVersionHistory(BranchToken, []*historyspb.VersionHistoryItem{item1, item2, item3})
   479  
   480  	_, err := GetVersionHistoryEventVersion(history, 0)
   481  	s.Error(err)
   482  
   483  	_, err = GetVersionHistoryEventVersion(history, 9)
   484  	s.Error(err)
   485  }
   486  
   487  func (s *versionHistorySuite) TestEquals() {
   488  	localBranchToken := []byte("local branch token")
   489  	localItems := []*historyspb.VersionHistoryItem{
   490  		{EventId: 3, Version: 0},
   491  		{EventId: 5, Version: 4},
   492  		{EventId: 7, Version: 6},
   493  		{EventId: 9, Version: 10},
   494  	}
   495  	remoteBranchToken := []byte("remote branch token")
   496  	remoteItems := []*historyspb.VersionHistoryItem{
   497  		{EventId: 3, Version: 1},
   498  		{EventId: 7, Version: 2},
   499  		{EventId: 8, Version: 3},
   500  	}
   501  	localVersionHistory := NewVersionHistory(localBranchToken, localItems)
   502  	remoteVersionHistory := NewVersionHistory(remoteBranchToken, remoteItems)
   503  
   504  	s.False(localVersionHistory.Equal(remoteVersionHistory))
   505  	s.True(localVersionHistory.Equal(CopyVersionHistory(localVersionHistory)))
   506  	s.True(remoteVersionHistory.Equal(CopyVersionHistory(remoteVersionHistory)))
   507  }
   508  
   509  func (s *versionHistoriesSuite) TestAddGetVersionHistory() {
   510  	versionHistory1 := NewVersionHistory([]byte("branch token 1"), []*historyspb.VersionHistoryItem{
   511  		{EventId: 3, Version: 0},
   512  		{EventId: 5, Version: 4},
   513  		{EventId: 7, Version: 6},
   514  		{EventId: 9, Version: 10},
   515  	})
   516  	versionHistory2 := NewVersionHistory([]byte("branch token 2"), []*historyspb.VersionHistoryItem{
   517  		{EventId: 3, Version: 0},
   518  		{EventId: 5, Version: 4},
   519  		{EventId: 6, Version: 6},
   520  		{EventId: 11, Version: 12},
   521  	})
   522  
   523  	histories := NewVersionHistories(versionHistory1)
   524  	s.Equal(int32(0), histories.CurrentVersionHistoryIndex)
   525  
   526  	currentBranchChanged, newVersionHistoryIndex, err := AddVersionHistory(histories, versionHistory2)
   527  	s.Nil(err)
   528  	s.True(currentBranchChanged)
   529  	s.Equal(int32(1), newVersionHistoryIndex)
   530  	s.Equal(int32(1), histories.CurrentVersionHistoryIndex)
   531  
   532  	resultVersionHistory1, err := GetVersionHistory(histories, 0)
   533  	s.Nil(err)
   534  	s.Equal(versionHistory1, resultVersionHistory1)
   535  
   536  	resultVersionHistory2, err := GetVersionHistory(histories, 1)
   537  	s.Nil(err)
   538  	s.Equal(versionHistory2, resultVersionHistory2)
   539  }
   540  
   541  func (s *versionHistoriesSuite) TestFindLCAVersionHistoryIndexAndItem_LargerEventIDWins() {
   542  	versionHistory1 := NewVersionHistory([]byte("branch token 1"), []*historyspb.VersionHistoryItem{
   543  		{EventId: 3, Version: 0},
   544  		{EventId: 5, Version: 4},
   545  		{EventId: 7, Version: 6},
   546  		{EventId: 9, Version: 10},
   547  	})
   548  	versionHistory2 := NewVersionHistory([]byte("branch token 2"), []*historyspb.VersionHistoryItem{
   549  		{EventId: 3, Version: 0},
   550  		{EventId: 5, Version: 4},
   551  		{EventId: 6, Version: 6},
   552  		{EventId: 11, Version: 12},
   553  	})
   554  
   555  	histories := NewVersionHistories(versionHistory1)
   556  	_, _, err := AddVersionHistory(histories, versionHistory2)
   557  	s.Nil(err)
   558  
   559  	versionHistoryIncoming := NewVersionHistory([]byte("branch token incoming"), []*historyspb.VersionHistoryItem{
   560  		{EventId: 3, Version: 0},
   561  		{EventId: 5, Version: 4},
   562  		{EventId: 8, Version: 6},
   563  		{EventId: 11, Version: 100},
   564  	})
   565  
   566  	item, index, err := FindLCAVersionHistoryItemAndIndex(histories, versionHistoryIncoming)
   567  	s.Nil(err)
   568  	s.Equal(int32(0), index)
   569  	s.Equal(NewVersionHistoryItem(7, 6), item)
   570  }
   571  
   572  func (s *versionHistoriesSuite) TestFindLCAVersionHistoryIndexAndItem_SameEventIDShorterLengthWins() {
   573  	versionHistory1 := NewVersionHistory([]byte("branch token 1"), []*historyspb.VersionHistoryItem{
   574  		{EventId: 3, Version: 0},
   575  		{EventId: 5, Version: 4},
   576  		{EventId: 7, Version: 6},
   577  		{EventId: 9, Version: 10},
   578  	})
   579  	versionHistory2 := NewVersionHistory([]byte("branch token 2"), []*historyspb.VersionHistoryItem{
   580  		{EventId: 3, Version: 0},
   581  		{EventId: 5, Version: 4},
   582  		{EventId: 7, Version: 6},
   583  	})
   584  
   585  	histories := NewVersionHistories(versionHistory1)
   586  	_, _, err := AddVersionHistory(histories, versionHistory2)
   587  	s.Nil(err)
   588  
   589  	versionHistoryIncoming := NewVersionHistory([]byte("branch token incoming"), []*historyspb.VersionHistoryItem{
   590  		{EventId: 3, Version: 0},
   591  		{EventId: 5, Version: 4},
   592  		{EventId: 8, Version: 6},
   593  		{EventId: 11, Version: 100},
   594  	})
   595  
   596  	item, index, err := FindLCAVersionHistoryItemAndIndex(histories, versionHistoryIncoming)
   597  	s.Nil(err)
   598  	s.Equal(int32(1), index)
   599  	s.Equal(NewVersionHistoryItem(7, 6), item)
   600  }
   601  
   602  func (s *versionHistoriesSuite) TestFindFirstVersionHistoryIndexByItem() {
   603  	versionHistory1 := NewVersionHistory([]byte("branch token 1"), []*historyspb.VersionHistoryItem{
   604  		{EventId: 3, Version: 0},
   605  		{EventId: 5, Version: 4},
   606  		{EventId: 7, Version: 6},
   607  	})
   608  	versionHistory2 := NewVersionHistory([]byte("branch token 2"), []*historyspb.VersionHistoryItem{
   609  		{EventId: 3, Version: 0},
   610  		{EventId: 5, Version: 4},
   611  		{EventId: 7, Version: 6},
   612  		{EventId: 9, Version: 10},
   613  	})
   614  
   615  	histories := NewVersionHistories(versionHistory1)
   616  	_, _, err := AddVersionHistory(histories, versionHistory2)
   617  	s.Nil(err)
   618  
   619  	index, err := FindFirstVersionHistoryIndexByVersionHistoryItem(histories, NewVersionHistoryItem(8, 10))
   620  	s.NoError(err)
   621  	s.Equal(int32(1), index)
   622  
   623  	index, err = FindFirstVersionHistoryIndexByVersionHistoryItem(histories, NewVersionHistoryItem(4, 4))
   624  	s.NoError(err)
   625  	s.Equal(int32(0), index)
   626  
   627  	_, err = FindFirstVersionHistoryIndexByVersionHistoryItem(histories, NewVersionHistoryItem(41, 4))
   628  	s.Error(err)
   629  }
   630  
   631  func (s *versionHistoriesSuite) TestCurrentVersionHistoryIndexIsInReplay() {
   632  	versionHistory1 := NewVersionHistory([]byte("branch token 1"), []*historyspb.VersionHistoryItem{
   633  		{EventId: 3, Version: 0},
   634  		{EventId: 5, Version: 4},
   635  		{EventId: 7, Version: 6},
   636  		{EventId: 9, Version: 10},
   637  	})
   638  	versionHistory2 := NewVersionHistory([]byte("branch token 2"), []*historyspb.VersionHistoryItem{
   639  		{EventId: 3, Version: 0},
   640  		{EventId: 5, Version: 4},
   641  		{EventId: 6, Version: 6},
   642  		{EventId: 11, Version: 12},
   643  	})
   644  
   645  	histories := NewVersionHistories(versionHistory1)
   646  	s.Equal(int32(0), histories.CurrentVersionHistoryIndex)
   647  
   648  	currentBranchChanged, newVersionHistoryIndex, err := AddVersionHistory(histories, versionHistory2)
   649  	s.Nil(err)
   650  	s.True(currentBranchChanged)
   651  	s.Equal(int32(1), newVersionHistoryIndex)
   652  	s.Equal(int32(1), histories.CurrentVersionHistoryIndex)
   653  
   654  	isInReplay, err := IsVersionHistoriesRebuilt(histories)
   655  	s.NoError(err)
   656  	s.False(isInReplay)
   657  
   658  	err = SetCurrentVersionHistoryIndex(histories, 0)
   659  	s.NoError(err)
   660  	isInReplay, err = IsVersionHistoriesRebuilt(histories)
   661  	s.NoError(err)
   662  	s.True(isInReplay)
   663  
   664  	err = SetCurrentVersionHistoryIndex(histories, 1)
   665  	s.NoError(err)
   666  	isInReplay, err = IsVersionHistoriesRebuilt(histories)
   667  	s.NoError(err)
   668  	s.False(isInReplay)
   669  }
   670  
   671  func (s *versionHistoriesSuite) TestIsVersionHistoryItemsInSameBranch_Same_VersionItems_Return_True() {
   672  	versionHistoryItemsA := []*historyspb.VersionHistoryItem{
   673  		{EventId: 3, Version: 0},
   674  		{EventId: 5, Version: 4},
   675  		{EventId: 7, Version: 6},
   676  		{EventId: 9, Version: 10},
   677  	}
   678  	versionHistoryItemsB := []*historyspb.VersionHistoryItem{
   679  		{EventId: 3, Version: 0},
   680  		{EventId: 5, Version: 4},
   681  		{EventId: 7, Version: 6},
   682  		{EventId: 9, Version: 10},
   683  	}
   684  	s.True(IsVersionHistoryItemsInSameBranch(versionHistoryItemsA, versionHistoryItemsB))
   685  	s.True(IsVersionHistoryItemsInSameBranch(versionHistoryItemsB, versionHistoryItemsA))
   686  }
   687  
   688  func (s *versionHistoriesSuite) TestIsVersionHistoryItemsInSameBranch_SameBranch1_Return_True() {
   689  	versionHistoryItemsA := []*historyspb.VersionHistoryItem{
   690  		{EventId: 3, Version: 0},
   691  		{EventId: 5, Version: 4},
   692  		{EventId: 7, Version: 6},
   693  	}
   694  	versionHistoryItemsB := []*historyspb.VersionHistoryItem{
   695  		{EventId: 3, Version: 0},
   696  		{EventId: 5, Version: 4},
   697  		{EventId: 7, Version: 6},
   698  		{EventId: 9, Version: 10},
   699  	}
   700  	s.True(IsVersionHistoryItemsInSameBranch(versionHistoryItemsA, versionHistoryItemsB))
   701  	s.True(IsVersionHistoryItemsInSameBranch(versionHistoryItemsB, versionHistoryItemsA))
   702  }
   703  
   704  func (s *versionHistoriesSuite) TestIsVersionHistoryItemsInSameBranch_SameBranch2_Return_True() {
   705  	versionHistoryItemsA := []*historyspb.VersionHistoryItem{
   706  		{EventId: 3, Version: 0},
   707  		{EventId: 5, Version: 4},
   708  		{EventId: 6, Version: 6},
   709  	}
   710  	versionHistoryItemsB := []*historyspb.VersionHistoryItem{
   711  		{EventId: 3, Version: 0},
   712  		{EventId: 5, Version: 4},
   713  		{EventId: 7, Version: 6},
   714  		{EventId: 9, Version: 10},
   715  	}
   716  	s.True(IsVersionHistoryItemsInSameBranch(versionHistoryItemsA, versionHistoryItemsB))
   717  	s.True(IsVersionHistoryItemsInSameBranch(versionHistoryItemsB, versionHistoryItemsA))
   718  }
   719  
   720  func (s *versionHistoriesSuite) TestIsVersionHistoryItemsInSameBranch_DifferentBranch1_Return_False() {
   721  	versionHistoryItemsA := []*historyspb.VersionHistoryItem{
   722  		{EventId: 1, Version: 1},
   723  		{EventId: 2, Version: 2},
   724  		{EventId: 3, Version: 3},
   725  	}
   726  	versionHistoryItemsB := []*historyspb.VersionHistoryItem{
   727  		{EventId: 1, Version: 1},
   728  		{EventId: 2, Version: 2},
   729  		{EventId: 3, Version: 4},
   730  	}
   731  	s.False(IsVersionHistoryItemsInSameBranch(versionHistoryItemsA, versionHistoryItemsB))
   732  	s.False(IsVersionHistoryItemsInSameBranch(versionHistoryItemsB, versionHistoryItemsA))
   733  }
   734  
   735  func (s *versionHistoriesSuite) TestIsVersionHistoryItemsInSameBranch_DifferentBranch2_Return_False() {
   736  	versionHistoryItemsA := []*historyspb.VersionHistoryItem{
   737  		{EventId: 1, Version: 1},
   738  		{EventId: 2, Version: 2},
   739  		{EventId: 7, Version: 3},
   740  	}
   741  	versionHistoryItemsB := []*historyspb.VersionHistoryItem{
   742  		{EventId: 1, Version: 1},
   743  		{EventId: 2, Version: 2},
   744  		{EventId: 6, Version: 3},
   745  		{EventId: 7, Version: 4},
   746  	}
   747  	s.False(IsVersionHistoryItemsInSameBranch(versionHistoryItemsA, versionHistoryItemsB))
   748  	s.False(IsVersionHistoryItemsInSameBranch(versionHistoryItemsB, versionHistoryItemsA))
   749  }