Golang cgl-tideland-biz-asserts.NewTestingAsserts类(方法)实例源码

// TestBox tests the box usage.
func TestEventBox(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	inbox := newBox()

	assert.Equal(inbox.len(), 0, "box is empty")

	inbox.push(EventMessage(EmptyPayload, "Event", 1))
	inbox.push(EventMessage(EmptyPayload, "Event", 2))
	inbox.push(EventMessage(EmptyPayload, "Event", 3))

	assert.Equal(inbox.len(), 3, "box has right length")
	assert.Equal(inbox.pop().event.Topic(), Id("Event", 1), "first event")
	assert.Equal(inbox.pop().event.Topic(), Id("Event", 2), "second event")
	assert.Equal(inbox.pop().event.Topic(), Id("Event", 3), "third event")

	go func() {
		assert.Equal(inbox.pop().event.Topic(), Id("Event", 4), "fourth event")

		inbox.push(EventMessage(EmptyPayload, "Event", 5))
	}()

	inbox.push(EventMessage(EmptyPayload, "Event", 4))
	time.Sleep(100 * time.Millisecond)
	assert.Equal(inbox.pop().event.Topic(), Id("Event", 5), "fifth event")
}

func TestHookRPC(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	// Create the UI to test
	h := new(packer.MockHook)

	// Serve
	server := rpc.NewServer()
	RegisterHook(server, h)
	address := serveSingleConn(server)

	// Create the client over RPC and run some methods to verify it works
	client, err := rpc.Dial("tcp", address)
	assert.Nil(err, "should be able to connect")

	hClient := Hook(client)

	// Test Run
	ui := &testUi{}
	hClient.Run("foo", ui, nil, 42)
	assert.True(h.RunCalled, "run should be called")

	// Test Cancel
	hClient.Cancel()
	assert.True(h.CancelCalled, "cancel should be called")
}

// Test of the ETM monitor.
func TestEtmMonitor(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	// Generate measurings.
	for i := 0; i < 500; i++ {
		n := rand.Intn(10)
		id := fmt.Sprintf("mp:task:%d", n)
		m := BeginMeasuring(id)
		work(n * 5000)
		m.EndMeasuring()
	}
	// Need some time to let that backend catch up queued mesurings.
	time.Sleep(1e7)
	// Asserts.
	mp, err := ReadMeasuringPoint("foo")
	assert.ErrorMatch(err, `measuring point "foo" does not exist`, "Reading non-existent measuring point.")
	mp, err = ReadMeasuringPoint("mp:task:5")
	assert.Nil(err, "No error expected.")
	assert.Equal(mp.Id, "mp:task:5", "Should get the right one.")
	assert.True(mp.Count > 0, "Should be measured several times.")
	assert.Match(mp.String(), `Measuring Point "mp:task:5" (.*)`, "String representation should look fine.")
	MeasuringPointsDo(func(mp *MeasuringPoint) {
		assert.Match(mp.Id, "mp:task:[0-9]", "Id has to match the pattern.")
		assert.True(mp.MinDuration <= mp.AvgDuration && mp.AvgDuration <= mp.MaxDuration,
			"Avg should be somewhere between min and max.")
	})
}

func TestBlockDevice(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	ec2Mapping := []ec2.BlockDeviceMapping{
		ec2.BlockDeviceMapping{
			DeviceName:          "/dev/sdb",
			VirtualName:         "ephemeral0",
			SnapshotId:          "snap-1234",
			VolumeType:          "standard",
			VolumeSize:          8,
			DeleteOnTermination: true,
			IOPS:                1000,
		},
	}

	blockDevice := BlockDevice{
		DeviceName:          "/dev/sdb",
		VirtualName:         "ephemeral0",
		SnapshotId:          "snap-1234",
		VolumeType:          "standard",
		VolumeSize:          8,
		DeleteOnTermination: true,
		IOPS:                1000,
	}

	blockDevices := BlockDevices{
		AMIMappings:    []BlockDevice{blockDevice},
		LaunchMappings: []BlockDevice{blockDevice},
	}

	assert.Equal(ec2Mapping, blockDevices.BuildAMIDevices(), "should match output")
	assert.Equal(ec2Mapping, blockDevices.BuildLaunchDevices(), "should match output")
}

