func DoRequest(r *sling.Sling) *http.Response {
req, err := r.Request()
Expect(err).To(BeNil())
response, err := http.DefaultClient.Do(req)
Expect(err).To(BeNil())
return response
}
// newStreamService returns a new StreamService.
func newStreamService(client *http.Client, sling *sling.Sling) *StreamService {
sling.Set("User-Agent", userAgent)
return &StreamService{
client: client,
public: sling.New().Base(publicStream).Path("statuses/"),
user: sling.New().Base(userStream),
site: sling.New().Base(siteStream),
}
}
func DoRequestThroughProxy(r *sling.Sling) *http.Response {
req, err := r.Request()
Expect(err).To(BeNil())
proxy, err := url.Parse(hoverflyProxyUrl)
proxyHttpClient := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxy)}, CheckRedirect: func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse }}
response, err := proxyHttpClient.Do(req)
Expect(err).To(BeNil())
return response
}
func DoRequestThroughProxy(r *sling.Sling) *http.Response {
req, err := r.Request()
Expect(err).To(BeNil())
proxy, err := url.Parse(hoverflyProxyUrl)
proxyHttpClient := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxy)}}
response, err := proxyHttpClient.Do(req)
Expect(err).To(BeNil())
return response
}
func request(_sling *sling.Sling, acceptHeader string, authInfo ...usrInfo) (int, []byte, error) {
_sling = _sling.Set("Accept", acceptHeader)
req, err := _sling.Request()
if err != nil {
return 400, nil, err
}
if len(authInfo) > 0 {
req.SetBasicAuth(authInfo[0].Name, authInfo[0].Passwd)
}
w := httptest.NewRecorder()
beego.BeeApp.Handlers.ServeHTTP(w, req)
body, err := ioutil.ReadAll(w.Body)
return w.Code, body, err
}
func (h *Hoverfly) doRequest(request *sling.Sling) (*http.Response, error) {
httpRequest, err := request.Request()
if err != nil {
log.Debug(err.Error())
return nil, errors.New("Could not communicate with Hoverfly")
}
response, err := h.httpClient.Do(httpRequest)
if err != nil {
log.Debug(err.Error())
return nil, errors.New("Could not communicate with Hoverfly")
}
if response.StatusCode == 401 {
return nil, errors.New("Hoverfly requires authentication")
}
return response, nil
}
func (h *Hoverfly) performAPIRequest(slingRequest *sling.Sling) (*http.Response, error) {
slingRequest, err := h.addAuthIfNeeded(slingRequest)
if err != nil {
log.Warn(err.Error())
return nil, errors.New("Could not authenticate with Hoverfly")
}
request, err := slingRequest.Request()
if err != nil {
log.Warn(err.Error())
return nil, errors.New("Could not communicate with Hoverfly")
}
response, err := h.httpClient.Do(request)
if err != nil {
log.Warn(err.Error())
return nil, errors.New("Could not communicate with Hoverfly")
}
return response, nil
}
func (h *Hoverfly) addAuthIfNeeded(sling *sling.Sling) (*sling.Sling, error) {
if len(h.Username) > 0 || len(h.Password) > 0 && len(h.authToken) == 0 {
var err error
h.authToken, err = h.generateAuthToken()
if err != nil {
return nil, err
}
}
if len(h.authToken) > 0 {
sling.Add("Authorization", h.buildAuthorizationHeaderValue())
}
return sling, nil
}
func newSchemaService(sling *sling.Sling) *SchemaService {
return &SchemaService{
sling: sling.Path("schemas"),
}
}
// newUserService returns a new UserService.
func newUserService(sling *sling.Sling) *UserService {
return &UserService{
sling: sling.Path("users/"),
}
}
func newGroupService(sling *sling.Sling) *GroupService {
return &GroupService{
sling: sling.Path("group/"),
}
}
func newStoreService(sling *sling.Sling) *StoreService {
return &StoreService{
sling: sling.Path("store"),
}
}
"net/http"
"os/exec"
"github.com/dghubble/sling"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gexec"
"github.com/rosenhouse/cnsim/models"
"github.com/sclevine/agouti"
. "github.com/sclevine/agouti/matchers"
)
var _ = Describe("CNSim Server", func() {
var (
session *gexec.Session
address string
apiClient *sling.Sling
)
var serverIsAvailable = func() error {
return VerifyTCPConnection(address)
}
BeforeEach(func() {
port := 10000 + rand.Intn(10000)
serverCmd := exec.Command(pathToServer)
serverCmd.Env = []string{fmt.Sprintf("PORT=%d", port)}
var err error
session, err = gexec.Start(serverCmd, GinkgoWriter, GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
// newAccountService returns a new AccountService.
func newAccountService(sling *sling.Sling) *AccountService {
return &AccountService{
sling: sling.Path("account/"),
}
}
// newStatusService returns a new StatusService.
func newStatusService(sling *sling.Sling) *StatusService {
return &StatusService{
sling: sling.Path("statuses/"),
}
}
// newTimelineService returns a new TimelineService.
func newTimelineService(sling *sling.Sling) *TimelineService {
return &TimelineService{
sling: sling.Path("statuses/"),
}
}
// newDirectMessageService returns a new StatusService.
func newDirectMessageService(sling *sling.Sling) *DirectMessageService {
return &DirectMessageService{
baseSling: sling.New(),
sling: sling.Path("direct_messages/"),
}
}
// NewUserService return a new UserService
func NewUserService(sling *sling.Sling) *UserService {
return &UserService{
sling: sling.Path(""),
}
}
func newAuthService(sling *sling.Sling) *AuthService {
return &AuthService{
sling: sling.Path("auth/"),
}
}
// newFollowerService returns a new FollowerService.
func newFollowerService(sling *sling.Sling) *FollowerService {
return &FollowerService{
sling: sling.Path("followers/"),
}
}
// NewObjectService returns a new ObjectService
func NewObjectService(sling *sling.Sling) *ObjectService {
return &ObjectService{
sling: sling.Path("classes/"),
}
}