resultset123_test.go

Documentation: github.com/go-kivik/kivik/v4

     1  // Licensed under the Apache License, Version 2.0 (the "License"); you may not
     2  // use this file except in compliance with the License. You may obtain a copy of
     3  // the License at
     4  //
     5  //  http://www.apache.org/licenses/LICENSE-2.0
     6  //
     7  // Unless required by applicable law or agreed to in writing, software
     8  // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
     9  // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
    10  // License for the specific language governing permissions and limitations under
    11  // the License.
    12  
    13  //go:build go1.23
    14  
    15  package kivik
    16  
    17  import (
    18  	"context"
    19  	"errors"
    20  	"io"
    21  	"testing"
    22  
    23  	"github.com/google/go-cmp/cmp"
    24  
    25  	"github.com/go-kivik/kivik/v4/driver"
    26  	"github.com/go-kivik/kivik/v4/int/mock"
    27  )
    28  
    29  func TestResultSetIterator(t *testing.T) {
    30  	t.Parallel()
    31  
    32  	rows := []interface{}{
    33  		&driver.Row{ID: "a"},
    34  		&driver.Row{ID: "b"},
    35  		&driver.Row{ID: "c"},
    36  	}
    37  
    38  	r := newResultSet(context.Background(), nil, &mock.Rows{
    39  		NextFunc: func(r *driver.Row) error {
    40  			if len(rows) == 0 {
    41  				return io.EOF
    42  			}
    43  			if dr, ok := rows[0].(*driver.Row); ok {
    44  				rows = rows[1:]
    45  				*r = *dr
    46  				return nil
    47  			}
    48  			return driver.EOQ
    49  		},
    50  	})
    51  
    52  	want := []string{"a", "b", "c"}
    53  	ids := []string{}
    54  
    55  	for row, err := range r.Iterator() {
    56  		if err != nil {
    57  			t.Fatalf("Unexpected error: %s", err)
    58  		}
    59  		id, err := row.ID()
    60  		if err != nil {
    61  			t.Fatalf("Unexpected error: %s", err)
    62  		}
    63  		ids = append(ids, id)
    64  	}
    65  	if d := cmp.Diff(want, ids); d != "" {
    66  		t.Errorf("Unexpected IDs: %s", d)
    67  	}
    68  }
    69  
    70  func TestResultSetIteratorError(t *testing.T) {
    71  	t.Parallel()
    72  
    73  	r := newResultSet(context.Background(), nil, &mock.Rows{
    74  		NextFunc: func(*driver.Row) error {
    75  			return errors.New("failure")
    76  		},
    77  	})
    78  
    79  	for _, err := range r.Iterator() {
    80  		if err == nil {
    81  			t.Fatal("expected error")
    82  		}
    83  		return
    84  	}
    85  	t.Fatal("Expected an error during iteration")
    86  }
    87  
    88  func TestResultSetIteratorBreak(t *testing.T) {
    89  	t.Parallel()
    90  
    91  	r := newResultSet(context.Background(), nil, &mock.Rows{
    92  		NextFunc: func(*driver.Row) error {
    93  			return nil
    94  		},
    95  	})
    96  
    97  	for _, err := range r.Iterator() {
    98  		if err != nil {
    99  			t.Fatalf("Unexpected error: %s", err)
   100  		}
   101  		break
   102  	}
   103  	if r.iter.state != stateClosed {
   104  		t.Errorf("Expected iterator to be closed")
   105  	}
   106  }
   107  
   108  func TestResultSetNextIterator(t *testing.T) {
   109  	t.Parallel()
   110  	r := multiResultSet()
   111  
   112  	ids := []string{}
   113  	for range r.NextIterator() {
   114  		for row, err := range r.Iterator() {
   115  			if err != nil {
   116  				t.Fatalf("Unexpected error: %s", err)
   117  			}
   118  			id, err := row.ID()
   119  			if err != nil {
   120  				t.Fatalf("Unexpected error: %s", err)
   121  			}
   122  			ids = append(ids, id)
   123  		}
   124  	}
   125  
   126  	if err := r.Err(); err != nil {
   127  		t.Error(err)
   128  	}
   129  	want := []string{"1", "2", "3", "x", "y"}
   130  	if d := cmp.Diff(want, ids); d != "" {
   131  		t.Error(d)
   132  	}
   133  
   134  	for row, err := range r.Iterator() {
   135  		if err != nil {
   136  			t.Fatalf("Unexpected error: %s", err)
   137  		}
   138  		id, err := row.ID()
   139  		if err != nil {
   140  			t.Fatalf("Unexpected error: %s", err)
   141  		}
   142  		ids = append(ids, id)
   143  	}
   144  	if d := cmp.Diff(want, ids); d != "" {
   145  		t.Errorf("Unexpected IDs: %s", d)
   146  	}
   147  }
   148  
   149  func TestResultSetNextIteratorBreak(t *testing.T) {
   150  	t.Parallel()
   151  
   152  	r := newResultSet(context.Background(), nil, &mock.Rows{
   153  		NextFunc: func(*driver.Row) error {
   154  			return errors.New("failure")
   155  		},
   156  	})
   157  
   158  	for range r.NextIterator() {
   159  		break
   160  	}
   161  
   162  	if r.iter.state != stateClosed {
   163  		t.Errorf("Expected iterator to be closed")
   164  	}
   165  }
   166
View as plain text