func TestProvisionerRPC(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	// Create the interface to test
	p := new(testProvisioner)

	// Start the server
	server := rpc.NewServer()
	RegisterProvisioner(server, p)
	address := serveSingleConn(server)

	// Create the client over RPC and run some methods to verify it works
	client, err := rpc.Dial("tcp", address)
	assert.Nil(err, "should be able to connect")

	// Test Prepare
	config := 42
	pClient := Provisioner(client)
	pClient.Prepare(config)
	assert.True(p.prepareCalled, "prepare should be called")
	assert.Equal(p.prepareConfigs, []interface{}{42}, "prepare should be called with right arg")

	// Test Provision
	ui := &testUi{}
	comm := new(packer.MockCommunicator)
	pClient.Provision(ui, comm)
	assert.True(p.provCalled, "provision should be called")

	p.provUi.Say("foo")
	assert.True(ui.sayCalled, "say should be called")
}

// TestDuration tests time.Duration values.
func TestDuration(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	provider := config.NewMapConfigurationProvider()
	cfg := config.New(provider)

	cfg.Set("alpha", "0")
	cfg.Set("bravo", 5*time.Second)
	cfg.Set("charlie", "4711ms")

	// Successful gets.
	value, err := cfg.GetDuration("alpha")
	assert.Nil(err, "No error.")
	assert.Equal(value, 0*time.Second, "Right value 'alpha' returned.")
	value, err = cfg.GetDuration("bravo")
	assert.Nil(err, "No error.")
	assert.Equal(value, 5*time.Second, "Right value 'bravo' returned.")
	value, err = cfg.GetDuration("charlie")
	assert.Nil(err, "No error.")
	assert.Equal(value, 4711*time.Millisecond, "Right value 'charlie' returned.")

	// Illegal format.
	cfg.Set("illegal-format", true)
	_, err = cfg.GetDuration("illegal-format")
	assert.ErrorMatch(err, `invalid type "duration" for "true" (.*)`, "Right error returned.")

	// Non-existing key.
	_, err = cfg.GetDuration("non-existing-key")
	assert.ErrorMatch(err, `key "non-existing-key" does not exist`, "Right error returned.")

	// Non-existing key with default.
	value, err = cfg.GetDurationDefault("non-existing-key", 5*time.Hour)
	assert.Nil(err, "No error.")
	assert.Equal(value, 5*time.Hour, "Right value 'non-existing-key' returned.")
}

// TestFloat64 tests float64 values.
func TestFloat64(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	provider := config.NewMapConfigurationProvider()
	cfg := config.New(provider)

	cfg.Set("alpha", 4711)
	cfg.Set("bravo", -47.11)
	cfg.Set("charlie", 0.0)

	// Successful gets.
	value, err := cfg.GetFloat64("alpha")
	assert.Nil(err, "No error.")
	assert.Equal(value, float64(4711), "Right value 'alpha' returned.")
	value, err = cfg.GetFloat64("bravo")
	assert.Nil(err, "No error.")
	assert.Equal(value, float64(-47.11), "Right value 'bravo' returned.")
	value, err = cfg.GetFloat64("charlie")
	assert.Nil(err, "No error.")
	assert.Equal(value, float64(0), "Right value 'charlie' returned.")

	// Illegal format.
	cfg.Set("illegal-format", true)
	_, err = cfg.GetFloat64("illegal-format")
	assert.ErrorMatch(err, `invalid type "float64" for "true" (.*)`, "Right error returned.")

	// Non-existing key.
	_, err = cfg.GetFloat64("non-existing-key")
	assert.ErrorMatch(err, `key "non-existing-key" does not exist`, "Right error returned.")

	// Non-existing key with default.
	value, err = cfg.GetFloat64Default("non-existing-key", 47.11)
	assert.Nil(err, "No error.")
	assert.Equal(value, float64(47.11), "Right value 'non-existing-key' returned.")
}

// Test negative reading.
func TestSMLNegativeReading(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	sml := "{Foo {bar:1 Yadda {test} {} 1} {bar:2 Yadda 2}}"
	builder := markup.NewNodeBuilder()
	err := markup.ReadSML(strings.NewReader(sml), builder)
	assert.ErrorMatch(err, "invalid rune.*", "Invalid rune should be found.")
}

// TestIntList tests the usage of int lists.
func TestIntList(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	values := worm.Ints{1, 5, 6, 2, 5, 2, 9}
	i := worm.NewIntList(values)

	// Test length.
	assert.Length(i, 7, "correct length")

	// Tast retrieving the values.
	values = i.Values()
	assert.Length(values, 7, "correct length")
	assert.Equal(values, worm.Ints{1, 5, 6, 2, 5, 2, 9}, "values are right")

	// Tast retrieving the values sorted.
	values = i.SortedValues()
	assert.Length(values, 7, "correct length")
	assert.Equal(values, worm.Ints{1, 2, 2, 5, 5, 6, 9}, "values are right")

	// Test containing test.
	// assert.True(i.Contains(), "emtpy values are ok")
	// assert.True(i.Contains(6, 5), "values detected")
	// assert.False(i.Contains(1, 2, 7), "invalid values recognized")

	// Test appending more values.
	av := worm.Ints{2, 6, 1001, 1010, 1005}
	ai := i.Append(av)
	assert.Length(ai, i.Len()+5, "five more values in the new list")
}

