Golang Empty示例

说明

golang empty示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: github.com/stretchr/testify/assert

示例#1
文件: dispatch_test.go 项目: ereyes01/victor

func TestNewDispatch(t *testing.T) {
	bot := getMockBot()
	assert.Empty(t, bot.dispatch.commands, "A new bot should have no commands.")
	assert.Nil(t, bot.dispatch.defaultHandler, "Default handler should be nil.")
	assert.Empty(t, bot.commandNames, "No command names should be stored on creation.")
	assert.Empty(t, bot.patterns, "Patterns array should be empty on creation.")
}

示例#2
文件: pagination_test.go 项目: tarsisazevedo/hugo

func TestPager(t *testing.T) {
	pages := createTestPages(21)
	groups, _ := pages.GroupBy("Weight", "desc")

	urlFactory := func(page int) string {
		return fmt.Sprintf("page/%d/", page)
	}

	_, err := newPaginatorFromPages(pages, -1, urlFactory)
	assert.NotNil(t, err)

	_, err = newPaginatorFromPageGroups(groups, -1, urlFactory)
	assert.NotNil(t, err)

	pag, err := newPaginatorFromPages(pages, 5, urlFactory)
	assert.Nil(t, err)
	doTestPages(t, pag)
	first := pag.Pagers()[0].First()
	assert.NotEmpty(t, first.Pages())
	assert.Empty(t, first.PageGroups())

	pag, err = newPaginatorFromPageGroups(groups, 5, urlFactory)
	assert.Nil(t, err)
	doTestPages(t, pag)
	first = pag.Pagers()[0].First()
	assert.NotEmpty(t, first.PageGroups())
	assert.Empty(t, first.Pages())

}

示例#3
文件: helpers_test.go 项目: NathanMcCauley/notary

// If applying a change fails due to a prefix error, it does not fall back
// on the parent.
func TestChangeTargetMetaDoesntFallbackIfPrefixError(t *testing.T) {
	repo, cs, err := testutils.EmptyRepo("docker.com/notary")
	assert.NoError(t, err)

	newKey, err := cs.Create("targets/level1", data.ED25519Key)
	assert.NoError(t, err)

	r, err := data.NewRole("targets/level1", 1, []string{newKey.ID()},
		[]string{"pathprefix"})
	assert.NoError(t, err)
	repo.UpdateDelegations(r, []data.PublicKey{newKey})

	hash := sha256.Sum256([]byte{})
	f := &data.FileMeta{
		Length: 1,
		Hashes: map[string][]byte{
			"sha256": hash[:],
		},
	}
	fjson, err := json.Marshal(f)
	assert.NoError(t, err)

	err = changeTargetMeta(repo, &changelist.TufChange{
		Actn:       changelist.ActionCreate,
		Role:       "targets/level1",
		ChangeType: "target",
		ChangePath: "notPathPrefix",
		Data:       fjson,
	})
	assert.Error(t, err)

	// no target in targets or targets/latest
	assert.Empty(t, repo.Targets[data.CanonicalTargetsRole].Signed.Targets)
	assert.Empty(t, repo.Targets["targets/level1"].Signed.Targets)
}

示例#4
文件: cache_impl_test.go 项目: AlbertZheng/heapster

func TestGC(t *testing.T) {
	var podEvictedCount int
	var containerEvictedCount int

	cache := NewCache(time.Millisecond, time.Second)
	cache.AddCacheListener(CacheListener{
		PodEvicted: func(namespace string, name string) {
			podEvictedCount += 1
		},
		FreeContainerEvicted: func(hostname string, name string) {
			containerEvictedCount += 1
		},
	})

	var (
		pods       []source_api.Pod
		containers []source_api.Container
	)
	f := fuzz.New().NumElements(2, 10).NilChance(0)
	f.Fuzz(&pods)
	f.Fuzz(&containers)
	assert := assert.New(t)
	assert.NoError(cache.StorePods(pods))
	assert.NoError(cache.StoreContainers(containers))
	zeroTime := time.Time{}
	assert.NotEmpty(cache.GetFreeContainers(zeroTime, zeroTime))
	assert.NotEmpty(cache.GetPods(zeroTime, zeroTime))
	// Expect all data to be deleted after 2 seconds.
	time.Sleep(10 * time.Second)
	assert.Empty(cache.GetFreeContainers(zeroTime, zeroTime))
	assert.Empty(cache.GetPods(zeroTime, zeroTime))

	assert.Equal(len(pods), podEvictedCount)
	assert.Equal(len(containers), containerEvictedCount)
}

