Initial commit

.gitignore

@@ -0,0 +1,32 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+
+# By Reza
+build/
+dist/
+.archive/
+.vagrant/
+.env
+*_[0-9]
+*_[0-9][0-9]
+*_????-??-??
+*.zip

LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2024, Reza Behzadan
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. The name of "Reza Behzadan" may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+4. Modified versions of the software must be distributed under the same terms and conditions of this license, and the original name of "Reza Behzadan" must be credited as the original developer in any significant portions of the redistributed or modified code.
+
+5. The software, including any modified versions, must not be used, directly or indirectly, in any type of military project or in any project that may cause harm to any human being.
+
+6. The software, including any modified versions, must not be used, directly or indirectly, by any individual, organization, or entity involved in or supporting oppressive, totalitarian regimes, or in any project that supports such regimes or contributes to human rights violations. This includes, but is not limited to, entities known for systematic oppression, cruelty, and use of violence against defenseless individuals, or for supporting terrorism.
+
+
+DISCLAIMER:
+
+THIS SOFTWARE IS PROVIDED BY REZA BEHZADAN "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL REZA BEHZADAN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+

README.md

@@ -0,0 +1,12 @@
+# GoDict
+
+
+## Tests
+```sh
+go test -v ./... 
+```
+
+## License
+
+This project is licensed under a custom license - see the [LICENSE](LICENSE) file for details.
+

go.mod

@@ -0,0 +1,5 @@
+module git.behzadan.ir/reza/GoDict
+
+go 1.22.0
+
+require gopkg.in/yaml.v3 v3.0.1 // indirect

go.sum

@@ -0,0 +1,3 @@
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/dict/dict.go

@@ -0,0 +1,62 @@
+package dict
+
+type Dict map[string]interface{}
+
+func New() Dict {
+	return make(Dict)
+}
+
+func IsDict(a interface{}) bool {
+	_, ok := a.(Dict)
+	return ok
+}
+
+func (d Dict) HasKey(key string) bool {
+	_, ok := d[key]
+	return ok
+}
+
+func Copy(dest *Dict, src Dict) {
+	if *dest == nil {
+		*dest = make(Dict)
+	}
+	for k, v := range src {
+		if vv, ok := v.(Dict); ok {
+			t := make(Dict)
+			Copy(&t, vv)
+			(*dest)[k] = t
+		} else {
+			(*dest)[k] = v
+		}
+	}
+}
+
+func (dest *Dict) CopyFrom(src Dict) {
+	if *dest == nil {
+		*dest = make(Dict)
+	}
+	for k, v := range src {
+		if vv, ok := v.(Dict); ok {
+			t := make(Dict)
+			t.CopyFrom(vv)
+			(*dest)[k] = t
+		} else {
+			(*dest)[k] = v
+		}
+	}
+}
+
+func (src Dict) CopyTo(dest *Dict) {
+	if *dest == nil {
+		*dest = make(Dict)
+	}
+	for k, v := range src {
+		if vv, ok := v.(Dict); ok {
+			t := make(Dict)
+			vv.CopyTo(&t)
+			(*dest)[k] = t
+		} else {
+			(*dest)[k] = v
+		}
+	}
+}

internal/dict/dict_merge.go

@@ -0,0 +1,49 @@
+package dict
+
+func softMerge(a, b Dict) {
+	for k, v := range b {
+		if a.HasKey(k) && IsDict(a[k]) && IsDict(v) {
+			softMerge(a[k].(Dict), v.(Dict))
+		} else if !a.HasKey(k) {
+			a[k] = v
+		}
+	}
+}
+
+func SoftMerge(target *Dict, source Dict) {
+	if target == nil {
+		*target = make(Dict)
+	}
+	softMerge(*target, source)
+}
+
+func (target *Dict) SoftMergeWith(source Dict) {
+	if target == nil {
+		*target = make(Dict)
+	}
+	softMerge(*target, source)
+}
+
+func merge(a, b Dict) {
+	for k, v := range b {
+		if a.HasKey(k) && IsDict(a[k]) && IsDict(v) {
+			merge(a[k].(Dict), v.(Dict))
+		} else {
+			a[k] = v
+		}
+	}
+}
+
+func Merge(target *Dict, source Dict) {
+	if target == nil {
+		*target = make(Dict)
+	}
+	merge(*target, source)
+}
+
+func (target *Dict) MergeWith(source Dict) {
+	if target == nil {
+		*target = make(Dict)
+	}
+	merge(*target, source)
+}

