Esempio n. 1
0
func TestMessageHTML(t *testing.T) {

	const caddyFile = `mailout {
				to              [email protected]
				bcc             [email protected]
				subject         " HTML Email via {{ .Form.Get \"firstname\" }} {{.Form.Get \"lastname\"}}"
				body            testdata/mail_tpl.html
			}`

	buf := new(bytes.Buffer)
	srv := testMessageServer(t, caddyFile, buf, 1)
	defer srv.Close()

	data := make(url.Values)
	data.Set("firstname", "Ken")
	data.Set("lastname", "Thompson")
	data.Set("email", "*****@*****.**")
	data.Set("name", "Ken S. Thompson")

	testDoPost(t, srv.URL, data)

	assert.True(t, buf.Len() > 10000) // whenever you change the template, change also here
	assert.Contains(t, buf.String(), "<h3>Thank you for contacting us, Ken Thompson</h3>")
	assert.Contains(t, buf.String(), "<h3>Sir Ken S. Thompson")
	assert.Contains(t, buf.String(), "Subject: =?UTF-8?q?=EF=A3=BF_HTML_Email_via_Ken_Thompson?=")
	assert.NotContains(t, buf.String(), "Bcc: [email protected]")
}
Esempio n. 2
0
func TestNewHydre(t *testing.T) {
	h, err := NewHydre("test/good-conf.yml")
	assert.Nil(t, err)
	assert.Equal(t, 10, h.Timeout)
	assert.Len(t, h.Daemons, 2)
	assert.Contains(t, h.Daemons, &Daemon{
		Name:        "daemon1",
		Command:     []string{"start", "daemon1"},
		StopCommand: []string{"stop", "daemon1"},
		PidFile:     "path/to/pidfile",
		LogFiles:    []string{"1.log", "2.log"},
	})
	assert.Contains(t, h.Daemons, &Daemon{
		Name:    "daemon2",
		Command: []string{"start", "daemon2"},
	})

	h, err = NewHydre("test/bad-conf.yml")
	assert.NotNil(t, err)
	assert.Nil(t, h)

	h, err = NewHydre("does-not-exist.yml")
	assert.NotNil(t, err)
	assert.Nil(t, h)
}
Esempio n. 3
0
func Test_client_buildMkdirRequest(t *testing.T) {
	c := client{
		options: ClientOptions{
			Locale: "init__locale",
			Root:   "init__root",
			Token:  "init__token",
		}}

	r, e := c.buildMkdirRequest("somepath")
	assert.NoError(t, e)
	assert.Equal(t, r.Method, "POST")

	auth := r.Header.Get("Authorization")
	assert.Contains(t, auth, "Bearer")
	assert.Contains(t, auth, "init__token")

	u := r.URL
	assert.Equal(t, u.Scheme, "https")
	assert.Equal(t, u.Host, "api.dropbox.com")
	assert.Equal(t, u.Path, "/1/fileops/create_folder")

	p := u.Query()
	assert.Equal(t, p.Get("root"), "init__root")
	assert.Equal(t, p.Get("path"), "somepath")
	assert.Equal(t, p.Get("locale"), "init__locale")
	assert.Equal(t, len(p), 3)
}
Esempio n. 4
0
func TestServerFlagsBad(t *testing.T) {
	x := runFull(t, "hyperkube test1 --bad-flag")
	assert.EqualError(t, x.err, "unknown flag: --bad-flag")
	assert.Contains(t, x.output, "A simple server named test1")
	assert.Contains(t, x.output, "-h, --help                                         help for hyperkube")
	assert.NotContains(t, x.output, "test1 Run")
}
Esempio n. 5
0
// TestSuccessCodeAndInfoForComplexMessage sends out a complex message to the pubnub channel
func TestSuccessCodeAndInfoForComplexMessage(t *testing.T) {
	assert := assert.New(t)

	stop, _ := NewVCRNonSubscribe(
		"fixtures/publish/successCodeAndInfoForComplexMessage", []string{"uuid"})
	defer stop()

	pubnubInstance := messaging.NewPubnub(PubKey, SubKey, "", "", false, "")
	channel := "successCodeAndInfoForComplexMessage"

	customStruct := CustomStruct{
		Foo: "hi!",
		Bar: []int{1, 2, 3, 4, 5},
	}

	successChannel := make(chan []byte)
	errorChannel := make(chan []byte)

	go pubnubInstance.Publish(channel, customStruct, successChannel, errorChannel)
	select {
	case msg := <-successChannel:
		assert.Contains(string(msg), "1,")
		assert.Contains(string(msg), "\"Sent\",")
	case err := <-errorChannel:
		assert.Fail(string(err))
	case <-timeout():
		assert.Fail("Publish timeout")
	}
}
Esempio n. 6
0
// If there is one key, asking to remove it will ask for confirmation.  Passing
// anything other than 'yes'/'y'/'' response will abort the deletion and
// not delete the key.
func TestRemoveOneKeyAbort(t *testing.T) {
	nos := []string{"no", "NO", "AAAARGH", "   N    "}
	store := trustmanager.NewKeyMemoryStore(ret)

	key, err := trustmanager.GenerateED25519Key(rand.Reader)
	assert.NoError(t, err)
	err = store.AddKey(key.ID(), "root", key)
	assert.NoError(t, err)

	stores := []trustmanager.KeyStore{store}

	for _, noAnswer := range nos {
		var out bytes.Buffer
		in := bytes.NewBuffer([]byte(noAnswer + "\n"))

		err := removeKeyInteractively(stores, key.ID(), in, &out)
		assert.NoError(t, err)
		text, err := ioutil.ReadAll(&out)
		assert.NoError(t, err)

		output := string(text)
		assert.Contains(t, output, "Are you sure")
		assert.Contains(t, output, "Aborting action")
		assert.Len(t, store.ListKeys(), 1)
	}
}
Esempio n. 7
0
func TestTopFlags(t *testing.T) {
	x := runFull(t, "hyperkube --help test1")
	assert.NoError(t, x.err)
	assert.Contains(t, x.output, "all-in-one")
	assert.Contains(t, x.output, "A simple server named test1")
	assert.NotContains(t, x.output, "test1 Run")
}
Esempio n. 8
0
func TestLoggerWritesEntriesOfAppropriateLevel(t *testing.T) {
	logDir := os.TempDir()
	logFile := logger.FILE_NAME
	log, err := logger.NewLogger("info", logDir, logFile)

	assert.NoError(t, err, "Expected new logger not to fail")

	filename := path.Join(logDir, logFile)

	log.InfoF("TestLog: %s", "InfoLog")
	log.ErrorF("TestLog: %s", "ErrorLog")

	fileContents, err := readFileContents(filename)
	assert.NoError(t, err, "Expected to read created file")

	scanner := bufio.NewScanner(bytes.NewBuffer([]byte(fileContents)))
	if scanner.Scan() {
		line := scanner.Text()
		println("text:", line[:4])
		assert.Equal(t, line[:4], "INFO")
	}
	if scanner.Scan() {
		assert.Equal(t, scanner.Text()[:4], "ERRO")
	}
	assert.Contains(t, fileContents, "TestLog: InfoLog", "Expected file to contain log entry")
	assert.Contains(t, fileContents, "TestLog: ErrorLog", "Expected file to contain log entry")
}
Esempio n. 9
0
func TestFindPlaceAllBas(t *testing.T) {
	pod1 := BuildTestPod("p1", 300, 500000)
	new1 := BuildTestPod("p2", 600, 500000)
	new2 := BuildTestPod("p3", 500, 500000)
	new3 := BuildTestPod("p4", 700, 500000)

	nodeInfos := map[string]*schedulercache.NodeInfo{
		"n1":   schedulercache.NewNodeInfo(pod1),
		"n2":   schedulercache.NewNodeInfo(),
		"nbad": schedulercache.NewNodeInfo(),
	}
	nodebad := BuildTestNode("nbad", 1000, 2000000)
	node1 := BuildTestNode("n1", 1000, 2000000)
	node2 := BuildTestNode("n2", 1000, 2000000)
	nodeInfos["n1"].SetNode(node1)
	nodeInfos["n2"].SetNode(node2)
	nodeInfos["nbad"].SetNode(nodebad)

	oldHints := make(map[string]string)
	newHints := make(map[string]string)
	tracker := NewUsageTracker()

	err := findPlaceFor(
		"nbad",
		[]*kube_api.Pod{new1, new2, new3},
		[]*kube_api.Node{nodebad, node1, node2},
		nodeInfos, NewTestPredicateChecker(),
		oldHints, newHints, tracker, time.Now())

	assert.Error(t, err)
	assert.True(t, len(newHints) == 2)
	assert.Contains(t, newHints, new1.Namespace+"/"+new1.Name)
	assert.Contains(t, newHints, new2.Namespace+"/"+new2.Name)
}
Esempio n. 10
0
func TestGroupSubscriptionToNotExistingChannelGroup(t *testing.T) {
	assert := assert.New(t)

	stop, sleep := NewVCRBoth(
		"fixtures/groups/notExistingCG", []string{"uuid"})
	defer stop()

	group := "Group_NotExistingCG"
	uuid := "UUID_NotExistingCG"
	pubnub := messaging.NewPubnub(PubKey, SubKey, "", "", false, uuid)

	successChannel := make(chan []byte)
	errorChannel := make(chan []byte)
	unsubscribeSuccessChannel := make(chan []byte)
	unsubscribeErrorChannel := make(chan []byte)

	removeChannelGroups(pubnub, []string{group})

	sleep(2)

	go pubnub.ChannelGroupSubscribe(group, successChannel, errorChannel)
	select {
	case response := <-successChannel:
		assert.Fail("Received success message while expecting error", string(response))
	case err := <-errorChannel:
		assert.Contains(string(err), "Channel group or groups result in empty subscription set")
		assert.Contains(string(err), group)
	}

	go pubnub.ChannelGroupUnsubscribe(group, unsubscribeSuccessChannel, unsubscribeErrorChannel)
	ExpectUnsubscribedEvent(t, "", group, unsubscribeSuccessChannel,
		unsubscribeErrorChannel)
}
Esempio n. 11
0
func TestUpdateServiceBroker(t *testing.T) {
	reqFactory := &testreq.FakeReqFactory{LoginSuccess: true}
	repo := &testapi.FakeServiceBrokerRepo{
		FindByNameServiceBroker: cf.ServiceBroker{Name: "my-found-broker", Guid: "my-found-broker-guid"},
	}
	args := []string{"my-broker", "new-username", "new-password", "new-url"}

	ui := callUpdateServiceBroker(t, args, reqFactory, repo)

	assert.Equal(t, repo.FindByNameName, "my-broker")

	assert.Contains(t, ui.Outputs[0], "Updating service broker")
	assert.Contains(t, ui.Outputs[0], "my-found-broker")
	assert.Contains(t, ui.Outputs[0], "my-user")

	expectedServiceBroker := cf.ServiceBroker{
		Name:     "my-found-broker",
		Username: "******",
		Password: "******",
		Url:      "new-url",
		Guid:     "my-found-broker-guid",
	}

	assert.Equal(t, repo.UpdatedServiceBroker, expectedServiceBroker)

	assert.Contains(t, ui.Outputs[1], "OK")
}
Esempio n. 12
0
func TestGroupSubscriptionNotSubscribed(t *testing.T) {
	assert := assert.New(t)

	stop, sleep := NewVCRNonSubscribe(
		"fixtures/groups/notSubscribed", []string{"uuid"})
	defer stop()

	group := "Group_NotSubscribed"
	uuid := "UUID_NotSubscribed"
	pubnub := messaging.NewPubnub(PubKey, SubKey, "", "", false, uuid)

	createChannelGroups(pubnub, []string{group})
	defer removeChannelGroups(pubnub, []string{group})

	sleep(2)

	successChannel := make(chan []byte)
	errorChannel := make(chan []byte)

	go pubnub.ChannelGroupUnsubscribe(group, successChannel, errorChannel)
	select {
	case response := <-successChannel:
		assert.Fail("Received success message while expecting error", string(response))
	case err := <-errorChannel:
		assert.Contains(string(err), "Subscription to channel group")
		assert.Contains(string(err), "not subscribed")
	}

	pubnub.CloseExistingConnection()
}
Esempio n. 13
0
func TestMessagePlainTextAllFormFields(t *testing.T) {

	const caddyFile = `mailout {
				to              [email protected]
				cc              "[email protected], [email protected]"
				subject         "Email from {{ .Form.Get \"firstname\" }} {{.Form.Get \"lastname\"}}"
				body            testdata/mail_plainTextMessage.txt
			}`

	buf := new(bytes.Buffer)
	srv := testMessageServer(t, caddyFile, buf, 1)
	defer srv.Close()

	data := make(url.Values)
	data.Set("firstname", "Ken")
	data.Set("lastname", "Thompson")
	data.Set("email", "*****@*****.**")
	data.Set("name", "Ken Thompson")

	testDoPost(t, srv.URL, data)

	assert.Len(t, buf.String(), 424) // whenever you change the template, change also here
	assert.Contains(t, buf.String(), "Email [email protected]")
	assert.Contains(t, buf.String(), `From: "Ken Thompson" <*****@*****.**>`)
	assert.Contains(t, buf.String(), "Subject: Email from Ken Thompson")
	assert.Contains(t, buf.String(), "Cc: [email protected], [email protected]")
	//t.Log(buf.String())
}
Esempio n. 14
0
func TestMessagePlainPGPSingleKey(t *testing.T) {

	const caddyFile = `mailout {
				to              [email protected]
				cc              "*****@*****.**"
				subject         "Encrypted contact 🔑"
				body            testdata/mail_plainTextMessage.txt
				[email protected] 		testdata/B06469EE_nopw.pub.asc
			}`

	buf := new(bytes.Buffer)
	srv := testMessageServer(t, caddyFile, buf, 2)
	defer srv.Close()

	data := make(url.Values)
	data.Set("firstname", "Ken")
	data.Set("lastname", "Thompson")
	data.Set("email", "*****@*****.**")
	data.Set("name", "Ken Thompson")

	testDoPost(t, srv.URL, data)

	assert.Len(t, buf.String(), 2710) // whenever you change the template, change also here
	assert.Contains(t, buf.String(), "Subject: =?UTF-8?q?Encrypted_contact_=F0=9F=94=91?=")
	assert.Contains(t, buf.String(), "Cc: [email protected]")
	assert.Exactly(t, 1, bytes.Count(buf.Bytes(), maillog.MultiMessageSeparator))
	assert.Contains(t, buf.String(), `This shows the content of a text template.`)
	//t.Log(buf.String())
}
Esempio n. 15
0
func TestApps(t *testing.T) {
	app1Urls := []string{"app1.cfapps.io", "app1.example.com"}
	app2Urls := []string{"app2.cfapps.io"}

	apps := []cf.Application{
		cf.Application{Name: "Application-1", State: "started", Instances: 1, Memory: 512, Urls: app1Urls},
		cf.Application{Name: "Application-2", State: "started", Instances: 2, Memory: 256, Urls: app2Urls},
	}
	spaceRepo := &testhelpers.FakeSpaceRepository{
		CurrentSpace: cf.Space{Name: "development", Guid: "development-guid"},
		SummarySpace: cf.Space{Applications: apps},
	}

	reqFactory := &testhelpers.FakeReqFactory{LoginSuccess: true, TargetedSpaceSuccess: true}

	ui := callApps(spaceRepo, reqFactory)

	assert.True(t, testhelpers.CommandDidPassRequirements)

	assert.Contains(t, ui.Outputs[0], "Getting applications in development")
	assert.Contains(t, ui.Outputs[1], "OK")
	assert.Contains(t, ui.Outputs[3], "Application-1")
	assert.Contains(t, ui.Outputs[3], "running")
	assert.Contains(t, ui.Outputs[3], "1 x 512M")
	assert.Contains(t, ui.Outputs[3], "app1.cfapps.io, app1.example.com")

	assert.Contains(t, ui.Outputs[4], "Application-2")
	assert.Contains(t, ui.Outputs[4], "running")
	assert.Contains(t, ui.Outputs[4], "2 x 256M")
	assert.Contains(t, ui.Outputs[4], "app2.cfapps.io")
}
Esempio n. 16
0
func TestSubVolumeCreateValidation(t *testing.T) {
	subvol := btrfs.NewIoctl().Subvolume()
	cmd := subvol.Create()
	err := cmd.Execute()
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "destination is empty")

	cmd = subvol.Create()
	err = cmd.Destination(strings.Repeat("s", 512)).Execute()
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "subvolume name too long")
	assert.Contains(t, err.Error(), "max length is 255")

	// cmd = subvol.Create()
	// err = cmd.Name("/name").Execute()
	// assert.Error(t, err)
	// assert.Contains(t, err.Error(), "incorrect subvolume name '/name'")

	cmd = subvol.Create()
	err = cmd.Destination(".").Execute()
	assert.Contains(t, err.Error(), "incorrect subvolume name '.'")

	cmd = subvol.Create()
	err = cmd.Destination("..").Execute()
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "incorrect subvolume name '..'")
}
Esempio n. 17
0
// If there is more than one key, removeKeyInteractively will ask which key to
// delete.  Then it will confirm whether they want to delete, and the user can
// abort at that confirmation.
func TestRemoveMultikeysAbortChoice(t *testing.T) {
	in := bytes.NewBuffer([]byte("1\nn\n"))

	key, err := trustmanager.GenerateED25519Key(rand.Reader)
	assert.NoError(t, err)

	stores := []trustmanager.KeyStore{
		trustmanager.NewKeyMemoryStore(ret),
		trustmanager.NewKeyMemoryStore(ret),
	}

	err = stores[0].AddKey(key.ID(), "root", key)
	assert.NoError(t, err)

	err = stores[1].AddKey("gun/"+key.ID(), "target", key)
	assert.NoError(t, err)

	var out bytes.Buffer

	err = removeKeyInteractively(stores, key.ID(), in, &out)
	assert.NoError(t, err) // no error to abort deleting
	text, err := ioutil.ReadAll(&out)
	assert.NoError(t, err)

	assert.Len(t, stores[0].ListKeys(), 1)
	assert.Len(t, stores[1].ListKeys(), 1)

	// It should have listed the keys, asked whether the user really wanted to
	// delete, and then aborted.
	output := string(text)
	assert.Contains(t, output, "Found the following matching keys")
	assert.Contains(t, output, "Are you sure")
	assert.Contains(t, output, "Aborting action")
}
Esempio n. 18
0
func TestDecompressFileToDir(t *testing.T) {
	fs, cmdRunner := getCompressorDependencies()
	dc := NewTarballCompressor(cmdRunner, fs)

	dstDir := createdTmpDir(t, fs)
	defer os.RemoveAll(dstDir)

	err := dc.DecompressFileToDir(fixtureSrcTgz(t), dstDir)
	assert.NoError(t, err)

	// regular files
	content, err := fs.ReadFile(dstDir + "/not-nested-file")
	assert.NoError(t, err)
	assert.Contains(t, content, "not-nested-file")

	// nested directory with a file
	content, err = fs.ReadFile(dstDir + "/dir/nested-file")
	assert.NoError(t, err)
	assert.Contains(t, content, "nested-file")

	// nested directory with a file inside another directory
	content, err = fs.ReadFile(dstDir + "/dir/nested-dir/double-nested-file")
	assert.NoError(t, err)
	assert.Contains(t, content, "double-nested-file")

	// directory without a file (empty)
	content, err = fs.ReadFile(dstDir + "/empty-dir")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "is a directory")

	// nested directory without a file (empty) inside another directory
	content, err = fs.ReadFile(dstDir + "/dir/empty-nested-dir")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "is a directory")
}
Esempio n. 19
0
// If there is one key, asking to remove it will ask for confirmation.  Passing
// 'yes'/'y'/'' response will continue the deletion.
func TestRemoveOneKeyConfirm(t *testing.T) {
	yesses := []string{"yes", " Y ", "yE", "   ", ""}

	for _, yesAnswer := range yesses {
		store := trustmanager.NewKeyMemoryStore(ret)

		key, err := trustmanager.GenerateED25519Key(rand.Reader)
		assert.NoError(t, err)
		err = store.AddKey(key.ID(), "root", key)
		assert.NoError(t, err)

		var out bytes.Buffer
		in := bytes.NewBuffer([]byte(yesAnswer + "\n"))

		err = removeKeyInteractively(
			[]trustmanager.KeyStore{store}, key.ID(), in, &out)
		assert.NoError(t, err)
		text, err := ioutil.ReadAll(&out)
		assert.NoError(t, err)

		output := string(text)
		assert.Contains(t, output, "Are you sure")
		assert.Contains(t, output, "Deleted "+key.ID())
		assert.Len(t, store.ListKeys(), 0)
	}
}
Esempio n. 20
0
func TestThatItSendsAllMessageToKnownDrains(t *testing.T) {
	client1ReceivedChan := make(chan []byte)

	fakeSyslogDrain, err := NewFakeService(client1ReceivedChan, "127.0.0.1:34566")
	defer fakeSyslogDrain.Stop()
	assert.NoError(t, err)
	go fakeSyslogDrain.Serve()
	<-fakeSyslogDrain.ReadyChan

	expectedMessageString := "Some Data"
	logEnvelope1 := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedMessageString, "myApp", SECRET, "syslog://localhost:34566")

	expectedSecondMessageString := "Some Data Without a drainurl"
	logEnvelope2 := messagetesthelpers.MarshalledLogEnvelopeForMessage(t, expectedSecondMessageString, "myApp", SECRET, "syslog://localhost:34566")

	dataReadChannel <- logEnvelope1

	select {
	case <-time.After(200 * time.Millisecond):
		t.Errorf("Did not get the first message")
	case message := <-client1ReceivedChan:
		assert.Contains(t, string(message), expectedMessageString)
	}

	dataReadChannel <- logEnvelope2

	select {
	case <-time.After(200 * time.Millisecond):
		t.Errorf("Did not get the second message")
	case message := <-client1ReceivedChan:
		assert.Contains(t, string(message), expectedSecondMessageString)
	}
}
Esempio n. 21
0
func TestServerHelp(t *testing.T) {
	x := runFull(t, "hyperkube test1 --help")
	assert.NoError(t, x.err)
	assert.Contains(t, x.output, "A simple server named test1")
	assert.Contains(t, x.output, "-h, --help                                         help for hyperkube")
	assert.NotContains(t, x.output, "test1 Run")
}
Esempio n. 22
0
func TestDebugInfo(t *testing.T) {
	fakeSink := NewFakeOpenTSDBSink(true, true)
	debugInfo := fakeSink.DebugInfo()
	assert.Contains(t, debugInfo, "Sink Type: OpenTSDB")
	assert.Contains(t, debugInfo, "client: Host "+fakeOpenTSDBHost)
	assert.Contains(t, debugInfo, "Number of write failures:")
}
Esempio n. 23
0
func TestGitHubGetBeginAuthURL(t *testing.T) {

	common.SetSecurityKey("ABC123")

	state := &common.State{Map: objx.MSI("after", "http://www.stretchr.com/")}

	g := New("clientID", "secret", "http://myapp.com/")

	url, err := g.GetBeginAuthURL(state, nil)

	if assert.NoError(t, err) {
		assert.Contains(t, url, "client_id=clientID")
		assert.Contains(t, url, "redirect_uri=http%3A%2F%2Fmyapp.com%2F")
		assert.Contains(t, url, "scope="+githubDefaultScope)
		assert.Contains(t, url, "access_type="+oauth2.OAuth2AccessTypeOnline)
		assert.Contains(t, url, "approval_prompt="+oauth2.OAuth2ApprovalPromptAuto)
	}

	state = &common.State{Map: objx.MSI("after", "http://www.stretchr.com/")}

	g = New("clientID", "secret", "http://myapp.com/")

	url, err = g.GetBeginAuthURL(state, objx.MSI(oauth2.OAuth2KeyScope, "avatar"))

	if assert.NoError(t, err) {
		assert.Contains(t, url, "client_id=clientID")
		assert.Contains(t, url, "redirect_uri=http%3A%2F%2Fmyapp.com%2F")
		assert.Contains(t, url, "scope=avatar+"+githubDefaultScope)
		assert.Contains(t, url, "access_type="+oauth2.OAuth2AccessTypeOnline)
		assert.Contains(t, url, "approval_prompt="+oauth2.OAuth2ApprovalPromptAuto)
	}

}
func Test_datastore_buildGetSnapshotRequest(t *testing.T) {
	ds := datastore{
		info: DatastoreInfo{
			Handle: "UcBxkoM8nLbUY3AHrkcKsKCeg9LbVl"},
		client: client{
			options: ClientOptions{
				Token: "init__token"}}}

	r, e := ds.buildGetSnapshotRequest()
	assert.NoError(t, e)
	assert.Equal(t, r.Method, "GET")

	auth := r.Header.Get("Authorization")
	assert.Contains(t, auth, "Bearer")
	assert.Contains(t, auth, "init__token")

	u := r.URL
	assert.Equal(t, u.Scheme, "https")
	assert.Equal(t, u.Host, "api.dropbox.com")
	assert.Equal(t, u.Path, "/r5/datastores/get_snapshot")

	p := u.Query()
	assert.Equal(t, p.Get("handle"), "UcBxkoM8nLbUY3AHrkcKsKCeg9LbVl")
	assert.Equal(t, len(p), 1)
}
Esempio n. 25
0
// TestSuccessCodeAndInfoWithEncryption sends out an encrypted
// message to the pubnub channel
func TestSuccessCodeAndInfoWithEncryption(t *testing.T) {
	assert := assert.New(t)

	stop, _ := NewVCRNonSubscribe(
		"fixtures/publish/successCodeAndInfoWithEncryption", []string{"uuid"})
	defer stop()

	pubnubInstance := messaging.NewPubnub(PubKey, SubKey, "", "enigma", false, "")
	channel := "successCodeAndInfo"
	message := "Pubnub API Usage Example"

	successChannel := make(chan []byte)
	errorChannel := make(chan []byte)

	go pubnubInstance.Publish(channel, message, successChannel, errorChannel)
	select {
	case msg := <-successChannel:
		assert.Contains(string(msg), "1,")
		assert.Contains(string(msg), "\"Sent\",")
	case err := <-errorChannel:
		assert.Fail(string(err))
	case <-timeout():
		assert.Fail("Publish timeout")
	}
}
Esempio n. 26
0
func TestLoggingInWithoutOrg(t *testing.T) {
	configRepo := testhelpers.FakeConfigRepository{}
	configRepo.Delete()
	config, _ := configRepo.Get()

	ui := new(testhelpers.FakeUI)
	ui.Inputs = []string{"*****@*****.**", "bar"}
	orgs := []cf.Organization{}
	spaces := []cf.Space{}

	callLogin(
		[]string{},
		ui,
		configRepo,
		&testhelpers.FakeOrgRepository{Organizations: orgs},
		&testhelpers.FakeSpaceRepository{Spaces: spaces},
		&testhelpers.FakeAuthenticator{ConfigRepo: configRepo},
	)

	assert.Contains(t, ui.Outputs[0], config.Target)

	assert.Contains(t, ui.Prompts[0], "Username")
	assert.Contains(t, ui.Prompts[1], "Password")
	assert.Contains(t, ui.Outputs[2], "OK")
	assert.Contains(t, ui.Outputs[3], "No orgs found.")

	savedConfig := testhelpers.SavedConfiguration
	assert.Equal(t, cf.Organization{}, savedConfig.Organization)
	assert.Equal(t, cf.Space{}, savedConfig.Space)
}
Esempio n. 27
0
func test_Databases(t *testing.T) {
	res, err := testClient.Databases()

	assert.Equal(t, nil, err)
	assert.Contains(t, res, "booktown")
	assert.Contains(t, res, "postgres")
}
Esempio n. 28
0
func TestSuccessfullyLoggingInWithUsernameAsArgument(t *testing.T) {
	configRepo := testhelpers.FakeConfigRepository{}
	configRepo.Delete()
	config, _ := configRepo.Get()

	ui := new(testhelpers.FakeUI)
	ui.Inputs = []string{"bar"}
	auth := &testhelpers.FakeAuthenticator{
		AccessToken:  "my_access_token",
		RefreshToken: "my_refresh_token",
		ConfigRepo:   configRepo,
	}
	callLogin(
		[]string{"*****@*****.**"},
		ui,
		configRepo,
		&testhelpers.FakeOrgRepository{},
		&testhelpers.FakeSpaceRepository{},
		auth,
	)

	savedConfig := testhelpers.SavedConfiguration

	assert.Contains(t, ui.Outputs[0], config.Target)
	assert.Contains(t, ui.Outputs[2], "OK")
	assert.Contains(t, ui.Prompts[0], "Password")

	assert.Equal(t, savedConfig.AccessToken, "my_access_token")
	assert.Equal(t, savedConfig.RefreshToken, "my_refresh_token")
	assert.Equal(t, auth.Email, "*****@*****.**")
	assert.Equal(t, auth.Password, "bar")
}
Esempio n. 29
0
func TestLoggerIPAddress(t *testing.T) {
	e := echo.New()
	req, _ := http.NewRequest(echo.GET, "/", nil)
	rec := httptest.NewRecorder()
	c := echo.NewContext(req, echo.NewResponse(rec, e), e)
	buf := new(bytes.Buffer)
	e.Logger().SetOutput(buf)
	ip := "127.0.0.1"
	h := func(c *echo.Context) error {
		return c.String(http.StatusOK, "test")
	}

	mw := Logger()

	// With X-Real-IP
	req.Header.Add(echo.XRealIP, ip)
	mw(h)(c)
	assert.Contains(t, buf.String(), ip)

	// With X-Forwarded-For
	buf.Reset()
	req.Header.Del(echo.XRealIP)
	req.Header.Add(echo.XForwardedFor, ip)
	mw(h)(c)
	assert.Contains(t, buf.String(), ip)

	// with req.RemoteAddr
	buf.Reset()
	mw(h)(c)
	assert.Contains(t, buf.String(), ip)
}
Esempio n. 30
0
func TestGRPCLogger_Printf(t *testing.T) {
	b := bytes.NewBuffer(nil)
	l := log.NewJSONLogger(b)
	g := sklog.NewGRPCLogger(l)

	success := []struct {
		expected string
		format   string
		args     []interface{}
	}{
		{
			expected: "message",
			format:   "message",
		},
		{
			expected: "message1, message2",
			format:   "%s, %s",
			args: []interface{}{
				"message1",
				"message2",
			},
		},
	}

	for _, data := range success {
		g.Printf(data.format, data.args...)
		assert.Contains(t, b.String(), sklog.LevelDebug)
		assert.Contains(t, b.String(), sklog.KeyLevel)
		assert.Contains(t, b.String(), data.expected)
		b.Reset()
	}
}