_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q179000 | Fill | test | func (s *Selection) Fill(text string) error {
return s.forEachElement(func(selectedElement element.Element) error {
if err := selectedElement.Clear(); err != nil {
return fmt.Errorf("failed to clear %s: %s", s, err)
}
if err := selectedElement.Value(text); err != nil {
return fmt.Errorf("failed to enter te... | go | {
"resource": ""
} |
q179001 | Tap | test | func (s *Selection) Tap(event Tap) error {
var touchFunc func(*api.Element) error
switch event {
case SingleTap:
touchFunc = s.session.TouchClick
case DoubleTap:
touchFunc = s.session.TouchDoubleClick
case LongTap:
touchFunc = s.session.TouchLongClick
default:
return fmt.Errorf("failed to %s on %s: invali... | go | {
"resource": ""
} |
q179002 | Touch | test | func (s *Selection) Touch(event Touch) error {
var touchFunc func(x, y int) error
switch event {
case HoldFinger:
touchFunc = s.session.TouchDown
case ReleaseFinger:
touchFunc = s.session.TouchUp
case MoveFinger:
touchFunc = s.session.TouchMove
default:
return fmt.Errorf("failed to %s on %s: invalid touch... | go | {
"resource": ""
} |
q179003 | FlickFinger | test | func (s *Selection) FlickFinger(xOffset, yOffset int, speed uint) error {
selectedElement, err := s.elements.GetExactlyOne()
if err != nil {
return fmt.Errorf("failed to select element from %s: %s", s, err)
}
if err := s.session.TouchFlick(selectedElement.(*api.Element), api.XYOffset{X: xOffset, Y: yOffset}, api... | go | {
"resource": ""
} |
q179004 | ScrollFinger | test | func (s *Selection) ScrollFinger(xOffset, yOffset int) error {
selectedElement, err := s.elements.GetExactlyOne()
if err != nil {
return fmt.Errorf("failed to select element from %s: %s", s, err)
}
if err := s.session.TouchScroll(selectedElement.(*api.Element), api.XYOffset{X: xOffset, Y: yOffset}); err != nil {... | go | {
"resource": ""
} |
q179005 | NewCapabilities | test | func NewCapabilities(features ...string) Capabilities {
c := Capabilities{}
for _, feature := range features {
c.With(feature)
}
return c
} | go | {
"resource": ""
} |
q179006 | JSON | test | func (c Capabilities) JSON() (string, error) {
capabilitiesJSON, err := json.Marshal(c)
return string(capabilitiesJSON), err
} | go | {
"resource": ""
} |
q179007 | HaveTitle | test | func HaveTitle(title string) types.GomegaMatcher {
return &internal.ValueMatcher{Method: "Title", Property: "title", Expected: title}
} | go | {
"resource": ""
} |
q179008 | HaveURL | test | func HaveURL(url string) types.GomegaMatcher {
return &internal.ValueMatcher{Method: "URL", Property: "URL", Expected: url}
} | go | {
"resource": ""
} |
q179009 | HavePopupText | test | func HavePopupText(text string) types.GomegaMatcher {
return &internal.ValueMatcher{Method: "PopupText", Property: "popup text", Expected: text}
} | go | {
"resource": ""
} |
q179010 | HaveLoggedError | test | func HaveLoggedError(messages ...string) types.GomegaMatcher {
return &internal.LogMatcher{
ExpectedMessages: messages,
Levels: []string{"WARNING", "SEVERE"},
Name: "error",
Type: "browser",
}
} | go | {
"resource": ""
} |
q179011 | Text | test | func (s *Selection) Text() (string, error) {
selectedElement, err := s.elements.GetExactlyOne()
if err != nil {
return "", fmt.Errorf("failed to select element from %s: %s", s, err)
}
text, err := selectedElement.GetText()
if err != nil {
return "", fmt.Errorf("failed to retrieve text for %s: %s", s, err)
}
... | go | {
"resource": ""
} |
q179012 | Active | test | func (s *Selection) Active() (bool, error) {
selectedElement, err := s.elements.GetExactlyOne()
if err != nil {
return false, fmt.Errorf("failed to select element from %s: %s", s, err)
}
activeElement, err := s.session.GetActiveElement()
if err != nil {
return false, fmt.Errorf("failed to retrieve active elem... | go | {
"resource": ""
} |
q179013 | Attribute | test | func (s *Selection) Attribute(attribute string) (string, error) {
return s.hasProperty(element.Element.GetAttribute, attribute, "attribute")
} | go | {
"resource": ""
} |
q179014 | CSS | test | func (s *Selection) CSS(property string) (string, error) {
return s.hasProperty(element.Element.GetCSS, property, "CSS property")
} | go | {
"resource": ""
} |
q179015 | Selected | test | func (s *Selection) Selected() (bool, error) {
return s.hasState(element.Element.IsSelected, "selected")
} | go | {
"resource": ""
} |
q179016 | Visible | test | func (s *Selection) Visible() (bool, error) {
return s.hasState(element.Element.IsDisplayed, "visible")
} | go | {
"resource": ""
} |
q179017 | Enabled | test | func (s *Selection) Enabled() (bool, error) {
return s.hasState(element.Element.IsEnabled, "enabled")
} | go | {
"resource": ""
} |
q179018 | HaveCount | test | func HaveCount(count int) types.GomegaMatcher {
return &internal.ValueMatcher{Method: "Count", Property: "element count", Expected: count}
} | go | {
"resource": ""
} |
q179019 | HaveAttribute | test | func HaveAttribute(attribute string, value string) types.GomegaMatcher {
return &internal.HaveAttributeMatcher{ExpectedAttribute: attribute, ExpectedValue: value}
} | go | {
"resource": ""
} |
q179020 | EdgeDriver | test | func EdgeDriver(options ...Option) *WebDriver {
var binaryName string
if runtime.GOOS == "windows" {
binaryName = "MicrosoftWebDriver.exe"
} else {
return nil
}
command := []string{binaryName, "--port={{.Port}}"}
// Using {{.Address}} means using 127.0.0.1
// But MicrosoftWebDriver only supports localhost, n... | go | {
"resource": ""
} |
q179021 | Selendroid | test | func Selendroid(jarFile string, options ...Option) *WebDriver {
absJARPath, err := filepath.Abs(jarFile)
if err != nil {
return nil
}
command := []string{
"java",
"-jar", absJARPath,
"-port", "{{.Port}}",
}
options = append([]Option{Timeout(90), Browser("android")}, options...)
return NewWebDriver("http... | go | {
"resource": ""
} |
q179022 | SwitchToFrame | test | func (s *Selection) SwitchToFrame() error {
selectedElement, err := s.elements.GetExactlyOne()
if err != nil {
return fmt.Errorf("failed to select element from %s: %s", s, err)
}
if err := s.session.Frame(selectedElement.(*api.Element)); err != nil {
return fmt.Errorf("failed to switch to frame referred to by ... | go | {
"resource": ""
} |
q179023 | Count | test | func (s *Selection) Count() (int, error) {
elements, err := s.elements.Get()
if err != nil {
return 0, fmt.Errorf("failed to select elements from %s: %s", s, err)
}
return len(elements), nil
} | go | {
"resource": ""
} |
q179024 | EqualsElement | test | func (s *Selection) EqualsElement(other interface{}) (bool, error) {
otherSelection, ok := other.(*Selection)
if !ok {
multiSelection, ok := other.(*MultiSelection)
if !ok {
return false, fmt.Errorf("must be *Selection or *MultiSelection")
}
otherSelection = &multiSelection.Selection
}
selectedElement, ... | go | {
"resource": ""
} |
q179025 | MouseToElement | test | func (s *Selection) MouseToElement() error {
selectedElement, err := s.elements.GetExactlyOne()
if err != nil {
return fmt.Errorf("failed to select element from %s: %s", s, err)
}
if err := s.session.MoveTo(selectedElement.(*api.Element), nil); err != nil {
return fmt.Errorf("failed to move mouse to element fo... | go | {
"resource": ""
} |
q179026 | loggingMiddleware | test | func loggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Printf("[DEBUG] http reverse proxy received connection from %s on path %s\n", r.RemoteAddr, r.RequestURI)
next.ServeHTTP(w, r)
})
} | go | {
"resource": ""
} |
q179027 | chainHandlers | test | func chainHandlers(mw ...Middleware) Middleware {
return func(final http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
last := final
for i := len(mw) - 1; i >= 0; i-- {
last = mw[i](last)
}
last.ServeHTTP(w, r)
})
}
} | go | {
"resource": ""
} |
q179028 | HTTPReverseProxy | test | func HTTPReverseProxy(options Options) (int, error) {
port := options.ProxyPort
var err error
proxy := httputil.NewSingleHostReverseProxy(&url.URL{
Scheme: options.TargetScheme,
Host: options.TargetAddress,
})
if port == 0 {
port, err = utils.GetFreePort()
if err != nil {
log.Println("[ERROR] unable... | go | {
"resource": ""
} |
q179029 | CheckInstallation | test | func (i *Installer) CheckInstallation() error {
for binary, versionRange := range versionMap {
log.Println("[INFO] checking", binary, "within range", versionRange)
version, err := i.GetVersionForBinary(binary)
if err != nil {
return err
}
if err = i.CheckVersion(binary, version); err != nil {
return... | go | {
"resource": ""
} |
q179030 | CheckVersion | test | func (i *Installer) CheckVersion(binary, version string) error {
log.Println("[DEBUG] checking version for binary", binary, "version", version)
v, err := goversion.NewVersion(version)
if err != nil {
log.Println("[DEBUG] err", err)
return err
}
versionRange, ok := versionMap[binary]
if !ok {
return fmt.Err... | go | {
"resource": ""
} |
q179031 | GetVersionForBinary | test | func (i *Installer) GetVersionForBinary(binary string) (version string, err error) {
log.Println("[DEBUG] running binary", binary)
content, err := i.commander.Output(binary, "version")
elements := strings.Split(strings.TrimSpace(string(content)), "\n")
version = strings.TrimSpace(elements[len(elements)-1])
retur... | go | {
"resource": ""
} |
q179032 | getUser | test | func (c *Client) getUser(id string) (*ex.User, error) {
u := fmt.Sprintf("%s/users/%s", c.Host, id)
req, err := http.NewRequest("GET", u, nil)
// NOTE: by default, request bodies are expected to be sent with a Content-Type
// of application/json. If you don't explicitly set the content-type, you
// will get a mi... | go | {
"resource": ""
} |
q179033 | login | test | func (c *Client) login(username string, password string) (*ex.User, error) {
loginRequest := fmt.Sprintf(`
{
"username":"%s",
"password": "%s"
}`, username, password)
res, err := http.Post(fmt.Sprintf("%s/login/10?foo=anything", c.Host), "application/json; charset=utf-8", bytes.NewReader([]byte(l... | go | {
"resource": ""
} |
q179034 | loginHandler | test | func (c *Client) loginHandler(w http.ResponseWriter, r *http.Request) {
username := r.FormValue("username")
password := r.FormValue("password")
user, err := c.login(username, password)
if err == nil && user != nil {
c.user = user
c.err = nil
http.Redirect(w, r, "/", http.StatusFound)
return
}
c.err = fmt... | go | {
"resource": ""
} |
q179035 | logoutHandler | test | func (c *Client) logoutHandler(w http.ResponseWriter, r *http.Request) {
c.user = nil
c.err = nil
http.Redirect(w, r, "/", http.StatusFound)
return
} | go | {
"resource": ""
} |
q179036 | viewHandler | test | func (c *Client) viewHandler(w http.ResponseWriter, r *http.Request) {
data := templateData{
User: c.user,
Error: c.err,
}
renderTemplate(w, "login", data)
} | go | {
"resource": ""
} |
q179037 | Run | test | func (c *Client) Run() {
http.HandleFunc("/login", c.loginHandler)
http.HandleFunc("/logout", c.logoutHandler)
http.HandleFunc("/", c.viewHandler)
fmt.Println("User svc client running on port 8081")
http.ListenAndServe(":8081", nil)
} | go | {
"resource": ""
} |
q179038 | WithRequest | test | func (i *Interaction) WithRequest(request Request) *Interaction {
i.Request = request
// Check if someone tried to add an object as a string representation
// as per original allowed implementation, e.g.
// { "foo": "bar", "baz": like("bat") }
if isJSONFormattedObject(request.Body) {
log.Println("[WARN] request... | go | {
"resource": ""
} |
q179039 | WillRespondWith | test | func (i *Interaction) WillRespondWith(response Response) *Interaction {
i.Response = response
return i
} | go | {
"resource": ""
} |
q179040 | isJSONFormattedObject | test | func isJSONFormattedObject(stringOrObject interface{}) bool {
switch content := stringOrObject.(type) {
case []byte:
case string:
var obj interface{}
err := json.Unmarshal([]byte(content), &obj)
if err != nil {
return false
}
// Check if a map type
if _, ok := obj.(map[string]interface{}); ok {
r... | go | {
"resource": ""
} |
q179041 | ByUsername | test | func (u *UserRepository) ByUsername(username string) (*User, error) {
if user, ok := u.Users[username]; ok {
return user, nil
}
return nil, ErrNotFound
} | go | {
"resource": ""
} |
q179042 | ByID | test | func (u *UserRepository) ByID(ID int) (*User, error) {
for _, user := range u.Users {
if user.ID == ID {
return user, nil
}
}
return nil, ErrNotFound
} | go | {
"resource": ""
} |
q179043 | UserLogin | test | func UserLogin(w http.ResponseWriter, r *http.Request) {
var login types.LoginRequest
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Header().Set("X-Api-Correlation-Id", "1234")
body, err := ioutil.ReadAll(r.Body)
defer r.Body.Close()
if err != nil {
w.WriteHeader(http.StatusServiceUnavai... | go | {
"resource": ""
} |
q179044 | newClient | test | func newClient(MockServiceManager client.Service, verificationServiceManager client.Service, messageServiceManager client.Service, publishServiceManager client.Service) *PactClient {
MockServiceManager.Setup()
verificationServiceManager.Setup()
messageServiceManager.Setup()
publishServiceManager.Setup()
return &P... | go | {
"resource": ""
} |
q179045 | NewClient | test | func NewClient() *PactClient {
return newClient(&client.MockService{}, &client.VerificationService{}, &client.MessageService{}, &client.PublishService{})
} | go | {
"resource": ""
} |
q179046 | ListServers | test | func (p *PactClient) ListServers() []*types.MockServer {
log.Println("[DEBUG] client: starting a server")
var servers []*types.MockServer
for port, s := range p.pactMockSvcManager.List() {
servers = append(servers, &types.MockServer{
Pid: s.Process.Pid,
Port: port,
})
}
return servers
} | go | {
"resource": ""
} |
q179047 | UpdateMessagePact | test | func (p *PactClient) UpdateMessagePact(request types.PactMessageRequest) error {
log.Println("[DEBUG] client: adding pact message...")
// Convert request into flags, and validate request
err := request.Validate()
if err != nil {
return err
}
svc := p.messageSvcManager.NewService(request.Args)
cmd := svc.Comm... | go | {
"resource": ""
} |
q179048 | PublishPacts | test | func (p *PactClient) PublishPacts(request types.PublishRequest) error {
svc := p.publishSvcManager.NewService(request.Args)
log.Println("[DEBUG] about to publish pacts")
cmd := svc.Start()
log.Println("[DEBUG] waiting for response")
err := cmd.Wait()
log.Println("[DEBUG] response from publish", err)
return er... | go | {
"resource": ""
} |
q179049 | getPort | test | func getPort(rawURL string) int {
parsedURL, err := url.Parse(rawURL)
if err == nil {
splitHost := strings.Split(parsedURL.Host, ":")
if len(splitHost) == 2 {
port, err := strconv.Atoi(splitHost[1])
if err == nil {
return port
}
}
if parsedURL.Scheme == "https" {
return 443
}
return 80
}
... | go | {
"resource": ""
} |
q179050 | getAddress | test | func getAddress(rawURL string) string {
parsedURL, err := url.Parse(rawURL)
if err != nil {
return ""
}
splitHost := strings.Split(parsedURL.Host, ":")
return splitHost[0]
} | go | {
"resource": ""
} |
q179051 | sanitiseRubyResponse | test | func sanitiseRubyResponse(response string) string {
log.Println("[TRACE] response from Ruby process pre-sanitisation:", response)
r := regexp.MustCompile("(?m)^\\s*#.*$")
s := r.ReplaceAllString(response, "")
r = regexp.MustCompile("(?m).*bundle exec rake pact:verify.*$")
s = r.ReplaceAllString(s, "")
r = rege... | go | {
"resource": ""
} |
q179052 | Publish | test | func (p *Publisher) Publish(request types.PublishRequest) error {
log.Println("[DEBUG] pact publisher: publish pact")
if p.pactClient == nil {
c := NewClient()
p.pactClient = c
}
err := request.Validate()
if err != nil {
return err
}
return p.pactClient.PublishPacts(request)
} | go | {
"resource": ""
} |
q179053 | FindPortInRange | test | func FindPortInRange(s string) (int, error) {
// Take care of csv and single value
if !strings.Contains(s, "-") {
ports := strings.Split(strings.TrimSpace(s), ",")
for _, p := range ports {
i, err := strconv.Atoi(p)
if err != nil {
return 0, err
}
err = checkPort(i)
if err != nil {
continue... | go | {
"resource": ""
} |
q179054 | EachLike | test | func EachLike(content interface{}, minRequired int) Matcher {
return eachLike{
Contents: content,
Min: minRequired,
}
} | go | {
"resource": ""
} |
q179055 | Term | test | func Term(generate string, matcher string) Matcher {
return term{
Data: termData{
Generate: generate,
Matcher: termMatcher{
Type: "Regexp",
O: 0,
Regex: matcher,
},
},
}
} | go | {
"resource": ""
} |
q179056 | UnmarshalJSON | test | func (m *MapMatcher) UnmarshalJSON(bytes []byte) (err error) {
sk := make(map[string]string)
err = json.Unmarshal(bytes, &sk)
if err != nil {
return
}
*m = make(map[string]Matcher)
for k, v := range sk {
(*m)[k] = String(v)
}
return
} | go | {
"resource": ""
} |
q179057 | objectToString | test | func objectToString(obj interface{}) string {
switch content := obj.(type) {
case string:
return content
default:
jsonString, err := json.Marshal(obj)
if err != nil {
log.Println("[DEBUG] objectToString: error unmarshaling object into string:", err.Error())
return ""
}
return string(jsonString)
}
} | go | {
"resource": ""
} |
q179058 | match | test | func match(srcType reflect.Type, params params) Matcher {
switch kind := srcType.Kind(); kind {
case reflect.Ptr:
return match(srcType.Elem(), params)
case reflect.Slice, reflect.Array:
return EachLike(match(srcType.Elem(), getDefaults()), params.slice.min)
case reflect.Struct:
result := StructMatcher{}
fo... | go | {
"resource": ""
} |
q179059 | AddMessage | test | func (p *Pact) AddMessage() *Message {
log.Println("[DEBUG] pact add message")
m := &Message{}
p.MessageInteractions = append(p.MessageInteractions, m)
return m
} | go | {
"resource": ""
} |
q179060 | AddInteraction | test | func (p *Pact) AddInteraction() *Interaction {
p.Setup(true)
log.Println("[DEBUG] pact add interaction")
i := &Interaction{}
p.Interactions = append(p.Interactions, i)
return i
} | go | {
"resource": ""
} |
q179061 | Teardown | test | func (p *Pact) Teardown() *Pact {
log.Println("[DEBUG] teardown")
if p.Server != nil {
server, err := p.pactClient.StopServer(p.Server)
if err != nil {
log.Println("error:", err)
}
p.Server = server
}
return p
} | go | {
"resource": ""
} |
q179062 | Verify | test | func (p *Pact) Verify(integrationTest func() error) error {
p.Setup(true)
log.Println("[DEBUG] pact verify")
// Check if we are verifying messages or if we actually have interactions
if len(p.Interactions) == 0 {
return errors.New("there are no interactions to be verified")
}
mockServer := &MockService{
Bas... | go | {
"resource": ""
} |
q179063 | stateHandlerMiddleware | test | func stateHandlerMiddleware(stateHandlers types.StateHandlers) proxy.Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/__setup" {
var s *types.ProviderState
decoder := json.NewDecoder(r.Body)
decoder.Dec... | go | {
"resource": ""
} |
q179064 | VerifyMessageProviderRaw | test | func (p *Pact) VerifyMessageProviderRaw(request VerifyMessageRequest) (types.ProviderVerifierResponse, error) {
p.Setup(false)
response := types.ProviderVerifierResponse{}
// Starts the message wrapper API with hooks back to the message handlers
// This maps the 'description' field of a message pact, to a function... | go | {
"resource": ""
} |
q179065 | VerifyMessageConsumerRaw | test | func (p *Pact) VerifyMessageConsumerRaw(message *Message, handler MessageConsumer) error {
log.Printf("[DEBUG] verify message")
p.Setup(false)
// Reify the message back to its "example/generated" form
reified, err := p.pactClient.ReifyMessage(&types.PactReificationRequest{
Message: message.Content,
})
if err ... | go | {
"resource": ""
} |
q179066 | VerifyProvider | test | func (p *mockClient) VerifyProvider(request types.VerifyRequest) (types.ProviderVerifierResponse, error) {
return p.VerifyProviderResponse, p.VerifyProviderError
} | go | {
"resource": ""
} |
q179067 | NewService | test | func (m *MockService) NewService(args []string) Service {
m.Args = []string{
"service",
}
m.Args = append(m.Args, args...)
m.Cmd = getMockServiceCommandPath()
return m
} | go | {
"resource": ""
} |
q179068 | Setup | test | func (s *ServiceManager) Setup() {
log.Println("[DEBUG] setting up a service manager")
s.commandCreatedChan = make(chan *exec.Cmd)
s.commandCompleteChan = make(chan *exec.Cmd)
s.processMap = processMap{processes: make(map[int]*exec.Cmd)}
// Listen for service create/kill
go s.addServiceMonitor()
go s.removeSer... | go | {
"resource": ""
} |
q179069 | addServiceMonitor | test | func (s *ServiceManager) addServiceMonitor() {
log.Println("[DEBUG] starting service creation monitor")
for {
select {
case p := <-s.commandCreatedChan:
if p != nil && p.Process != nil {
s.processMap.Set(p.Process.Pid, p)
}
}
}
} | go | {
"resource": ""
} |
q179070 | removeServiceMonitor | test | func (s *ServiceManager) removeServiceMonitor() {
log.Println("[DEBUG] starting service removal monitor")
var p *exec.Cmd
for {
select {
case p = <-s.commandCompleteChan:
if p != nil && p.Process != nil {
p.Process.Signal(os.Interrupt)
s.processMap.Delete(p.Process.Pid)
}
}
}
} | go | {
"resource": ""
} |
q179071 | List | test | func (s *ServiceManager) List() map[int]*exec.Cmd {
log.Println("[DEBUG] listing services")
return s.processMap.processes
} | go | {
"resource": ""
} |
q179072 | Command | test | func (s *ServiceManager) Command() *exec.Cmd {
cmd := exec.Command(s.Cmd, s.Args...)
env := os.Environ()
env = append(env, s.Env...)
cmd.Env = env
return cmd
} | go | {
"resource": ""
} |
q179073 | call | test | func (m *MockService) call(method string, url string, content interface{}) error {
body, err := json.Marshal(content)
if err != nil {
fmt.Println(err)
return err
}
client := &http.Client{}
var req *http.Request
if method == "POST" {
req, err = http.NewRequest(method, url, bytes.NewReader(body))
} else {
... | go | {
"resource": ""
} |
q179074 | DeleteInteractions | test | func (m *MockService) DeleteInteractions() error {
log.Println("[DEBUG] mock service delete interactions")
url := fmt.Sprintf("%s/interactions", m.BaseURL)
return m.call("DELETE", url, nil)
} | go | {
"resource": ""
} |
q179075 | AddInteraction | test | func (m *MockService) AddInteraction(interaction *Interaction) error {
log.Println("[DEBUG] mock service add interaction")
url := fmt.Sprintf("%s/interactions", m.BaseURL)
return m.call("POST", url, interaction)
} | go | {
"resource": ""
} |
q179076 | WritePact | test | func (m *MockService) WritePact() error {
log.Println("[DEBUG] mock service write pact")
if m.Consumer == "" || m.Provider == "" {
return errors.New("Consumer and Provider name need to be provided")
}
if m.PactFileWriteMode == "" {
m.PactFileWriteMode = "overwrite"
}
pact := map[string]interface{}{
"consu... | go | {
"resource": ""
} |
q179077 | ExpectsToReceive | test | func (p *Message) ExpectsToReceive(description string) *Message {
p.Description = description
return p
} | go | {
"resource": ""
} |
q179078 | WithMetadata | test | func (p *Message) WithMetadata(metadata MapMatcher) *Message {
p.Metadata = metadata
return p
} | go | {
"resource": ""
} |
q179079 | AsType | test | func (p *Message) AsType(t interface{}) *Message {
fmt.Println("[DEBUG] setting Message decoding to type:", reflect.TypeOf(t))
p.Type = t
return p
} | go | {
"resource": ""
} |
q179080 | UserLogin | test | func UserLogin(c *gin.Context) {
c.Header("X-Api-Correlation-Id", "1234")
var json Login
if c.BindJSON(&json) == nil {
user, err := userRepository.ByUsername(json.User)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"status": "file not found"})
} else if user.Username != json.User || user.Password != js... | go | {
"resource": ""
} |
q179081 | Region | test | func (s *S3) Region() string {
region := os.Getenv("AWS_REGION")
switch s.Domain {
case "s3.amazonaws.com", "s3-external-1.amazonaws.com":
return "us-east-1"
case "s3-accelerate.amazonaws.com":
if region == "" {
panic("can't find endpoint region")
}
return region
default:
regions := regionMatcher.Find... | go | {
"resource": ""
} |
q179082 | New | test | func New(domain string, keys Keys) *S3 {
if domain == "" {
domain = DefaultDomain
}
return &S3{domain, keys}
} | go | {
"resource": ""
} |
q179083 | Bucket | test | func (s *S3) Bucket(name string) *Bucket {
return &Bucket{
S3: s,
Name: name,
Config: DefaultConfig,
}
} | go | {
"resource": ""
} |
q179084 | PutWriter | test | func (b *Bucket) PutWriter(path string, h http.Header, c *Config) (w io.WriteCloser, err error) {
if c == nil {
c = b.conf()
}
u, err := b.url(path, c)
if err != nil {
return nil, err
}
return newPutter(*u, h, c, b)
} | go | {
"resource": ""
} |
q179085 | url | test | func (b *Bucket) url(bPath string, c *Config) (*url.URL, error) {
// parse versionID parameter from path, if included
// See https://github.com/rlmcpherson/s3gof3r/issues/84 for rationale
purl, err := url.Parse(bPath)
if err != nil {
return nil, err
}
var vals url.Values
if v := purl.Query().Get(versionParam)... | go | {
"resource": ""
} |
q179086 | SetLogger | test | func SetLogger(out io.Writer, prefix string, flag int, debug bool) {
logger = internalLogger{
log.New(out, prefix, flag),
debug,
}
} | go | {
"resource": ""
} |
q179087 | InstanceKeys | test | func InstanceKeys() (keys Keys, err error) {
rolePath := "http://169.254.169.254/latest/meta-data/iam/security-credentials/"
var creds mdCreds
// request the role name for the instance
// assumes there is only one
resp, err := ClientWithTimeout(2 * time.Second).Get(rolePath)
if err != nil {
return
}
defer c... | go | {
"resource": ""
} |
q179088 | EnvKeys | test | func EnvKeys() (keys Keys, err error) {
keys = Keys{
AccessKey: os.Getenv("AWS_ACCESS_KEY_ID"),
SecretKey: os.Getenv("AWS_SECRET_ACCESS_KEY"),
SecurityToken: os.Getenv("AWS_SECURITY_TOKEN"),
}
if keys.AccessKey == "" || keys.SecretKey == "" {
err = fmt.Errorf("keys not set in environment: AWS_ACCESS_... | go | {
"resource": ""
} |
q179089 | Sign | test | func (b *Bucket) Sign(req *http.Request) {
if req.Header == nil {
req.Header = http.Header{}
}
if b.S3.Keys.SecurityToken != "" {
req.Header.Set("X-Amz-Security-Token", b.S3.Keys.SecurityToken)
}
req.Header.Set("User-Agent", "S3Gof3r")
s := &signer{
Time: time.Now(),
Request: req,
Region: b.S3.Regio... | go | {
"resource": ""
} |
q179090 | getAWSKeys | test | func getAWSKeys() (keys s3gof3r.Keys, err error) {
keys, err = s3gof3r.EnvKeys()
if err == nil {
return
}
keys, err = s3gof3r.InstanceKeys()
if err == nil {
return
}
err = errors.New("no AWS keys found")
return
} | go | {
"resource": ""
} |
q179091 | homeDir | test | func homeDir() (string, error) {
if h := os.Getenv("HOME"); h != "" {
return h, nil
}
h, err := exec.Command("sh", "-c", "eval echo ~$USER").Output()
if err == nil && len(h) > 0 {
return strings.TrimSpace(string(h)), nil
}
return "", fmt.Errorf("home directory not found for current user")
} | go | {
"resource": ""
} |
q179092 | ACL | test | func ACL(h http.Header, acl string) http.Header {
if acl != "" {
h.Set("x-amz-acl", acl)
}
return h
} | go | {
"resource": ""
} |
q179093 | putPart | test | func (p *putter) putPart(part *part) error {
v := url.Values{}
v.Set("partNumber", strconv.Itoa(part.PartNumber))
v.Set("uploadId", p.UploadID)
if _, err := part.r.Seek(0, 0); err != nil { // move back to beginning, if retrying
return err
}
req, err := http.NewRequest("PUT", p.url.String()+"?"+v.Encode(), part.... | go | {
"resource": ""
} |
q179094 | abort | test | func (p *putter) abort() {
v := url.Values{}
v.Set("uploadId", p.UploadID)
s := p.url.String() + "?" + v.Encode()
resp, err := p.retryRequest("DELETE", s, nil, nil)
if err != nil {
logger.Printf("Error aborting multipart upload: %v\n", err)
return
}
defer checkClose(resp.Body, err)
if resp.StatusCode != 204... | go | {
"resource": ""
} |
q179095 | growPartSize | test | func growPartSize(partIndex int, partSize, putsz int64) bool {
return (maxObjSize-putsz)/(maxNPart-int64(partIndex)) > partSize
} | go | {
"resource": ""
} |
q179096 | CheckDisallowed | test | func CheckDisallowed(prefix string, spec interface{}) error {
infos, err := gatherInfo(prefix, spec)
if err != nil {
return err
}
vars := make(map[string]struct{})
for _, info := range infos {
vars[info.Key] = struct{}{}
}
if prefix != "" {
prefix = strings.ToUpper(prefix) + "_"
}
for _, env := range ... | go | {
"resource": ""
} |
q179097 | Process | test | func Process(prefix string, spec interface{}) error {
infos, err := gatherInfo(prefix, spec)
for _, info := range infos {
// `os.Getenv` cannot differentiate between an explicitly set empty value
// and an unset value. `os.LookupEnv` is preferred to `syscall.Getenv`,
// but it is only available in go1.5 or ne... | go | {
"resource": ""
} |
q179098 | MustProcess | test | func MustProcess(prefix string, spec interface{}) {
if err := Process(prefix, spec); err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q179099 | toTypeDescription | test | func toTypeDescription(t reflect.Type) string {
switch t.Kind() {
case reflect.Array, reflect.Slice:
return fmt.Sprintf("Comma-separated list of %s", toTypeDescription(t.Elem()))
case reflect.Map:
return fmt.Sprintf(
"Comma-separated list of %s:%s pairs",
toTypeDescription(t.Key()),
toTypeDescription(t.... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.