github.com/dnephin/dobi@v0.15.0/config/image_test.go (about)

     1  package config
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  	"time"
     7  
     8  	pth "github.com/dnephin/configtf/path"
     9  	"gotest.tools/v3/assert"
    10  	is "gotest.tools/v3/assert/cmp"
    11  )
    12  
    13  func sampleImageConfig() *ImageConfig {
    14  	return &ImageConfig{
    15  		Dockerfile: "Dockerfile",
    16  		Context:    ".",
    17  		Image:      "example",
    18  	}
    19  }
    20  
    21  func TestImageConfigString(t *testing.T) {
    22  	image := sampleImageConfig()
    23  	image.Context = "./files"
    24  	assert.Equal(t, "Build image 'example' from 'files/Dockerfile'", image.String())
    25  }
    26  
    27  func TestImageConfigValidateMissingDependencies(t *testing.T) {
    28  	image := sampleImageConfig()
    29  	image.Depends = []string{"one", "two"}
    30  	conf := NewConfig()
    31  	err := validateResourcesExist(pth.NewPath(""), conf, image.Dependencies())
    32  	assert.Assert(t, is.ErrorContains(err, "missing dependencies: one, two"))
    33  }
    34  
    35  func TestImageConfigValidateTagsWithValidFirstTag(t *testing.T) {
    36  	image := sampleImageConfig()
    37  	image.Tags = []string{"good"}
    38  	err := image.ValidateTags()
    39  	assert.NilError(t, err)
    40  }
    41  
    42  func TestImageConfigValidateTagsWithBadFirstTag(t *testing.T) {
    43  	image := sampleImageConfig()
    44  	image.Tags = []string{"bad:tag"}
    45  	err := image.ValidateTags()
    46  	expected := "the first tag \"tag\" may not include an image name"
    47  	assert.Assert(t, is.ErrorContains(err, expected))
    48  }
    49  
    50  func TestImageConfigValidate(t *testing.T) {
    51  	var testcases = []struct {
    52  		doc                string
    53  		image              *ImageConfig
    54  		expectedErr        string
    55  		expectedDockerfile string
    56  	}{
    57  		{
    58  			doc: "dockerfile and steps both set",
    59  			image: &ImageConfig{
    60  				Steps:      "FROM alpine:3.6",
    61  				Dockerfile: "Dockerfile",
    62  				Context:    ".",
    63  			},
    64  			expectedErr: "dockerfile can not be used with steps",
    65  		},
    66  		{
    67  			doc:         "missing required field",
    68  			image:       &ImageConfig{Steps: "FROM alpine:3.6"},
    69  			expectedErr: "one of context, or pull is required",
    70  		},
    71  		{
    72  			doc:                "just context",
    73  			image:              &ImageConfig{Context: "."},
    74  			expectedDockerfile: "Dockerfile",
    75  		},
    76  		{
    77  			doc:   "just pull",
    78  			image: &ImageConfig{Pull: pull{action: pullAlways}},
    79  		},
    80  		{
    81  			doc:                "just dockerfile",
    82  			image:              &ImageConfig{Dockerfile: "Dockerfile"},
    83  			expectedDockerfile: "Dockerfile",
    84  		},
    85  	}
    86  
    87  	for _, testcase := range testcases {
    88  		t.Run(testcase.doc, func(t *testing.T) {
    89  			err := testcase.image.Validate(pth.NewPath("."), NewConfig())
    90  			if testcase.expectedErr != "" {
    91  				assert.Assert(t, is.ErrorContains(err, testcase.expectedErr))
    92  				return
    93  			}
    94  
    95  			assert.Assert(t, err == nil)
    96  			assert.Assert(t, is.Equal(testcase.expectedDockerfile, testcase.image.Dockerfile))
    97  		})
    98  	}
    99  }
   100  
   101  func TestImageConfigResolve(t *testing.T) {
   102  	resolver := newFakeResolver(map[string]string{
   103  		"{one}":   "thetag",
   104  		"{two}":   "theother",
   105  		"{three}": "last",
   106  	})
   107  
   108  	image := &ImageConfig{
   109  		Tags:  []string{"foo", "{one}"},
   110  		Image: "{three}",
   111  		Steps: "{two}",
   112  		Args: map[string]string{
   113  			"key1": "{one}",
   114  			"key2": "ok",
   115  		},
   116  		CacheFrom: []string{"{one}", "two"},
   117  	}
   118  	resolved, err := image.Resolve(resolver)
   119  	assert.NilError(t, err)
   120  	expected := &ImageConfig{
   121  		Tags:  []string{"foo", "thetag"},
   122  		Image: "last",
   123  		Steps: "theother",
   124  		Args: map[string]string{
   125  			"key1": "thetag",
   126  			"key2": "ok",
   127  		},
   128  		CacheFrom: []string{"thetag", "two"},
   129  	}
   130  	assert.Check(t, is.DeepEqual(expected, resolved, cmpConfigOpt))
   131  }
   132  
   133  func TestPullWithDuration(t *testing.T) {
   134  	p := pull{}
   135  	now := time.Now()
   136  	old := now.Add(-time.Duration(32 * 60 * 10e9))
   137  	err := p.TransformConfig(reflect.ValueOf("30m"))
   138  	assert.NilError(t, err)
   139  
   140  	assert.Check(t, !p.Required(&now))
   141  	assert.Check(t, p.Required(&old))
   142  	assert.Check(t, p.Required(nil))
   143  }
   144  
   145  func TestPullTransformConfig(t *testing.T) {
   146  	p := pull{}
   147  	zero := reflect.Value{}
   148  	err := p.TransformConfig(zero)
   149  
   150  	assert.Check(t, is.ErrorContains(err, "must be a string"))
   151  }