restLiClient := &Client{
	// This uses a standard http.Client. Most clients will need to be configured with the right timeouts, TLS
	// contexts, CA certs etc. The following is a recommended configuration that aggressively times out connections
	// and TLS handshakes but not the actual request time, allowing servers to block as long as they want (this is
	// common for actions).
	Client: &http.Client{
		Transport: &http.Transport{
			// This times out connecting to the server
			DialContext: (&net.Dialer{
				Timeout: 10 * time.Second,
			}).DialContext,
			// This times out the TLS handshake
			TLSHandshakeTimeout: 10 * time.Second,
		},
		// Deliberately not set to ensure the client does not have an overall timeout
		Timeout: 0,
	},

	// The HostnameResolver implements locating the host a request should go to. This example always returns the
	// same hostname, but can be implemented in any way shape or form.
	HostnameResolver: &SimpleHostnameResolver{Hostname: hostname},
	// For example, a D2 client can be used to look up hostnames dynamically
	HostnameResolver: d2.Client{Conn: zkConn},

	// This flag toggles returning errors on incomplete/illegal responses from servers. This happens if for whatever
	// reason an endpoint implementation forgot to set a field, or if a field is removed as the API evolves. Because
	// of how often this happens, strict deserialization is disabled by default.
	StrictResponseDeserialization: false,
}

// Now that we have a restli.Client, we can use it to call some resources. Every resource defines a NewClient method
// that takes in a restli.Client
collectionClient := collection.NewClient(restLiClient)
// The returned client wraps the restli client and exposes that resource's methods. All network errors will be
// url.Errors, otherwise they will be corresponding error types declared in the restli package.
msg, err := collectionClient.Get(123)
...

// restli clients can be reused across multiple resources
actionsetClient := actionset.NewClient(restLiClient)

type Resource interface {
	Create(ctx *restli.RequestContext, entity *Message) (createdEntity *CreatedEntity, err error)
	Get(ctx *restli.RequestContext, collectionId int64) (entity *Message, err error)
	Update(ctx *restli.RequestContext, collectionId int64, entity *Message) (err error)
	Delete(ctx *restli.RequestContext, collectionId int64) (err error)
}

type impl map[int64]*Message

func (i impl) Create(ctx *restli.RequestContext, entity *Message) (createdEntity *CreatedEntity, err error) {
	id := rand.Int63()
	i[id] = entity
	// If the Status field of CreatedEntity is not set, it will default to http.StatusCreated
	createdEntity = &CreatedEntity{Id: id}
	// The SetLocation method is used to set (optionally) the Location field, and returns an error if the id cannot be
	// serialized
	_ = restli.SetLocation(ctx, createdEntity)
	return createdEntity, nil
}

func (i impl) Get(ctx *restli.RequestContext, collectionId int64) (entity *Message, err error) {
	if m, ok := i[collectionId]; ok {
		return m, nil
	} else {
		// Returning a *restlidata.ErrorResponse will automatically set the response code and format a restli service
		// error.
		return nil, &restlidata.ErrorResponse{
			Status:  restli.Int32Pointer(http.StatusNotFound),
			Message: restli.StringPointerf("No such message %q", collectionId),
		}
	}
}

func (i impl) Update(ctx *restli.RequestContext, collectionId int64, entity *Message) (err error) {
	// The original request is accessible via the request context. For example, to read any extra headers that may have
	// been added or to get the client certificates to check if the client has access to specific methods
	if err = checkUserCanUpdate(ctx.Request.TLS.PeerCertificates); err != nil {
		return err
	}

	if _, ok := i[collectionId]; ok {
		i[collectionId] = entity
		return nil
	} else {
		return &restlidata.ErrorResponse{
			Status:  restli.Int32Pointer(http.StatusNotFound),
			Message: restli.StringPointerf("No such message %q", collectionId),
		}
	}
}

func (i impl) Delete(ctx *restli.RequestContext, collectionId int64) (err error) {
	// If ctx.ResponseStatus isn't set, Delete will default to http.StatusNoContent. In this case we want to return
	// another status if the key didn't actually exist, but without failing
	if _, ok := i[collectionId]; !ok {
		ctx.ResponseStatus = http.StatusOK
	}
	delete(i, collectionId)
	return nil
}

// When a prefix is specified, the Server will ignore any requests whose path do not start with said prefix. Otherwise
// NewServer defaults to "/"
server := restli.NewPrefixedServer("/api/v1", /* Filters can be added here */)
RegisterResource(server, make(impl))

...

// Once all the resources have been registered, the server can be added to a normal *http.ServeMux:
mux := http.NewServeMux()
server.AddToMux(mux)

// Or if no other endpoints need to be added, the Server can be used to directly serve requests
http.ListenAndServe("localhost:8080", server.Handler())

func (o *Operation) CollectionGet(t *testing.T, c Client) func(*testing.T) *MockResource {
	id := int64(1)
	expected := newMessage(id, "test message")
	res, err := c.Get(id)
	require.NoError(t, err)
	require.Equal(t, expected, res)

	return func(t *testing.T) *MockResource {
		return &MockResource{
			MockGet: func(ctx *restli.RequestContext, collectionId int64) (entity *conflictresolution.Message, err error) {
				require.Equal(t, id, collectionId)
				return expected, nil
			},
		}
	}
}