vars: behaviour: properly handle local scope
I realized that local scope wasn't being handled properly before. We created a clone of the local vars when we called `NewLocalScope`, but local vars are typically populated at runtime - not in the `engine/builder`. So, the clone was always empty. Instead, form a linked list of `BuildVariables` that point to its parent scope. This commit also renames `CredVarsTracker` to `BuildVariables`, and exposes the struct directly rather than an interface. This commit is incomplete in the sense that it doesn't perform that renaming everywhere, but the diff got pretty huge and I wanted to separate out just the behaviour aspect of this change. Signed-off-by: Aidan Oldershaw <aoldershaw@pivotal.io>
This commit is contained in:
Aidan Oldershaw
parent
f7a8755916
commit
41c606daa6
|
|
@ -0,0 +1,69 @@
|
|||
package vars
|
||||
|
||||
type BuildVariables struct {
|
||||
parentScope interface {
|
||||
Variables
|
||||
IterateInterpolatedCreds(iter TrackedVarsIterator)
|
||||
}
|
||||
|
||||
localVars StaticVariables
|
||||
tracker *tracker
|
||||
}
|
||||
|
||||
func NewBuildVariables(credVars Variables, enableRedaction bool) *BuildVariables {
|
||||
return &BuildVariables{
|
||||
parentScope: &credVarsTracker{
|
||||
credVars: credVars,
|
||||
tracker: newTracker(enableRedaction),
|
||||
},
|
||||
localVars: StaticVariables{},
|
||||
tracker: newTracker(enableRedaction),
|
||||
}
|
||||
}
|
||||
|
||||
func (b *BuildVariables) Get(varDef VariableDefinition) (interface{}, bool, error) {
|
||||
if varDef.Ref.Source == "." {
|
||||
val, found, _ := b.localVars.Get(varDef)
|
||||
if found {
|
||||
return val, true, nil
|
||||
}
|
||||
}
|
||||
return b.parentScope.Get(varDef)
|
||||
}
|
||||
|
||||
func (b *BuildVariables) List() ([]VariableDefinition, error) {
|
||||
list, err := b.parentScope.List()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for k := range b.localVars {
|
||||
list = append(list, VariableDefinition{
|
||||
Ref: VariableReference{Source: ".", Path: k},
|
||||
})
|
||||
}
|
||||
return list, nil
|
||||
}
|
||||
|
||||
func (b *BuildVariables) IterateInterpolatedCreds(iter TrackedVarsIterator) {
|
||||
b.tracker.IterateInterpolatedCreds(iter)
|
||||
b.parentScope.IterateInterpolatedCreds(iter)
|
||||
}
|
||||
|
||||
func (b *BuildVariables) NewLocalScope() *BuildVariables {
|
||||
return &BuildVariables{
|
||||
parentScope: b,
|
||||
localVars: StaticVariables{},
|
||||
tracker: newTracker(b.tracker.enabled),
|
||||
}
|
||||
}
|
||||
|
||||
func (b *BuildVariables) AddLocalVar(name string, val interface{}, redact bool) {
|
||||
b.localVars[name] = val
|
||||
if redact {
|
||||
b.tracker.Track(VariableReference{Source: ".", Path: name}, val)
|
||||
}
|
||||
}
|
||||
|
||||
func (b *BuildVariables) RedactionEnabled() bool {
|
||||
return b.tracker.enabled
|
||||
}
|
||||
|
|
@ -0,0 +1,195 @@
|
|||
package vars_test
|
||||
|
||||
import (
|
||||
"github.com/concourse/concourse/vars"
|
||||
. "github.com/concourse/concourse/vars"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("BuildVariables", func() {
|
||||
var buildVars *vars.BuildVariables
|
||||
|
||||
Describe("turn on track", func() {
|
||||
BeforeEach(func() {
|
||||
buildVars = vars.NewBuildVariables(StaticVariables{"k1": "v1", "k2": "v2", "k3": "v3"}, true)
|
||||
})
|
||||
|
||||
Describe("Get", func() {
|
||||
It("returns expected value", func() {
|
||||
val, found, err := buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
Expect(found).To(BeTrue())
|
||||
Expect(err).To(BeNil())
|
||||
Expect(val).To(Equal("v1"))
|
||||
})
|
||||
|
||||
It("fetched variables are tracked", func() {
|
||||
buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k2"}})
|
||||
mapit := vars.TrackedVarsMap{}
|
||||
buildVars.IterateInterpolatedCreds(mapit)
|
||||
Expect(mapit["k1"]).To(Equal("v1"))
|
||||
Expect(mapit["k2"]).To(Equal("v2"))
|
||||
// "k3" has not been Get, thus should not be tracked.
|
||||
Expect(mapit).ToNot(HaveKey("k3"))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("List", func() {
|
||||
It("returns list of names from multiple vars with duplicates", func() {
|
||||
defs, err := buildVars.List()
|
||||
Expect(defs).To(ConsistOf([]VariableDefinition{
|
||||
{Ref: VariableReference{Path: "k1"}},
|
||||
{Ref: VariableReference{Path: "k2"}},
|
||||
{Ref: VariableReference{Path: "k3"}},
|
||||
}))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
|
||||
It("includes all local vars", func() {
|
||||
buildVars.AddLocalVar("l1", 1, false)
|
||||
buildVars.AddLocalVar("l2", 2, false)
|
||||
|
||||
defs, err := buildVars.List()
|
||||
Expect(defs).To(ConsistOf([]VariableDefinition{
|
||||
{Ref: VariableReference{Source: ".", Path: "l1"}},
|
||||
{Ref: VariableReference{Source: ".", Path: "l2"}},
|
||||
|
||||
{Ref: VariableReference{Path: "k1"}},
|
||||
{Ref: VariableReference{Path: "k2"}},
|
||||
{Ref: VariableReference{Path: "k3"}},
|
||||
}))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
})
|
||||
|
||||
Describe("AddLocalVar", func() {
|
||||
Describe("redact", func() {
|
||||
BeforeEach(func() {
|
||||
buildVars.AddLocalVar("foo", "bar", true)
|
||||
})
|
||||
|
||||
It("should get local value", func() {
|
||||
val, found, err := buildVars.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}})
|
||||
Expect(err).To(BeNil())
|
||||
Expect(found).To(BeTrue())
|
||||
Expect(val).To(Equal("bar"))
|
||||
})
|
||||
|
||||
It("fetched variables are tracked when added", func() {
|
||||
mapit := vars.TrackedVarsMap{}
|
||||
buildVars.IterateInterpolatedCreds(mapit)
|
||||
Expect(mapit["foo"]).To(Equal("bar"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("NewLocalScope", func() {
|
||||
It("can access local vars from parent scope", func() {
|
||||
buildVars.AddLocalVar("hello", "world", false)
|
||||
scope := buildVars.NewLocalScope()
|
||||
val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}})
|
||||
Expect(val).To(Equal("world"))
|
||||
})
|
||||
|
||||
It("adding local vars does not affect the original tracker", func() {
|
||||
scope := buildVars.NewLocalScope()
|
||||
scope.AddLocalVar("hello", "world", false)
|
||||
_, found, _ := buildVars.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}})
|
||||
Expect(found).To(BeFalse())
|
||||
})
|
||||
|
||||
It("shares the underlying non-local variables", func() {
|
||||
scope := buildVars.NewLocalScope()
|
||||
val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
Expect(val).To(Equal("v1"))
|
||||
})
|
||||
|
||||
It("local vars added after creating the subscope are accessible", func() {
|
||||
scope := buildVars.NewLocalScope()
|
||||
buildVars.AddLocalVar("hello", "world", false)
|
||||
val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}})
|
||||
Expect(val).To(Equal("world"))
|
||||
})
|
||||
|
||||
It("current scope is preferred over parent scope", func() {
|
||||
buildVars.AddLocalVar("a", 1, false)
|
||||
scope := buildVars.NewLocalScope()
|
||||
scope.AddLocalVar("a", 2, false)
|
||||
|
||||
val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "a"}})
|
||||
Expect(val).To(Equal(2))
|
||||
})
|
||||
|
||||
Describe("TrackedVarsMap", func() {
|
||||
It("prefers the value set in the current scope over the parent scope", func() {
|
||||
buildVars.AddLocalVar("a", "from parent", true)
|
||||
scope := buildVars.NewLocalScope()
|
||||
scope.AddLocalVar("a", "from child", true)
|
||||
|
||||
mapit := vars.TrackedVarsMap{}
|
||||
scope.IterateInterpolatedCreds(mapit)
|
||||
|
||||
Expect(mapit["a"]).To(Equal("from child"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("not redact", func() {
|
||||
BeforeEach(func() {
|
||||
buildVars.AddLocalVar("foo", "bar", false)
|
||||
})
|
||||
|
||||
It("should get local value", func() {
|
||||
val, found, err := buildVars.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}})
|
||||
Expect(err).To(BeNil())
|
||||
Expect(found).To(BeTrue())
|
||||
Expect(val).To(Equal("bar"))
|
||||
})
|
||||
|
||||
It("fetched variables are not tracked", func() {
|
||||
buildVars.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}})
|
||||
mapit := vars.TrackedVarsMap{}
|
||||
buildVars.IterateInterpolatedCreds(mapit)
|
||||
Expect(mapit).ToNot(ContainElement("foo"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("turn off track", func() {
|
||||
BeforeEach(func() {
|
||||
buildVars = vars.NewBuildVariables(StaticVariables{"k1": "v1", "k2": "v2", "k3": "v3"}, false)
|
||||
})
|
||||
|
||||
Describe("Get", func() {
|
||||
It("returns expected value", func() {
|
||||
val, found, err := buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
Expect(found).To(BeTrue())
|
||||
Expect(err).To(BeNil())
|
||||
Expect(val).To(Equal("v1"))
|
||||
})
|
||||
|
||||
It("fetched variables should not be tracked", func() {
|
||||
buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k2"}})
|
||||
mapit := vars.TrackedVarsMap{}
|
||||
buildVars.IterateInterpolatedCreds(mapit)
|
||||
Expect(mapit).ToNot(HaveKey("k1"))
|
||||
Expect(mapit).ToNot(HaveKey("k2"))
|
||||
Expect(mapit).ToNot(HaveKey("k3"))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("List", func() {
|
||||
It("returns list of names from multiple vars with duplicates", func() {
|
||||
defs, err := buildVars.List()
|
||||
Expect(defs).To(ConsistOf([]VariableDefinition{
|
||||
{Ref: VariableReference{Path: "k1"}},
|
||||
{Ref: VariableReference{Path: "k2"}},
|
||||
{Ref: VariableReference{Path: "k3"}},
|
||||
}))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
package vars
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
type TrackedVarsIterator interface {
|
||||
YieldCred(string, string)
|
||||
}
|
||||
|
||||
type tracker struct {
|
||||
enabled bool
|
||||
|
||||
// Considering in-parallel steps, a lock is need.
|
||||
lock sync.RWMutex
|
||||
interpolatedCreds map[string]string
|
||||
}
|
||||
|
||||
func newTracker(on bool) *tracker {
|
||||
return &tracker{
|
||||
enabled: on,
|
||||
interpolatedCreds: map[string]string{},
|
||||
}
|
||||
}
|
||||
|
||||
func (t *tracker) Track(varRef VariableReference, val interface{}) {
|
||||
if !t.enabled {
|
||||
return
|
||||
}
|
||||
|
||||
t.lock.Lock()
|
||||
defer t.lock.Unlock()
|
||||
|
||||
t.track(varRef, val)
|
||||
}
|
||||
|
||||
func (t *tracker) track(varRef VariableReference, val interface{}) {
|
||||
switch v := val.(type) {
|
||||
case map[interface{}]interface{}:
|
||||
for kk, vv := range v {
|
||||
t.track(VariableReference{
|
||||
Path: varRef.Path,
|
||||
Fields: append(varRef.Fields, kk.(string)),
|
||||
}, vv)
|
||||
}
|
||||
case map[string]interface{}:
|
||||
for kk, vv := range v {
|
||||
t.track(VariableReference{
|
||||
Path: varRef.Path,
|
||||
Fields: append(varRef.Fields, kk),
|
||||
}, vv)
|
||||
}
|
||||
case string:
|
||||
paths := append([]string{varRef.Path}, varRef.Fields...)
|
||||
|
||||
t.interpolatedCreds[strings.Join(paths, ".")] = v
|
||||
default:
|
||||
// Do nothing
|
||||
}
|
||||
}
|
||||
|
||||
func (t *tracker) IterateInterpolatedCreds(iter TrackedVarsIterator) {
|
||||
t.lock.RLock()
|
||||
for k, v := range t.interpolatedCreds {
|
||||
iter.YieldCred(k, v)
|
||||
}
|
||||
t.lock.RUnlock()
|
||||
}
|
||||
|
||||
type credVarsTracker struct {
|
||||
*tracker
|
||||
credVars Variables
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) Get(varDef VariableDefinition) (interface{}, bool, error) {
|
||||
val, found, err := t.credVars.Get(varDef)
|
||||
if found {
|
||||
t.tracker.Track(varDef.Ref, val)
|
||||
}
|
||||
return val, found, err
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) List() ([]VariableDefinition, error) {
|
||||
return t.credVars.List()
|
||||
}
|
||||
|
||||
// TrackedVarsMap is a TrackedVarsIterator which populates interpolated secrets into a map.
|
||||
// If there are multiple secrets with the same name, it only keeps the first value.
|
||||
type TrackedVarsMap map[string]string
|
||||
|
||||
func (it TrackedVarsMap) YieldCred(k, v string) {
|
||||
_, found := it[k]
|
||||
if !found {
|
||||
it[k] = v
|
||||
}
|
||||
}
|
||||
|
|
@ -1,5 +1,7 @@
|
|||
package vars
|
||||
|
||||
//go:generate counterfeiter . Variables
|
||||
|
||||
type Variables interface {
|
||||
Get(VariableDefinition) (interface{}, bool, error)
|
||||
List() ([]VariableDefinition, error)
|
||||
|
|
|
|||
|
|
@ -1,152 +0,0 @@
|
|||
package vars
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// CredVarsTracker implements the interface Variables. It wraps a secret manager and
|
||||
// tracks key-values fetched from the secret managers. It also provides a method to
|
||||
// thread-safely iterate interpolated key-values.
|
||||
type CredVarsTrackerIterator interface {
|
||||
YieldCred(string, string)
|
||||
}
|
||||
|
||||
//go:generate counterfeiter . CredVarsTracker
|
||||
|
||||
type CredVarsTracker interface {
|
||||
Variables
|
||||
IterateInterpolatedCreds(iter CredVarsTrackerIterator)
|
||||
Enabled() bool
|
||||
|
||||
NewLocalScope() CredVarsTracker
|
||||
AddLocalVar(string, interface{}, bool)
|
||||
}
|
||||
|
||||
func NewCredVarsTracker(credVars Variables, on bool) CredVarsTracker {
|
||||
return &credVarsTracker{
|
||||
localVars: StaticVariables{},
|
||||
credVars: credVars,
|
||||
enabled: on,
|
||||
interpolatedCreds: map[string]string{},
|
||||
noRedactVarNames: map[string]bool{},
|
||||
}
|
||||
}
|
||||
|
||||
type credVarsTracker struct {
|
||||
credVars Variables
|
||||
localVars StaticVariables
|
||||
|
||||
enabled bool
|
||||
|
||||
interpolatedCreds map[string]string
|
||||
|
||||
noRedactVarNames map[string]bool
|
||||
|
||||
// Considering in-parallel steps, a lock is need.
|
||||
lock sync.RWMutex
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) Get(varDef VariableDefinition) (interface{}, bool, error) {
|
||||
var (
|
||||
val interface{}
|
||||
found bool
|
||||
err error
|
||||
)
|
||||
|
||||
redact := true
|
||||
if varDef.Ref.Source == "." {
|
||||
val, found, err = t.localVars.Get(varDef)
|
||||
if found {
|
||||
if _, ok := t.noRedactVarNames[varDef.Ref.Path]; ok {
|
||||
redact = false
|
||||
}
|
||||
}
|
||||
} else {
|
||||
val, found, err = t.credVars.Get(varDef)
|
||||
}
|
||||
|
||||
if t.enabled && found && redact {
|
||||
t.lock.Lock()
|
||||
t.track(varDef.Ref, val)
|
||||
t.lock.Unlock()
|
||||
}
|
||||
|
||||
return val, found, err
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) track(varRef VariableReference, val interface{}) {
|
||||
switch v := val.(type) {
|
||||
case map[interface{}]interface{}:
|
||||
for kk, vv := range v {
|
||||
t.track(VariableReference{
|
||||
Path: varRef.Path,
|
||||
Fields: append(varRef.Fields, kk.(string)),
|
||||
}, vv)
|
||||
}
|
||||
case map[string]interface{}:
|
||||
for kk, vv := range v {
|
||||
t.track(VariableReference{
|
||||
Path: varRef.Path,
|
||||
Fields: append(varRef.Fields, kk),
|
||||
}, vv)
|
||||
}
|
||||
case string:
|
||||
paths := append([]string{varRef.Path}, varRef.Fields...)
|
||||
|
||||
t.interpolatedCreds[strings.Join(paths, ".")] = v
|
||||
default:
|
||||
// Do nothing
|
||||
}
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) List() ([]VariableDefinition, error) {
|
||||
return t.credVars.List()
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) IterateInterpolatedCreds(iter CredVarsTrackerIterator) {
|
||||
t.lock.RLock()
|
||||
for k, v := range t.interpolatedCreds {
|
||||
iter.YieldCred(k, v)
|
||||
}
|
||||
t.lock.RUnlock()
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) Enabled() bool {
|
||||
return t.enabled
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) NewLocalScope() CredVarsTracker {
|
||||
localVarsClone := make(StaticVariables, len(t.localVars))
|
||||
for k, v := range t.localVars {
|
||||
localVarsClone[k] = v
|
||||
}
|
||||
noRedactVarNamesClone := make(map[string]bool, len(t.noRedactVarNames))
|
||||
for k, v := range t.noRedactVarNames {
|
||||
noRedactVarNamesClone[k] = v
|
||||
}
|
||||
interpolatedCredsClone := MapCredVarsTrackerIterator{}
|
||||
t.IterateInterpolatedCreds(interpolatedCredsClone)
|
||||
return &credVarsTracker{
|
||||
credVars: t.credVars,
|
||||
enabled: t.enabled,
|
||||
localVars: localVarsClone,
|
||||
noRedactVarNames: noRedactVarNamesClone,
|
||||
interpolatedCreds: interpolatedCredsClone,
|
||||
}
|
||||
}
|
||||
|
||||
func (t *credVarsTracker) AddLocalVar(name string, value interface{}, redact bool) {
|
||||
t.localVars[name] = value
|
||||
if !redact {
|
||||
t.noRedactVarNames[name] = true
|
||||
}
|
||||
}
|
||||
|
||||
// MapCredVarsTrackerIterator implements a simple CredVarsTrackerIterator which just
|
||||
// populate interpolated secrets into a map.
|
||||
type MapCredVarsTrackerIterator map[string]string
|
||||
|
||||
func (it MapCredVarsTrackerIterator) YieldCred(k, v string) {
|
||||
it[k] = v
|
||||
}
|
||||
|
|
@ -1,172 +0,0 @@
|
|||
package vars_test
|
||||
|
||||
import (
|
||||
. "github.com/concourse/concourse/vars"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("vars_tracker", func() {
|
||||
var tracker CredVarsTracker
|
||||
|
||||
Describe("turn on track", func() {
|
||||
BeforeEach(func() {
|
||||
v := StaticVariables{"k1": "v1", "k2": "v2", "k3": "v3"}
|
||||
tracker = NewCredVarsTracker(v, true)
|
||||
})
|
||||
|
||||
Describe("Get", func() {
|
||||
It("returns expected value", func() {
|
||||
var (
|
||||
val interface{}
|
||||
found bool
|
||||
err error
|
||||
)
|
||||
val, found, err = tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
Expect(found).To(BeTrue())
|
||||
Expect(err).To(BeNil())
|
||||
Expect(val).To(Equal("v1"))
|
||||
})
|
||||
|
||||
It("fetched variables are tracked", func() {
|
||||
tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k2"}})
|
||||
mapit := MapCredVarsTrackerIterator{}
|
||||
tracker.IterateInterpolatedCreds(mapit)
|
||||
Expect(mapit["k1"]).To(Equal("v1"))
|
||||
Expect(mapit["k2"]).To(Equal("v2"))
|
||||
// "k3" has not been Get, thus should not be tracked.
|
||||
Expect(mapit).ToNot(ContainElement("k3"))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("List", func() {
|
||||
It("returns list of names from multiple vars with duplicates", func() {
|
||||
defs, err := tracker.List()
|
||||
Expect(defs).To(ConsistOf([]VariableDefinition{
|
||||
{Ref: VariableReference{Path: "k1"}},
|
||||
{Ref: VariableReference{Path: "k2"}},
|
||||
{Ref: VariableReference{Path: "k3"}},
|
||||
}))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
})
|
||||
|
||||
Describe("AddLocalVar", func() {
|
||||
Describe("redact", func() {
|
||||
BeforeEach(func() {
|
||||
tracker.AddLocalVar("foo", "bar", true)
|
||||
})
|
||||
|
||||
It("should get local value", func() {
|
||||
var (
|
||||
val interface{}
|
||||
found bool
|
||||
err error
|
||||
)
|
||||
val, found, err = tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}})
|
||||
Expect(err).To(BeNil())
|
||||
Expect(found).To(BeTrue())
|
||||
Expect(val).To(Equal("bar"))
|
||||
})
|
||||
|
||||
It("fetched variables are tracked", func() {
|
||||
tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}})
|
||||
mapit := MapCredVarsTrackerIterator{}
|
||||
tracker.IterateInterpolatedCreds(mapit)
|
||||
Expect(mapit["foo"]).To(Equal("bar"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("NewLocalScope", func() {
|
||||
It("copies all existing local vars", func() {
|
||||
tracker.AddLocalVar("hello", "world", false)
|
||||
scope := tracker.NewLocalScope()
|
||||
val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}})
|
||||
Expect(val).To(Equal("world"))
|
||||
})
|
||||
|
||||
It("adding local vars does not affect the original tracker", func() {
|
||||
scope := tracker.NewLocalScope()
|
||||
scope.AddLocalVar("hello", "world", false)
|
||||
_, found, _ := tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}})
|
||||
Expect(found).To(BeFalse())
|
||||
})
|
||||
|
||||
It("shares the underlying non-local variables", func() {
|
||||
scope := tracker.NewLocalScope()
|
||||
val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
Expect(val).To(Equal("v1"))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("not redact", func() {
|
||||
BeforeEach(func() {
|
||||
tracker.AddLocalVar("foo", "bar", false)
|
||||
})
|
||||
|
||||
It("should get local value", func() {
|
||||
var (
|
||||
val interface{}
|
||||
found bool
|
||||
err error
|
||||
)
|
||||
val, found, err = tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}})
|
||||
Expect(err).To(BeNil())
|
||||
Expect(found).To(BeTrue())
|
||||
Expect(val).To(Equal("bar"))
|
||||
})
|
||||
|
||||
It("fetched variables are not tracked", func() {
|
||||
tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}})
|
||||
mapit := MapCredVarsTrackerIterator{}
|
||||
tracker.IterateInterpolatedCreds(mapit)
|
||||
Expect(mapit).ToNot(ContainElement("foo"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("turn off track", func() {
|
||||
BeforeEach(func() {
|
||||
v := StaticVariables{"k1": "v1", "k2": "v2", "k3": "v3"}
|
||||
tracker = NewCredVarsTracker(v, false)
|
||||
})
|
||||
|
||||
Describe("Get", func() {
|
||||
It("returns expected value", func() {
|
||||
var (
|
||||
val interface{}
|
||||
found bool
|
||||
err error
|
||||
)
|
||||
val, found, err = tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
Expect(found).To(BeTrue())
|
||||
Expect(err).To(BeNil())
|
||||
Expect(val).To(Equal("v1"))
|
||||
})
|
||||
|
||||
It("fetched variables should not be tracked", func() {
|
||||
tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}})
|
||||
tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k2"}})
|
||||
mapit := MapCredVarsTrackerIterator{}
|
||||
tracker.IterateInterpolatedCreds(mapit)
|
||||
Expect(mapit).ToNot(ContainElement("k1"))
|
||||
Expect(mapit).ToNot(ContainElement("k2"))
|
||||
Expect(mapit).ToNot(ContainElement("k3"))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("List", func() {
|
||||
It("returns list of names from multiple vars with duplicates", func() {
|
||||
defs, err := tracker.List()
|
||||
Expect(defs).To(ConsistOf([]VariableDefinition{
|
||||
{Ref: VariableReference{Path: "k1"}},
|
||||
{Ref: VariableReference{Path: "k2"}},
|
||||
{Ref: VariableReference{Path: "k3"}},
|
||||
}))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
@ -1,397 +0,0 @@
|
|||
// Code generated by counterfeiter. DO NOT EDIT.
|
||||
package varsfakes
|
||||
|
||||
import (
|
||||
"sync"
|
||||
|
||||
"github.com/concourse/concourse/vars"
|
||||
)
|
||||
|
||||
type FakeCredVarsTracker struct {
|
||||
AddLocalVarStub func(string, interface{}, bool)
|
||||
addLocalVarMutex sync.RWMutex
|
||||
addLocalVarArgsForCall []struct {
|
||||
arg1 string
|
||||
arg2 interface{}
|
||||
arg3 bool
|
||||
}
|
||||
EnabledStub func() bool
|
||||
enabledMutex sync.RWMutex
|
||||
enabledArgsForCall []struct {
|
||||
}
|
||||
enabledReturns struct {
|
||||
result1 bool
|
||||
}
|
||||
enabledReturnsOnCall map[int]struct {
|
||||
result1 bool
|
||||
}
|
||||
GetStub func(vars.VariableDefinition) (interface{}, bool, error)
|
||||
getMutex sync.RWMutex
|
||||
getArgsForCall []struct {
|
||||
arg1 vars.VariableDefinition
|
||||
}
|
||||
getReturns struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
}
|
||||
getReturnsOnCall map[int]struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
}
|
||||
IterateInterpolatedCredsStub func(vars.CredVarsTrackerIterator)
|
||||
iterateInterpolatedCredsMutex sync.RWMutex
|
||||
iterateInterpolatedCredsArgsForCall []struct {
|
||||
arg1 vars.CredVarsTrackerIterator
|
||||
}
|
||||
ListStub func() ([]vars.VariableDefinition, error)
|
||||
listMutex sync.RWMutex
|
||||
listArgsForCall []struct {
|
||||
}
|
||||
listReturns struct {
|
||||
result1 []vars.VariableDefinition
|
||||
result2 error
|
||||
}
|
||||
listReturnsOnCall map[int]struct {
|
||||
result1 []vars.VariableDefinition
|
||||
result2 error
|
||||
}
|
||||
NewLocalScopeStub func() vars.CredVarsTracker
|
||||
newLocalScopeMutex sync.RWMutex
|
||||
newLocalScopeArgsForCall []struct {
|
||||
}
|
||||
newLocalScopeReturns struct {
|
||||
result1 vars.CredVarsTracker
|
||||
}
|
||||
newLocalScopeReturnsOnCall map[int]struct {
|
||||
result1 vars.CredVarsTracker
|
||||
}
|
||||
invocations map[string][][]interface{}
|
||||
invocationsMutex sync.RWMutex
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) AddLocalVar(arg1 string, arg2 interface{}, arg3 bool) {
|
||||
fake.addLocalVarMutex.Lock()
|
||||
fake.addLocalVarArgsForCall = append(fake.addLocalVarArgsForCall, struct {
|
||||
arg1 string
|
||||
arg2 interface{}
|
||||
arg3 bool
|
||||
}{arg1, arg2, arg3})
|
||||
fake.recordInvocation("AddLocalVar", []interface{}{arg1, arg2, arg3})
|
||||
fake.addLocalVarMutex.Unlock()
|
||||
if fake.AddLocalVarStub != nil {
|
||||
fake.AddLocalVarStub(arg1, arg2, arg3)
|
||||
}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) AddLocalVarCallCount() int {
|
||||
fake.addLocalVarMutex.RLock()
|
||||
defer fake.addLocalVarMutex.RUnlock()
|
||||
return len(fake.addLocalVarArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) AddLocalVarCalls(stub func(string, interface{}, bool)) {
|
||||
fake.addLocalVarMutex.Lock()
|
||||
defer fake.addLocalVarMutex.Unlock()
|
||||
fake.AddLocalVarStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) AddLocalVarArgsForCall(i int) (string, interface{}, bool) {
|
||||
fake.addLocalVarMutex.RLock()
|
||||
defer fake.addLocalVarMutex.RUnlock()
|
||||
argsForCall := fake.addLocalVarArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) Enabled() bool {
|
||||
fake.enabledMutex.Lock()
|
||||
ret, specificReturn := fake.enabledReturnsOnCall[len(fake.enabledArgsForCall)]
|
||||
fake.enabledArgsForCall = append(fake.enabledArgsForCall, struct {
|
||||
}{})
|
||||
fake.recordInvocation("Enabled", []interface{}{})
|
||||
fake.enabledMutex.Unlock()
|
||||
if fake.EnabledStub != nil {
|
||||
return fake.EnabledStub()
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
fakeReturns := fake.enabledReturns
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) EnabledCallCount() int {
|
||||
fake.enabledMutex.RLock()
|
||||
defer fake.enabledMutex.RUnlock()
|
||||
return len(fake.enabledArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) EnabledCalls(stub func() bool) {
|
||||
fake.enabledMutex.Lock()
|
||||
defer fake.enabledMutex.Unlock()
|
||||
fake.EnabledStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) EnabledReturns(result1 bool) {
|
||||
fake.enabledMutex.Lock()
|
||||
defer fake.enabledMutex.Unlock()
|
||||
fake.EnabledStub = nil
|
||||
fake.enabledReturns = struct {
|
||||
result1 bool
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) EnabledReturnsOnCall(i int, result1 bool) {
|
||||
fake.enabledMutex.Lock()
|
||||
defer fake.enabledMutex.Unlock()
|
||||
fake.EnabledStub = nil
|
||||
if fake.enabledReturnsOnCall == nil {
|
||||
fake.enabledReturnsOnCall = make(map[int]struct {
|
||||
result1 bool
|
||||
})
|
||||
}
|
||||
fake.enabledReturnsOnCall[i] = struct {
|
||||
result1 bool
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) Get(arg1 vars.VariableDefinition) (interface{}, bool, error) {
|
||||
fake.getMutex.Lock()
|
||||
ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)]
|
||||
fake.getArgsForCall = append(fake.getArgsForCall, struct {
|
||||
arg1 vars.VariableDefinition
|
||||
}{arg1})
|
||||
fake.recordInvocation("Get", []interface{}{arg1})
|
||||
fake.getMutex.Unlock()
|
||||
if fake.GetStub != nil {
|
||||
return fake.GetStub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2, ret.result3
|
||||
}
|
||||
fakeReturns := fake.getReturns
|
||||
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) GetCallCount() int {
|
||||
fake.getMutex.RLock()
|
||||
defer fake.getMutex.RUnlock()
|
||||
return len(fake.getArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) GetCalls(stub func(vars.VariableDefinition) (interface{}, bool, error)) {
|
||||
fake.getMutex.Lock()
|
||||
defer fake.getMutex.Unlock()
|
||||
fake.GetStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) GetArgsForCall(i int) vars.VariableDefinition {
|
||||
fake.getMutex.RLock()
|
||||
defer fake.getMutex.RUnlock()
|
||||
argsForCall := fake.getArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) GetReturns(result1 interface{}, result2 bool, result3 error) {
|
||||
fake.getMutex.Lock()
|
||||
defer fake.getMutex.Unlock()
|
||||
fake.GetStub = nil
|
||||
fake.getReturns = struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
}{result1, result2, result3}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) GetReturnsOnCall(i int, result1 interface{}, result2 bool, result3 error) {
|
||||
fake.getMutex.Lock()
|
||||
defer fake.getMutex.Unlock()
|
||||
fake.GetStub = nil
|
||||
if fake.getReturnsOnCall == nil {
|
||||
fake.getReturnsOnCall = make(map[int]struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
})
|
||||
}
|
||||
fake.getReturnsOnCall[i] = struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
}{result1, result2, result3}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) IterateInterpolatedCreds(arg1 vars.CredVarsTrackerIterator) {
|
||||
fake.iterateInterpolatedCredsMutex.Lock()
|
||||
fake.iterateInterpolatedCredsArgsForCall = append(fake.iterateInterpolatedCredsArgsForCall, struct {
|
||||
arg1 vars.CredVarsTrackerIterator
|
||||
}{arg1})
|
||||
fake.recordInvocation("IterateInterpolatedCreds", []interface{}{arg1})
|
||||
fake.iterateInterpolatedCredsMutex.Unlock()
|
||||
if fake.IterateInterpolatedCredsStub != nil {
|
||||
fake.IterateInterpolatedCredsStub(arg1)
|
||||
}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) IterateInterpolatedCredsCallCount() int {
|
||||
fake.iterateInterpolatedCredsMutex.RLock()
|
||||
defer fake.iterateInterpolatedCredsMutex.RUnlock()
|
||||
return len(fake.iterateInterpolatedCredsArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) IterateInterpolatedCredsCalls(stub func(vars.CredVarsTrackerIterator)) {
|
||||
fake.iterateInterpolatedCredsMutex.Lock()
|
||||
defer fake.iterateInterpolatedCredsMutex.Unlock()
|
||||
fake.IterateInterpolatedCredsStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) IterateInterpolatedCredsArgsForCall(i int) vars.CredVarsTrackerIterator {
|
||||
fake.iterateInterpolatedCredsMutex.RLock()
|
||||
defer fake.iterateInterpolatedCredsMutex.RUnlock()
|
||||
argsForCall := fake.iterateInterpolatedCredsArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) List() ([]vars.VariableDefinition, error) {
|
||||
fake.listMutex.Lock()
|
||||
ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)]
|
||||
fake.listArgsForCall = append(fake.listArgsForCall, struct {
|
||||
}{})
|
||||
fake.recordInvocation("List", []interface{}{})
|
||||
fake.listMutex.Unlock()
|
||||
if fake.ListStub != nil {
|
||||
return fake.ListStub()
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.listReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) ListCallCount() int {
|
||||
fake.listMutex.RLock()
|
||||
defer fake.listMutex.RUnlock()
|
||||
return len(fake.listArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) ListCalls(stub func() ([]vars.VariableDefinition, error)) {
|
||||
fake.listMutex.Lock()
|
||||
defer fake.listMutex.Unlock()
|
||||
fake.ListStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) ListReturns(result1 []vars.VariableDefinition, result2 error) {
|
||||
fake.listMutex.Lock()
|
||||
defer fake.listMutex.Unlock()
|
||||
fake.ListStub = nil
|
||||
fake.listReturns = struct {
|
||||
result1 []vars.VariableDefinition
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) ListReturnsOnCall(i int, result1 []vars.VariableDefinition, 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
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.listReturnsOnCall[i] = struct {
|
||||
result1 []vars.VariableDefinition
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) NewLocalScope() vars.CredVarsTracker {
|
||||
fake.newLocalScopeMutex.Lock()
|
||||
ret, specificReturn := fake.newLocalScopeReturnsOnCall[len(fake.newLocalScopeArgsForCall)]
|
||||
fake.newLocalScopeArgsForCall = append(fake.newLocalScopeArgsForCall, struct {
|
||||
}{})
|
||||
fake.recordInvocation("NewLocalScope", []interface{}{})
|
||||
fake.newLocalScopeMutex.Unlock()
|
||||
if fake.NewLocalScopeStub != nil {
|
||||
return fake.NewLocalScopeStub()
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
fakeReturns := fake.newLocalScopeReturns
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) NewLocalScopeCallCount() int {
|
||||
fake.newLocalScopeMutex.RLock()
|
||||
defer fake.newLocalScopeMutex.RUnlock()
|
||||
return len(fake.newLocalScopeArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) NewLocalScopeCalls(stub func() vars.CredVarsTracker) {
|
||||
fake.newLocalScopeMutex.Lock()
|
||||
defer fake.newLocalScopeMutex.Unlock()
|
||||
fake.NewLocalScopeStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) NewLocalScopeReturns(result1 vars.CredVarsTracker) {
|
||||
fake.newLocalScopeMutex.Lock()
|
||||
defer fake.newLocalScopeMutex.Unlock()
|
||||
fake.NewLocalScopeStub = nil
|
||||
fake.newLocalScopeReturns = struct {
|
||||
result1 vars.CredVarsTracker
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) NewLocalScopeReturnsOnCall(i int, result1 vars.CredVarsTracker) {
|
||||
fake.newLocalScopeMutex.Lock()
|
||||
defer fake.newLocalScopeMutex.Unlock()
|
||||
fake.NewLocalScopeStub = nil
|
||||
if fake.newLocalScopeReturnsOnCall == nil {
|
||||
fake.newLocalScopeReturnsOnCall = make(map[int]struct {
|
||||
result1 vars.CredVarsTracker
|
||||
})
|
||||
}
|
||||
fake.newLocalScopeReturnsOnCall[i] = struct {
|
||||
result1 vars.CredVarsTracker
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) Invocations() map[string][][]interface{} {
|
||||
fake.invocationsMutex.RLock()
|
||||
defer fake.invocationsMutex.RUnlock()
|
||||
fake.addLocalVarMutex.RLock()
|
||||
defer fake.addLocalVarMutex.RUnlock()
|
||||
fake.enabledMutex.RLock()
|
||||
defer fake.enabledMutex.RUnlock()
|
||||
fake.getMutex.RLock()
|
||||
defer fake.getMutex.RUnlock()
|
||||
fake.iterateInterpolatedCredsMutex.RLock()
|
||||
defer fake.iterateInterpolatedCredsMutex.RUnlock()
|
||||
fake.listMutex.RLock()
|
||||
defer fake.listMutex.RUnlock()
|
||||
fake.newLocalScopeMutex.RLock()
|
||||
defer fake.newLocalScopeMutex.RUnlock()
|
||||
copiedInvocations := map[string][][]interface{}{}
|
||||
for key, value := range fake.invocations {
|
||||
copiedInvocations[key] = value
|
||||
}
|
||||
return copiedInvocations
|
||||
}
|
||||
|
||||
func (fake *FakeCredVarsTracker) recordInvocation(key string, args []interface{}) {
|
||||
fake.invocationsMutex.Lock()
|
||||
defer fake.invocationsMutex.Unlock()
|
||||
if fake.invocations == nil {
|
||||
fake.invocations = map[string][][]interface{}{}
|
||||
}
|
||||
if fake.invocations[key] == nil {
|
||||
fake.invocations[key] = [][]interface{}{}
|
||||
}
|
||||
fake.invocations[key] = append(fake.invocations[key], args)
|
||||
}
|
||||
|
||||
var _ vars.CredVarsTracker = new(FakeCredVarsTracker)
|
||||
|
|
@ -0,0 +1,189 @@
|
|||
// Code generated by counterfeiter. DO NOT EDIT.
|
||||
package varsfakes
|
||||
|
||||
import (
|
||||
"sync"
|
||||
|
||||
"github.com/concourse/concourse/vars"
|
||||
)
|
||||
|
||||
type FakeVariables struct {
|
||||
GetStub func(vars.VariableDefinition) (interface{}, bool, error)
|
||||
getMutex sync.RWMutex
|
||||
getArgsForCall []struct {
|
||||
arg1 vars.VariableDefinition
|
||||
}
|
||||
getReturns struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
}
|
||||
getReturnsOnCall map[int]struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
}
|
||||
ListStub func() ([]vars.VariableDefinition, error)
|
||||
listMutex sync.RWMutex
|
||||
listArgsForCall []struct {
|
||||
}
|
||||
listReturns struct {
|
||||
result1 []vars.VariableDefinition
|
||||
result2 error
|
||||
}
|
||||
listReturnsOnCall map[int]struct {
|
||||
result1 []vars.VariableDefinition
|
||||
result2 error
|
||||
}
|
||||
invocations map[string][][]interface{}
|
||||
invocationsMutex sync.RWMutex
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) Get(arg1 vars.VariableDefinition) (interface{}, bool, error) {
|
||||
fake.getMutex.Lock()
|
||||
ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)]
|
||||
fake.getArgsForCall = append(fake.getArgsForCall, struct {
|
||||
arg1 vars.VariableDefinition
|
||||
}{arg1})
|
||||
fake.recordInvocation("Get", []interface{}{arg1})
|
||||
fake.getMutex.Unlock()
|
||||
if fake.GetStub != nil {
|
||||
return fake.GetStub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2, ret.result3
|
||||
}
|
||||
fakeReturns := fake.getReturns
|
||||
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) GetCallCount() int {
|
||||
fake.getMutex.RLock()
|
||||
defer fake.getMutex.RUnlock()
|
||||
return len(fake.getArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) GetCalls(stub func(vars.VariableDefinition) (interface{}, bool, error)) {
|
||||
fake.getMutex.Lock()
|
||||
defer fake.getMutex.Unlock()
|
||||
fake.GetStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) GetArgsForCall(i int) vars.VariableDefinition {
|
||||
fake.getMutex.RLock()
|
||||
defer fake.getMutex.RUnlock()
|
||||
argsForCall := fake.getArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) GetReturns(result1 interface{}, result2 bool, result3 error) {
|
||||
fake.getMutex.Lock()
|
||||
defer fake.getMutex.Unlock()
|
||||
fake.GetStub = nil
|
||||
fake.getReturns = struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
}{result1, result2, result3}
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) GetReturnsOnCall(i int, result1 interface{}, result2 bool, result3 error) {
|
||||
fake.getMutex.Lock()
|
||||
defer fake.getMutex.Unlock()
|
||||
fake.GetStub = nil
|
||||
if fake.getReturnsOnCall == nil {
|
||||
fake.getReturnsOnCall = make(map[int]struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
})
|
||||
}
|
||||
fake.getReturnsOnCall[i] = struct {
|
||||
result1 interface{}
|
||||
result2 bool
|
||||
result3 error
|
||||
}{result1, result2, result3}
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) List() ([]vars.VariableDefinition, error) {
|
||||
fake.listMutex.Lock()
|
||||
ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)]
|
||||
fake.listArgsForCall = append(fake.listArgsForCall, struct {
|
||||
}{})
|
||||
fake.recordInvocation("List", []interface{}{})
|
||||
fake.listMutex.Unlock()
|
||||
if fake.ListStub != nil {
|
||||
return fake.ListStub()
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
fakeReturns := fake.listReturns
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) ListCallCount() int {
|
||||
fake.listMutex.RLock()
|
||||
defer fake.listMutex.RUnlock()
|
||||
return len(fake.listArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) ListCalls(stub func() ([]vars.VariableDefinition, error)) {
|
||||
fake.listMutex.Lock()
|
||||
defer fake.listMutex.Unlock()
|
||||
fake.ListStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) ListReturns(result1 []vars.VariableDefinition, result2 error) {
|
||||
fake.listMutex.Lock()
|
||||
defer fake.listMutex.Unlock()
|
||||
fake.ListStub = nil
|
||||
fake.listReturns = struct {
|
||||
result1 []vars.VariableDefinition
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) ListReturnsOnCall(i int, result1 []vars.VariableDefinition, 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
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.listReturnsOnCall[i] = struct {
|
||||
result1 []vars.VariableDefinition
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) Invocations() map[string][][]interface{} {
|
||||
fake.invocationsMutex.RLock()
|
||||
defer fake.invocationsMutex.RUnlock()
|
||||
fake.getMutex.RLock()
|
||||
defer fake.getMutex.RUnlock()
|
||||
fake.listMutex.RLock()
|
||||
defer fake.listMutex.RUnlock()
|
||||
copiedInvocations := map[string][][]interface{}{}
|
||||
for key, value := range fake.invocations {
|
||||
copiedInvocations[key] = value
|
||||
}
|
||||
return copiedInvocations
|
||||
}
|
||||
|
||||
func (fake *FakeVariables) recordInvocation(key string, args []interface{}) {
|
||||
fake.invocationsMutex.Lock()
|
||||
defer fake.invocationsMutex.Unlock()
|
||||
if fake.invocations == nil {
|
||||
fake.invocations = map[string][][]interface{}{}
|
||||
}
|
||||
if fake.invocations[key] == nil {
|
||||
fake.invocations[key] = [][]interface{}{}
|
||||
}
|
||||
fake.invocations[key] = append(fake.invocations[key], args)
|
||||
}
|
||||
|
||||
var _ vars.Variables = new(FakeVariables)
|
||||
Loading…
Reference in New Issue