github.com/ahjdzx/deis@v1.1.1/tests/etcdutils/etcdutils.go (about)

     1  // Package etcdutils helps test interactions with etcd.
     2  
     3  package etcdutils
     4  
     5  import (
     6  	"fmt"
     7  	"strings"
     8  	"testing"
     9  
    10  	"github.com/coreos/go-etcd/etcd"
    11  	"github.com/deis/deis/tests/utils"
    12  )
    13  
    14  // EtcdHandle is used to set keys and values in a test etcd instance.
    15  type EtcdHandle struct {
    16  	Dirs []string
    17  	Keys []string
    18  	C    *etcd.Client
    19  }
    20  
    21  func etcdClient(port string) *etcd.Client {
    22  	machines := []string{"http://" + utils.HostAddress() + ":" + port}
    23  	return etcd.NewClient(machines)
    24  }
    25  
    26  // InitEtcd configures a test etcd instance.
    27  func InitEtcd(setdir, setkeys []string, port string) *EtcdHandle {
    28  	cli := etcdClient(port)
    29  	controllerHandle := new(EtcdHandle)
    30  	controllerHandle.Dirs = setdir
    31  	controllerHandle.Keys = setkeys
    32  	controllerHandle.C = cli
    33  	fmt.Println("Etcd client initialized")
    34  	return controllerHandle
    35  }
    36  
    37  // SetSingle sets a key and value into a test etcd instance.
    38  func SetSingle(t *testing.T, key string, value string, port string) {
    39  	c := etcdClient(port)
    40  	_, err := c.Set(key, value, 0)
    41  	if err != nil {
    42  		t.Fatal(err)
    43  	}
    44  }
    45  
    46  // SetEtcd sets an array of values into a test etcd instance.
    47  func SetEtcd(t *testing.T, keys []string, values []string, c *etcd.Client) {
    48  	for i, key := range keys {
    49  		_, err := c.Set(key, values[i], 0)
    50  		if err != nil {
    51  			t.Fatal(err)
    52  		}
    53  	}
    54  }
    55  
    56  // VerifyEtcdKey verifies that an etcd key exists.
    57  func VerifyEtcdKey(t *testing.T, key string, port string) {
    58  	c := etcdClient(port)
    59  	_, err := c.Get(key, true, true)
    60  	if err != nil {
    61  		t.Fatal(err)
    62  	}
    63  }
    64  
    65  // VerifyEtcdValue verifies the value of an etcd key.
    66  func VerifyEtcdValue(t *testing.T, key string, expectedValue string, port string) {
    67  	c := etcdClient(port)
    68  	result, err := c.Get(key, true, true)
    69  	if err != nil {
    70  		t.Fatal(err)
    71  	}
    72  	if result.Node.Value != expectedValue {
    73  		t.Errorf(key + ": expected '" + expectedValue + "', got '" + result.Node.Value + "'.")
    74  	}
    75  }
    76  
    77  // PublishEtcd sets canonical etcd values into a test etcd instance.
    78  func PublishEtcd(t *testing.T, ecli *EtcdHandle) {
    79  	fmt.Println("--- Publish etcd keys and values")
    80  	for _, dir := range ecli.Dirs {
    81  		_, err := ecli.C.SetDir(dir, 0)
    82  		if err != nil {
    83  			t.Fatal(err)
    84  		}
    85  	}
    86  	for _, key := range ecli.Keys {
    87  		switch true {
    88  		case (strings.Contains(key, "host")):
    89  			_, err := ecli.C.Set(key, "172.17.8.100", 0)
    90  			if err != nil {
    91  				t.Fatal(err)
    92  			}
    93  		case (strings.Contains(key, "port")):
    94  			_, err := ecli.C.Set(key, "10881", 0)
    95  			if err != nil {
    96  				t.Fatal(err)
    97  			}
    98  		default:
    99  			_, err := ecli.C.Set(key, "deis", 0)
   100  			if err != nil {
   101  				t.Fatal(err)
   102  			}
   103  		}
   104  	}
   105  }