github.com/cycloidio/terraform@v1.1.10-0.20220513142504-76d5c768dc63/depsfile/locks_test.go (about) 1 package depsfile 2 3 import ( 4 "testing" 5 6 "github.com/google/go-cmp/cmp" 7 "github.com/cycloidio/terraform/addrs" 8 "github.com/cycloidio/terraform/getproviders" 9 ) 10 11 func TestLocksEqual(t *testing.T) { 12 boopProvider := addrs.NewDefaultProvider("boop") 13 v2 := getproviders.MustParseVersion("2.0.0") 14 v2LocalBuild := getproviders.MustParseVersion("2.0.0+awesomecorp.1") 15 v2GtConstraints := getproviders.MustParseVersionConstraints(">= 2.0.0") 16 v2EqConstraints := getproviders.MustParseVersionConstraints("2.0.0") 17 hash1 := getproviders.HashScheme("test").New("1") 18 hash2 := getproviders.HashScheme("test").New("2") 19 hash3 := getproviders.HashScheme("test").New("3") 20 21 equalBothWays := func(t *testing.T, a, b *Locks) { 22 t.Helper() 23 if !a.Equal(b) { 24 t.Errorf("a should be equal to b") 25 } 26 if !b.Equal(a) { 27 t.Errorf("b should be equal to a") 28 } 29 } 30 nonEqualBothWays := func(t *testing.T, a, b *Locks) { 31 t.Helper() 32 if a.Equal(b) { 33 t.Errorf("a should be equal to b") 34 } 35 if b.Equal(a) { 36 t.Errorf("b should be equal to a") 37 } 38 } 39 40 t.Run("both empty", func(t *testing.T) { 41 a := NewLocks() 42 b := NewLocks() 43 equalBothWays(t, a, b) 44 }) 45 t.Run("an extra provider lock", func(t *testing.T) { 46 a := NewLocks() 47 b := NewLocks() 48 b.SetProvider(boopProvider, v2, v2GtConstraints, nil) 49 nonEqualBothWays(t, a, b) 50 }) 51 t.Run("both have boop provider with same version", func(t *testing.T) { 52 a := NewLocks() 53 b := NewLocks() 54 // Note: the constraints are not part of the definition of "Equal", so they can differ 55 a.SetProvider(boopProvider, v2, v2GtConstraints, nil) 56 b.SetProvider(boopProvider, v2, v2EqConstraints, nil) 57 equalBothWays(t, a, b) 58 }) 59 t.Run("both have boop provider with different versions", func(t *testing.T) { 60 a := NewLocks() 61 b := NewLocks() 62 a.SetProvider(boopProvider, v2, v2EqConstraints, nil) 63 b.SetProvider(boopProvider, v2LocalBuild, v2EqConstraints, nil) 64 nonEqualBothWays(t, a, b) 65 }) 66 t.Run("both have boop provider with same version and same hashes", func(t *testing.T) { 67 a := NewLocks() 68 b := NewLocks() 69 hashes := []getproviders.Hash{hash1, hash2, hash3} 70 a.SetProvider(boopProvider, v2, v2EqConstraints, hashes) 71 b.SetProvider(boopProvider, v2, v2EqConstraints, hashes) 72 equalBothWays(t, a, b) 73 }) 74 t.Run("both have boop provider with same version but different hashes", func(t *testing.T) { 75 a := NewLocks() 76 b := NewLocks() 77 hashesA := []getproviders.Hash{hash1, hash2} 78 hashesB := []getproviders.Hash{hash1, hash3} 79 a.SetProvider(boopProvider, v2, v2EqConstraints, hashesA) 80 b.SetProvider(boopProvider, v2, v2EqConstraints, hashesB) 81 nonEqualBothWays(t, a, b) 82 }) 83 } 84 85 func TestLocksEqualProviderAddress(t *testing.T) { 86 boopProvider := addrs.NewDefaultProvider("boop") 87 v2 := getproviders.MustParseVersion("2.0.0") 88 v2LocalBuild := getproviders.MustParseVersion("2.0.0+awesomecorp.1") 89 v2GtConstraints := getproviders.MustParseVersionConstraints(">= 2.0.0") 90 v2EqConstraints := getproviders.MustParseVersionConstraints("2.0.0") 91 hash1 := getproviders.HashScheme("test").New("1") 92 hash2 := getproviders.HashScheme("test").New("2") 93 hash3 := getproviders.HashScheme("test").New("3") 94 95 equalProviderAddressBothWays := func(t *testing.T, a, b *Locks) { 96 t.Helper() 97 if !a.EqualProviderAddress(b) { 98 t.Errorf("a should be equal to b") 99 } 100 if !b.EqualProviderAddress(a) { 101 t.Errorf("b should be equal to a") 102 } 103 } 104 nonEqualProviderAddressBothWays := func(t *testing.T, a, b *Locks) { 105 t.Helper() 106 if a.EqualProviderAddress(b) { 107 t.Errorf("a should be equal to b") 108 } 109 if b.EqualProviderAddress(a) { 110 t.Errorf("b should be equal to a") 111 } 112 } 113 114 t.Run("both empty", func(t *testing.T) { 115 a := NewLocks() 116 b := NewLocks() 117 equalProviderAddressBothWays(t, a, b) 118 }) 119 t.Run("an extra provider lock", func(t *testing.T) { 120 a := NewLocks() 121 b := NewLocks() 122 b.SetProvider(boopProvider, v2, v2GtConstraints, nil) 123 nonEqualProviderAddressBothWays(t, a, b) 124 }) 125 t.Run("both have boop provider with different versions", func(t *testing.T) { 126 a := NewLocks() 127 b := NewLocks() 128 a.SetProvider(boopProvider, v2, v2EqConstraints, nil) 129 b.SetProvider(boopProvider, v2LocalBuild, v2EqConstraints, nil) 130 equalProviderAddressBothWays(t, a, b) 131 }) 132 t.Run("both have boop provider with same version but different hashes", func(t *testing.T) { 133 a := NewLocks() 134 b := NewLocks() 135 hashesA := []getproviders.Hash{hash1, hash2} 136 hashesB := []getproviders.Hash{hash1, hash3} 137 a.SetProvider(boopProvider, v2, v2EqConstraints, hashesA) 138 b.SetProvider(boopProvider, v2, v2EqConstraints, hashesB) 139 equalProviderAddressBothWays(t, a, b) 140 }) 141 } 142 143 func TestLocksProviderSetRemove(t *testing.T) { 144 beepProvider := addrs.NewDefaultProvider("beep") 145 boopProvider := addrs.NewDefaultProvider("boop") 146 v2 := getproviders.MustParseVersion("2.0.0") 147 v2EqConstraints := getproviders.MustParseVersionConstraints("2.0.0") 148 v2GtConstraints := getproviders.MustParseVersionConstraints(">= 2.0.0") 149 hash := getproviders.HashScheme("test").New("1") 150 151 locks := NewLocks() 152 if got, want := len(locks.AllProviders()), 0; got != want { 153 t.Fatalf("fresh locks object already has providers") 154 } 155 156 locks.SetProvider(boopProvider, v2, v2EqConstraints, []getproviders.Hash{hash}) 157 { 158 got := locks.AllProviders() 159 want := map[addrs.Provider]*ProviderLock{ 160 boopProvider: { 161 addr: boopProvider, 162 version: v2, 163 versionConstraints: v2EqConstraints, 164 hashes: []getproviders.Hash{hash}, 165 }, 166 } 167 if diff := cmp.Diff(want, got, ProviderLockComparer); diff != "" { 168 t.Fatalf("wrong providers after SetProvider boop\n%s", diff) 169 } 170 } 171 172 locks.SetProvider(beepProvider, v2, v2GtConstraints, []getproviders.Hash{hash}) 173 { 174 got := locks.AllProviders() 175 want := map[addrs.Provider]*ProviderLock{ 176 boopProvider: { 177 addr: boopProvider, 178 version: v2, 179 versionConstraints: v2EqConstraints, 180 hashes: []getproviders.Hash{hash}, 181 }, 182 beepProvider: { 183 addr: beepProvider, 184 version: v2, 185 versionConstraints: v2GtConstraints, 186 hashes: []getproviders.Hash{hash}, 187 }, 188 } 189 if diff := cmp.Diff(want, got, ProviderLockComparer); diff != "" { 190 t.Fatalf("wrong providers after SetProvider beep\n%s", diff) 191 } 192 } 193 194 locks.RemoveProvider(boopProvider) 195 { 196 got := locks.AllProviders() 197 want := map[addrs.Provider]*ProviderLock{ 198 beepProvider: { 199 addr: beepProvider, 200 version: v2, 201 versionConstraints: v2GtConstraints, 202 hashes: []getproviders.Hash{hash}, 203 }, 204 } 205 if diff := cmp.Diff(want, got, ProviderLockComparer); diff != "" { 206 t.Fatalf("wrong providers after RemoveProvider boop\n%s", diff) 207 } 208 } 209 210 locks.RemoveProvider(beepProvider) 211 { 212 got := locks.AllProviders() 213 want := map[addrs.Provider]*ProviderLock{} 214 if diff := cmp.Diff(want, got, ProviderLockComparer); diff != "" { 215 t.Fatalf("wrong providers after RemoveProvider beep\n%s", diff) 216 } 217 } 218 }