opensourcemirror
/
concourse
mirror of https://github.com/concourse/concourse.git
1
0
Fork 0
Code Issues Releases Wiki Activity

vars: structure: remove VariableDefinition 

I'm not sure if the Type/Option fields were ever used, but they aren't
anymore - so, let's just get rid of the wrapper type and use
vars.Reference instead

Signed-off-by: Aidan Oldershaw <aoldershaw@pivotal.io>
This commit is contained in:
Aidan Oldershaw 2020-10-13 17:53:32 -04:00
parent 5f29d0875f
commit 2561420f90
28 changed files with 179 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
atc/creds/conjur/conjur_test.go
View File

@ -34,11 +34,11 @@ func (mock *MockConjurService) RetrieveSecret(input string) ([]byte, error) {
var _ = Describe("Conjur", func() {
var secretAccess *Conjur
var variables vars.Variables
var varDef vars.VariableDefinition
var varRef vars.Reference
var mockService MockConjurService
JustBeforeEach(func() {
varDef = vars.VariableDefinition{Ref: vars.Reference{Path: "cheery"}}
varRef = vars.Reference{Path: "cheery"}
t1, err := creds.BuildSecretTemplate("t1", DefaultPipelineSecretTemplate)
Expect(t1).NotTo(BeNil())
Expect(err).To(BeNil())
@ -58,7 +58,7 @@ var _ = Describe("Conjur", func() {
Describe("Get()", func() {
It("should get parameter if exists", func() {
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("secret value"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
@ -71,7 +71,7 @@ var _ = Describe("Conjur", func() {
}
return []byte("team secret"), nil
}
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("team secret"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
@ -79,7 +79,7 @@ var _ = Describe("Conjur", func() {
It("should return not found on error", func() {
mockService.stubGetParameter = nil
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).To(BeNil())
@ -91,7 +91,7 @@ var _ = Describe("Conjur", func() {
Expect(input).To(Equal("concourse/alpha/cheery"))
return []byte("team secret"), nil
}
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("team secret"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
@ -104,7 +104,7 @@ var _ = Describe("Conjur", func() {
Expect(input).To(Equal("cheery"))
return []byte("full path secret"), nil
}
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("full path secret"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())

4
atc/creds/dummy/secrets.go
View File

@ -29,9 +29,7 @@ func (secrets *Secrets) NewSecretLookupPaths(teamName string, pipelineName strin
}
func (secrets *Secrets) Get(secretPath string) (interface{}, *time.Time, bool, error) {
v, found, err := secrets.StaticVariables.Get(vars.VariableDefinition{
Ref: vars.Reference{Path: secretPath},
})
v, found, err := secrets.StaticVariables.Get(vars.Reference{Path: secretPath})
if err != nil {
return nil, nil, false, err
}

4
atc/creds/retryable_secrets_test.go
View File

@ -29,7 +29,7 @@ var _ = Describe("Re-retrieval of secrets on retryable errors", func() {
It("should retry receiving a parameter in case of retryable error", func() {
flakySecretManager := makeFlakySecretManager(3)
retryableSecretManager := creds.NewRetryableSecrets(flakySecretManager, creds.SecretRetryConfig{Attempts: 5, Interval: time.Millisecond})
varDef := vars.VariableDefinition{Ref: vars.Reference{Name: "somevar"}}
varDef := vars.Reference{Name: "somevar"}
value, found, err := creds.NewVariables(retryableSecretManager, "team", "pipeline", false).Get(varDef)
Expect(value).To(BeEquivalentTo("received value"))
Expect(found).To(BeTrue())
@ -39,7 +39,7 @@ var _ = Describe("Re-retrieval of secrets on retryable errors", func() {
It("should not receive a parameter if the number of retryable errors exceeded the number of allowed attempts", func() {
flakySecretManager := makeFlakySecretManager(10)
retryableSecretManager := creds.NewRetryableSecrets(flakySecretManager, creds.SecretRetryConfig{Attempts: 5, Interval: time.Millisecond})
varDef := vars.VariableDefinition{Ref: vars.Reference{Name: "somevar"}}
varDef := vars.Reference{Name: "somevar"}
value, found, err := creds.NewVariables(retryableSecretManager, "team", "pipeline", false).Get(varDef)
Expect(value).To(BeNil())
Expect(found).To(BeFalse())

8
atc/creds/secret_var_lookup.go
View File

@ -16,12 +16,12 @@ func NewVariables(secrets Secrets, teamName string, pipelineName string, allowRo
}
}
func (sl VariableLookupFromSecrets) Get(varDef vars.VariableDefinition) (interface{}, bool, error) {
func (sl VariableLookupFromSecrets) Get(ref vars.Reference) (interface{}, bool, error) {
// try to find a secret according to our var->secret lookup paths
if len(sl.LookupPaths) > 0 {
for _, rule := range sl.LookupPaths {
// prepands any additionals prefix paths to front of the path
secretRef, err := rule.VariableToSecretPath(varDef.Ref)
secretRef, err := rule.VariableToSecretPath(ref)
if err != nil {
return nil, false, err
}
@ -37,11 +37,11 @@ func (sl VariableLookupFromSecrets) Get(varDef vars.VariableDefinition) (interfa
return nil, false, nil
} else {
// if no paths are specified (i.e. for fake & noop secret managers), then try 1-to-1 var->secret mapping
result, _, found, err := sl.Secrets.Get(varDef.Ref.Path)
result, _, found, err := sl.Secrets.Get(ref.Path)
return result, found, err
}
}
func (sl VariableLookupFromSecrets) List() ([]vars.VariableDefinition, error) {
func (sl VariableLookupFromSecrets) List() ([]vars.Reference, error) {
return nil, nil
}

14
atc/creds/secretsmanager/secretsmanager_test.go
View File

@ -40,11 +40,11 @@ func (mock *MockSecretsManagerService) GetSecretValue(input *secretsmanager.GetS
var _ = Describe("SecretsManager", func() {
var secretAccess *SecretsManager
var variables vars.Variables
var varDef vars.VariableDefinition
var varRef vars.Reference
var mockService MockSecretsManagerService
JustBeforeEach(func() {
varDef = vars.VariableDefinition{Ref: vars.Reference{Path: "cheery"}}
varRef = vars.Reference{Path: "cheery"}
t1, err := creds.BuildSecretTemplate("t1", DefaultPipelineSecretTemplate)
Expect(t1).NotTo(BeNil())
Expect(err).To(BeNil())
@ -64,7 +64,7 @@ var _ = Describe("SecretsManager", func() {
Describe("Get()", func() {
It("should get parameter if exists", func() {
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("secret value"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
@ -76,7 +76,7 @@ var _ = Describe("SecretsManager", func() {
SecretBinary: []byte(`{"name": "yours", "pass": "truely"}`),
}, nil
}
value, found, err := variables.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "user"}})
value, found, err := variables.Get(vars.Reference{Path: "user"})
Expect(err).To(BeNil())
Expect(found).To(BeTrue())
Expect(value).To(BeEquivalentTo(map[string]interface{}{
@ -92,7 +92,7 @@ var _ = Describe("SecretsManager", func() {
}
return &secretsmanager.GetSecretValueOutput{SecretString: aws.String("team decrypted value")}, nil
}
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("team decrypted value"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
@ -100,7 +100,7 @@ var _ = Describe("SecretsManager", func() {
It("should return not found on error", func() {
mockService.stubGetParameter = nil
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).NotTo(BeNil())
@ -112,7 +112,7 @@ var _ = Describe("SecretsManager", func() {
Expect(input).To(Equal("/concourse/alpha/cheery"))
return &secretsmanager.GetSecretValueOutput{SecretString: aws.String("team power")}, nil
}
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("team power"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())

16
atc/creds/ssm/ssm_test.go
View File

@ -87,11 +87,11 @@ func (mock *MockSsmService) GetParametersByPathPages(input *ssm.GetParametersByP
var _ = Describe("Ssm", func() {
var ssmAccess *Ssm
var variables vars.Variables
var varDef vars.VariableDefinition
var varRef vars.Reference
var mockService MockSsmService
JustBeforeEach(func() {
varDef = vars.VariableDefinition{Ref: vars.Reference{Path: "cheery"}}
varRef = vars.Reference{Path: "cheery"}
t1, err := creds.BuildSecretTemplate("t1", DefaultPipelineSecretTemplate)
Expect(t1).NotTo(BeNil())
Expect(err).To(BeNil())
@ -114,7 +114,7 @@ var _ = Describe("Ssm", func() {
Describe("Get()", func() {
It("should get parameter if exists", func() {
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("ssm decrypted value"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
@ -132,7 +132,7 @@ var _ = Describe("Ssm", func() {
},
}
}
value, found, err := variables.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "user"}})
value, found, err := variables.Get(vars.Reference{Path: "user"})
Expect(value).To(BeEquivalentTo(map[string]interface{}{
"name": "yours",
"pass": "truely",
@ -145,7 +145,7 @@ var _ = Describe("Ssm", func() {
mockService.stubGetParameter = func(input string) (string, error) {
return "101", nil
}
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("101"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
@ -158,7 +158,7 @@ var _ = Describe("Ssm", func() {
}
return "team decrypted value", nil
}
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("team decrypted value"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
@ -166,7 +166,7 @@ var _ = Describe("Ssm", func() {
It("should return not found on error", func() {
mockService.stubGetParameter = nil
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).NotTo(BeNil())
@ -178,7 +178,7 @@ var _ = Describe("Ssm", func() {
Expect(input).To(Equal("/concourse/alpha/cheery"))
return "team power", nil
}
value, found, err := variables.Get(varDef)
value, found, err := variables.Get(varRef)
Expect(value).To(BeEquivalentTo("team power"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())

8
atc/creds/vault/vault_test.go
View File

@ -35,7 +35,7 @@ var _ = Describe("Vault", func() {
var v *vault.Vault
var variables vars.Variables
var msr *MockSecretReader
var varFoo vars.VariableDefinition
var varFoo vars.Reference
BeforeEach(func() {
@ -59,7 +59,7 @@ var _ = Describe("Vault", func() {
}
variables = creds.NewVariables(v, "team", "pipeline", false)
varFoo = vars.VariableDefinition{Ref: vars.Reference{Path: "foo"}}
varFoo = vars.Reference{Path: "foo"}
})
Describe("Get()", func() {
@ -173,14 +173,14 @@ var _ = Describe("Vault", func() {
})
It("should find team secrets in the configured place", func() {
value, found, err := variables.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "baz"}})
value, found, err := variables.Get(vars.Reference{Path: "baz"})
Expect(value).To(BeEquivalentTo("qux"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())
})
It("should find static secrets in the configured place", func() {
value, found, err := variables.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "global"}})
value, found, err := variables.Get(vars.Reference{Path: "global"})
Expect(value).To(BeEquivalentTo("shared"))
Expect(found).To(BeTrue())
Expect(err).To(BeNil())

6
atc/db/build_test.go
View File

@ -880,7 +880,7 @@ var _ = Describe("Build", func() {
v, err := build.Variables(logger, globalSecrets, varSourcePool)
Expect(err).ToNot(HaveOccurred())
val, found, err := v.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "foo"}})
val, found, err := v.Get(vars.Reference{Path: "foo"})
Expect(err).ToNot(HaveOccurred())
Expect(found).To(BeTrue())
Expect(val).To(Equal("bar"))
@ -915,7 +915,7 @@ var _ = Describe("Build", func() {
v, err := build.Variables(logger, globalSecrets, varSourcePool)
Expect(err).ToNot(HaveOccurred())
val, found, err := v.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "foo"}})
val, found, err := v.Get(vars.Reference{Path: "foo"})
Expect(err).ToNot(HaveOccurred())
Expect(found).To(BeTrue())
Expect(val).To(Equal("bar"))
@ -925,7 +925,7 @@ var _ = Describe("Build", func() {
v, err := build.Variables(logger, globalSecrets, varSourcePool)
Expect(err).ToNot(HaveOccurred())
val, found, err := v.Get(vars.VariableDefinition{Ref: vars.Reference{Source: "some-source", Path: "baz"}})
val, found, err := v.Get(vars.Reference{Source: "some-source", Path: "baz"})
Expect(err).ToNot(HaveOccurred())
Expect(found).To(BeTrue())
Expect(val).To(Equal("caz"))

12
atc/db/pipeline_test.go
View File

@ -2142,32 +2142,32 @@ var _ = Describe("Pipeline", func() {
})
It("should get var from pipeline var source", func() {
v, found, err := pvars.Get(vars.VariableDefinition{Ref: vars.Reference{Source: "some-var-source", Path: "pk"}})
v, found, err := pvars.Get(vars.Reference{Source: "some-var-source", Path: "pk"})
Expect(err).NotTo(HaveOccurred())
Expect(found).To(BeTrue())
Expect(v.(string)).To(Equal("pv"))
})
It("should not get pipeline var 'pk' without specifying var_source name", func() {
_, found, err := pvars.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "pk"}})
_, found, err := pvars.Get(vars.Reference{Path: "pk"})
Expect(err).NotTo(HaveOccurred())
Expect(found).To(BeFalse())
})
It("should not get from global secrets if found in the pipeline var source", func() {
pvars.Get(vars.VariableDefinition{Ref: vars.Reference{Source: "some-var-source", Path: "pk"}})
pvars.Get(vars.Reference{Source: "some-var-source", Path: "pk"})
Expect(fakeGlobalSecrets.GetCallCount()).To(Equal(0))
})
It("should get var from global var source", func() {
v, found, err := pvars.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "gk"}})
v, found, err := pvars.Get(vars.Reference{Path: "gk"})
Expect(err).NotTo(HaveOccurred())
Expect(found).To(BeTrue())
Expect(v.(string)).To(Equal("gv"))
})
It("should not get var 'foo'", func() {
_, found, err := pvars.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "foo"}})
_, found, err := pvars.Get(vars.Reference{Path: "foo"})
Expect(err).NotTo(HaveOccurred())
Expect(found).To(BeFalse())
})
@ -2191,7 +2191,7 @@ var _ = Describe("Pipeline", func() {
// The second var source is configured with vars that needs to be interpolated
// from "some-var-source".
It("should get pipeline var 'pk' from the second var_source", func() {
v, found, err := pvars.Get(vars.VariableDefinition{Ref: vars.Reference{Source: "second-var-source", Path: "pk"}})
v, found, err := pvars.Get(vars.Reference{Source: "second-var-source", Path: "pk"})
Expect(err).NotTo(HaveOccurred())
Expect(found).To(BeTrue())
Expect(v.(string)).To(Equal("pv"))

4
atc/engine/builder/build_step_delegate_test.go
View File

@ -348,8 +348,8 @@ var _ = Describe("BuildStepDelegate", func() {
runState = exec.NewRunState(credVars, true)
delegate = builder.NewBuildStepDelegate(fakeBuild, "some-plan-id", runState, fakeClock)
runState.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "source-param"}})
runState.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "git-key"}})
runState.Get(vars.Reference{Path: "source-param"})
runState.Get(vars.Reference{Path: "git-key"})
})
Context("Stdout", func() {

2
atc/engine/engine_test.go
View File

@ -165,7 +165,7 @@ var _ = Describe("Engine", func() {
It("runs the step with the build variables", func() {
state := <-invokedState
val, found, err := state.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "foo"}})
val, found, err := state.Get(vars.Reference{Path: "foo"})
Expect(err).ToNot(HaveOccurred())
Expect(found).To(BeTrue())
Expect(val).To(Equal("bar"))

4
atc/exec/across_step.go
View File

@ -64,9 +64,7 @@ func (step AcrossStep) Run(ctx context.Context, state RunState) error {
fmt.Fprintln(stderr, "")
for _, v := range step.vars {
_, found, _ := state.Get(vars.VariableDefinition{
Ref: vars.Reference{Source: ".", Path: v.Var},
})
_, found, _ := state.Get(vars.Reference{Source: ".", Path: v.Var})
if found {
fmt.Fprintf(stderr, "\x1b[1;33mWARNING: across step shadows local var '%s'\x1b[0m\n", v.Var)
}

4
atc/exec/across_step_test.go
View File

@ -55,9 +55,7 @@ var _ = Describe("AcrossStep", func() {
s.RunStub = func(ctx context.Context, state exec.RunState) error {
defer GinkgoRecover()
for i, v := range acrossVars {
val, found, _ := state.Get(vars.VariableDefinition{
Ref: vars.Reference{Source: ".", Path: v.Var},
})
val, found, _ := state.Get(vars.Reference{Source: ".", Path: v.Var})
Expect(found).To(BeTrue(), "unset variable "+v.Var)
Expect(val).To(Equal(values[i]), "invalid value for variable "+v.Var)
}

14
atc/exec/build_vars.go
View File

@ -25,25 +25,23 @@ func newBuildVariables(credVars vars.Variables, enableRedaction bool) *buildVari
}
}
func (b *buildVariables) Get(varDef vars.VariableDefinition) (interface{}, bool, error) {
if varDef.Ref.Source == "." {
val, found, _ := b.localVars.Get(varDef)
func (b *buildVariables) Get(ref vars.Reference) (interface{}, bool, error) {
if ref.Source == "." {
val, found, _ := b.localVars.Get(ref)
if found {
return val, true, nil
}
}
return b.parentScope.Get(varDef)
return b.parentScope.Get(ref)
}
func (b *buildVariables) List() ([]vars.VariableDefinition, error) {
func (b *buildVariables) List() ([]vars.Reference, error) {
list, err := b.parentScope.List()
if err != nil {
return nil, err
}
for k := range b.localVars {
list = append(list, vars.VariableDefinition{
Ref: vars.Reference{Source: ".", Path: k},
})
list = append(list, vars.Reference{Source: ".", Path: k})
}
return list, nil
}

32
atc/exec/execfakes/fake_run_state.go
View File

@ -28,10 +28,10 @@ type FakeRunState struct {
artifactRepositoryReturnsOnCall map[int]struct {
result1 *build.Repository
}
GetStub func(vars.VariableDefinition) (interface{}, bool, error)
GetStub func(vars.Reference) (interface{}, bool, error)
getMutex sync.RWMutex
getArgsForCall []struct {
arg1 vars.VariableDefinition
arg1 vars.Reference
}
getReturns struct {
result1 interface{}
@ -48,16 +48,16 @@ type FakeRunState struct {
iterateInterpolatedCredsArgsForCall []struct {
arg1 vars.TrackedVarsIterator
}
ListStub func() ([]vars.VariableDefinition, error)
ListStub func() ([]vars.Reference, error)
listMutex sync.RWMutex
listArgsForCall []struct {
}
listReturns struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
}
listReturnsOnCall map[int]struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
}
NewLocalScopeStub func() exec.RunState
@ -187,11 +187,11 @@ func (fake *FakeRunState) ArtifactRepositoryReturnsOnCall(i int, result1 *build.
}{result1}
}
func (fake *FakeRunState) Get(arg1 vars.VariableDefinition) (interface{}, bool, error) {
func (fake *FakeRunState) Get(arg1 vars.Reference) (interface{}, bool, error) {
fake.getMutex.Lock()
ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)]
fake.getArgsForCall = append(fake.getArgsForCall, struct {
arg1 vars.VariableDefinition
arg1 vars.Reference
}{arg1})
fake.recordInvocation("Get", []interface{}{arg1})
fake.getMutex.Unlock()
@ -211,13 +211,13 @@ func (fake *FakeRunState) GetCallCount() int {
return len(fake.getArgsForCall)
}
func (fake *FakeRunState) GetCalls(stub func(vars.VariableDefinition) (interface{}, bool, error)) {
func (fake *FakeRunState) GetCalls(stub func(vars.Reference) (interface{}, bool, error)) {
fake.getMutex.Lock()
defer fake.getMutex.Unlock()
fake.GetStub = stub
}
func (fake *FakeRunState) GetArgsForCall(i int) vars.VariableDefinition {
func (fake *FakeRunState) GetArgsForCall(i int) vars.Reference {
fake.getMutex.RLock()
defer fake.getMutex.RUnlock()
argsForCall := fake.getArgsForCall[i]
@ -284,7 +284,7 @@ func (fake *FakeRunState) IterateInterpolatedCredsArgsForCall(i int) vars.Tracke
return argsForCall.arg1
}
func (fake *FakeRunState) List() ([]vars.VariableDefinition, error) {
func (fake *FakeRunState) List() ([]vars.Reference, error) {
fake.listMutex.Lock()
ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)]
fake.listArgsForCall = append(fake.listArgsForCall, struct {
@ -307,34 +307,34 @@ func (fake *FakeRunState) ListCallCount() int {
return len(fake.listArgsForCall)
}
func (fake *FakeRunState) ListCalls(stub func() ([]vars.VariableDefinition, error)) {
func (fake *FakeRunState) ListCalls(stub func() ([]vars.Reference, error)) {
fake.listMutex.Lock()
defer fake.listMutex.Unlock()
fake.ListStub = stub
}
func (fake *FakeRunState) ListReturns(result1 []vars.VariableDefinition, result2 error) {
func (fake *FakeRunState) ListReturns(result1 []vars.Reference, result2 error) {
fake.listMutex.Lock()
defer fake.listMutex.Unlock()
fake.ListStub = nil
fake.listReturns = struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
}{result1, result2}
}
func (fake *FakeRunState) ListReturnsOnCall(i int, result1 []vars.VariableDefinition, result2 error) {
func (fake *FakeRunState) ListReturnsOnCall(i int, result1 []vars.Reference, result2 error) {
fake.listMutex.Lock()
defer fake.listMutex.Unlock()
fake.ListStub = nil
if fake.listReturnsOnCall == nil {
fake.listReturnsOnCall = make(map[int]struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
})
}
fake.listReturnsOnCall[i] = struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
}{result1, result2}
}

6
atc/exec/run_state.go
View File

@ -47,11 +47,11 @@ func (state *runState) StoreResult(id atc.PlanID, val interface{}) {
state.results.Store(id, val)
}
func (state *runState) Get(varDef vars.VariableDefinition) (interface{}, bool, error) {
return state.vars.Get(varDef)
func (state *runState) Get(ref vars.Reference) (interface{}, bool, error) {
return state.vars.Get(ref)
}
func (state *runState) List() ([]vars.VariableDefinition, error) {
func (state *runState) List() ([]vars.Reference, error) {
return state.vars.List()
}

46
atc/exec/run_state_test.go
View File

@ -88,7 +88,7 @@ var _ = Describe("RunState", func() {
})
It("fetches from cred vars", func() {
val, found, err := state.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "k1"}})
val, found, err := state.Get(vars.Reference{Path: "k1"})
Expect(err).ToNot(HaveOccurred())
Expect(found).To(BeTrue())
Expect(val).To(Equal("v1"))
@ -100,8 +100,8 @@ var _ = Describe("RunState", func() {
})
It("fetched variables are tracked", func() {
state.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "k1"}})
state.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "k2"}})
state.Get(vars.Reference{Path: "k1"})
state.Get(vars.Reference{Path: "k2"})
mapit := vars.TrackedVarsMap{}
state.IterateInterpolatedCreds(mapit)
Expect(mapit["k1"]).To(Equal("v1"))
@ -117,8 +117,8 @@ var _ = Describe("RunState", func() {
})
It("fetched variables are not tracked", func() {
state.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "k1"}})
state.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "k2"}})
state.Get(vars.Reference{Path: "k1"})
state.Get(vars.Reference{Path: "k2"})
mapit := vars.TrackedVarsMap{}
state.IterateInterpolatedCreds(mapit)
Expect(mapit).ToNot(HaveKey("k1"))
@ -131,10 +131,10 @@ var _ = Describe("RunState", func() {
Describe("List", func() {
It("returns list of names from multiple vars with duplicates", func() {
defs, err := state.List()
Expect(defs).To(ConsistOf([]vars.VariableDefinition{
{Ref: vars.Reference{Path: "k1"}},
{Ref: vars.Reference{Path: "k2"}},
{Ref: vars.Reference{Path: "k3"}},
Expect(defs).To(ConsistOf([]vars.Reference{
{Path: "k1"},
{Path: "k2"},
{Path: "k3"},
}))
Expect(err).ToNot(HaveOccurred())
})
@ -144,13 +144,13 @@ var _ = Describe("RunState", func() {
state.AddLocalVar("l2", 2, false)
defs, err := state.List()
Expect(defs).To(ConsistOf([]vars.VariableDefinition{
{Ref: vars.Reference{Source: ".", Path: "l1"}},
{Ref: vars.Reference{Source: ".", Path: "l2"}},
Expect(defs).To(ConsistOf([]vars.Reference{
{Source: ".", Path: "l1"},
{Source: ".", Path: "l2"},
{Ref: vars.Reference{Path: "k1"}},
{Ref: vars.Reference{Path: "k2"}},
{Ref: vars.Reference{Path: "k3"}},
{Path: "k1"},
{Path: "k2"},
{Path: "k3"},
}))
Expect(err).ToNot(HaveOccurred())
})
@ -164,7 +164,7 @@ var _ = Describe("RunState", func() {
})
It("should get local value", func() {
val, found, err := state.Get(vars.VariableDefinition{Ref: vars.Reference{Source: ".", Path: "foo"}})
val, found, err := state.Get(vars.Reference{Source: ".", Path: "foo"})
Expect(err).To(BeNil())
Expect(found).To(BeTrue())
Expect(val).To(Equal("bar"))
@ -183,14 +183,14 @@ var _ = Describe("RunState", func() {
})
It("should get local value", func() {
val, found, err := state.Get(vars.VariableDefinition{Ref: vars.Reference{Source: ".", Path: "foo"}})
val, found, err := state.Get(vars.Reference{Source: ".", Path: "foo"})
Expect(err).To(BeNil())
Expect(found).To(BeTrue())
Expect(val).To(Equal("bar"))
})
It("fetched variables are not tracked", func() {
state.Get(vars.VariableDefinition{Ref: vars.Reference{Source: ".", Path: "foo"}})
state.Get(vars.Reference{Source: ".", Path: "foo"})
mapit := vars.TrackedVarsMap{}
state.IterateInterpolatedCreds(mapit)
Expect(mapit).ToNot(ContainElement("foo"))
@ -202,27 +202,27 @@ var _ = Describe("RunState", func() {
It("can access local vars from parent scope", func() {
state.AddLocalVar("hello", "world", false)
scope := state.NewLocalScope()
val, _, _ := scope.Get(vars.VariableDefinition{Ref: vars.Reference{Source: ".", Path: "hello"}})
val, _, _ := scope.Get(vars.Reference{Source: ".", Path: "hello"})
Expect(val).To(Equal("world"))
})
It("adding local vars does not affect the original tracker", func() {
scope := state.NewLocalScope()
scope.AddLocalVar("hello", "world", false)
_, found, _ := state.Get(vars.VariableDefinition{Ref: vars.Reference{Source: ".", Path: "hello"}})
_, found, _ := state.Get(vars.Reference{Source: ".", Path: "hello"})
Expect(found).To(BeFalse())
})
It("shares the underlying non-local variables", func() {
scope := state.NewLocalScope()
val, _, _ := scope.Get(vars.VariableDefinition{Ref: vars.Reference{Path: "k1"}})
val, _, _ := scope.Get(vars.Reference{Path: "k1"})
Expect(val).To(Equal("v1"))
})
It("local vars added after creating the subscope are accessible", func() {
scope := state.NewLocalScope()
state.AddLocalVar("hello", "world", false)
val, _, _ := scope.Get(vars.VariableDefinition{Ref: vars.Reference{Source: ".", Path: "hello"}})
val, _, _ := scope.Get(vars.Reference{Source: ".", Path: "hello"})
Expect(val).To(Equal("world"))
})
@ -231,7 +231,7 @@ var _ = Describe("RunState", func() {
scope := state.NewLocalScope()
scope.AddLocalVar("a", 2, false)
val, _, _ := scope.Get(vars.VariableDefinition{Ref: vars.Reference{Source: ".", Path: "a"}})
val, _, _ := scope.Get(vars.Reference{Source: ".", Path: "a"})
Expect(val).To(Equal(2))
})

12
vars/multi_vars.go
View File

@ -10,9 +10,9 @@ func NewMultiVars(varss []Variables) MultiVars {
var _ Variables = MultiVars{}
func (m MultiVars) Get(varDef VariableDefinition) (interface{}, bool, error) {
func (m MultiVars) Get(ref Reference) (interface{}, bool, error) {
for _, vars := range m.varss {
val, found, err := vars.Get(varDef)
val, found, err := vars.Get(ref)
if found || err != nil {
return val, found, err
}
@ -21,8 +21,8 @@ func (m MultiVars) Get(varDef VariableDefinition) (interface{}, bool, error) {
return nil, false, nil
}
func (m MultiVars) List() ([]VariableDefinition, error) {
var allDefs []VariableDefinition
func (m MultiVars) List() ([]Reference, error) {
var allRefs []Reference
for _, vars := range m.varss {
defs, err := vars.List()
@ -30,8 +30,8 @@ func (m MultiVars) List() ([]VariableDefinition, error) {
return nil, err
}
allDefs = append(allDefs, defs...)
allRefs = append(allRefs, defs...)
}
return allDefs, nil
return allRefs, nil
}

22
vars/multi_vars_test.go
View File

@ -12,7 +12,7 @@ import (
var _ = Describe("MultiVariables", func() {
Describe("Get", func() {
It("return no value and not found if there are no sources", func() {
val, found, err := NewMultiVars(nil).Get(VariableDefinition{})
val, found, err := NewMultiVars(nil).Get(Reference{})
Expect(val).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).ToNot(HaveOccurred())
@ -23,7 +23,7 @@ var _ = Describe("MultiVariables", func() {
vars2 := StaticVariables{"key2": "val"}
vars := NewMultiVars([]Variables{vars1, vars2})
val, found, err := vars.Get(VariableDefinition{Ref: Reference{Path: "key3"}})
val, found, err := vars.Get(Reference{Path: "key3"})
Expect(val).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).ToNot(HaveOccurred())
@ -34,7 +34,7 @@ var _ = Describe("MultiVariables", func() {
vars2 := &FakeVariables{GetErr: errors.New("fake-err")}
vars := NewMultiVars([]Variables{vars1, vars2})
val, found, err := vars.Get(VariableDefinition{Ref: Reference{Path: "key3"}})
val, found, err := vars.Get(Reference{Path: "key3"})
Expect(val).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).To(Equal(errors.New("fake-err")))
@ -46,7 +46,7 @@ var _ = Describe("MultiVariables", func() {
vars3 := &FakeVariables{GetErr: errors.New("fake-err")}
vars := NewMultiVars([]Variables{vars1, vars2, vars3})
val, found, err := vars.Get(VariableDefinition{Ref: Reference{Path: "key2"}})
val, found, err := vars.Get(Reference{Path: "key2"})
Expect(val).To(Equal("val"))
Expect(found).To(BeTrue())
Expect(err).ToNot(HaveOccurred())
@ -61,12 +61,12 @@ var _ = Describe("MultiVariables", func() {
vars2 := StaticVariables{"key2": "val"}
vars := NewMultiVars([]Variables{vars1, vars2})
val, found, err := vars.Get(VariableDefinition{Ref: Reference{Path: "key2"}, Type: "type", Options: "opts"})
val, found, err := vars.Get(Reference{Path: "key2"})
Expect(val).To(Equal("val"))
Expect(found).To(BeTrue())
Expect(err).ToNot(HaveOccurred())
Expect(vars1.GetVarDef).To(Equal(VariableDefinition{Ref: Reference{Path: "key2"}, Type: "type", Options: "opts"}))
Expect(vars1.GetVarDef).To(Equal(Reference{Path: "key2"}))
})
})
@ -79,11 +79,11 @@ var _ = Describe("MultiVariables", func() {
vars := NewMultiVars([]Variables{StaticVariables{"a": "1", "b": "2"}, StaticVariables{"b": "3", "c": "4"}})
defs, err = vars.List()
Expect(defs).To(ConsistOf([]VariableDefinition{
{Ref: Reference{Path: "a"}},
{Ref: Reference{Path: "b"}},
{Ref: Reference{Path: "b"}},
{Ref: Reference{Path: "c"}},
Expect(defs).To(ConsistOf([]Reference{
{Path: "a"},
{Path: "b"},
{Path: "b"},
{Path: "c"},
}))
Expect(err).ToNot(HaveOccurred())
})

26
vars/named_vars.go
View File

@ -3,36 +3,36 @@ package vars
type NamedVariables map[string]Variables
// Get checks var_source if presents, then forward var to underlying secret manager.
// A `varDef.Name` with a var_source looks like "myvault:foo", where "myvault" is
// A Reference with a var_source looks like "myvault:foo", where "myvault" is
// the var_source name, and "foo" is the real var name that should be forwarded
// to the underlying secret manager.
func (m NamedVariables) Get(varDef VariableDefinition) (interface{}, bool, error) {
if varDef.Ref.Source == "" {
func (m NamedVariables) Get(ref Reference) (interface{}, bool, error) {
if ref.Source == "" {
return nil, false, nil
}
if vars, ok := m[varDef.Ref.Source]; ok {
return vars.Get(varDef)
if vars, ok := m[ref.Source]; ok {
return vars.Get(ref)
}
return nil, false, MissingSourceError{Name: varDef.Ref.Name, Source: varDef.Ref.Source}
return nil, false, MissingSourceError{Name: ref.Name, Source: ref.Source}
}
func (m NamedVariables) List() ([]VariableDefinition, error) {
var allDefs []VariableDefinition
func (m NamedVariables) List() ([]Reference, error) {
var allRefs []Reference
for source, vars := range m {
defs, err := vars.List()
refs, err := vars.List()
if err != nil {
return nil, err
}
for i, _ := range defs {
defs[i].Ref.Source = source
for i, _ := range refs {
refs[i].Source = source
}
allDefs = append(allDefs, defs...)
allRefs = append(allRefs, refs...)
}
return allDefs, nil
return allRefs, nil
}

20
vars/named_vars_test.go
View File

@ -12,7 +12,7 @@ import (
var _ = Describe("NamedVariables", func() {
Describe("Get", func() {
It("return no value and not found if there are no sources", func() {
val, found, err := NamedVariables{}.Get(VariableDefinition{})
val, found, err := NamedVariables{}.Get(Reference{})
Expect(val).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).ToNot(HaveOccurred())
@ -23,7 +23,7 @@ var _ = Describe("NamedVariables", func() {
vars2 := StaticVariables{"key2": "val"}
vars := NamedVariables{"s1": vars1, "s2": vars2}
val, found, err := vars.Get(VariableDefinition{Ref: Reference{Name: "s3:foo", Source: "s3"}})
val, found, err := vars.Get(Reference{Name: "s3:foo", Source: "s3"})
Expect(val).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).To(HaveOccurred())
@ -36,7 +36,7 @@ var _ = Describe("NamedVariables", func() {
vars3 := &FakeVariables{GetErr: errors.New("fake-err")}
vars := NamedVariables{"s1": vars1, "s2": vars2, "s3": vars3}
val, found, err := vars.Get(VariableDefinition{Ref: Reference{Source: "s2", Path: "key2"}})
val, found, err := vars.Get(Reference{Source: "s2", Path: "key2"})
Expect(val).To(Equal("val"))
Expect(found).To(BeTrue())
Expect(err).ToNot(HaveOccurred())
@ -51,7 +51,7 @@ var _ = Describe("NamedVariables", func() {
vars2 := StaticVariables{"key2": "val"}
vars := NamedVariables{"s1": vars1, "s2": vars2}
val, found, err := vars.Get(VariableDefinition{Ref: Reference{Name: "key1"}})
val, found, err := vars.Get(Reference{Name: "key1"})
Expect(val).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).ToNot(HaveOccurred())
@ -62,7 +62,7 @@ var _ = Describe("NamedVariables", func() {
vars2 := &FakeVariables{GetErr: errors.New("fake-err")}
vars := NamedVariables{"s1": vars1, "s2": vars2}
val, found, err := vars.Get(VariableDefinition{Ref: Reference{Source: "s2", Name: "key3"}})
val, found, err := vars.Get(Reference{Source: "s2", Name: "key3"})
Expect(val).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).To(Equal(errors.New("fake-err")))
@ -81,11 +81,11 @@ var _ = Describe("NamedVariables", func() {
}
defs, err = vars.List()
Expect(defs).To(ConsistOf([]VariableDefinition{
{Ref: Reference{Source: "s1", Path: "a"}},
{Ref: Reference{Source: "s1", Path: "b"}},
{Ref: Reference{Source: "s2", Path: "b"}},
{Ref: Reference{Source: "s2", Path: "c"}},
Expect(defs).To(ConsistOf([]Reference{
{Source: "s1", Path: "a"},
{Source: "s1", Path: "b"},
{Source: "s2", Path: "b"},
{Source: "s2", Path: "c"},
}))
Expect(err).ToNot(HaveOccurred())
})

12
vars/static_vars.go
View File

@ -4,17 +4,17 @@ type StaticVariables map[string]interface{}
var _ Variables = StaticVariables{}
func (v StaticVariables) Get(varDef VariableDefinition) (interface{}, bool, error) {
val, found := v[varDef.Ref.Path]
func (v StaticVariables) Get(ref Reference) (interface{}, bool, error) {
val, found := v[ref.Path]
return val, found, nil
}
func (v StaticVariables) List() ([]VariableDefinition, error) {
var defs []VariableDefinition
func (v StaticVariables) List() ([]Reference, error) {
var refs []Reference
for name, _ := range v {
defs = append(defs, VariableDefinition{Ref: Reference{Path: name}})
refs = append(refs, Reference{Path: name})
}
return defs, nil
return refs, nil
}

12
vars/static_vars_test.go
View File

@ -12,7 +12,7 @@ var _ = Describe("StaticVariables", func() {
It("returns value and found if key is found", func() {
a := StaticVariables{"a": "foo"}
val, found, err := a.Get(VariableDefinition{Ref: Reference{Path: "a"}})
val, found, err := a.Get(Reference{Path: "a"})
Expect(val).To(Equal("foo"))
Expect(found).To(BeTrue())
Expect(err).ToNot(HaveOccurred())
@ -21,7 +21,7 @@ var _ = Describe("StaticVariables", func() {
It("returns nil and not found if key is not found", func() {
a := StaticVariables{"a": "foo"}
val, found, err := a.Get(VariableDefinition{Ref: Reference{Path: "b"}})
val, found, err := a.Get(Reference{Path: "b"})
Expect(val).To(BeNil())
Expect(found).To(BeFalse())
Expect(err).ToNot(HaveOccurred())
@ -30,7 +30,7 @@ var _ = Describe("StaticVariables", func() {
It("recognizes keys that use dot notation for subvalues", func() {
a := StaticVariables{"a.subkey": "foo", "a.subkey2": "foo2"}
val, found, err := a.Get(VariableDefinition{Ref: Reference{Path: "a.subkey"}})
val, found, err := a.Get(Reference{Path: "a.subkey"})
Expect(val).To(Equal("foo"))
Expect(found).To(BeTrue())
Expect(err).ToNot(HaveOccurred())
@ -44,9 +44,9 @@ var _ = Describe("StaticVariables", func() {
Expect(err).ToNot(HaveOccurred())
defs, err = StaticVariables{"a": "1", "b": "2"}.List()
Expect(defs).To(ConsistOf([]VariableDefinition{
{Ref: Reference{Path: "a"}},
{Ref: Reference{Path: "b"}},
Expect(defs).To(ConsistOf([]Reference{
{Path: "a"},
{Path: "b"},
}))
Expect(err).ToNot(HaveOccurred())
})

12
vars/suite_test.go
View File

@ -15,21 +15,21 @@ func TestReg(t *testing.T) {
}
type FakeVariables struct {
GetFunc func(VariableDefinition) (interface{}, bool, error)
GetVarDef VariableDefinition
GetFunc func(Reference) (interface{}, bool, error)
GetVarDef Reference
GetErr error
GetCallCount int
}
func (v *FakeVariables) Get(varDef VariableDefinition) (interface{}, bool, error) {
func (v *FakeVariables) Get(ref Reference) (interface{}, bool, error) {
v.GetCallCount += 1
v.GetVarDef = varDef
v.GetVarDef = ref
if v.GetFunc != nil {
return v.GetFunc(varDef)
return v.GetFunc(ref)
}
return nil, false, v.GetErr
}
func (v *FakeVariables) List() ([]VariableDefinition, error) {
func (v *FakeVariables) List() ([]Reference, error) {
return nil, nil
}

8
vars/template.go
View File

@ -194,7 +194,7 @@ func (t varsTracker) Get(varName string) (interface{}, bool, error) {
t.visitedAll[identifier(varRef)] = struct{}{}
val, found, err := t.vars.Get(VariableDefinition{Ref: varRef})
val, found, err := t.vars.Get(varRef)
if !found || err != nil {
t.missing[varRef.Name] = struct{}{}
return val, found, err
@ -259,15 +259,15 @@ func (t varsTracker) ExtraError() error {
return nil
}
allDefs, err := t.vars.List()
allRefs, err := t.vars.List()
if err != nil {
return err
}
unusedNames := map[string]struct{}{}
for _, def := range allDefs {
id := identifier(def.Ref)
for _, ref := range allRefs {
id := identifier(ref)
if _, found := t.visitedAll[id]; !found {
unusedNames[id] = struct{}{}
}

8
vars/tracker.go
View File

@ -73,15 +73,15 @@ type CredVarsTracker struct {
CredVars Variables
}
func (t *CredVarsTracker) Get(varDef VariableDefinition) (interface{}, bool, error) {
val, found, err := t.CredVars.Get(varDef)
func (t *CredVarsTracker) Get(ref Reference) (interface{}, bool, error) {
val, found, err := t.CredVars.Get(ref)
if found {
t.Tracker.Track(varDef.Ref, val)
t.Tracker.Track(ref, val)
}
return val, found, err
}
func (t *CredVarsTracker) List() ([]VariableDefinition, error) {
func (t *CredVarsTracker) List() ([]Reference, error) {
return t.CredVars.List()
}

10
vars/variables.go
View File

@ -3,8 +3,8 @@ package vars
//go:generate counterfeiter . Variables
type Variables interface {
Get(VariableDefinition) (interface{}, bool, error)
List() ([]VariableDefinition, error)
Get(Reference) (interface{}, bool, error)
List() ([]Reference, error)
}
type Reference struct {
@ -13,9 +13,3 @@ type Reference struct {
Path string
Fields []string
}
type VariableDefinition struct {
Ref Reference
Type string
Options interface{}
}

32
vars/varsfakes/fake_variables.go
View File

@ -8,10 +8,10 @@ import (
)
type FakeVariables struct {
GetStub func(vars.VariableDefinition) (interface{}, bool, error)
GetStub func(vars.Reference) (interface{}, bool, error)
getMutex sync.RWMutex
getArgsForCall []struct {
arg1 vars.VariableDefinition
arg1 vars.Reference
}
getReturns struct {
result1 interface{}
@ -23,27 +23,27 @@ type FakeVariables struct {
result2 bool
result3 error
}
ListStub func() ([]vars.VariableDefinition, error)
ListStub func() ([]vars.Reference, error)
listMutex sync.RWMutex
listArgsForCall []struct {
}
listReturns struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
}
listReturnsOnCall map[int]struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
}
invocations map[string][][]interface{}
invocationsMutex sync.RWMutex
}
func (fake *FakeVariables) Get(arg1 vars.VariableDefinition) (interface{}, bool, error) {
func (fake *FakeVariables) Get(arg1 vars.Reference) (interface{}, bool, error) {
fake.getMutex.Lock()
ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)]
fake.getArgsForCall = append(fake.getArgsForCall, struct {
arg1 vars.VariableDefinition
arg1 vars.Reference
}{arg1})
fake.recordInvocation("Get", []interface{}{arg1})
fake.getMutex.Unlock()
@ -63,13 +63,13 @@ func (fake *FakeVariables) GetCallCount() int {
return len(fake.getArgsForCall)
}
func (fake *FakeVariables) GetCalls(stub func(vars.VariableDefinition) (interface{}, bool, error)) {
func (fake *FakeVariables) GetCalls(stub func(vars.Reference) (interface{}, bool, error)) {
fake.getMutex.Lock()
defer fake.getMutex.Unlock()
fake.GetStub = stub
}
func (fake *FakeVariables) GetArgsForCall(i int) vars.VariableDefinition {
func (fake *FakeVariables) GetArgsForCall(i int) vars.Reference {
fake.getMutex.RLock()
defer fake.getMutex.RUnlock()
argsForCall := fake.getArgsForCall[i]
@ -105,7 +105,7 @@ func (fake *FakeVariables) GetReturnsOnCall(i int, result1 interface{}, result2
}{result1, result2, result3}
}
func (fake *FakeVariables) List() ([]vars.VariableDefinition, error) {
func (fake *FakeVariables) List() ([]vars.Reference, error) {
fake.listMutex.Lock()
ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)]
fake.listArgsForCall = append(fake.listArgsForCall, struct {
@ -128,34 +128,34 @@ func (fake *FakeVariables) ListCallCount() int {
return len(fake.listArgsForCall)
}
func (fake *FakeVariables) ListCalls(stub func() ([]vars.VariableDefinition, error)) {
func (fake *FakeVariables) ListCalls(stub func() ([]vars.Reference, error)) {
fake.listMutex.Lock()
defer fake.listMutex.Unlock()
fake.ListStub = stub
}
func (fake *FakeVariables) ListReturns(result1 []vars.VariableDefinition, result2 error) {
func (fake *FakeVariables) ListReturns(result1 []vars.Reference, result2 error) {
fake.listMutex.Lock()
defer fake.listMutex.Unlock()
fake.ListStub = nil
fake.listReturns = struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
}{result1, result2}
}
func (fake *FakeVariables) ListReturnsOnCall(i int, result1 []vars.VariableDefinition, result2 error) {
func (fake *FakeVariables) ListReturnsOnCall(i int, result1 []vars.Reference, result2 error) {
fake.listMutex.Lock()
defer fake.listMutex.Unlock()
fake.ListStub = nil
if fake.listReturnsOnCall == nil {
fake.listReturnsOnCall = make(map[int]struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
})
}
fake.listReturnsOnCall[i] = struct {
result1 []vars.VariableDefinition
result1 []vars.Reference
result2 error
}{result1, result2}
}