diff --git a/pkg/common/providers/core/provider.go b/pkg/common/providers/core/provider.go index 95b52ae6d0..f9b3e7bcbc 100644 --- a/pkg/common/providers/core/provider.go +++ b/pkg/common/providers/core/provider.go @@ -29,23 +29,7 @@ type Providers interface { //ConfigProvider provides config backend for SDK type ConfigProvider func() (ConfigBackend, error) -//LookupOpts contains options for looking up key in config backend -type LookupOpts struct { - UnmarshalType interface{} -} - -//LookupOption option to lookup key in config backend -type LookupOption func(opts *LookupOpts) - //ConfigBackend backend for all config types in SDK type ConfigBackend interface { - //TODO lookupOption should be removed, unmarshal option should be handled externally - Lookup(key string, opts ...LookupOption) (interface{}, bool) -} - -//WithUnmarshalType lookup option which can be used to unmarshal lookup value to provided type -func WithUnmarshalType(unmarshalType interface{}) LookupOption { - return func(opts *LookupOpts) { - opts.UnmarshalType = unmarshalType - } + Lookup(key string) (interface{}, bool) } diff --git a/pkg/common/providers/test/mockcore/mockcore.gen.go b/pkg/common/providers/test/mockcore/mockcore.gen.go index ac48414851..8a6d2dd243 100644 --- a/pkg/common/providers/test/mockcore/mockcore.gen.go +++ b/pkg/common/providers/test/mockcore/mockcore.gen.go @@ -178,21 +178,16 @@ func (m *MockConfigBackend) EXPECT() *MockConfigBackendMockRecorder { } // Lookup mocks base method -func (m *MockConfigBackend) Lookup(arg0 string, arg1 ...core.LookupOption) (interface{}, bool) { - varargs := []interface{}{arg0} - for _, a := range arg1 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "Lookup", varargs...) +func (m *MockConfigBackend) Lookup(arg0 string) (interface{}, bool) { + ret := m.ctrl.Call(m, "Lookup", arg0) ret0, _ := ret[0].(interface{}) ret1, _ := ret[1].(bool) return ret0, ret1 } // Lookup indicates an expected call of Lookup -func (mr *MockConfigBackendMockRecorder) Lookup(arg0 interface{}, arg1 ...interface{}) *gomock.Call { - varargs := append([]interface{}{arg0}, arg1...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lookup", reflect.TypeOf((*MockConfigBackend)(nil).Lookup), varargs...) +func (mr *MockConfigBackendMockRecorder) Lookup(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lookup", reflect.TypeOf((*MockConfigBackend)(nil).Lookup), arg0) } // MockProviders is a mock of Providers interface diff --git a/pkg/core/config/config.go b/pkg/core/config/config.go index efd3b16d73..39c425ee01 100644 --- a/pkg/core/config/config.go +++ b/pkg/core/config/config.go @@ -19,8 +19,6 @@ import ( "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/core" ) -var logger = logging.NewLogger("fabsdk/core") - var logModules = [...]string{"fabsdk", "fabsdk/client", "fabsdk/core", "fabsdk/fab", "fabsdk/common", "fabsdk/msp", "fabsdk/util", "fabsdk/context"} @@ -61,9 +59,7 @@ func FromFile(name string, opts ...Option) core.ConfigProvider { // If a config file is found, read it in. err = backend.configViper.MergeInConfig() - if err == nil { - logger.Debugf("Using config file: %s", backend.configViper.ConfigFileUsed()) - } else { + if err != nil { return nil, errors.Wrap(err, "loading config file failed") } @@ -77,7 +73,6 @@ func FromFile(name string, opts ...Option) core.ConfigProvider { func FromRaw(configBytes []byte, configType string, opts ...Option) core.ConfigProvider { return func() (core.ConfigBackend, error) { buf := bytes.NewBuffer(configBytes) - logger.Debugf("config.FromRaw buf Len is %d, Cap is %d: %s", buf.Len(), buf.Cap(), buf) return initFromReader(buf, configType, opts...) } } @@ -154,7 +149,6 @@ func setLogLevel(backend core.ConfigBackend) { logLevel := logging.INFO if loggingLevelString != nil { const logModule = "fabsdk" // TODO: allow more flexability in setting levels for different modules - logger.Debugf("%s logging level from the config: %v", logModule, loggingLevelString) var err error logLevel, err = logging.LogLevel(loggingLevelString.(string)) if err != nil { diff --git a/pkg/core/config/defbackend.go b/pkg/core/config/defbackend.go index 9a678ea2f0..8dbeff8813 100644 --- a/pkg/core/config/defbackend.go +++ b/pkg/core/config/defbackend.go @@ -7,7 +7,6 @@ SPDX-License-Identifier: Apache-2.0 package config import ( - "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/core" "github.com/hyperledger/fabric-sdk-go/pkg/util/pathvar" "github.com/pkg/errors" "github.com/spf13/viper" @@ -20,22 +19,7 @@ type defConfigBackend struct { } // Lookup gets the config item value by Key -func (c *defConfigBackend) Lookup(key string, opts ...core.LookupOption) (interface{}, bool) { - if len(opts) > 0 { - lookupOpts := &core.LookupOpts{} - for _, option := range opts { - option(lookupOpts) - } - - if lookupOpts.UnmarshalType != nil { - err := c.configViper.UnmarshalKey(key, lookupOpts.UnmarshalType) - if err != nil { - //TODO may need debug logger here - return nil, false - } - return lookupOpts.UnmarshalType, true - } - } +func (c *defConfigBackend) Lookup(key string) (interface{}, bool) { value := c.configViper.Get(key) if value == nil { return nil, false diff --git a/pkg/core/config/lookup/lookup.go b/pkg/core/config/lookup/lookup.go index fb02ed9f50..e07151f8e0 100644 --- a/pkg/core/config/lookup/lookup.go +++ b/pkg/core/config/lookup/lookup.go @@ -10,6 +10,7 @@ import ( "time" "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/core" + "github.com/mitchellh/mapstructure" "github.com/spf13/cast" ) @@ -60,7 +61,19 @@ func (c *ConfigLookup) GetDuration(key string) time.Duration { } //UnmarshalKey unmarshals value for given key to rawval type -func (c *ConfigLookup) UnmarshalKey(key string, rawVal interface{}) bool { - _, ok := c.backend.Lookup(key, core.WithUnmarshalType(rawVal)) - return ok +func (c *ConfigLookup) UnmarshalKey(key string, rawVal interface{}) error { + value, ok := c.backend.Lookup(key) + if !ok { + return nil + } + + decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{ + DecodeHook: mapstructure.StringToTimeDurationHookFunc(), + Result: rawVal, + }) + if err != nil { + return err + } + + return decoder.Decode(value) } diff --git a/pkg/core/config/lookup/lookup_test.go b/pkg/core/config/lookup/lookup_test.go new file mode 100644 index 0000000000..4a1787aba0 --- /dev/null +++ b/pkg/core/config/lookup/lookup_test.go @@ -0,0 +1,257 @@ +/* +Copyright SecureKey Technologies Inc. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package lookup + +import ( + "testing" + + "os" + + "time" + + "strings" + + "reflect" + + "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/fab" + "github.com/hyperledger/fabric-sdk-go/pkg/core/mocks" + "github.com/spf13/viper" + "github.com/stretchr/testify/assert" +) + +var sampleConfigFile = "../testdata/config_test.yaml" + +var backend *mocks.MockConfigBackend + +func TestMain(m *testing.M) { + setupCustomBackend() + r := m.Run() + os.Exit(r) +} + +func TestGetBool(t *testing.T) { + testLookup := New(backend) + assert.True(t, testLookup.GetBool("key.bool.true"), "expected lookup to return true") + assert.False(t, testLookup.GetBool("key.bool.false"), "expected lookup to return false") + assert.False(t, testLookup.GetBool("key.bool.invalid"), "expected lookup to return false for invalid value") + assert.False(t, testLookup.GetBool("key.bool.notexisting"), "expected lookup to return false for not existing value") +} + +func TestGetInt(t *testing.T) { + testLookup := New(backend) + assert.True(t, testLookup.GetInt("key.int.positive") == 5, "expected lookup to return valid positive value") + assert.True(t, testLookup.GetInt("key.int.negative") == -5, "expected lookup to return valid negative value") + assert.True(t, testLookup.GetInt("key.int.invalid") == 0, "expected lookup to return 0") + assert.True(t, testLookup.GetInt("key.int.not.existing") == 0, "expected lookup to return 0") +} + +func TestGetString(t *testing.T) { + testLookup := New(backend) + assert.True(t, testLookup.GetString("key.string.valid") == "valid-string", "expected lookup to return valid string value") + assert.True(t, testLookup.GetString("key.string.empty") == "", "expected lookup to return empty string value") + assert.True(t, testLookup.GetString("key.string.nil") == "", "expected lookup to return empty string value") + assert.True(t, testLookup.GetString("key.string.number") == "1234", "expected lookup to return valid string value") + assert.True(t, testLookup.GetString("key.string.not existing") == "", "expected lookup to return empty string value") +} + +func TestGetDuration(t *testing.T) { + testLookup := New(backend) + assert.True(t, testLookup.GetDuration("key.duration.valid.hour").String() == (24*time.Hour).String(), "expected valid time value") + assert.True(t, testLookup.GetDuration("key.duration.valid.minute").String() == (24*time.Minute).String(), "expected valid time value") + assert.True(t, testLookup.GetDuration("key.duration.valid.second").String() == (24*time.Second).String(), "expected valid time value") + assert.True(t, testLookup.GetDuration("key.duration.valid.millisecond").String() == (24*time.Millisecond).String(), "expected valid time value") + assert.True(t, testLookup.GetDuration("key.duration.valid.microsecond").String() == (24*time.Microsecond).String(), "expected valid time value") + assert.True(t, testLookup.GetDuration("key.duration.valid.nanosecond").String() == (24*time.Nanosecond).String(), "expected valid time value") + //default value tests + assert.True(t, testLookup.GetDuration("key.duration.valid.not.existing").String() == (0*time.Second).String(), "expected valid default time value") + assert.True(t, testLookup.GetDuration("key.duration.valid.invalid").String() == (0*time.Second).String(), "expected valid default time value") + assert.True(t, testLookup.GetDuration("key.duration.valid.nil").String() == (0*time.Second).String(), "expected valid default time value") + assert.True(t, testLookup.GetDuration("key.duration.valid.empty").String() == (0*time.Second).String(), "expected valid default time value") + //default when no time unit provided + assert.True(t, testLookup.GetDuration("key.duration.valid.no.unit").String() == (12*time.Nanosecond).String(), "expected valid default time value with default unit") +} + +func TestUnmarshal(t *testing.T) { + testLookup := New(backend) + + //output struct + networkConfig := fab.NetworkConfig{} + testLookup.UnmarshalKey("channels", &networkConfig.Channels) + + assert.True(t, len(networkConfig.Channels) == 2) + assert.True(t, len(networkConfig.Channels["mychannel"].Peers) == 1) + assert.True(t, networkConfig.Channels["mychannel"].Policies.QueryChannelConfig.MinResponses == 1) + assert.True(t, networkConfig.Channels["mychannel"].Policies.QueryChannelConfig.MaxTargets == 1) + assert.True(t, networkConfig.Channels["mychannel"].Policies.QueryChannelConfig.RetryOpts.MaxBackoff.String() == (5*time.Second).String()) + assert.True(t, networkConfig.Channels["mychannel"].Policies.QueryChannelConfig.RetryOpts.InitialBackoff.String() == (500*time.Millisecond).String()) + assert.True(t, networkConfig.Channels["mychannel"].Policies.QueryChannelConfig.RetryOpts.BackoffFactor == 2.0) + +} + +func TestLookupUnmarshalAgainstViperUnmarshal(t *testing.T) { + + //new lookup + testLookup := New(backend) + //setup viper + sampleViper := newViper() + //viper network config + networkConfigViper := fab.NetworkConfig{} + //lookup network config + networkConfig := fab.NetworkConfig{} + + /* + TEST NETWORK CONFIG CLIENT + */ + //get client through backend lookup + err := testLookup.UnmarshalKey("client", &networkConfig.Client) + if err != nil { + t.Fatal(err) + } + //get client from viper + sampleViper.UnmarshalKey("client", &networkConfigViper.Client) + //now compare + assert.True(t, reflect.DeepEqual(&networkConfig.Client, &networkConfigViper.Client), "unmarshalled value from config lookup supposed to match unmarshalled value from viper") + + /* + TEST NETWORK CONFIG ORDERERS + */ + //get orderers through backend lookup + err = testLookup.UnmarshalKey("orderers", &networkConfig.Orderers) + if err != nil { + t.Fatal(err) + } + //get orderers from viper + sampleViper.UnmarshalKey("orderers", &networkConfigViper.Orderers) + //now compare + assert.True(t, reflect.DeepEqual(&networkConfig.Orderers, &networkConfigViper.Orderers), "unmarshalled value from config lookup supposed to match unmarshalled value from viper") + + /* + TEST NETWORK CONFIG CERTIFICATE AUTHORITIES + */ + //get orderers through backend lookup + err = testLookup.UnmarshalKey("certificateAuthorities", &networkConfig.CertificateAuthorities) + if err != nil { + t.Fatal(err) + } + //get orderers from viper + sampleViper.UnmarshalKey("certificateAuthorities", &networkConfigViper.CertificateAuthorities) + //now compare + assert.True(t, reflect.DeepEqual(&networkConfig.CertificateAuthorities, &networkConfigViper.CertificateAuthorities), "unmarshalled value from config lookup supposed to match unmarshalled value from viper") + + /* + TEST NETWORK CONFIG ENTITY MATCHERS + */ + //get orderers through backend lookup + err = testLookup.UnmarshalKey("entityMatchers", &networkConfig.EntityMatchers) + if err != nil { + t.Fatal(err) + } + //get orderers from viper + sampleViper.UnmarshalKey("entityMatchers", &networkConfigViper.EntityMatchers) + //now compare + assert.True(t, reflect.DeepEqual(&networkConfig.EntityMatchers, &networkConfigViper.EntityMatchers), "unmarshalled value from config lookup supposed to match unmarshalled value from viper") + + /* + TEST NETWORK CONFIG ORGANIZATIONS + */ + //get orderers through backend lookup + err = testLookup.UnmarshalKey("organizations", &networkConfig.Organizations) + if err != nil { + t.Fatal(err) + } + //get orderers from viper + sampleViper.UnmarshalKey("organizations", &networkConfigViper.Organizations) + //now compare + assert.True(t, reflect.DeepEqual(&networkConfig.Organizations, &networkConfigViper.Organizations), "unmarshalled value from config lookup supposed to match unmarshalled value from viper") + + /* + TEST NETWORK CONFIG CHANNELS + */ + //get orderers through backend lookup + err = testLookup.UnmarshalKey("channels", &networkConfig.Channels) + if err != nil { + t.Fatal(err) + } + //get orderers from viper + sampleViper.UnmarshalKey("channels", &networkConfigViper.Channels) + //now compare + assert.True(t, reflect.DeepEqual(&networkConfig.Channels, &networkConfigViper.Channels), "unmarshalled value from config lookup supposed to match unmarshalled value from viper") + + /* + TEST NETWORK CONFIG PEERS + */ + //get orderers through backend lookup + err = testLookup.UnmarshalKey("peers", &networkConfig.Peers) + if err != nil { + t.Fatal(err) + } + //get orderers from viper + sampleViper.UnmarshalKey("peers", &networkConfigViper.Peers) + //now compare + assert.True(t, reflect.DeepEqual(&networkConfig.Peers, &networkConfigViper.Peers), "unmarshalled value from config lookup supposed to match unmarshalled value from viper") + + //Just to make sure that empty values are not being compared + assert.True(t, len(networkConfigViper.Channels) > 0, "expected to get valid unmarshalled value") + assert.True(t, len(networkConfigViper.Organizations) > 0, "expected to get valid unmarshalled value") + assert.True(t, len(networkConfigViper.Orderers) > 0, "expected to get valid unmarshalled value") + assert.True(t, len(networkConfigViper.Peers) > 0, "expected to get valid unmarshalled value") + assert.True(t, len(networkConfigViper.EntityMatchers) > 0, "expected to get valid unmarshalled value") + assert.True(t, networkConfigViper.Client.Organization != "", "expected to get valid unmarshalled value") + +} + +func setupCustomBackend() { + backendMap := make(map[string]interface{}) + + backendMap["key.bool.true"] = true + backendMap["key.bool.false"] = false + backendMap["key.bool.invalid"] = "INVALID" + + backendMap["key.int.positive"] = 5 + backendMap["key.int.negative"] = -5 + backendMap["key.int.invalid"] = "INVALID" + + backendMap["key.string.valid"] = "valid-string" + backendMap["key.string.empty"] = "" + backendMap["key.string.nil"] = nil + backendMap["key.string.number"] = 1234 + + backendMap["key.duration.valid.hour"] = "24h" + backendMap["key.duration.valid.minute"] = "24m" + backendMap["key.duration.valid.second"] = "24s" + backendMap["key.duration.valid.millisecond"] = "24ms" + backendMap["key.duration.valid.microsecond"] = "24µs" + backendMap["key.duration.valid.nanosecond"] = "24ns" + backendMap["key.duration.valid.no.unit"] = "12" + backendMap["key.duration.invalid"] = "24XYZ" + backendMap["key.duration.nil"] = nil + backendMap["key.duration.empty"] = "" + + //test fab network config + sampleViper := newViper() + backendMap["client"] = sampleViper.Get("client") + backendMap["channels"] = sampleViper.Get("channels") + backendMap["certificateAuthorities"] = sampleViper.Get("certificateAuthorities") + backendMap["entityMatchers"] = sampleViper.Get("entityMatchers") + backendMap["organizations"] = sampleViper.Get("organizations") + backendMap["orderers"] = sampleViper.Get("orderers") + backendMap["peers"] = sampleViper.Get("peers") + + backend = &mocks.MockConfigBackend{KeyValueMap: backendMap} +} + +func newViper() *viper.Viper { + myViper := viper.New() + replacer := strings.NewReplacer(".", "_") + myViper.SetEnvKeyReplacer(replacer) + myViper.SetConfigFile(sampleConfigFile) + err := myViper.MergeInConfig() + if err != nil { + panic(err) + } + return myViper +} diff --git a/pkg/core/mocks/mockconfigbackend.go b/pkg/core/mocks/mockconfigbackend.go index e9c240b6a6..3d636e58a5 100644 --- a/pkg/core/mocks/mockconfigbackend.go +++ b/pkg/core/mocks/mockconfigbackend.go @@ -6,44 +6,13 @@ SPDX-License-Identifier: Apache-2.0 package mocks -import ( - "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/core" - "github.com/mitchellh/mapstructure" -) - //MockConfigBackend mocks config backend for unit tests type MockConfigBackend struct { KeyValueMap map[string]interface{} } //Lookup returns or unmarshals value for given key -func (b *MockConfigBackend) Lookup(key string, opts ...core.LookupOption) (interface{}, bool) { - if len(opts) > 0 { - lookupOpts := &core.LookupOpts{} - for _, option := range opts { - option(lookupOpts) - } - - if lookupOpts.UnmarshalType != nil { - v, ok := b.KeyValueMap[key] - if !ok { - return nil, false - } - - decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{ - DecodeHook: mapstructure.StringToTimeDurationHookFunc(), - Result: lookupOpts.UnmarshalType, - }) - if err != nil { - return nil, false - } - err = decoder.Decode(v) - if err != nil { - return nil, false - } - return lookupOpts.UnmarshalType, true - } - } +func (b *MockConfigBackend) Lookup(key string) (interface{}, bool) { v, ok := b.KeyValueMap[key] return v, ok } diff --git a/pkg/fab/endpointconfig.go b/pkg/fab/endpointconfig.go index fc77bf7b9f..50b0ac4d3e 100644 --- a/pkg/fab/endpointconfig.go +++ b/pkg/fab/endpointconfig.go @@ -575,46 +575,46 @@ func (c *EndpointConfig) cacheNetworkConfiguration() error { networkConfig.Description = c.backend.GetString("description") networkConfig.Version = c.backend.GetString("version") - ok := c.backend.UnmarshalKey("client", &networkConfig.Client) + err := c.backend.UnmarshalKey("client", &networkConfig.Client) logger.Debugf("Client is: %+v", networkConfig.Client) - if !ok { - return errors.New("failed to parse 'client' config item to networkConfig.Client type") + if err != nil { + return errors.WithMessage(err, "failed to parse 'client' config item to networkConfig.Client type") } - ok = c.backend.UnmarshalKey("channels", &networkConfig.Channels) + err = c.backend.UnmarshalKey("channels", &networkConfig.Channels) logger.Debugf("channels are: %+v", networkConfig.Channels) - if !ok { - return errors.New("failed to parse 'channels' config item to networkConfig.Channels type") + if err != nil { + return errors.WithMessage(err, "failed to parse 'channels' config item to networkConfig.Channels type") } - ok = c.backend.UnmarshalKey("organizations", &networkConfig.Organizations) + err = c.backend.UnmarshalKey("organizations", &networkConfig.Organizations) logger.Debugf("organizations are: %+v", networkConfig.Organizations) - if !ok { - return errors.New("failed to parse 'organizations' config item to networkConfig.Organizations type") + if err != nil { + return errors.WithMessage(err, "failed to parse 'organizations' config item to networkConfig.Organizations type") } - ok = c.backend.UnmarshalKey("orderers", &networkConfig.Orderers) + err = c.backend.UnmarshalKey("orderers", &networkConfig.Orderers) logger.Debugf("orderers are: %+v", networkConfig.Orderers) - if !ok { - return errors.New("failed to parse 'orderers' config item to networkConfig.Orderers type") + if err != nil { + return errors.WithMessage(err, "failed to parse 'orderers' config item to networkConfig.Orderers type") } - ok = c.backend.UnmarshalKey("peers", &networkConfig.Peers) + err = c.backend.UnmarshalKey("peers", &networkConfig.Peers) logger.Debugf("peers are: %+v", networkConfig.Peers) - if !ok { - return errors.New("failed to parse 'peers' config item to networkConfig.Peers type") + if err != nil { + return errors.WithMessage(err, "failed to parse 'peers' config item to networkConfig.Peers type") } - ok = c.backend.UnmarshalKey("certificateAuthorities", &networkConfig.CertificateAuthorities) + err = c.backend.UnmarshalKey("certificateAuthorities", &networkConfig.CertificateAuthorities) logger.Debugf("certificateAuthorities are: %+v", networkConfig.CertificateAuthorities) - if !ok { - return errors.New("failed to parse 'certificateAuthorities' config item to networkConfig.CertificateAuthorities type") + if err != nil { + return errors.WithMessage(err, "failed to parse 'certificateAuthorities' config item to networkConfig.CertificateAuthorities type") } - ok = c.backend.UnmarshalKey("entityMatchers", &networkConfig.EntityMatchers) + err = c.backend.UnmarshalKey("entityMatchers", &networkConfig.EntityMatchers) logger.Debugf("Matchers are: %+v", networkConfig.EntityMatchers) - if !ok { - return errors.New("failed to parse 'entityMatchers' config item to networkConfig.EntityMatchers type") + if err != nil { + return errors.WithMessage(err, "failed to parse 'entityMatchers' config item to networkConfig.EntityMatchers type") } c.networkConfig = &networkConfig diff --git a/pkg/fab/endpointconfig_test.go b/pkg/fab/endpointconfig_test.go index f34d6c115f..851a9d589d 100644 --- a/pkg/fab/endpointconfig_test.go +++ b/pkg/fab/endpointconfig_test.go @@ -132,16 +132,6 @@ func TestCAConfigFailsByNetworkConfig(t *testing.T) { if coConfigs != nil || err == nil { t.Fatal("Testing ChannelOrderers supposed to fail") } - - // test empty network objects - - customBackend.KeyValueMap["channels"], _ = configBackend.Lookup("channels") - delete(customBackend.KeyValueMap, "organizations") - sampleEndpointConfig.networkConfigCached = false - _, err = sampleEndpointConfig.NetworkConfig() - if err == nil { - t.Fatalf("Organizations were empty, it should return an error") - } } func TestTLSCAConfig(t *testing.T) { diff --git a/pkg/fab/mocks/mockconfig.go b/pkg/fab/mocks/mockconfig.go index 02667424a5..0ee2a74759 100644 --- a/pkg/fab/mocks/mockconfig.go +++ b/pkg/fab/mocks/mockconfig.go @@ -337,7 +337,7 @@ func (c *MockConfig) EventServiceType() fab.EventServiceType { } // Lookup gets the Value from config file by Key -func (c *MockConfig) Lookup(key string, opts ...core.LookupOption) (interface{}, bool) { +func (c *MockConfig) Lookup(key string) (interface{}, bool) { if key == "invalid" { return nil, false }