github.com/braveheart12/just@v0.8.7/ledger/storage/replicastorage_test.go (about)

     1  /*
     2   *    Copyright 2019 Insolar Technologies
     3   *
     4   *    Licensed under the Apache License, Version 2.0 (the "License");
     5   *    you may not use this file except in compliance with the License.
     6   *    You may obtain a copy of the License at
     7   *
     8   *        http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   *    Unless required by applicable law or agreed to in writing, software
    11   *    distributed under the License is distributed on an "AS IS" BASIS,
    12   *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   *    See the License for the specific language governing permissions and
    14   *    limitations under the License.
    15   */
    16  
    17  package storage_test
    18  
    19  import (
    20  	"context"
    21  	"testing"
    22  
    23  	"github.com/insolar/insolar/component"
    24  	"github.com/insolar/insolar/ledger/storage"
    25  	"github.com/insolar/insolar/platformpolicy"
    26  	"github.com/stretchr/testify/assert"
    27  	"github.com/stretchr/testify/require"
    28  	"github.com/stretchr/testify/suite"
    29  
    30  	"github.com/insolar/insolar/core"
    31  	"github.com/insolar/insolar/instrumentation/inslogger"
    32  	"github.com/insolar/insolar/ledger/storage/storagetest"
    33  	"github.com/insolar/insolar/testutils"
    34  )
    35  
    36  type replicaSuite struct {
    37  	suite.Suite
    38  
    39  	cm      *component.Manager
    40  	ctx     context.Context
    41  	cleaner func()
    42  
    43  	replicaStorage storage.ReplicaStorage
    44  
    45  	jetID core.RecordID
    46  }
    47  
    48  func NewReplicaSuite() *replicaSuite {
    49  	return &replicaSuite{
    50  		Suite: suite.Suite{},
    51  	}
    52  }
    53  
    54  // Init and run suite
    55  func TestReplicaStorage(t *testing.T) {
    56  	suite.Run(t, NewReplicaSuite())
    57  }
    58  
    59  func (s *replicaSuite) BeforeTest(suiteName, testName string) {
    60  	s.cm = &component.Manager{}
    61  	s.ctx = inslogger.TestContext(s.T())
    62  	s.jetID = core.TODOJetID
    63  
    64  	db, cleaner := storagetest.TmpDB(s.ctx, s.T())
    65  	s.cleaner = cleaner
    66  	s.replicaStorage = storage.NewReplicaStorage()
    67  
    68  	s.cm.Inject(
    69  		platformpolicy.NewPlatformCryptographyScheme(),
    70  		db,
    71  		s.replicaStorage,
    72  	)
    73  
    74  	err := s.cm.Init(s.ctx)
    75  	if err != nil {
    76  		s.T().Error("ComponentManager init failed", err)
    77  	}
    78  	err = s.cm.Start(s.ctx)
    79  	if err != nil {
    80  		s.T().Error("ComponentManager start failed", err)
    81  	}
    82  }
    83  
    84  func (s *replicaSuite) AfterTest(suiteName, testName string) {
    85  	err := s.cm.Stop(s.ctx)
    86  	if err != nil {
    87  		s.T().Error("ComponentManager stop failed", err)
    88  	}
    89  	s.cleaner()
    90  }
    91  
    92  func (s *replicaSuite) Test_ReplicatedPulse() {
    93  	// test {Set/Get}HeavySyncedPulse methods pair
    94  	heavyGot0, err := s.replicaStorage.GetHeavySyncedPulse(s.ctx, s.jetID)
    95  	require.NoError(s.T(), err)
    96  	assert.Equal(s.T(), core.PulseNumber(0), heavyGot0)
    97  
    98  	expectHeavy := core.PulseNumber(100500)
    99  	err = s.replicaStorage.SetHeavySyncedPulse(s.ctx, s.jetID, expectHeavy)
   100  	require.NoError(s.T(), err)
   101  
   102  	gotHeavy, err := s.replicaStorage.GetHeavySyncedPulse(s.ctx, s.jetID)
   103  	require.NoError(s.T(), err)
   104  	assert.Equal(s.T(), expectHeavy, gotHeavy)
   105  }
   106  
   107  func (s *replicaSuite) Test_SyncClientJetPulses() {
   108  	var expectEmpty []core.PulseNumber
   109  	gotEmpty, err := s.replicaStorage.GetSyncClientJetPulses(s.ctx, s.jetID)
   110  	require.NoError(s.T(), err)
   111  	assert.Equal(s.T(), expectEmpty, gotEmpty)
   112  
   113  	expect := []core.PulseNumber{100, 500, 100500}
   114  	err = s.replicaStorage.SetSyncClientJetPulses(s.ctx, s.jetID, expect)
   115  	require.NoError(s.T(), err)
   116  
   117  	got, err := s.replicaStorage.GetSyncClientJetPulses(s.ctx, s.jetID)
   118  	require.NoError(s.T(), err)
   119  	assert.Equal(s.T(), expect, got)
   120  }
   121  
   122  func (s *replicaSuite) Test_GetAllSyncClientJets() {
   123  	tt := []struct {
   124  		jetID  core.RecordID
   125  		pulses []core.PulseNumber
   126  	}{
   127  		{
   128  			jetID:  testutils.RandomJet(),
   129  			pulses: []core.PulseNumber{100, 500, 100500},
   130  		},
   131  		{
   132  			jetID:  testutils.RandomJet(),
   133  			pulses: []core.PulseNumber{100, 500},
   134  		},
   135  		{
   136  			jetID: testutils.RandomJet(),
   137  		},
   138  		{
   139  			jetID:  testutils.RandomJet(),
   140  			pulses: []core.PulseNumber{100500},
   141  		},
   142  	}
   143  
   144  	for _, tCase := range tt {
   145  		err := s.replicaStorage.SetSyncClientJetPulses(s.ctx, tCase.jetID, tCase.pulses)
   146  		require.NoError(s.T(), err)
   147  	}
   148  
   149  	gotJets, err := s.replicaStorage.GetAllNonEmptySyncClientJets(s.ctx)
   150  	require.NoError(s.T(), err)
   151  
   152  	for i, tCase := range tt {
   153  		gotPulses, ok := gotJets[tCase.jetID]
   154  		if tCase.pulses == nil {
   155  			assert.Falsef(s.T(), ok, "jet should not present jetID=%v", tCase.jetID)
   156  		} else {
   157  			require.Truef(s.T(), ok, "jet should  present jetID=%v", tCase.jetID)
   158  			assert.Equalf(s.T(), tCase.pulses, gotPulses, "pulses not found for jet number %v: %v", i, tCase.jetID)
   159  		}
   160  	}
   161  
   162  	gotJets, err = s.replicaStorage.GetAllSyncClientJets(s.ctx)
   163  	require.NoError(s.T(), err)
   164  
   165  	for i, tCase := range tt {
   166  		gotPulses, ok := gotJets[tCase.jetID]
   167  		require.Truef(s.T(), ok, "jet should  present jetID=%v", tCase.jetID)
   168  		assert.Equalf(s.T(), tCase.pulses, gotPulses, "pulses not found for jet number %v: %v", i, tCase.jetID)
   169  	}
   170  }