func TestStripTags(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	in := "<p>The quick brown <b>fox</b> jumps over the lazy <em>dog</em>.</p>"
	out, err := net.StripTags(in, true, false)
	assert.Nil(err, "No error during stripping.")
	assert.Equal(out, "The quick brown fox jumps over the lazy dog .", "Tags have been removed.")

	in = "<p>The quick brown <b>fox</b> jumps over the lazy <em>dog.</p>"
	out, err = net.StripTags(in, true, false)
	assert.ErrorMatch(err, `XML syntax error on line 1.*`, "Error in document detected.")

	in = "<p>The quick brown <b>fox</b> jumps over the lazy <em>dog.</p>"
	out, err = net.StripTags(in, false, false)
	assert.Nil(err, "No error during stripping.")
	assert.Equal(out, "The quick brown fox jumps over the lazy dog.", "Tags have been removed.")

	in = "<p>The quick brown <b>fox &amp; goose</b> jump over the lazy &lt;em&gt;dog&lt;/em&gt;.</p>"
	out, err = net.StripTags(in, true, false)
	assert.Nil(err, "No error during stripping.")
	assert.Equal(out, "The quick brown fox & goose jump over the lazy <em>dog</em>.", "Tags have been removed.")

	in = "<p>The quick brown <b>fox &amp;amp; goose</b> jump over the lazy &lt;em&gt;dog&lt;/em&gt;.</p>"
	out, err = net.StripTags(in, true, true)
	assert.Nil(err, "No error during stripping.")
	assert.Equal(out, "The quick brown fox & goose jump over the lazy dog .", "Tags have been removed.")
}

// Test encoding and decoding a doc.
func TestEncodeDecode(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	a1 := &atom.Feed{
		XMLNS:   atom.XMLNS,
		Id:      "http://tideland.biz/pkg/net/atom",
		Title:   &atom.Text{"Test Encode/Decode", "", "text"},
		Updated: atom.ComposeTime(time.Now()),
		Entries: []*atom.Entry{
			{
				Id:      "http://tideland.bi/pkg/net/atom/entry-1",
				Title:   &atom.Text{"Entry 1", "", "text"},
				Updated: atom.ComposeTime(time.Now()),
			},
			{
				Id:      "http://tideland.bi/pkg/net/atom/entry-2",
				Title:   &atom.Text{"Entry 2", "", "text"},
				Updated: atom.ComposeTime(time.Now()),
			},
		},
	}
	b := &bytes.Buffer{}

	err := atom.Encode(b, a1)
	assert.Nil(err, "Encoding returns no error.")
	assert.Substring(b.String(), `<title type="text">Test Encode/Decode</title>`, "Title has been encoded correctly.")

	a2, err := atom.Decode(b)
	assert.Nil(err, "Decoding returns no error.")
	assert.Equal(a2.Title.Text, "Test Encode/Decode", "Title has been decoded correctly.")
	assert.Length(a2.Entries, 2, "Decoded feed has the right number of items.")
}

// TestCounterBehavior tests the counting of events
// by the counter behavior.
func TestCounterBehavior(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	cf := func(e Event) []string {
		return []string{e.Topic()}
	}
	env := NewEnvironment("counter-behavior")
	env.AddCell("counter", NewCounterBehaviorFactory(cf))
	env.AddCell("collector", CollectorBehaviorFactory)

	env.Subscribe("counter", "collector")

	env.EmitSimple("counter", "a", true)
	env.EmitSimple("counter", "b", true)
	env.EmitSimple("counter", "c", true)
	env.EmitSimple("counter", "a", true)

	time.Sleep(100 * time.Millisecond)

	b, _ := env.CellBehavior("collector")
	collector := b.(EventCollector)
	events := collector.Events()

	assert.Equal(events[0].Payload().(int64), int64(1), "First result is ok.")
	assert.Equal(events[1].Payload().(int64), int64(1), "Second result is ok.")
	assert.Equal(events[2].Payload().(int64), int64(1), "Third result is ok.")
	assert.Equal(events[3].Payload().(int64), int64(2), "Fourth result is ok.")
}

