github.com/weaviate/weaviate@v1.24.6/usecases/replica/resolver_test.go (about)

     1  //                           _       _
     2  // __      _____  __ ___   ___  __ _| |_ ___
     3  // \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
     4  //  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
     5  //   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
     6  //
     7  //  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
     8  //
     9  //  CONTACT: hello@weaviate.io
    10  //
    11  
    12  package replica
    13  
    14  import (
    15  	"testing"
    16  
    17  	"github.com/stretchr/testify/assert"
    18  )
    19  
    20  func TestResolver(t *testing.T) {
    21  	ss := map[string][]string{
    22  		"S0": {},
    23  		"S1": {"A", "B", "C"},
    24  		"S2": {"D", "E"},
    25  		"S3": {"A", "B", "C", "D", "E"},
    26  		"S4": {"D", "E", "F"},
    27  		"S5": {"A", "B", "C", "D", "E", "F"},
    28  	}
    29  	assertSameHosts := func(want, got rState, thisNode string) {
    30  		t.Helper()
    31  		if thisNode != "" {
    32  			assert.Equal(t, thisNode, got.Hosts[0])
    33  		}
    34  		assert.ElementsMatch(t, want.Hosts, got.Hosts, "match Hosts")
    35  		assert.Equal(t, want.NodeMap, got.NodeMap, "match NodeMap")
    36  		assert.Equal(t, want.CLevel, got.CLevel, "match CLevel")
    37  		assert.Equal(t, want.Level, got.Level, "match Level")
    38  	}
    39  
    40  	nr := newFakeNodeResolver([]string{"A", "B", "C"})
    41  	r := resolver{
    42  		nodeResolver: nr,
    43  		Class:        "C",
    44  		NodeName:     "A",
    45  		Schema:       newFakeShardingState("A", ss, nr),
    46  	}
    47  	t.Run("ShardingState", func(t *testing.T) {
    48  		_, err := r.State("Sx", One, "")
    49  		assert.NotNil(t, err)
    50  		assert.Contains(t, err.Error(), "sharding state")
    51  	})
    52  	t.Run("ALL", func(t *testing.T) {
    53  		r := resolver{
    54  			nodeResolver: nr,
    55  			Class:        "C",
    56  			NodeName:     "B",
    57  			Schema:       newFakeShardingState("B", ss, nr),
    58  		}
    59  		got, err := r.State("S1", All, "")
    60  		assert.Nil(t, err)
    61  		m := make(map[string]string, len(ss["S1"]))
    62  		for _, k := range ss["S1"] {
    63  			m[k] = nr.hosts[k]
    64  		}
    65  		want := rState{All, len(ss["S1"]), ss["S1"], m}
    66  		assertSameHosts(want, got, "B")
    67  	})
    68  
    69  	t.Run("ALLWithDirectCandidate", func(t *testing.T) {
    70  		got, err := r.State("S1", All, "B")
    71  		assert.Nil(t, err)
    72  		m := make(map[string]string, len(ss["S1"]))
    73  		for _, k := range ss["S1"] {
    74  			m[k] = nr.hosts[k]
    75  		}
    76  		want := rState{All, len(ss["S1"]), ss["S1"], m}
    77  		assertSameHosts(want, got, "B")
    78  	})
    79  	t.Run("Quorum", func(t *testing.T) {
    80  		got, err := r.State("S3", Quorum, "")
    81  		assert.Nil(t, err)
    82  
    83  		m := make(map[string]string, len(ss["S1"]))
    84  		for _, k := range ss["S3"] {
    85  			m[k] = nr.hosts[k]
    86  		}
    87  		want := rState{Quorum, len(ss["S1"]), ss["S1"], m} // ss["S2"]}
    88  		assertSameHosts(want, got, "A")
    89  		_, err = got.ConsistencyLevel(All)
    90  		assert.ErrorIs(t, err, errUnresolvedName)
    91  		_, err = got.ConsistencyLevel(Quorum)
    92  		assert.Nil(t, err)
    93  		_, err = got.ConsistencyLevel(One)
    94  		assert.Nil(t, err)
    95  	})
    96  	t.Run("NoQuorum", func(t *testing.T) {
    97  		got, err := r.State("S5", Quorum, "")
    98  		assert.ErrorIs(t, err, errUnresolvedName)
    99  		m := make(map[string]string, len(ss["S1"]))
   100  		for _, k := range ss["S5"] {
   101  			m[k] = nr.hosts[k]
   102  		}
   103  		want := rState{Quorum, 0, ss["S1"], m} // ss["S4"]}
   104  		assertSameHosts(want, got, "A")
   105  
   106  		_, err = got.ConsistencyLevel(All)
   107  		assert.ErrorIs(t, err, errUnresolvedName)
   108  		_, err = got.ConsistencyLevel(Quorum)
   109  		assert.ErrorIs(t, err, errUnresolvedName)
   110  		_, err = got.ConsistencyLevel(One)
   111  		assert.Nil(t, err)
   112  	})
   113  }