示例#5
文件: convutil_test.go 项目: gunosy/aws-sdk-go

func TestTimeValueSlice(t *testing.T) {
	for idx, in := range testCasesTimeValueSlice {
		if in == nil {
			continue
		}
		out := aws.TimeValueSlice(in)
		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
		for i := range out {
			if in[i] == nil {
				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
			} else {
				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
			}
		}

		out2 := aws.TimeSlice(out)
		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
		for i := range out2 {
			if in[i] == nil {
				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
			} else {
				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
			}
		}
	}
}

示例#6
文件: auth_test.go 项目: cnry/aws-sdk-go-wrapper

func TestNewConfigWithKeys(t *testing.T) {
	assert := assert.New(t)

	var conf Config

	conf = NewConfigWithKeys(Keys{
		AccessKey: "access",
		SecretKey: "secret",
	})
	assert.NotNil(conf.Config)
	assert.NotNil(conf.Config.Credentials)
	assert.Empty(conf.Config.Region)
	assert.Empty(conf.Config.Endpoint)

	conf = NewConfigWithKeys(Keys{
		AccessKey: "access",
		SecretKey: "secret",
		Region:    "region",
		Endpoint:  "endpoint",
	})
	assert.NotNil(conf.Config)
	assert.NotNil(conf.Config.Credentials)
	assert.Equal("region", conf.Config.Region)
	assert.Equal("endpoint", conf.Config.Endpoint)
}

示例#7
文件: router_test.go 项目: hartsock/go-swagger

func TestRouterBuilder(t *testing.T) {
	spec, api := petstore.NewAPI(t)

	assert.Len(t, spec.RequiredConsumes(), 3)
	assert.Len(t, spec.RequiredProduces(), 5)
	assert.Len(t, spec.OperationIDs(), 4)

	// context := NewContext(spec, api)
	builder := petAPIRouterBuilder(spec, api)
	getRecords := builder.records["GET"]
	postRecords := builder.records["POST"]
	deleteRecords := builder.records["DELETE"]

	assert.Len(t, getRecords, 2)
	assert.Len(t, postRecords, 1)
	assert.Len(t, deleteRecords, 1)

	assert.Empty(t, builder.records["PATCH"])
	assert.Empty(t, builder.records["OPTIONS"])
	assert.Empty(t, builder.records["HEAD"])
	assert.Empty(t, builder.records["PUT"])

	rec := postRecords[0]
	assert.Equal(t, rec.Key, "/pets")
	val := rec.Value.(*routeEntry)
	assert.Len(t, val.Consumers, 3)
	assert.Len(t, val.Producers, 5)
	assert.Len(t, val.Consumes, 3)
	assert.Len(t, val.Produces, 5)

	assert.Len(t, val.Parameters, 1)
}

示例#8
文件: command_test.go 项目: inka/tacks

func TestCommand(t *testing.T) {

	t.Parallel()

	assert := assert.New(t)

	c := Command(good1)
	res, err := c.Value()

	assert.Equal("values_test.go", res)
	assert.NoError(err)

	c = Command(bad)
	res, err = c.Value()

	assert.Empty(res)
	assert.Equal(`failed to execute "false": "" (exit status 1)`, err.Error())

	c = Command(missing)
	res, err = c.Value()

	assert.Empty(res)
	assert.Equal(`failed to execute "no_such_binary_exists": /bin/bash: no_such_binary_exists: command not found (exit status 127)`, err.Error())

}

示例#9
文件: provider_test.go 项目: ColourboxDevelopment/aws-sdk-go