internal/dict/dict_merge_test.go

@@ -0,0 +1,46 @@
+package dict
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSoftMerge(t *testing.T) {
+	testCases := loadDictDictToDictTestCases("test_data/soft_merge_cases.yaml")
+	for _, testCase := range testCases {
+		SoftMerge(&testCase.Dict1, testCase.Dict2)
+		if !reflect.DeepEqual(testCase.Dict1, testCase.Result) {
+			t.Errorf("Expected dict to be %v, got %v", testCase.Result, testCase.Dict1)
+		}
+	}
+}
+
+func TestSoftMergeWith(t *testing.T) {
+	testCases := loadDictDictToDictTestCases("test_data/soft_merge_cases.yaml")
+	for _, testCase := range testCases {
+		testCase.Dict1.SoftMergeWith(testCase.Dict2)
+		if !reflect.DeepEqual(testCase.Dict1, testCase.Result) {
+			t.Errorf("Expected dict to be %v, got %v", testCase.Result, testCase.Dict1)
+		}
+	}
+}
+
+func TestMerge(t *testing.T) {
+	testCases := loadDictDictToDictTestCases("test_data/merge_cases.yaml")
+	for _, testCase := range testCases {
+		Merge(&testCase.Dict1, testCase.Dict2)
+		if !reflect.DeepEqual(testCase.Dict1, testCase.Result) {
+			t.Errorf("Expected dict to be %v, got %v", testCase.Result, testCase.Dict1)
+		}
+	}
+}
+
+func TestMergeWith(t *testing.T) {
+	testCases := loadDictDictToDictTestCases("test_data/merge_cases.yaml")
+	for _, testCase := range testCases {
+		testCase.Dict1.MergeWith(testCase.Dict2)
+		if !reflect.DeepEqual(testCase.Dict1, testCase.Result) {
+			t.Errorf("Expected dict to be %v, got %v", testCase.Result, testCase.Dict1)
+		}
+	}
+}

internal/dict/dict_serialization.go

