func setupSuccessfulFetch(server *ghttp.Server) {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/v1/images/layer-3/json"),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Header().Add("X-Docker-Size", "123")
w.Write([]byte(`{"id":"layer-3","parent":"parent-3","Config":{"env": ["env2=env2Value", "malformedenvvar"]}}`))
}),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/v1/images/layer-3/layer"),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte(`layer-3-data`))
}),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/v1/images/layer-2/json"),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Header().Add("X-Docker-Size", "456")
w.Write([]byte(`{"id":"layer-2","parent":"parent-2","Config":{"volumes": { "/tmp": {}, "/another": {} }, "env": ["env1=env1Value", "env2=env2NewValue"]}}`))
}),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/v1/images/layer-2/layer"),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte(`layer-2-data`))
}),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/v1/images/layer-1/json"),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Header().Add("X-Docker-Size", "789")
w.Write([]byte(`{"id":"layer-1","parent":"parent-1"}`))
}),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/v1/images/layer-1/layer"),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte(`layer-1-data`))
}),
),
)
}
func NewTestServer(server *ghttp.Server) *ghttp.Server {
sampleSuccessTokenStringFormat := `{"access_token":"%s","token_type":"bearer","refresh_token":"%s","expires_in":599,"scope":"password.write cloud_controller.write openid cloud_controller.read","jti":"%s"}`
loginTokenResponse := fmt.Sprintf(sampleSuccessTokenStringFormat, "access-token", "refresh-token", "jti")
aiBasicResponse, _ := ioutil.ReadFile("fixtures/ai_basic_response.json")
aiInfoHandler := ghttp.RespondWith(http.StatusOK, aiBasicResponse)
aiDeleteHandler := ghttp.RespondWith(http.StatusNoContent, "")
aiInfoPath, _ := regexp.Compile("/v2/apps/.*/instances")
aiDeletePath, _ := regexp.Compile("/v2/apps/.*/instances/.*")
server.RouteToHandler("GET", aiInfoPath, aiInfoHandler)
server.RouteToHandler("DELETE", aiDeletePath, aiDeleteHandler)
server.RouteToHandler("POST", "/oauth/token", ghttp.RespondWith(http.StatusOK, "{}"))
server.AppendHandlers(
ghttp.RespondWith(http.StatusOK, loginTokenResponse),
)
return server
}
func setupSuccessfulV2Fetch(server *ghttp.Server, layer1Cached bool) {
layer1Data := "banana-1-flan"
layer1Dgst, _ := digest.FromBytes([]byte(layer1Data))
layer2Data := "banana-2-flan"
layer2Dgst, _ := digest.FromBytes([]byte(layer2Data))
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/v2/some-repo/manifests/some-tag"),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte(fmt.Sprintf(`
{
"name":"some-repo",
"tag":"some-tag",
"fsLayers":[
{
"blobSum":"%s"
},
{
"blobSum":"%s"
}
],
"history":[
{
"v1Compatibility": "{\"id\":\"banana-pie-2\", \"parent\":\"banana-pie-1\"}"
},
{
"v1Compatibility": "{\"id\":\"banana-pie-1\"}"
}
]
}
`, layer2Dgst.String(), layer1Dgst.String())))
}),
),
)
if !layer1Cached {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", fmt.Sprintf("/v2/some-repo/blobs/%s", layer1Dgst)),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte(layer1Data))
}),
),
)
}
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", fmt.Sprintf("/v2/some-repo/blobs/%s", layer2Dgst)),
http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte(layer2Data))
}),
),
)
}
"github.com/cloudfoundry-incubator/bbs"
"github.com/cloudfoundry-incubator/bbs/models"
"github.com/cloudfoundry-incubator/locket"
"github.com/cloudfoundry-incubator/runtime-schema/cc_messages"
)
var _ = Describe("Syncing desired state with CC", func() {
const interruptTimeout = 5 * time.Second
var (
fakeCC *ghttp.Server
process ifrit.Process
domainTTL time.Duration
bulkerLockName = "nsync_bulker_lock"
pollingInterval time.Duration
heartbeatInterval time.Duration
logger lager.Logger
)
startBulker := func(check bool) ifrit.Process {
runner := ginkgomon.New(ginkgomon.Config{
Name: "nsync-bulker",
AnsiColorCode: "97m",
StartCheck: "nsync.bulker.started",
Command: exec.Command(
bulkerPath,
"-ccBaseURL", fakeCC.URL(),
"testing" ) var ( trafficControllerAddress string trafficControllerPort int trafficControllerURL string etcdPort int consulRunner *consulrunner.ClusterRunner listenerPort int listenerAddr string listener ifrit.Process runner *ginkgomon.Runner listenerPath string fakeCC *ghttp.Server etcdRunner *etcdstorerunner.ETCDClusterRunner store storeadapter.StoreAdapter bbsClient bbs.Client logger *lagertest.TestLogger bbsPath string bbsURL *url.URL ) var bbsArgs bbstestrunner.Args var bbsRunner *ginkgomon.Runner
"github.com/onsi/gomega/gbytes"
"github.com/onsi/gomega/ghttp"
"github.com/pivotal-golang/lager/lagertest"
"github.com/tedsuo/rata"
"github.com/cloudfoundry-incubator/garden"
. "github.com/cloudfoundry-incubator/garden/client/connection"
"github.com/cloudfoundry-incubator/garden/client/connection/fakes"
"github.com/cloudfoundry-incubator/garden/transport"
)
var _ = Describe("Connection", func() {
var (
connection Connection
resourceLimits garden.ResourceLimits
server *ghttp.Server
hijacker HijackStreamer
network string
address string
)
BeforeEach(func() {
server = ghttp.NewServer()
network = "tcp"
address = server.HTTPTestServer.Listener.Addr().String()
hijacker = NewHijackStreamer(network, address)
})
JustBeforeEach(func() {
connection = NewWithHijacker(network, address, hijacker, lagertest.NewTestLogger("test-connection"))
})
"net/http"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
"github.com/rosenhouse/proctor/client"
)
var _ = Describe("JSON Client", func() {
var (
server *ghttp.Server
c *client.JSONClient
serverHandler http.HandlerFunc
route string
responseStruct struct {
SomeResponseField string `json:"SomeResponseField"`
}
)
BeforeEach(func() {
server = ghttp.NewServer()
c = &client.JSONClient{
BaseURL: server.URL(),
}
route = "/some/route"
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
. "github.com/onsi/gomega/gexec"
"github.com/onsi/gomega/ghttp"
)
var runner *testrunner.Runner
var _ = Describe("The Rep", func() {
var (
fakeGarden *ghttp.Server
serviceClient bbs.ServiceClient
pollingInterval time.Duration
evacuationTimeout time.Duration
rootFSName string
rootFSPath string
logger *lagertest.TestLogger
flushEvents chan struct{}
)
var getActualLRPGroups = func() []*models.ActualLRPGroup {
actualLRPGroups, err := bbsClient.ActualLRPGroups(models.ActualLRPFilter{})
Expect(err).NotTo(HaveOccurred())
return actualLRPGroups
}
BeforeEach(func() {
Eventually(getActualLRPGroups, 5*pollingInterval).Should(BeEmpty())
flushEvents = make(chan struct{})
import (
"net/http"
"os/exec"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/concourse/atc"
"github.com/onsi/gomega/gbytes"
"github.com/onsi/gomega/gexec"
"github.com/onsi/gomega/ghttp"
"github.com/tedsuo/rata"
)
var _ = Describe("Fly CLI", func() {
var atcServer *ghttp.Server
Describe("pause-pipeline", func() {
BeforeEach(func() {
atcServer = ghttp.NewServer()
})
Context("when the pipeline name is specified", func() {
var (
path string
err error
)
BeforeEach(func() {
path, err = atc.Routes.CreatePathForRoute(atc.PausePipeline, rata.Params{"pipeline_name": "awesome-pipeline"})
Expect(err).NotTo(HaveOccurred())
type Config struct {
Name string `json:"name"`
Type string `json:"type"`
Network Network `json:"network"`
DaemonBaseURL string `json:"daemon_base_url"`
}
const DEFAULT_TIMEOUT = "3s"
var _ = Describe("VXLAN ADD", func() {
var (
netConfig Config
session *gexec.Session
server *ghttp.Server
containerID string
containerNSPath string
ipamResult types.Result
)
BeforeEach(func() {
containerID = "guid-1"
containerNSPath = "/some/container/namespace/path"
server = ghttp.NewServer()
serverURL := server.URL()
network := Network{
ID: "some-network-id",
"github.com/concourse/go-concourse/concourse"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
"testing"
)
func TestApi(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Concourse Client Suite")
}
var (
atcServer *ghttp.Server
client concourse.Client
team concourse.Team
)
var _ = BeforeEach(func() {
atcServer = ghttp.NewServer()
client = concourse.NewClient(
atcServer.URL(),
&http.Client{},
)
team = client.Team("some-team")
})
var _ = AfterEach(func() {
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/cloudfoundry-incubator/garden"
"github.com/cloudfoundry-incubator/garden-windows/backend"
"github.com/cloudfoundry-incubator/garden-windows/container"
"github.com/cloudfoundry-incubator/garden-windows/dotnet"
"github.com/pivotal-golang/lager/lagertest"
"time"
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("backend", func() {
var server *ghttp.Server
var dotNetBackend garden.Backend
var serverUri *url.URL
var logger *lagertest.TestLogger
var client *dotnet.Client
BeforeEach(func() {
server = ghttp.NewServer()
logger = lagertest.NewTestLogger("backend")
serverUri, _ = url.Parse(server.URL())
client = dotnet.NewClient(logger, serverUri)
dotNetBackend, _ = backend.NewDotNetBackend(client, logger)
})
AfterEach(func() {
//shut down the server between tests
package flipkart_test
import (
. "github.com/arangamani/go-flipkart"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("Flipkart", func() {
var f *Flipkart
var server *ghttp.Server
BeforeEach(func() {
server = ghttp.NewServer()
f = &Flipkart{
AffiliateId: "fk-id",
AffliateToken: "fk-secret",
Host: server.URL()[7:],
Scheme: "http",
}
})
Context("TopOffers", func() {
BeforeEach(func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/affiliate/offers/v1/top/json"),
ghttp.VerifyHeaderKV("Fk-Affiliate-Id", "fk-id"),
ghttp.VerifyHeaderKV("Fk-Affiliate-Token", "fk-secret"),
package droplet_runner_test
import (
"net/http"
"github.com/cloudfoundry-incubator/ltc/droplet_runner"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("HTTPProxyConfReader", func() {
var (
proxyConfReader *droplet_runner.HTTPProxyConfReader
fakeServer *ghttp.Server
badURL string
)
BeforeEach(func() {
fakeServer = ghttp.NewServer()
badServer := ghttp.NewServer()
badURL = badServer.URL()
badServer.Close()
proxyConfReader = &droplet_runner.HTTPProxyConfReader{
URL: fakeServer.URL() + "/pc.json",
}
})
AfterEach(func() {
var _ = Describe("SSH proxy", func() {
var (
fakeBBS *ghttp.Server
fakeUAA *ghttp.Server
fakeCC *ghttp.Server
runner ifrit.Runner
process ifrit.Process
address string
bbsAddress string
ccAPIURL string
diegoCredentials string
enableCFAuth bool
enableDiegoAuth bool
hostKey string
hostKeyFingerprint string
skipCertVerify bool
uaaTokenURL string
uaaPassword string
uaaUsername string
allowedCiphers string
allowedMACs string
allowedKeyExchanges string
expectedGetActualLRPRequest *models.ActualLRPGroupByProcessGuidAndIndexRequest
actualLRPGroupResponse *models.ActualLRPGroupResponse
getDesiredLRPRequest *models.DesiredLRPByProcessGuidRequest
desiredLRPResponse *models.DesiredLRPResponse
processGuid string
clientConfig *ssh.ClientConfig
)
var _ = Describe("Main", func() {
var (
flags []string
)
var buildCommand = func(cmd string, flags []string, args []string) []string {
command := []string{cmd}
command = append(command, flags...)
command = append(command, args...)
return command
}
Context("Given reasonable arguments", func() {
var (
server *ghttp.Server
authServer *ghttp.Server
token string
)
BeforeEach(func() {
server = ghttp.NewServer()
authServer = ghttp.NewServer()
token = uuid.NewUUID().String()
responseBody := &token_fetcher.Token{
AccessToken: token,
ExpireTime: 20,
}
authServer.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/oauth/token"),
)
Expect(err).ToNot(HaveOccurred())
server = httptest.NewServer(handler)
cookieJar, err = cookiejar.New(nil)
Expect(err).ToNot(HaveOccurred())
client = &http.Client{
Transport: &http.Transport{},
Jar: cookieJar,
}
})
Describe("GET /auth/:provider", func() {
var redirectTarget *ghttp.Server
var request *http.Request
var response *http.Response
BeforeEach(func() {
redirectTarget = ghttp.NewServer()
redirectTarget.RouteToHandler("GET", "/", ghttp.RespondWith(http.StatusOK, "sup"))
var err error
request, err = http.NewRequest("GET", server.URL, nil)
Expect(err).NotTo(HaveOccurred())
})
JustBeforeEach(func() {
var err error
"github.com/dotcloud/docker/image"
"github.com/dotcloud/docker/registry"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
. "github.com/vito/warden-docker/container_pool/repository_fetcher"
"github.com/vito/warden-docker/fake_graph"
)
var _ = Describe("RepositoryFetcher", func() {
var graph *fake_graph.FakeGraph
var fetcher RepositoryFetcher
var server *ghttp.Server
var endpoint1 *ghttp.Server
var endpoint2 *ghttp.Server
BeforeEach(func() {
graph = fake_graph.New()
server = ghttp.NewServer()
endpoint1 = ghttp.NewServer()
endpoint2 = ghttp.NewServer()
registry, err := registry.NewRegistry(nil, nil, server.URL()+"/v1/")
Ω(err).ShouldNot(HaveOccurred())
fetcher = New(registry, graph)
"net/http"
"net/url"
"strings"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
"github.com/rackhd/rackhd-cpi/bosh"
"github.com/rackhd/rackhd-cpi/config"
"github.com/rackhd/rackhd-cpi/cpi"
"github.com/rackhd/rackhd-cpi/helpers"
)
var _ = Describe("Setting VM Metadata", func() {
Context("When called with metadata", func() {
var server *ghttp.Server
var jsonReader *strings.Reader
var cpiConfig config.Cpi
var request bosh.CpiRequest
BeforeEach(func() {
server = ghttp.NewServer()
serverURL, err := url.Parse(server.URL())
Expect(err).ToNot(HaveOccurred())
jsonReader = strings.NewReader(fmt.Sprintf(`{"apiserver":"%s", "agent":{"blobstore": {"provider":"local","some": "options"}, "mbus":"localhost"}, "max_create_vm_attempts":1}`, serverURL.Host))
request = bosh.CpiRequest{Method: bosh.SET_VM_METADATA}
cpiConfig, err = config.New(jsonReader, request)
Expect(err).ToNot(HaveOccurred())
})
AfterEach(func() {
"github.com/cloudfoundry/cli/cf/net"
"github.com/cloudfoundry/cli/cf/terminal/terminalfakes"
testconfig "github.com/cloudfoundry/cli/testhelpers/configuration"
"github.com/onsi/gomega/ghttp"
"github.com/cloudfoundry/cli/cf/trace/tracefakes"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("CloudControllerRepository", func() {
var (
ccServer *ghttp.Server
configRepo coreconfig.ReadWriter
repo environmentvariablegroups.CloudControllerRepository
)
BeforeEach(func() {
ccServer = ghttp.NewServer()
configRepo = testconfig.NewRepositoryWithDefaults()
configRepo.SetAPIEndpoint(ccServer.URL())
gateway := net.NewCloudControllerGateway(configRepo, time.Now, new(terminalfakes.FakeUI), new(tracefakes.FakePrinter), "")
repo = environmentvariablegroups.NewCloudControllerRepository(configRepo, gateway)
})
AfterEach(func() {
ccServer.Close()
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
"crypto/tls"
"time"
. "github.com/cloudfoundry/bosh-utils/httpclient"
"github.com/cloudfoundry/bosh-utils/logger/loggerfakes"
)
var _ = Describe("HTTPClient", func() {
var (
httpClient HTTPClient
server *ghttp.Server
logger loggerfakes.FakeLogger
)
BeforeEach(func() {
logger = loggerfakes.FakeLogger{}
httpClient = NewHTTPClient(&http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
RootCAs: nil,
InsecureSkipVerify: true,
},
Proxy: http.ProxyFromEnvironment,
"github.com/onsi/gomega/ghttp"
config_package "github.com/cloudfoundry-incubator/ltc/config"
"github.com/cloudfoundry-incubator/ltc/receptor_client/fake_receptor_client_creator"
"github.com/cloudfoundry-incubator/ltc/version"
"github.com/cloudfoundry-incubator/ltc/version/fake_file_swapper"
"github.com/cloudfoundry-incubator/receptor"
"github.com/cloudfoundry-incubator/receptor/fake_receptor"
)
var _ = Describe("VersionManager", func() {
var (
fakeFileSwapper *fake_file_swapper.FakeFileSwapper
fakeServer *ghttp.Server
config *config_package.Config
versionManager version.VersionManager
fakeReceptorClientCreator *fake_receptor_client_creator.FakeCreator
fakeReceptorClient *fake_receptor.FakeClient
ltcTempFile *os.File
)
BeforeEach(func() {
fakeFileSwapper = &fake_file_swapper.FakeFileSwapper{}
fakeServer = ghttp.NewServer()
fakeServerURL, err := url.Parse(fakeServer.URL())
Expect(err).NotTo(HaveOccurred())
fakeServerHost, fakeServerPort, err := net.SplitHostPort(fakeServerURL.Host)
Expect(err).NotTo(HaveOccurred())
"io/ioutil"
"math/rand"
"net"
"net/http"
"strconv"
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
"gopkg.in/inconshreveable/log15.v2"
)
var _ = Describe("Testing misc requests", func() {
var server *ghttp.Server
var listener net.Listener
var wstunsrv *WSTunnelServer
var wstuncli *WSTunnelClient
var wstunUrl string
var wstunToken string
BeforeEach(func() {
// start ghttp to simulate target server
wstunToken = "test567890123456-" + strconv.Itoa(rand.Int()%1000000)
server = ghttp.NewServer()
log15.Info("ghttp started", "url", server.URL())
// start wstunsrv
listener, _ = net.Listen("tcp", "127.0.0.1:0")
wstunsrv = NewWSTunnelServer([]string{})
"math/rand"
"net"
"net/http"
"strconv"
"strings"
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
"gopkg.in/inconshreveable/log15.v2"
)
var _ = Describe("Testing xhost requests", func() {
var server *ghttp.Server
var wstuncli *WSTunnelClient
var wstunsrv *WSTunnelServer
var wstunUrl string
var wstunToken string
var cliStart func(server, regexp string) *WSTunnelClient
BeforeEach(func() {
wstunToken = "test567890123456-" + strconv.Itoa(rand.Int()%1000000)
server = ghttp.NewServer()
log15.Info("ghttp started", "url", server.URL())
l, _ := net.Listen("tcp", "127.0.0.1:0")
wstunsrv = NewWSTunnelServer([]string{})
wstunsrv.Start(l)
wstunUrl = "http://" + l.Addr().String()
"github.com/cloudfoundry/cli/cf/configuration/core_config"
"github.com/cloudfoundry/cli/cf/errors"
"github.com/cloudfoundry/cli/cf/models"
"github.com/cloudfoundry/cli/cf/net"
. "github.com/cloudfoundry/cli/cf/api"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Service Keys Repo", func() {
var (
ccServer *ghttp.Server
configRepo core_config.ReadWriter
repo ServiceKeyRepository
)
BeforeEach(func() {
configRepo = testconfig.NewRepositoryWithDefaults()
configRepo.SetAccessToken("BEARER my_access_token")
ccServer = ghttp.NewServer()
configRepo.SetApiEndpoint(ccServer.URL())
gateway := net.NewCloudControllerGateway(configRepo, time.Now, &testterm.FakeUI{})
repo = NewCloudControllerServiceKeyRepository(configRepo, gateway)
})
AfterEach(func() {
"github.com/cloudfoundry-incubator/bbs/taskworkpool"
"github.com/cloudfoundry-incubator/cf_http"
"github.com/pivotal-golang/lager"
"github.com/pivotal-golang/lager/lagertest"
"github.com/tedsuo/ifrit"
"github.com/tedsuo/ifrit/ginkgomon"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("TaskWorker", func() {
var (
fakeServer *ghttp.Server
logger *lagertest.TestLogger
timeout time.Duration
)
BeforeEach(func() {
timeout = 1 * time.Second
cf_http.Initialize(timeout)
fakeServer = ghttp.NewServer()
logger = lagertest.NewTestLogger("test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.INFO))
})
AfterEach(func() {
fakeServer.Close()
})
It("sets the API endpoint", func() {
command := exec.Command("cf", "api", getAPI(), "--skip-ssl-validation")
session, err := Start(command, GinkgoWriter, GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
Eventually(session.Out).Should(Say("Setting api endpoint to %s...", getAPI()))
Eventually(session.Out).Should(Say("OK"))
Eventually(session.Out).Should(Say("API endpoint:\\s+https://%s", getAPI()))
Eventually(session.Out).Should(Say("API version: \\d+\\.\\d+\\.\\d+"))
Eventually(session).Should(Exit(0))
})
})
Context("api does not have SSL", func() {
var server *ghttp.Server
BeforeEach(func() {
server = ghttp.NewServer()
serverAPIURL := server.URL()[7:]
response := `{
"name":"",
"build":"",
"support":"http://support.cloudfoundry.com",
"version":0,
"description":"",
"authorization_endpoint":"https://login.APISERVER",
"token_endpoint":"https://uaa.APISERVER",
"min_cli_version":null,
"min_recommended_cli_version":null,
"github.com/cloudfoundry/cli/testhelpers/cloudcontrollergateway"
testconfig "github.com/cloudfoundry/cli/testhelpers/configuration"
testnet "github.com/cloudfoundry/cli/testhelpers/net"
testterm "github.com/cloudfoundry/cli/testhelpers/terminal"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("Gateway", func() {
var (
ccServer *ghttp.Server
ccGateway Gateway
uaaGateway Gateway
config coreconfig.ReadWriter
authRepo authentication.AuthenticationRepository
currentTime time.Time
clock func() time.Time
client *netfakes.FakeHTTPClientInterface
)
BeforeEach(func() {
currentTime = time.Unix(0, 0)
clock = func() time.Time { return currentTime }
config = testconfig.NewRepository()
ccGateway = NewCloudControllerGateway(config, clock, &testterm.FakeUI{}, new(tracefakes.FakePrinter))
ccGateway.PollingThrottle = 3 * time.Millisecond
uaaGateway = NewUAAGateway(config, &testterm.FakeUI{}, new(tracefakes.FakePrinter))
})
import (
"os/exec"
"github.com/concourse/atc"
"github.com/concourse/fly/ui"
"github.com/fatih/color"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
"github.com/onsi/gomega/gexec"
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("Fly CLI", func() {
var (
atcServer *ghttp.Server
)
Describe("containers", func() {
var (
flyCmd *exec.Cmd
)
BeforeEach(func() {
atcServer = ghttp.NewServer()
flyCmd = exec.Command(flyPath, "-t", atcServer.URL(), "containers")
})
Context("when containers are returned from the API", func() {
BeforeEach(func() {
atcServer.AppendHandlers(
Context("when there is a UAA error", func() {
BeforeEach(func() {
setupTestServer(errorLoginRequest)
})
It("returns the API error", func() {
Expect(apiErr).NotTo(BeNil())
})
})
})
})
Describe("Authorize", func() {
var (
uaaServer *ghttp.Server
gateway net.Gateway
config core_config.ReadWriter
authRepo AuthenticationRepository
)
BeforeEach(func() {
uaaServer = ghttp.NewServer()
config = testconfig.NewRepository()
config.SetAuthenticationEndpoint(uaaServer.URL())
config.SetSSHOAuthClient("ssh-oauth-client")
gateway = net.NewUAAGateway(config, &testterm.FakeUI{})
authRepo = NewUAAAuthenticationRepository(gateway, config)
uaaServer.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyHeader(http.Header{"authorization": []string{"auth-token"}}),