func TestFailedRetrieveCredentials(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(400)
		encoder := json.NewEncoder(w)
		err := encoder.Encode(map[string]interface{}{
			"Code":    "Error",
			"Message": "Message",
		})

		if err != nil {
			fmt.Println("failed to write error", err)
		}
	}))

	client := endpointcreds.NewProviderClient(*unit.Session.Config, unit.Session.Handlers, server.URL)
	creds, err := client.Retrieve()

	assert.Error(t, err)
	aerr := err.(awserr.Error)

	assert.Equal(t, "CredentialsEndpointError", aerr.Code())
	assert.Equal(t, "failed to load credentials", aerr.Message())

	aerr = aerr.OrigErr().(awserr.Error)
	assert.Equal(t, "Error", aerr.Code())
	assert.Equal(t, "Message", aerr.Message())

	assert.Empty(t, creds.AccessKeyID)
	assert.Empty(t, creds.SecretAccessKey)
	assert.Empty(t, creds.SessionToken)
	assert.True(t, client.IsExpired())
}

示例#10
文件: locks_test.go 项目: diffeo/go-coordinate

func TestLocksome(t *testing.T) {
	j := setUpTest(t, "TestLocksome")
	defer tearDownTest(t, j)

	ok, msg, err := j.Lock("id", 0,
		[]interface{}{[]interface{}{"foo"}})
	if assert.NoError(t, err) {
		assert.True(t, ok)
		assert.Empty(t, msg)
	}

	locked, msg, err := j.Locksome("id", 0, []interface{}{
		[]interface{}{"foo"},
		[]interface{}{"bar"},
		[]interface{}{"baz"},
	})
	if assert.NoError(t, err) {
		assert.Empty(t, msg)
		assert.Equal(t, [][]interface{}{
			nil,
			[]interface{}{"bar"},
			[]interface{}{"baz"},
		}, locked)
	}
}

示例#11
文件: repository_test.go 项目: nsnt/cli

func TestClearSession(t *testing.T) {
	withFakeHome(t, func() {
		repo := NewConfigurationDiskRepository()
		config, err := repo.Get()
		assert.NoError(t, err)

		config.Target = "http://api.example.com"
		config.RefreshToken = "some old refresh token"
		config.AccessToken = "some old access token"
		org := cf.OrganizationFields{}
		org.Name = "my-org"
		space := cf.SpaceFields{}
		space.Name = "my-space"
		repo.Save()

		err = repo.ClearSession()
		assert.NoError(t, err)

		repo.Save()

		savedConfig, err := repo.Get()
		assert.NoError(t, err)
		assert.Equal(t, savedConfig.Target, "http://api.example.com")
		assert.Empty(t, savedConfig.AccessToken)
		assert.Empty(t, savedConfig.RefreshToken)
		assert.Equal(t, savedConfig.OrganizationFields, cf.OrganizationFields{})
		assert.Equal(t, savedConfig.SpaceFields, cf.SpaceFields{})
	})
}

示例#12
文件: locks_test.go 项目: diffeo/go-coordinate

func TestUnlockSanity(t *testing.T) {
	j := setUpTest(t, "TestUnlockSanity")
	defer tearDownTest(t, j)

	keys := []interface{}{[]interface{}{"foo"}, []interface{}{"bar"}}

	ok, msg, err := j.Lock("id", 0, keys)
	if assert.NoError(t, err) {
		assert.True(t, ok)
		assert.Empty(t, msg)
	}

	// Should not be able to unlock something a different locker locked
	ok, msg, err = j.Unlock("id2", keys)
	if assert.NoError(t, err) {
		assert.False(t, ok)
		assert.NotEmpty(t, msg)
	}

	// Should be able to read original lock
	lockid, err := j.Readlock(keys)
	if assert.NoError(t, err) {
		assert.Equal(t, []interface{}{"id", "id"}, lockid)
	}

	ok, msg, err = j.Unlock("id", keys)
	if assert.NoError(t, err) {
		assert.True(t, ok)
		assert.Empty(t, msg)
	}
}

示例#13
文件: push_test.go 项目: jbayer/cli

