github.com/cellofellow/gopkg@v0.0.0-20140722061823-eec0544a62ad/database/unqlite/unqlite_test.go (about)

     1  // Copyright 2014 <chaishushan{AT}gmail.com>. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package unqlite
     6  
     7  import (
     8  	"bytes"
     9  	"testing"
    10  )
    11  
    12  func TestErrnoError(t *testing.T) {
    13  	for k, v := range errText {
    14  		if s := k.Error(); s != v {
    15  			t.Errorf("Errno(%d).Error() = %s, expected %s", k, s, v)
    16  		}
    17  	}
    18  }
    19  
    20  func TestOpenCloseInMemoryDatabase(t *testing.T) {
    21  	db, err := Open(":mem:")
    22  	if err != nil {
    23  		t.Fatalf("Open(\":mem:\") error: %s", err)
    24  	}
    25  	err = db.Close()
    26  	if err != nil {
    27  		t.Fatalf("db.Close() error: %s", err)
    28  	}
    29  }
    30  
    31  type keyValuePair struct {
    32  	key   []byte
    33  	value []byte
    34  }
    35  
    36  var keyValuePairs = []keyValuePair{
    37  	{[]byte("key"), []byte("value")},
    38  	{[]byte("hello"), []byte("世界")},
    39  	{[]byte("hello"), []byte("world")},
    40  	{[]byte("gordon"), []byte("gopher")},
    41  	{[]byte{'f', 'o', 'o'}, []byte{'b', 'a', 'r'}},
    42  	{[]byte{'\000'}, []byte{42}},
    43  }
    44  
    45  func TestStore(t *testing.T) {
    46  	db, err := Open(":mem:")
    47  	if err != nil {
    48  		t.Fatalf("Open(\":mem:\") error: %s", err)
    49  	}
    50  	defer db.Close()
    51  
    52  	for _, p := range keyValuePairs {
    53  		if err := db.Store(p.key, p.value); err != nil {
    54  			t.Fatalf("db.Store(%v, %v) error: %v", p.key, p.value, err)
    55  		}
    56  		b, err := db.Fetch(p.key)
    57  		if err != nil {
    58  			t.Fatalf("db.Fetch(%v) error: %v", p.key, err)
    59  		}
    60  		if !bytes.Equal(b, p.value) {
    61  			t.Errorf("db.Fetch(%v) = %v, expected %v", p.key, b, p.value)
    62  		}
    63  	}
    64  }
    65  
    66  func TestAppend(t *testing.T) {
    67  	db, err := Open(":mem:")
    68  	if err != nil {
    69  		t.Fatalf("Open(\":mem:\") error: %s", err)
    70  	}
    71  	defer db.Close()
    72  	p := keyValuePairs[0]
    73  	if err := db.Store(p.key, p.value); err != nil {
    74  		t.Fatalf("db.Store(%v, %v) error: %v", p.key, p.value, err)
    75  	}
    76  	b, err := db.Fetch(p.key)
    77  	if err != nil {
    78  		t.Fatalf("db.Fetch(%v) error: %v", p.key, err)
    79  	}
    80  	if !bytes.Equal(b, p.value) {
    81  		t.Errorf("db.Fetch(%v) = %v, expected %v", p.key, b, p.value)
    82  	}
    83  	if err := db.Append(p.key, p.value); err != nil {
    84  		t.Fatalf("db.Append(%v, %v) error: %v", p.key, p.value, err)
    85  	}
    86  	bb, err := db.Fetch(p.key)
    87  	if err != nil {
    88  		t.Fatalf("db.Fetch(%v) error: %v", p.key, err)
    89  	}
    90  	if !bytes.Equal(bb, append(b, b...)) {
    91  		t.Errorf("db.Fetch(%v) = %v, expected %v", p.key, bb, append(b, b...))
    92  	}
    93  }
    94  
    95  func TestDelete(t *testing.T) {
    96  	db, err := Open(":mem:")
    97  	if err != nil {
    98  		t.Fatalf("Open(\":mem:\") error: %s", err)
    99  	}
   100  	defer db.Close()
   101  
   102  	for _, p := range keyValuePairs {
   103  		// Test delete non-existing records.
   104  		if err := db.Delete(p.key); err != ErrNotFound {
   105  			t.Fatalf("db.Delete(%v) = %v, expected %v", p.key, err, ErrNotFound)
   106  		}
   107  		// Store records.
   108  		if err := db.Store(p.key, p.value); err != nil {
   109  			t.Fatalf("db.Store(%v, %v) error: %v", p.key, p.value, err)
   110  		}
   111  		// Fetch and compare records to make sure that they were stored.
   112  		b, err := db.Fetch(p.key)
   113  		if err != nil {
   114  			t.Fatalf("db.Fetch(%v) error: %v", p.key, err)
   115  		}
   116  		if !bytes.Equal(b, p.value) {
   117  			t.Errorf("db.Fetch(%v) = %v, expected %v", p.key, b, p.value)
   118  		}
   119  		// Test delete records.
   120  		if err := db.Delete(p.key); err != nil {
   121  			t.Fatalf("db.Delete(%v) = %v, expected %v", p.key, err, nil)
   122  		}
   123  	}
   124  }
   125  
   126  func TestCommit(t *testing.T) {
   127  	db, err := Open(":mem:")
   128  	if err != nil {
   129  		t.Fatalf("Open(\":mem:\") error: %s", err)
   130  	}
   131  	defer db.Close()
   132  
   133  	for _, p := range keyValuePairs {
   134  		if err := db.Store(p.key, p.value); err != nil {
   135  			t.Fatalf("db.Store(%v, %v) error: %v", p.key, p.value, err)
   136  		}
   137  		if err := db.Commit(); err != nil {
   138  			t.Fatalf("db.Commit() error: %v", err)
   139  		}
   140  	}
   141  }