This commit is contained in:
Ashish Ranjan 2026-11-06 20:57:15 +00:00 • committed by GitHub
commit faa12f8ab4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 683 additions and 45 deletions

View file

@ -51,6 +51,7 @@ longer signal it.
### Fixed
- **organization_member, organization_member_add**: Refresh now reads `GET /organization/info` instead of returning the state as-is, so a member removed outside Terraform (UI or `/organization/member_delete`) leaves state and the next apply adds it back, and a role changed out of band shows as drift. Members are matched by `user_id`, or by `user_email` (case-insensitive) for email-only members, whose `user_id` the proxy mints. A deleted organization removes its members from state. Deleting a member that is already gone, or whose organization was deleted, now succeeds instead of failing every destroy. An email-only member is tracked by the `user_id` the proxy resolved, kept in the new computed `member_user_ids` map on `litellm_organization_member_add`, so changing their email outside Terraform no longer drops them from state and removal or destroy still revokes their access
- **model**: `additional_drop_params` in `litellm_model.additional_litellm_params` is now sent to the proxy as the deployment's `additional_drop_params` list, the same list a `model_list` entry takes. Before, the provider never sent the list and instead deleted every key it named from `litellm_params`, so a `store` or `vertex_location` listed there was lost and requests still carried the parameters (#38349). The value must be a JSON list of parameter names such as `jsonencode(["store"])`, which `terraform plan` now checks, and `null` entries are skipped as before. When the configuration sets the list, refresh reads the stored list back from the proxy, so a list changed outside Terraform shows up as drift. On a model an older provider created, the proxy has no stored list, so the first plan after upgrading shows the list and every listed key the configuration sets as changes, since that apply writes them. A write-only secret such as `model_api_key_wo` is never shown in a plan
- **user**: `litellm_user` updates no longer send `blocked`, which `/user/update` writes into the user table where no such column exists, so every update failed with a 400 (`Could not find field at upsertOneLiteLLM_UserTable.create.blocked`). Create still sends `blocked`, including `false`, so a `default_internal_user_params.blocked` on the proxy cannot block the auto-created key. Changing `blocked` after creation has no effect, since the proxy has no user-level block; use `litellm_key_block` instead
- **key**: `litellm_key` and `litellm_key_block` drop a key deleted outside Terraform from state again now that `/key/info` serves deleted keys with `status = "deleted"` instead of a 404, so plan recreates it, and destroying a `litellm_key` the proxy already deleted succeeds instead of failing on the 404 `No keys found` from `/key/delete`

View file

