Exemple #1
0
func TestMemcache(t *testing.T) {
	airfields := []airfield.Airfield{
		airfield.Airfield{ID: "MockID", ShortName: "MockShortName", Name: "MockName",
			Region: "FR", ICAO: "AAAA", Flags: 0, Catalog: 11, Length: 1000, Elevation: 2000,
			Runway: "32R", Frequency: 123.45, Latitude: 32.533, Longitude: 100.376},
	}
	// get the expected geojson to compare at the end
	geojson, _ := spatial.Struct2GeoJSON([]interface{}{
		airfields[0],
	})
	expected, _ := json.MarshalIndent(geojson, "", "\t")

	// using a mock object to return airfields
	mock := &mock.Mock{
		GetAirfieldF: func(regions []string, updatedSince time.Time) ([]airfield.Airfield, error) {
			return airfields, nil
		},
	}

	// use a local memcached server
	cfg := Config{Airfielder: mock, Waypointer: mock, Static: "/tmp", Memcache: "localhost:11211"}
	srv, err := NewServer(cfg)
	if err != nil {
		t.Errorf("failed to init server with memcache :: %v", err)
		return
	}

	resp := httptest.NewRecorder()
	req, _ := http.NewRequest("GET", "/airfield/", nil)
	req.Header.Set("Accept", "application/json")
	srv.mux.ServeHTTP(resp, req)
	r, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		t.Errorf("failed to read response :: %v", err)
		return
	}

	// first we compare the reply with the expected json
	if string(r) != string(expected) {
		t.Errorf("reply expected %v but got %v", string(expected), string(r))
		return
	}

	// then we compare the value in memcache with the expected json
	mclient := memcache.New(cfg.Memcache)
	a, err := mclient.Get(NewCacheResponseWriter(nil, nil, nil).requestKey(req))
	if err != nil {
		t.Errorf("failed to contact memcache :: %v", err)
		return
	}
	if string(a.Value) != string(expected) {
		t.Errorf("memcache expected %v but got %v", string(expected), string(a.Value))
		return
	}
}
Exemple #2
0
// toOutput returns a string representation (in the requested format) of the given content.
// format should be as in the Accept: header (application/json, ...), content is an array
// of Struct which can be Airfield, Waypoint, etc.
func (srv *Server) toOutput(format string, content []interface{}) (string, error) {
	var output string
	switch format {
	case "application/json":
		collection, err := spatial.Struct2GeoJSON(content)
		if err != nil {
			return "", err
		}
		bytes, _ := json.MarshalIndent(collection, "", "\t")
		output = string(bytes)
	//case "application/csv": FIXME: enable csv output
	//output = util.Struct2CSV(content)
	default:
		return "", fmt.Errorf("format %v not supported", format)
	}
	return output, nil
}