Example #1
0
func TestConnHashTestSuite(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping zk shard test in short mode.")
	}
	//launch zk
	sl := test.NewServiceLauncher()
	etcdOriPort, stopEtcd, err := sl.Start(test.Etcd)
	assert.NoError(t, err)
	s := new(ConnHashTestSuite)
	s.etcdOriPort = etcdOriPort
	s.etcdPort = 3333 // used for port forward
	s.forwarder = portForwarder(
		fmt.Sprintf(":%d", s.etcdPort), fmt.Sprintf(":%d", s.etcdOriPort))

	s.stopForward, err = s.forwarder()
	assert.NoError(t, err, "no error")

	// non-forward etcdCli
	etcdCli = etcd.NewClient([]string{fmt.Sprintf("http://localhost:%d", etcdOriPort)})
	// forwardable etcdCli
	etcdForwdCli = etcd.NewClient([]string{fmt.Sprintf("http://localhost:%d", s.etcdPort)})
	suite.Run(t, s)

	// clean up the forwarding
	s.stopForward <- struct{}{}
	etcdCli.Close()
	etcdForwdCli.Close()
	assert.NoError(s.T(), stopEtcd())
}
Example #2
0
func TestNewLister(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in short mode.")
	}
	// create etcd
	fmt.Println("starting etcd")
	srvLaunch := test.NewServiceLauncher()
	port, stop, err := srvLaunch.Start(test.Etcd)
	if err != nil {
		log.Fatalf("etcd failed, %s", err)
	}
	assert.NoError(t, err)
	etcdEnsemble := fmt.Sprintf("http://localhost:%d", port)
	etcdCli := etcd.NewClient([]string{etcdEnsemble})
	assert.NotNil(t, etcdCli)
	fmt.Println("started etcd")

	// create config client
	root := "/root"
	_, err = etcdCli.SetDir(root, 0)
	assert.NoError(t, err)
	_, err = etcdCli.Set(fmt.Sprintf(infoPrefix, root), "{}", 0)
	assert.NoError(t, err)
	tcli, err := NewClient(etcdCli, root)
	cli, ok := tcli.(*clientImpl)
	assert.True(t, ok)

	// build file tree
	_, err = etcdCli.SetDir(filepath.Join(root, "a/b"), 0)
	assert.NoError(t, err)

	// create lister
	ls, err := newLister(cli, "a")
	assert.NoError(t, err)

	// add file in dir
	_, err = etcdCli.Set(fmt.Sprintf(infoPrefix, root), `{"modfiles":[{"op":"A", "path":"a/b/f1"}]}`, 0)
	assert.NoError(t, err)
	time.Sleep(time.Second)
	_, ok = ls.tree["a/b/f1"]
	assert.True(t, ok)

	// delete file in dir
	_, err = etcdCli.Set(fmt.Sprintf(infoPrefix, root), `{"modfiles":[{"op":"D", "path":"a/b/f1"}]}`, 0)
	assert.NoError(t, err)
	time.Sleep(time.Second)
	_, ok = ls.tree["a/b/f1"]
	assert.False(t, ok)

	assert.NoError(t, cli.Stop())
	assert.NoError(t, stop())
}
Example #3
0
func (c *ConfigClientTestSuite) SetupSuite() {
	fmt.Println("starting etcd")
	c.srvLaunch = test.NewServiceLauncher()
	port, stop, err := c.srvLaunch.Start(test.Etcd)
	c.srvStop = stop
	c.srvPort = port
	if err != nil {
		log.Fatalf("etcd failed, %s", err)
	}
	assert.NoError(c.T(), err)
	etcdEnsemble := fmt.Sprintf("http://localhost:%d", port)
	c.etcdCli = etcd.NewClient([]string{etcdEnsemble})
	assert.NotNil(c.T(), c.etcdCli)
	fmt.Println("started etcd")
}
Example #4
0
// SetupSuite setups the testing environment.
func (s *ConfigTestSuite) SetupSuite() {
	var err error

	s.sl = test.NewServiceLauncher()
	port, stop, err := s.sl.Start(test.Etcd)
	s.slStopFunc = stop
	if err != nil {
		log.Fatalf("etcd failed, %s", err)
	}
	assert.NoError(s.T(), err)
	etcdEnsemble := fmt.Sprintf("http://localhost:%d", port)
	s.etcdConn = etcd.NewClient(strings.Split(etcdEnsemble, etcdDelimiter))
	assert.NotNil(s.T(), s.etcdConn)

	promptUser = func(format string, args ...interface{}) {
		fmt.Printf(format+"\n", args...)
		s.prompts++
	}
}
Example #5
0
func TestEtcdSuite(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping zk shard test in short mode.")
	}
	launcher := test.NewServiceLauncher()
	defer launcher.StopAll()

	e := &etcdSuite{}
	e.testETCD = true
	e.startFunc = func() (int, error) {
		port, _, err := launcher.Start(test.Etcd)
		return port, err
	}
	e.stopFunc = func() {}
	e.newEphemeral = func(port int) (Ephemeral, error) {
		return NewEtcdEphemeral(etcd.NewClient([]string{fmt.Sprintf("http://localhost:%d", port)}))
	}
	fmt.Println("Starting ETCD test suite")
	suite.Run(t, e)
}
Example #6
0
func TestZKSuite(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping zk shard test in short mode.")
	}
	launcher := test.NewServiceLauncher()
	z := &zkSuite{}
	z.testZK = true
	z.startFunc = func() (int, error) {
		p, _, e := launcher.Start(test.ZooKeeper)
		return p, e
	}
	z.stopFunc = func() {
		launcher.StopAll()
	}
	z.newEphemeral = func(port int) (Ephemeral, error) {
		return NewZKEphemeral([]string{fmt.Sprintf(":%d", port)}, ZKRecvTimeout(time.Second))
	}
	fmt.Println("Starting ZK test suite")
	suite.Run(t, z)
}
Example #7
0
File: main.go Project: csigo/test
func run() {
	sl := test.NewServiceLauncher()
	defer sl.StopAll()

	zkPort, _, _ := sl.Start(test.ZooKeeper)
	fmt.Println(zkPort)

	redisPort, _, _ := sl.Start(test.Redis)
	fmt.Println(redisPort)

	etcdPort, _, _ := sl.Start(test.Etcd)
	fmt.Println(etcdPort)

	hbasePort, _, _ := sl.Start(test.HBase)
	fmt.Println(hbasePort)

	s := sl.Get(hbasePort)
	err := s.(test.HbaseService).RunScript(`list`)
	fmt.Println(err)
	err = s.(test.HbaseService).RunScriptFromFile("schema.hbase")
	fmt.Println(err)
}