. "github.com/onsi/gomega"
"github.com/pivotal-golang/clock"
"github.com/pivotal-golang/lager/lagertest"
"github.com/tedsuo/ifrit"
"github.com/tedsuo/ifrit/ginkgomon"
)
var _ = Describe("Encryptor", func() {
var (
runner ifrit.Runner
encryptorProcess ifrit.Process
logger *lagertest.TestLogger
cryptor encryption.Cryptor
keyManager encryption.KeyManager
ready chan struct{}
signals chan os.Signal
runErrChan chan error
fakeDB *dbfakes.FakeEncryptionDB
sender *fake.FakeMetricSender
)
BeforeEach(func() {
sender = fake.NewFakeMetricSender()
metrics.Initialize(sender, nil)
runErrChan = make(chan error, 1)
ready = make(chan struct{})
signals = make(chan os.Signal)
package helpers_test
import (
"io"
"github.com/cloudfoundry-incubator/diego-ssh/helpers"
"github.com/pivotal-golang/lager"
"github.com/pivotal-golang/lager/lagertest"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("LagerWriter", func() {
var logger *lagertest.TestLogger
var lagerWriter io.Writer
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
lagerWriter = helpers.NewLagerWriter(logger)
})
It("writes the payload as lager.Data", func() {
payload := []byte("Hello, world!\n")
n, err := lagerWriter.Write(payload)
Expect(err).NotTo(HaveOccurred())
Expect(n).To(Equal(len(payload)))
Expect(logger.Logs()).To(HaveLen(1))
. "github.com/onsi/gomega"
)
func expectInvalidInput(responseRecorder *httptest.ResponseRecorder, database *fake_db.FakeDB, logger *lagertest.TestLogger) {
Expect(responseRecorder.Code).To(Equal(http.StatusBadRequest))
Expect(responseRecorder.Body.String()).To(ContainSubstring("Each tcp mapping requires a positive host port"))
Expect(database.SaveRouteCallCount()).To(Equal(0))
Expect(logger.Logs()[0].Message).To(ContainSubstring("error"))
}
var _ = Describe("TcpRouteMappingsHandler", func() {
var (
tcpRouteMappingsHandler *handlers.TcpRouteMappingsHandler
request *http.Request
responseRecorder *httptest.ResponseRecorder
validator *fake_validator.FakeRouteValidator
database *fake_db.FakeDB
logger *lagertest.TestLogger
token *fake_token.FakeToken
)
BeforeEach(func() {
database = &fake_db.FakeDB{}
token = &fake_token.FakeToken{}
validator = &fake_validator.FakeRouteValidator{}
logger = lagertest.NewTestLogger("routing-api-test")
tcpRouteMappingsHandler = handlers.NewTcpRouteMappingsHandler(token, validator, database, logger)
responseRecorder = httptest.NewRecorder()
})
Describe("Upsert", func() {
func expectInvalidInput(responseRecorder *httptest.ResponseRecorder, database *fake_db.FakeDB, logger *lagertest.TestLogger) {
Expect(responseRecorder.Code).To(Equal(http.StatusBadRequest))
Expect(responseRecorder.Body.String()).To(ContainSubstring("Each tcp mapping requires a positive host port"))
Expect(database.SaveRouteCallCount()).To(Equal(0))
Expect(logger.Logs()[0].Message).To(ContainSubstring("error"))
}
fake_auction_runner "github.com/cloudfoundry-incubator/auction/auctiontypes/fakes"
"github.com/cloudfoundry-incubator/bbs/auctionhandlers"
"github.com/cloudfoundry-incubator/bbs/models"
"github.com/pivotal-golang/lager"
"github.com/pivotal-golang/lager/lagertest"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/onsi/gomega/gbytes"
)
var _ = Describe("TaskAuctionHandler", func() {
var (
logger *lagertest.TestLogger
runner *fake_auction_runner.FakeAuctionRunner
responseRecorder *httptest.ResponseRecorder
handler *auctionhandlers.TaskAuctionHandler
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
runner = new(fake_auction_runner.FakeAuctionRunner)
responseRecorder = httptest.NewRecorder()
handler = auctionhandlers.NewTaskAuctionHandler(runner)
})
Describe("Create", func() {
Context("when the request body is a task", func() {
var tasks []*models.Task
)
type EventHolder struct {
event models.Event
}
var nilEventHolder = EventHolder{}
var _ = Describe("Watcher", func() {
var (
eventSource *eventfakes.FakeEventSource
bbsClient *fake_bbs.FakeClient
ccClient *fakes.FakeCcClient
watcherRunner *watcher.Watcher
process ifrit.Process
logger *lagertest.TestLogger
nextErr atomic.Value
nextEvent atomic.Value
)
BeforeEach(func() {
eventSource = new(eventfakes.FakeEventSource)
bbsClient = new(fake_bbs.FakeClient)
bbsClient.SubscribeToEventsReturns(eventSource, nil)
logger = lagertest.NewTestLogger("test")
ccClient = new(fakes.FakeCcClient)
var err error
. "github.com/onsi/gomega"
"github.com/pivotal-golang/clock/fakeclock"
"github.com/pivotal-golang/lager/lagertest"
"github.com/tedsuo/ifrit"
_ "github.com/lib/pq"
"testing"
)
var (
db *sql.DB
sqlDB *sqldb.SQLDB
fakeClock *fakeclock.FakeClock
fakeGUIDProvider *guidproviderfakes.FakeGUIDProvider
logger *lagertest.TestLogger
cryptor encryption.Cryptor
serializer format.Serializer
migrationProcess ifrit.Process
dbDriverName, dbBaseConnectionString string
dbFlavor string
)
func TestSql(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "SQL DB Suite")
}
var _ = BeforeSuite(func() {
if !test_helpers.UseSQL() {
return
"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()
})
"strings"
"github.com/pivotal-cf/brokerapi"
"github.com/pivotal-cf/brokerapi/fakes"
"github.com/drewolson/testflight"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-golang/lager"
"github.com/pivotal-golang/lager/lagertest"
)
var _ = Describe("Service Broker API", func() {
var fakeServiceBroker *fakes.FakeServiceBroker
var brokerAPI http.Handler
var brokerLogger *lagertest.TestLogger
var credentials = brokerapi.BrokerCredentials{
Username: "******",
Password: "******",
}
makeInstanceProvisioningRequest := func(instanceID string, details brokerapi.ProvisionDetails, queryString string) *testflight.Response {
response := &testflight.Response{}
testflight.WithServer(brokerAPI, func(r *testflight.Requester) {
path := "/v2/service_instances/" + instanceID + queryString
buffer := &bytes.Buffer{}
json.NewEncoder(buffer).Encode(details)
request, err := http.NewRequest("PUT", path, buffer)
Expect(err).NotTo(HaveOccurred())
import (
"github.com/cloudfoundry-incubator/ducati-daemon/executor"
"github.com/cloudfoundry-incubator/ducati-daemon/fakes"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-golang/lager/lagertest"
)
var _ = Describe("Executor", func() {
var (
logger *lagertest.TestLogger
addressManager *fakes.AddressManager
routeManager *fakes.RouteManager
linkFactory *fakes.LinkFactory
sandboxNamespaceRepository *fakes.Repository
sandboxRepository *fakes.SandboxRepository
listenerFactory *fakes.ListenerFactory
dnsServerFactory *fakes.DNSServerFactory
command *fakes.Command
ex executor.Executor
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
addressManager = &fakes.AddressManager{}
routeManager = &fakes.RouteManager{}
linkFactory = &fakes.LinkFactory{}
sandboxNamespaceRepository = &fakes.Repository{}
sandboxRepository = &fakes.SandboxRepository{}
listenerFactory = &fakes.ListenerFactory{}
dnsServerFactory = &fakes.DNSServerFactory{}
var _ = Describe("Linux containers", func() {
var fakeCgroups *fake_cgroups_manager.FakeCgroupsManager
var fakeQuotaManager *fake_quota_manager.FakeQuotaManager
var fakeBandwidthManager *fake_bandwidth_manager.FakeBandwidthManager
var fakeRunner *fake_command_runner.FakeCommandRunner
var containerResources *linux_backend.Resources
var container *linux_container.LinuxContainer
var fakePortPool *fake_port_pool.FakePortPool
var fakeProcessTracker *fake_process_tracker.FakeProcessTracker
var fakeFilter *networkFakes.FakeFilter
var fakeIPTablesManager *fake_iptables_manager.FakeIPTablesManager
var fakeOomWatcher *fake_watcher.FakeWatcher
var containerDir string
var containerProps map[string]string
var logger *lagertest.TestLogger
BeforeEach(func() {
fakeRunner = fake_command_runner.New()
fakeCgroups = fake_cgroups_manager.New("/cgroups", "some-id")
fakeQuotaManager = new(fake_quota_manager.FakeQuotaManager)
fakeBandwidthManager = fake_bandwidth_manager.New()
fakeProcessTracker = new(fake_process_tracker.FakeProcessTracker)
fakeFilter = new(networkFakes.FakeFilter)
fakeIPTablesManager = new(fake_iptables_manager.FakeIPTablesManager)
fakeOomWatcher = new(fake_watcher.FakeWatcher)
fakePortPool = fake_port_pool.New(1000)
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
"github.com/BurntSushi/migration"
"github.com/pivotal-golang/lager"
"github.com/pivotal-golang/lager/lagertest"
"github.com/concourse/atc/db/migrations"
"github.com/concourse/atc/db/migrations/fakes"
)
var _ = Describe("Logging migration progress", func() {
var logger *lagertest.TestLogger
BeforeEach(func() {
logger = lagertest.NewTestLogger("migrations")
})
Describe("Translogrifier", func() {
It("calls the correct number of migratior functions", func() {
oldMigrations := []migration.Migrator{
func(otx migration.LimitedTx) error {
otx.Exec(`SELECT 1`)
return nil
},
func(otx migration.LimitedTx) error {
otx.Exec(`SELECT 2`)
return nil
"path"
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-golang/lager/lagertest"
"github.com/cloudfoundry-incubator/garden"
"github.com/cloudfoundry-incubator/garden-linux/container_repository"
"github.com/cloudfoundry-incubator/garden-linux/linux_backend"
"github.com/cloudfoundry-incubator/garden-linux/linux_backend/fakes"
"github.com/cloudfoundry-incubator/garden-linux/sysinfo/fake_sysinfo"
)
var _ = Describe("LinuxBackend", func() {
var logger *lagertest.TestLogger
var fakeResourcePool *fakes.FakeResourcePool
var fakeSystemInfo *fake_sysinfo.FakeProvider
var fakeContainerProvider *fakes.FakeContainerProvider
var fakeHealthCheck *fakes.FakeHealthChecker
var containerRepo linux_backend.ContainerRepository
var linuxBackend *linux_backend.LinuxBackend
var snapshotsPath string
var maxContainers int
var fakeContainers map[string]*fakes.FakeContainer
newTestContainer := func(spec linux_backend.LinuxContainerSpec) *fakes.FakeContainer {
container := new(fakes.FakeContainer)
container.HandleReturns(spec.Handle)
container.GraceTimeReturns(spec.GraceTime)
fake_db "github.com/cloudfoundry-incubator/routing-api/db/fakes"
"github.com/cloudfoundry-incubator/routing-api/helpers"
"github.com/cloudfoundry-incubator/routing-api/models"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-golang/lager/lagertest"
"github.com/tedsuo/ifrit"
)
var _ = Describe("Helpers", func() {
Describe("RouteRegister", func() {
var (
routeRegister *helpers.RouteRegister
database *fake_db.FakeDB
route models.Route
logger *lagertest.TestLogger
timeChan chan time.Time
ticker *time.Ticker
)
var process ifrit.Process
BeforeEach(func() {
route = models.Route{
Route: "i dont care",
Port: 3000,
IP: "i dont care even more",
TTL: 120,
LogGuid: "i care a little bit more now",
}
"github.com/pivotal-golang/lager/lagertest"
"github.com/cloudfoundry-incubator/switchboard/api/middleware"
"github.com/cloudfoundry-incubator/switchboard/api/middleware/fakes"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Logger", func() {
var dummyRequest *http.Request
var err error
var fakeResponseWriter http.ResponseWriter
var fakeHandler *fakes.FakeHandler
var logger *lagertest.TestLogger
var routePrefix string
const fakePassword = "******"
BeforeEach(func() {
routePrefix = "/v0"
dummyRequest, err = http.NewRequest("GET", "/v0/backends", nil)
Expect(err).NotTo(HaveOccurred())
dummyRequest.Header.Add("Authorization", fakePassword)
fakeResponseWriter = &apifakes.FakeResponseWriter{}
fakeHandler = &fakes.FakeHandler{}
logger = lagertest.NewTestLogger("backup-download-test")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.INFO))
"github.com/cloudfoundry-incubator/routing-api/db"
fake_db "github.com/cloudfoundry-incubator/routing-api/db/fakes"
"github.com/cloudfoundry-incubator/routing-api/handlers"
fake_validator "github.com/cloudfoundry-incubator/routing-api/handlers/fakes"
"github.com/pivotal-golang/lager/lagertest"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("RoutesHandler", func() {
var (
routesHandler *handlers.RoutesHandler
request *http.Request
responseRecorder *httptest.ResponseRecorder
database *fake_db.FakeDB
logger *lagertest.TestLogger
validator *fake_validator.FakeRouteValidator
token *fake_token.FakeToken
)
BeforeEach(func() {
database = &fake_db.FakeDB{}
validator = &fake_validator.FakeRouteValidator{}
token = &fake_token.FakeToken{}
logger = lagertest.NewTestLogger("routing-api-test")
routesHandler = handlers.NewRoutesHandler(token, 50, validator, database, logger)
responseRecorder = httptest.NewRecorder()
})
Describe(".List", func() {
"github.com/tedsuo/ifrit"
"github.com/tedsuo/ifrit/ginkgomon"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
)
var _ = Describe("Maintain Presence", func() {
var (
config maintain.Config
fakeHeartbeater *maintain_fakes.FakeRunner
fakeClient *fake_client.FakeClient
serviceClient *fake_bbs.FakeServiceClient
logger *lagertest.TestLogger
maintainer ifrit.Runner
maintainProcess ifrit.Process
heartbeaterErrors chan error
observedSignals chan os.Signal
clock *fakeclock.FakeClock
pingErrors chan error
)
BeforeEach(func() {
pingErrors = make(chan error, 1)
fakeClient = &fake_client.FakeClient{
PingStub: func() error {
return <-pingErrors
},
}
resources := executor.ExecutorResources{MemoryMB: 128, DiskMB: 1024, Containers: 6}
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-golang/lager"
"github.com/pivotal-golang/lager/lagertest"
"golang.org/x/crypto/ssh"
)
var _ = Describe("DirectTcpipChannelHandler", func() {
var (
sshd *daemon.Daemon
client *ssh.Client
logger *lagertest.TestLogger
serverSSHConfig *ssh.ServerConfig
handler *fake_handlers.FakeNewChannelHandler
testHandler *handlers.DirectTcpipChannelHandler
testDialer *fakes.FakeDialer
echoHandler *fake_server.FakeConnectionHandler
echoServer *server.Server
echoAddress string
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
echoHandler = &fake_server.FakeConnectionHandler{}
echoHandler.HandleConnectionStub = func(conn net.Conn) {
io.Copy(conn, conn)
conn.Close()
"fmt"
"net/http"
"github.com/michaelklishin/rabbit-hole"
"github.com/pivotal-cf/brokerapi"
"github.com/pivotal-cf/cf-rabbitmq-broker"
"github.com/pivotal-cf/cf-rabbitmq-broker/fakes"
"github.com/pivotal-golang/lager/lagertest"
)
var _ = Describe("Broker Provisioning and Deprovisioning", func() {
var (
client *fakes.FakeAPIClient
config *rabbitbroker.Config
broker brokerapi.ServiceBroker
credentialsGenerator *fakes.FakeCredentialsGenerator
logger *lagertest.TestLogger
)
BeforeEach(func() {
config = defaultConfig()
client = new(fakes.FakeAPIClient)
credentialsGenerator = new(fakes.FakeCredentialsGenerator)
logger = lagertest.NewTestLogger("test")
broker = rabbitbroker.New(config, client, credentialsGenerator, logger, nil)
})
Context("Provision", func() {
BeforeEach(func() {
"github.com/drewolson/testflight"
"github.com/pivotal-golang/lager"
"github.com/pivotal-golang/lager/lagertest"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/pivotal-cf/brokerapi"
"github.com/pivotal-cf/brokerapi/fakes"
)
var _ = Describe("Service Broker API", func() {
var fakeServiceBroker *fakes.FakeServiceBroker
var brokerAPI http.Handler
var brokerLogger *lagertest.TestLogger
var credentials = brokerapi.BrokerCredentials{
Username: "******",
Password: "******",
}
makeInstanceProvisioningRequest := func(instanceID string, details brokerapi.ProvisionDetails) *testflight.Response {
response := &testflight.Response{}
testflight.WithServer(brokerAPI, func(r *testflight.Requester) {
path := "/v2/service_instances/" + instanceID
buffer := &bytes.Buffer{}
json.NewEncoder(buffer).Encode(details)
request, err := http.NewRequest("PUT", path, buffer)
Expect(err).NotTo(HaveOccurred())
request.Header.Add("Content-Type", "application/json")
err := utils.WriteToFile([]byte(cfg), configFile)
Expect(err).ShouldNot(HaveOccurred())
Expect(utils.FileExists(configFile)).To(BeTrue())
return configFile
}
verifyHaProxyConfigContent := func(haproxyFileName, expectedContent string) {
data, err := ioutil.ReadFile(haproxyFileName)
Expect(err).ShouldNot(HaveOccurred())
Expect(string(data)).Should(ContainSubstring(expectedContent))
}
var (
externalIP string
oauthServer *ghttp.Server
server ifrit.Process
logger *lagertest.TestLogger
session *gexec.Session
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
externalIP = testutil.GetExternalIP()
})
Context("when both oauth and routing api servers are up and running", func() {
BeforeEach(func() {
oauthServer = oAuthServer(logger)
server = routingApiServer(logger)
oauthServerPort := getServerPort(oauthServer.URL())
configFile := generateConfigFile(oauthServerPort, fmt.Sprintf("%d", routingAPIPort), false)