store - store_test.go

     1  package store
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  )
     7  
     8  func newTestStore() (*Store, error) {
     9  	return New(":memory:")
    10  }
    11  
    12  type testType struct {
    13  	ID     int
    14  	Data   string
    15  	Number int64
    16  }
    17  
    18  func TestSetGet(t *testing.T) {
    19  	s, err := newTestStore()
    20  	defer s.Close()
    21  	if err != nil {
    22  		t.Errorf("received unexpected error: %s", err)
    23  		return
    24  	}
    25  	err = s.Register(new(testType))
    26  	if err != nil {
    27  		t.Errorf("received unexpected error: %s", err)
    28  		return
    29  	}
    30  	tests := []struct {
    31  		testType
    32  		redo bool
    33  	}{
    34  		{testType{0, "HELLO", 12}, true},
    35  		{testType{0, "WORLD", 14}, false},
    36  		{testType{2, "Barry", 11}, true},
    37  	}
    38  	for n := range tests {
    39  		err = s.Set(&tests[n].testType)
    40  		test := tests[n]
    41  		if err != nil {
    42  			t.Errorf("test 1 %d: received unexpected error: %s", n+1, err)
    43  			break
    44  		}
    45  		toRet := new(testType)
    46  		toRet.ID = test.ID
    47  		err = s.Get(toRet)
    48  		if err != nil {
    49  			t.Errorf("test 1 %d: received unexpected error: %s", n+1, err)
    50  		} else if toRet.ID != test.ID || toRet.Data != test.Data || toRet.Number != test.Number {
    51  			t.Errorf("test 1 %d: returned data does not match expected\nexpecting: %v\ngot: %v", n+1, test.testType, toRet)
    52  		}
    53  	}
    54  	for n, test := range tests {
    55  		if !test.redo {
    56  			continue
    57  		}
    58  		toRet := new(testType)
    59  		toRet.ID = test.ID
    60  		err = s.Get(toRet)
    61  		if err != nil {
    62  			t.Errorf("test 2 %d: received unexpected error: %s", n+1, err)
    63  		} else if toRet.ID != test.ID || toRet.Data != test.Data || toRet.Number != test.Number {
    64  			t.Errorf("test 2 %d: returned data does not match expected\nexpecting: %v\ngot: %v", n+1, test.testType, toRet)
    65  		}
    66  	}
    67  }
    68  
    69  type embeddedTestType struct {
    70  	ID          int
    71  	Data        string
    72  	AnotherType testType
    73  }
    74  
    75  func TestSetGetAdvanced(t *testing.T) {
    76  	s, err := newTestStore()
    77  	defer s.Close()
    78  	if err != nil {
    79  		t.Error(err)
    80  		return
    81  	}
    82  	err = s.Register(new(embeddedTestType))
    83  	if err != nil {
    84  		t.Error(err)
    85  		return
    86  	}
    87  
    88  	tests := []embeddedTestType{
    89  		{0, "Beep", testType{0, "Boop", 1}},
    90  		{0, "Hello", testType{1, "Boop", 1}},
    91  		{0, "123", testType{0, "456", 123}},
    92  	}
    93  
    94  	for n, test := range tests {
    95  		err := s.Set(&test)
    96  		if err != nil {
    97  			t.Errorf("test %d: unexpected error - %s", n+1, err)
    98  			continue
    99  		}
   100  		ett := embeddedTestType{ID: test.ID}
   101  		err = s.Get(&ett)
   102  		if err != nil {
   103  			t.Errorf("test %d: unexpected error - %s", n+1, err)
   104  			continue
   105  		}
   106  		if !reflect.DeepEqual(&ett, &test) {
   107  			t.Errorf("test %d: expecting %v, got %v", n+1, test, ett)
   108  		}
   109  	}
   110  }
   111  
   112  func TestRemove(t *testing.T) {
   113  	s, err := newTestStore()
   114  	defer s.Close()
   115  	if err != nil {
   116  		t.Errorf("received unexpected error: %s", err)
   117  		return
   118  	}
   119  	err = s.Register(new(testType))
   120  	if err != nil {
   121  		t.Errorf("received unexpected error: %s", err)
   122  		return
   123  	}
   124  	tests := []testType{
   125  		{0, "HELLO", 12},
   126  		{0, "WORLD", 14},
   127  		{0, "Barry", 11},
   128  	}
   129  	for n, test := range tests {
   130  		err = s.Set(&test)
   131  		if err != nil {
   132  			t.Errorf("test %d-1: received unexpected error: %s", n+1, err)
   133  		}
   134  		tt := testType{ID: test.ID}
   135  		err = s.Get(&tt)
   136  		if err != nil {
   137  			t.Errorf("test %d-2: received unexpected error: %s", n+1, err)
   138  		} else if tt.ID != test.ID || tt.Data != test.Data || tt.Number != test.Number {
   139  			t.Errorf("test %d-2: returned data does not match expected\nexpecting: %v\ngot: %v", n+1, test, tt)
   140  		}
   141  		err = s.Remove(&tt)
   142  		if err != nil {
   143  			t.Errorf("test %d-3: received unexpected error: %s", n+1, err)
   144  		}
   145  		tt = testType{ID: test.ID}
   146  		err = s.Get(&tt)
   147  		if err != nil {
   148  			t.Errorf("test %d-4: received unexpected error: %s", n+1, err)
   149  		} else if tt.ID != 0 {
   150  			t.Errorf("test %d-4: expecting id 0, got %d", n+1, tt.ID)
   151  		}
   152  	}
   153  }
   154  
   155  func TestGetPage(t *testing.T) {
   156  	s, err := newTestStore()
   157  	defer s.Close()
   158  	if err != nil {
   159  		t.Errorf("received unexpected error: %s", err)
   160  		return
   161  	}
   162  	err = s.Register(new(testType))
   163  	if err != nil {
   164  		t.Errorf("received unexpected error: %s", err)
   165  		return
   166  	}
   167  	s.Set(
   168  		&testType{0, "BEEP", 1},
   169  		&testType{0, "3.14159", 42},
   170  		&testType{0, "hats", 420},
   171  		&testType{0, "string", 25},
   172  	)
   173  	tests := []struct {
   174  		toGet, offset int
   175  		result        []testType
   176  	}{
   177  		{1, 0,
   178  			[]testType{
   179  				{1, "BEEP", 1},
   180  			},
   181  		},
   182  		{1, 1,
   183  			[]testType{
   184  				{2, "3.14159", 42},
   185  			},
   186  		},
   187  		{2, 2,
   188  			[]testType{
   189  				{3, "hats", 420},
   190  				{4, "string", 25},
   191  			},
   192  		},
   193  		{2, 3,
   194  			[]testType{
   195  				{4, "string", 25},
   196  			},
   197  		},
   198  	}
   199  	for n, test := range tests {
   200  		data := make([]testType, test.toGet)
   201  		idata := make([]interface{}, test.toGet)
   202  		for i := 0; i < test.toGet; i++ {
   203  			idata[i] = &data[i]
   204  		}
   205  		num, err := s.GetPage(idata, test.offset)
   206  		if err != nil {
   207  			t.Errorf("test %d: received unexpected error: %s", n+1, err)
   208  		} else if num != len(test.result) {
   209  			t.Errorf("test %d: received %d results, expecting %d", n+1, num, len(test.result))
   210  		} else {
   211  			for m, d := range test.result {
   212  				if d.ID != data[m].ID || d.Data != data[m].Data || d.Number != data[m].Number {
   213  					t.Errorf("test %d %d: returned data does not match expected\nexpecting: %v\ngot: %v", n+1, m, d, data[m])
   214  				}
   215  			}
   216  		}
   217  	}
   218  }