func TestPushingAppWhenItDoesNotExistButRouteExists(t *testing.T) {
	domains := []cf.Domain{
		cf.Domain{Name: "foo.cf-app.com", Guid: "foo-domain-guid"},
	}
	route := cf.Route{Host: "my-new-app"}
	domainRepo := &testhelpers.FakeDomainRepository{FindByNameDomain: domains[0]}
	routeRepo := &testhelpers.FakeRouteRepository{FindByHostRoute: route}
	appRepo := &testhelpers.FakeApplicationRepository{AppByNameErr: true}
	stackRepo := &testhelpers.FakeStackRepository{}
	fakeStarter := &testhelpers.FakeAppStarter{}
	fakeStopper := &testhelpers.FakeAppStopper{}
	zipper := &testhelpers.FakeZipper{}

	fakeUI := callPush([]string{"--name", "my-new-app"}, fakeStarter, fakeStopper, zipper, appRepo, domainRepo, routeRepo, stackRepo)

	assert.Empty(t, routeRepo.CreatedRoute.Host)
	assert.Empty(t, routeRepo.CreatedRouteDomain.Guid)
	assert.Contains(t, fakeUI.Outputs[2], "my-new-app.foo.cf-app.com")
	assert.Equal(t, routeRepo.FindByHostHost, "my-new-app")

	assert.Contains(t, fakeUI.Outputs[3], "my-new-app.foo.cf-app.com")
	assert.Equal(t, routeRepo.BoundApp.Name, "my-new-app")
	assert.Equal(t, routeRepo.BoundRoute.Host, "my-new-app")
	assert.Contains(t, fakeUI.Outputs[4], "OK")
}

示例#14
文件: slack_test.go 项目: pubnative/statusboard

func TestCleanupEvents(t *testing.T) {
	_, server := initServer()
	notice := buildSlack(server.URL, map[string]string{"delay_in_sec": "0"})
	assert.True(t, notice.debounce)
	testEvents := []notices.Event{
		notices.Event{
			ServiceName: "testService",
			Status:      storages.DownStatus,
			Occurred:    time.Now(),
		},
		notices.Event{
			ServiceName: "testService",
			Status:      storages.UpStatus,
			Occurred:    time.Now(),
		},
	}
	assert.Empty(t, notice.cleanupEvents(testEvents))
	testEvents[0].Status = storages.UpStatus
	testEvents[1].Status = storages.DownStatus
	assert.Empty(t, notice.cleanupEvents(testEvents))
	testEvents[0].Status = storages.DownStatus
	testEvents[1].Status = storages.DownStatus
	assert.NotEmpty(t, notice.cleanupEvents(testEvents))
	testEvents[0].Status = storages.UpStatus
	testEvents[1].Status = storages.UpStatus
	assert.NotEmpty(t, notice.cleanupEvents(testEvents))
}

示例#15
文件: setup_settings_test.go 项目: Team254/cheesy-arena

func TestSetupSettingsClearDb(t *testing.T) {
	clearDb()
	defer clearDb()
	var err error
	db, err = OpenDatabase(testDbPath)
	assert.Nil(t, err)
	defer db.Close()
	eventSettings, _ = db.GetEventSettings()

	db.CreateTeam(new(Team))
	db.CreateMatch(&Match{Type: "qualification"})
	db.CreateMatchResult(new(MatchResult))
	db.CreateRanking(new(Ranking))
	db.CreateAllianceTeam(new(AllianceTeam))
	recorder := postHttpResponse("/setup/db/clear", "")
	assert.Equal(t, 302, recorder.Code)

	teams, _ := db.GetAllTeams()
	assert.NotEmpty(t, teams)
	matches, _ := db.GetMatchesByType("qualification")
	assert.Empty(t, matches)
	rankings, _ := db.GetAllRankings()
	assert.Empty(t, rankings)
	db.CalculateRankings()
	assert.Empty(t, rankings)
	alliances, _ := db.GetAllAlliances()
	assert.Empty(t, alliances)
}

示例#16
文件: push_test.go 项目: nsnt/cli

func TestPushingAppWhenItDoesNotExistButRouteExists(t *testing.T) {
	deps := getPushDependencies()

	domain := cf.Domain{}
	domain.Name = "foo.cf-app.com"
	domain.Guid = "foo-domain-guid"
	domain.Shared = true

	route := cf.Route{}
	route.Guid = "my-route-guid"
	route.Host = "my-new-app"
	route.Domain = domain.DomainFields

	deps.domainRepo.ListSharedDomainsDomains = []cf.Domain{domain}

	deps.routeRepo.FindByHostAndDomainRoute = route
	deps.appRepo.ReadNotFound = true

	ui := callPush(t, []string{"my-new-app"}, deps)

	assert.Empty(t, deps.routeRepo.CreatedHost)
	assert.Empty(t, deps.routeRepo.CreatedDomainGuid)
	assert.Equal(t, deps.routeRepo.FindByHostAndDomainHost, "my-new-app")
	assert.Equal(t, deps.routeRepo.BoundAppGuid, "my-new-app-guid")
	assert.Equal(t, deps.routeRepo.BoundRouteGuid, "my-route-guid")

	testassert.SliceContains(t, ui.Outputs, testassert.Lines{
		{"Using", "my-new-app.foo.cf-app.com"},
		{"Binding", "my-new-app.foo.cf-app.com"},
		{"OK"},
	})
}

