id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c179000 |
if err := selectedElement.Value(text); err != nil {
return fmt.Errorf("failed to enter text into %s: %s", s, err)
}
return nil
})
} | |
c179001 | }
return s.forEachElement(func(selectedElement element.Element) error {
if err := touchFunc(selectedElement.(*api.Element)); err != nil {
return fmt.Errorf("failed to %s on %s: %s", event, s, err)
}
return nil
})
} | |
c179002 | %s on %s: invalid touch event", event, s)
}
return s.forEachElement(func(selectedElement element.Element) error {
x, y, err := selectedElement.GetLocation()
if err != nil {
return fmt.Errorf("failed to retrieve location of %s: %s", s, err)
}
if err := touchFunc(x, y); err != nil {
return fmt.Errorf("failed to flick finger on %s: %s", s, err)
}
return nil
})
} | |
c179003 | from %s: %s", s, err)
}
if err := s.session.TouchFlick(selectedElement.(*api.Element), api.XYOffset{X: xOffset, Y: yOffset}, api.ScalarSpeed(speed)); err != nil {
return fmt.Errorf("failed to flick finger on %s: %s", s, err)
}
return nil
} | |
c179004 | element from %s: %s", s, err)
}
if err := s.session.TouchScroll(selectedElement.(*api.Element), api.XYOffset{X: xOffset, Y: yOffset}); err != nil {
return fmt.Errorf("failed to scroll finger on %s: %s", s, err)
}
return nil
} | |
c179005 | := Capabilities{}
for _, feature := range features {
c.With(feature)
}
return c
} | |
c179006 | return string(capabilitiesJSON), err
} | |
c179007 | &internal.ValueMatcher{Method: "Title", Property: "title", Expected: title}
} | |
c179008 | &internal.ValueMatcher{Method: "URL", Property: "URL", Expected: url}
} | |
c179009 | &internal.ValueMatcher{Method: "PopupText", Property: "popup text", Expected: text}
} | |
c179010 |
Levels: []string{"WARNING", "SEVERE"},
Name: "error",
Type: "browser",
}
} | |
c179011 | err != nil {
return "", fmt.Errorf("failed to retrieve text for %s: %s", s, err)
}
return text, nil
} | |
c179012 | %s", err)
}
equal, err := selectedElement.IsEqualTo(activeElement)
if err != nil {
return false, fmt.Errorf("failed to compare selection to active element: %s", err)
}
return equal, nil
} | |
c179013 | {
return s.hasProperty(element.Element.GetAttribute, attribute, "attribute")
} | |
c179014 | {
return s.hasProperty(element.Element.GetCSS, property, "CSS property")
} | |
c179015 | {
return s.hasState(element.Element.IsSelected, "selected")
} | |
c179016 | {
return s.hasState(element.Element.IsDisplayed, "visible")
} | |
c179017 | {
return s.hasState(element.Element.IsEnabled, "enabled")
} | |
c179018 | "Count", Property: "element count", Expected: count}
} | |
c179019 | {
return &internal.HaveAttributeMatcher{ExpectedAttribute: attribute, ExpectedValue: value}
} | |
c179020 | }
command := []string{binaryName, "--port={{.Port}}"}
// Using {{.Address}} means using 127.0.0.1
// But MicrosoftWebDriver only supports localhost, not 127.0.0.1
return NewWebDriver("http://localhost:{{.Port}}", command, options...)
} | |
c179021 | append([]Option{Timeout(90), Browser("android")}, options...)
return NewWebDriver("http://{{.Address}}/wd/hub", command, options...)
} | |
c179022 | 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 %s: %s", s, err)
}
return nil
} | |
c179023 | to select elements from %s: %s", s, err)
}
return len(elements), nil
} | |
c179024 |
return false, fmt.Errorf("failed to select element from %s: %s", other, err)
}
equal, err := selectedElement.IsEqualTo(otherElement.(*api.Element))
if err != nil {
return false, fmt.Errorf("failed to compare %s to %s: %s", s, other, err)
}
return equal, nil
} | |
c179025 | 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 for %s: %s", s, err)
}
return nil
} | |
c179026 | received connection from %s on path %s\n", r.RemoteAddr, r.RequestURI)
next.ServeHTTP(w, r)
})
} | |
c179027 | r *http.Request) {
last := final
for i := len(mw) - 1; i >= 0; i-- {
last = mw[i](last)
}
last.ServeHTTP(w, r)
})
}
} | |
c179028 | chainHandlers(append(options.Middleware, loggingMiddleware)...)
log.Println("[DEBUG] starting reverse proxy on port", port)
go http.ListenAndServe(fmt.Sprintf(":%d", port), wrapper(proxy))
return port, nil
} | |
c179029 | return err
}
if err = i.CheckVersion(binary, version); err != nil {
return err
}
}
return nil
} | |
c179030 |
return fmt.Errorf("unable to find version range for binary %s", binary)
}
log.Println("[DEBUG] checking if version", v, "within semver range", versionRange)
constraints, err := goversion.NewConstraint(versionRange)
if constraints.Check(v) {
log.Println("[DEBUG]", v, "satisfies constraints", v, constraints)
return nil
}
return fmt.Errorf("version %s of %s does not match constraint %s", version, binary, versionRange)
} | |
c179031 | err := i.commander.Output(binary, "version")
elements := strings.Split(strings.TrimSpace(string(content)), "\n")
version = strings.TrimSpace(elements[len(elements)-1])
return version, err
} | |
c179032 | mismatch during Verification.
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", c.token)
res, err := http.DefaultClient.Do(req)
if res.StatusCode != 200 || err != nil {
return nil, fmt.Errorf("get user failed")
}
data, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
var response ex.User
err = json.Unmarshal(data, &response)
if err != nil {
return nil, err
}
return &response, err
} | |
c179033 | failed")
}
data, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
var response loginResponse
err = json.Unmarshal(data, &response)
if err != nil {
return nil, err
}
return &response.User, err
} | |
c179034 | c.err = nil
http.Redirect(w, r, "/", http.StatusFound)
return
}
c.err = fmt.Errorf("Invalid username/password")
http.Redirect(w, r, "/", http.StatusFound)
return
} | |
c179035 |
http.Redirect(w, r, "/", http.StatusFound)
return
} | |
c179036 | c.user,
Error: c.err,
}
renderTemplate(w, "login", data)
} | |
c179037 |
fmt.Println("User svc client running on port 8081")
http.ListenAndServe(":8081", nil)
} | |
c179038 | appears to be a JSON formatted object, " +
"no structural matching will occur. Support for structured strings has been" +
"deprecated as of 0.13.0")
}
return i
} | |
c179039 | i.Response = response
return i
} | |
c179040 | return false
}
// Check if a map type
if _, ok := obj.(map[string]interface{}); ok {
return true
}
}
return false
} | |
c179041 |
return user, nil
}
return nil, ErrNotFound
} | |
c179042 | ID {
return user, nil
}
}
return nil, ErrNotFound
} | |
c179043 | login.Username || user.Password != login.Password {
w.WriteHeader(http.StatusUnauthorized)
} else {
w.Header().Set("X-Auth-Token", getAuthToken())
w.WriteHeader(http.StatusOK)
res := types.LoginResponse{User: user}
resBody, _ := json.Marshal(res)
w.Write(resBody)
}
} | |
c179044 | verificationSvcManager: verificationServiceManager,
messageSvcManager: messageServiceManager,
publishSvcManager: publishServiceManager,
TimeoutDuration: 10 * time.Second,
}
} | |
c179045 | &client.VerificationService{}, &client.MessageService{}, &client.PublishService{})
} | |
c179046 |
servers = append(servers, &types.MockServer{
Pid: s.Process.Pid,
Port: port,
})
}
return servers
} | |
c179047 |
if err != nil {
return err
}
stdOut, err := ioutil.ReadAll(stdOutPipe)
if err != nil {
return err
}
stdErr, err := ioutil.ReadAll(stdErrPipe)
if err != nil {
return err
}
err = cmd.Wait()
if err == nil {
return nil
}
return fmt.Errorf("error creating message: %s\n\nSTDERR:\n%s\n\nSTDOUT:\n%s", err, stdErr, stdOut)
} | |
c179048 |
log.Println("[DEBUG] waiting for response")
err := cmd.Wait()
log.Println("[DEBUG] response from publish", err)
return err
} | |
c179049 | err == nil {
return port
}
}
if parsedURL.Scheme == "https" {
return 443
}
return 80
}
return -1
} | |
c179050 | if err != nil {
return ""
}
splitHost := strings.Split(parsedURL.Host, ":")
return splitHost[0]
} | |
c179051 | regexp.MustCompile("(?m).*bundle exec rake pact:verify.*$")
s = r.ReplaceAllString(s, "")
r = regexp.MustCompile("\\n+")
s = r.ReplaceAllString(s, "\n")
return s
} | |
c179052 | }
err := request.Validate()
if err != nil {
return err
}
return p.pactClient.PublishPacts(request)
} | |
c179053 | strconv.Atoi(ports[0])
if err != nil {
return 0, err
}
upper, err := strconv.Atoi(ports[1])
if err != nil {
return 0, err
}
if upper < lower {
return 0, errors.New("invalid range passed")
}
for i := lower; i <= upper; i++ {
err = checkPort(i)
if err != nil {
continue
}
return i, nil
}
return 0, errors.New("all passed ports are unusable")
} | |
c179054 | {
return eachLike{
Contents: content,
Min: minRequired,
}
} | |
c179055 | Generate: generate,
Matcher: termMatcher{
Type: "Regexp",
O: 0,
Regex: matcher,
},
},
}
} | |
c179056 | &sk)
if err != nil {
return
}
*m = make(map[string]Matcher)
for k, v := range sk {
(*m)[k] = String(v)
}
return
} | |
c179057 | := json.Marshal(obj)
if err != nil {
log.Println("[DEBUG] objectToString: error unmarshaling object into string:", err.Error())
return ""
}
return string(jsonString)
}
} | |
c179058 | return Like(params.str.example)
}
return Like("string")
case reflect.Bool:
return Like(true)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return Like(1)
case reflect.Float32, reflect.Float64:
return Like(1.1)
default:
panic(fmt.Sprintf("match: unhandled type: %v", srcType))
}
} | |
c179059 | message")
m := &Message{}
p.MessageInteractions = append(p.MessageInteractions, m)
return m
} | |
c179060 | pact add interaction")
i := &Interaction{}
p.Interactions = append(p.Interactions, i)
return i
} | |
c179061 | != nil {
log.Println("error:", err)
}
p.Server = server
}
return p
} | |
c179062 | return err
}
}
// Run the integration test
err := integrationTest()
if err != nil {
return err
}
// Run Verification Process
err = mockServer.Verify()
if err != nil {
return err
}
// Clear out interations
p.Interactions = make([]*Interaction, 0)
return mockServer.DeleteInteractions()
} | |
c179063 | log.Printf("[ERROR] state handler for '%v' errored: %v", state, err)
w.WriteHeader(http.StatusInternalServerError)
return
}
}
}
w.WriteHeader(http.StatusOK)
return
}
log.Println("[DEBUG] skipping state handler for request", r.RequestURI)
// Pass through to application
next.ServeHTTP(w, r)
})
}
} | |
c179064 | p.Provider,
}
mux.HandleFunc("/", messageVerificationHandler(request.MessageHandlers, request.StateHandlers))
ln, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
if err != nil {
log.Fatal(err)
}
defer ln.Close()
log.Printf("[DEBUG] API handler starting: port %d (%s)", port, ln.Addr())
go http.Serve(ln, mux)
portErr := waitForPort(port, "tcp", "localhost", p.ClientTimeout,
fmt.Sprintf(`Timed out waiting for pact proxy on port %d - check for errors`, port))
if portErr != nil {
log.Fatal("Error:", err)
return response, portErr
}
log.Println("[DEBUG] pact provider verification")
return p.pactClient.VerifyProvider(verificationRequest)
} | |
c179065 | message.States,
Description: message.Description,
Metadata: message.Metadata,
}
err = handler(generatedMessage)
if err != nil {
return err
}
// If no errors, update Message Pact
return p.pactClient.UpdateMessagePact(types.PactMessageRequest{
Message: message,
Consumer: p.Consumer,
Provider: p.Provider,
PactDir: p.PactDir,
})
} | |
c179066 | p.VerifyProviderResponse, p.VerifyProviderError
} | |
c179067 | args...)
m.Cmd = getMockServiceCommandPath()
return m
} | |
c179068 | 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.removeServiceMonitor()
} | |
c179069 | != nil && p.Process != nil {
s.processMap.Set(p.Process.Pid, p)
}
}
}
} | |
c179070 | != nil && p.Process != nil {
p.Process.Signal(os.Interrupt)
s.processMap.Delete(p.Process.Pid)
}
}
}
} | |
c179071 |
log.Println("[DEBUG] listing services")
return s.processMap.processes
} | |
c179072 | s.Args...)
env := os.Environ()
env = append(env, s.Env...)
cmd.Env = env
return cmd
} | |
c179073 | err := client.Do(req)
if err != nil {
return err
}
responseBody, err := ioutil.ReadAll(res.Body)
res.Body.Close()
if res.StatusCode < 200 || res.StatusCode >= 300 {
return errors.New(string(responseBody))
}
return err
} | |
c179074 | url := fmt.Sprintf("%s/interactions", m.BaseURL)
return m.call("DELETE", url, nil)
} | |
c179075 | mock service add interaction")
url := fmt.Sprintf("%s/interactions", m.BaseURL)
return m.call("POST", url, interaction)
} | |
c179076 | map[string]string{
"name": m.Consumer,
},
"provider": map[string]string{
"name": m.Provider,
},
"pactFileWriteMode": m.PactFileWriteMode,
}
url := fmt.Sprintf("%s/pact", m.BaseURL)
return m.call("POST", url, pact)
} | |
c179077 | p.Description = description
return p
} | |
c179078 | p.Metadata = metadata
return p
} | |
c179079 | type:", reflect.TypeOf(t))
p.Type = t
return p
} | |
c179080 | c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
} else {
c.Header("X-Auth-Token", getAuthToken())
c.JSON(http.StatusOK, types.LoginResponse{User: user})
}
}
} | |
c179081 | return region
default:
regions := regionMatcher.FindStringSubmatch(s.Domain)
if len(regions) < 2 {
if region == "" {
panic("can't find endpoint region")
}
return region
}
return regions[1]
}
} | |
c179082 | == "" {
domain = DefaultDomain
}
return &S3{domain, keys}
} | |
c179083 |
Name: name,
Config: DefaultConfig,
}
} | |
c179084 | b.url(path, c)
if err != nil {
return nil, err
}
return newPutter(*u, h, c, b)
} | |
c179085 |
Host: b.S3.Domain,
Scheme: c.Scheme,
Path: path.Clean(fmt.Sprintf("/%s/%s", b.Name, bPath)),
RawQuery: vals.Encode(),
}, nil
} else {
return &url.URL{
Scheme: c.Scheme,
Path: path.Clean(fmt.Sprintf("/%s", bPath)),
Host: path.Clean(fmt.Sprintf("%s.%s", b.Name, b.S3.Domain)),
RawQuery: vals.Encode(),
}, nil
}
} | |
c179086 | bool) {
logger = internalLogger{
log.New(out, prefix, flag),
debug,
}
} | |
c179087 | }
role, err := ioutil.ReadAll(resp.Body)
if err != nil {
return
}
// request the credential metadata for the role
resp, err = http.Get(rolePath + string(role))
if err != nil {
return
}
defer checkClose(resp.Body, err)
if resp.StatusCode != 200 {
err = newRespError(resp)
return
}
metadata, err := ioutil.ReadAll(resp.Body)
if err != nil {
return
}
if err = json.Unmarshal([]byte(metadata), &creds); err != nil {
return
}
keys = Keys{
AccessKey: creds.AccessKeyID,
SecretKey: creds.SecretAccessKey,
SecurityToken: creds.Token,
}
return
} | |
c179088 | == "" || keys.SecretKey == "" {
err = fmt.Errorf("keys not set in environment: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY")
}
return
} | |
c179089 | &signer{
Time: time.Now(),
Request: req,
Region: b.S3.Region(),
Keys: b.S3.Keys,
}
s.sign()
} | |
c179090 | nil {
return
}
keys, err = s3gof3r.InstanceKeys()
if err == nil {
return
}
err = errors.New("no AWS keys found")
return
} | |
c179091 | 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")
} | |
c179092 | h.Set("x-amz-acl", acl)
}
return h
} | |
c179093 | {
return newRespError(resp)
}
s := resp.Header.Get("etag")
if len(s) < 2 {
return fmt.Errorf("Got Bad etag:%s", s)
}
s = s[1 : len(s)-1] // includes quote chars for some reason
if part.ETag != s {
return fmt.Errorf("Response etag does not match. Remote:%s Calculated:%s", s, p.ETag)
}
return nil
} | |
c179094 | }
defer checkClose(resp.Body, err)
if resp.StatusCode != 204 {
logger.Printf("Error aborting multipart upload: %v", newRespError(resp))
}
return
} | |
c179095 | (maxObjSize-putsz)/(maxNPart-int64(partIndex)) > partSize
} | |
c179096 | continue
}
v := strings.SplitN(env, "=", 2)[0]
if _, found := vars[v]; !found {
return fmt.Errorf("unknown environment variable %s", v)
}
}
return nil
} | |
c179097 | return fmt.Errorf("required key %s missing value", info.Key)
}
continue
}
err = processField(value, info.Field)
if err != nil {
return &ParseError{
KeyName: info.Key,
FieldName: info.Name,
TypeName: info.Field.Type().String(),
Value: value,
Err: err,
}
}
}
return err
} | |
c179098 | := Process(prefix, spec); err != nil {
panic(err)
}
} | |
c179099 | name != "" && !strings.HasPrefix(name, "int") {
return name
}
return "Integer"
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
name := t.Name()
if name != "" && !strings.HasPrefix(name, "uint") {
return name
}
return "Unsigned Integer"
case reflect.Float32, reflect.Float64:
name := t.Name()
if name != "" && !strings.HasPrefix(name, "float") {
return name
}
return "Float"
}
return fmt.Sprintf("%+v", t)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.