github.com/PDOK/gokoala@v0.50.6/internal/ogc/features/domain/cursor_test.go (about)

     1  package domain
     2  
     3  import (
     4  	"math"
     5  	"reflect"
     6  	"testing"
     7  )
     8  
     9  func TestNewCursor(t *testing.T) {
    10  	type args struct {
    11  		features []*Feature
    12  		id       PrevNextFID
    13  	}
    14  	var tests = []struct {
    15  		name string
    16  		args args
    17  		want Cursors
    18  	}{
    19  		{
    20  			name: "test first page",
    21  			args: args{
    22  				features: []*Feature{{ID: 1}, {ID: 2}, {ID: 3}, {ID: 4}},
    23  				id: PrevNextFID{
    24  					Prev: 0,
    25  					Next: 4,
    26  				},
    27  			},
    28  			want: Cursors{
    29  				Prev:    "|",
    30  				Next:    "BA|",
    31  				HasPrev: false,
    32  				HasNext: true,
    33  			},
    34  		},
    35  		{
    36  			name: "test last page",
    37  			args: args{
    38  				features: []*Feature{{ID: 5}, {ID: 6}, {ID: 7}, {ID: 8}},
    39  				id: PrevNextFID{
    40  					Prev: 4,
    41  					Next: 0,
    42  				},
    43  			},
    44  			want: Cursors{
    45  				Prev:    "BA|",
    46  				Next:    "|",
    47  				HasPrev: true,
    48  				HasNext: false,
    49  			},
    50  		},
    51  		{
    52  			name: "test middle page",
    53  			args: args{
    54  				features: []*Feature{{ID: 3}, {ID: 4}, {ID: 5}, {ID: 6}},
    55  				id: PrevNextFID{
    56  					Prev: 2,
    57  					Next: 7,
    58  				},
    59  			},
    60  			want: Cursors{
    61  				Prev:    "Ag|",
    62  				Next:    "Bw|",
    63  				HasPrev: true,
    64  				HasNext: true,
    65  			},
    66  		},
    67  	}
    68  	for _, tt := range tests {
    69  		t.Run(tt.name, func(t *testing.T) {
    70  			got := NewCursors(tt.args.id, []byte{})
    71  			if !reflect.DeepEqual(got, tt.want) {
    72  				t.Errorf("NewCursors() = %v, want %v", got, tt.want)
    73  			}
    74  		})
    75  	}
    76  }
    77  
    78  func TestEncodedCursor_Decode(t *testing.T) {
    79  	type args struct {
    80  		filtersChecksum []byte
    81  	}
    82  	tests := []struct {
    83  		name string
    84  		c    EncodedCursor
    85  		args args
    86  		want DecodedCursor
    87  	}{
    88  		{
    89  			name: "should return cursor if no checksum is available in cursor, and no expected checksum provided",
    90  			c:    encodeCursor(123, []byte{}),
    91  			args: args{
    92  				filtersChecksum: []byte{},
    93  			},
    94  			want: DecodedCursor{
    95  				FID:             123,
    96  				FiltersChecksum: []byte{},
    97  			},
    98  		},
    99  		{
   100  			name: "should not fail on checksum which contains separator",
   101  			c:    encodeCursor(123456, []byte{'a', separator, 'b'}),
   102  			args: args{
   103  				filtersChecksum: []byte{'a', separator, 'b'},
   104  			},
   105  			want: DecodedCursor{
   106  				FID:             123456,
   107  				FiltersChecksum: []byte{'a', separator, 'b'},
   108  			},
   109  		},
   110  		{
   111  			name: "should not fail on checksum which contains only separator",
   112  			c:    encodeCursor(123456, []byte{separator}),
   113  			args: args{
   114  				filtersChecksum: []byte{separator},
   115  			},
   116  			want: DecodedCursor{
   117  				FID:             123456,
   118  				FiltersChecksum: []byte{separator},
   119  			},
   120  		},
   121  		{
   122  			name: "should fail (return 0 fid) on non matching checksums",
   123  			c:    encodeCursor(123456, []byte("foobarbaz")),
   124  			args: args{
   125  				filtersChecksum: []byte("bazbar"),
   126  			},
   127  			want: DecodedCursor{
   128  				FID:             0,
   129  				FiltersChecksum: []byte("bazbar"),
   130  			},
   131  		},
   132  		{
   133  			name: "should handle large feature id",
   134  			c:    encodeCursor(math.MaxInt64, []byte("foobar")),
   135  			args: args{
   136  				filtersChecksum: []byte("foobar"),
   137  			},
   138  			want: DecodedCursor{
   139  				FID:             math.MaxInt64,
   140  				FiltersChecksum: []byte("foobar"),
   141  			},
   142  		},
   143  		{
   144  			name: "should always return positive feature id",
   145  			c:    encodeCursor(math.MinInt64, []byte("foobar")),
   146  			args: args{
   147  				filtersChecksum: []byte("foobar"),
   148  			},
   149  			want: DecodedCursor{
   150  				FID:             0,
   151  				FiltersChecksum: []byte("foobar"),
   152  			},
   153  		},
   154  	}
   155  	for _, tt := range tests {
   156  		t.Run(tt.name, func(t *testing.T) {
   157  			if got := tt.c.Decode(tt.args.filtersChecksum); !reflect.DeepEqual(got, tt.want) {
   158  				t.Errorf("Decode() = %v, want %v", got, tt.want)
   159  			}
   160  		})
   161  	}
   162  }
   163  
   164  func TestEncodedCursor_Pagination(t *testing.T) {
   165  	type args struct {
   166  		filtersChecksum []byte
   167  	}
   168  	tests := []struct {
   169  		name string
   170  		c    EncodedCursor
   171  		args args
   172  		want DecodedCursor
   173  	}{
   174  		{
   175  			name: "should not reset to first page",
   176  			c:    "Z3Z8%7C-Q8mwg",
   177  			args: args{
   178  				filtersChecksum: []byte{249, 15, 38, 194},
   179  			},
   180  			want: DecodedCursor{
   181  				FID:             6780540,
   182  				FiltersChecksum: []byte{249, 15, 38, 194},
   183  			},
   184  		},
   185  		{
   186  			name: "should return cursor with fid 0 and empty checksum",
   187  			c:    "%7C",
   188  			args: args{
   189  				filtersChecksum: []byte{},
   190  			},
   191  			want: DecodedCursor{
   192  				FID:             0,
   193  				FiltersChecksum: []byte{},
   194  			},
   195  		},
   196  	}
   197  	for _, tt := range tests {
   198  		t.Run(tt.name, func(t *testing.T) {
   199  			if got := tt.c.Decode(tt.args.filtersChecksum); !reflect.DeepEqual(got, tt.want) {
   200  				t.Errorf("Decode() = %v, want %v", got, tt.want)
   201  			}
   202  		})
   203  	}
   204  }