mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-28 18:01:01 -06:00
ef4726bd50
Changing the Set internals makes a lot of sense as it saves doing conversions in multiple places and gives a central place to alter the key when a item is computed. This will have no side effects other then that the ordering is now based on strings instead on integers, so the order will be different. This will however have no effect on existing configs as these will use the individual codes/keys and not the ordering to determine if there is a diff or not. Lastly (but I think also most importantly) there is a fix in this PR that makes diffing sets extremely more performand. Before a full diff required reading the complete Set for every single parameter/attribute you wanted to diff, while now it only gets that specific parameter. We have a use case where we have a Set that has 18 parameters and the set consist of about 600 items (don't ask 😉). So when doing a diff it would take 100% CPU of all cores and stay that way for almost an hour before being able to complete the diff. Debugging this we learned that for retrieving every single parameter it made over 52.000 calls to `func (c *ResourceConfig) get(..)`. In this function a slice is created and used only for the duration of the call, so the time needed to create all needed slices and on the other hand the time the garbage collector needed to clean them up again caused the system to cripple itself. Next to that there are also some expensive reflect calls in this function which also claimed a fair amount of CPU time. After this fix the number of calls needed to get a single parameter dropped from 52.000+ to only 2! 😃
114 lines
1.8 KiB
Go
114 lines
1.8 KiB
Go
package schema
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestSetAdd(t *testing.T) {
|
|
s := &Set{F: testSetInt}
|
|
s.Add(1)
|
|
s.Add(5)
|
|
s.Add(25)
|
|
|
|
expected := []interface{}{1, 25, 5}
|
|
actual := s.List()
|
|
if !reflect.DeepEqual(actual, expected) {
|
|
t.Fatalf("bad: %#v", actual)
|
|
}
|
|
}
|
|
|
|
func TestSetAdd_negative(t *testing.T) {
|
|
// Since we don't allow negative hashes, this should just hash to the
|
|
// same thing...
|
|
s := &Set{F: testSetInt}
|
|
s.Add(-1)
|
|
s.Add(1)
|
|
|
|
expected := []interface{}{-1}
|
|
actual := s.List()
|
|
if !reflect.DeepEqual(actual, expected) {
|
|
t.Fatalf("bad: %#v", actual)
|
|
}
|
|
}
|
|
|
|
func TestSetContains(t *testing.T) {
|
|
s := &Set{F: testSetInt}
|
|
s.Add(5)
|
|
s.Add(-5)
|
|
|
|
if s.Contains(2) {
|
|
t.Fatal("should not contain")
|
|
}
|
|
if !s.Contains(5) {
|
|
t.Fatal("should contain")
|
|
}
|
|
if !s.Contains(-5) {
|
|
t.Fatal("should contain")
|
|
}
|
|
}
|
|
|
|
func TestSetDifference(t *testing.T) {
|
|
s1 := &Set{F: testSetInt}
|
|
s2 := &Set{F: testSetInt}
|
|
|
|
s1.Add(1)
|
|
s1.Add(5)
|
|
|
|
s2.Add(5)
|
|
s2.Add(25)
|
|
|
|
difference := s1.Difference(s2)
|
|
difference.Add(2)
|
|
|
|
expected := []interface{}{1, 2}
|
|
actual := difference.List()
|
|
if !reflect.DeepEqual(actual, expected) {
|
|
t.Fatalf("bad: %#v", actual)
|
|
}
|
|
}
|
|
|
|
func TestSetIntersection(t *testing.T) {
|
|
s1 := &Set{F: testSetInt}
|
|
s2 := &Set{F: testSetInt}
|
|
|
|
s1.Add(1)
|
|
s1.Add(5)
|
|
|
|
s2.Add(5)
|
|
s2.Add(25)
|
|
|
|
intersection := s1.Intersection(s2)
|
|
intersection.Add(2)
|
|
|
|
expected := []interface{}{2, 5}
|
|
actual := intersection.List()
|
|
if !reflect.DeepEqual(actual, expected) {
|
|
t.Fatalf("bad: %#v", actual)
|
|
}
|
|
}
|
|
|
|
func TestSetUnion(t *testing.T) {
|
|
s1 := &Set{F: testSetInt}
|
|
s2 := &Set{F: testSetInt}
|
|
|
|
s1.Add(1)
|
|
s1.Add(5)
|
|
|
|
s2.Add(5)
|
|
s2.Add(25)
|
|
|
|
union := s1.Union(s2)
|
|
union.Add(2)
|
|
|
|
expected := []interface{}{1, 2, 25, 5}
|
|
actual := union.List()
|
|
if !reflect.DeepEqual(actual, expected) {
|
|
t.Fatalf("bad: %#v", actual)
|
|
}
|
|
}
|
|
|
|
func testSetInt(v interface{}) int {
|
|
return v.(int)
|
|
}
|