github.com/onsi/gomega@v1.32.0/gstruct/keys_test.go (about)

     1  package gstruct_test
     2  
     3  import (
     4  	. "github.com/onsi/ginkgo/v2"
     5  	. "github.com/onsi/gomega"
     6  	. "github.com/onsi/gomega/gstruct"
     7  )
     8  
     9  var _ = Describe("Map", func() {
    10  	allKeys := map[string]string{"A": "a", "B": "b"}
    11  	missingKeys := map[string]string{"A": "a"}
    12  	extraKeys := map[string]string{"A": "a", "B": "b", "C": "c"}
    13  	emptyKeys := map[string]string{}
    14  
    15  	It("should strictly match all keys", func() {
    16  		m := MatchAllKeys(Keys{
    17  			"B": Equal("b"),
    18  			"A": Equal("a"),
    19  		})
    20  		Expect(allKeys).Should(m, "should match all keys")
    21  		Expect(missingKeys).ShouldNot(m, "should fail with missing keys")
    22  		Expect(extraKeys).ShouldNot(m, "should fail with extra keys")
    23  		Expect(emptyKeys).ShouldNot(m, "should fail with empty keys")
    24  
    25  		m = MatchAllKeys(Keys{
    26  			"A": Equal("a"),
    27  			"B": Equal("fail"),
    28  		})
    29  		Expect(allKeys).ShouldNot(m, "should run nested matchers")
    30  	})
    31  
    32  	It("should handle empty maps", func() {
    33  		m := MatchAllKeys(Keys{})
    34  		Expect(map[string]string{}).Should(m, "should handle empty maps")
    35  		Expect(allKeys).ShouldNot(m, "should fail with extra keys")
    36  	})
    37  
    38  	It("should ignore missing keys", func() {
    39  		m := MatchKeys(IgnoreMissing, Keys{
    40  			"B": Equal("b"),
    41  			"A": Equal("a"),
    42  		})
    43  		Expect(allKeys).Should(m, "should match all keys")
    44  		Expect(missingKeys).Should(m, "should ignore missing keys")
    45  		Expect(extraKeys).ShouldNot(m, "should fail with extra keys")
    46  		Expect(emptyKeys).Should(m, "should match empty keys")
    47  	})
    48  
    49  	It("should ignore extra keys", func() {
    50  		m := MatchKeys(IgnoreExtras, Keys{
    51  			"B": Equal("b"),
    52  			"A": Equal("a"),
    53  		})
    54  		Expect(allKeys).Should(m, "should match all keys")
    55  		Expect(missingKeys).ShouldNot(m, "should fail with missing keys")
    56  		Expect(extraKeys).Should(m, "should ignore extra keys")
    57  		Expect(emptyKeys).ShouldNot(m, "should fail with empty keys")
    58  	})
    59  
    60  	It("should ignore missing and extra keys", func() {
    61  		m := MatchKeys(IgnoreMissing|IgnoreExtras, Keys{
    62  			"B": Equal("b"),
    63  			"A": Equal("a"),
    64  		})
    65  		Expect(allKeys).Should(m, "should match all keys")
    66  		Expect(missingKeys).Should(m, "should ignore missing keys")
    67  		Expect(extraKeys).Should(m, "should ignore extra keys")
    68  		Expect(emptyKeys).Should(m, "should match empty keys")
    69  
    70  		m = MatchKeys(IgnoreMissing|IgnoreExtras, Keys{
    71  			"A": Equal("a"),
    72  			"B": Equal("fail"),
    73  		})
    74  		Expect(allKeys).ShouldNot(m, "should run nested matchers")
    75  	})
    76  
    77  	It("should produce sensible error messages", func() {
    78  		m := MatchAllKeys(Keys{
    79  			"B": Equal("b"),
    80  			"A": Equal("a"),
    81  		})
    82  
    83  		actual := map[string]string{"A": "b", "C": "c"}
    84  
    85  		//Because the order of the constituent errors can't be guaranteed,
    86  		//we do a number of checks to make sure everything's included
    87  		m.Match(actual)
    88  		Expect(m.FailureMessage(actual)).Should(HavePrefix(
    89  			"Expected\n    <string>: \nto match keys: {\n",
    90  		))
    91  		Expect(m.FailureMessage(actual)).Should(ContainSubstring(
    92  			".\"A\":\n	Expected\n	    <string>: b\n	to equal\n	    <string>: a\n",
    93  		))
    94  		Expect(m.FailureMessage(actual)).Should(ContainSubstring(
    95  			"missing expected key B\n",
    96  		))
    97  		Expect(m.FailureMessage(actual)).Should(ContainSubstring(
    98  			".\"C\":\n	unexpected key C: map[",
    99  		))
   100  	})
   101  })