github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/libraries/pingcap/tidb/structure/structure_test.go (about)

     1  // Copyright 2015 PingCAP, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // See the License for the specific language governing permissions and
    12  // limitations under the License.
    13  
    14  package structure
    15  
    16  import (
    17  	"testing"
    18  
    19  	. "github.com/insionng/yougam/libraries/pingcap/check"
    20  	"github.com/insionng/yougam/libraries/pingcap/tidb/kv"
    21  	"github.com/insionng/yougam/libraries/pingcap/tidb/store/localstore"
    22  	"github.com/insionng/yougam/libraries/pingcap/tidb/store/localstore/goleveldb"
    23  	"github.com/insionng/yougam/libraries/pingcap/tidb/util/testleak"
    24  )
    25  
    26  func TestTxStructure(t *testing.T) {
    27  	TestingT(t)
    28  }
    29  
    30  var _ = Suite(&testTxStructureSuite{})
    31  
    32  type testTxStructureSuite struct {
    33  	store kv.Storage
    34  }
    35  
    36  func (s *testTxStructureSuite) SetUpSuite(c *C) {
    37  	path := "memory:"
    38  	d := localstore.Driver{
    39  		Driver: goleveldb.MemoryDriver{},
    40  	}
    41  	store, err := d.Open(path)
    42  	c.Assert(err, IsNil)
    43  	s.store = store
    44  }
    45  
    46  func (s *testTxStructureSuite) TearDownSuite(c *C) {
    47  	err := s.store.Close()
    48  	c.Assert(err, IsNil)
    49  }
    50  
    51  func (s *testTxStructureSuite) TestString(c *C) {
    52  	defer testleak.AfterTest(c)()
    53  	txn, err := s.store.Begin()
    54  	c.Assert(err, IsNil)
    55  	defer txn.Rollback()
    56  
    57  	tx := NewStructure(txn, []byte{0x00})
    58  
    59  	key := []byte("a")
    60  	value := []byte("1")
    61  	err = tx.Set(key, value)
    62  	c.Assert(err, IsNil)
    63  
    64  	v, err := tx.Get(key)
    65  	c.Assert(err, IsNil)
    66  	c.Assert(v, DeepEquals, value)
    67  
    68  	n, err := tx.Inc(key, 1)
    69  	c.Assert(err, IsNil)
    70  	c.Assert(n, Equals, int64(2))
    71  
    72  	v, err = tx.Get(key)
    73  	c.Assert(err, IsNil)
    74  	c.Assert(v, DeepEquals, []byte("2"))
    75  
    76  	n, err = tx.GetInt64(key)
    77  	c.Assert(err, IsNil)
    78  	c.Assert(n, Equals, int64(2))
    79  
    80  	err = tx.Clear(key)
    81  	c.Assert(err, IsNil)
    82  
    83  	v, err = tx.Get(key)
    84  	c.Assert(err, IsNil)
    85  	c.Assert(v, IsNil)
    86  
    87  	err = txn.Commit()
    88  	c.Assert(err, IsNil)
    89  }
    90  
    91  func (s *testTxStructureSuite) TestList(c *C) {
    92  	defer testleak.AfterTest(c)()
    93  	txn, err := s.store.Begin()
    94  	c.Assert(err, IsNil)
    95  	defer txn.Rollback()
    96  
    97  	tx := NewStructure(txn, []byte{0x00})
    98  
    99  	key := []byte("a")
   100  	err = tx.LPush(key, []byte("3"), []byte("2"), []byte("1"))
   101  	c.Assert(err, IsNil)
   102  
   103  	l, err := tx.LLen(key)
   104  	c.Assert(err, IsNil)
   105  	c.Assert(l, Equals, int64(3))
   106  
   107  	value, err := tx.LIndex(key, 1)
   108  	c.Assert(err, IsNil)
   109  	c.Assert(value, DeepEquals, []byte("2"))
   110  
   111  	err = tx.LSet(key, 1, []byte("4"))
   112  	c.Assert(err, IsNil)
   113  
   114  	value, err = tx.LIndex(key, 1)
   115  	c.Assert(err, IsNil)
   116  	c.Assert(value, DeepEquals, []byte("4"))
   117  
   118  	err = tx.LSet(key, 1, []byte("2"))
   119  	c.Assert(err, IsNil)
   120  
   121  	value, err = tx.LIndex(key, -1)
   122  	c.Assert(err, IsNil)
   123  	c.Assert(value, DeepEquals, []byte("3"))
   124  
   125  	value, err = tx.LPop(key)
   126  	c.Assert(err, IsNil)
   127  	c.Assert(value, DeepEquals, []byte("1"))
   128  
   129  	l, err = tx.LLen(key)
   130  	c.Assert(err, IsNil)
   131  	c.Assert(l, Equals, int64(2))
   132  
   133  	err = tx.RPush(key, []byte("4"))
   134  	c.Assert(err, IsNil)
   135  
   136  	l, err = tx.LLen(key)
   137  	c.Assert(err, IsNil)
   138  	c.Assert(l, Equals, int64(3))
   139  
   140  	value, err = tx.LIndex(key, -1)
   141  	c.Assert(err, IsNil)
   142  	c.Assert(value, DeepEquals, []byte("4"))
   143  
   144  	value, err = tx.RPop(key)
   145  	c.Assert(err, IsNil)
   146  	c.Assert(value, DeepEquals, []byte("4"))
   147  
   148  	value, err = tx.RPop(key)
   149  	c.Assert(err, IsNil)
   150  	c.Assert(value, DeepEquals, []byte("3"))
   151  
   152  	value, err = tx.RPop(key)
   153  	c.Assert(err, IsNil)
   154  	c.Assert(value, DeepEquals, []byte("2"))
   155  
   156  	l, err = tx.LLen(key)
   157  	c.Assert(err, IsNil)
   158  	c.Assert(l, Equals, int64(0))
   159  
   160  	err = tx.LPush(key, []byte("1"))
   161  	c.Assert(err, IsNil)
   162  
   163  	err = tx.LClear(key)
   164  	c.Assert(err, IsNil)
   165  
   166  	l, err = tx.LLen(key)
   167  	c.Assert(err, IsNil)
   168  	c.Assert(l, Equals, int64(0))
   169  
   170  	err = txn.Commit()
   171  	c.Assert(err, IsNil)
   172  }
   173  
   174  func (s *testTxStructureSuite) TestHash(c *C) {
   175  	defer testleak.AfterTest(c)()
   176  	txn, err := s.store.Begin()
   177  	c.Assert(err, IsNil)
   178  	defer txn.Rollback()
   179  
   180  	tx := NewStructure(txn, []byte{0x00})
   181  
   182  	key := []byte("a")
   183  
   184  	err = tx.HSet(key, []byte("1"), []byte("1"))
   185  	c.Assert(err, IsNil)
   186  
   187  	err = tx.HSet(key, []byte("2"), []byte("2"))
   188  	c.Assert(err, IsNil)
   189  
   190  	l, err := tx.HLen(key)
   191  	c.Assert(err, IsNil)
   192  	c.Assert(l, Equals, int64(2))
   193  
   194  	value, err := tx.HGet(key, []byte("1"))
   195  	c.Assert(err, IsNil)
   196  	c.Assert(value, DeepEquals, []byte("1"))
   197  
   198  	value, err = tx.HGet(key, []byte("fake"))
   199  	c.Assert(err, IsNil)
   200  	c.Assert(value, IsNil)
   201  
   202  	keys, err := tx.HKeys(key)
   203  	c.Assert(err, IsNil)
   204  	c.Assert(keys, DeepEquals, [][]byte{[]byte("1"), []byte("2")})
   205  
   206  	res, err := tx.HGetAll(key)
   207  	c.Assert(err, IsNil)
   208  	c.Assert(res, DeepEquals, []HashPair{
   209  		{[]byte("1"), []byte("1")},
   210  		{[]byte("2"), []byte("2")}})
   211  
   212  	err = tx.HDel(key, []byte("1"))
   213  	c.Assert(err, IsNil)
   214  
   215  	value, err = tx.HGet(key, []byte("1"))
   216  	c.Assert(err, IsNil)
   217  	c.Assert(value, IsNil)
   218  
   219  	l, err = tx.HLen(key)
   220  	c.Assert(err, IsNil)
   221  	c.Assert(l, Equals, int64(1))
   222  
   223  	n, err := tx.HInc(key, []byte("1"), 1)
   224  	c.Assert(err, IsNil)
   225  	c.Assert(n, Equals, int64(1))
   226  
   227  	l, err = tx.HLen(key)
   228  	c.Assert(err, IsNil)
   229  	c.Assert(l, Equals, int64(2))
   230  
   231  	// Test set new value which equals to old value.
   232  	value, err = tx.HGet(key, []byte("1"))
   233  	c.Assert(err, IsNil)
   234  	c.Assert(value, DeepEquals, []byte("1"))
   235  
   236  	err = tx.HSet(key, []byte("1"), []byte("1"))
   237  	c.Assert(err, IsNil)
   238  
   239  	value, err = tx.HGet(key, []byte("1"))
   240  	c.Assert(err, IsNil)
   241  	c.Assert(value, DeepEquals, []byte("1"))
   242  
   243  	l, err = tx.HLen(key)
   244  	c.Assert(err, IsNil)
   245  	c.Assert(l, Equals, int64(2))
   246  
   247  	n, err = tx.HInc(key, []byte("1"), 1)
   248  	c.Assert(err, IsNil)
   249  	c.Assert(n, Equals, int64(2))
   250  
   251  	l, err = tx.HLen(key)
   252  	c.Assert(err, IsNil)
   253  	c.Assert(l, Equals, int64(2))
   254  
   255  	n, err = tx.HInc(key, []byte("1"), 1)
   256  	c.Assert(err, IsNil)
   257  	c.Assert(n, Equals, int64(3))
   258  
   259  	l, err = tx.HLen(key)
   260  	c.Assert(err, IsNil)
   261  	c.Assert(l, Equals, int64(2))
   262  
   263  	n, err = tx.HGetInt64(key, []byte("1"))
   264  	c.Assert(err, IsNil)
   265  	c.Assert(n, Equals, int64(3))
   266  
   267  	l, err = tx.HLen(key)
   268  	c.Assert(err, IsNil)
   269  	c.Assert(l, Equals, int64(2))
   270  
   271  	err = tx.HClear(key)
   272  	c.Assert(err, IsNil)
   273  
   274  	l, err = tx.HLen(key)
   275  	c.Assert(err, IsNil)
   276  	c.Assert(l, Equals, int64(0))
   277  
   278  	err = tx.HDel(key, []byte("fake_key"))
   279  	c.Assert(err, IsNil)
   280  
   281  	// Test set nil value.
   282  	value, err = tx.HGet(key, []byte("nil_key"))
   283  	c.Assert(err, IsNil)
   284  	c.Assert(value, IsNil)
   285  
   286  	l, err = tx.HLen(key)
   287  	c.Assert(err, IsNil)
   288  	c.Assert(l, Equals, int64(0))
   289  
   290  	err = tx.HSet(key, []byte("nil_key"), nil)
   291  	c.Assert(err, IsNil)
   292  
   293  	l, err = tx.HLen(key)
   294  	c.Assert(err, IsNil)
   295  	c.Assert(l, Equals, int64(0))
   296  
   297  	err = tx.HSet(key, []byte("nil_key"), []byte("1"))
   298  	c.Assert(err, IsNil)
   299  
   300  	l, err = tx.HLen(key)
   301  	c.Assert(err, IsNil)
   302  	c.Assert(l, Equals, int64(1))
   303  
   304  	value, err = tx.HGet(key, []byte("nil_key"))
   305  	c.Assert(err, IsNil)
   306  	c.Assert(value, DeepEquals, []byte("1"))
   307  
   308  	err = tx.HSet(key, []byte("nil_key"), nil)
   309  	c.Assert(err, NotNil)
   310  
   311  	l, err = tx.HLen(key)
   312  	c.Assert(err, IsNil)
   313  	c.Assert(l, Equals, int64(1))
   314  
   315  	value, err = tx.HGet(key, []byte("nil_key"))
   316  	c.Assert(err, IsNil)
   317  	c.Assert(value, DeepEquals, []byte("1"))
   318  
   319  	err = tx.HSet(key, []byte("nil_key"), []byte("2"))
   320  	c.Assert(err, IsNil)
   321  
   322  	l, err = tx.HLen(key)
   323  	c.Assert(err, IsNil)
   324  	c.Assert(l, Equals, int64(1))
   325  
   326  	value, err = tx.HGet(key, []byte("nil_key"))
   327  	c.Assert(err, IsNil)
   328  	c.Assert(value, DeepEquals, []byte("2"))
   329  
   330  	err = txn.Commit()
   331  	c.Assert(err, IsNil)
   332  
   333  	err = kv.RunInNewTxn(s.store, false, func(txn kv.Transaction) error {
   334  		t := NewStructure(txn, []byte{0x00})
   335  		err = t.Set(key, []byte("abc"))
   336  		c.Assert(err, IsNil)
   337  
   338  		value, err = t.Get(key)
   339  		c.Assert(err, IsNil)
   340  		c.Assert(value, DeepEquals, []byte("abc"))
   341  		return nil
   342  	})
   343  	c.Assert(err, IsNil)
   344  }