Golang wcg.NewAssert函数代码示例

func TestObjectValidation(t *testing.T) {
	type TestObject struct {
		Str1 string
		Str2 string
	}
	assert := wcg.NewAssert(t)
	obj := &TestObject{}
	v := NewObjectValidator()
	v.Func(func(v interface{}) *FieldValidationError {
		obj := v.(*TestObject)
		if obj.Str1 == obj.Str2 {
			return NewFieldValidationError(
				"Same!!", nil,
			)
		}
		return nil
	})

	obj.Str1 = "foo"
	obj.Str2 = "foo"
	result := v.Eval(obj).(*ValidationError)
	assert.NotNil(result.Errors["."], "ValidationError should claims on 'Str'")
	assert.EqStr("Same!!", result.Errors["."][0].String(), "ValidationError Error message")

	obj.Str2 = "bar"
	assert.Nil(v.Eval(obj), "Eval(obj) should return nil when validation passed.")
}

func TestRecorderStart_CancelBeforeStart(t *testing.T) {
	assert := wcg.NewAssert(t)
	receiver := make(chan []Record)
	recorder := NewRecorder((<-chan []Record)(receiver))

	interval := time.Duration(30) * time.Millisecond
	wait := 10
	go recorder.Start(interval)

	now := time.Now()
	r1 := NewDummyRecord("r1") // cancel before starting
	r1.startAt = now.Add(time.Duration(30 * time.Minute))
	r1.endAt = now.Add(time.Duration(60 * time.Minute))
	// r2 := NewDummyRecord("r2") // cancel after starting
	// r3 := NewDummyRecord("r3") // succeeded
	// r4 := NewDummyRecord("r4") // failed

	receiver <- []Record{r1}
	err := util.WaitFor(func() bool {
		return len(recorder.controls) == 1
	}, wait)
	assert.Nil(err, "check r1 in controls.")
	assert.EqStr(r1.Key(), recorder.controls[r1.Key()].record.Key(), "check r1 in controls.")

	receiver <- []Record{}
	err = util.WaitFor(func() bool {
		return len(recorder.controls) == 0
	}, wait)
	assert.Nil(err, "check r1 removed from controls.")

	recorder.Stop()
}

func TestRecordValidator(t *testing.T) {
	var err error
	assert := wcg.NewAssert(t)
	r := genTestRecord()

	r.Title = ""
	err = RecordValidator.Eval(r)
	assert.NotNil(err, "Empty Title Error")

	r.Title = "../foo"
	err = RecordValidator.Eval(r)
	assert.NotNil(err, "Special Character Validation")

	r.Title = "NormalTitle"
	err = RecordValidator.Eval(r)
	assert.Nil(err, "Normal Character Validation")

	r.Title = "日本語はつかえる"
	err = RecordValidator.Eval(r)
	assert.Nil(err, "日本語 Validation")

	r.Title = "モーニング娘。"
	err = RecordValidator.Eval(r)
	assert.Nil(err, "日本語 特殊文字 Valiation")
}

func TestRecorderStart(t *testing.T) {
	assert := wcg.NewAssert(t)
	receiver := make(chan []Record)
	recorder := NewRecorder((<-chan []Record)(receiver))

	interval := time.Duration(30) * time.Millisecond
	wait := 10
	go recorder.Start(interval)

	now := time.Now()
	r1 := NewDummyRecord("r1") // cancel before starting
	r1.startAt = now
	r1.endAt = now.Add(time.Duration(5 * time.Second))
	receiver <- []Record{r1}
	err := util.WaitFor(func() bool {
		return len(recorder.controls) == 1
	}, wait)
	assert.Nil(err, "check r1 in controls.")
	ctrl := recorder.controls[r1.Key()]

	err = util.WaitFor(func() bool {
		return r1.done == true
	}, wait)
	assert.Nil(err, "check r1 has been done.")
	assert.EqInt(int(RSSucceeded), int(ctrl.state), "Record state should be RSSucceeded")
	recorder.Stop()
}

func TestPt1Record_Start(t *testing.T) {
	assert := wcg.NewAssert(t)
	now := time.Now()

	tvrecord := models.NewTvRecord(
		"Title",
		"Category",
		now,
		now.Add(time.Duration(5)*time.Second),
		"cid",
		"sid",
		"uid",
	)
	util.WithTempDir(func(dir string) {
		record := NewPt1Record(tvrecord, genPt1Config(dir))
		err := record.Start()
		assert.Nil(err, "Pt1Record started.")
		time.Sleep(1 * time.Second)
		assert.Ok(record.IsRunning(), "Pt1Record is running.")

		err = record.Stop()
		assert.Nil(err, "Stop record.")

		err = util.WaitFor(func() bool {
			return record.IsRunning() == false
		}, 10)
		assert.Nil(err, "Pt1Record has stopped.")

		content, _ := ioutil.ReadFile(record.filepath)
		lines := bytes.Split(content, []byte("\n"))
		assert.EqStr("OK", string(lines[len(lines)-1]), "Check the mock record content.")
	})
}

