Note: for the purposes of this discussion, archives will be treated as assets, as their differences are not particularly meaningful. Currently, the identity of an asset is derived from the hash and the location of its contents (i.e. two assets are equal iff their contents have the same hash and the same path/URI/inline value). This means that changing the source of an asset will cause the engine to detect a difference in the asset even if the source's contents are identical. At best, this leads to inefficiencies such as unnecessary updates. This commit changes asset identity so that it is derived solely from an asset's hash. The source of an asset's contents is no longer part of the asset's identity, and need only be provided if the contents themselves may need to be available (e.g. if a hash does not yet exist for the asset or if the asset's contents might be needed for an update). This commit also changes the way old assets are exposed to providers. Currently, an old asset is exposed as both its hash and its contents. This allows providers to take a dependency on the contents of an old asset being available, even though this is not an invariant of the system. These changes remove the contents of old assets from their serialized form when they are passed to providers, eliminating the ability of a provider to take such a dependency. In combination with the changes to asset identity, this allows a provider to detect changes to an asset simply by comparing its old and new hashes. This is half of the fix for [pulumi/pulumi-cloud#158]. The other half involves changes in [pulumi/pulumi-terraform].
328 lines
11 KiB
Go
328 lines
11 KiB
Go
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
|
|
|
|
package resource
|
|
|
|
import (
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/pulumi/pulumi/pkg/util/contract"
|
|
)
|
|
|
|
func TestNullPropertyValueDiffs(t *testing.T) {
|
|
t.Parallel()
|
|
d1 := NewNullProperty().Diff(NewNullProperty())
|
|
assert.Nil(t, d1)
|
|
d2 := NewNullProperty().Diff(NewBoolProperty(true))
|
|
assert.NotNil(t, d2)
|
|
assert.Nil(t, d2.Array)
|
|
assert.Nil(t, d2.Object)
|
|
assert.True(t, d2.Old.IsNull())
|
|
assert.True(t, d2.New.IsBool())
|
|
assert.Equal(t, true, d2.New.BoolValue())
|
|
}
|
|
|
|
func TestBoolPropertyValueDiffs(t *testing.T) {
|
|
t.Parallel()
|
|
d1 := NewBoolProperty(true).Diff(NewBoolProperty(true))
|
|
assert.Nil(t, d1)
|
|
d2 := NewBoolProperty(true).Diff(NewBoolProperty(false))
|
|
assert.NotNil(t, d2)
|
|
assert.Nil(t, d2.Array)
|
|
assert.Nil(t, d2.Object)
|
|
assert.True(t, d2.Old.IsBool())
|
|
assert.Equal(t, true, d2.Old.BoolValue())
|
|
assert.True(t, d2.New.IsBool())
|
|
assert.Equal(t, false, d2.New.BoolValue())
|
|
d3 := NewBoolProperty(true).Diff(NewNullProperty())
|
|
assert.NotNil(t, d3)
|
|
assert.Nil(t, d3.Array)
|
|
assert.Nil(t, d3.Object)
|
|
assert.True(t, d3.Old.IsBool())
|
|
assert.Equal(t, true, d3.Old.BoolValue())
|
|
assert.True(t, d3.New.IsNull())
|
|
}
|
|
|
|
func TestNumberPropertyValueDiffs(t *testing.T) {
|
|
t.Parallel()
|
|
d1 := NewNumberProperty(42).Diff(NewNumberProperty(42))
|
|
assert.Nil(t, d1)
|
|
d2 := NewNumberProperty(42).Diff(NewNumberProperty(66))
|
|
assert.NotNil(t, d2)
|
|
assert.Nil(t, d2.Array)
|
|
assert.Nil(t, d2.Object)
|
|
assert.True(t, d2.Old.IsNumber())
|
|
assert.Equal(t, float64(42), d2.Old.NumberValue())
|
|
assert.True(t, d2.New.IsNumber())
|
|
assert.Equal(t, float64(66), d2.New.NumberValue())
|
|
d3 := NewNumberProperty(88).Diff(NewBoolProperty(true))
|
|
assert.NotNil(t, d3)
|
|
assert.Nil(t, d3.Array)
|
|
assert.Nil(t, d3.Object)
|
|
assert.True(t, d3.Old.IsNumber())
|
|
assert.Equal(t, float64(88), d3.Old.NumberValue())
|
|
assert.True(t, d3.New.IsBool())
|
|
assert.Equal(t, true, d3.New.BoolValue())
|
|
}
|
|
|
|
func TestStringPropertyValueDiffs(t *testing.T) {
|
|
t.Parallel()
|
|
d1 := NewStringProperty("a string").Diff(NewStringProperty("a string"))
|
|
assert.Nil(t, d1)
|
|
d2 := NewStringProperty("a string").Diff(NewStringProperty("some other string"))
|
|
assert.NotNil(t, d2)
|
|
assert.True(t, d2.Old.IsString())
|
|
assert.Equal(t, "a string", d2.Old.StringValue())
|
|
assert.True(t, d2.New.IsString())
|
|
assert.Equal(t, "some other string", d2.New.StringValue())
|
|
d3 := NewStringProperty("what a string").Diff(NewNumberProperty(973))
|
|
assert.NotNil(t, d3)
|
|
assert.Nil(t, d3.Array)
|
|
assert.Nil(t, d3.Object)
|
|
assert.True(t, d3.Old.IsString())
|
|
assert.Equal(t, "what a string", d3.Old.StringValue(), "what a string")
|
|
assert.True(t, d3.New.IsNumber())
|
|
assert.Equal(t, float64(973), d3.New.NumberValue())
|
|
}
|
|
|
|
func TestArrayPropertyValueDiffs(t *testing.T) {
|
|
t.Parallel()
|
|
// no diffs:
|
|
d1 := NewArrayProperty([]PropertyValue{}).Diff(NewArrayProperty([]PropertyValue{}))
|
|
assert.Nil(t, d1)
|
|
d2 := NewArrayProperty([]PropertyValue{
|
|
NewStringProperty("element one"), NewNumberProperty(2), NewNullProperty(),
|
|
}).Diff(NewArrayProperty([]PropertyValue{
|
|
NewStringProperty("element one"), NewNumberProperty(2), NewNullProperty(),
|
|
}))
|
|
assert.Nil(t, d2)
|
|
// all updates:
|
|
d3a1 := NewArrayProperty([]PropertyValue{
|
|
NewStringProperty("element one"), NewNumberProperty(2), NewNullProperty()})
|
|
d3a2 := NewArrayProperty([]PropertyValue{
|
|
NewNumberProperty(1), NewNullProperty(), NewStringProperty("element three")})
|
|
d3 := d3a1.Diff(d3a2)
|
|
assert.NotNil(t, d3)
|
|
assert.NotNil(t, d3.Array)
|
|
assert.Nil(t, d3.Object)
|
|
assert.Equal(t, 0, len(d3.Array.Adds))
|
|
assert.Equal(t, 0, len(d3.Array.Deletes))
|
|
assert.Equal(t, 0, len(d3.Array.Sames))
|
|
assert.Equal(t, 3, len(d3.Array.Updates))
|
|
for i, update := range d3.Array.Updates {
|
|
assert.Equal(t, d3a1.ArrayValue()[i], update.Old)
|
|
assert.Equal(t, d3a2.ArrayValue()[i], update.New)
|
|
}
|
|
// update one, keep one, delete one:
|
|
d4a1 := NewArrayProperty([]PropertyValue{
|
|
NewStringProperty("element one"), NewNumberProperty(2), NewBoolProperty(true)})
|
|
d4a2 := NewArrayProperty([]PropertyValue{
|
|
NewStringProperty("element 1"), NewNumberProperty(2)})
|
|
d4 := d4a1.Diff(d4a2)
|
|
assert.NotNil(t, d4)
|
|
assert.NotNil(t, d4.Array)
|
|
assert.Nil(t, d4.Object)
|
|
assert.Equal(t, 0, len(d4.Array.Adds))
|
|
assert.Equal(t, 1, len(d4.Array.Deletes))
|
|
for i, delete := range d4.Array.Deletes {
|
|
assert.Equal(t, 2, i)
|
|
assert.Equal(t, d4a1.ArrayValue()[i], delete)
|
|
}
|
|
assert.Equal(t, 1, len(d4.Array.Sames))
|
|
for i, same := range d4.Array.Sames {
|
|
assert.Equal(t, 1, i)
|
|
assert.Equal(t, d4a1.ArrayValue()[i], same)
|
|
assert.Equal(t, d4a2.ArrayValue()[i], same)
|
|
}
|
|
assert.Equal(t, 1, len(d4.Array.Updates))
|
|
for i, update := range d4.Array.Updates {
|
|
assert.Equal(t, 0, i)
|
|
assert.Equal(t, d4a1.ArrayValue()[i], update.Old)
|
|
assert.Equal(t, d4a2.ArrayValue()[i], update.New)
|
|
}
|
|
// keep one, update one, add one:
|
|
d5a1 := NewArrayProperty([]PropertyValue{
|
|
NewStringProperty("element one"), NewNumberProperty(2)})
|
|
d5a2 := NewArrayProperty([]PropertyValue{
|
|
NewStringProperty("element 1"), NewNumberProperty(2), NewBoolProperty(true)})
|
|
d5 := d5a1.Diff(d5a2)
|
|
assert.NotNil(t, d5)
|
|
assert.NotNil(t, d5.Array)
|
|
assert.Nil(t, d5.Object)
|
|
assert.Equal(t, 1, len(d5.Array.Adds))
|
|
for i, add := range d5.Array.Adds {
|
|
assert.Equal(t, 2, i)
|
|
assert.Equal(t, d5a2.ArrayValue()[i], add)
|
|
}
|
|
assert.Equal(t, 0, len(d5.Array.Deletes))
|
|
assert.Equal(t, 1, len(d5.Array.Sames))
|
|
for i, same := range d5.Array.Sames {
|
|
assert.Equal(t, 1, i)
|
|
assert.Equal(t, d5a1.ArrayValue()[i], same)
|
|
assert.Equal(t, d5a2.ArrayValue()[i], same)
|
|
}
|
|
assert.Equal(t, 1, len(d5.Array.Updates))
|
|
for i, update := range d5.Array.Updates {
|
|
assert.Equal(t, 0, i)
|
|
assert.Equal(t, d5a1.ArrayValue()[i], update.Old)
|
|
assert.Equal(t, d5a2.ArrayValue()[i], update.New)
|
|
}
|
|
// from nil to empty array:
|
|
d6 := NewNullProperty().Diff(NewArrayProperty([]PropertyValue{}))
|
|
assert.NotNil(t, d6)
|
|
}
|
|
|
|
func TestObjectPropertyValueDiffs(t *testing.T) {
|
|
t.Parallel()
|
|
// no diffs:
|
|
d1 := PropertyMap{}.Diff(PropertyMap{})
|
|
assert.Nil(t, d1)
|
|
d2 := PropertyMap{
|
|
PropertyKey("a"): NewBoolProperty(true),
|
|
}.Diff(PropertyMap{
|
|
PropertyKey("a"): NewBoolProperty(true),
|
|
})
|
|
assert.Nil(t, d2)
|
|
// all updates:
|
|
{
|
|
obj1 := PropertyMap{
|
|
PropertyKey("prop-a"): NewBoolProperty(true),
|
|
PropertyKey("prop-b"): NewStringProperty("bbb"),
|
|
PropertyKey("prop-c"): NewObjectProperty(PropertyMap{
|
|
PropertyKey("inner-prop-a"): NewNumberProperty(673),
|
|
}),
|
|
}
|
|
obj2 := PropertyMap{
|
|
PropertyKey("prop-a"): NewBoolProperty(false),
|
|
PropertyKey("prop-b"): NewNumberProperty(89),
|
|
PropertyKey("prop-c"): NewObjectProperty(PropertyMap{
|
|
PropertyKey("inner-prop-a"): NewNumberProperty(672),
|
|
}),
|
|
}
|
|
d3 := obj1.Diff(obj2)
|
|
assert.NotNil(t, d3)
|
|
assert.Equal(t, 0, len(d3.Adds))
|
|
assert.Equal(t, 0, len(d3.Deletes))
|
|
assert.Equal(t, 0, len(d3.Sames))
|
|
assert.Equal(t, 3, len(d3.Updates))
|
|
d3pa := d3.Updates[PropertyKey("prop-a")]
|
|
assert.Nil(t, d3pa.Array)
|
|
assert.Nil(t, d3pa.Object)
|
|
assert.True(t, d3pa.Old.IsBool())
|
|
assert.Equal(t, true, d3pa.Old.BoolValue())
|
|
assert.True(t, d3pa.Old.IsBool())
|
|
assert.Equal(t, false, d3pa.New.BoolValue())
|
|
d3pb := d3.Updates[PropertyKey("prop-b")]
|
|
assert.Nil(t, d3pb.Array)
|
|
assert.Nil(t, d3pb.Object)
|
|
assert.True(t, d3pb.Old.IsString())
|
|
assert.Equal(t, "bbb", d3pb.Old.StringValue())
|
|
assert.True(t, d3pb.New.IsNumber())
|
|
assert.Equal(t, float64(89), d3pb.New.NumberValue())
|
|
d3pc := d3.Updates[PropertyKey("prop-c")]
|
|
assert.Nil(t, d3pc.Array)
|
|
assert.NotNil(t, d3pc.Object)
|
|
assert.Equal(t, 0, len(d3pc.Object.Adds))
|
|
assert.Equal(t, 0, len(d3pc.Object.Deletes))
|
|
assert.Equal(t, 0, len(d3pc.Object.Sames))
|
|
assert.Equal(t, 1, len(d3pc.Object.Updates))
|
|
d3pcu := d3pc.Object.Updates[PropertyKey("inner-prop-a")]
|
|
assert.True(t, d3pcu.Old.IsNumber())
|
|
assert.Equal(t, float64(673), d3pcu.Old.NumberValue())
|
|
assert.True(t, d3pcu.New.IsNumber())
|
|
assert.Equal(t, float64(672), d3pcu.New.NumberValue())
|
|
}
|
|
// add two (1 missing key, 1 null), update one, keep two, delete two (1 missing key, 1 null).
|
|
{
|
|
obj1 := PropertyMap{
|
|
PropertyKey("prop-a-2"): NewNullProperty(),
|
|
PropertyKey("prop-b"): NewStringProperty("bbb"),
|
|
PropertyKey("prop-c-1"): NewNumberProperty(6767),
|
|
PropertyKey("prop-c-2"): NewNullProperty(),
|
|
PropertyKey("prop-d-1"): NewBoolProperty(true),
|
|
PropertyKey("prop-d-2"): NewBoolProperty(false),
|
|
}
|
|
obj2 := PropertyMap{
|
|
PropertyKey("prop-a-1"): NewStringProperty("a fresh value"),
|
|
PropertyKey("prop-a-2"): NewStringProperty("a non-nil value"),
|
|
PropertyKey("prop-b"): NewNumberProperty(89),
|
|
PropertyKey("prop-c-1"): NewNumberProperty(6767),
|
|
PropertyKey("prop-c-2"): NewNullProperty(),
|
|
PropertyKey("prop-d-2"): NewNullProperty(),
|
|
}
|
|
d4 := obj1.Diff(obj2)
|
|
assert.NotNil(t, d4)
|
|
assert.Equal(t, 2, len(d4.Adds))
|
|
assert.Equal(t, obj2[PropertyKey("prop-a-1")], d4.Adds[PropertyKey("prop-a-1")])
|
|
assert.Equal(t, obj2[PropertyKey("prop-a-2")], d4.Adds[PropertyKey("prop-a-2")])
|
|
assert.Equal(t, 2, len(d4.Deletes))
|
|
assert.Equal(t, obj1[PropertyKey("prop-d-1")], d4.Deletes[PropertyKey("prop-d-1")])
|
|
assert.Equal(t, obj1[PropertyKey("prop-d-2")], d4.Deletes[PropertyKey("prop-d-2")])
|
|
assert.Equal(t, 2, len(d4.Sames))
|
|
assert.Equal(t, obj1[PropertyKey("prop-c-1")], d4.Sames[PropertyKey("prop-c-1")])
|
|
assert.Equal(t, obj1[PropertyKey("prop-c-2")], d4.Sames[PropertyKey("prop-c-2")])
|
|
assert.Equal(t, obj2[PropertyKey("prop-c-1")], d4.Sames[PropertyKey("prop-c-1")])
|
|
assert.Equal(t, obj2[PropertyKey("prop-c-2")], d4.Sames[PropertyKey("prop-c-2")])
|
|
assert.Equal(t, 1, len(d4.Updates))
|
|
assert.Equal(t, obj1[PropertyKey("prop-b")], d4.Updates[PropertyKey("prop-b")].Old)
|
|
assert.Equal(t, obj2[PropertyKey("prop-b")], d4.Updates[PropertyKey("prop-b")].New)
|
|
}
|
|
}
|
|
|
|
func TestAssetPropertyValueDiffs(t *testing.T) {
|
|
t.Parallel()
|
|
a1, err := NewTextAsset("test")
|
|
assert.Nil(t, err)
|
|
d1 := NewAssetProperty(a1).Diff(NewAssetProperty(a1))
|
|
assert.Nil(t, d1)
|
|
a2, err := NewTextAsset("test2")
|
|
assert.Nil(t, err)
|
|
d2 := NewAssetProperty(a1).Diff(NewAssetProperty(a2))
|
|
assert.NotNil(t, d2)
|
|
assert.Nil(t, d2.Array)
|
|
assert.Nil(t, d2.Object)
|
|
assert.True(t, d2.Old.IsAsset())
|
|
assert.Equal(t, "test", d2.Old.AssetValue().Text)
|
|
assert.True(t, d2.New.IsAsset())
|
|
assert.Equal(t, "test2", d2.New.AssetValue().Text)
|
|
d3 := NewAssetProperty(a1).Diff(NewNullProperty())
|
|
assert.NotNil(t, d3)
|
|
assert.Nil(t, d3.Array)
|
|
assert.Nil(t, d3.Object)
|
|
assert.True(t, d3.Old.IsAsset())
|
|
assert.Equal(t, "test", d3.Old.AssetValue().Text)
|
|
assert.True(t, d3.New.IsNull())
|
|
}
|
|
|
|
func TestArchivePropertyValueDiffs(t *testing.T) {
|
|
t.Parallel()
|
|
path, err := tempArchive("test", false)
|
|
assert.Nil(t, err)
|
|
defer func() { contract.IgnoreError(os.Remove(path)) }()
|
|
a1, err := NewPathArchive(path)
|
|
assert.Nil(t, err)
|
|
d1 := NewArchiveProperty(a1).Diff(NewArchiveProperty(a1))
|
|
assert.Nil(t, d1)
|
|
path2, err := tempArchive("test2", true)
|
|
assert.Nil(t, err)
|
|
defer func() { contract.IgnoreError(os.Remove(path)) }()
|
|
a2, err := NewPathArchive(path2)
|
|
assert.Nil(t, err)
|
|
d2 := NewArchiveProperty(a1).Diff(NewArchiveProperty(a2))
|
|
assert.NotNil(t, d2)
|
|
assert.Nil(t, d2.Array)
|
|
assert.Nil(t, d2.Object)
|
|
assert.True(t, d2.Old.IsArchive())
|
|
assert.Equal(t, path, d2.Old.ArchiveValue().Path)
|
|
assert.True(t, d2.New.IsArchive())
|
|
assert.Equal(t, path2, d2.New.ArchiveValue().Path)
|
|
d3 := NewArchiveProperty(a1).Diff(NewNullProperty())
|
|
assert.NotNil(t, d3)
|
|
assert.Nil(t, d3.Array)
|
|
assert.Nil(t, d3.Object)
|
|
assert.True(t, d3.Old.IsArchive())
|
|
assert.Equal(t, path, d3.Old.ArchiveValue().Path)
|
|
assert.True(t, d3.New.IsNull())
|
|
}
|