@ -9,6 +9,7 @@ import (
"io"
"log"
"net/http"
"net/url"
"regexp"
"strings"
)
@ -62,6 +63,10 @@ func (c *Client) DeleteOrganizationMember(data map[string]interface{}) (map[stri
return c.sendRequest("DELETE", "/organization/member_delete", data)
}
func (c *Client) GetOrganizationInfo(organizationID string) (map[string]interface{}, error) {
return c.sendRequest("GET", fmt.Sprintf("/organization/info?organization_id=%s", url.QueryEscape(organizationID)), nil)
}
// Key-related methods
func (c *Client) CreateKey(key *Key) (*Key, error) {
resp, err := c.sendRequest("POST", "/key/generate", key)

View file

@ -73,9 +73,31 @@ func resourceLiteLLMOrganizationMemberCreate(d *schema.ResourceData, m interface
}
func resourceLiteLLMOrganizationMemberRead(d *schema.ResourceData, m interface{}) error {
// There's no specific endpoint to read a single organization member
// We'll just return the data we have in the state
client := m.(*Client)
log.Printf("[INFO] Reading organization member with ID: %s", d.Id())
orgID := d.Get("organization_id").(string)
members, found, err := fetchOrganizationMembers(client, orgID)
if err != nil {
return err
}
if !found {
log.Printf("[WARN] Organization %s not found, removing member %s from state", orgID, d.Id())
d.SetId("")
return nil
}
member, ok := findOrgMember(members, d.Get("user_id").(string), d.Get("user_email").(string))
if !ok {
log.Printf("[WARN] Organization member %s not found, removing from state", d.Id())
d.SetId("")
return nil
}
if err := d.Set("role", member.Role); err != nil {
return fmt.Errorf("error setting role: %w", err)
}
return nil
}
@ -106,17 +128,9 @@ func resourceLiteLLMOrganizationMemberUpdate(d *schema.ResourceData, m interface
func resourceLiteLLMOrganizationMemberDelete(d *schema.ResourceData, m interface{}) error {
client := m.(*Client)
deleteData := map[string]interface{}{
"user_id": d.Get("user_id").(string),
"user_email": d.Get("user_email").(string),
"organization_id": d.Get("organization_id").(string),
}
log.Printf("[DEBUG] Delete organization member request payload: %+v", deleteData)
_, err := client.DeleteOrganizationMember(deleteData)
err := deleteOrganizationMember(client, d.Get("organization_id").(string), d.Get("user_id").(string), d.Get("user_email").(string))
if err != nil {
return fmt.Errorf("error deleting organization member: %v", err)
return err
}
log.Printf("[INFO] Successfully deleted organization member with ID: %s", d.Id())

View file

@ -3,6 +3,7 @@ package litellm
import (
"fmt"
"log"
"strings"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
@ -46,6 +47,11 @@ func resourceLiteLLMOrganizationMemberAdd() *schema.Resource {
},
},
},
"member_user_ids": {
Type: schema.TypeMap,
Computed: true,
Elem: &schema.Schema{Type: schema.TypeString},
},
},
}
}
@ -93,8 +99,52 @@ func resourceLiteLLMOrganizationMemberAddCreate(d *schema.ResourceData, m interf
}
func resourceLiteLLMOrganizationMemberAddRead(d *schema.ResourceData, m interface{}) error {
// The API doesn't provide a way to read specific organization members easily
// We'll maintain the state as is
client := m.(*Client)
orgID := d.Get("organization_id").(string)
members, found, err := fetchOrganizationMembers(client, orgID)
if err != nil {
return err
}
if !found {
log.Printf("[WARN] Organization %s not found, removing organization members from state", orgID)
d.SetId("")
return nil
}
// Keep only the configured members that are still in the organization,
// each with the role the proxy reports. Members removed out of band drop
// out of state, so the next apply adds them back.
resolvedUserIDs := d.Get("member_user_ids").(map[string]interface{})
current := make([]interface{}, 0)
currentUserIDs := make(map[string]interface{})
for _, member := range d.Get("member").(*schema.Set).List() {
configured := member.(map[string]interface{})
configuredID, _ := configured["user_id"].(string)
configuredEmail, _ := configured["user_email"].(string)
userID, userEmail := orgMemberIdentity(configured, resolvedUserIDs)
existing, ok := findOrgMember(members, userID, userEmail)
if !ok {
log.Printf("[WARN] Organization member (user_id=%q, user_email=%q) not found in organization %s", configuredID, configuredEmail, orgID)
continue
}
current = append(current, map[string]interface{}{
"user_id": configuredID,
"user_email": configuredEmail,
"role": existing.Role,
})
if configuredID == "" {
currentUserIDs[strings.ToLower(configuredEmail)] = existing.UserID
}
}
if err := d.Set("member", current); err != nil {
return fmt.Errorf("error setting member: %w", err)
}
if err := d.Set("member_user_ids", currentUserIDs); err != nil {
return fmt.Errorf("error setting member_user_ids: %w", err)
}
return nil
}
@ -105,6 +155,7 @@ func resourceLiteLLMOrganizationMemberAddUpdate(d *schema.ResourceData, m interf
o, n := d.GetChange("member")
oldMembers := o.(*schema.Set)
newMembers := n.(*schema.Set)
resolvedUserIDs := d.Get("member_user_ids").(map[string]interface{})
// Create maps for easier lookup by user identifier
oldMemberMap := make(map[string]map[string]interface{})
@ -131,21 +182,9 @@ func resourceLiteLLMOrganizationMemberAddUpdate(d *schema.ResourceData, m interf
// Find members to delete (in old but not in new)
for key, oldMember := range oldMemberMap {
if _, exists := newMemberMap[key]; !exists {
deleteData := map[string]interface{}{
"organization_id": orgID,
}
if userID, ok := oldMember["user_id"].(string); ok && userID != "" {
deleteData["user_id"] = userID
}
if userEmail, ok := oldMember["user_email"].(string); ok && userEmail != "" {
deleteData["user_email"] = userEmail
}
log.Printf("[DEBUG] Delete organization member request payload: %+v", deleteData)
_, err := client.DeleteOrganizationMember(deleteData)
if err != nil {
return fmt.Errorf("error deleting organization member: %v", err)
userID, userEmail := orgMemberIdentity(oldMember, resolvedUserIDs)
if err := deleteOrganizationMember(client, orgID, userID, userEmail); err != nil {
return err
}
}
}
@ -159,10 +198,11 @@ func resourceLiteLLMOrganizationMemberAddUpdate(d *schema.ResourceData, m interf
"organization_id": orgID,
"role": newMember["role"].(string),
}
if userID, ok := newMember["user_id"].(string); ok && userID != "" {
userID, userEmail := orgMemberIdentity(newMember, resolvedUserIDs)
if userID != "" {
updateData["user_id"] = userID
}
if userEmail, ok := newMember["user_email"].(string); ok && userEmail != "" {
if userEmail != "" {
updateData["user_email"] = userEmail
}
@ -235,23 +275,13 @@ func resourceLiteLLMOrganizationMemberAddDelete(d *schema.ResourceData, m interf
client := m.(*Client)
orgID := d.Get("organization_id").(string)
members := d.Get("member").(*schema.Set)
resolvedUserIDs := d.Get("member_user_ids").(map[string]interface{})
// Delete each member
for _, member := range members.List() {
m := member.(map[string]interface{})
deleteData := map[string]interface{}{
"organization_id": orgID,
}
if userID, ok := m["user_id"].(string); ok && userID != "" {
deleteData["user_id"] = userID
}
if userEmail, ok := m["user_email"].(string); ok && userEmail != "" {
deleteData["user_email"] = userEmail
}
_, err := client.DeleteOrganizationMember(deleteData)
if err != nil {
return fmt.Errorf("error deleting organization member: %v", err)
userID, userEmail := orgMemberIdentity(member.(map[string]interface{}), resolvedUserIDs)
if err := deleteOrganizationMember(client, orgID, userID, userEmail); err != nil {
return err
}
}

View file

@ -0,0 +1,476 @@
package litellm
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
)
// fakeOrgProxy serves GET /organization/info and DELETE /organization/member_delete
// for a single organization, so Read and Delete can be checked against drift.
type fakeOrgProxy struct {
t *testing.T
orgID string
orgExists bool
members []map[string]interface{}
deleteStatus int
deleteCalls int
deleteBodies []map[string]interface{}
updatedBodies []map[string]interface{}
}
func decodeBody(t *testing.T, r *http.Request) map[string]interface{} {
var body map[string]interface{}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
t.Errorf("decoding %s body: %v", r.URL.Path, err)
}
return body
}
func (p *fakeOrgProxy) serve() *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
switch {
case r.Method == http.MethodGet && r.URL.Path == "/organization/info":
if got := r.URL.Query().Get("organization_id"); got != p.orgID {
p.t.Errorf("organization/info called with organization_id=%q, want %q", got, p.orgID)
}
if !p.orgExists {
w.WriteHeader(http.StatusNotFound)
w.Write([]byte(`{"detail":{"error":"Organization not found"}}`))
return
}
json.NewEncoder(w).Encode(map[string]interface{}{
"organization_id": p.orgID,
"members": p.members,
})
case r.Method == http.MethodDelete && r.URL.Path == "/organization/member_delete":
p.deleteCalls++
p.deleteBodies = append(p.deleteBodies, decodeBody(p.t, r))
status := p.deleteStatus
if status == 0 {
status = http.StatusOK
}
w.WriteHeader(status)
w.Write([]byte(`{}`))
case r.Method == http.MethodPatch && r.URL.Path == "/organization/member_update":
p.updatedBodies = append(p.updatedBodies, decodeBody(p.t, r))
w.Write([]byte(`{}`))
default:
p.t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
w.WriteHeader(http.StatusNotFound)
}
}))
}
func orgMemberRow(userID, email, role string) map[string]interface{} {
return map[string]interface{}{
"user_id": userID,
"organization_id": "org-1",
"user_role": role,
"user": map[string]interface{}{"user_id": userID, "user_email": email},
}
}
func newOrgMemberData(t *testing.T) *schema.ResourceData {
d := schema.TestResourceDataRaw(t, resourceLiteLLMOrganizationMember().Schema, map[string]interface{}{
"organization_id": "org-1",
"user_id": "user-1",
"user_email": "user-1@example.com",
"role": "org_admin",
})
d.SetId("org-1:user-1")
return d
}
func TestOrganizationMemberReadRefreshesRole(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("user-1", "user-1@example.com", "internal_user_viewer"),
}}
srv := proxy.serve()
defer srv.Close()
d := newOrgMemberData(t)
if err := resourceLiteLLMOrganizationMemberRead(d, NewClient(srv.URL, "test-key", true)); err != nil {
t.Fatalf("read failed: %v", err)
}
if d.Id() != "org-1:user-1" {
t.Fatalf("member still in the organization was removed from state")
}
if got := d.Get("role").(string); got != "internal_user_viewer" {
t.Fatalf("role = %q, want the proxy's internal_user_viewer", got)
}
}
func TestOrganizationMemberReadRemovesMemberRemovedOutOfBand(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("user-2", "user-2@example.com", "internal_user"),
}}
srv := proxy.serve()
defer srv.Close()
d := newOrgMemberData(t)
if err := resourceLiteLLMOrganizationMemberRead(d, NewClient(srv.URL, "test-key", true)); err != nil {
t.Fatalf("read failed: %v", err)
}
if d.Id() != "" {
t.Fatalf("member missing from the organization should be removed from state, got ID %q", d.Id())
}
}
func TestOrganizationMemberReadRemovesMemberOfDeletedOrganization(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: false}
srv := proxy.serve()
defer srv.Close()
d := newOrgMemberData(t)
if err := resourceLiteLLMOrganizationMemberRead(d, NewClient(srv.URL, "test-key", true)); err != nil {
t.Fatalf("read failed: %v", err)
}
if d.Id() != "" {
t.Fatalf("member of a deleted organization should be removed from state, got ID %q", d.Id())
}
}
func TestOrganizationMemberDeleteTreatsAlreadyRemovedMemberAsDeleted(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, deleteStatus: http.StatusInternalServerError}
srv := proxy.serve()
defer srv.Close()
d := newOrgMemberData(t)
if err := resourceLiteLLMOrganizationMemberDelete(d, NewClient(srv.URL, "test-key", true)); err != nil {
t.Fatalf("deleting a member that is already gone should succeed, got: %v", err)
}
if proxy.deleteCalls != 1 {
t.Fatalf("expected 1 member_delete call, got %d", proxy.deleteCalls)
}
if d.Id() != "" {
t.Fatalf("ID should be cleared after delete, got %q", d.Id())
}
}
func TestOrganizationMemberDeleteTreatsDeletedOrganizationAsDeleted(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: false, deleteStatus: http.StatusInternalServerError}
srv := proxy.serve()
defer srv.Close()
d := newOrgMemberData(t)
if err := resourceLiteLLMOrganizationMemberDelete(d, NewClient(srv.URL, "test-key", true)); err != nil {
t.Fatalf("deleting a member of a deleted organization should succeed, got: %v", err)
}
}
func TestOrganizationMemberDeleteKeepsErrorWhenMemberStillPresent(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, deleteStatus: http.StatusInternalServerError,
members: []map[string]interface{}{orgMemberRow("user-1", "user-1@example.com", "org_admin")}}
srv := proxy.serve()
defer srv.Close()
d := newOrgMemberData(t)
if err := resourceLiteLLMOrganizationMemberDelete(d, NewClient(srv.URL, "test-key", true)); err == nil {
t.Fatalf("a failed delete of a member that is still present must return an error")
}
}
func TestOrganizationMemberAddReadKeepsOnlyRemainingMembers(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("user-1", "user-1@example.com", "internal_user_viewer"),
// Added by email only: the proxy minted the user_id, and the stored email differs in case.
orgMemberRow("generated-id", "bob@example.com", "internal_user"),
}}
srv := proxy.serve()
defer srv.Close()
d := schema.TestResourceDataRaw(t, resourceLiteLLMOrganizationMemberAdd().Schema, map[string]interface{}{
"organization_id": "org-1",
"member": []interface{}{
map[string]interface{}{"user_id": "user-1", "role": "org_admin"},
map[string]interface{}{"user_id": "user-2", "role": "internal_user"},
map[string]interface{}{"user_email": "Bob@Example.com", "role": "internal_user"},
},
})
d.SetId("org-1")
if err := resourceLiteLLMOrganizationMemberAddRead(d, NewClient(srv.URL, "test-key", true)); err != nil {
t.Fatalf("read failed: %v", err)
}
got := map[string]string{}
for _, raw := range d.Get("member").(*schema.Set).List() {
member := raw.(map[string]interface{})
key := getOrgMemberKey(member)
got[key] = member["role"].(string)
}
want := map[string]string{
"id:user-1": "internal_user_viewer",
"email:Bob@Example.com": "internal_user",
}
if len(got) != len(want) {
t.Fatalf("members in state = %v, want %v", got, want)
}
for key, role := range want {
if got[key] != role {
t.Fatalf("members in state = %v, want %v", got, want)
}
}
}
func TestOrganizationMemberAddReadRemovesDeletedOrganization(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: false}
srv := proxy.serve()
defer srv.Close()
d := schema.TestResourceDataRaw(t, resourceLiteLLMOrganizationMemberAdd().Schema, map[string]interface{}{
"organization_id": "org-1",
"member": []interface{}{
map[string]interface{}{"user_id": "user-1", "role": "org_admin"},
},
})
d.SetId("org-1")
if err := resourceLiteLLMOrganizationMemberAddRead(d, NewClient(srv.URL, "test-key", true)); err != nil {
t.Fatalf("read failed: %v", err)
}
if d.Id() != "" {
t.Fatalf("members of a deleted organization should be removed from state, got ID %q", d.Id())
}
}
func TestOrganizationMemberAddDeleteSkipsMembersAlreadyRemoved(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, deleteStatus: http.StatusInternalServerError}
srv := proxy.serve()
defer srv.Close()
d := schema.TestResourceDataRaw(t, resourceLiteLLMOrganizationMemberAdd().Schema, map[string]interface{}{
"organization_id": "org-1",
"member": []interface{}{
map[string]interface{}{"user_id": "user-1", "role": "org_admin"},
map[string]interface{}{"user_email": "bob@example.com", "role": "internal_user"},
},
})
d.SetId("org-1")
if err := resourceLiteLLMOrganizationMemberAddDelete(d, NewClient(srv.URL, "test-key", true)); err != nil {
t.Fatalf("deleting members that are already gone should succeed, got: %v", err)
}
if proxy.deleteCalls != 2 {
t.Fatalf("expected 2 member_delete calls, got %d", proxy.deleteCalls)
}
}
func emailOnlyMember(email, role string) map[string]interface{} {
return map[string]interface{}{"user_email": email, "role": role}
}
// refreshedEmailOnlyState applies the config, reads it back from the proxy, and
// returns the state Terraform would persist.
func refreshedEmailOnlyState(t *testing.T, client *Client, members ...interface{}) *terraform.InstanceState {
d := schema.TestResourceDataRaw(t, resourceLiteLLMOrganizationMemberAdd().Schema, map[string]interface{}{
"organization_id": "org-1",
"member": members,
})
d.SetId("org-1")
if err := resourceLiteLLMOrganizationMemberAddRead(d, client); err != nil {
t.Fatalf("read failed: %v", err)
}
return d.State()
}
func orgMemberAddDataFromState(t *testing.T, state *terraform.InstanceState) *schema.ResourceData {
d, err := schema.InternalMap(resourceLiteLLMOrganizationMemberAdd().Schema).Data(state, nil)
if err != nil {
t.Fatalf("loading state: %v", err)
}
return d
}
func orgMemberAddDataWithConfig(t *testing.T, state *terraform.InstanceState, members ...interface{}) *schema.ResourceData {
internal := schema.InternalMap(resourceLiteLLMOrganizationMemberAdd().Schema)
config := terraform.NewResourceConfigRaw(map[string]interface{}{"organization_id": "org-1", "member": members})
diff, err := internal.Diff(context.Background(), state, config, nil, nil, true)
if err != nil {
t.Fatalf("diffing config: %v", err)
}
d, err := internal.Data(state, diff)
if err != nil {
t.Fatalf("loading state with diff: %v", err)
}
return d
}
func TestOrganizationMemberAddReadKeepsEmailOnlyMemberAfterEmailChange(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("generated-id", "bob@example.com", "internal_user"),
}}
srv := proxy.serve()
defer srv.Close()
client := NewClient(srv.URL, "test-key", true)
state := refreshedEmailOnlyState(t, client, emailOnlyMember("Bob@Example.com", "internal_user"))
proxy.members = []map[string]interface{}{orgMemberRow("generated-id", "bob-new@example.com", "internal_user_viewer")}
d := orgMemberAddDataFromState(t, state)
if err := resourceLiteLLMOrganizationMemberAddRead(d, client); err != nil {
t.Fatalf("read failed: %v", err)
}
list := d.Get("member").(*schema.Set).List()
if len(list) != 1 {
t.Fatalf("member whose email changed should stay in state, got %v", list)
}
member := list[0].(map[string]interface{})
if member["user_email"] != "Bob@Example.com" || member["role"] != "internal_user_viewer" {
t.Fatalf("member = %v, want the configured email with the proxy's role", member)
}
}
func TestOrganizationMemberAddReadDoesNotRebindResolvedIDByEmail(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("old-id", "bob@example.com", "org_admin"),
}}
srv := proxy.serve()
defer srv.Close()
client := NewClient(srv.URL, "test-key", true)
state := refreshedEmailOnlyState(t, client, emailOnlyMember("bob@example.com", "org_admin"))
proxy.members = []map[string]interface{}{orgMemberRow("other-id", "BOB@example.com", "internal_user")}
d := orgMemberAddDataFromState(t, state)
if err := resourceLiteLLMOrganizationMemberAddRead(d, client); err != nil {
t.Fatalf("read failed: %v", err)
}
if got := d.Get("member").(*schema.Set).Len(); got != 0 {
t.Fatalf("member whose resolved user_id is gone should leave state, %d left", got)
}
if got := d.Get("member_user_ids").(map[string]interface{}); len(got) != 0 {
t.Fatalf("another membership with the same email must not be tracked, got %v", got)
}
}
func TestOrganizationMemberAddReadDropsEmailOnlyMemberRemovedOutOfBand(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("generated-id", "bob@example.com", "internal_user"),
}}
srv := proxy.serve()
defer srv.Close()
client := NewClient(srv.URL, "test-key", true)
state := refreshedEmailOnlyState(t, client, emailOnlyMember("bob@example.com", "internal_user"))
proxy.members = nil
d := orgMemberAddDataFromState(t, state)
if err := resourceLiteLLMOrganizationMemberAddRead(d, client); err != nil {
t.Fatalf("read failed: %v", err)
}
if got := d.Get("member").(*schema.Set).Len(); got != 0 {
t.Fatalf("member removed out of band should leave state, %d left", got)
}
if got := d.Get("member_user_ids").(map[string]interface{}); len(got) != 0 {
t.Fatalf("resolved user_ids of a removed member should be dropped, got %v", got)
}
}
func TestOrganizationMemberAddDeleteRevokesByResolvedIDAfterEmailChange(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("generated-id", "bob@example.com", "internal_user"),
}}
srv := proxy.serve()
defer srv.Close()
client := NewClient(srv.URL, "test-key", true)
state := refreshedEmailOnlyState(t, client, emailOnlyMember("bob@example.com", "internal_user"))
proxy.members = []map[string]interface{}{orgMemberRow("generated-id", "bob-new@example.com", "internal_user")}
if err := resourceLiteLLMOrganizationMemberAddDelete(orgMemberAddDataFromState(t, state), client); err != nil {
t.Fatalf("delete failed: %v", err)
}
if len(proxy.deleteBodies) != 1 || proxy.deleteBodies[0]["user_id"] != "generated-id" {
t.Fatalf("delete bodies = %v, want one delete by generated-id", proxy.deleteBodies)
}
if _, sent := proxy.deleteBodies[0]["user_email"]; sent {
t.Fatalf("delete should not send the stale email, got %v", proxy.deleteBodies[0])
}
}
func TestOrganizationMemberAddDeleteKeepsErrorWhenEmailChangedMemberStillPresent(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("generated-id", "bob@example.com", "internal_user"),
}}
srv := proxy.serve()
defer srv.Close()
client := NewClient(srv.URL, "test-key", true)
state := refreshedEmailOnlyState(t, client, emailOnlyMember("bob@example.com", "internal_user"))
proxy.members = []map[string]interface{}{orgMemberRow("generated-id", "bob-new@example.com", "internal_user")}
proxy.deleteStatus = http.StatusInternalServerError
if err := resourceLiteLLMOrganizationMemberAddDelete(orgMemberAddDataFromState(t, state), client); err == nil {
t.Fatalf("a failed delete of a member still in the organization must return an error")
}
}
func TestOrganizationMemberAddUpdateUsesResolvedIDAfterEmailChange(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("generated-id", "bob@example.com", "internal_user"),
orgMemberRow("generated-id-2", "carol@example.com", "internal_user"),
}}
srv := proxy.serve()
defer srv.Close()
client := NewClient(srv.URL, "test-key", true)
state := refreshedEmailOnlyState(t, client,
emailOnlyMember("bob@example.com", "internal_user"),
emailOnlyMember("carol@example.com", "internal_user"),
)
proxy.members = []map[string]interface{}{
orgMemberRow("generated-id", "bob-new@example.com", "internal_user"),
orgMemberRow("generated-id-2", "carol-new@example.com", "internal_user"),
}
d := orgMemberAddDataWithConfig(t, state, emailOnlyMember("carol@example.com", "org_admin"))
if err := resourceLiteLLMOrganizationMemberAddUpdate(d, client); err != nil {
t.Fatalf("update failed: %v", err)
}
if len(proxy.deleteBodies) != 1 || proxy.deleteBodies[0]["user_id"] != "generated-id" {
t.Fatalf("delete bodies = %v, want one delete by generated-id", proxy.deleteBodies)
}
if len(proxy.updatedBodies) != 1 || proxy.updatedBodies[0]["user_id"] != "generated-id-2" {
t.Fatalf("update bodies = %v, want one update by generated-id-2", proxy.updatedBodies)
}
}
func TestOrganizationMemberAddPlansNoChangesAfterEmailChange(t *testing.T) {
proxy := &fakeOrgProxy{t: t, orgID: "org-1", orgExists: true, members: []map[string]interface{}{
orgMemberRow("generated-id", "bob@example.com", "internal_user"),
}}
srv := proxy.serve()
defer srv.Close()
client := NewClient(srv.URL, "test-key", true)
state := refreshedEmailOnlyState(t, client, emailOnlyMember("bob@example.com", "internal_user"))
proxy.members = []map[string]interface{}{orgMemberRow("generated-id", "bob-new@example.com", "internal_user")}
d := orgMemberAddDataFromState(t, state)
if err := resourceLiteLLMOrganizationMemberAddRead(d, client); err != nil {
t.Fatalf("read failed: %v", err)
}
config := terraform.NewResourceConfigRaw(map[string]interface{}{
"organization_id": "org-1",
"member": []interface{}{emailOnlyMember("bob@example.com", "internal_user")},
})
internal := schema.InternalMap(resourceLiteLLMOrganizationMemberAdd().Schema)
diff, err := internal.Diff(context.Background(), d.State(), config, nil, nil, true)
if err != nil {
t.Fatalf("diffing config: %v", err)
}
if diff != nil && !diff.Empty() {
t.Fatalf("plan after an email change should be empty, got %v", diff)
}
}

