github.com/docker/app@v0.9.1-beta3.0.20210611140623-a48f773ab002/internal/formatter/formatter_test.go (about)

     1  package formatter
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/docker/app/internal/formatter/driver"
     7  	composetypes "github.com/docker/cli/cli/compose/types"
     8  	"github.com/pkg/errors"
     9  	"gotest.tools/assert"
    10  	is "gotest.tools/assert/cmp"
    11  )
    12  
    13  type fakeDriver struct{}
    14  
    15  func (d *fakeDriver) Format(config *composetypes.Config) (string, error) {
    16  	return "fake", nil
    17  }
    18  
    19  type fakeErrorDriver struct{}
    20  
    21  func (d *fakeErrorDriver) Format(config *composetypes.Config) (string, error) {
    22  	return "", errors.New("error in driver")
    23  }
    24  
    25  func TestRegisterNilPanics(t *testing.T) {
    26  	defer func() {
    27  		if recover() == nil {
    28  			t.Errorf("The code did not panic")
    29  		}
    30  		resetDrivers()
    31  	}()
    32  	Register("foo", nil)
    33  }
    34  
    35  func TestRegisterDuplicatePanics(t *testing.T) {
    36  	defer func() {
    37  		if recover() == nil {
    38  			t.Errorf("The code did not panic")
    39  		}
    40  		resetDrivers()
    41  	}()
    42  	Register("bar", &fakeDriver{})
    43  	Register("bar", &fakeDriver{})
    44  }
    45  
    46  func TestRegister(t *testing.T) {
    47  	d := &fakeDriver{}
    48  	Register("baz", d)
    49  	defer resetDrivers()
    50  	assert.Check(t, is.DeepEqual(drivers, map[string]driver.Driver{"baz": d}))
    51  }
    52  
    53  func TestNoDrivers(t *testing.T) {
    54  	assert.Check(t, is.DeepEqual(Drivers(), []string{}))
    55  }
    56  
    57  func TestRegisteredDrivers(t *testing.T) {
    58  	Register("foo", &fakeDriver{})
    59  	Register("bar", &fakeDriver{})
    60  	defer resetDrivers()
    61  	assert.Check(t, is.DeepEqual(Drivers(), []string{"bar", "foo"}))
    62  }
    63  
    64  func TestFormatNonExistentDriver(t *testing.T) {
    65  	_, err := Format(&composetypes.Config{}, "toto")
    66  	assert.Check(t, err != nil)
    67  	assert.Check(t, is.ErrorContains(err, `unknown formatter "toto"`))
    68  }
    69  
    70  func TestFormatErrorDriver(t *testing.T) {
    71  	Register("err", &fakeErrorDriver{})
    72  	defer resetDrivers()
    73  	_, err := Format(&composetypes.Config{}, "err")
    74  	assert.Check(t, err != nil)
    75  	assert.Check(t, is.ErrorContains(err, "error in driver"))
    76  }
    77  
    78  func TestFormatNone(t *testing.T) {
    79  	Register("fake", &fakeDriver{})
    80  	defer resetDrivers()
    81  	_, err := Format(&composetypes.Config{}, "none")
    82  	assert.Check(t, err != nil)
    83  	assert.Check(t, is.ErrorContains(err, `unknown formatter "none"`))
    84  }
    85  
    86  func TestFormat(t *testing.T) {
    87  	Register("fake", &fakeDriver{})
    88  	defer resetDrivers()
    89  	s, err := Format(&composetypes.Config{}, "fake")
    90  	assert.NilError(t, err)
    91  	assert.Check(t, is.Equal(s, "fake"))
    92  }
    93  
    94  func resetDrivers() {
    95  	drivers = map[string]driver.Driver{}
    96  }