Update client to use segment semantics.

README.md

@@ -11,9 +11,9 @@ config := Config{APIKey: "<api-key>" BaseURL: "<url-to-the-rpc>"}
 client, err := NewClient(config)
 ```
 
-### Get Condition Members
+### Get Segment Members
 
-Evaluate a condition and retrieve the members.
+Evaluate a segment's conditions and retrieve its members.
 
 ```golang
 gte := Gte{
@@ -24,12 +24,12 @@ condition := Condition{
     Gte: gte,
 }
 
-result, err := client.GetConditionMembers(condition)
+result, err := client.GetSegmentMembers(condition)
 ```
 
-### Intersect Members to Condition
+### Intersect Members to Segment
 
-Identify the intersection of an array of members to evaluated conditions.
+Identify the intersection of an array of members to a segment's evaluated conditions.
 
 ```go
 intersectMembers := make([]string, 0)
@@ -43,7 +43,7 @@ condition := Condition{
     Gte: gte,
 }
 
-result, err := client.IntersectMembersToCondition(intersectMembers, condition)
+result, err := client.IntersectMembersToSegment(intersectMembers, condition)
 ```
 
 ### Get Member Partitions
@@ -108,3 +108,9 @@ jobID := "0f5f8149-03b7-4809-ae3b-0b319cf062c0"
 
 result, err := client.GetRefreshJob(jobID)
 ```
+
+## Test
+
+```bash
+go test
+```

client_test.go

@@ -17,10 +17,10 @@ func makeCondition() Condition {
 	return c
 }
 
-func TestClient_GetConditionMembers(t *testing.T) {
+func TestClient_GetSegmentMembers(t *testing.T) {
 	client := getClient(t)
 
-	c, err := client.GetConditionMembers(makeCondition())
+	c, err := client.GetSegmentMembers(makeCondition())
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -28,18 +28,18 @@ func TestClient_GetConditionMembers(t *testing.T) {
 		t.Fatal("count is nil")
 	}
 
-	fmt.Fprintln(os.Stdout, "GetConditionMembers")
+	fmt.Fprintln(os.Stdout, "GetSegmentMembers")
 	fmt.Fprintln(os.Stdout, *c)
 	fmt.Println("")
 }
 
-func TestClient_IntersectMembersToCondition(t *testing.T) {
+func TestClient_IntersectMembersToSegment(t *testing.T) {
 	client := getClient(t)
 
 	intersectMembers := make([]string, 0)
 	intersectMembers = append(intersectMembers, "a090b025a1489aa6c9204d7b85ac77d51b814402d5cbdec27335575bb46e4f20")
 
-	c, err := client.IntersectMembersToCondition(intersectMembers, makeCondition())
+	c, err := client.IntersectMembersToSegment(intersectMembers, makeCondition())
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -47,7 +47,7 @@ func TestClient_IntersectMembersToCondition(t *testing.T) {
 		t.Fatal("count is nil")
 	}
 
-	fmt.Fprintln(os.Stdout, "IntersectMembersToCondition")
+	fmt.Fprintln(os.Stdout, "IntersectMembersToSegment")
 	fmt.Fprintln(os.Stdout, *c)
 	fmt.Println("")
 }
@@ -112,22 +112,22 @@ func TestClient_GetDatasets(t *testing.T) {
 // 	fmt.Println("")
 // }
 
-func TestClient_GetRefreshJob(t *testing.T) {
-	client := getClient(t)
-	jobID := "0f5f8149-03b7-4809-ae3b-0b319cf062c0"
+// func TestClient_GetRefreshJob(t *testing.T) {
+// 	client := getClient(t)
+// 	jobID := "0f5f8149-03b7-4809-ae3b-0b319cf062c0"
 
-	c, err := client.GetRefreshJob(jobID)
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-	if c == nil {
-		t.Fatal("count is nil")
-	}
+// 	c, err := client.GetRefreshJob(jobID)
+// 	if err != nil {
+// 		t.Fatalf("Unexpected error: %v", err)
+// 	}
+// 	if c == nil {
+// 		t.Fatal("count is nil")
+// 	}
 
-	fmt.Fprintln(os.Stdout, "GetRefreshJob")
-	fmt.Fprintln(os.Stdout, *c)
-	fmt.Println("")
-}
+// 	fmt.Fprintln(os.Stdout, "GetRefreshJob")
+// 	fmt.Fprintln(os.Stdout, *c)
+// 	fmt.Println("")
+// }
 
 func getClient(t *testing.T) Client {
 	apiKey := os.Getenv("FLIP_API_KEY")

segment.go

@@ -42,55 +42,55 @@ type Condition struct {
 	Lte Lte          `json:"lte"`
 }
 
-// GetConditionMembersResponse returns the RPC response
-type GetConditionMembersResponse struct {
+// GetSegmentMembersResponse returns the RPC response
+type GetSegmentMembersResponse struct {
 	Members     []string `mapstructure:"members"`
 	MemberCount int      `mapstructure:"member_count"`
 }
 
-// GetConditionMembers returns the members belonging to the result set of a condition.
-func (c Client) GetConditionMembers(condition Condition) (*GetConditionMembersResponse, error) {
+// GetSegmentMembers returns the members belonging to the result set of a condition.
+func (c Client) GetSegmentMembers(condition Condition) (*GetSegmentMembersResponse, error) {
 	var input = make(map[string]Condition)
-	input["condition"] = condition
+	input["segment"] = condition
 
-	var conditionMembers GetConditionMembersResponse
+	var segmentMembers GetSegmentMembersResponse
 
-	result, err := c.CallRPC("RPCService.GetConditionMembers", input)
+	result, err := c.CallRPC("RPCService.GetSegmentMembers", input)
 	if err != nil {
-		return &conditionMembers, err
+		return &segmentMembers, err
 	}
 
-	err = mapstructure.Decode(result, &conditionMembers)
+	err = mapstructure.Decode(result, &segmentMembers)
 	if err != nil {
-		return &conditionMembers, errors.Wrap(err, "error decoding into `GetConditionMembersResponse`")
+		return &segmentMembers, errors.Wrap(err, "error decoding into `GetSegmentMembersResponse`")
 	}
 
-	return &conditionMembers, nil
+	return &segmentMembers, nil
 }
 
-// IntersectMembersToConditionResponse returns the RPC response
-type IntersectMembersToConditionResponse struct {
-	ConditionSetCount int      `mapstructure:"condition_set_count"`
-	Matches           []string `mapstructure:"matches"`
-	MatchCount        int      `mapstructure:"match_count"`
+// IntersectMembersToSegmentResponse returns the RPC response
+type IntersectMembersToSegmentResponse struct {
+	SegmentMemberCount int      `mapstructure:"segment_member_count"`
+	Matches            []string `mapstructure:"matches"`
+	MatchCount         int      `mapstructure:"match_count"`
 }
 
-// IntersectMembersToCondition returns the intersection between a set of inputs against conditions
-func (c Client) IntersectMembersToCondition(members []string, condition Condition) (*IntersectMembersToConditionResponse, error) {
+// IntersectMembersToSegment returns the intersection between a set of inputs against a segment formed by conditions
+func (c Client) IntersectMembersToSegment(members []string, condition Condition) (*IntersectMembersToSegmentResponse, error) {
 	var input = make(map[string]interface{})
-	input["condition"] = condition
+	input["segment"] = condition
 	input["members"] = members
 
-	var intersectResponse IntersectMembersToConditionResponse
+	var intersectResponse IntersectMembersToSegmentResponse
 
-	result, err := c.CallRPC("RPCService.IntersectMembersToCondition", input)
+	result, err := c.CallRPC("RPCService.IntersectMembersToSegment", input)
 	if err != nil {
 		return &intersectResponse, err
 	}
 
 	err = mapstructure.Decode(result, &intersectResponse)
 	if err != nil {
-		return &intersectResponse, errors.Wrap(err, "error decoding into `IntersectMembersToConditionResponse`")
+		return &intersectResponse, errors.Wrap(err, "error decoding into `IntersectMembersToSegmentResponse`")
 	}
 
 	return &intersectResponse, nil