Function TestReplicatorPutObjects

usecases/replica/replicator_test.go:606–780

(t *testing.T)

}

func TestReplicatorPutObjects(t *testing.T) {
	var (
		cls   = "C1"
		shard = "SH1"
		nodes = []string{"A", "B"}
		ctx   = context.Background()
		objs  = []*storobj.Object{{}, {}, {}}
		resp1 = replica.SimpleResponse{[]replicaerrors.Error{{}}}
	)

	testCases := []struct {
		variant       string
		isMultiTenant bool
	}{
		{"MultiTenant", true},
		{"SingleTenant", false},
	}

	for _, tc := range testCases {
		t.Run(fmt.Sprintf("SuccessWithConsistencyLevelAll_%v", tc.variant), func(t *testing.T) {
			f := newFakeFactory(t, "C1", shard, nodes, tc.isMultiTenant)
			rep := f.newReplicator()
			resp := replica.SimpleResponse{Errors: make([]replicaerrors.Error, 3)}
			for _, n := range nodes {
				f.WClient.On("PutObjects", mock.Anything, n, cls, shard, anyVal, objs, uint64(123)).Return(resp, nil)
				f.WClient.On("Commit", ctx, n, cls, shard, anyVal, anyVal).Return(nil)
			}
			errs := rep.PutObjects(ctx, shard, objs, types.ConsistencyLevelAll, 123)
			assert.Equal(t, []error{nil, nil, nil}, errs)
		})

		t.Run(fmt.Sprintf("SuccessWithConsistencyLevelOne_%v", tc.variant), func(t *testing.T) {
			nodes := []string{"A", "B", "C"}
			f := newFakeFactory(t, "C1", shard, nodes, tc.isMultiTenant)
			rep := f.newReplicator()

			// Phase one: branch on host(make it deterministic). Only "A" can succeed; all other hosts
			// return a phase-one error. This guarantees:
			//   - multiple replicas are contacted
			//   - only "A" is eligible for commit.
			f.WClient.EXPECT().
				PutObjects(mock.Anything, mock.Anything, cls, shard, anyVal, objs, uint64(0)).
				RunAndReturn(func(ctx context.Context, host, index, shard, reqID string, os []*storobj.Object, sv uint64) (replica.SimpleResponse, error) {
					if host == "A" {
						return resp1, nil
					}
					return replica.SimpleResponse{}, errAny
				})

			// Commit only on the successful node.
			var wg sync.WaitGroup
			wg.Add(1)
			f.WClient.On("Commit", ctx, "A", cls, shard, anyVal, anyVal).Return(nil).RunFn = func(a mock.Arguments) {
				defer wg.Done()
				resp := a[5].(*replica.SimpleResponse)
				*resp = replica.SimpleResponse{Errors: make([]replicaerrors.Error, 3)}
			}