github.com/docker/engine@v22.0.0-20211208180946-d456264580cf+incompatible/image/image_test.go (about)

     1  package image // import "github.com/docker/docker/image"
     2  
     3  import (
     4  	"encoding/json"
     5  	"runtime"
     6  	"sort"
     7  	"strings"
     8  	"testing"
     9  
    10  	"github.com/docker/docker/api/types/container"
    11  	"github.com/docker/docker/layer"
    12  	"github.com/google/go-cmp/cmp"
    13  	"gotest.tools/v3/assert"
    14  	is "gotest.tools/v3/assert/cmp"
    15  )
    16  
    17  const sampleImageJSON = `{
    18  	"architecture": "amd64",
    19  	"os": "linux",
    20  	"config": {},
    21  	"rootfs": {
    22  		"type": "layers",
    23  		"diff_ids": []
    24  	}
    25  }`
    26  
    27  func TestNewFromJSON(t *testing.T) {
    28  	img, err := NewFromJSON([]byte(sampleImageJSON))
    29  	assert.NilError(t, err)
    30  	assert.Check(t, is.Equal(sampleImageJSON, string(img.RawJSON())))
    31  }
    32  
    33  func TestNewFromJSONWithInvalidJSON(t *testing.T) {
    34  	_, err := NewFromJSON([]byte("{}"))
    35  	assert.Check(t, is.Error(err, "invalid image JSON, no RootFS key"))
    36  }
    37  
    38  func TestMarshalKeyOrder(t *testing.T) {
    39  	b, err := json.Marshal(&Image{
    40  		V1Image: V1Image{
    41  			Comment:      "a",
    42  			Author:       "b",
    43  			Architecture: "c",
    44  		},
    45  	})
    46  	assert.Check(t, err)
    47  
    48  	expectedOrder := []string{"architecture", "author", "comment"}
    49  	var indexes []int
    50  	for _, k := range expectedOrder {
    51  		indexes = append(indexes, strings.Index(string(b), k))
    52  	}
    53  
    54  	if !sort.IntsAreSorted(indexes) {
    55  		t.Fatal("invalid key order in JSON: ", string(b))
    56  	}
    57  }
    58  
    59  const sampleHistoryJSON = `{
    60  	"created": "2021-01-13T09:35:56Z",
    61  	"created_by": "image_test.go"
    62  }`
    63  
    64  func TestHistoryEqual(t *testing.T) {
    65  	h := historyFromJSON(t, sampleHistoryJSON)
    66  	hCopy := h
    67  	assert.Check(t, h.Equal(hCopy))
    68  
    69  	hUTC := historyFromJSON(t, `{"created": "2021-01-13T14:00:00Z"}`)
    70  	hOffset0 := historyFromJSON(t, `{"created": "2021-01-13T14:00:00+00:00"}`)
    71  	assert.Check(t, hUTC.Created != hOffset0.Created)
    72  	assert.Check(t, hUTC.Equal(hOffset0))
    73  }
    74  
    75  func historyFromJSON(t *testing.T, historyJSON string) History {
    76  	var h History
    77  	err := json.Unmarshal([]byte(historyJSON), &h)
    78  	assert.Check(t, err)
    79  	return h
    80  }
    81  
    82  func TestImage(t *testing.T) {
    83  	cid := "50a16564e727"
    84  	config := &container.Config{
    85  		Hostname:   "hostname",
    86  		Domainname: "domain",
    87  		User:       "root",
    88  	}
    89  	os := runtime.GOOS
    90  
    91  	img := &Image{
    92  		V1Image: V1Image{
    93  			Config: config,
    94  		},
    95  		computedID: ID(cid),
    96  	}
    97  
    98  	assert.Check(t, is.Equal(cid, img.ImageID()))
    99  	assert.Check(t, is.Equal(cid, img.ID().String()))
   100  	assert.Check(t, is.Equal(os, img.OperatingSystem()))
   101  	assert.Check(t, is.DeepEqual(config, img.RunConfig()))
   102  }
   103  
   104  func TestImageOSNotEmpty(t *testing.T) {
   105  	os := "os"
   106  	img := &Image{
   107  		V1Image: V1Image{
   108  			OS: os,
   109  		},
   110  		OSVersion: "osversion",
   111  	}
   112  	assert.Check(t, is.Equal(os, img.OperatingSystem()))
   113  }
   114  
   115  func TestNewChildImageFromImageWithRootFS(t *testing.T) {
   116  	rootFS := NewRootFS()
   117  	rootFS.Append(layer.DiffID("ba5e"))
   118  	parent := &Image{
   119  		RootFS: rootFS,
   120  		History: []History{
   121  			NewHistory("a", "c", "r", false),
   122  		},
   123  	}
   124  	childConfig := ChildConfig{
   125  		DiffID:  layer.DiffID("abcdef"),
   126  		Author:  "author",
   127  		Comment: "comment",
   128  		ContainerConfig: &container.Config{
   129  			Cmd: []string{"echo", "foo"},
   130  		},
   131  		Config: &container.Config{},
   132  	}
   133  
   134  	newImage := NewChildImage(parent, childConfig, "platform")
   135  	expectedDiffIDs := []layer.DiffID{layer.DiffID("ba5e"), layer.DiffID("abcdef")}
   136  	assert.Check(t, is.DeepEqual(expectedDiffIDs, newImage.RootFS.DiffIDs))
   137  	assert.Check(t, is.Equal(childConfig.Author, newImage.Author))
   138  	assert.Check(t, is.DeepEqual(childConfig.Config, newImage.Config))
   139  	assert.Check(t, is.DeepEqual(*childConfig.ContainerConfig, newImage.ContainerConfig))
   140  	assert.Check(t, is.Equal("platform", newImage.OS))
   141  	assert.Check(t, is.DeepEqual(childConfig.Config, newImage.Config))
   142  
   143  	assert.Check(t, is.Len(newImage.History, 2))
   144  	assert.Check(t, is.Equal(childConfig.Comment, newImage.History[1].Comment))
   145  
   146  	assert.Check(t, !cmp.Equal(parent.RootFS.DiffIDs, newImage.RootFS.DiffIDs),
   147  		"RootFS should be copied not mutated")
   148  }