本文整理汇总了Golang中github.com/juju/testing.NewClock函数的典型用法代码示例。如果您正苦于以下问题:Golang NewClock函数的具体用法?Golang NewClock怎么用?Golang NewClock使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了NewClock函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: TestConfigValidation
func (s *IsolatedWorkerSuite) TestConfigValidation(c *gc.C) {
tests := []struct {
cfg meterstatus.IsolatedConfig
expected string
}{{
cfg: meterstatus.IsolatedConfig{
Runner: &stubRunner{stub: s.stub},
StateFile: meterstatus.NewStateFile(path.Join(s.dataDir, "meter-status.yaml")),
},
expected: "clock not provided",
}, {
cfg: meterstatus.IsolatedConfig{
Clock: testing.NewClock(time.Now()),
StateFile: meterstatus.NewStateFile(path.Join(s.dataDir, "meter-status.yaml")),
},
expected: "hook runner not provided",
}, {
cfg: meterstatus.IsolatedConfig{
Clock: testing.NewClock(time.Now()),
Runner: &stubRunner{stub: s.stub},
},
expected: "state file not provided",
}}
for i, test := range tests {
c.Logf("running test %d", i)
err := test.cfg.Validate()
c.Assert(err, gc.ErrorMatches, test.expected)
}
}
示例2: TestPrunes
func (s *TxnPrunerSuite) TestPrunes(c *gc.C) {
fakePruner := newFakeTransactionPruner()
testClock := testing.NewClock(time.Now())
interval := time.Minute
p := txnpruner.New(fakePruner, interval, testClock)
defer p.Kill()
select {
case <-testClock.Alarms():
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for worker to stat")
}
c.Logf("pruner running and waiting: %s (%s)", testClock.Now(), time.Now())
// Show that we prune every minute
for i := 0; i < 5; i++ {
testClock.Advance(interval)
c.Logf("loop %d: %s (%s)", i, testClock.Now(), time.Now())
select {
case <-fakePruner.pruneCh:
case <-time.After(coretesting.LongWait):
c.Fatal("timed out waiting for pruning to happen")
}
// Now we need to wait for the txn pruner to call clock.After again
// before we advance the clock, or it will be waiting for the wrong time.
select {
case <-testClock.Alarms():
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for worker to loop around")
}
}
}
示例3: SetUpTest
func (s *Suite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.clock = jujutesting.NewClock(time.Now())
s.stub = new(jujutesting.Stub)
s.connection = &stubConnection{
stub: s.stub,
controllerTag: targetControllerTag,
}
s.connectionErr = nil
s.facade = newStubMasterFacade(s.stub, s.clock.Now())
// The default worker Config used by most of the tests. Tests may
// tweak parts of this as needed.
s.config = migrationmaster.Config{
ModelUUID: utils.MustNewUUID().String(),
Facade: s.facade,
Guard: newStubGuard(s.stub),
APIOpen: s.apiOpen,
UploadBinaries: nullUploadBinaries,
CharmDownloader: fakeCharmDownloader,
ToolsDownloader: fakeToolsDownloader,
Clock: s.clock,
}
}
示例4: newServerWithTestClock
func (s *pingerSuite) newServerWithTestClock(c *gc.C) (*apiserver.Server, *testing.Clock) {
clock := testing.NewClock(time.Now())
config := s.sampleConfig(c)
config.PingClock = clock
server := s.newServer(c, config)
return server, clock
}
示例5: SetUpTest
func (s *MigrationSuite) SetUpTest(c *gc.C) {
s.ConnSuite.SetUpTest(c)
s.clock = jujutesting.NewClock(time.Now().Truncate(time.Second))
err := s.State.SetClockForTesting(s.clock)
c.Assert(err, jc.ErrorIsNil)
// Create a hosted model to migrate.
s.State2 = s.Factory.MakeModel(c, nil)
s.AddCleanup(func(*gc.C) { s.State2.Close() })
targetControllerTag := names.NewControllerTag(utils.MustNewUUID().String())
mac, err := macaroon.New([]byte("secret"), "id", "location")
c.Assert(err, jc.ErrorIsNil)
// Plausible migration arguments to test with.
s.stdSpec = state.MigrationSpec{
InitiatedBy: names.NewUserTag("admin"),
TargetInfo: migration.TargetInfo{
ControllerTag: targetControllerTag,
Addrs: []string{"1.2.3.4:5555", "4.3.2.1:6666"},
CACert: "cert",
AuthTag: names.NewUserTag("user"),
Password: "password",
Macaroons: []macaroon.Slice{{mac}},
},
}
}
示例6: SetUpTest
func (s *SenderSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "cs:quantal/metered"})
s.meteredService = s.Factory.MakeApplication(c, &factory.ApplicationParams{Charm: meteredCharm})
s.unit = s.Factory.MakeUnit(c, &factory.UnitParams{Application: s.meteredService, SetCharmURL: true})
s.clock = jujutesting.NewClock(time.Now())
}
示例7: TestPingTimeout
func (r *pingSuite) TestPingTimeout(c *gc.C) {
triggered := make(chan struct{})
action := func() {
close(triggered)
}
clock := jujutesting.NewClock(time.Now())
timeout := apiserver.NewPingTimeout(action, clock, 50*time.Millisecond)
for i := 0; i < 2; i++ {
waitAlarm(c, clock)
clock.Advance(10 * time.Millisecond)
timeout.Ping()
}
waitAlarm(c, clock)
clock.Advance(49 * time.Millisecond)
select {
case <-triggered:
c.Fatalf("action triggered early")
case <-time.After(testing.ShortWait):
}
clock.Advance(time.Millisecond)
select {
case <-triggered:
case <-time.After(testing.LongWait):
c.Fatalf("action never triggered")
}
}
示例8: TestAuthenticateLocalLoginMacaroon
func (s *userAuthenticatorSuite) TestAuthenticateLocalLoginMacaroon(c *gc.C) {
service := mockBakeryService{}
clock := testing.NewClock(time.Time{})
authenticator := &authentication.UserAuthenticator{
Service: &service,
Clock: clock,
LocalUserIdentityLocation: "https://testing.invalid:1234/auth",
}
service.SetErrors(&bakery.VerificationError{})
_, err := authenticator.Authenticate(
authentication.EntityFinder(nil),
names.NewUserTag("bobbrown"),
params.LoginRequest{},
)
c.Assert(err, gc.FitsTypeOf, &common.DischargeRequiredError{})
service.CheckCallNames(c, "CheckAny", "ExpireStorageAt", "NewMacaroon")
calls := service.Calls()
c.Assert(calls[1].Args, jc.DeepEquals, []interface{}{clock.Now().Add(24 * time.Hour)})
c.Assert(calls[2].Args, jc.DeepEquals, []interface{}{
"", []byte(nil), []checkers.Caveat{
checkers.NeedDeclaredCaveat(
checkers.Caveat{
Location: "https://testing.invalid:1234/auth",
Condition: "is-authenticated-user [email protected]",
},
"username",
),
{Condition: "time-before 0001-01-02T00:00:00Z"},
},
})
}
示例9: newFixture
func newFixture(period time.Duration) workerFixture {
return workerFixture{
revisionUpdater: newMockRevisionUpdater(),
clock: testing.NewClock(time.Now()),
period: period,
}
}
示例10: TestDeleteSecurityGroupFewCalls
func (s *SecurityGroupSuite) TestDeleteSecurityGroupFewCalls(c *gc.C) {
t0 := time.Time{}
clock := autoAdvancingClock{testing.NewClock(t0)}
count := 0
maxCalls := 4
expectedTimes := []time.Time{
t0,
t0.Add(time.Second),
t0.Add(3 * time.Second),
t0.Add(7 * time.Second),
t0.Add(15 * time.Second),
}
s.instanceStub.deleteSecurityGroup = func(group amzec2.SecurityGroup) (resp *amzec2.SimpleResp, err error) {
c.Assert(clock.Now(), gc.Equals, expectedTimes[count])
if count < maxCalls {
count++
return nil, &amzec2.Error{Code: "keep going"}
}
return nil, nil
}
err := s.deleteFunc(s.instanceStub, amzec2.SecurityGroup{}, clock)
c.Assert(err, jc.ErrorIsNil)
expectedCalls := make([]string, maxCalls+1)
for i := 0; i < maxCalls+1; i++ {
expectedCalls[i] = "DeleteSecurityGroup"
}
s.instanceStub.CheckCallNames(c, expectedCalls...)
}
示例11: SetUpTest
func (s *IsolatedWorkerSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.stub = &testing.Stub{}
s.dataDir = c.MkDir()
s.hookRan = make(chan struct{})
s.triggersCreated = make(chan struct{})
triggerFactory := func(state meterstatus.WorkerState, status string, disconectedAt time.Time, clk clock.Clock, amber time.Duration, red time.Duration) (<-chan time.Time, <-chan time.Time) {
select {
case s.triggersCreated <- struct{}{}:
case <-time.After(coretesting.LongWait):
c.Fatalf("failed to signal trigger creation")
}
return meterstatus.GetTriggers(state, status, disconectedAt, clk, amber, red)
}
s.clk = testing.NewClock(time.Now())
wrk, err := meterstatus.NewIsolatedStatusWorker(
meterstatus.IsolatedConfig{
Runner: &stubRunner{stub: s.stub, ran: s.hookRan},
StateFile: meterstatus.NewStateFile(path.Join(s.dataDir, "meter-status.yaml")),
Clock: s.clk,
AmberGracePeriod: AmberGracePeriod,
RedGracePeriod: RedGracePeriod,
TriggerFactory: triggerFactory,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(wrk, gc.NotNil)
s.worker = wrk
}
示例12: TestPartialInstanceErrors
func (s *aggregateSuite) TestPartialInstanceErrors(c *gc.C) {
testGetter := new(testInstanceGetter)
clock := jujutesting.NewClock(time.Now())
delay := time.Second
cfg := aggregatorConfig{
Clock: clock,
Delay: delay,
Environ: testGetter,
}
testGetter.err = environs.ErrPartialInstances
testGetter.newTestInstance("foo", "not foobar", []string{"192.168.1.2"})
aggregator, err := newAggregator(cfg)
c.Check(err, jc.ErrorIsNil)
// Ensure the worker is killed and cleaned up if the test exits early.
defer workertest.CleanKill(c, aggregator)
// // Create a checker we can launch as goroutines
var wg sync.WaitGroup
checkInfo := func(id instance.Id, expectStatus string, expectedError error) {
defer wg.Done()
info, err := aggregator.instanceInfo(id)
if expectedError == nil {
c.Check(err, jc.ErrorIsNil)
} else {
c.Check(err.Error(), gc.Equals, expectedError.Error())
}
c.Check(info.status.Message, gc.Equals, expectStatus)
}
// Launch and wait for these
wg.Add(2)
go checkInfo("foo", "not foobar", nil)
go checkInfo("foo2", "", errors.New("instance foo2 not found"))
// Unwind the testing clock to let our requests through.
waitAlarms(c, clock, 2)
clock.Advance(delay)
// Check we're still alive.
workertest.CheckAlive(c, aggregator)
// Wait until the checkers pass.
wg.Wait()
// Now kill the worker so we don't risk a race in the following assertions.
workertest.CleanKill(c, aggregator)
// Ensure we got our list back with the correct length.
c.Assert(len(testGetter.ids), gc.Equals, 2)
// Ensure we called instances once.
// TODO(redir): all this stuff is really crying out to be, e.g.
// testGetter.CheckOneCall(c, "foo", "foo2") per
// http://reviews.vapour.ws/r/4885/
c.Assert(testGetter.counter, gc.Equals, int32(1))
}
示例13: TestPruneStatusHistoryBySize
func (s *StatusHistorySuite) TestPruneStatusHistoryBySize(c *gc.C) {
clock := testing.NewClock(time.Now())
err := s.State.SetClockForTesting(clock)
c.Assert(err, jc.ErrorIsNil)
service := s.Factory.MakeApplication(c, nil)
unit := s.Factory.MakeUnit(c, &factory.UnitParams{Application: service})
state.PrimeUnitStatusHistory(c, clock, unit, status.Active, 20000, 1000, nil)
history, err := unit.StatusHistory(status.StatusHistoryFilter{Size: 25000})
c.Assert(err, jc.ErrorIsNil)
c.Logf("%d\n", len(history))
c.Assert(history, gc.HasLen, 20001)
err = state.PruneStatusHistory(s.State, 0, 1)
c.Assert(err, jc.ErrorIsNil)
history, err = unit.StatusHistory(status.StatusHistoryFilter{Size: 25000})
c.Assert(err, jc.ErrorIsNil)
historyLen := len(history)
// When writing this test, the size was 6670 for about 0,00015 MB per entry
// but that is a size that can most likely change so I wont risk a flaky test
// here, enough to say that if this size suddenly is no longer less than
// half its good reason for suspicion.
c.Assert(historyLen, jc.LessThan, 10000)
}
示例14: TestNewMetricsManagerAPIRefusesNonMachine
func (s *metricsManagerSuite) TestNewMetricsManagerAPIRefusesNonMachine(c *gc.C) {
tests := []struct {
tag names.Tag
environManager bool
expectedError string
}{
{names.NewUnitTag("mysql/0"), true, "permission denied"},
{names.NewLocalUserTag("admin"), true, "permission denied"},
{names.NewMachineTag("0"), false, "permission denied"},
{names.NewMachineTag("0"), true, ""},
}
for i, test := range tests {
c.Logf("test %d", i)
anAuthoriser := s.authorizer
anAuthoriser.EnvironManager = test.environManager
anAuthoriser.Tag = test.tag
endPoint, err := metricsmanager.NewMetricsManagerAPI(s.State, nil, anAuthoriser, jujutesting.NewClock(time.Now()))
if test.expectedError == "" {
c.Assert(err, jc.ErrorIsNil)
c.Assert(endPoint, gc.NotNil)
} else {
c.Assert(err, gc.ErrorMatches, test.expectedError)
c.Assert(endPoint, gc.IsNil)
}
}
}
示例15: TestNoPollWhenNotProvisioned
func (s *machineSuite) TestNoPollWhenNotProvisioned(c *gc.C) {
s.PatchValue(&ShortPoll, 1*time.Millisecond)
s.PatchValue(&LongPoll, coretesting.LongWait)
polled := make(chan struct{}, 1)
getInstanceInfo := func(id instance.Id) (instanceInfo, error) {
select {
case polled <- struct{}{}:
default:
}
return instanceInfo{testAddrs, instance.InstanceStatus{Status: status.Unknown, Message: "pending"}}, nil
}
context := &testMachineContext{
getInstanceInfo: getInstanceInfo,
dyingc: make(chan struct{}),
}
m := &testMachine{
tag: names.NewMachineTag("99"),
instanceId: instance.Id(""),
refresh: func() error { return nil },
addresses: testAddrs,
life: params.Alive,
status: "pending",
}
died := make(chan machine)
clock := gitjujutesting.NewClock(time.Time{})
changed := make(chan struct{})
go runMachine(context, m, changed, died, clock)
expectPoll := func() {
// worker should be waiting for ShortPoll
select {
case <-clock.Alarms():
case <-time.After(coretesting.LongWait):
c.Fatalf("expected time-based polling")
}
clock.Advance(ShortPoll)
}
expectPoll()
expectPoll()
select {
case <-polled:
c.Fatalf("unexpected instance poll")
case <-time.After(coretesting.ShortWait):
}
m.setInstanceId("inst-ance")
expectPoll()
select {
case <-polled:
case <-time.After(coretesting.LongWait):
c.Fatalf("expected instance poll")
}
killMachineLoop(c, m, context.dyingc, died)
c.Assert(context.killErr, gc.Equals, nil)
}