func TestGetIEpgList(t *testing.T) {
	assert := wcg.NewAssert(t)
	client := NewCrawler(http.DefaultClient)
	list, err := client.GetIEpgList("今井絵理子", FEED_SCOPE_ALL)
	assert.Nil(err, "GetIEpgList should not return an error.")
	assert.NotNil(list, "GetIEpgList should return list of ids")
}

func TestChannel_AddAndDelCrawlerConfig(t *testing.T) {
	test.RunTestServer(func(ts *test.TestServer) {
		assert := wcg.NewAssert(t)

		// prepare
		d := NewCrawlerConfigDriver(TEST_APP_KEY, ts.Context, wcg.NewLogger(nil))
		d.Add(&tv.CrawlerConfig{
			Keyword:  "キーワード1",
			Category: "カテゴリー1",
			Scope:    1,
		})
		d.Add(&tv.CrawlerConfig{
			Keyword:  "キーワード2",
			Category: "カテゴリー2",
			Scope:    1,
		})

		err := util.WaitFor(func() bool {
			c, _ := d.NewQuery().Count()
			return c == 2
		}, util.DefaultWaitForTimeout)
		assert.Nil(err, "Confirm CrawlerConfig entities has been stored within a timeout window.")

		d.Delete("キーワード1")
		err = util.WaitFor(func() bool {
			c, _ := d.NewQuery().Count()
			return c == 1
		}, util.DefaultWaitForTimeout)
		assert.Nil(err, "Confirm CrawlerConfig entities has been deleted within a timeout window.")

		err = d.Delete("Not Exists")
		assert.Nil(err, "Delete should not return even trying to delete the unexising keyword.")
	})
}

func TestIOLogSinkFormat(t *testing.T) {
	assert := wcg.NewAssert(t)
	record := NewTestRecord()
	storage := NewTestLogStorage()
	s := NewIOLogSink("", storage)
	s.Write(record)
	assert.NotZero(len(storage.GetLines()), "sink.Write should write a log record")
	line := storage.GetLines()[0]
	expect := "1984/09/22 12:01:28 +0000 [TRACE] [1|user1|session1|request1] This is a test (sourec.go#1)"
	assert.EqStr(expect, line, "LogRecord format")

	// custom format
	storage = NewTestLogStorage()
	s = NewIOLogSink("$TIMESTAMP $INVALIDVAR $TEXT", storage)
	s.Write(record)
	assert.NotZero(len(storage.GetLines()), "sink.Write should write a log record")

	line = storage.GetLines()[0]
	expect = "1984/09/22 12:01:28 +0000  This is a test"
	assert.EqStr(expect, line, "LogRecord format")

	// Data record case.
	storage = NewTestLogStorage()
	s = NewIOLogSink("", storage)
	record.Data = wcg.DataBag{}
	s.Write(record)
	assert.Zero(len(storage.GetLines()), "sink.Write should not write anything if the record has DataBag")
}

func TestRecorderUpcomming(t *testing.T) {
	assert := wcg.NewAssert(t)
	receiver := make(chan []Record)
	recorder := NewRecorder((<-chan []Record)(receiver))
	interval := time.Duration(30) * time.Millisecond
	wait := 10
	go recorder.Start(interval)

	r1 := NewDummyRecord("r1")
	r1.startAt = time.Now().Add(time.Duration(2 * time.Hour))
	r1.endAt = r1.startAt.Add(time.Duration(10 * time.Minute))
	r2 := NewDummyRecord("r2")
	r2.startAt = time.Now().Add(time.Duration(4 * time.Hour))
	r2.endAt = r2.startAt.Add(time.Duration(10 * time.Minute))
	r3 := NewDummyRecord("r3")
	r3.startAt = time.Now().Add(time.Duration(8 * time.Hour))
	r3.endAt = r3.startAt.Add(time.Duration(10 * time.Minute))

	receiver <- []Record{r1, r2, r3}
	err := util.WaitFor(func() bool {
		return len(recorder.controls) == 3
	}, wait)
	assert.Nil(err, "check all records in controls.")

	upcome := recorder.Upcomming()
	assert.Ok(r1.startAt.Equal(upcome), "Upcomming should be r2")
	recorder.Stop()
}