示例#17
文件: updateagent_test.go 项目: aws/amazon-ssm-agent

func TestUpdateAgent(t *testing.T) {
	pluginInput := createStubPluginInput()
	pluginInput.TargetVersion = ""
	context := createStubInstanceContext()
	manifest := createStubManifest(pluginInput, context, true, true)
	config := contracts.Configuration{}
	plugin := &Plugin{}

	testCases := []fakeUpdateManager{
		{
			generateUpdateCmdResult: "-updater -message id value",
			generateUpdateCmdError:  nil,
			downloadManifestResult:  manifest,
			downloadManifestError:   nil,
			downloadUpdaterResult:   "updater",
			downloadUpdaterError:    nil,
			validateUpdateResult:    false,
			validateUpdateError:     nil,
		},
	}

	pluginInput.TargetVersion = ""
	mockCancelFlag := new(task.MockCancelFlag)
	util := fakeUtility{}

	for _, manager := range testCases {
		out := updateAgent(plugin, config, logger, &manager, &util, pluginInput, mockCancelFlag, "", "", time.Now())
		assert.Empty(t, out.Stderr)
		assert.Empty(t, out.Errors)
	}
}

示例#18
文件: cors_test.go 项目: gin-contrib/cors

func TestPassesAllowedAllOrigins(t *testing.T) {
	router := newTestRouter(Config{
		AllowAllOrigins:  true,
		AllowMethods:     []string{" Patch ", "get", "post", "POST"},
		AllowHeaders:     []string{"Content-type", "  testheader "},
		ExposeHeaders:    []string{"Data2", "x-User2"},
		AllowCredentials: false,
		MaxAge:           10 * time.Hour,
	})

	// no CORS request, origin == ""
	w := performRequest(router, "GET", "")
	assert.Equal(t, w.Body.String(), "get")
	assert.Empty(t, w.Header().Get("Access-Control-Allow-Origin"))
	assert.Empty(t, w.Header().Get("Access-Control-Allow-Credentials"))
	assert.Empty(t, w.Header().Get("Access-Control-Expose-Headers"))

	// allowed CORS request
	w = performRequest(router, "POST", "example.com")
	assert.Equal(t, w.Body.String(), "post")
	assert.Equal(t, w.Header().Get("Access-Control-Allow-Origin"), "*")
	assert.Equal(t, w.Header().Get("Access-Control-Expose-Headers"), "Data2,X-User2")
	assert.Empty(t, w.Header().Get("Access-Control-Allow-Credentials"))

	// allowed CORS prefligh request
	w = performRequest(router, "OPTIONS", "https://facebook.com")
	assert.Equal(t, w.Code, 200)
	assert.Equal(t, w.Header().Get("Access-Control-Allow-Origin"), "*")
	assert.Equal(t, w.Header().Get("Access-Control-Allow-Methods"), "PATCH,GET,POST")
	assert.Equal(t, w.Header().Get("Access-Control-Allow-Headers"), "Content-Type,Testheader")
	assert.Equal(t, w.Header().Get("Access-Control-Max-Age"), "36000")
	assert.Empty(t, w.Header().Get("Access-Control-Allow-Credentials"))
}

示例#19
文件: bits_test.go 项目: sjeff83/hzip

