profiles/internal/rpc/version/version_test.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package version

import (
	"testing"

	inaming "v.io/x/ref/profiles/internal/naming"

	"v.io/v23/naming"
	"v.io/v23/rpc/version"
	"v.io/v23/verror"
)

func TestCommonVersion(t *testing.T) {
	r := &Range{Min: 2, Max: 4}

	type testCase struct {
		localMin, localMax   version.RPCVersion
		remoteMin, remoteMax version.RPCVersion
		expectedVer          version.RPCVersion
		expectedErr          verror.IDAction
	}
	tests := []testCase{
		{0, 0, 0, 0, 0, ErrUnknownVersion},
		{0, 2, 3, 4, 0, ErrNoCompatibleVersion},
		{3, 4, 0, 2, 0, ErrNoCompatibleVersion},
		{0, 6, 6, 7, 0, ErrNoCompatibleVersion},
		{0, 3, 3, 5, 3, verror.ErrUnknown},
		{0, 3, 2, 4, 3, verror.ErrUnknown},
		{2, 4, 2, 4, 4, verror.ErrUnknown},
		{4, 4, 4, 4, 4, verror.ErrUnknown},
	}
	for _, tc := range tests {
		local := &inaming.Endpoint{
			MinRPCVersion: tc.localMin,
			MaxRPCVersion: tc.localMax,
		}
		remote := &inaming.Endpoint{
			MinRPCVersion: tc.remoteMin,
			MaxRPCVersion: tc.remoteMax,
		}
		ver, err := r.CommonVersion(local, remote)
		if ver != tc.expectedVer || (err != nil && verror.ErrorID(err) != tc.expectedErr.ID) {
			t.Errorf("Unexpected result for local: %v, remote: %v.  Got (%d, %v) wanted (%d, %v)",
				local, remote, ver, err, tc.expectedVer, tc.expectedErr)
		}
		if err != nil {
			t.Logf("%s", err)
		}
	}
}

func TestProxiedEndpoint(t *testing.T) {
	type testCase struct {
		supportMin, supportMax version.RPCVersion
		proxyMin, proxyMax     version.RPCVersion
		outMin, outMax         version.RPCVersion
		expectError            bool
	}
	tests := []testCase{
		{2, 4, 2, 3, 2, 3, false},
		{2, 4, 4, 6, 4, 4, false},
		{2, 4, 0, 2, 2, 2, false},
		{2, 4, 0, 2, 2, 2, false},
		{0, 0, 0, 0, 0, 0, true},
		{3, 4, 0, 2, 0, 0, true},
		{3, 6, 7, 8, 0, 0, true},
	}

	rid := naming.FixedRoutingID(1)
	for _, tc := range tests {
		r := &Range{Min: tc.supportMin, Max: tc.supportMax}
		proxy := &inaming.Endpoint{
			MinRPCVersion: tc.proxyMin,
			MaxRPCVersion: tc.proxyMax,
		}
		if ep, err := r.ProxiedEndpoint(rid, proxy); err != nil {
			if !tc.expectError {
				t.Errorf("Unexpected error for case %+v: %v", tc, err)
			}
		} else {
			if tc.expectError {
				t.Errorf("Expected Error, but got result for test case %+v", tc)
				continue
			}
			if ep.MinRPCVersion != tc.outMin || ep.MaxRPCVersion != tc.outMax {
				t.Errorf("Unexpected range for case %+v.  Got (%d, %d) want (%d, %d)",
					tc, ep.MinRPCVersion, ep.MaxRPCVersion, tc.outMin, tc.outMax)
			}
		}
	}
}

func TestCheckCompatibility(t *testing.T) {
	type testCase struct {
		supportMin, supportMax version.RPCVersion
		remoteMin, remoteMax   version.RPCVersion
		expectedError          verror.IDAction
	}
	tests := []testCase{
		{0, 0, 0, 0, ErrUnknownVersion},
		{6, 11, 2, 5, ErrNoCompatibleVersion},
		{2, 5, 6, 11, ErrNoCompatibleVersion},
		{2, 11, 3, 10, verror.ErrUnknown},
		{4, 9, 2, 5, verror.ErrUnknown},
		{4, 9, 8, 10, verror.ErrUnknown},
	}

	for _, tc := range tests {
		r := &Range{Min: tc.supportMin, Max: tc.supportMax}
		remote := &inaming.Endpoint{
			MinRPCVersion: tc.remoteMin,
			MaxRPCVersion: tc.remoteMax,
		}
		err := r.CheckCompatibility(remote)
		if err != nil && verror.ErrorID(err) != tc.expectedError.ID {
			t.Errorf("Unexpected error for case %+v: got %v, wanted %v",
				tc, err, tc.expectedError)
		}
		if err != nil {
			t.Logf("%s", err)
		}
	}
}