github.com/cayleygraph/cayley@v0.7.7/graph/iterator/resolver_test.go (about)

     1  package iterator_test
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/cayleygraph/cayley/graph"
     8  	"github.com/cayleygraph/cayley/graph/graphmock"
     9  	"github.com/cayleygraph/cayley/graph/iterator"
    10  	"github.com/cayleygraph/quad"
    11  )
    12  
    13  func TestResolverIteratorIterate(t *testing.T) {
    14  	var ctx context.Context
    15  	nodes := []quad.Value{
    16  		quad.String("1"),
    17  		quad.String("2"),
    18  		quad.String("3"),
    19  		quad.String("4"),
    20  		quad.String("5"),
    21  		quad.String("3"), // Assert iterator can handle duplicate values
    22  	}
    23  	data := make([]quad.Quad, 0, len(nodes))
    24  	for _, node := range nodes {
    25  		data = append(data, quad.Make(quad.String("0"), "has", node, nil))
    26  	}
    27  	qs := &graphmock.Store{
    28  		Data: data,
    29  	}
    30  	expected := make(map[quad.Value]graph.Ref)
    31  	for _, node := range nodes {
    32  		expected[node] = qs.ValueOf(node)
    33  	}
    34  	it := iterator.NewResolver(qs, nodes...)
    35  	for _, node := range nodes {
    36  		if it.Next(ctx) != true {
    37  			t.Fatal("unexpected end of iterator")
    38  		}
    39  		if err := it.Err(); err != nil {
    40  			t.Fatalf("unexpected error: %v", err)
    41  		}
    42  		if value := it.Result(); value != expected[node] {
    43  			t.Fatalf("unexpected quad value: expected %v, got %v", expected[node], value)
    44  		}
    45  	}
    46  	if it.Next(ctx) != false {
    47  		t.Fatal("expected end of iterator")
    48  	}
    49  	if it.Result() != nil {
    50  		t.Fatal("expected nil result")
    51  	}
    52  }
    53  
    54  func TestResolverIteratorNotFoundError(t *testing.T) {
    55  	var ctx context.Context
    56  	nodes := []quad.Value{
    57  		quad.String("1"),
    58  		quad.String("2"),
    59  		quad.String("3"),
    60  		quad.String("4"),
    61  		quad.String("5"),
    62  	}
    63  	data := make([]quad.Quad, 0)
    64  	skip := 3
    65  	for i, node := range nodes {
    66  		// Simulate a missing subject
    67  		if i == skip {
    68  			continue
    69  		}
    70  		data = append(data, quad.Make(quad.String("0"), "has", node, nil))
    71  	}
    72  	qs := &graphmock.Store{
    73  		Data: data,
    74  	}
    75  	count := 0
    76  	it := iterator.NewResolver(qs, nodes...)
    77  	for it.Next(ctx) {
    78  		count++
    79  	}
    80  	if count != 0 {
    81  		t.Fatal("expected end of iterator")
    82  	}
    83  	if it.Err() == nil {
    84  		t.Fatal("expected not found error")
    85  	}
    86  	if it.Result() != nil {
    87  		t.Fatal("expected nil result")
    88  	}
    89  }
    90  
    91  func TestResolverIteratorContains(t *testing.T) {
    92  	tests := []struct {
    93  		name     string
    94  		nodes    []quad.Value
    95  		subject  quad.Value
    96  		contains bool
    97  	}{
    98  		{
    99  			"contains",
   100  			[]quad.Value{
   101  				quad.String("1"),
   102  				quad.String("2"),
   103  				quad.String("3"),
   104  			},
   105  			quad.String("2"),
   106  			true,
   107  		},
   108  		{
   109  			"not contains",
   110  			[]quad.Value{
   111  				quad.String("1"),
   112  				quad.String("3"),
   113  			},
   114  			quad.String("2"),
   115  			false,
   116  		},
   117  	}
   118  	for _, test := range tests {
   119  		t.Run(test.name, func(t *testing.T) {
   120  			var ctx context.Context
   121  			data := make([]quad.Quad, 0, len(test.nodes))
   122  			for _, node := range test.nodes {
   123  				data = append(data, quad.Make(quad.String("0"), "has", node, nil))
   124  			}
   125  			qs := &graphmock.Store{
   126  				Data: data,
   127  			}
   128  			it := iterator.NewResolver(qs, test.nodes...)
   129  			if it.Contains(ctx, graph.PreFetched(test.subject)) != test.contains {
   130  				t.Fatal("unexpected result")
   131  			}
   132  		})
   133  	}
   134  }