+++ /dev/null
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package regtest
-
-import (
- "fmt"
- "regexp"
- "strings"
-
- "golang.org/x/tools/internal/lsp"
- "golang.org/x/tools/internal/lsp/protocol"
- "golang.org/x/tools/internal/span"
-)
-
-// An Expectation asserts that the state of the editor at a point in time
-// matches an expected condition. This is used for signaling in tests when
-// certain conditions in the editor are met.
-type Expectation interface {
- // Check determines whether the state of the editor satisfies the
- // expectation, returning the results that met the condition.
- Check(State) Verdict
- // Description is a human-readable description of the expectation.
- Description() string
-}
-
-var (
- // InitialWorkspaceLoad is an expectation that the workspace initial load has
- // completed. It is verified via workdone reporting.
- InitialWorkspaceLoad = CompletedWork(lsp.DiagnosticWorkTitle(lsp.FromInitialWorkspaceLoad), 1)
-)
-
-// A Verdict is the result of checking an expectation against the current
-// editor state.
-type Verdict int
-
-// Order matters for the following constants: verdicts are sorted in order of
-// decisiveness.
-const (
- // Met indicates that an expectation is satisfied by the current state.
- Met Verdict = iota
- // Unmet indicates that an expectation is not currently met, but could be met
- // in the future.
- Unmet
- // Unmeetable indicates that an expectation cannot be satisfied in the
- // future.
- Unmeetable
-)
-
-func (v Verdict) String() string {
- switch v {
- case Met:
- return "Met"
- case Unmet:
- return "Unmet"
- case Unmeetable:
- return "Unmeetable"
- }
- return fmt.Sprintf("unrecognized verdict %d", v)
-}
-
-// SimpleExpectation holds an arbitrary check func, and implements the Expectation interface.
-type SimpleExpectation struct {
- check func(State) Verdict
- description string
-}
-
-// Check invokes e.check.
-func (e SimpleExpectation) Check(s State) Verdict {
- return e.check(s)
-}
-
-// Description returns e.descriptin.
-func (e SimpleExpectation) Description() string {
- return e.description
-}
-
-// OnceMet returns an Expectation that, once the precondition is met, asserts
-// that mustMeet is met.
-func OnceMet(precondition Expectation, mustMeet Expectation) *SimpleExpectation {
- check := func(s State) Verdict {
- switch pre := precondition.Check(s); pre {
- case Unmeetable:
- return Unmeetable
- case Met:
- verdict := mustMeet.Check(s)
- if verdict != Met {
- return Unmeetable
- }
- return Met
- default:
- return Unmet
- }
- }
- return &SimpleExpectation{
- check: check,
- description: fmt.Sprintf("once %q is met, must have %q", precondition.Description(), mustMeet.Description()),
- }
-}
-
-// ReadDiagnostics is an 'expectation' that is used to read diagnostics
-// atomically. It is intended to be used with 'OnceMet'.
-func ReadDiagnostics(fileName string, into *protocol.PublishDiagnosticsParams) *SimpleExpectation {
- check := func(s State) Verdict {
- diags, ok := s.diagnostics[fileName]
- if !ok {
- return Unmeetable
- }
- *into = *diags
- return Met
- }
- return &SimpleExpectation{
- check: check,
- description: fmt.Sprintf("read diagnostics for %q", fileName),
- }
-}
-
-// NoOutstandingWork asserts that there is no work initiated using the LSP
-// $/progress API that has not completed.
-func NoOutstandingWork() SimpleExpectation {
- check := func(s State) Verdict {
- if len(s.outstandingWork) == 0 {
- return Met
- }
- return Unmet
- }
- return SimpleExpectation{
- check: check,
- description: "no outstanding work",
- }
-}
-
-// NoShowMessage asserts that the editor has not received a ShowMessage.
-func NoShowMessage() SimpleExpectation {
- check := func(s State) Verdict {
- if len(s.showMessage) == 0 {
- return Met
- }
- return Unmeetable
- }
- return SimpleExpectation{
- check: check,
- description: "no ShowMessage received",
- }
-}
-
-// ShownMessage asserts that the editor has received a ShownMessage with the
-// given title.
-func ShownMessage(title string) SimpleExpectation {
- check := func(s State) Verdict {
- for _, m := range s.showMessage {
- if strings.Contains(m.Message, title) {
- return Met
- }
- }
- return Unmet
- }
- return SimpleExpectation{
- check: check,
- description: "received ShowMessage",
- }
-}
-
-// ShowMessageRequest asserts that the editor has received a ShowMessageRequest
-// with an action item that has the given title.
-func ShowMessageRequest(title string) SimpleExpectation {
- check := func(s State) Verdict {
- if len(s.showMessageRequest) == 0 {
- return Unmet
- }
- // Only check the most recent one.
- m := s.showMessageRequest[len(s.showMessageRequest)-1]
- if len(m.Actions) == 0 || len(m.Actions) > 1 {
- return Unmet
- }
- if m.Actions[0].Title == title {
- return Met
- }
- return Unmet
- }
- return SimpleExpectation{
- check: check,
- description: "received ShowMessageRequest",
- }
-}
-
-// CompletedWork expects a work item to have been completed >= atLeast times.
-//
-// Since the Progress API doesn't include any hidden metadata, we must use the
-// progress notification title to identify the work we expect to be completed.
-func CompletedWork(title string, atLeast int) SimpleExpectation {
- check := func(s State) Verdict {
- if s.completedWork[title] >= atLeast {
- return Met
- }
- return Unmet
- }
- return SimpleExpectation{
- check: check,
- description: fmt.Sprintf("completed work %q at least %d time(s)", title, atLeast),
- }
-}
-
-// LogExpectation is an expectation on the log messages received by the editor
-// from gopls.
-type LogExpectation struct {
- check func([]*protocol.LogMessageParams) Verdict
- description string
-}
-
-// Check implements the Expectation interface.
-func (e LogExpectation) Check(s State) Verdict {
- return e.check(s.logs)
-}
-
-// Description implements the Expectation interface.
-func (e LogExpectation) Description() string {
- return e.description
-}
-
-// NoErrorLogs asserts that the client has not received any log messages of
-// error severity.
-func NoErrorLogs() LogExpectation {
- return NoLogMatching(protocol.Error, "")
-}
-
-// LogMatching asserts that the client has received a log message
-// of type typ matching the regexp re.
-func LogMatching(typ protocol.MessageType, re string, count int) LogExpectation {
- rec, err := regexp.Compile(re)
- if err != nil {
- panic(err)
- }
- check := func(msgs []*protocol.LogMessageParams) Verdict {
- var found int
- for _, msg := range msgs {
- if msg.Type == typ && rec.Match([]byte(msg.Message)) {
- found++
- }
- }
- if found == count {
- return Met
- }
- return Unmet
- }
- return LogExpectation{
- check: check,
- description: fmt.Sprintf("log message matching %q", re),
- }
-}
-
-// NoLogMatching asserts that the client has not received a log message
-// of type typ matching the regexp re. If re is an empty string, any log
-// message is considered a match.
-func NoLogMatching(typ protocol.MessageType, re string) LogExpectation {
- var r *regexp.Regexp
- if re != "" {
- var err error
- r, err = regexp.Compile(re)
- if err != nil {
- panic(err)
- }
- }
- check := func(msgs []*protocol.LogMessageParams) Verdict {
- for _, msg := range msgs {
- if msg.Type != typ {
- continue
- }
- if r == nil || r.Match([]byte(msg.Message)) {
- return Unmeetable
- }
- }
- return Met
- }
- return LogExpectation{
- check: check,
- description: fmt.Sprintf("no log message matching %q", re),
- }
-}
-
-// RegistrationExpectation is an expectation on the capability registrations
-// received by the editor from gopls.
-type RegistrationExpectation struct {
- check func([]*protocol.RegistrationParams) Verdict
- description string
-}
-
-// Check implements the Expectation interface.
-func (e RegistrationExpectation) Check(s State) Verdict {
- return e.check(s.registrations)
-}
-
-// Description implements the Expectation interface.
-func (e RegistrationExpectation) Description() string {
- return e.description
-}
-
-// RegistrationMatching asserts that the client has received a capability
-// registration matching the given regexp.
-func RegistrationMatching(re string) RegistrationExpectation {
- rec, err := regexp.Compile(re)
- if err != nil {
- panic(err)
- }
- check := func(params []*protocol.RegistrationParams) Verdict {
- for _, p := range params {
- for _, r := range p.Registrations {
- if rec.Match([]byte(r.Method)) {
- return Met
- }
- }
- }
- return Unmet
- }
- return RegistrationExpectation{
- check: check,
- description: fmt.Sprintf("registration matching %q", re),
- }
-}
-
-// UnregistrationExpectation is an expectation on the capability
-// unregistrations received by the editor from gopls.
-type UnregistrationExpectation struct {
- check func([]*protocol.UnregistrationParams) Verdict
- description string
-}
-
-// Check implements the Expectation interface.
-func (e UnregistrationExpectation) Check(s State) Verdict {
- return e.check(s.unregistrations)
-}
-
-// Description implements the Expectation interface.
-func (e UnregistrationExpectation) Description() string {
- return e.description
-}
-
-// UnregistrationMatching asserts that the client has received an
-// unregistration whose ID matches the given regexp.
-func UnregistrationMatching(re string) UnregistrationExpectation {
- rec, err := regexp.Compile(re)
- if err != nil {
- panic(err)
- }
- check := func(params []*protocol.UnregistrationParams) Verdict {
- for _, p := range params {
- for _, r := range p.Unregisterations {
- if rec.Match([]byte(r.Method)) {
- return Met
- }
- }
- }
- return Unmet
- }
- return UnregistrationExpectation{
- check: check,
- description: fmt.Sprintf("unregistration matching %q", re),
- }
-}
-
-// A DiagnosticExpectation is a condition that must be met by the current set
-// of diagnostics for a file.
-type DiagnosticExpectation struct {
- // IsMet determines whether the diagnostics for this file version satisfy our
- // expectation.
- isMet func(*protocol.PublishDiagnosticsParams) bool
- // Description is a human-readable description of the diagnostic expectation.
- description string
- // Path is the scratch workdir-relative path to the file being asserted on.
- path string
-}
-
-// Check implements the Expectation interface.
-func (e DiagnosticExpectation) Check(s State) Verdict {
- if diags, ok := s.diagnostics[e.path]; ok && e.isMet(diags) {
- return Met
- }
- return Unmet
-}
-
-// Description implements the Expectation interface.
-func (e DiagnosticExpectation) Description() string {
- return fmt.Sprintf("%s: %s", e.path, e.description)
-}
-
-// EmptyDiagnostics asserts that empty diagnostics are sent for the
-// workspace-relative path name.
-func EmptyDiagnostics(name string) Expectation {
- check := func(s State) Verdict {
- if diags := s.diagnostics[name]; diags != nil && len(diags.Diagnostics) == 0 {
- return Met
- }
- return Unmet
- }
- return SimpleExpectation{
- check: check,
- description: "empty diagnostics",
- }
-}
-
-// NoDiagnostics asserts that no diagnostics are sent for the
-// workspace-relative path name. It should be used primarily in conjunction
-// with a OnceMet, as it has to check that all outstanding diagnostics have
-// already been delivered.
-func NoDiagnostics(name string) Expectation {
- check := func(s State) Verdict {
- if _, ok := s.diagnostics[name]; !ok {
- return Met
- }
- return Unmet
- }
- return SimpleExpectation{
- check: check,
- description: "no diagnostics",
- }
-}
-
-// AnyDiagnosticAtCurrentVersion asserts that there is a diagnostic report for
-// the current edited version of the buffer corresponding to the given
-// workdir-relative pathname.
-func (e *Env) AnyDiagnosticAtCurrentVersion(name string) DiagnosticExpectation {
- version := e.Editor.BufferVersion(name)
- isMet := func(diags *protocol.PublishDiagnosticsParams) bool {
- return int(diags.Version) == version
- }
- return DiagnosticExpectation{
- isMet: isMet,
- description: fmt.Sprintf("any diagnostics at version %d", version),
- path: name,
- }
-}
-
-// DiagnosticAtRegexp expects that there is a diagnostic entry at the start
-// position matching the regexp search string re in the buffer specified by
-// name. Note that this currently ignores the end position.
-func (e *Env) DiagnosticAtRegexp(name, re string) DiagnosticExpectation {
- e.T.Helper()
- pos := e.RegexpSearch(name, re)
- expectation := DiagnosticAt(name, pos.Line, pos.Column)
- expectation.description += fmt.Sprintf(" (location of %q)", re)
- return expectation
-}
-
-// DiagnosticAt asserts that there is a diagnostic entry at the position
-// specified by line and col, for the workdir-relative path name.
-func DiagnosticAt(name string, line, col int) DiagnosticExpectation {
- isMet := func(diags *protocol.PublishDiagnosticsParams) bool {
- for _, d := range diags.Diagnostics {
- if d.Range.Start.Line == float64(line) && d.Range.Start.Character == float64(col) {
- return true
- }
- }
- return false
- }
- return DiagnosticExpectation{
- isMet: isMet,
- description: fmt.Sprintf("diagnostic at {line:%d, column:%d}", line, col),
- path: name,
- }
-}
-
-// NoDiagnosticAtRegexp expects that there is no diagnostic entry at the start
-// position matching the regexp search string re in the buffer specified by
-// name. Note that this currently ignores the end position.
-// This should only be used in combination with OnceMet for a given condition,
-// otherwise it may always succeed.
-func (e *Env) NoDiagnosticAtRegexp(name, re string) DiagnosticExpectation {
- e.T.Helper()
- pos := e.RegexpSearch(name, re)
- expectation := NoDiagnosticAt(name, pos.Line, pos.Column)
- expectation.description += fmt.Sprintf(" (location of %q)", re)
- return expectation
-}
-
-// NoDiagnosticAt asserts that there is no diagnostic entry at the position
-// specified by line and col, for the workdir-relative path name.
-// This should only be used in combination with OnceMet for a given condition,
-// otherwise it may always succeed.
-func NoDiagnosticAt(name string, line, col int) DiagnosticExpectation {
- isMet := func(diags *protocol.PublishDiagnosticsParams) bool {
- for _, d := range diags.Diagnostics {
- if d.Range.Start.Line == float64(line) && d.Range.Start.Character == float64(col) {
- return false
- }
- }
- return true
- }
- return DiagnosticExpectation{
- isMet: isMet,
- description: fmt.Sprintf("no diagnostic at {line:%d, column:%d}", line, col),
- path: name,
- }
-}
-
-// NoDiagnosticWithMessage asserts that there is no diagnostic entry with the
-// given message.
-//
-// This should only be used in combination with OnceMet for a given condition,
-// otherwise it may always succeed.
-func NoDiagnosticWithMessage(msg string) DiagnosticExpectation {
- var uri span.URI
- isMet := func(diags *protocol.PublishDiagnosticsParams) bool {
- for _, d := range diags.Diagnostics {
- if d.Message == msg {
- return true
- }
- }
- return false
- }
- var path string
- if uri != "" {
- path = uri.Filename()
- }
- return DiagnosticExpectation{
- isMet: isMet,
- description: fmt.Sprintf("no diagnostic with message %s", msg),
- path: path,
- }
-}
projects / dotfiles / .git / blobdiff