// TestFilterBehavior tests the filtering of events by the
// filter behavior.
func TestFilterBehavior(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	ff := func(e Event) bool {
		if strings.Contains(e.Topic(), "yes") {
			return true
		}
		return false
	}
	env := NewEnvironment("filter-behavior")
	env.AddCell("filter", NewFilteredBroadcastBehaviorFactory(ff))
	env.AddCell("collector", CollectorBehaviorFactory)

	env.Subscribe("filter", "collector")

	env.EmitSimple("filter", "yes", true)
	env.EmitSimple("filter", "no", true)
	env.EmitSimple("filter", "yes", true)

	time.Sleep(100 * time.Millisecond)

	b, _ := env.CellBehavior("collector")
	collector := b.(EventCollector)
	events := collector.Events()

	assert.Length(events, 2, "All events received")
}

func TestUiRPC(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	// Create the UI to test
	ui := new(testUi)

	// Start the RPC server
	server := rpc.NewServer()
	RegisterUi(server, ui)
	address := serveSingleConn(server)

	// Create the client over RPC and run some methods to verify it works
	client, err := rpc.Dial("tcp", address)
	if err != nil {
		panic(err)
	}

	uiClient := &Ui{client}

	// Basic error and say tests
	result, err := uiClient.Ask("query")
	assert.Nil(err, "should not error")
	assert.True(ui.askCalled, "ask should be called")
	assert.Equal(ui.askQuery, "query", "should be correct")
	assert.Equal(result, "foo", "should have correct result")

	uiClient.Error("message")
	assert.Equal(ui.errorMessage, "message", "message should be correct")

	uiClient.Message("message")
	assert.Equal(ui.messageMessage, "message", "message should be correct")

	uiClient.Say("message")
	assert.Equal(ui.sayMessage, "message", "message should be correct")
}

// TestSimple tests simple value retrieved as string.
func TestSimple(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	provider := config.NewMapConfigurationProvider()
	cfg := config.New(provider)

	cfg.Set("alpha", "quick brown fox")
	cfg.Set("bravo", true)
	cfg.Set("charlie", 4711)
	cfg.Set("delta", 47.11)

	// Successful gets.
	value, err := cfg.Get("alpha")
	assert.Nil(err, "No error.")
	assert.Equal(value, "quick brown fox", "Right value 'alpha' returned.")
	value, err = cfg.Get("bravo")
	assert.Nil(err, "No error.")
	assert.Equal(value, "true", "Right value 'bravo' returned.")
	value, err = cfg.Get("charlie")
	assert.Nil(err, "No error.")
	assert.Equal(value, "4711", "Right value 'charlie' returned.")
	value, err = cfg.Get("delta")
	assert.Nil(err, "No error.")
	assert.Equal(value, "47.11", "Right value 'delta' returned.")

	// Non-existing key.
	_, err = cfg.Get("non-existing-key")
	assert.ErrorMatch(err, `key "non-existing-key" does not exist`, "Right error returned.")

	// Non-existing key with default.
	value, err = cfg.GetDefault("non-existing-key", "default value")
	assert.Nil(err, "No error.")
	assert.Equal(value, "default value", "Right value 'non-existing-key' returned.")
}

// TestChildSupervisor tests a supervisor as a child.
func TestChildSupervisor(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	sup := supervisor.NewSupervisor("parent", supervisor.OneForAll, 3, time.Second)
	chsup, _ := sup.Supervisor("child", supervisor.OneForOne, 5, time.Second)
	st := newStarts()
	childA := func(h *supervisor.Handle) error { return methodChild(h, st) }
	childB := func(h *supervisor.Handle) error { return panicChild(h, st, shortWait) }

	sup.Go("alpha", childA)
	sup.Go("beta", childA)

	chsup.Go("gamma", childA)
	chsup.Go("delta", childA)
	chsup.Go("epsilon", childB)

	time.Sleep(2 * time.Second)

	err := sup.Stop()
	assert.Nil(err, "stopping parent of 'child-supervisor'")
	assert.Equal(st.count("alpha"), 4, "starts of 'alpha'")
	assert.Equal(st.count("beta"), 4, "starts of 'beta'")
	assert.Equal(st.count("gamma"), 4, "starts of 'gamma'")
	assert.Equal(st.count("delta"), 4, "starts of 'delta'")
	assert.True(st.count("epsilon") > 1, "starts of 'epsilon'")
}