func TestRecorderStart_CancelWhileRecording(t *testing.T) {
	assert := wcg.NewAssert(t)
	receiver := make(chan []Record)
	recorder := NewRecorder((<-chan []Record)(receiver))
	interval := time.Duration(30) * time.Millisecond
	wait := 5

	go recorder.Start(interval)

	now := time.Now()
	r1 := NewDummyRecord("r1") // cancel before starting
	r1.startAt = now
	r1.endAt = now.Add(time.Duration(30 * time.Minute))

	receiver <- []Record{r1}
	err := util.WaitFor(func() bool {
		return len(recorder.controls) == 1
	}, wait)
	assert.Nil(err, "check r1 in controls.")
	assert.EqStr(r1.Key(), recorder.controls[r1.Key()].record.Key(), "check r1 in controls.")

	err = util.WaitFor(func() bool {
		return recorder.controls[r1.Key()].state == RSRecording
	}, wait)
	assert.Nil(err, "check r1 in RSRecording state.")

	receiver <- []Record{}
	err = util.WaitFor(func() bool {
		return len(recorder.controls) == 0
	}, wait)
	assert.Nil(err, "check r1 removed from controls.")

	recorder.Stop()
}

func Test_parseAuctionApiResult(t *testing.T) {
	assert := wcg.NewAssert(t)

	file, _ := os.Open("./auction-sample.xml")
	defer file.Close()
	auction, err := parseAuctionApiResult(file)
	assert.Nil(err, "parseAuctionApiResult should not return an error")
	assert.EqStr("h206483716", auction.Id, "Id")
	assert.EqStr("9/20 モーニング娘。15 座間 秋ツアー 夜公演 一般席 即決特典付", auction.Title, "Title")
	assert.EqStr("http://page8.auctions.yahoo.co.jp/jp/auction/h206483716", auction.Url, "Url")
	assert.EqStr("", auction.ImageUrl, "ImageUrl")
	assert.EqStr("gaba9tmcy2gam0", auction.Seller, "Seller")
	assert.EqFloat32(9000.0, auction.InitPrice, "InitPrice")
	assert.EqFloat32(9500.0, auction.CurrentPrice, "CurrentPrice")
	assert.EqFloat32(13000.0, auction.BidOrBuy, "BidOrBuy")
	assert.EqFloat32(13000.0, auction.BidOrBuy, "BidOrBuy")
	assert.EqInt(1, auction.Quantity, "Quantity")
	assert.EqInt(3, auction.Bids, "Bids")
	assert.EqTime(
		wcg.Must(time.Parse(time.RFC3339, "2015-08-30T20:27:57+09:00")).(time.Time),
		auction.StartAt,
		"StartAt",
	)
	assert.EqTime(
		wcg.Must(time.Parse(time.RFC3339, "2015-08-31T23:27:57+09:00")).(time.Time),
		auction.EndAt,
		"EndAt",
	)
	assert.Ok(
		STATUS_CLOSED == auction.Status,
		"Closed",
	)
}

func TestTwitterClient_Stream(t *testing.T) {
	assert := wcg.NewAssert(t)
	NUM_TWEETS_IN_STREAM := 5
	httptest.StartMockServer("./dummy", func(ms *httptest.MockServer) {
		ms.Routes().Get("/1.1/statuses/filter.json", func(res *wcg.Response, req *wcg.Request) {
			data, _ := json.Marshal(map[string]interface{}{
				"id_str":     "123",
				"text":       "test text",
				"created_at": "Thu Sep 24 13:26:59 +0000 2015",
			})
			for i := 0; i < NUM_TWEETS_IN_STREAM; i++ {
				res.WriteString(string(data) + "\r\n")
				res.WriteString("\r\n") // send empty (optional)
				res.Flush()
				time.Sleep(10 * time.Millisecond)
			}
			res.Close()
		})
		client := NewTwitterClient("", "", nil)
		client.StreamingEndpoint = ms.BaseUrl()
		client.Token = BearerToken("TestToken")
		ts, err := client.Stream(&StreamingParams{})
		assert.Nil(err, "Stream should not return an error")

		var tweet *Tweet
		ch := ts.GetStreamChannel()
		num_received := 0
		for tweet = range ch {
			num_received += 1
		}
		assert.EqInt(NUM_TWEETS_IN_STREAM+1, num_received, "The number of tweets is incorrect.")
		assert.Nil(tweet, "The end of stream should be nil")
	})

}

