| package json |
| |
| import ( |
| "fmt" |
| "reflect" |
| "strings" |
| "testing" |
| |
| "github.com/davecgh/go-spew/spew" |
| "github.com/go-test/deep" |
| "github.com/hashicorp/hcl/v2" |
| "github.com/zclconf/go-cty/cty" |
| ) |
| |
| func TestBodyPartialContent(t *testing.T) { |
| tests := []struct { |
| src string |
| schema *hcl.BodySchema |
| want *hcl.BodyContent |
| diagCount int |
| }{ |
| { |
| `{}`, |
| &hcl.BodySchema{}, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 2, Byte: 1}, |
| End: hcl.Pos{Line: 1, Column: 3, Byte: 2}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `[]`, |
| &hcl.BodySchema{}, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 1, Byte: 0}, |
| End: hcl.Pos{Line: 1, Column: 2, Byte: 1}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `[{}]`, |
| &hcl.BodySchema{}, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 1, Byte: 0}, |
| End: hcl.Pos{Line: 1, Column: 2, Byte: 1}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `[[]]`, |
| &hcl.BodySchema{}, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 1, Byte: 0}, |
| End: hcl.Pos{Line: 1, Column: 2, Byte: 1}, |
| }, |
| }, |
| 1, // elements of root array must be objects |
| }, |
| { |
| `{"//": "comment that should be ignored"}`, |
| &hcl.BodySchema{}, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 40, Byte: 39}, |
| End: hcl.Pos{Line: 1, Column: 41, Byte: 40}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"//": "comment that should be ignored", "//": "another comment"}`, |
| &hcl.BodySchema{}, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 65, Byte: 64}, |
| End: hcl.Pos{Line: 1, Column: 66, Byte: 65}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"name":"Ermintrude"}`, |
| &hcl.BodySchema{ |
| Attributes: []hcl.AttributeSchema{ |
| { |
| Name: "name", |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{ |
| "name": &hcl.Attribute{ |
| Name: "name", |
| Expr: &expression{ |
| src: &stringVal{ |
| Value: "Ermintrude", |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 8, |
| Line: 1, |
| Column: 9, |
| }, |
| End: hcl.Pos{ |
| Byte: 20, |
| Line: 1, |
| Column: 21, |
| }, |
| }, |
| }, |
| }, |
| Range: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 20, |
| Line: 1, |
| Column: 21, |
| }, |
| }, |
| NameRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 7, |
| Line: 1, |
| Column: 8, |
| }, |
| }, |
| }, |
| }, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 21, Byte: 20}, |
| End: hcl.Pos{Line: 1, Column: 22, Byte: 21}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `[{"name":"Ermintrude"}]`, |
| &hcl.BodySchema{ |
| Attributes: []hcl.AttributeSchema{ |
| { |
| Name: "name", |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{ |
| "name": &hcl.Attribute{ |
| Name: "name", |
| Expr: &expression{ |
| src: &stringVal{ |
| Value: "Ermintrude", |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 9, |
| Line: 1, |
| Column: 10, |
| }, |
| End: hcl.Pos{ |
| Byte: 21, |
| Line: 1, |
| Column: 22, |
| }, |
| }, |
| }, |
| }, |
| Range: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 2, |
| Line: 1, |
| Column: 3, |
| }, |
| End: hcl.Pos{ |
| Byte: 21, |
| Line: 1, |
| Column: 22, |
| }, |
| }, |
| NameRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 2, |
| Line: 1, |
| Column: 3, |
| }, |
| End: hcl.Pos{ |
| Byte: 8, |
| Line: 1, |
| Column: 9, |
| }, |
| }, |
| }, |
| }, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 1, Byte: 0}, |
| End: hcl.Pos{Line: 1, Column: 2, Byte: 1}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"name":"Ermintrude"}`, |
| &hcl.BodySchema{ |
| Attributes: []hcl.AttributeSchema{ |
| { |
| Name: "name", |
| Required: true, |
| }, |
| { |
| Name: "age", |
| Required: true, |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{ |
| "name": &hcl.Attribute{ |
| Name: "name", |
| Expr: &expression{ |
| src: &stringVal{ |
| Value: "Ermintrude", |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 8, |
| Line: 1, |
| Column: 9, |
| }, |
| End: hcl.Pos{ |
| Byte: 20, |
| Line: 1, |
| Column: 21, |
| }, |
| }, |
| }, |
| }, |
| Range: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 20, |
| Line: 1, |
| Column: 21, |
| }, |
| }, |
| NameRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 7, |
| Line: 1, |
| Column: 8, |
| }, |
| }, |
| }, |
| }, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 21, Byte: 20}, |
| End: hcl.Pos{Line: 1, Column: 22, Byte: 21}, |
| }, |
| }, |
| 1, |
| }, |
| { |
| `{"resource": null}`, |
| &hcl.BodySchema{ |
| Blocks: []hcl.BlockHeaderSchema{ |
| { |
| Type: "resource", |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| // We don't find any blocks if the value is json null. |
| Blocks: nil, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 18, Byte: 17}, |
| End: hcl.Pos{Line: 1, Column: 19, Byte: 18}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"resource": { "nested": null }}`, |
| &hcl.BodySchema{ |
| Blocks: []hcl.BlockHeaderSchema{ |
| { |
| Type: "resource", |
| LabelNames: []string{"name"}, |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| Blocks: nil, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 32, Byte: 31}, |
| End: hcl.Pos{Line: 1, Column: 33, Byte: 32}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"resource":{}}`, |
| &hcl.BodySchema{ |
| Blocks: []hcl.BlockHeaderSchema{ |
| { |
| Type: "resource", |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| Blocks: hcl.Blocks{ |
| { |
| Type: "resource", |
| Labels: []string{}, |
| Body: &body{ |
| val: &objectVal{ |
| Attrs: []*objectAttr{}, |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 12, |
| Line: 1, |
| Column: 13, |
| }, |
| End: hcl.Pos{ |
| Byte: 14, |
| Line: 1, |
| Column: 15, |
| }, |
| }, |
| OpenRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 12, |
| Line: 1, |
| Column: 13, |
| }, |
| End: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| }, |
| CloseRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| End: hcl.Pos{ |
| Byte: 14, |
| Line: 1, |
| Column: 15, |
| }, |
| }, |
| }, |
| }, |
| |
| DefRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 12, |
| Line: 1, |
| Column: 13, |
| }, |
| End: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| }, |
| TypeRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 11, |
| Line: 1, |
| Column: 12, |
| }, |
| }, |
| LabelRanges: []hcl.Range{}, |
| }, |
| }, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 15, Byte: 14}, |
| End: hcl.Pos{Line: 1, Column: 16, Byte: 15}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"resource":[{},{}]}`, |
| &hcl.BodySchema{ |
| Blocks: []hcl.BlockHeaderSchema{ |
| { |
| Type: "resource", |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| Blocks: hcl.Blocks{ |
| { |
| Type: "resource", |
| Labels: []string{}, |
| Body: &body{ |
| val: &objectVal{ |
| Attrs: []*objectAttr{}, |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| End: hcl.Pos{ |
| Byte: 15, |
| Line: 1, |
| Column: 16, |
| }, |
| }, |
| OpenRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| End: hcl.Pos{ |
| Byte: 14, |
| Line: 1, |
| Column: 15, |
| }, |
| }, |
| CloseRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 14, |
| Line: 1, |
| Column: 15, |
| }, |
| End: hcl.Pos{ |
| Byte: 15, |
| Line: 1, |
| Column: 16, |
| }, |
| }, |
| }, |
| }, |
| |
| DefRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 12, |
| Line: 1, |
| Column: 13, |
| }, |
| End: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| }, |
| TypeRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 11, |
| Line: 1, |
| Column: 12, |
| }, |
| }, |
| LabelRanges: []hcl.Range{}, |
| }, |
| { |
| Type: "resource", |
| Labels: []string{}, |
| Body: &body{ |
| val: &objectVal{ |
| Attrs: []*objectAttr{}, |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 16, |
| Line: 1, |
| Column: 17, |
| }, |
| End: hcl.Pos{ |
| Byte: 18, |
| Line: 1, |
| Column: 19, |
| }, |
| }, |
| OpenRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 16, |
| Line: 1, |
| Column: 17, |
| }, |
| End: hcl.Pos{ |
| Byte: 17, |
| Line: 1, |
| Column: 18, |
| }, |
| }, |
| CloseRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 17, |
| Line: 1, |
| Column: 18, |
| }, |
| End: hcl.Pos{ |
| Byte: 18, |
| Line: 1, |
| Column: 19, |
| }, |
| }, |
| }, |
| }, |
| |
| DefRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 12, |
| Line: 1, |
| Column: 13, |
| }, |
| End: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| }, |
| TypeRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 11, |
| Line: 1, |
| Column: 12, |
| }, |
| }, |
| LabelRanges: []hcl.Range{}, |
| }, |
| }, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 20, Byte: 19}, |
| End: hcl.Pos{Line: 1, Column: 21, Byte: 20}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"resource":{"foo_instance":{"bar":{}}}}`, |
| &hcl.BodySchema{ |
| Blocks: []hcl.BlockHeaderSchema{ |
| { |
| Type: "resource", |
| LabelNames: []string{"type", "name"}, |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| Blocks: hcl.Blocks{ |
| { |
| Type: "resource", |
| Labels: []string{"foo_instance", "bar"}, |
| Body: &body{ |
| val: &objectVal{ |
| Attrs: []*objectAttr{}, |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 35, |
| Line: 1, |
| Column: 36, |
| }, |
| End: hcl.Pos{ |
| Byte: 37, |
| Line: 1, |
| Column: 38, |
| }, |
| }, |
| OpenRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 35, |
| Line: 1, |
| Column: 36, |
| }, |
| End: hcl.Pos{ |
| Byte: 36, |
| Line: 1, |
| Column: 37, |
| }, |
| }, |
| CloseRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 36, |
| Line: 1, |
| Column: 37, |
| }, |
| End: hcl.Pos{ |
| Byte: 37, |
| Line: 1, |
| Column: 38, |
| }, |
| }, |
| }, |
| }, |
| |
| DefRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 35, |
| Line: 1, |
| Column: 36, |
| }, |
| End: hcl.Pos{ |
| Byte: 36, |
| Line: 1, |
| Column: 37, |
| }, |
| }, |
| TypeRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 11, |
| Line: 1, |
| Column: 12, |
| }, |
| }, |
| LabelRanges: []hcl.Range{ |
| { |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| End: hcl.Pos{ |
| Byte: 27, |
| Line: 1, |
| Column: 28, |
| }, |
| }, |
| { |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 29, |
| Line: 1, |
| Column: 30, |
| }, |
| End: hcl.Pos{ |
| Byte: 34, |
| Line: 1, |
| Column: 35, |
| }, |
| }, |
| }, |
| }, |
| }, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 40, Byte: 39}, |
| End: hcl.Pos{Line: 1, Column: 41, Byte: 40}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"resource":{"foo_instance":[{"bar":{}}, {"bar":{}}]}}`, |
| &hcl.BodySchema{ |
| Blocks: []hcl.BlockHeaderSchema{ |
| { |
| Type: "resource", |
| LabelNames: []string{"type", "name"}, |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| Blocks: hcl.Blocks{ |
| { |
| Type: "resource", |
| Labels: []string{"foo_instance", "bar"}, |
| Body: &body{ |
| val: &objectVal{ |
| Attrs: []*objectAttr{}, |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 36, |
| Line: 1, |
| Column: 37, |
| }, |
| End: hcl.Pos{ |
| Byte: 38, |
| Line: 1, |
| Column: 39, |
| }, |
| }, |
| OpenRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 36, |
| Line: 1, |
| Column: 37, |
| }, |
| End: hcl.Pos{ |
| Byte: 37, |
| Line: 1, |
| Column: 38, |
| }, |
| }, |
| CloseRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 37, |
| Line: 1, |
| Column: 38, |
| }, |
| End: hcl.Pos{ |
| Byte: 38, |
| Line: 1, |
| Column: 39, |
| }, |
| }, |
| }, |
| }, |
| |
| DefRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 36, |
| Line: 1, |
| Column: 37, |
| }, |
| End: hcl.Pos{ |
| Byte: 37, |
| Line: 1, |
| Column: 38, |
| }, |
| }, |
| TypeRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 11, |
| Line: 1, |
| Column: 12, |
| }, |
| }, |
| LabelRanges: []hcl.Range{ |
| { |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| End: hcl.Pos{ |
| Byte: 27, |
| Line: 1, |
| Column: 28, |
| }, |
| }, |
| { |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 30, |
| Line: 1, |
| Column: 31, |
| }, |
| End: hcl.Pos{ |
| Byte: 35, |
| Line: 1, |
| Column: 36, |
| }, |
| }, |
| }, |
| }, |
| { |
| Type: "resource", |
| Labels: []string{"foo_instance", "bar"}, |
| Body: &body{ |
| val: &objectVal{ |
| Attrs: []*objectAttr{}, |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 36, |
| Line: 1, |
| Column: 37, |
| }, |
| End: hcl.Pos{ |
| Byte: 38, |
| Line: 1, |
| Column: 39, |
| }, |
| }, |
| OpenRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 36, |
| Line: 1, |
| Column: 37, |
| }, |
| End: hcl.Pos{ |
| Byte: 37, |
| Line: 1, |
| Column: 38, |
| }, |
| }, |
| CloseRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 37, |
| Line: 1, |
| Column: 38, |
| }, |
| End: hcl.Pos{ |
| Byte: 38, |
| Line: 1, |
| Column: 39, |
| }, |
| }, |
| }, |
| }, |
| |
| DefRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 48, |
| Line: 1, |
| Column: 49, |
| }, |
| End: hcl.Pos{ |
| Byte: 49, |
| Line: 1, |
| Column: 50, |
| }, |
| }, |
| TypeRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 1, |
| Line: 1, |
| Column: 2, |
| }, |
| End: hcl.Pos{ |
| Byte: 11, |
| Line: 1, |
| Column: 12, |
| }, |
| }, |
| LabelRanges: []hcl.Range{ |
| { |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 13, |
| Line: 1, |
| Column: 14, |
| }, |
| End: hcl.Pos{ |
| Byte: 27, |
| Line: 1, |
| Column: 28, |
| }, |
| }, |
| { |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 42, |
| Line: 1, |
| Column: 43, |
| }, |
| End: hcl.Pos{ |
| Byte: 47, |
| Line: 1, |
| Column: 48, |
| }, |
| }, |
| }, |
| }, |
| }, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 54, Byte: 53}, |
| End: hcl.Pos{Line: 1, Column: 55, Byte: 54}, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"name":"Ermintrude"}`, |
| &hcl.BodySchema{ |
| Blocks: []hcl.BlockHeaderSchema{ |
| { |
| Type: "name", |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{}, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 21, Byte: 20}, |
| End: hcl.Pos{Line: 1, Column: 22, Byte: 21}, |
| }, |
| }, |
| 1, // name is supposed to be a block |
| }, |
| { |
| `[{"name":"Ermintrude"},{"name":"Ermintrude"}]`, |
| &hcl.BodySchema{ |
| Attributes: []hcl.AttributeSchema{ |
| { |
| Name: "name", |
| }, |
| }, |
| }, |
| &hcl.BodyContent{ |
| Attributes: map[string]*hcl.Attribute{ |
| "name": { |
| Name: "name", |
| Expr: &expression{ |
| src: &stringVal{ |
| Value: "Ermintrude", |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 8, |
| Line: 1, |
| Column: 9, |
| }, |
| End: hcl.Pos{ |
| Byte: 20, |
| Line: 1, |
| Column: 21, |
| }, |
| }, |
| }, |
| }, |
| Range: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 2, |
| Line: 1, |
| Column: 3, |
| }, |
| End: hcl.Pos{ |
| Byte: 21, |
| Line: 1, |
| Column: 22, |
| }, |
| }, |
| NameRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{ |
| Byte: 2, |
| Line: 1, |
| Column: 3, |
| }, |
| End: hcl.Pos{ |
| Byte: 8, |
| Line: 1, |
| Column: 9, |
| }, |
| }, |
| }, |
| }, |
| MissingItemRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 1, Byte: 0}, |
| End: hcl.Pos{Line: 1, Column: 2, Byte: 1}, |
| }, |
| }, |
| 1, // "name" attribute is defined twice |
| }, |
| } |
| |
| for i, test := range tests { |
| t.Run(fmt.Sprintf("%02d-%s", i, test.src), func(t *testing.T) { |
| file, diags := Parse([]byte(test.src), "test.json") |
| if len(diags) != 0 { |
| t.Fatalf("Parse produced diagnostics: %s", diags) |
| } |
| got, _, diags := file.Body.PartialContent(test.schema) |
| if len(diags) != test.diagCount { |
| t.Errorf("Wrong number of diagnostics %d; want %d", len(diags), test.diagCount) |
| for _, diag := range diags { |
| t.Logf(" - %s", diag) |
| } |
| } |
| |
| for _, problem := range deep.Equal(got, test.want) { |
| t.Error(problem) |
| } |
| }) |
| } |
| } |
| |
| func TestBodyContent(t *testing.T) { |
| // We test most of the functionality already in TestBodyPartialContent, so |
| // this test focuses on the handling of extraneous attributes. |
| tests := []struct { |
| src string |
| schema *hcl.BodySchema |
| diagCount int |
| }{ |
| { |
| `{"unknown": true}`, |
| &hcl.BodySchema{}, |
| 1, |
| }, |
| { |
| `{"//": "comment that should be ignored"}`, |
| &hcl.BodySchema{}, |
| 0, |
| }, |
| { |
| `{"unknow": true}`, |
| &hcl.BodySchema{ |
| Attributes: []hcl.AttributeSchema{ |
| { |
| Name: "unknown", |
| }, |
| }, |
| }, |
| 1, |
| }, |
| { |
| `{"unknow": true, "unnown": true}`, |
| &hcl.BodySchema{ |
| Attributes: []hcl.AttributeSchema{ |
| { |
| Name: "unknown", |
| }, |
| }, |
| }, |
| 2, |
| }, |
| } |
| |
| for i, test := range tests { |
| t.Run(fmt.Sprintf("%02d-%s", i, test.src), func(t *testing.T) { |
| file, diags := Parse([]byte(test.src), "test.json") |
| if len(diags) != 0 { |
| t.Fatalf("Parse produced diagnostics: %s", diags) |
| } |
| _, diags = file.Body.Content(test.schema) |
| if len(diags) != test.diagCount { |
| t.Errorf("Wrong number of diagnostics %d; want %d", len(diags), test.diagCount) |
| for _, diag := range diags { |
| t.Logf(" - %s", diag) |
| } |
| } |
| }) |
| } |
| } |
| |
| func TestJustAttributes(t *testing.T) { |
| // We test most of the functionality already in TestBodyPartialContent, so |
| // this test focuses on the handling of extraneous attributes. |
| tests := []struct { |
| src string |
| want hcl.Attributes |
| diagCount int |
| }{ |
| { |
| `{}`, |
| map[string]*hcl.Attribute{}, |
| 0, |
| }, |
| { |
| `{"foo": true}`, |
| map[string]*hcl.Attribute{ |
| "foo": { |
| Name: "foo", |
| Expr: &expression{ |
| src: &booleanVal{ |
| Value: true, |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Byte: 8, Line: 1, Column: 9}, |
| End: hcl.Pos{Byte: 12, Line: 1, Column: 13}, |
| }, |
| }, |
| }, |
| Range: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Byte: 1, Line: 1, Column: 2}, |
| End: hcl.Pos{Byte: 12, Line: 1, Column: 13}, |
| }, |
| NameRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Byte: 1, Line: 1, Column: 2}, |
| End: hcl.Pos{Byte: 6, Line: 1, Column: 7}, |
| }, |
| }, |
| }, |
| 0, |
| }, |
| { |
| `{"//": "comment that should be ignored"}`, |
| map[string]*hcl.Attribute{}, |
| 0, |
| }, |
| { |
| `{"foo": true, "foo": true}`, |
| map[string]*hcl.Attribute{ |
| "foo": { |
| Name: "foo", |
| Expr: &expression{ |
| src: &booleanVal{ |
| Value: true, |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Byte: 8, Line: 1, Column: 9}, |
| End: hcl.Pos{Byte: 12, Line: 1, Column: 13}, |
| }, |
| }, |
| }, |
| Range: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Byte: 1, Line: 1, Column: 2}, |
| End: hcl.Pos{Byte: 12, Line: 1, Column: 13}, |
| }, |
| NameRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Byte: 1, Line: 1, Column: 2}, |
| End: hcl.Pos{Byte: 6, Line: 1, Column: 7}, |
| }, |
| }, |
| }, |
| 1, // attribute foo was already defined |
| }, |
| } |
| |
| for i, test := range tests { |
| t.Run(fmt.Sprintf("%02d-%s", i, test.src), func(t *testing.T) { |
| file, diags := Parse([]byte(test.src), "test.json") |
| if len(diags) != 0 { |
| t.Fatalf("Parse produced diagnostics: %s", diags) |
| } |
| got, diags := file.Body.JustAttributes() |
| if len(diags) != test.diagCount { |
| t.Errorf("Wrong number of diagnostics %d; want %d", len(diags), test.diagCount) |
| for _, diag := range diags { |
| t.Logf(" - %s", diag) |
| } |
| } |
| if !reflect.DeepEqual(got, test.want) { |
| t.Errorf("wrong result\ngot: %s\nwant: %s", spew.Sdump(got), spew.Sdump(test.want)) |
| } |
| }) |
| } |
| } |
| |
| func TestExpressionVariables(t *testing.T) { |
| tests := []struct { |
| Src string |
| Want []hcl.Traversal |
| }{ |
| { |
| `{"a":true}`, |
| nil, |
| }, |
| { |
| `{"a":"${foo}"}`, |
| []hcl.Traversal{ |
| { |
| hcl.TraverseRoot{ |
| Name: "foo", |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 9, Byte: 8}, |
| End: hcl.Pos{Line: 1, Column: 12, Byte: 11}, |
| }, |
| }, |
| }, |
| }, |
| }, |
| { |
| `{"a":["${foo}"]}`, |
| []hcl.Traversal{ |
| { |
| hcl.TraverseRoot{ |
| Name: "foo", |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 10, Byte: 9}, |
| End: hcl.Pos{Line: 1, Column: 13, Byte: 12}, |
| }, |
| }, |
| }, |
| }, |
| }, |
| { |
| `{"a":{"b":"${foo}"}}`, |
| []hcl.Traversal{ |
| { |
| hcl.TraverseRoot{ |
| Name: "foo", |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 14, Byte: 13}, |
| End: hcl.Pos{Line: 1, Column: 17, Byte: 16}, |
| }, |
| }, |
| }, |
| }, |
| }, |
| { |
| `{"a":{"${foo}":"b"}}`, |
| []hcl.Traversal{ |
| { |
| hcl.TraverseRoot{ |
| Name: "foo", |
| SrcRange: hcl.Range{ |
| Filename: "test.json", |
| Start: hcl.Pos{Line: 1, Column: 10, Byte: 9}, |
| End: hcl.Pos{Line: 1, Column: 13, Byte: 12}, |
| }, |
| }, |
| }, |
| }, |
| }, |
| } |
| |
| for _, test := range tests { |
| t.Run(test.Src, func(t *testing.T) { |
| file, diags := Parse([]byte(test.Src), "test.json") |
| if len(diags) != 0 { |
| t.Fatalf("Parse produced diagnostics: %s", diags) |
| } |
| attrs, diags := file.Body.JustAttributes() |
| if len(diags) != 0 { |
| t.Fatalf("JustAttributes produced diagnostics: %s", diags) |
| } |
| got := attrs["a"].Expr.Variables() |
| if !reflect.DeepEqual(got, test.Want) { |
| t.Errorf("wrong result\ngot: %s\nwant: %s", spew.Sdump(got), spew.Sdump(test.Want)) |
| } |
| }) |
| } |
| } |
| |
| func TestExpressionAsTraversal(t *testing.T) { |
| e := &expression{ |
| src: &stringVal{ |
| Value: "foo.bar[0]", |
| }, |
| } |
| traversal := e.AsTraversal() |
| if len(traversal) != 3 { |
| t.Fatalf("incorrect traversal %#v; want length 3", traversal) |
| } |
| } |
| |
| func TestStaticExpressionList(t *testing.T) { |
| e := &expression{ |
| src: &arrayVal{ |
| Values: []node{ |
| &stringVal{ |
| Value: "hello", |
| }, |
| }, |
| }, |
| } |
| exprs := e.ExprList() |
| if len(exprs) != 1 { |
| t.Fatalf("incorrect exprs %#v; want length 1", exprs) |
| } |
| if exprs[0].(*expression).src != e.src.(*arrayVal).Values[0] { |
| t.Fatalf("wrong first expression node") |
| } |
| } |
| |
| func TestExpression_Value(t *testing.T) { |
| src := `{ |
| "string": "string_val", |
| "number": 5, |
| "bool_true": true, |
| "bool_false": false, |
| "array": ["a"], |
| "object": {"key": "value"}, |
| "null": null |
| }` |
| expected := map[string]cty.Value{ |
| "string": cty.StringVal("string_val"), |
| "number": cty.NumberIntVal(5), |
| "bool_true": cty.BoolVal(true), |
| "bool_false": cty.BoolVal(false), |
| "array": cty.TupleVal([]cty.Value{cty.StringVal("a")}), |
| "object": cty.ObjectVal(map[string]cty.Value{ |
| "key": cty.StringVal("value"), |
| }), |
| "null": cty.NullVal(cty.DynamicPseudoType), |
| } |
| |
| file, diags := Parse([]byte(src), "") |
| if len(diags) != 0 { |
| t.Errorf("got %d diagnostics on parse; want 0", len(diags)) |
| for _, diag := range diags { |
| t.Logf("- %s", diag.Error()) |
| } |
| } |
| if file == nil { |
| t.Errorf("got nil File; want actual file") |
| } |
| if file.Body == nil { |
| t.Fatalf("got nil Body; want actual body") |
| } |
| attrs, diags := file.Body.JustAttributes() |
| if len(diags) != 0 { |
| t.Errorf("got %d diagnostics on decode; want 0", len(diags)) |
| for _, diag := range diags { |
| t.Logf("- %s", diag.Error()) |
| } |
| } |
| |
| for ek, ev := range expected { |
| val, diags := attrs[ek].Expr.Value(&hcl.EvalContext{}) |
| if len(diags) != 0 { |
| t.Errorf("got %d diagnostics on eval; want 0", len(diags)) |
| for _, diag := range diags { |
| t.Logf("- %s", diag.Error()) |
| } |
| } |
| |
| if !val.RawEquals(ev) { |
| t.Errorf("wrong result %#v; want %#v", val, ev) |
| } |
| } |
| |
| } |
| |
| // TestExpressionValue_Diags asserts that Value() returns diagnostics |
| // from nested evaluations for complex objects (e.g. ObjectVal, ArrayVal) |
| func TestExpressionValue_Diags(t *testing.T) { |
| cases := []struct { |
| name string |
| src string |
| expected cty.Value |
| error string |
| }{ |
| { |
| name: "string: happy", |
| src: `{"v": "happy ${VAR1}"}`, |
| expected: cty.StringVal("happy case"), |
| }, |
| { |
| name: "string: unhappy", |
| src: `{"v": "happy ${UNKNOWN}"}`, |
| expected: cty.UnknownVal(cty.String), |
| error: "Unknown variable", |
| }, |
| { |
| name: "object_val: happy", |
| src: `{"v": {"key": "happy ${VAR1}"}}`, |
| expected: cty.ObjectVal(map[string]cty.Value{ |
| "key": cty.StringVal("happy case"), |
| }), |
| }, |
| { |
| name: "object_val: unhappy", |
| src: `{"v": {"key": "happy ${UNKNOWN}"}}`, |
| expected: cty.ObjectVal(map[string]cty.Value{ |
| "key": cty.UnknownVal(cty.String), |
| }), |
| error: "Unknown variable", |
| }, |
| { |
| name: "object_key: happy", |
| src: `{"v": {"happy ${VAR1}": "val"}}`, |
| expected: cty.ObjectVal(map[string]cty.Value{ |
| "happy case": cty.StringVal("val"), |
| }), |
| }, |
| { |
| name: "object_key: unhappy", |
| src: `{"v": {"happy ${UNKNOWN}": "val"}}`, |
| expected: cty.DynamicVal, |
| error: "Unknown variable", |
| }, |
| { |
| name: "array: happy", |
| src: `{"v": ["happy ${VAR1}"]}`, |
| expected: cty.TupleVal([]cty.Value{cty.StringVal("happy case")}), |
| }, |
| { |
| name: "array: unhappy", |
| src: `{"v": ["happy ${UNKNOWN}"]}`, |
| expected: cty.TupleVal([]cty.Value{cty.UnknownVal(cty.String)}), |
| error: "Unknown variable", |
| }, |
| } |
| |
| ctx := &hcl.EvalContext{ |
| Variables: map[string]cty.Value{ |
| "VAR1": cty.StringVal("case"), |
| }, |
| } |
| |
| for _, c := range cases { |
| t.Run(c.name, func(t *testing.T) { |
| file, diags := Parse([]byte(c.src), "") |
| |
| if len(diags) != 0 { |
| t.Errorf("got %d diagnostics on parse; want 0", len(diags)) |
| for _, diag := range diags { |
| t.Logf("- %s", diag.Error()) |
| } |
| t.FailNow() |
| } |
| if file == nil { |
| t.Errorf("got nil File; want actual file") |
| } |
| if file.Body == nil { |
| t.Fatalf("got nil Body; want actual body") |
| } |
| |
| attrs, diags := file.Body.JustAttributes() |
| if len(diags) != 0 { |
| t.Errorf("got %d diagnostics on decode; want 0", len(diags)) |
| for _, diag := range diags { |
| t.Logf("- %s", diag.Error()) |
| } |
| t.FailNow() |
| } |
| |
| val, diags := attrs["v"].Expr.Value(ctx) |
| if c.error == "" && len(diags) != 0 { |
| t.Errorf("got %d diagnostics on eval; want 0", len(diags)) |
| for _, diag := range diags { |
| t.Logf("- %s", diag.Error()) |
| } |
| t.FailNow() |
| } else if c.error != "" && len(diags) == 0 { |
| t.Fatalf("got 0 diagnostics on eval, want 1 with %s", c.error) |
| } else if c.error != "" && len(diags) != 0 { |
| if !strings.Contains(diags[0].Error(), c.error) { |
| t.Fatalf("found error: %s; want %s", diags[0].Error(), c.error) |
| } |
| } |
| |
| if !val.RawEquals(c.expected) { |
| t.Errorf("wrong result %#v; want %#v", val, c.expected) |
| } |
| }) |
| } |
| |
| } |