@@ -0,0 +1,108 @@
+package dict
+
+import (
+	"encoding/json"
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+func loadYaml(fn string) (Dict, error) {
+	content, err := os.ReadFile(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	var data Dict
+	err = yaml.Unmarshal(content, &data)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+
+}
+
+func loadYamlStr(yamlStr string) (Dict, error) {
+	var data Dict
+	err := yaml.Unmarshal([]byte(yamlStr), &data)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func (d Dict) dumpYaml(fn string) error {
+	data, err := yaml.Marshal(d)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(fn, data, 0644) // Write with user read/write, group read, and others read permissions
+}
+
+func (d Dict) dumpYamlStr() (string, error) {
+	data, err := yaml.Marshal(d)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+// loadJson loads the dictionary from a JSON file.
+func loadJson(fn string) (Dict, error) {
+	var data Dict
+	content, err := os.ReadFile(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal(content, &data)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func loadJsonStr(jsonStr string) (Dict, error) {
+	var data Dict
+	err := json.Unmarshal([]byte(jsonStr), &data)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+// dumpJson writes the dictionary to a JSON file.
+func (d Dict) dumpJson(fn string) error {
+	data, err := json.Marshal(d)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(fn, data, 0644) // Write with user read/write, group read, and others read permissions
+}
+
+// dumpJsonIndent writes the dictionary to a JSON file but applies indent first.
+func (d Dict) dumpJsonIndent(fn string, prefix, indent string) error {
+	data, err := json.MarshalIndent(d, prefix, indent)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(fn, data, 0644) // Write with user read/write, group read, and others read permissions
+}
+
+// dumpJsonStr returns the dictionary as a JSON string.
+func (d Dict) dumpJsonStr() (string, error) {
+	data, err := json.Marshal(d)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+// dumpJsonStr returns the dictionary as a JSON string.
+func (d Dict) dumpJsonStrIndent(prefix, indent string) (string, error) {
+	data, err := json.MarshalIndent(d, prefix, indent)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}

internal/dict/dict_serialization_test.go

@@ -0,0 +1,84 @@
+package dict
+
+import (
+	"os"
+	"reflect"
+	"testing"
+)
+
+// TestLoadYamlUsingTempFile tests the loadYaml function.
+func TestLoadYamlUsingTempFile(t *testing.T) {
+	// Step 1: Create a temporary file.
+	tmpFile, err := os.CreateTemp("", "example.*.yaml")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name()) // Clean up after the test.
+
+	// Step 2: Write some YAML content to this file.
+	yamlContent := `
+key1: value1
+key2: 2
+key3:
+  - elem1
+  - elem2
+`
+	if _, err := tmpFile.Write([]byte(yamlContent)); err != nil {
+		t.Fatalf("Failed to write to temp file: %v", err)
+	}
+	if err := tmpFile.Close(); err != nil {
+		t.Fatalf("Failed to close temp file: %v", err)
+	}
+
+	// Step 3: Use the loadYaml function to load this file into a Dict.
+	dict, err := loadYaml(tmpFile.Name())
+	if err != nil {
+		t.Fatalf("loadYaml failed: %v", err)
+	}
+
+	// Step 4: Verify that the Dict contains the expected data.
+	expectedDict := Dict{
+		"key1": "value1",
+		"key2": 2,
+		"key3": []interface{}{"elem1", "elem2"},
+	}
+
+	if !reflect.DeepEqual(dict, expectedDict) {
+		t.Errorf("Expected dict to be %v, got %v", expectedDict, dict)
+	}
+}
+
+// TestLoadYaml tests the loadYaml function.
+func TestLoadYaml(t *testing.T) {
+
+	dict, err := loadYaml("test_data/dict1.yaml")
+	if err != nil {
+		t.Fatalf("loadYaml() returned an error: %v", err)
+	}
+
+	expectedDict := Dict{
+		"key1": "value1",
+		"key2": 2,
+		"key3": []interface{}{"elem1", "elem2"},
+	}
+
+	if !reflect.DeepEqual(dict, expectedDict) {
+		t.Errorf("Expected dict to be %v, got %v", expectedDict, dict)
+	}
+}
+
+func TestDumpJsonStrIndent(t *testing.T) {
+	d := Dict{"key": "value", "number": 1}
+	jsonStr, err := d.dumpJsonStrIndent("", "  ")
+	if err != nil {
+		t.Fatalf("dumpJsonStrIndent() returned an error: %v", err)
+	}
+
+	expected := `{
+  "key": "value",
+  "number": 1
+}`
+	if jsonStr != expected {
+		t.Errorf("Expected %v, got %v", expected, jsonStr)
+	}
+}

internal/dict/dict_test.go

@@ -0,0 +1,207 @@
+package dict
+
+import (
+	"reflect"
+	"testing"
+)
+
+func sampleDict() Dict {
+	return Dict{
+		"name":        "Test Project",
+		"version":     1.0,
+		"active":      true,
+		"description": "This is a sample YAML file for testing the Dict package.",
+		"metadata": Dict{
+			"author":  "John Doe",
+			"license": "MIT",
+			"tags":    []interface{}{"sample", "test", "yaml"},
+		},
+		"configuration": Dict{
+			"threads":  4,
+			"verbose":  true,
+			"features": []interface{}{"logging", "monitoring"},
+		},
+		"resources": []interface{}{
+			Dict{
+				"type": "database",
+				"name": "primary-db",
+				"properties": Dict{
+					"host": "localhost",
+					"port": 5432,
+					"credentials": Dict{
+						"username": "admin",
+						"password": "secret",
+					},
+				},
+			},
+			Dict{
+				"type": "cache",
+				"name": "redis-cache",
+				"properties": Dict{
+					"host": "localhost",
+					"port": 6379,
+					"ttl":  3600,
+				},
+			},
+		},
+		"nested": Dict{
+			"level1": Dict{
+				"level2": Dict{
+					"level3": Dict{
+						"key":   "value",
+						"array": []interface{}{1, 2, 3, 4.5},
+						"nestedArray": []interface{}{
+							Dict{"key1": "val1"},
+							Dict{
+								"key2": "val2",
+								"subNested": Dict{
+									"subKey1": "subVal1",
+									"subKey2": 2,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		"additionalNotes": "This is a multiline string.\nIt can contain new lines and spaces.\nIt's useful for longer descriptions or content.",
+	}
+}
+
+func TestSampleDict(t *testing.T) {
+	originalDict, err := loadYaml("test_data/dict2.yaml")
+	if err != nil {
+		t.Fatalf("loadYaml() returned an error: %v", err)
+	}
+
+	dict := sampleDict()
+
+	if !reflect.DeepEqual(dict, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, dict)
+	}
+
+}
+
+func TestNew(t *testing.T) {
+	d := New()
+	if d == nil {
+		t.Error("New() should not return nil")
+	}
+	if len(d) != 0 {
+		t.Errorf("New() should return an empty dict, got %v", d)
+	}
+}
+
+func TestIsDict(t *testing.T) {
+	d := Dict{
+		"key1": "value1",
+	}
+
+	r := IsDict(d)
+	if !r {
+		t.Errorf("Expected true, got %v", r)
+	}
+
+	r = IsDict(12)
+	if r {
+		t.Errorf("Expected false, got %v", r)
+	}
+
+	r = IsDict("Cool!")
+	if r {
+		t.Errorf("Expected false, got %v", r)
+	}
+
+	var v1 interface{}
+	r = IsDict(v1)
+	if r {
+		t.Errorf("Expected false, got %v", r)
+	}
+
+	var v2 []interface{}
+	r = IsDict(v2)
+	if r {
+		t.Errorf("Expected false, got %v", r)
+	}
+
+	var v3 map[string]interface{}
+	r = IsDict(v3)
+	if r {
+		t.Errorf("Expected false, got %v", r)
+	}
+}
+
+func TestCopy(t *testing.T) {
+	originalDict, err := loadYaml("test_data/dict2.yaml")
+	if err != nil {
+		t.Fatalf("loadYaml() returned an error: %v", err)
+	}
+
+	newDict1 := Dict{}
+	Copy(&newDict1, originalDict)
+	if !reflect.DeepEqual(newDict1, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict1)
+	}
+
+	newDict2 := make(Dict)
+	Copy(&newDict2, originalDict)
+	if !reflect.DeepEqual(newDict2, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict2)
+	}
+
+	var newDict3 Dict
+	Copy(&newDict3, originalDict)
+	if !reflect.DeepEqual(newDict3, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict3)
+	}
+}
+
+func TestCopyFrom(t *testing.T) {
+	originalDict, err := loadYaml("test_data/dict2.yaml")
+	if err != nil {
+		t.Fatalf("loadYaml() returned an error: %v", err)
+	}
+
+	newDict1 := Dict{}
+	newDict1.CopyFrom(originalDict)
+	if !reflect.DeepEqual(newDict1, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict1)
+	}
+
+	newDict2 := make(Dict)
+	newDict2.CopyFrom(originalDict)
+	if !reflect.DeepEqual(newDict2, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict2)
+	}
+
+	var newDict3 Dict
+	newDict3.CopyFrom(originalDict)
+	if !reflect.DeepEqual(newDict3, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict3)
+	}
+}
+
+func TestCopyTo(t *testing.T) {
+	originalDict, err := loadYaml("test_data/dict2.yaml")
+	if err != nil {
+		t.Fatalf("loadYaml() returned an error: %v", err)
+	}
+
+	newDict1 := Dict{}
+	originalDict.CopyTo(&newDict1)
+	if !reflect.DeepEqual(newDict1, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict1)
+	}
+
+	newDict2 := make(Dict)
+	originalDict.CopyTo(&newDict2)
+	if !reflect.DeepEqual(newDict2, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict2)
+	}
+
+	var newDict3 Dict
+	originalDict.CopyTo(&newDict3)
+	if !reflect.DeepEqual(newDict3, originalDict) {
+		t.Errorf("Expected dict to be %v, got %v", originalDict, newDict3)
+	}
+}

internal/dict/test_data/dict1.yaml

@@ -0,0 +1,6 @@
+key1: value1
+key2: 2
+key3:
+  - elem1
+  - elem2
+

internal/dict/test_data/dict2.yaml

@@ -0,0 +1,51 @@
+name: Test Project
+version: 1.0
+active: true
+description: This is a sample YAML file for testing the Dict package.
+
+metadata:
+  author: John Doe
+  license: MIT
+  tags: [sample, test, yaml]
+
+configuration:
+  threads: 4
+  verbose: true
+  features:
+    - logging
+    - monitoring
+
+resources:
+  - type: database
+    name: primary-db
+    properties:
+      host: localhost
+      port: 5432
+      credentials:
+        username: admin
+        password: secret
+
+  - type: cache
+    name: redis-cache
+    properties:
+      host: localhost
+      port: 6379
+      ttl: 3600
+
+nested:
+  level1:
+    level2:
+      level3:
+        key: value
+        array: [1, 2, 3, 4.5]
+        nestedArray:
+          - key1: val1
+          - key2: val2
+            subNested:
+              subKey1: subVal1
+              subKey2: 2
+
+additionalNotes: |-
+  This is a multiline string.
+  It can contain new lines and spaces.
+  It's useful for longer descriptions or content.

internal/dict/test_data/dict3.yaml

@@ -0,0 +1,24 @@
+nginx:
+  globals:
+    http_port: 80
+    https_port: 443
+    redirect_to_https: true
+    acme_challange: true
+  http_port: 8888
+  sites:
+    globals:
+      domain: "example.com"
+      rate_limit: 
+        zone: "mylimit"
+        burst: 20
+    cdn:
+      subdomain: "cdn"
+      root: "/srv/public/cdn"
+    www:
+      subdomain: "www"
+      domain: "mywebsite.com"
+      redirect_to_https: false
+      http2: true
+      https_port: 8443
+      rate_limit: 
+        burst: 70

internal/dict/test_data/dict4.yaml

@@ -0,0 +1,32 @@
+---
+globals:
+  domain: "main.sample.org"
+  names:
+    - Jack
+    - John
+    - Jill
+nginx:
+  globals:
+    http_port: 80
+    https_port: 443
+    redirect_to_https: true
+    acme_challange: true
+  http_port: 8888
+  sites:
+    globals:
+      domain: "exmaple.com"
+      rate_limit: 
+        zone: "mylimit"
+        burst: 20
+    cdn:
+      subdomain: "cdn"
+      root: "/srv/public/cdn"
+    www:
+      subdomain: "www"
+      domain: "mywebsite.com"
+      redirect_to_https: false
+      http2: true
+      https_port: 8443
+      rate_limit: 
+        burst: 70
+

internal/dict/test_data/dict5.yaml

@@ -0,0 +1,5 @@
+key1: value1
+key2: value2
+key3:
+  key31: value31
+  key32: value32

internal/dict/test_data/merge_cases.yaml

@@ -0,0 +1,52 @@
+---
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key3: value3
+  result:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+    key3: value3
+
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key1: value9
+  result:
+    key1: value9
+    key2:
+      key21: value21
+      key22: value22
+
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key2: value9
+  result:
+    key1: value1
+    key2: value9
+
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key2:
+      key22: value99
+  result:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value99

internal/dict/test_data/soft_merge_cases.yaml

@@ -0,0 +1,95 @@
+---
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key3: value3
+  result:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+    key3: value3
+
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key2: value9
+  result:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key1: value9
+    key2:
+      key22: value99
+  result:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key1: value9
+    key2:
+      key33: value33
+  result:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+      key33: value33
+
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key1: value9
+    key2:
+      key33: value33
+    key3: value3
+  result:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+      key33: value33
+    key3: value3
+
+- dict1:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+  dict2:
+    key1: value9
+    key2:
+      key22: value99
+      key33: value33
+    key3: value3
+  result:
+    key1: value1
+    key2:
+      key21: value21
+      key22: value22
+      key33: value33
+    key3: value3

internal/dict/testutils_test.go

@@ -0,0 +1,27 @@
+package dict
+
+import (
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+type dictDictToDictTestCase struct {
+	Dict1  Dict `yaml:"dict1"`
+	Dict2  Dict `yaml:"dict2"`
+	Result Dict `yaml:"result"`
+}
+
+func loadDictDictToDictTestCases(fn string) []dictDictToDictTestCase {
+	content, err := os.ReadFile(fn)
+	if err != nil {
+		panic(err)
+	}
+
+	var testCases []dictDictToDictTestCase
+	err = yaml.Unmarshal(content, &testCases)
+	if err != nil {
+		panic(err)
+	}
+	return testCases
+}

main.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println("hi")
+}