// TestTime tests time.Time values.
func TestTime(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	provider := config.NewMapConfigurationProvider()
	cfg := config.New(provider)
	now := time.Now()
	later := now.Add(12 * time.Hour)
	earlier := now.Add(-12 * time.Hour)

	cfg.Set("alpha", now)
	cfg.Set("bravo", later)

	// Successful gets.
	value, err := cfg.GetTime("alpha")
	assert.Nil(err, "No error.")
	assert.Equal(value, now, "Right value 'alpha' returned.")
	value, err = cfg.GetTime("bravo")
	assert.Nil(err, "No error.")
	assert.Equal(value, later, "Right value 'bravo' returned.")

	// Illegal format.
	cfg.Set("illegal-format", true)
	_, err = cfg.GetTime("illegal-format")
	assert.ErrorMatch(err, `invalid type "time" for "true" (.*)`, "Right error returned.")

	// Non-existing key.
	_, err = cfg.GetTime("non-existing-key")
	assert.ErrorMatch(err, `key "non-existing-key" does not exist`, "Right error returned.")

	// Non-existing key with default.
	value, err = cfg.GetTimeDefault("non-existing-key", earlier)
	assert.Nil(err, "No error.")
	assert.Equal(value, earlier, "Right value 'non-existing-key' returned.")
}

func TestNewEnvironment_NoConfig(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	env, err := NewEnvironment(nil)
	assert.Nil(env, "env should be nil")
	assert.NotNil(err, "should be an error")
}

func TestBuildRPC(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)

	// Create the interface to test
	b := new(testBuild)

	// Start the server
	server := rpc.NewServer()
	RegisterBuild(server, b)
	address := serveSingleConn(server)

	// Create the client over RPC and run some methods to verify it works
	client, err := rpc.Dial("tcp", address)
	assert.Nil(err, "should be able to connect")
	bClient := Build(client)

	// Test Name
	bClient.Name()
	assert.True(b.nameCalled, "name should be called")

	// Test Prepare
	bClient.Prepare()
	assert.True(b.prepareCalled, "prepare should be called")

	// Test Run
	cache := new(testCache)
	ui := new(testUi)
	artifacts, err := bClient.Run(ui, cache)
	assert.True(b.runCalled, "run should be called")
	assert.Nil(err, "should not error")
	assert.Equal(len(artifacts), 1, "should have one artifact")
	assert.Equal(artifacts[0].BuilderId(), "bid", "should have proper builder id")

	// Test the UI given to run, which should be fully functional
	if b.runCalled {
		b.runCache.Lock("foo")
		assert.True(cache.lockCalled, "lock should be called")

		b.runUi.Say("format")
		assert.True(ui.sayCalled, "say should be called")
		assert.Equal(ui.sayMessage, "format", "message should be correct")
	}

	// Test run with an error
	b.errRunResult = true
	_, err = bClient.Run(ui, cache)
	assert.NotNil(err, "should not nil")

	// Test SetDebug
	bClient.SetDebug(true)
	assert.True(b.setDebugCalled, "should be called")

	// Test SetForce
	bClient.SetForce(true)
	assert.True(b.setForceCalled, "should be called")

	// Test Cancel
	bClient.Cancel()
	assert.True(b.cancelCalled, "cancel should be called")
}

// Test time containments.
func TestTimeContainments(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	// Create some test data.
	ts := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
	years := []int{2008, 2009, 2010}
	months := []time.Month{10, 11, 12}
	days := []int{10, 11, 12, 13, 14}
	hours := []int{20, 21, 22, 23}
	minutes := []int{0, 5, 10, 15, 20, 25}
	seconds := []int{0, 15, 30, 45}
	weekdays := []time.Weekday{time.Monday, time.Tuesday, time.Wednesday}

	assert.True(YearInList(ts, years), "Go time in year list.")
	assert.True(YearInRange(ts, 2005, 2015), "Go time in year range.")
	assert.True(MonthInList(ts, months), "Go time in month list.")
	assert.True(MonthInRange(ts, 7, 12), "Go time in month range.")
	assert.True(DayInList(ts, days), "Go time in day list.")
	assert.True(DayInRange(ts, 5, 15), "Go time in day range .")
	assert.True(HourInList(ts, hours), "Go time in hour list.")
	assert.True(HourInRange(ts, 20, 31), "Go time in hour range .")
	assert.True(MinuteInList(ts, minutes), "Go time in minute list.")
	assert.True(MinuteInRange(ts, 0, 5), "Go time in minute range .")
	assert.True(SecondInList(ts, seconds), "Go time in second list.")
	assert.True(SecondInRange(ts, 0, 5), "Go time in second range .")
	assert.True(WeekdayInList(ts, weekdays), "Go time in weekday list.")
	assert.True(WeekdayInRange(ts, time.Monday, time.Friday), "Go time in weekday range .")
}