func TestBitFlush(t *testing.T) {
	var err error
	buf := new(bytes.Buffer)
	w := newBitWriter(buf)

	// Empty flush
	err = w.Flush()
	assert.Nil(t, err)
	assert.Empty(t, buf.Bytes())

	// Flush with one 0 bit
	buf.Reset()
	w.WriteBitString("0")
	assert.Empty(t, buf.Bytes())
	err = w.Flush()
	assert.Nil(t, err)
	assert.Equal(t, []byte{0x00}, buf.Bytes())

	// Flush with 2 bytes
	buf.Reset()
	w.WriteBitString("01100101010")
	assert.Equal(t, []byte{0x65}, buf.Bytes())
	err = w.Flush()
	assert.Nil(t, err)
	assert.Equal(t, []byte{0x65, 0x40}, buf.Bytes())
	// Test double flush
	err = w.Flush()
	assert.Nil(t, err)
	assert.Equal(t, []byte{0x65, 0x40}, buf.Bytes())
}

示例#20
文件: baskets_bolt_test.go 项目: darklynx/request-baskets

func TestBoltDatabase_FindNames(t *testing.T) {
	db := NewBoltDatabase("test9.db")
	defer db.Release()
	defer os.Remove("test9.db")

	config := BasketConfig{Capacity: 5}
	for i := 0; i < 35; i++ {
		db.Create(fmt.Sprintf("test%v", i), config)
	}

	res1 := db.FindNames("test2", 20, 0)
	assert.False(t, res1.HasMore, "no more names are expected")
	assert.Len(t, res1.Names, 11, "wrong number of found names")
	for _, name := range res1.Names {
		assert.Contains(t, name, "test2", "invalid name among search results")
	}

	res2 := db.FindNames("test1", 5, 0)
	assert.True(t, res2.HasMore, "more names are expected")
	assert.Len(t, res2.Names, 5, "wrong number of found names")

	// Corner cases
	assert.Len(t, db.FindNames("test1", 5, 10).Names, 1, "wrong number of returned names")
	assert.Empty(t, db.FindNames("test2", 5, 20).Names, "names in this page are not expected")
	assert.False(t, db.FindNames("test3", 5, 6).HasMore, "no more names are expected")
	assert.False(t, db.FindNames("abc", 5, 0).HasMore, "no more names are expected")
	assert.Empty(t, db.FindNames("xyz", 5, 0).Names, "names are not expected")
}

示例#21
文件: eurekache_extra_test.go 项目: evalphobia/eurekache

func TestExtraEurekacheSetExpire(t *testing.T) {
	assert := assert.New(t)
	val := "value"

	e := New()
	m := memorycache.NewCacheTTL(1)
	e.SetCacheSources([]Cache{m})
	e.SetExpire("key", val, 100)

	var result string
	var ok bool

	ok = m.Get("nokey", &result)
	assert.False(ok)
	assert.Empty(result)

	result = ""
	ok = e.Get("key", &result)
	assert.True(ok)
	assert.Equal(val, result)

	result = ""
	time.Sleep(100 * time.Millisecond)
	ok = e.Get("key", &result)
	assert.False(ok)
	assert.Empty(result)
}

示例#22
文件: s3_download_test.go 项目: APTrust/exchange

func TestFetchWithoutChecksums(t *testing.T) {
	if !canTestS3() {
		return
	}
	download := getS3DownloadObject(t)
	if download == nil {
		return
	}
	download.CalculateMd5 = false
	download.CalculateSha256 = false
	download.Fetch()
	defer os.Remove(download.LocalPath)

	assert.Empty(t, download.ErrorMessage)
	if download.Response == nil {
		assert.FailNow(t, "Response object is nil")
	}

	assert.Equal(t, testFileETag, *download.Response.ETag)
	assert.Equal(t, int64(testFileSize), *download.Response.ContentLength)
	assert.Equal(t, int64(testFileSize), download.BytesCopied)

	fileStat, err := os.Stat(download.LocalPath)
	if err != nil {
		assert.FailNow(t, "Download file '%s' does not exist", download.LocalPath)
	}
	assert.Equal(t, int64(testFileSize), fileStat.Size())

	assert.Empty(t, download.Md5Digest)
	assert.Empty(t, download.Sha256Digest)
}

示例#23
文件: virtualbox_test.go 项目: MerlinDMC/machine

