github.com/avenga/couper@v1.12.2/config/sequence/sequence_test.go (about)

     1  package sequence
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/google/go-cmp/cmp"
     7  )
     8  
     9  func TestItem_ResolveSequence(t *testing.T) {
    10  
    11  	b := (&Item{Name: "b"}).Add(&Item{Name: "c"})
    12  
    13  	tests := []struct {
    14  		name        string
    15  		item        *Item
    16  		expResolved []string
    17  	}{
    18  		{name: "order A", item: (&Item{Name: "test"}).
    19  			Add((&Item{Name: "a"}).Add(b)).
    20  			Add(b),
    21  			expResolved: []string{"c", "b", "a", "test"}},
    22  		{name: "order B", item: (&Item{Name: "test"}).
    23  			Add(b).
    24  			Add((&Item{Name: "a"}).Add(b)),
    25  			expResolved: []string{"c", "b", "a", "test"}},
    26  	}
    27  	for _, tt := range tests {
    28  		t.Run(tt.name, func(st *testing.T) {
    29  			var resolved, seen []string
    30  			resolveSequence(tt.item, &resolved, &seen)
    31  			if diff := cmp.Diff(tt.expResolved, resolved); diff != "" {
    32  				st.Errorf("\ngot:\t%#v\ndiff: %s\nseen:\t%#v", resolved, diff, seen)
    33  			}
    34  		})
    35  	}
    36  }
    37  
    38  func TestItem_Add_error(t *testing.T) {
    39  
    40  	tests := []struct {
    41  		name     string
    42  		itemFunc func(a, b, c *Item) *Item
    43  	}{
    44  		{
    45  			name: "circle 1",
    46  			itemFunc: func(a, b, c *Item) *Item {
    47  				a.Add(b)
    48  				b.Add(a)
    49  				return a
    50  			},
    51  		},
    52  		{
    53  			name: "circle 2",
    54  			itemFunc: func(a, b, c *Item) *Item {
    55  				a.Add(b)
    56  				b.Add(c)
    57  				c.Add(a)
    58  				return a
    59  			},
    60  		},
    61  		{
    62  			name: "add self",
    63  			itemFunc: func(a, b, c *Item) *Item {
    64  				a.Add(a)
    65  				return a
    66  			},
    67  		},
    68  	}
    69  	for _, tt := range tests {
    70  		t.Run(tt.name, func(st *testing.T) {
    71  			i := &Item{Name: "i"}
    72  			j := &Item{Name: "j"}
    73  			k := &Item{Name: "k"}
    74  
    75  			defer func() { _ = recover() }()
    76  
    77  			tt.itemFunc(i, j, k)
    78  
    79  			st.Error("Missing panic")
    80  		})
    81  	}
    82  }
    83  
    84  func TestBackendItem_ResolveSequence(t *testing.T) {
    85  
    86  	tests := []struct {
    87  		name        string
    88  		itemFunc    func(a, b, c *Item) *Item
    89  		expResolved []string
    90  	}{
    91  		{
    92  			name: "order A",
    93  			itemFunc: func(a, b, c *Item) *Item {
    94  				b.Add(c)
    95  				a.Add(b)
    96  				a.Add(c)
    97  				return a
    98  			},
    99  			expResolved: []string{"vault", "as", "rs"},
   100  		},
   101  		{
   102  			name: "order B",
   103  			itemFunc: func(a, b, c *Item) *Item {
   104  				a.Add(b)
   105  				a.Add(c)
   106  				b.Add(c)
   107  				return a
   108  			},
   109  			expResolved: []string{"vault", "as", "rs"},
   110  		},
   111  		{
   112  			name: "multiple",
   113  			itemFunc: func(a, b, c *Item) *Item {
   114  				a.Add(b)
   115  				a.Add(b)
   116  				return a
   117  			},
   118  			expResolved: []string{"as", "rs"},
   119  		},
   120  	}
   121  	for _, tt := range tests {
   122  		t.Run(tt.name, func(st *testing.T) {
   123  			var resolved, seen []string
   124  
   125  			rs := NewBackendItem("rs")
   126  			as := NewBackendItem("as")
   127  			vault := NewBackendItem("vault")
   128  
   129  			resolveSequence(tt.itemFunc(rs, as, vault), &resolved, &seen)
   130  			if diff := cmp.Diff(tt.expResolved, resolved); diff != "" {
   131  				st.Errorf("\ngot:\t%#v\ndiff: %s\nseen:\t%#v", resolved, diff, seen)
   132  			}
   133  		})
   134  	}
   135  }
   136  
   137  func TestBackendItem_Add_error(t *testing.T) {
   138  
   139  	tests := []struct {
   140  		name     string
   141  		itemFunc func(a, b, c *Item) *Item
   142  	}{
   143  		{
   144  			name: "circle 1",
   145  			itemFunc: func(a, b, c *Item) *Item {
   146  				a.Add(b)
   147  				b.Add(a)
   148  				return a
   149  			},
   150  		},
   151  		{
   152  			name: "circle 2",
   153  			itemFunc: func(a, b, c *Item) *Item {
   154  				a.Add(b)
   155  				b.Add(c)
   156  				c.Add(a)
   157  				return a
   158  			},
   159  		},
   160  		{
   161  			name: "add self",
   162  			itemFunc: func(a, b, c *Item) *Item {
   163  				a.Add(a)
   164  				return a
   165  			},
   166  		},
   167  	}
   168  	for _, tt := range tests {
   169  		t.Run(tt.name, func(st *testing.T) {
   170  			rs := NewBackendItem("rs")
   171  			as := NewBackendItem("as")
   172  			vault := NewBackendItem("vault")
   173  
   174  			defer func() { _ = recover() }()
   175  
   176  			tt.itemFunc(rs, as, vault)
   177  
   178  			st.Error("Missing panic")
   179  		})
   180  	}
   181  }