github.com/sereiner/library@v0.0.0-20200518095232-1fa3e640cc5f/zk/zookeeper.create_test.go (about)

     1  package zk
     2  
     3  import (
     4  	"fmt"
     5  	"reflect"
     6  	"testing"
     7  	"time"
     8  
     9  	"strings"
    10  
    11  	"github.com/sereiner/library/utility"
    12  )
    13  
    14  /*
    15     192.168.0.159:2181
    16     192.168.0.154:2181
    17     做的集群，159为主
    18  */
    19  
    20  var (
    21  	masterAddress = []string{"192.168.0.159:2181", "192.168.0.154:2181"}
    22  )
    23  
    24  // TestCreatePersistentNode 测试监控一个节点的值是否发送变化
    25  func TestCreatePersistentNode(t *testing.T) {
    26  	zk, err := New(masterAddress, time.Second)
    27  	expect(t, err, nil)
    28  	err = zk.Connect()
    29  	expect(t, err, nil)
    30  
    31  	//创建永久节点
    32  	path1 := fmt.Sprintf("/%s", utility.GetGUID())
    33  	err = zk.CreatePersistentNode(path1, "data")
    34  	expect(t, err, nil)
    35  
    36  	//检查节点是否存在
    37  	b, err := zk.Exists(path1)
    38  	expect(t, err, nil)
    39  	expect(t, b, true)
    40  	zk.Close()
    41  
    42  	//关闭连接
    43  	b, err = zk.Exists(path1)
    44  	expect(t, b, false)
    45  	expect(t, err, ErrColientCouldNotConnect)
    46  
    47  	//重新连接
    48  	err = zk.Reconnect()
    49  	expect(t, err, nil)
    50  
    51  	//节点应该存在
    52  	b, err = zk.Exists(path1)
    53  	expect(t, err, nil)
    54  	expect(t, b, true)
    55  
    56  	//删除节点
    57  	err = zk.Delete(path1)
    58  	expect(t, err, nil)
    59  }
    60  
    61  // TestBindWatchValue 测试监控一个节点的值是否发送变化
    62  func TestBindCreateTempNode(t *testing.T) {
    63  	zk, err := New(masterAddress, time.Second)
    64  	expect(t, err, nil)
    65  	err = zk.Connect()
    66  	expect(t, err, nil)
    67  
    68  	//创建临时节点
    69  	path1 := fmt.Sprintf("/T%s", utility.GetGUID())
    70  	err = zk.CreateTempNode(path1, "data")
    71  	expect(t, err, nil)
    72  
    73  	//检查节点是否存在
    74  	b, err := zk.Exists(path1)
    75  	expect(t, err, nil)
    76  	expect(t, b, true)
    77  	zk.Close()
    78  
    79  	//关闭连接
    80  	b, err = zk.Exists(path1)
    81  	expect(t, b, false)
    82  	expect(t, err, ErrColientCouldNotConnect)
    83  
    84  	//重新连接
    85  	err = zk.Reconnect()
    86  	expect(t, err, nil)
    87  
    88  	//节点应该存在
    89  	b, err = zk.Exists(path1)
    90  	expect(t, err, nil)
    91  	expect(t, b, false)
    92  }
    93  
    94  // TestBindWatchValue 测试监控一个节点的值是否发送变化
    95  func TestBindCreateSeqNode(t *testing.T) {
    96  	zk, err := New(masterAddress, time.Second)
    97  	expect(t, err, nil)
    98  	err = zk.Connect()
    99  	expect(t, err, nil)
   100  
   101  	//创建临时节点
   102  	path1 := fmt.Sprintf("/S%s_", utility.GetGUID())
   103  	rpath, err := zk.CreateSeqNode(path1, "data")
   104  	expect(t, err, nil)
   105  	expect(t, strings.HasPrefix(rpath, path1), true)
   106  	//检查节点是否存在
   107  	b, err := zk.Exists(rpath)
   108  	expect(t, err, nil)
   109  	expect(t, b, true)
   110  	zk.Close()
   111  
   112  	//关闭连接
   113  	b, err = zk.Exists(rpath)
   114  	expect(t, b, false)
   115  	expect(t, err, ErrColientCouldNotConnect)
   116  
   117  	//重新连接
   118  	err = zk.Reconnect()
   119  	expect(t, err, nil)
   120  
   121  	//节点应该存在
   122  	b, err = zk.Exists(rpath)
   123  	expect(t, err, nil)
   124  	expect(t, b, false)
   125  }
   126  
   127  // TestBindWatchValue 测试监控一个节点的值是否发送变化
   128  func TestDelete(t *testing.T) {
   129  	zk, err := New(masterAddress, time.Second)
   130  	expect(t, err, nil)
   131  	err = zk.Connect()
   132  	expect(t, err, nil)
   133  
   134  	//创建临时节点
   135  	path1 := fmt.Sprintf("/S%s_", utility.GetGUID())
   136  	rpath, err := zk.CreateSeqNode(path1, "data")
   137  	expect(t, err, nil)
   138  	expect(t, strings.HasPrefix(rpath, path1), true)
   139  	//检查节点是否存在
   140  	b, err := zk.Exists(rpath)
   141  	expect(t, err, nil)
   142  	expect(t, b, true)
   143  
   144  	//删除节点
   145  	err = zk.Delete(rpath)
   146  	expect(t, err, nil)
   147  
   148  	//检查是否存在
   149  	b, err = zk.Exists(rpath)
   150  	expect(t, err, nil)
   151  	expect(t, b, false)
   152  }
   153  func expect(t *testing.T, a interface{}, b interface{}) {
   154  	if a != b {
   155  		t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
   156  	}
   157  }