From 1f548a8e054638344178ab0b50035b1011b017cf Mon Sep 17 00:00:00 2001 From: Dimitar Yanakiev Date: Wed, 29 Nov 2023 10:49:56 +0200 Subject: [PATCH] Second set of tests --- Makefile | 6 +- component/mounts_table_test.go | 59 +++ component/policy_acl_table.go | 19 +- component/policy_acl_table_test.go | 72 +++ component/policy_table_test.go | 98 ++++ layout/layout_test.go | 49 ++ vault/client.go | 5 + vault/kv.go | 4 +- vault/secret.go | 6 +- vault/vaultfakes/fake_client.go | 102 +++++ view/init.go | 2 +- watcher/watcher.go | 2 + watcher/watcherfakes/fake_activities.go | 106 +++++ watcher/watcherfakes/fake_vault.go | 564 ++++++++++++++++++++++++ 14 files changed, 1077 insertions(+), 17 deletions(-) create mode 100644 component/policy_acl_table_test.go create mode 100644 component/policy_table_test.go create mode 100644 layout/layout_test.go create mode 100644 vault/vaultfakes/fake_client.go create mode 100644 watcher/watcherfakes/fake_activities.go create mode 100644 watcher/watcherfakes/fake_vault.go diff --git a/Makefile b/Makefile index 612dcc2..634eb57 100644 --- a/Makefile +++ b/Makefile @@ -23,4 +23,8 @@ build: .PHONY: run run: - ./bin/vaul7y \ No newline at end of file + ./bin/vaul7y + +.PHONY: test +test: + go test ./... \ No newline at end of file diff --git a/component/mounts_table_test.go b/component/mounts_table_test.go index d2e0c8d..0818382 100644 --- a/component/mounts_table_test.go +++ b/component/mounts_table_test.go @@ -6,6 +6,7 @@ import ( "github.com/dkyanakiev/vaulty/component" "github.com/dkyanakiev/vaulty/component/componentfakes" "github.com/dkyanakiev/vaulty/models" + "github.com/dkyanakiev/vaulty/styles" "github.com/gdamore/tcell/v2" "github.com/rivo/tview" "github.com/stretchr/testify/require" @@ -57,4 +58,62 @@ func TestMountsTable_Pass(t *testing.T) { }) + t.Run("No data to render", func(t *testing.T) { + fakeTable := &componentfakes.FakeTable{} + mTable := component.NewMountsTable() + + mTable.Table = fakeTable + mTable.Props.Namespace = "default" + mTable.Props.Data = map[string]*models.MountOutput{} + + var NoResourcesCalled bool + mTable.Props.HandleNoResources = func(format string, args ...interface{}) { + NoResourcesCalled = true + + r.Equal("%sno mounts available\n¯%s\\_( ͡• ͜ʖ ͡•)_/¯", format) + r.Len(args, 2) + r.Equal(args[0], styles.HighlightPrimaryTag) + r.Equal(args[1], styles.HighlightSecondaryTag) + } + + slot := tview.NewFlex() + mTable.Bind(slot) + + // It doesn't error + err := mTable.Render() + r.NoError(err) + + // It handled the case that there are no resources + r.True(NoResourcesCalled) + + // It didn't returned after handling no resources + r.Equal(fakeTable.RenderHeaderCallCount(), 0) + r.Equal(fakeTable.RenderRowCallCount(), 0) + + }) + } + +//TODO: Revisit after validation logic is fixed for mounts_table +// func TestMountsTable_Fail(t *testing.T) { +// r := require.New(t) + +// t.Run("When SelectDeployment is not set", func(t *testing.T) { +// mt := component.NewMountsTable() + +// mt.Props.HandleNoResources = func(format string, args ...interface{}) {} + +// slot := tview.NewFlex() +// mt.Bind(slot) + +// // It doesn't error +// err := mt.Render() +// r.NoError(err) + +// // It provides the correct error message +// r.EqualError(err, "component properties not set") + +// // It is the correct error +// r.True(errors.Is(err, component.ErrComponentPropsNotSet)) +// }) +// } diff --git a/component/policy_acl_table.go b/component/policy_acl_table.go index 7f52ed4..8fbf0af 100644 --- a/component/policy_acl_table.go +++ b/component/policy_acl_table.go @@ -71,18 +71,17 @@ func (p *PolicyAclTable) reset() { func (p *PolicyAclTable) Render() error { p.reset() + //p.Table.RenderHeader(PolicyAclTableHeaders) - if p.Props == nil { - if p.Props.SelectedPolicyACL == "" { - p.Props.HandleNoResources( - "%sCant read ACL policy \n%s\\(╯°□°)╯︵ ┻━┻", - styles.HighlightPrimaryTag, - styles.HighlightSecondaryTag, - ) - return nil - } + if p.Props.SelectedPolicyACL == "" { + p.Props.HandleNoResources( + "%sCant read ACL policy \n%s\\(╯°□°)╯︵ ┻━┻", + styles.HighlightPrimaryTag, + styles.HighlightSecondaryTag, + ) + return nil } - //p.Table.RenderHeader(PolicyAclTableHeaders) + p.renderACL() p.slot.AddItem(p.TextView.Primitive(), 0, 1, false) return nil diff --git a/component/policy_acl_table_test.go b/component/policy_acl_table_test.go new file mode 100644 index 0000000..05e1356 --- /dev/null +++ b/component/policy_acl_table_test.go @@ -0,0 +1,72 @@ +package component_test + +import ( + "testing" + + "github.com/dkyanakiev/vaulty/component" + "github.com/dkyanakiev/vaulty/component/componentfakes" + "github.com/dkyanakiev/vaulty/styles" + "github.com/rivo/tview" + "github.com/stretchr/testify/require" +) + +func TestPolicyACLTable_Pass(t *testing.T) { + r := require.New(t) + t.Run("Data to be rendered", func(t *testing.T) { + // fakeTable := &componentfakes.FakeTable{} + fakeTextView := &componentfakes.FakeTextView{} + pt := component.NewPolicyAclTable() + + pt.TextView = fakeTextView + pt.Props.SelectedPolicyName = "policy-one" + pt.Props.SelectedPolicyACL = "path \"secret/data/path\" { capabilities = [\"read\", \"list\"] }" + + pt.Props.SelectPath = func(id string) {} + pt.Props.HandleNoResources = func(format string, args ...interface{}) {} + + slot := tview.NewFlex() + pt.Bind(slot) + + err := pt.Render() + r.NoError(err) + + // It renders the correct text + fakeTextView.GetTextReturns(pt.Props.SelectedPolicyACL) + fakeTextView.GetTextReturnsOnCall(0, pt.Props.SelectedPolicyACL) + renderedText := fakeTextView.GetText(true) + + r.Equal("path \"secret/data/path\" { capabilities = [\"read\", \"list\"] }", renderedText) + + }) + + t.Run("No data to be rendered", func(t *testing.T) { + fakeTextView := &componentfakes.FakeTextView{} + pt := component.NewPolicyAclTable() + + pt.TextView = fakeTextView + pt.Props.SelectedPolicyName = "policy-one" + pt.Props.SelectedPolicyACL = "" + + var handleNoResourcesCalled bool + pt.Props.HandleNoResources = func(format string, args ...interface{}) { + handleNoResourcesCalled = true + + r.Equal("%sCant read ACL policy \n%s\\(╯°□°)╯︵ ┻━┻", format) + r.Len(args, 2) + r.Equal(args[0], styles.HighlightPrimaryTag) + r.Equal(args[1], styles.HighlightSecondaryTag) + } + + slot := tview.NewFlex() + pt.Bind(slot) + + err := pt.Render() + r.NoError(err) + + r.True(handleNoResourcesCalled) + + }) +} + +func TestPolicyACLTable_Fail(t *testing.T) { +} diff --git a/component/policy_table_test.go b/component/policy_table_test.go new file mode 100644 index 0000000..17e8f87 --- /dev/null +++ b/component/policy_table_test.go @@ -0,0 +1,98 @@ +package component_test + +import ( + "testing" + + "github.com/dkyanakiev/vaulty/component" + "github.com/dkyanakiev/vaulty/component/componentfakes" + "github.com/dkyanakiev/vaulty/styles" + "github.com/gdamore/tcell/v2" + "github.com/rivo/tview" + "github.com/stretchr/testify/require" +) + +func TestPolicyTable_Pass(t *testing.T) { + r := require.New(t) + t.Run("When the component is bound", func(t *testing.T) { + + fakeTable := &componentfakes.FakeTable{} + pt := component.NewPolicyTable() + + pt.Table = fakeTable + pt.Props.Data = []string{"policy1", "policy2", "policy3"} + + pt.Props.SelectPath = func(id string) {} + pt.Props.HandleNoResources = func(format string, args ...interface{}) {} + slot := tview.NewFlex() + pt.Bind(slot) + // It doesn't error + err := pt.Render() + r.NoError(err) + + // Render header rows + renderHeaderCount := fakeTable.RenderHeaderCallCount() + r.Equal(renderHeaderCount, 1) + + // Correct headers + header := fakeTable.RenderHeaderArgsForCall(0) + r.Equal(component.PolicyTableHeaderJobs, header) + + // It renders the correct number of rows + renderRowCallCount := fakeTable.RenderRowCallCount() + r.Equal(renderRowCallCount, 3) + + row1, index1, c1 := fakeTable.RenderRowArgsForCall(0) + row2, index2, c2 := fakeTable.RenderRowArgsForCall(1) + row3, index3, c3 := fakeTable.RenderRowArgsForCall(2) + + expectedRow1 := []string{"policy1"} + expectedRow2 := []string{"policy2"} + expectedRow3 := []string{"policy3"} + + r.Equal(expectedRow1, row1) + r.Equal(expectedRow2, row2) + r.Equal(expectedRow3, row3) + r.Equal(index1, 1) + r.Equal(index2, 2) + r.Equal(index3, 3) + + r.Equal(c1, tcell.ColorYellow) + r.Equal(c2, tcell.ColorYellow) + r.Equal(c3, tcell.ColorYellow) + + }) + + t.Run("No data to render", func(t *testing.T) { + fakeTable := &componentfakes.FakeTable{} + pt := component.NewPolicyTable() + + pt.Table = fakeTable + pt.Props.Data = []string{} + + pt.Props.HandleNoResources = func(format string, args ...interface{}) {} + var NoResourcesCalled bool + pt.Props.HandleNoResources = func(format string, args ...interface{}) { + NoResourcesCalled = true + + r.Equal("%sNo policy found\n%s\\(╯°□°)╯︵ ┻━┻", format) + r.Len(args, 2) + r.Equal(args[0], styles.HighlightPrimaryTag) + r.Equal(args[1], styles.HighlightSecondaryTag) + } + + slot := tview.NewFlex() + pt.Bind(slot) + // It doesn't error + err := pt.Render() + r.NoError(err) + + // It handled the case that there are no resources + r.True(NoResourcesCalled) + + // It didn't returned after handling no resources + r.Equal(fakeTable.RenderHeaderCallCount(), 0) + r.Equal(fakeTable.RenderRowCallCount(), 0) + + }) + +} diff --git a/layout/layout_test.go b/layout/layout_test.go new file mode 100644 index 0000000..362ddd0 --- /dev/null +++ b/layout/layout_test.go @@ -0,0 +1,49 @@ +package layout_test + +import ( + "testing" + + "github.com/dkyanakiev/vaulty/layout" + "github.com/rivo/tview" + "github.com/stretchr/testify/require" +) + +func TestDefaultLayout(t *testing.T) { + r := require.New(t) + + l := layout.New(layout.Default) + + r.NotNil(l.Container) + r.IsType(l.Container, &tview.Application{}) + + r.NotNil(l.Pages) + r.IsType(l.Pages, &tview.Pages{}) + r.Equal(l.Pages.GetPageCount(), 1) + r.True(l.Pages.HasPage("main")) + + r.NotNil(l.Header) + r.NotNil(l.Header.SlotInfo) + r.IsType(l.Header.SlotInfo, &tview.Flex{}) + + r.NotNil(l.Header.SlotCmd) + r.IsType(l.Header.SlotCmd, &tview.Flex{}) + + r.NotNil(l.Header.SlotLogo) + r.IsType(l.Header.SlotLogo, &tview.Flex{}) + + r.NotNil(l.Elements) + r.NotNil(l.Elements.ClusterInfo) + r.IsType(l.Elements.ClusterInfo, &tview.Flex{}) + + r.NotNil(l.Elements.Dropdowns) + r.IsType(l.Elements.Dropdowns, &tview.Flex{}) + + r.NotNil(l.Body) + r.IsType(l.Body, &tview.Flex{}) + + r.NotNil(l.Footer) + r.IsType(l.Footer, &tview.Flex{}) + + r.NotNil(l.MainPage) + r.IsType(l.MainPage, &tview.Flex{}) +} diff --git a/vault/client.go b/vault/client.go index 142f9e3..b4bb2b5 100644 --- a/vault/client.go +++ b/vault/client.go @@ -7,10 +7,12 @@ import ( "github.com/rs/zerolog" ) +//go:generate counterfeiter . Client type Client interface { Address() string } +//go:generate counterfeiter . Vault type Vault struct { vault *api.Client Client Client @@ -21,6 +23,7 @@ type Vault struct { Logger *zerolog.Logger } +//go:generate counterfeiter . Logical type Logical interface { List(path string) (*api.Secret, error) } @@ -29,6 +32,7 @@ type Secret interface { //ListSecrets(string) (*api.Secret, error) } +//go:generate counterfeiter . Sys type Sys interface { ListMounts() (map[string]*api.MountOutput, error) ListPolicies() ([]string, error) @@ -36,6 +40,7 @@ type Sys interface { //ListMounts() ([]*api.Sys, error) } +//go:generate counterfeiter . KV2 type KV2 interface { Get(context.Context, string) (*api.KVSecret, error) GetMetadata(context.Context, string) (*api.KVMetadata, error) diff --git a/vault/kv.go b/vault/kv.go index c5dce39..a5445d7 100644 --- a/vault/kv.go +++ b/vault/kv.go @@ -9,7 +9,7 @@ import ( func (v *Vault) Get(ctx context.Context, path string) (*api.KVSecret, error) { secret, err := v.KV2.Get(ctx, path) if err != nil { - v.Logger.Err(err).Msgf("filed to retrieve secret: %w", err) + v.Logger.Err(err).Msgf("filed to retrieve secret: %s", err) } return secret, nil } @@ -17,7 +17,7 @@ func (v *Vault) Get(ctx context.Context, path string) (*api.KVSecret, error) { func (v *Vault) GetMetadata(ctx context.Context, path string) (*api.KVMetadata, error) { secret, err := v.KV2.GetMetadata(ctx, path) if err != nil { - v.Logger.Err(err).Msgf("filed to retrieve secret: %w", err) + v.Logger.Err(err).Msgf("filed to retrieve secret: %s", err) } return secret, nil } diff --git a/vault/secret.go b/vault/secret.go index f26dbae..8ccdfca 100644 --- a/vault/secret.go +++ b/vault/secret.go @@ -71,8 +71,8 @@ func (v *Vault) ListNestedSecrets(mount, path string) ([]models.SecretPath, erro v.Logger.Debug().Msg(fmt.Sprintf("Listing secrets for path: %s", mountPath)) if err != nil { - v.Logger.Err(err).Msgf("failed to list secrets: %w", err) - return nil, fmt.Errorf("failed to list secrets: %w", err) + v.Logger.Err(err).Msgf("failed to list secrets: %s", err) + return nil, fmt.Errorf("failed to list secrets: %s", err) } if secrets == nil { @@ -108,7 +108,7 @@ func (v *Vault) GetSecretInfo(mount, path string) (*api.Secret, error) { secretPath = sanitizePath(secretPath) secretData, err := v.vault.Logical().Read(secretPath) if err != nil { - v.Logger.Err(err).Msgf("failed to read secret: %w", err) + v.Logger.Err(err).Msgf("failed to read secret: %s", err) return nil, errors.New(fmt.Sprintf("Failed to read secret: %v", err)) } diff --git a/vault/vaultfakes/fake_client.go b/vault/vaultfakes/fake_client.go new file mode 100644 index 0000000..5fc168a --- /dev/null +++ b/vault/vaultfakes/fake_client.go @@ -0,0 +1,102 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package vaultfakes + +import ( + "sync" + + "github.com/dkyanakiev/vaulty/vault" +) + +type FakeClient struct { + AddressStub func() string + addressMutex sync.RWMutex + addressArgsForCall []struct { + } + addressReturns struct { + result1 string + } + addressReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeClient) Address() string { + fake.addressMutex.Lock() + ret, specificReturn := fake.addressReturnsOnCall[len(fake.addressArgsForCall)] + fake.addressArgsForCall = append(fake.addressArgsForCall, struct { + }{}) + stub := fake.AddressStub + fakeReturns := fake.addressReturns + fake.recordInvocation("Address", []interface{}{}) + fake.addressMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeClient) AddressCallCount() int { + fake.addressMutex.RLock() + defer fake.addressMutex.RUnlock() + return len(fake.addressArgsForCall) +} + +func (fake *FakeClient) AddressCalls(stub func() string) { + fake.addressMutex.Lock() + defer fake.addressMutex.Unlock() + fake.AddressStub = stub +} + +func (fake *FakeClient) AddressReturns(result1 string) { + fake.addressMutex.Lock() + defer fake.addressMutex.Unlock() + fake.AddressStub = nil + fake.addressReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeClient) AddressReturnsOnCall(i int, result1 string) { + fake.addressMutex.Lock() + defer fake.addressMutex.Unlock() + fake.AddressStub = nil + if fake.addressReturnsOnCall == nil { + fake.addressReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.addressReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeClient) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.addressMutex.RLock() + defer fake.addressMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeClient) 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 _ vault.Client = new(FakeClient) diff --git a/view/init.go b/view/init.go index 91b412f..2823fca 100644 --- a/view/init.go +++ b/view/init.go @@ -102,7 +102,7 @@ func (v *View) Init(version string) { v.components.Info.Bind(v.Layout.Pages) v.components.Info.Props.Done = func(buttonIndex int, buttonLabel string) { v.Layout.Pages.RemovePage(component.PageNameInfo) - v.logger.Debug().Msgf("Info page removed, Active page is: ", v.state.Elements.TableMain) + v.logger.Debug().Msgf("Info page removed, Active page is: %s", v.state.Elements.TableMain.GetTitle()) v.Layout.Container.SetFocus(v.state.Elements.TableMain) // v.GoBack() } diff --git a/watcher/watcher.go b/watcher/watcher.go index 3d2baba..d6e4939 100644 --- a/watcher/watcher.go +++ b/watcher/watcher.go @@ -9,11 +9,13 @@ import ( "github.com/rs/zerolog" ) +//go:generate counterfeiter . Activities type Activities interface { Add(chan struct{}) DeactivateAll() } +//go:generate counterfeiter . Vault type Vault interface { Address() string AllPolicies() ([]string, error) diff --git a/watcher/watcherfakes/fake_activities.go b/watcher/watcherfakes/fake_activities.go new file mode 100644 index 0000000..5a157cb --- /dev/null +++ b/watcher/watcherfakes/fake_activities.go @@ -0,0 +1,106 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package watcherfakes + +import ( + "sync" + + "github.com/dkyanakiev/vaulty/watcher" +) + +type FakeActivities struct { + AddStub func(chan struct{}) + addMutex sync.RWMutex + addArgsForCall []struct { + arg1 chan struct{} + } + DeactivateAllStub func() + deactivateAllMutex sync.RWMutex + deactivateAllArgsForCall []struct { + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeActivities) Add(arg1 chan struct{}) { + fake.addMutex.Lock() + fake.addArgsForCall = append(fake.addArgsForCall, struct { + arg1 chan struct{} + }{arg1}) + stub := fake.AddStub + fake.recordInvocation("Add", []interface{}{arg1}) + fake.addMutex.Unlock() + if stub != nil { + fake.AddStub(arg1) + } +} + +func (fake *FakeActivities) AddCallCount() int { + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + return len(fake.addArgsForCall) +} + +func (fake *FakeActivities) AddCalls(stub func(chan struct{})) { + fake.addMutex.Lock() + defer fake.addMutex.Unlock() + fake.AddStub = stub +} + +func (fake *FakeActivities) AddArgsForCall(i int) chan struct{} { + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + argsForCall := fake.addArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeActivities) DeactivateAll() { + fake.deactivateAllMutex.Lock() + fake.deactivateAllArgsForCall = append(fake.deactivateAllArgsForCall, struct { + }{}) + stub := fake.DeactivateAllStub + fake.recordInvocation("DeactivateAll", []interface{}{}) + fake.deactivateAllMutex.Unlock() + if stub != nil { + fake.DeactivateAllStub() + } +} + +func (fake *FakeActivities) DeactivateAllCallCount() int { + fake.deactivateAllMutex.RLock() + defer fake.deactivateAllMutex.RUnlock() + return len(fake.deactivateAllArgsForCall) +} + +func (fake *FakeActivities) DeactivateAllCalls(stub func()) { + fake.deactivateAllMutex.Lock() + defer fake.deactivateAllMutex.Unlock() + fake.DeactivateAllStub = stub +} + +func (fake *FakeActivities) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + fake.deactivateAllMutex.RLock() + defer fake.deactivateAllMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeActivities) 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 _ watcher.Activities = new(FakeActivities) diff --git a/watcher/watcherfakes/fake_vault.go b/watcher/watcherfakes/fake_vault.go new file mode 100644 index 0000000..07a99a9 --- /dev/null +++ b/watcher/watcherfakes/fake_vault.go @@ -0,0 +1,564 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package watcherfakes + +import ( + "sync" + + "github.com/dkyanakiev/vaulty/models" + "github.com/dkyanakiev/vaulty/watcher" + "github.com/hashicorp/vault/api" +) + +type FakeVault struct { + AddressStub func() string + addressMutex sync.RWMutex + addressArgsForCall []struct { + } + addressReturns struct { + result1 string + } + addressReturnsOnCall map[int]struct { + result1 string + } + AllMountsStub func() (map[string]*models.MountOutput, error) + allMountsMutex sync.RWMutex + allMountsArgsForCall []struct { + } + allMountsReturns struct { + result1 map[string]*models.MountOutput + result2 error + } + allMountsReturnsOnCall map[int]struct { + result1 map[string]*models.MountOutput + result2 error + } + AllPoliciesStub func() ([]string, error) + allPoliciesMutex sync.RWMutex + allPoliciesArgsForCall []struct { + } + allPoliciesReturns struct { + result1 []string + result2 error + } + allPoliciesReturnsOnCall map[int]struct { + result1 []string + result2 error + } + GetPolicyInfoStub func(string) (string, error) + getPolicyInfoMutex sync.RWMutex + getPolicyInfoArgsForCall []struct { + arg1 string + } + getPolicyInfoReturns struct { + result1 string + result2 error + } + getPolicyInfoReturnsOnCall map[int]struct { + result1 string + result2 error + } + GetSecretInfoStub func(string, string) (*api.Secret, error) + getSecretInfoMutex sync.RWMutex + getSecretInfoArgsForCall []struct { + arg1 string + arg2 string + } + getSecretInfoReturns struct { + result1 *api.Secret + result2 error + } + getSecretInfoReturnsOnCall map[int]struct { + result1 *api.Secret + result2 error + } + ListNestedSecretsStub func(string, string) ([]models.SecretPath, error) + listNestedSecretsMutex sync.RWMutex + listNestedSecretsArgsForCall []struct { + arg1 string + arg2 string + } + listNestedSecretsReturns struct { + result1 []models.SecretPath + result2 error + } + listNestedSecretsReturnsOnCall map[int]struct { + result1 []models.SecretPath + result2 error + } + ListSecretsStub func(string) (*api.Secret, error) + listSecretsMutex sync.RWMutex + listSecretsArgsForCall []struct { + arg1 string + } + listSecretsReturns struct { + result1 *api.Secret + result2 error + } + listSecretsReturnsOnCall map[int]struct { + result1 *api.Secret + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeVault) Address() string { + fake.addressMutex.Lock() + ret, specificReturn := fake.addressReturnsOnCall[len(fake.addressArgsForCall)] + fake.addressArgsForCall = append(fake.addressArgsForCall, struct { + }{}) + stub := fake.AddressStub + fakeReturns := fake.addressReturns + fake.recordInvocation("Address", []interface{}{}) + fake.addressMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVault) AddressCallCount() int { + fake.addressMutex.RLock() + defer fake.addressMutex.RUnlock() + return len(fake.addressArgsForCall) +} + +func (fake *FakeVault) AddressCalls(stub func() string) { + fake.addressMutex.Lock() + defer fake.addressMutex.Unlock() + fake.AddressStub = stub +} + +func (fake *FakeVault) AddressReturns(result1 string) { + fake.addressMutex.Lock() + defer fake.addressMutex.Unlock() + fake.AddressStub = nil + fake.addressReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeVault) AddressReturnsOnCall(i int, result1 string) { + fake.addressMutex.Lock() + defer fake.addressMutex.Unlock() + fake.AddressStub = nil + if fake.addressReturnsOnCall == nil { + fake.addressReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.addressReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeVault) AllMounts() (map[string]*models.MountOutput, error) { + fake.allMountsMutex.Lock() + ret, specificReturn := fake.allMountsReturnsOnCall[len(fake.allMountsArgsForCall)] + fake.allMountsArgsForCall = append(fake.allMountsArgsForCall, struct { + }{}) + stub := fake.AllMountsStub + fakeReturns := fake.allMountsReturns + fake.recordInvocation("AllMounts", []interface{}{}) + fake.allMountsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVault) AllMountsCallCount() int { + fake.allMountsMutex.RLock() + defer fake.allMountsMutex.RUnlock() + return len(fake.allMountsArgsForCall) +} + +func (fake *FakeVault) AllMountsCalls(stub func() (map[string]*models.MountOutput, error)) { + fake.allMountsMutex.Lock() + defer fake.allMountsMutex.Unlock() + fake.AllMountsStub = stub +} + +func (fake *FakeVault) AllMountsReturns(result1 map[string]*models.MountOutput, result2 error) { + fake.allMountsMutex.Lock() + defer fake.allMountsMutex.Unlock() + fake.AllMountsStub = nil + fake.allMountsReturns = struct { + result1 map[string]*models.MountOutput + result2 error + }{result1, result2} +} + +func (fake *FakeVault) AllMountsReturnsOnCall(i int, result1 map[string]*models.MountOutput, result2 error) { + fake.allMountsMutex.Lock() + defer fake.allMountsMutex.Unlock() + fake.AllMountsStub = nil + if fake.allMountsReturnsOnCall == nil { + fake.allMountsReturnsOnCall = make(map[int]struct { + result1 map[string]*models.MountOutput + result2 error + }) + } + fake.allMountsReturnsOnCall[i] = struct { + result1 map[string]*models.MountOutput + result2 error + }{result1, result2} +} + +func (fake *FakeVault) AllPolicies() ([]string, error) { + fake.allPoliciesMutex.Lock() + ret, specificReturn := fake.allPoliciesReturnsOnCall[len(fake.allPoliciesArgsForCall)] + fake.allPoliciesArgsForCall = append(fake.allPoliciesArgsForCall, struct { + }{}) + stub := fake.AllPoliciesStub + fakeReturns := fake.allPoliciesReturns + fake.recordInvocation("AllPolicies", []interface{}{}) + fake.allPoliciesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVault) AllPoliciesCallCount() int { + fake.allPoliciesMutex.RLock() + defer fake.allPoliciesMutex.RUnlock() + return len(fake.allPoliciesArgsForCall) +} + +func (fake *FakeVault) AllPoliciesCalls(stub func() ([]string, error)) { + fake.allPoliciesMutex.Lock() + defer fake.allPoliciesMutex.Unlock() + fake.AllPoliciesStub = stub +} + +func (fake *FakeVault) AllPoliciesReturns(result1 []string, result2 error) { + fake.allPoliciesMutex.Lock() + defer fake.allPoliciesMutex.Unlock() + fake.AllPoliciesStub = nil + fake.allPoliciesReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *FakeVault) AllPoliciesReturnsOnCall(i int, result1 []string, result2 error) { + fake.allPoliciesMutex.Lock() + defer fake.allPoliciesMutex.Unlock() + fake.AllPoliciesStub = nil + if fake.allPoliciesReturnsOnCall == nil { + fake.allPoliciesReturnsOnCall = make(map[int]struct { + result1 []string + result2 error + }) + } + fake.allPoliciesReturnsOnCall[i] = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *FakeVault) GetPolicyInfo(arg1 string) (string, error) { + fake.getPolicyInfoMutex.Lock() + ret, specificReturn := fake.getPolicyInfoReturnsOnCall[len(fake.getPolicyInfoArgsForCall)] + fake.getPolicyInfoArgsForCall = append(fake.getPolicyInfoArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.GetPolicyInfoStub + fakeReturns := fake.getPolicyInfoReturns + fake.recordInvocation("GetPolicyInfo", []interface{}{arg1}) + fake.getPolicyInfoMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVault) GetPolicyInfoCallCount() int { + fake.getPolicyInfoMutex.RLock() + defer fake.getPolicyInfoMutex.RUnlock() + return len(fake.getPolicyInfoArgsForCall) +} + +func (fake *FakeVault) GetPolicyInfoCalls(stub func(string) (string, error)) { + fake.getPolicyInfoMutex.Lock() + defer fake.getPolicyInfoMutex.Unlock() + fake.GetPolicyInfoStub = stub +} + +func (fake *FakeVault) GetPolicyInfoArgsForCall(i int) string { + fake.getPolicyInfoMutex.RLock() + defer fake.getPolicyInfoMutex.RUnlock() + argsForCall := fake.getPolicyInfoArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeVault) GetPolicyInfoReturns(result1 string, result2 error) { + fake.getPolicyInfoMutex.Lock() + defer fake.getPolicyInfoMutex.Unlock() + fake.GetPolicyInfoStub = nil + fake.getPolicyInfoReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeVault) GetPolicyInfoReturnsOnCall(i int, result1 string, result2 error) { + fake.getPolicyInfoMutex.Lock() + defer fake.getPolicyInfoMutex.Unlock() + fake.GetPolicyInfoStub = nil + if fake.getPolicyInfoReturnsOnCall == nil { + fake.getPolicyInfoReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.getPolicyInfoReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeVault) GetSecretInfo(arg1 string, arg2 string) (*api.Secret, error) { + fake.getSecretInfoMutex.Lock() + ret, specificReturn := fake.getSecretInfoReturnsOnCall[len(fake.getSecretInfoArgsForCall)] + fake.getSecretInfoArgsForCall = append(fake.getSecretInfoArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.GetSecretInfoStub + fakeReturns := fake.getSecretInfoReturns + fake.recordInvocation("GetSecretInfo", []interface{}{arg1, arg2}) + fake.getSecretInfoMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVault) GetSecretInfoCallCount() int { + fake.getSecretInfoMutex.RLock() + defer fake.getSecretInfoMutex.RUnlock() + return len(fake.getSecretInfoArgsForCall) +} + +func (fake *FakeVault) GetSecretInfoCalls(stub func(string, string) (*api.Secret, error)) { + fake.getSecretInfoMutex.Lock() + defer fake.getSecretInfoMutex.Unlock() + fake.GetSecretInfoStub = stub +} + +func (fake *FakeVault) GetSecretInfoArgsForCall(i int) (string, string) { + fake.getSecretInfoMutex.RLock() + defer fake.getSecretInfoMutex.RUnlock() + argsForCall := fake.getSecretInfoArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeVault) GetSecretInfoReturns(result1 *api.Secret, result2 error) { + fake.getSecretInfoMutex.Lock() + defer fake.getSecretInfoMutex.Unlock() + fake.GetSecretInfoStub = nil + fake.getSecretInfoReturns = struct { + result1 *api.Secret + result2 error + }{result1, result2} +} + +func (fake *FakeVault) GetSecretInfoReturnsOnCall(i int, result1 *api.Secret, result2 error) { + fake.getSecretInfoMutex.Lock() + defer fake.getSecretInfoMutex.Unlock() + fake.GetSecretInfoStub = nil + if fake.getSecretInfoReturnsOnCall == nil { + fake.getSecretInfoReturnsOnCall = make(map[int]struct { + result1 *api.Secret + result2 error + }) + } + fake.getSecretInfoReturnsOnCall[i] = struct { + result1 *api.Secret + result2 error + }{result1, result2} +} + +func (fake *FakeVault) ListNestedSecrets(arg1 string, arg2 string) ([]models.SecretPath, error) { + fake.listNestedSecretsMutex.Lock() + ret, specificReturn := fake.listNestedSecretsReturnsOnCall[len(fake.listNestedSecretsArgsForCall)] + fake.listNestedSecretsArgsForCall = append(fake.listNestedSecretsArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.ListNestedSecretsStub + fakeReturns := fake.listNestedSecretsReturns + fake.recordInvocation("ListNestedSecrets", []interface{}{arg1, arg2}) + fake.listNestedSecretsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVault) ListNestedSecretsCallCount() int { + fake.listNestedSecretsMutex.RLock() + defer fake.listNestedSecretsMutex.RUnlock() + return len(fake.listNestedSecretsArgsForCall) +} + +func (fake *FakeVault) ListNestedSecretsCalls(stub func(string, string) ([]models.SecretPath, error)) { + fake.listNestedSecretsMutex.Lock() + defer fake.listNestedSecretsMutex.Unlock() + fake.ListNestedSecretsStub = stub +} + +func (fake *FakeVault) ListNestedSecretsArgsForCall(i int) (string, string) { + fake.listNestedSecretsMutex.RLock() + defer fake.listNestedSecretsMutex.RUnlock() + argsForCall := fake.listNestedSecretsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeVault) ListNestedSecretsReturns(result1 []models.SecretPath, result2 error) { + fake.listNestedSecretsMutex.Lock() + defer fake.listNestedSecretsMutex.Unlock() + fake.ListNestedSecretsStub = nil + fake.listNestedSecretsReturns = struct { + result1 []models.SecretPath + result2 error + }{result1, result2} +} + +func (fake *FakeVault) ListNestedSecretsReturnsOnCall(i int, result1 []models.SecretPath, result2 error) { + fake.listNestedSecretsMutex.Lock() + defer fake.listNestedSecretsMutex.Unlock() + fake.ListNestedSecretsStub = nil + if fake.listNestedSecretsReturnsOnCall == nil { + fake.listNestedSecretsReturnsOnCall = make(map[int]struct { + result1 []models.SecretPath + result2 error + }) + } + fake.listNestedSecretsReturnsOnCall[i] = struct { + result1 []models.SecretPath + result2 error + }{result1, result2} +} + +func (fake *FakeVault) ListSecrets(arg1 string) (*api.Secret, error) { + fake.listSecretsMutex.Lock() + ret, specificReturn := fake.listSecretsReturnsOnCall[len(fake.listSecretsArgsForCall)] + fake.listSecretsArgsForCall = append(fake.listSecretsArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.ListSecretsStub + fakeReturns := fake.listSecretsReturns + fake.recordInvocation("ListSecrets", []interface{}{arg1}) + fake.listSecretsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVault) ListSecretsCallCount() int { + fake.listSecretsMutex.RLock() + defer fake.listSecretsMutex.RUnlock() + return len(fake.listSecretsArgsForCall) +} + +func (fake *FakeVault) ListSecretsCalls(stub func(string) (*api.Secret, error)) { + fake.listSecretsMutex.Lock() + defer fake.listSecretsMutex.Unlock() + fake.ListSecretsStub = stub +} + +func (fake *FakeVault) ListSecretsArgsForCall(i int) string { + fake.listSecretsMutex.RLock() + defer fake.listSecretsMutex.RUnlock() + argsForCall := fake.listSecretsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeVault) ListSecretsReturns(result1 *api.Secret, result2 error) { + fake.listSecretsMutex.Lock() + defer fake.listSecretsMutex.Unlock() + fake.ListSecretsStub = nil + fake.listSecretsReturns = struct { + result1 *api.Secret + result2 error + }{result1, result2} +} + +func (fake *FakeVault) ListSecretsReturnsOnCall(i int, result1 *api.Secret, result2 error) { + fake.listSecretsMutex.Lock() + defer fake.listSecretsMutex.Unlock() + fake.ListSecretsStub = nil + if fake.listSecretsReturnsOnCall == nil { + fake.listSecretsReturnsOnCall = make(map[int]struct { + result1 *api.Secret + result2 error + }) + } + fake.listSecretsReturnsOnCall[i] = struct { + result1 *api.Secret + result2 error + }{result1, result2} +} + +func (fake *FakeVault) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.addressMutex.RLock() + defer fake.addressMutex.RUnlock() + fake.allMountsMutex.RLock() + defer fake.allMountsMutex.RUnlock() + fake.allPoliciesMutex.RLock() + defer fake.allPoliciesMutex.RUnlock() + fake.getPolicyInfoMutex.RLock() + defer fake.getPolicyInfoMutex.RUnlock() + fake.getSecretInfoMutex.RLock() + defer fake.getSecretInfoMutex.RUnlock() + fake.listNestedSecretsMutex.RLock() + defer fake.listNestedSecretsMutex.RUnlock() + fake.listSecretsMutex.RLock() + defer fake.listSecretsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeVault) 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 _ watcher.Vault = new(FakeVault)