feature_test.go

package geojson

import (
	"bytes"
	"encoding/json"
	"testing"
)

func TestNewFeature(t *testing.T) {
	f := NewFeature(NewPointGeometry([]float64{1, 2}))

	if f.Type != "Feature" {
		t.Errorf("should have type of Feature, got %v", f.Type)
	}
}

func TestFeatureMarshalJSON(t *testing.T) {
	f := NewFeature(NewPointGeometry([]float64{1, 2}))
	blob, err := f.MarshalJSON()

	if err != nil {
		t.Fatalf("should marshal to json just fine but got %v", err)
	}

	if !bytes.Contains(blob, []byte(`"properties":null`)) {
		t.Errorf("json should set properties to null if there are none")
	}
}

func TestFeatureMarshal(t *testing.T) {
	f := NewFeature(NewPointGeometry([]float64{1, 2}))
	blob, err := json.Marshal(f)

	if err != nil {
		t.Fatalf("should marshal to json just fine but got %v", err)
	}

	if !bytes.Contains(blob, []byte(`"properties":null`)) {
		t.Errorf("json should set properties to null if there are none")
	}
}

func TestFeatureMarshalValue(t *testing.T) {
	f := NewFeature(NewPointGeometry([]float64{1, 2}))
	blob, err := json.Marshal(*f)

	if err != nil {
		t.Fatalf("should marshal to json just fine but got %v", err)
	}

	if !bytes.Contains(blob, []byte(`"properties":null`)) {
		t.Errorf("json should set properties to null if there are none")
	}
}

func TestUnmarshalFeature(t *testing.T) {
	rawJSON := `
	  { "type": "Feature",
	    "bbox": [1, 2, 3, 4],
	    "geometry": {"type": "Point", "coordinates": [102.0, 0.5]},
	    "properties": {"prop0": "value0"}
	  }`

	f, err := UnmarshalFeature([]byte(rawJSON))
	if err != nil {
		t.Fatalf("should unmarshal feature without issue, err %v", err)
	}

	if f.Type != "Feature" {
		t.Errorf("should have type of Feature, got %v", f.Type)
	}

	if len(f.Properties) != 1 {
		t.Errorf("should have 1 property but got %d", len(f.Properties))
	}

	if len(f.BoundingBox) != 4 {
		t.Errorf("should have unmarshalled bounding box")
	}
}

func TestUnmarshalFeature2(t *testing.T) {
	rawJSON := `{
		"id": "6cdeb425-0b80-442c-a806-632a8130087d",
		"type": "Feature",
		"bbox": [1, 2, 3, 4],
		"geometry": {
			"type": "Polygon",
			"boundingbox": [],
			"point": [],
			"multipoint": [],
			"linestring": [],
			"multilinestring": [],
			"polygon": [
				[
					[65.0, 22.0],
					[58.0, 22.0],
					[45.0, 15.0],
					[39.0, 15.0],
					[39.0, -5.0],
					[65.0, -5.0],
					[65.0, 22.0]
				]
			],
			"multipolygon": [],
			"geometries": [],
			"crs": {}
		},
		"properties": {"public_zone": true},
		"crs": {}
	}`

	f, err := UnmarshalFeature([]byte(rawJSON))
	if err != nil {
		t.Fatalf("should unmarshal feature without issue, err %v", err)
	}

	if f.Type != "Feature" {
		t.Errorf("should have type of Feature, got %v", f.Type)
	}

	if len(f.Properties) != 1 {
		t.Errorf("should have 1 property but got %d", len(f.Properties))
	}

	if len(f.BoundingBox) != 4 {
		t.Errorf("should have unmarshalled bounding box")
	}
}

func TestMarshalFeatureID(t *testing.T) {
	f := &Feature{
		ID: "asdf",
	}

	data, err := f.MarshalJSON()
	if err != nil {
		t.Fatalf("should marshal, %v", err)
	}

	if !bytes.Equal(data, []byte(`{"id":"asdf","type":"Feature","geometry":null,"properties":null}`)) {
		t.Errorf("data not correct")
		t.Logf("%v", string(data))
	}

	f.ID = 123
	data, err = f.MarshalJSON()
	if err != nil {
		t.Fatalf("should marshal, %v", err)

	}

	if !bytes.Equal(data, []byte(`{"id":123,"type":"Feature","geometry":null,"properties":null}`)) {
		t.Errorf("data not correct")
		t.Logf("%v", string(data))
	}
}

func TestUnmarshalFeatureID(t *testing.T) {
	rawJSON := `
	  { "type": "Feature",
	    "id": 123,
	    "geometry": {"type": "Point", "coordinates": [102.0, 0.5]}
	  }`

	f, err := UnmarshalFeature([]byte(rawJSON))
	if err != nil {
		t.Fatalf("should unmarshal feature without issue, err %v", err)
	}

	if v, ok := f.ID.(float64); !ok || v != 123 {
		t.Errorf("should parse id as number, got %T %f", f.ID, v)
	}

	rawJSON = `
	  { "type": "Feature",
	    "id": "abcd",
	    "geometry": {"type": "Point", "coordinates": [102.0, 0.5]}
	  }`

	f, err = UnmarshalFeature([]byte(rawJSON))
	if err != nil {
		t.Fatalf("should unmarshal feature without issue, err %v", err)
	}

	if v, ok := f.ID.(string); !ok || v != "abcd" {
		t.Errorf("should parse id as string, got %T %s", f.ID, v)
	}
}