alldocs_test.go

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

     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  package memorydb
    14  
    15  import (
    16  	"context"
    17  	"io"
    18  	"sort"
    19  	"testing"
    20  
    21  	"gitlab.com/flimzy/testy"
    22  
    23  	"github.com/go-kivik/kivik/v4/driver"
    24  )
    25  
    26  func TestAllDocsClose(t *testing.T) {
    27  	rs := &alldocsResults{
    28  		resultSet{
    29  			revs:   []*revision{{}, {}}, // Two nil revisions
    30  			docIDs: []string{"a", "b"},
    31  		},
    32  	}
    33  	row := driver.Row{}
    34  	if err := rs.Next(&row); err != nil {
    35  		t.Fatal(err)
    36  	}
    37  	if err := rs.Close(); err != nil {
    38  		t.Errorf("Unexpected error: %s", err)
    39  	}
    40  	if err := rs.Next(&row); err != io.EOF {
    41  		t.Errorf("Unexpected Next() error after closing: %s", err)
    42  	}
    43  }
    44  
    45  func TestAllDocs(t *testing.T) {
    46  	type adTest struct {
    47  		Name        string
    48  		ExpectedIDs []string
    49  		Error       string
    50  		DB          *db
    51  		RowsError   string
    52  	}
    53  	tests := []adTest{
    54  		{
    55  			Name: "NoDocs",
    56  		},
    57  		{
    58  			Name: "OneDoc",
    59  			DB: func() *db {
    60  				db := setupDB(t)
    61  				if _, err := db.Put(context.Background(), "foo", map[string]string{"foo": "bar"}, nil); err != nil {
    62  					t.Fatal(err)
    63  				}
    64  				return db
    65  			}(),
    66  			ExpectedIDs: []string{"foo"},
    67  		},
    68  		{
    69  			Name: "Five Docs",
    70  			DB: func() *db {
    71  				db := setupDB(t)
    72  				for _, id := range []string{"a", "c", "z", "q", "chicken"} {
    73  					if _, err := db.Put(context.Background(), id, map[string]string{"value": id}, nil); err != nil {
    74  						t.Fatal(err)
    75  					}
    76  				}
    77  				return db
    78  			}(),
    79  			ExpectedIDs: []string{"a", "c", "chicken", "q", "z"},
    80  		},
    81  	}
    82  	for _, test := range tests {
    83  		func(test adTest) {
    84  			t.Run(test.Name, func(t *testing.T) {
    85  				db := test.DB
    86  				if db == nil {
    87  					db = setupDB(t)
    88  				}
    89  				rows, err := db.AllDocs(context.Background(), nil)
    90  				var msg string
    91  				if err != nil {
    92  					msg = err.Error()
    93  				}
    94  				if test.Error != msg {
    95  					t.Errorf("Unexpected error: %s", msg)
    96  				}
    97  				if err != nil {
    98  					return
    99  				}
   100  				checkRows(t, rows, test.ExpectedIDs, test.RowsError)
   101  			})
   102  		}(test)
   103  	}
   104  }
   105  
   106  func checkRows(t *testing.T, rows driver.Rows, expectedIDs []string, rowsErr string) {
   107  	t.Helper()
   108  	var row driver.Row
   109  	var ids []string
   110  	msg := ""
   111  	for {
   112  		e := rows.Next(&row)
   113  		if e != nil {
   114  			if e != io.EOF {
   115  				msg = e.Error()
   116  			}
   117  			break
   118  		}
   119  		ids = append(ids, row.ID)
   120  	}
   121  	if rowsErr != msg {
   122  		t.Errorf("Unexpected rows error: %s", msg)
   123  	}
   124  	sort.Strings(ids)
   125  	if d := testy.DiffTextSlices(expectedIDs, ids); d != nil {
   126  		t.Error(d)
   127  	}
   128  }
   129  
   130  func TestAllDocsUpdateSeq(t *testing.T) {
   131  	expected := "12345"
   132  	rs := &alldocsResults{resultSet{updateSeq: expected}}
   133  	if result := rs.UpdateSeq(); result != expected {
   134  		t.Errorf("Unexpected upste seq: %s", result)
   135  	}
   136  }
   137  
   138  func TestAllDocsTotalRows(t *testing.T) {
   139  	expected := int64(123)
   140  	rs := &alldocsResults{resultSet{totalRows: expected}}
   141  	if result := rs.TotalRows(); result != expected {
   142  		t.Errorf("Unexpected upste seq: %d", result)
   143  	}
   144  }
   145  
   146  func TestAllDocsOffset(t *testing.T) {
   147  	expected := int64(123)
   148  	rs := &alldocsResults{resultSet{offset: expected}}
   149  	if result := rs.Offset(); result != expected {
   150  		t.Errorf("Unexpected upste seq: %d", result)
   151  	}
   152  }
   153
View as plain text