func TestGetIPErrors(t *testing.T) {
	var tests = []struct {
		stdOut   string
		err      error
		finalErr error
	}{
		{`VMState="poweroff"`, nil, errors.New("Host is not running")},
		{"", errors.New("Unable to get state"), errors.New("Unable to get state")},
	}

	for _, expected := range tests {
		driver := newTestDriver("default")
		driver.VBoxManager = &VBoxManagerMock{
			args:   "showvminfo default --machinereadable",
			stdOut: expected.stdOut,
			err:    expected.err,
		}

		ip, err := driver.GetIP()

		assert.Empty(t, ip)
		assert.Equal(t, err, expected.finalErr)

		url, err := driver.GetURL()

		assert.Empty(t, url)
		assert.Equal(t, err, expected.finalErr)
	}
}

示例#24
文件: ask_test.go 项目: rayrutjes/ask

func TestFask(t *testing.T) {
	question := "question"
	expectedQuestion := "question: "

	answer := "answer\n"
	expectedAnswer := "answer"

	w := new(bytes.Buffer)
	r := bytes.NewBufferString(answer)

	a, err := Fask(question, w, r)
	assert.Nil(t, err)
	assert.Equal(t, expectedQuestion, w.String())
	assert.Equal(t, expectedAnswer, a)

	// Error while reading answer
	a, err = Fask(question, ioutil.Discard, new(bytes.Buffer))
	assert.Empty(t, a)
	assert.Error(t, err)

	// Error while writing question
	brokenWriter := new(WriterMock)
	brokenWriter.On("Write", []byte(expectedQuestion)).Return(0, io.EOF)
	a, err = Fask(question, brokenWriter, r)
	assert.Empty(t, a)
	assert.Error(t, err)
}

示例#25
文件: repository_test.go 项目: pmuellr/cli

func TestClearTokens(t *testing.T) {
	org := cf.OrganizationFields{}
	org.Name = "my-org"
	space := cf.SpaceFields{}
	space.Name = "my-space"

	repo := NewConfigurationDiskRepository()
	config := repo.loadDefaultConfig(t)
	defer repo.restoreConfig(t)

	config.Target = "http://api.example.com"
	config.RefreshToken = "some old refresh token"
	config.AccessToken = "some old access token"
	config.OrganizationFields = org
	config.SpaceFields = space
	repo.Save()

	err := repo.ClearTokens()
	assert.NoError(t, err)

	repo.Save()

	savedConfig, err := repo.Get()
	assert.NoError(t, err)
	assert.Equal(t, savedConfig.Target, "http://api.example.com")
	assert.Empty(t, savedConfig.AccessToken)
	assert.Empty(t, savedConfig.RefreshToken)
	assert.Equal(t, savedConfig.OrganizationFields, org)
	assert.Equal(t, savedConfig.SpaceFields, space)
}

示例#26
文件: virtual_bag_test.go 项目: APTrust/exchange

func TestVirtualBagRead_ChecksumOptions(t *testing.T) {
	tempDir, bagPath, err := testhelper.UntarTestBag("example.edu.tagsample_good.tar")
	if err != nil {
		assert.Fail(t, err.Error())
	}
	if tempDir != "" {
		defer os.RemoveAll(tempDir)
	}
	files := []string{"bagit.txt", "bag-info.txt", "aptrust-info.txt"}
	vbag := models.NewVirtualBag(bagPath, files, true, false)
	assert.NotNil(t, vbag)
	obj, _ := vbag.Read()

	// Should calculate md5 only
	for _, gf := range obj.GenericFiles {
		assert.NotEmpty(t, gf.IngestMd5)
		assert.Empty(t, gf.IngestSha256)
	}

	vbag = models.NewVirtualBag(bagPath, files, false, true)
	assert.NotNil(t, vbag)
	obj, _ = vbag.Read()

	// Should calculate sha256 only
	for _, gf := range obj.GenericFiles {
		assert.Empty(t, gf.IngestMd5)
		assert.NotEmpty(t, gf.IngestSha256)
	}

}

示例#27
文件: context_test.go 项目: MStoykov/go-swagger

