func TestHostnamesInheritFromDefault(t *testing.T) {
	assert := assert.Assert(t)

	yml := loadFile("config_hostnames_inherit_from_default.yml")
	setting, err := kasi.ParseConfig(yml)
	assert.Equal(err, nil)

	assert.Equal(len(setting.Services), 1)
	assert.Equal(len(setting.Services[0].Hostnames), 2)

	for _, h := range []string{"my0.github.com", "my1.github.com"} {
		if sort.SearchStrings(setting.Services[0].Hostnames, h) == 2 {
			t.Error("failed to parse hostnames")
		}
	}

	ymlOverride := loadFile("config_hostnames_override_default.yml")
	setting, err = kasi.ParseConfig(ymlOverride)
	assert.Nil(err)

	assert.Equal(len(setting.Services), 1)
	assert.Equal(len(setting.Services[0].Hostnames), 1)

	for _, h := range []string{"my2.github.com"} {
		if sort.SearchStrings(setting.Services[0].Hostnames, h) == 2 {
			t.Error("failed to parse hostnames")
		}
	}
}
func TestEndpointsOpen(t *testing.T) {
	assert := assert.Assert(t)

	var yml string
	var setting *kasi_conf.CoreSetting
	var err error

	yml = loadFile("config_simple_endpoint0.yml")
	setting, err = kasi.ParseConfig(yml)
	assert.Nil(err)
	assert.Equal(len(setting.Services[0].Endpoints), 1)

	yml = loadFile("config_opened_endpoint.yml")
	setting, err = kasi.ParseConfig(yml)
	assert.Nil(err)
	assert.Equal(len(setting.Services[0].Endpoints), 1)

	yml = loadFile("config_closed_endpoint.yml")

	setting, err = kasi.ParseConfig(yml)
	assert.Nil(err)

	assert.False(setting.Services[0].Opened(), "")
	assert.Equal(len(setting.Services[0].Endpoints), 0)
}
func TestMiddleware(t *testing.T) {
	assert := assert.Assert(t)

	yml := loadFile("conf_middlewares.yml")
	setting, err := kasi.ParseConfig(yml)
	assert.Equal(err, nil)

	assert.Equal(len(setting.Middlewares), 2)
	service0, _ := setting.GetServiceByID("service0")
	assert.Equal(service0.Middleware, "base")
	service1, _ := setting.GetServiceByID("service1")
	assert.Equal(service1.Middleware, "extend")

	assert.Equal(len(service0.Endpoints[0].Middleware), 2)
	assert.Equal(service0.Endpoints[0].Middleware[0], "a.js")
	assert.Equal(service0.Endpoints[0].Middleware[1], "b.js")

	assert.Equal(len(service0.Endpoints[0].Middleware), 2)
	assert.Nil(service0.Endpoints[1].Middleware)

	assert.Equal(len(service1.Endpoints[0].Middleware), 2)
	assert.Equal(service1.Endpoints[0].Middleware[0], "a.js")
	assert.Equal(service1.Endpoints[0].Middleware[1], "b.js")

	assert.Equal(len(service1.Endpoints[1].Middleware), 2)
	assert.Equal(service1.Endpoints[1].Middleware[0], "c.js")
	assert.Equal(service1.Endpoints[1].Middleware[1], "d.js")
}
Exemple #4
0
func TestServices(t *testing.T) {
	assert := assert.Assert(t)
	services := new(Services)
	assert.Equal(len(services.Services), 0)

	// Addition
	services.Add(Service{Name: "google.com", Password: "******", Meta: "Personal"})
	assert.Equal(len(services.Services), 1)
	assert.Equal(services.Services[0].Name, "google.com")

	// replacement
	services.Add(Service{Name: "google.com", Password: "******"})
	assert.Equal(len(services.Services), 1)
	assert.Equal(services.Services[0].Password, "lkjpoiu")

	// Addition
	services.Add(Service{Name: "facebook.com", Password: "******"})
	assert.Equal(len(services.Services), 2)

	// another replacement
	services.Add(Service{Name: "google.com", Password: "******"})
	assert.Equal(services.Get("google.com").Password, "asghasd")
	assert.Equal(len(services.Services), 2)

	services.Add(Service{Name: "golang.org"})
	goServices := services.Search("go")
	assert.Equal(len(goServices), 2)
	assert.True(goServices[0].Name[:2] == "go", "Service 0 begins with go")
	assert.True(goServices[1].Name[:2] == "go", "Service 1 begins with go")
	assert.Equal(len(services.Search("*")), 3)
}
Exemple #5
0
func TestJoinURL(t *testing.T) {
	assert := assert.Assert(t)

	var base, target string

	// 2 FQDN url
	base = "http://a0.com/b0/c0.html"
	target = "http://a1.com/b1/c1.html"
	assert.Equal(joinURL(base, target), target)

	// 1 FQDN and 1 path
	base = "http://a0.com/b0/c0.html"
	target = "/b1/c1.html"
	assert.Equal(joinURL(base, target), "http://a0.com"+target)

	// 1 invalid url and 1 valid url
	base = "****************\\*"
	target = "/b1/c1.html"
	assert.Equal(joinURL(base, target), target)

	// 2 path, but one is relative
	base = "/b0/c0.html"
	target = "b1/c1.html"
	assert.Equal(joinURL(base, target), base+"/"+target)

	// merge querystring
	base = "/b0/c0.html?a=1&b=2"
	target = "b1/c1.html?a=3"
	assert.Equal(joinURL(base, target), "/b0/c0.html/b1/c1.html?a=3&b=2")
}
Exemple #6
0
func TestParseTimeUnit(t *testing.T) {
	assert := assert.Assert(t)

	cases := []struct {
		in   string
		want time.Duration
	}{
		{"10", time.Nanosecond * 10},
		{"100000", time.Nanosecond * 100 * 1000},
		{"1s", time.Second * 1},
		{"2s", time.Second * 2},
		{"3m", time.Minute * 3},
		{"4h", time.Hour * 4},
		{"5d", time.Hour * 24 * 5},
		{"6M", time.Hour * 24 * 30 * 6},
		{"7y", time.Hour * 24 * 365 * 7},
	}
	for _, c := range cases {
		assert.Equal(
			func() time.Duration {
				p, err := parseTimeUnit(c.in)
				assert.Nil(err)
				return p
			}(),
			c.want,
		)
	}
}
Exemple #7
0
func Test_ConnectCounter(t *testing.T) {
	assert := assert.Assert(t)
	cc := new(ConnectCounter)
	assert.False(cc.incr(true), "f1")
	assert.False(cc.incr(true), "f2")
	assert.False(cc.incr(true), "f3")
	assert.True(cc.incr(true), "t")
}
Exemple #8
0
func TestPasswordGenerationWithWords(t *testing.T) {
	assert := assert.Assert(t)
	generator := NewPasswordGenerator("w24")
	assert.Equal(generator.length, 24)
	assert.Equal(generator.words, true)
	password := generator.generate()
	assert.True(len(password) >= 24, "length")
}
Exemple #9
0
func TestBoard_turn_switches_after_each_play(t *testing.T) {
	assert := assert.Assert(t)
	g := NewGame()
	assert.Equal(g.Turn(), byte(1))
	g.Play(1)
	assert.Equal(g.Turn(), byte(2))
	g.Play(1)
	assert.Equal(g.Turn(), byte(1))
}
Exemple #10
0
func TestDuplicatedID(t *testing.T) {
	assert := assert.Assert(t)

	var yml string
	var err error

	yml = loadFile("config_duplicated_id.yml")
	_, err = kasi.ParseConfig(yml)
	assert.NotNil(err)
}
Exemple #11
0
func Test_C4Game(t *testing.T) {
	assert := assert.Assert(t)
	game := GameWrapper{NewGame()}
	g := minimax.Game(game)
	assert.NotNil(g, "not nil")

	game1 := game.Copy()
	game1.Play(1)
	assert.NotEqual(game, game1)
}
Exemple #12
0
func Test_HasWonUtilityFunction_returns_1_when_won(t *testing.T) {
	assert := assert.Assert(t)
	game := NewGame()
	wrapper := GameWrapper{game}
	game.SetRows("1110000")
	assert.Equal(HasWon(wrapper), 0)
	hasWon, _ := game.Play(4) // now it's player 2's turn, but 1 won
	assert.True(hasWon, "should have won")
	assert.Equal(HasWon(wrapper), 1)
}
Exemple #13
0
func TestEnv(t *testing.T) {
	assert := assert.Assert(t)

	yml := loadFile("config_env.yml")
	setting, err := kasi.ParseConfig(yml)
	assert.Equal(err, nil)

	assert.NotEqual(setting.Env.Hostname, "")
	assert.NotEqual(setting.Env.GOOS, "")
}
Exemple #14
0
func TestPasswordGeneration(t *testing.T) {
	assert := assert.Assert(t)
	generator := NewPasswordGenerator("lunc20")
	assert.Equal(generator.length, 20)
	password := generator.generate()
	assert.Equal(len(password), 20)
	assert.True(strings.ContainsAny(password, LOWERCASE), "missing characters")
	assert.True(strings.ContainsAny(password, UPPERCASE), "missing characters")
	assert.True(strings.ContainsAny(password, NUMBERS), "missing characters")
	assert.True(strings.ContainsAny(password, CHARACTERS), "missing characters")
}
Exemple #15
0
func Test_Solve_avert_disaster(t *testing.T) {
	assert := assert.Assert(t)
	game := NewGame()
	game.SetRows(
		"2000000",
		"2000000",
		"1110000")
	game.turn = p2
	move := Solve(game, 2)
	assert.Equal(move, 4)
}
func TestHostnamesWithString(t *testing.T) {
	assert := assert.Assert(t)

	yml := loadFile("config_hostnames_string.yml")
	setting, err := kasi.ParseConfig(yml)
	assert.Nil(err)

	assert.Equal(len(setting.Services), 1)
	assert.Equal(len(setting.Services[0].Hostnames), 1)
	assert.Equal(setting.Services[0].Hostnames[0], "my0.github.com")
}
Exemple #17
0
func Test_Copy(t *testing.T) {
	assert := assert.Assert(t)
	g := NewGame()
	g.SetRows("1212000")
	g1 := g.Copy()
	g1.Play(5)
	assert.Equal(g.turn, p1)
	assert.Equal(g1.turn, p2)
	assert.Equal(g.board[0], []byte{1, 2, 1, 2, 0, 0, 0})
	assert.Equal(g1.board[0], []byte{1, 2, 1, 2, 1, 0, 0})
}
Exemple #18
0
func TestMinimax(t *testing.T) {
	assert := assert.Assert(t)
	//                     p1   [--p2--]  [------p1------]
	game := NewHeapGame(0, 0, 1, 0, 1, -1, 0, 0, 1, -1, 0, 1, 2, 0, 1)
	fmt.Println(game.utility)
	// best move: 1
	solver := &Solver{HeapUtilityFunction, 2}
	move, utility := solver.Solve(game)
	moveInt := move.(int)
	assert.Equal(moveInt, 1)
	assert.Equal(utility, 1)
}
Exemple #19
0
func Test_Play_returns_true_when_wins_left_diagonal(t *testing.T) {
	assert := assert.Assert(t)
	g := NewGame()

	g.SetRows(
		"0000000",
		"0001200",
		"0012200",
		"0121200")
	win, err := g.Play(5)
	assert.Nil(err, "error after player 1 played final piece")
	assert.True(win, "player 1 should have won")
}
Exemple #20
0
func Test_LegalMoves(t *testing.T) {
	assert := assert.Assert(t)
	g := NewGame()
	assert.Equal(g.LegalMoves(),
		[]int{1, 2, 3, 4, 5, 6, 7})

	for row := 0; row < ROWS/2; row++ {
		g.Play(1)
		g.Play(1)
		g.Play(4)
		g.Play(4)
	}
	assert.Equal(g.LegalMoves(),
		[]int{2, 3, 5, 6, 7})
}
Exemple #21
0
func Test_Play_returns_true_when_wins_in_row(t *testing.T) {
	assert := assert.Assert(t)
	g := NewGame()

	players := []int{1, 2}
	for i := 1; i < 4; i++ {
		for _, p := range players {
			won, err := g.Play(i)
			assert.False(won, "player %v should not have won", p)
			assert.Nil(err, "error after player %d played", p)
		}
	}
	won, err := g.Play(4)
	assert.Nil(err, "error when player 1 played final piece")
	assert.True(won, "player 1 should have won")
}
func TestHostnamesWithStrings(t *testing.T) {
	assert := assert.Assert(t)

	yml := loadFile("config_hostnames_strings.yml")
	setting, err := kasi.ParseConfig(yml)
	assert.Nil(err)

	assert.Equal(len(setting.Services), 1)
	assert.Equal(len(setting.Services[0].Hostnames), 2)

	for _, h := range []string{"my0.github.com", "my1.github.com"} {
		if sort.SearchStrings(setting.Services[0].Hostnames, h) == 2 {
			t.Error("failed to parse hostnames")
		}
	}
}
Exemple #23
0
func TestID(t *testing.T) {
	assert := assert.Assert(t)

	var yml string
	var setting *kasi_conf.CoreSetting
	var err error

	yml = loadFile("config_check_id.yml")
	setting, err = kasi.ParseConfig(yml)
	assert.Equal(err, nil)

	assert.Equal(setting.Services[0].GetID(), "this-is-service-id")
	assert.Equal(setting.Services[0].Endpoints[0].GetID(), "findme")
	assert.Equal(len(setting.Services[0].Endpoints[1].GetID()), 36)
	assert.Equal(setting.Services[0].Endpoints[1].GetID(), setting.Services[0].Endpoints[1].GetID())
}
Exemple #24
0
func TestBindInheritFromDefault(t *testing.T) {
	assert := assert.Assert(t)

	yml := loadFile("conf_default_bind.yml")

	setting, err := kasi.ParseConfig(yml)
	assert.Equal(err, nil)

	cases := map[string]*net.TCPAddr{
		"a.com": setting.GetDefaultSetting().Bind,
		"b.com": &net.TCPAddr{Port: 90},
	}

	for _, service := range setting.Services {
		assert.Equal(cases[service.Hostnames[0]], service.Bind)
	}
}
Exemple #25
0
func Test_Solve_aver_vertical_disaster(t *testing.T) {
	assert := assert.Assert(t)
	game := NewGame()
	game.SetRows(
		"1000000",
		"2010000",
		"2211000",
		"2211120")

	over, _ := game.Play(2)
	assert.False(over, "wtf")

	// game.turn = p2
	// move := SolveVerbose(game, 2)
	// assert.Equal(move, 3)

}
Exemple #26
0
func TestSetRows_sets_rows(t *testing.T) {
	assert := assert.Assert(t)
	g := NewGame()

	g.SetRows(
		"   1112",
		"  11212")

	expectedBoard := [][]byte{
		{0, 0, 1, 1, 2, 1, 2},
		{0, 0, 0, 1, 1, 1, 2},
		{0, 0, 0, 0, 0, 0, 0},
		{0, 0, 0, 0, 0, 0, 0},
		{0, 0, 0, 0, 0, 0, 0},
		{0, 0, 0, 0, 0, 0, 0}}

	assert.Equal(g.board, expectedBoard)
}
func TestTimeout(t *testing.T) {
	assert := assert.Assert(t)

	yml := loadFile("config_timeout.yml")
	setting, err := kasi.ParseConfig(yml)
	assert.Equal(err, nil)

	cases := map[string]time.Duration{
		"a.com": time.Second * 9,
		"b.com": time.Second * 0,
		"c.com": setting.GetDefaultSetting().Timeout,
		"d.com": setting.GetDefaultSetting().Timeout,
	}

	for _, service := range setting.Services {
		assert.Equal(service.Timeout, cases[service.Hostnames[0]])
	}
}
Exemple #28
0
func TestBind(t *testing.T) {
	assert := assert.Assert(t)

	yml := loadFile("config_multiple_bind.yml")

	setting, err := kasi.ParseConfig(yml)
	assert.Equal(err, nil)

	cases := map[string]*net.TCPAddr{
		"a.com": &net.TCPAddr{Port: 8000},
		"b.com": &net.TCPAddr{Port: 8000},
		"c.com": &net.TCPAddr{Port: 8000},
		"d.com": &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8000},
	}

	for _, service := range setting.Services {
		assert.Equal(cases[service.Hostnames[0]], service.Bind)
	}
}
func TestEndpoints(t *testing.T) {
	assert := assert.Assert(t)

	var yml string
	var setting *kasi_conf.CoreSetting
	var err error

	yml = loadFile("config_simple_endpoint0.yml")

	setting, err = kasi.ParseConfig(yml)
	assert.Nil(err)
	assert.Equal(len(setting.Services[0].Endpoints), 1)

	yml = loadFile("config_simple_endpoint1.yml")

	setting, err = kasi.ParseConfig(yml)
	assert.Nil(err)
	assert.Equal(len(setting.Services[0].Endpoints), 2)
}
Exemple #30
0
func TestIsPath(t *testing.T) {
	assert := assert.Assert(t)

	cases := []struct {
		in   string
		want bool
	}{
		{"/a/", true},
		{"://a/", true},
		{"http://a.com/", false},
		{"p://a.com/", false},
	}
	for _, c := range cases {
		assert.Equal(
			isPath(c.in),
			c.want,
		)
	}
}