func TestParseIEpg(t *testing.T) {
	assert := wcg.NewAssert(t)
	file, _ := os.Open("./iepg-sample.iepg")
	defer file.Close()
	iepg, err := ParseIEpg(file)
	assert.Nil(err, "ParseIEPG should not return an error")
	assert.EqStr("The　Girls　Live　▽道重さゆみ卒業ライブに密着▽LoVendoЯスタジオライブ", iepg.ProgramTitle, "ProgramTitle")
	assert.EqStr("テレビ東京", iepg.StationName, "StationName")
	assert.EqStr("DFS00430", iepg.StationId, "StationId")
	assert.EqInt(7852, iepg.ProgramId, "ProgramId")
	assert.EqInt(2014, iepg.StartAt.Year(), "StartAt.Year")
	assert.EqInt(12, int(iepg.StartAt.Month()), "StartAt.Date")
	assert.EqInt(5, iepg.StartAt.Day(), "StartAt.Date")
	assert.EqInt(1, iepg.StartAt.Hour(), "StartAt.Hour")
	assert.EqInt(0, iepg.StartAt.Minute(), "StartAt.Mininute")
	zone, _ := iepg.StartAt.Zone()
	assert.EqStr("JST", zone, "StartAt.Zone")

	assert.EqInt(2014, iepg.EndAt.Year(), "EndAt.Year")
	assert.EqInt(12, int(iepg.EndAt.Month()), "EndAt.Date")
	assert.EqInt(5, iepg.EndAt.Day(), "EndAt.Date")
	assert.EqInt(1, iepg.EndAt.Hour(), "EndAt.Hour")
	assert.EqInt(30, iepg.EndAt.Minute(), "EndAt.Mininute")
	zone, _ = iepg.EndAt.Zone()
	assert.EqStr("JST", zone, "EndAt.Zone")

}

func TestMax(t *testing.T) {
	type TestObject struct {
		Str   string
		Int   int
		Float float32
		Array []string
	}
	assert := wcg.NewAssert(t)
	obj := &TestObject{}
	v := NewObjectValidator()
	v.Field("Str").Max(1)
	v.Field("Int").Max(1)
	v.Field("Float").Max(1)
	v.Field("Array").Max(1)

	obj.Str = "Foo"
	obj.Int = 5
	obj.Float = 5
	obj.Array = []string{"a", "b", "c", "d"}
	result := v.Eval(obj).(*ValidationError)
	assert.NotNil(result.Errors["Str"], "ValidationError should claims on 'Str'")
	assert.NotNil(result.Errors["Int"], "ValidationError should claims on 'Int'")
	assert.NotNil(result.Errors["Float"], "ValidationError should claims on 'Float'")
	assert.NotNil(result.Errors["Array"], "ValidationError should claims on 'Arrau'")
	assert.EqStr("must be less than or equal to 1", result.Errors["Str"][0].String(), "ValidationError Error message")
	assert.EqStr("must be less than or equal to 1", result.Errors["Int"][0].String(), "ValidationError Error message")
	assert.EqStr("must be less than or equal to 1", result.Errors["Float"][0].String(), "ValidationError Error message")
	assert.EqStr("must be less than or equal to 1", result.Errors["Array"][0].String(), "ValidationError Error message")

	obj.Str = "F"
	obj.Int = 1
	obj.Float = 1
	obj.Array = []string{"a"}
	assert.Nil(v.Eval(obj), "Eval(obj) should return nil when validation passed.")
}

func TestMatch(t *testing.T) {
	type TestObject struct {
		Str   string
		Bytes []byte
	}
	assert := wcg.NewAssert(t)
	obj := &TestObject{}
	v := NewObjectValidator()
	v.Field("Str").Match("a+")
	v.Field("Bytes").Match("a+")
	result := v.Eval(obj).(*ValidationError)
	assert.NotNil(result.Errors["Str"], "ValidationError should claims on 'Str'")
	assert.NotNil(result.Errors["Bytes"], "ValidationError should claims on 'Bytes'")
	assert.EqStr("not match with 'a+'", result.Errors["Str"][0].String(), "ValidationError Error message")
	assert.EqStr("not match with 'a+'", result.Errors["Bytes"][0].String(), "ValidationError Error message")

	obj.Str = "bbb"
	obj.Bytes = []byte(obj.Str)
	result = v.Eval(obj).(*ValidationError)
	assert.NotNil(result, "Eval(obj) should return ValidationError")
	assert.NotNil(result.Errors["Str"], "ValidationError should claims on 'Str'")
	assert.NotNil(result.Errors["Bytes"], "ValidationError should claims on 'Bytes'")
	assert.EqStr("not match with 'a+'", result.Errors["Str"][0].String(), "ValidationError Error message")
	assert.EqStr("not match with 'a+'", result.Errors["Bytes"][0].String(), "ValidationError Error message")

	obj.Str = "aaa"
	obj.Bytes = []byte(obj.Str)
	assert.Nil(v.Eval(obj), "Eval(obj) should return nil when validation passed.")
}