func TestContextInvalidResponseFormat(t *testing.T) {
	ct := "application/x-yaml"
	other := "application/sgml"
	spec, api := petstore.NewAPI(t)
	ctx := NewContext(spec, api, nil)
	ctx.router = DefaultRouter(spec, ctx.api)

	request, _ := http.NewRequest("GET", "http://localhost:8080", nil)
	request.Header.Set(httpkit.HeaderAccept, ct)

	// check there's nothing there
	cached, ok := context.GetOk(request, ctxResponseFormat)
	assert.False(t, ok)
	assert.Empty(t, cached)

	// trigger the parse
	mt := ctx.ResponseFormat(request, []string{other})
	assert.Empty(t, mt)

	// check it was cached
	cached, ok = context.GetOk(request, ctxResponseFormat)
	assert.False(t, ok)
	assert.Empty(t, cached)

	// check if the cast works and fetch from cache too
	mt = ctx.ResponseFormat(request, []string{other})
	assert.Empty(t, mt)
}

示例#28
文件: discovery_test.go 项目: winsx/libnetwork

func TestEntriesDiff(t *testing.T) {
	entry1 := &Entry{Host: "1.1.1.1", Port: "1111"}
	entry2 := &Entry{Host: "2.2.2.2", Port: "2222"}
	entry3 := &Entry{Host: "3.3.3.3", Port: "3333"}
	entries := Entries{entry1, entry2}

	// No diff
	added, removed := entries.Diff(Entries{entry2, entry1})
	assert.Empty(t, added)
	assert.Empty(t, removed)

	// Add
	added, removed = entries.Diff(Entries{entry2, entry3, entry1})
	assert.Len(t, added, 1)
	assert.True(t, added.Contains(entry3))
	assert.Empty(t, removed)

	// Remove
	added, removed = entries.Diff(Entries{entry2})
	assert.Empty(t, added)
	assert.Len(t, removed, 1)
	assert.True(t, removed.Contains(entry1))

	// Add and remove
	added, removed = entries.Diff(Entries{entry1, entry3})
	assert.Len(t, added, 1)
	assert.True(t, added.Contains(entry3))
	assert.Len(t, removed, 1)
	assert.True(t, removed.Contains(entry2))
}

示例#29
文件: routes_test.go 项目: gerryeng/fx-ticker

// TestContextParamsGet tests that a parameter can be parsed from the URL.
func TestRouteParamsByName(t *testing.T) {
	name := ""
	lastName := ""
	wild := ""
	router := New()
	router.GET("/test/:name/:last_name/*wild", func(c *Context) {
		name = c.Params.ByName("name")
		lastName = c.Params.ByName("last_name")
		var ok bool
		wild, ok = c.Params.Get("wild")

		assert.True(t, ok)
		assert.Equal(t, name, c.Param("name"))
		assert.Equal(t, name, c.Param("name"))
		assert.Equal(t, lastName, c.Param("last_name"))

		assert.Empty(t, c.Param("wtf"))
		assert.Empty(t, c.Params.ByName("wtf"))

		wtf, ok := c.Params.Get("wtf")
		assert.Empty(t, wtf)
		assert.False(t, ok)
	})

	w := performRequest(router, "GET", "/test/john/smith/is/super/great")

	assert.Equal(t, w.Code, 200)
	assert.Equal(t, name, "john")
	assert.Equal(t, lastName, "smith")
	assert.Equal(t, wild, "/is/super/great")
}

示例#30
文件: magi_test.go 项目: evanhuang8/Magi

func TestConsumerDelay(t *testing.T) {
	assert := assert.New(t)
	FlushQueue()
	// Instantiation
	consumer, err := Consumer(dqConfig, rConfig)
	assert.Empty(err)
	assert.NotEmpty(consumer)
	defer consumer.Close()
	queue := "jobq" + RandomKey()
	// Add delay job
	eta := time.Now().Add(5 * time.Second)
	body := RandomKey()
	job, err := consumer.AddJob(queue, body, eta, nil)
	assert.Empty(err)
	assert.NotEmpty(job)
	assert.NotEmpty(job.ID)
	assert.Equal(job.Body, body)
	// Setup the processor
	p := &DummyProcessor{
		Bodies: make([]string, 0, 1),
	}
	consumer.Register(queue, p)
	// Kick off processing
	go consumer.Process(queue)
	time.Sleep(2 * time.Second)
	assert.True(consumer.IsProcessing())
	// Check delay behavior
	time.Sleep(time.Second)
	assert.Equal(len(p.Bodies), 0)
	time.Sleep(2 * time.Second)
	assert.Equal(len(p.Bodies), 1)
	assert.Equal(p.Bodies[0], body+"dummy")
}

展开阅读全文