github.com/ConsenSys/Quorum@v20.10.0+incompatible/plugin/service_test.go (about)

     1  package plugin
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/hashicorp/go-plugin"
     7  	testifyassert "github.com/stretchr/testify/assert"
     8  )
     9  
    10  func typicalPluginManager(t *testing.T) *PluginManager {
    11  	testObject, err := NewPluginManager("arbitraryName", &Settings{
    12  		Providers: map[PluginInterfaceName]PluginDefinition{
    13  			HelloWorldPluginInterfaceName: {
    14  				Name:    "arbitrary-helloWorld",
    15  				Version: "1.0.0",
    16  				Config:  "arbitrary config",
    17  			},
    18  		},
    19  	}, false, false, "")
    20  
    21  	testifyassert.NoError(t, err)
    22  	return testObject
    23  }
    24  
    25  func TestPluginManager_ProvidersPopulation(t *testing.T) {
    26  	arbitraryPluginInterfaceName := PluginInterfaceName("arbitrary")
    27  	defer func() {
    28  		delete(pluginProviders, arbitraryPluginInterfaceName)
    29  	}()
    30  	pluginProviders[arbitraryPluginInterfaceName] = pluginProvider{
    31  		pluginSet: plugin.PluginSet{},
    32  	}
    33  
    34  	testObject, err := NewPluginManager("arbitraryName", &Settings{
    35  		Providers: map[PluginInterfaceName]PluginDefinition{
    36  			HelloWorldPluginInterfaceName: {
    37  				Name:    "arbitrary-helloWorld",
    38  				Version: "1.0.0",
    39  				Config:  "arbitrary config",
    40  			},
    41  			arbitraryPluginInterfaceName: {
    42  				Name:    "foo-bar",
    43  				Version: "2.0.0",
    44  				Config:  "arbitrary config",
    45  			},
    46  		},
    47  	}, false, false, "")
    48  
    49  	testifyassert.NoError(t, err)
    50  	testifyassert.Equal(t, "arbitrary-helloWorld-1.0.0", testObject.initializedPlugins[HelloWorldPluginInterfaceName].(*basePlugin).pluginDefinition.FullName())
    51  	testifyassert.Equal(t, "foo-bar-2.0.0", testObject.initializedPlugins[arbitraryPluginInterfaceName].(*basePlugin).pluginDefinition.FullName())
    52  }
    53  
    54  func TestPluginManager_GetPluginTemplate_whenTypical(t *testing.T) {
    55  	assert := testifyassert.New(t)
    56  	testObject := typicalPluginManager(t)
    57  
    58  	p := new(HelloWorldPluginTemplate)
    59  	err := testObject.GetPluginTemplate(HelloWorldPluginInterfaceName, p)
    60  
    61  	assert.NoError(err)
    62  	assert.NotNil(p)
    63  }
    64  
    65  func TestPluginManager_GetPlugin_whenReadFromCache(t *testing.T) {
    66  	assert := testifyassert.New(t)
    67  	testObject := typicalPluginManager(t)
    68  	p := new(HelloWorldPluginTemplate)
    69  	err := testObject.GetPluginTemplate(HelloWorldPluginInterfaceName, p)
    70  	assert.NoError(err)
    71  	assert.NotNil(p)
    72  
    73  	actual, ok := testObject.getPlugin(HelloWorldPluginInterfaceName)
    74  
    75  	assert.True(ok)
    76  	assert.Equal(p, actual)
    77  }
    78  
    79  func TestPluginManager_GetPlugin_whenReadFromInitializedPluginsCache(t *testing.T) {
    80  	assert := testifyassert.New(t)
    81  	testObject := typicalPluginManager(t)
    82  
    83  	actual, ok := testObject.getPlugin(HelloWorldPluginInterfaceName)
    84  
    85  	assert.True(ok)
    86  	assert.IsType(new(basePlugin), actual)
    87  }
    88  
    89  func TestPluginManager_GetPluginTemplate_whenReadFromCache(t *testing.T) {
    90  	assert := testifyassert.New(t)
    91  	testObject := typicalPluginManager(t)
    92  	p := new(HelloWorldPluginTemplate)
    93  	err := testObject.GetPluginTemplate(HelloWorldPluginInterfaceName, p)
    94  	assert.NoError(err)
    95  	assert.NotNil(p)
    96  
    97  	actual := new(HelloWorldPluginTemplate)
    98  	err = testObject.GetPluginTemplate(HelloWorldPluginInterfaceName, actual)
    99  
   100  	assert.NoError(err)
   101  	assert.Equal(p, actual)
   102  }
   103  
   104  func TestPluginManager_GetPluginTemplate_whenPluginTemplateNotExtendBasePlugin(t *testing.T) {
   105  	assert := testifyassert.New(t)
   106  	testObject := typicalPluginManager(t)
   107  
   108  	invalid := new(invalidPluginTemplate)
   109  	err := testObject.GetPluginTemplate(HelloWorldPluginInterfaceName, invalid)
   110  
   111  	t.Log(err)
   112  	assert.Error(err)
   113  }
   114  
   115  func TestPluginManager_GetPluginTemplate_whenPluginTemplateNotExtendPointerBasePlugin(t *testing.T) {
   116  	assert := testifyassert.New(t)
   117  	testObject := typicalPluginManager(t)
   118  
   119  	invalid := new(invalidPluginTemplateNoPointer)
   120  	err := testObject.GetPluginTemplate(HelloWorldPluginInterfaceName, invalid)
   121  
   122  	t.Log(err)
   123  	assert.Error(err)
   124  }
   125  
   126  type invalidPluginTemplateNoPointer struct {
   127  	basePlugin
   128  }
   129  
   130  type invalidPluginTemplate struct {
   131  	someField int
   132  }
   133  
   134  func (i invalidPluginTemplate) Start() error {
   135  	panic("implement me")
   136  }
   137  
   138  func (i invalidPluginTemplate) Stop() error {
   139  	panic("implement me")
   140  }
   141  
   142  func (i invalidPluginTemplate) Info() (PluginInterfaceName, interface{}) {
   143  	panic("implement me")
   144  }