Example #1
0
func TestHttpGunWithHttp(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel()

	result := make(chan *aggregate.Sample)
	requests := make(chan *http.Request)

	ts := httptest.NewServer(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			fmt.Fprintln(w, "Hello, client")
			go func() {
				requests <- r
			}()
		}))
	defer ts.Close()

	gun := &HttpGun{
		target:  ts.Listener.Addr().String(),
		ssl:     false,
		results: result,
	}
	promise := utils.Promise(func() error {
		defer close(result)
		return gun.Shoot(ctx, &ammo.Http{
			Host:   "example.org",
			Method: "GET",
			Uri:    "/path",
			Headers: map[string]string{
				"Accept":          "*/*",
				"Accept-Encoding": "gzip, deflate",
				"Host":            "example.org",
				"User-Agent":      "Pandora/0.0.1",
			},
		})
	})
	results := aggregate.Drain(ctx, result)
	require.Len(t, results, 1)
	assert.Equal(t, "REQUEST", results[0].Tag)
	assert.Equal(t, 200, results[0].ProtoCode)

	select {
	case r := <-requests:
		assert.Equal(t, "GET", r.Method)
		assert.Equal(t, "example.org", r.Host)
		assert.Equal(t, "/path", r.URL.Path)
		assert.Equal(t, "Pandora/0.0.1", r.Header.Get("User-Agent"))
	case <-ctx.Done():
		t.Fatal(ctx.Err())
	}

	// TODO: test scenaries with errors

	select {
	case err := <-promise:
		require.NoError(t, err)
	case <-ctx.Done():
		t.Fatal(ctx.Err())
	}
}
Example #2
0
func TestSpdyGun(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel()

	result := make(chan aggregate.Sample)

	gun := &SpdyGun{
		target:     "localhost:3000",
		pingPeriod: time.Second * 5,
	}
	promise := utils.Promise(func() error {
		defer close(result)
		return gun.Shoot(ctx, &ammo.Http{
			Host:   "example.org",
			Method: "GET",
			Uri:    "/path",
			Headers: map[string]string{
				"Accept":          "*/*",
				"Accept-Encoding": "gzip, deflate",
				"Host":            "example.org",
				"User-Agent":      "Pandora/0.0.1",
			},
		}, result)
	})

	results := aggregate.Drain(ctx, result)
	require.Len(t, results, 2)
	{
		// first result is connect
		rPhout, casted := (results[0]).(aggregate.PhantomCompatible)
		require.True(t, casted, "Should be phantom compatible")
		phoutSample := rPhout.PhoutSample()
		assert.Equal(t, "CONNECT", phoutSample.Tag)
		assert.Equal(t, 200, phoutSample.ProtoCode)
	}
	{
		// second result is request
		rPhout, casted := (results[1]).(aggregate.PhantomCompatible)
		require.True(t, casted, "Should be phantom compatible")
		phoutSample := rPhout.PhoutSample()
		spew.Dump(phoutSample)
		assert.Equal(t, "REQUEST", phoutSample.Tag)
		assert.Equal(t, 200, phoutSample.ProtoCode)
	}

	// TODO: test scenaries with errors
	// TODO: test ping logic

	select {
	case err := <-promise:
		require.NoError(t, err)
	case <-ctx.Done():
		t.Fatal(ctx.Err())
	}

}
Example #3
0
func TestSpdyGun(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel()

	result := make(chan *aggregate.Sample)

	gun := &SpdyGun{
		target:  "localhost:3000",
		results: result,
	}
	promise := utils.Promise(func() error {
		defer gun.Close()
		defer close(result)
		return gun.Shoot(ctx, &ammo.Http{
			Host:   "example.org",
			Method: "GET",
			Uri:    "/path",
			Headers: map[string]string{
				"Accept":          "*/*",
				"Accept-Encoding": "gzip, deflate",
				"Host":            "example.org",
				"User-Agent":      "Pandora/0.0.1",
			},
		})
	})

	results := aggregate.Drain(ctx, result)
	require.Len(t, results, 2)
	{
		// first result is connect

		assert.Equal(t, "CONNECT", results[0].Tag)
		assert.Equal(t, 200, results[0].ProtoCode)
	}
	{
		// second result is request

		assert.Equal(t, "REQUEST", results[1].Tag)
		assert.Equal(t, 200, results[1].ProtoCode)
	}

	// TODO: test scenaries with errors

	select {
	case err := <-promise:
		require.NoError(t, err)
	case <-ctx.Done():
		t.Fatal(ctx.Err())
	}

}
Example #4
0
func TestSpdyConnectPing(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel()

	result := make(chan *aggregate.Sample)

	gun := &SpdyGun{
		target:  "localhost:3000",
		results: result,
	}
	promise := utils.Promise(func() error {
		defer gun.Close()
		defer close(result)
		if err := gun.Connect(); err != nil {
			return err
		}
		gun.Ping()
		return nil
	})

	results := aggregate.Drain(ctx, result)
	require.Len(t, results, 2)
	{
		// first result is connect

		assert.Equal(t, "CONNECT", results[0].Tag)
		assert.Equal(t, 200, results[0].ProtoCode)
	}
	{
		// second result is PING

		assert.Equal(t, "PING", results[1].Tag)
		assert.Equal(t, 200, results[1].ProtoCode)
	}
	select {
	case err := <-promise:
		require.NoError(t, err)
	case <-ctx.Done():
		t.Fatal(ctx.Err())
	}

}