View file

@ -0,0 +1,112 @@
package litellm
import (
"fmt"
"log"
"strings"
)
// orgMembership is one row of the members list returned by GET /organization/info.
type orgMembership struct {
UserID string
UserEmail string
Role string
}
// fetchOrganizationMembers returns the current members of an organization.
// found is false when the proxy reports that the organization does not exist.
func fetchOrganizationMembers(client *Client, organizationID string) (members []orgMembership, found bool, err error) {
resp, err := client.GetOrganizationInfo(organizationID)
if err != nil {
if isNotFound(err) {
return nil, false, nil
}
return nil, false, fmt.Errorf("error reading organization %s: %w", organizationID, err)
}
rawMembers, _ := resp["members"].([]interface{})
for _, raw := range rawMembers {
row, ok := raw.(map[string]interface{})
if !ok {
continue
}
member := orgMembership{}
member.UserID, _ = row["user_id"].(string)
member.Role, _ = row["user_role"].(string)
if user, ok := row["user"].(map[string]interface{}); ok {
member.UserEmail, _ = user["user_email"].(string)
}
members = append(members, member)
}
return members, true, nil
}
// findOrgMember matches by user_id when one is given, otherwise by user_email
// (case-insensitive). The proxy mints a user_id for members added by email
// only, so email-only configuration has to be matched on the email.
func findOrgMember(members []orgMembership, userID, userEmail string) (orgMembership, bool) {
for _, member := range members {
if userID != "" {
if member.UserID == userID {
return member, true
}
continue
}
if userEmail != "" && strings.EqualFold(member.UserEmail, userEmail) {
return member, true
}
}
return orgMembership{}, false
}
// orgMemberIdentity returns how to address a configured member on the proxy.
// An email-only member is addressed by the user_id the proxy resolved, because
// the email can change while the user_id and the membership stay the same.
func orgMemberIdentity(member, resolvedUserIDs map[string]interface{}) (userID, userEmail string) {
userID, _ = member["user_id"].(string)
userEmail, _ = member["user_email"].(string)
if userID != "" {
return userID, userEmail
}
if resolved, ok := resolvedUserIDs[strings.ToLower(userEmail)].(string); ok && resolved != "" {
return resolved, ""
}
return "", userEmail
}
// deleteOrganizationMember removes a member and treats a member (or
// organization) that is already gone as deleted. The proxy fails the delete
// in that case, which would otherwise block every destroy until the resource
// is removed from state by hand.
func deleteOrganizationMember(client *Client, organizationID, userID, userEmail string) error {
deleteData := map[string]interface{}{
"organization_id": organizationID,
}
if userID != "" {
deleteData["user_id"] = userID
}
if userEmail != "" {
deleteData["user_email"] = userEmail
}
log.Printf("[DEBUG] Delete organization member request payload: %+v", deleteData)
_, deleteErr := client.DeleteOrganizationMember(deleteData)
if deleteErr == nil {
return nil
}
members, found, err := fetchOrganizationMembers(client, organizationID)
if err != nil {
return fmt.Errorf("error deleting organization member: %v", deleteErr)
}
if !found {
log.Printf("[WARN] Organization %s no longer exists, treating member as deleted", organizationID)
return nil
}
if _, stillMember := findOrgMember(members, userID, userEmail); !stillMember {
log.Printf("[WARN] Member (user_id=%q, user_email=%q) is no longer in organization %s, treating as deleted", userID, userEmail, organizationID)
return nil
}
return fmt.Errorf("error deleting organization member: %v", deleteErr)
}