[IAM] Implement federated provider (#126)

[IAM] Implement federated provider

Which issue this PR fixes

Fixes #123

Reviewed-by: None <None>
Reviewed-by: Anton Sidelnikov <None>
Reviewed-by: Rodion Gyrbu <fpsoff@outlook.com>

Author: outcatcher

acceptance/openstack/identity/v3/fed_providers_test.go

@@ -0,0 +1,68 @@
+package v3
+
+import (
+	"os"
+	"testing"
+
+	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/clients"
+	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/tools"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/identity/v3/federation/providers"
+	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
+)
+
+func TestFederatedProviderLifecycle(t *testing.T) {
+	if os.Getenv("OS_TENANT_ADMIN") == "" {
+		t.Skip("Requires iam:identityProviders:createIdentityProvider permission")
+	}
+
+	client, err := clients.NewIdentityV3Client()
+	th.AssertNoErr(t, err)
+
+	cOpts := providers.CreateOpts{
+		ID:          tools.RandomString("test-", 5),
+		Description: tools.RandomString("This is ", 30),
+		Enabled:     true,
+	}
+
+	provider, err := providers.Create(client, cOpts).Extract()
+	th.AssertNoErr(t, err)
+
+	defer func() {
+		err = providers.Delete(client, provider.ID).ExtractErr()
+		th.AssertNoErr(t, err)
+	}()
+
+	th.AssertEquals(t, cOpts.Enabled, provider.Enabled)
+
+	got, err := providers.Get(client, provider.ID).Extract()
+	th.AssertNoErr(t, err)
+	th.AssertDeepEquals(t, provider, got)
+
+	pages, err := providers.List(client).AllPages()
+	th.AssertNoErr(t, err)
+
+	providerList, err := providers.ExtractProviders(pages)
+	th.AssertNoErr(t, err)
+	found := false
+	for _, p := range providerList {
+		if p.ID == provider.ID {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("created provider not found in the list")
+	}
+
+	iFalse := false
+	uOpts := providers.UpdateOpts{
+		Enabled: &iFalse,
+	}
+	updated, err := providers.Update(client, provider.ID, uOpts).Extract()
+	th.AssertNoErr(t, err)
+	th.AssertEquals(t, false, updated.Enabled)
+
+	got2, err := providers.Get(client, provider.ID).Extract()
+	th.AssertNoErr(t, err)
+	th.AssertDeepEquals(t, updated, got2)
+}

openstack/identity/v3/federation/providers/requests.go

@@ -0,0 +1,83 @@
+package providers
+
+import (
+	"fmt"
+
+	golangsdk "github.com/opentelekomcloud/gophertelekomcloud"
+	"github.com/opentelekomcloud/gophertelekomcloud/pagination"
+)
+
+type CreateOptsBuilder interface {
+	Id() string
+	ToProviderCreateMap() (map[string]interface{}, error)
+}
+
+type CreateOpts struct {
+	ID          string `json:"-"`
+	Description string `json:"description,omitempty"`
+	Enabled     bool   `json:"enabled,omitempty"`
+}
+
+func (opts CreateOpts) ToProviderCreateMap() (map[string]interface{}, error) {
+	return golangsdk.BuildRequestBody(opts, "identity_provider")
+}
+
+func (opts CreateOpts) Id() string {
+	return opts.ID
+}
+
+func Create(client *golangsdk.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
+	if opts.Id() == "" {
+		r.Err = fmt.Errorf("missing identity provider ID")
+		return
+	}
+	b, err := opts.ToProviderCreateMap()
+	if err != nil {
+		r.Err = fmt.Errorf("error building provider create body: %s", err)
+	}
+	_, r.Err = client.Put(providerURL(client, opts.Id()), b, &r.Body, &golangsdk.RequestOpts{
+		OkCodes: []int{201},
+	})
+	return
+}
+
+func Get(client *golangsdk.ServiceClient, id string) (r GetResult) {
+	_, r.Err = client.Get(providerURL(client, id), &r.Body, nil)
+	return
+}
+
+func List(client *golangsdk.ServiceClient) pagination.Pager {
+	return pagination.NewPager(client, listURL(client), func(r pagination.PageResult) pagination.Page {
+		return ProviderPage{pagination.LinkedPageBase{PageResult: r}}
+	})
+}
+
+type UpdateOptsBuilder interface {
+	ToUpdateOptsMap() (map[string]interface{}, error)
+}
+
+type UpdateOpts struct {
+	Description string `json:"description,omitempty"`
+	Enabled     *bool  `json:"enabled,omitempty"`
+}
+
+func (opts UpdateOpts) ToUpdateOptsMap() (map[string]interface{}, error) {
+	return golangsdk.BuildRequestBody(opts, "identity_provider")
+}
+
+func Update(client *golangsdk.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
+	b, err := opts.ToUpdateOptsMap()
+	if err != nil {
+		r.Err = err
+		return
+	}
+	_, r.Err = client.Patch(providerURL(client, id), b, &r.Body, &golangsdk.RequestOpts{
+		OkCodes: []int{200},
+	})
+	return
+}
+
+func Delete(client *golangsdk.ServiceClient, id string) (r DeleteResult) {
+	_, r.Err = client.Delete(providerURL(client, id), nil)
+	return
+}

openstack/identity/v3/federation/providers/results.go

@@ -0,0 +1,57 @@
+package providers
+
+import (
+	golangsdk "github.com/opentelekomcloud/gophertelekomcloud"
+	"github.com/opentelekomcloud/gophertelekomcloud/pagination"
+)
+
+type Provider struct {
+	ID          string            `json:"id"`
+	Description string            `json:"description"`
+	Enabled     bool              `json:"enabled"`
+	RemoteIDs   []string          `json:"remote_ids"`
+	Links       map[string]string `json:"links"`
+}
+
+type commonResult struct {
+	golangsdk.Result
+}
+
+func (r commonResult) Extract() (*Provider, error) {
+	s := new(Provider)
+	return s, r.ExtractIntoStructPtr(s, "identity_provider")
+}
+
+type CreateResult struct {
+	commonResult
+}
+
+type GetResult struct {
+	commonResult
+}
+
+type ProviderPage struct {
+	pagination.LinkedPageBase
+}
+
+func (p ProviderPage) IsEmpty() (bool, error) {
+	providers, err := ExtractProviders(p)
+	if err != nil {
+		return false, err
+	}
+	return len(providers) == 0, err
+}
+
+func ExtractProviders(r pagination.Page) ([]Provider, error) {
+	var providers []Provider
+	err := (r.(ProviderPage)).ExtractIntoSlicePtr(&providers, "identity_providers")
+	return providers, err
+}
+
+type UpdateResult struct {
+	commonResult
+}
+
+type DeleteResult struct {
+	golangsdk.ErrResult
+}

openstack/identity/v3/federation/providers/testing/fixtures.go

@@ -0,0 +1,66 @@
+package testing
+
+import (
+	"fmt"
+	"strings"
+)
+
+const (
+	providerID          = "ACME"
+	providerDescription = "Stores ACME identities"
+
+	listURI = "/OS-FEDERATION/identity_providers"
+)
+
+var (
+	providerURI = fmt.Sprintf("%s/%s", listURI, providerID)
+
+	providerResponse = fmt.Sprintf(`
+{
+    "identity_provider": {
+        "description": "%s",
+        "enabled": true,
+        "id": "%s",
+        "remote_ids": [],
+        "links": {
+            "protocols": "https://example.com/v3/OS-FEDERATION/identity_providers/ACME/protocols",
+            "self": "https://example.com/v3/OS-FEDERATION/identity_providers/ACME"
+        }
+    }
+}
+`, providerDescription, providerID)
+
+	providerListResponse = fmt.Sprintf(`
+{
+    "identity_providers": [
+        {
+            "description": "%s",
+            "enabled": true,
+            "id": "%s",
+            "remote_ids": [],
+            "links": {
+                "protocols": "https://example.com/v3/OS-FEDERATION/identity_providers/ACME/protocols",
+                "self": "https://example.com/v3/OS-FEDERATION/identity_providers/ACME"
+            }
+        },
+        {
+            "description": "Stores contractor identities",
+            "enabled": false,
+            "remote_ids": [],
+            "id": "ACME-contractors",
+            "links": {
+                "protocols": "https://example.com/v3/OS-FEDERATION/identity_providers/ACME-contractors/protocols",
+                "self": "https://example.com/v3/OS-FEDERATION/identity_providers/ACME-contractors"
+            }
+        }
+    ],
+    "links": {
+        "next": null,
+        "previous": null,
+        "self": "https://example.com/v3/OS-FEDERATION/identity_providers"
+    }
+}
+`, providerDescription, providerID)
+
+	updatedProviderResposnse = strings.ReplaceAll(providerResponse, "true", "false")
+)

openstack/identity/v3/federation/providers/testing/requests_test.go

@@ -0,0 +1,109 @@
+package testing
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/identity/v3/federation/providers"
+	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
+	fake "github.com/opentelekomcloud/gophertelekomcloud/testhelper/client"
+)
+
+func TestProviderCreateRequest(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+
+	th.Mux.HandleFunc(providerURI, func(w http.ResponseWriter, r *http.Request) {
+		th.TestMethod(t, r, "PUT")
+		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "Content-Type", "application/json")
+		th.TestHeader(t, r, "Accept", "application/json")
+		w.WriteHeader(201)
+		_, _ = fmt.Fprint(w, providerResponse)
+	})
+
+	opts := providers.CreateOpts{
+		ID:          providerID,
+		Description: providerDescription,
+		Enabled:     true,
+	}
+	p, err := providers.Create(fake.ServiceClient(), opts).Extract()
+	th.AssertNoErr(t, err)
+	th.AssertEquals(t, opts.ID, p.ID)
+	th.AssertEquals(t, opts.Enabled, p.Enabled)
+	th.AssertEquals(t, 0, len(p.RemoteIDs))
+}
+
+func TestProviderGetRequest(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+
+	th.Mux.HandleFunc(providerURI, func(w http.ResponseWriter, r *http.Request) {
+		th.TestMethod(t, r, "GET")
+		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "Accept", "application/json")
+		_, _ = fmt.Fprint(w, providerResponse)
+	})
+
+	p, err := providers.Get(fake.ServiceClient(), providerID).Extract()
+	th.AssertNoErr(t, err)
+	th.AssertEquals(t, true, p.Enabled)
+	th.AssertEquals(t, providerDescription, p.Description)
+}
+
+func TestProviderListRequest(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+
+	th.Mux.HandleFunc(listURI, func(w http.ResponseWriter, r *http.Request) {
+		th.TestMethod(t, r, "GET")
+		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+
+		w.Header().Add("Content-Type", "application/json")
+		_, _ = fmt.Fprint(w, providerListResponse)
+	})
+
+	pages, err := providers.List(fake.ServiceClient()).AllPages()
+	th.AssertNoErr(t, err)
+
+	providerList, err := providers.ExtractProviders(pages)
+	th.AssertNoErr(t, err)
+	th.AssertEquals(t, 2, len(providerList))
+}
+
+func TestProviderUpdateRequest(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+
+	th.Mux.HandleFunc(providerURI, func(w http.ResponseWriter, r *http.Request) {
+		th.TestMethod(t, r, "PATCH")
+		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+
+		w.Header().Add("Content-Type", "application/json")
+		_, _ = fmt.Fprint(w, updatedProviderResposnse)
+	})
+
+	iFalse := false
+	opts := providers.UpdateOpts{
+		Enabled: &iFalse,
+	}
+	p, err := providers.Update(fake.ServiceClient(), providerID, opts).Extract()
+
+	th.AssertNoErr(t, err)
+	th.AssertEquals(t, iFalse, p.Enabled)
+}
+
+func TestProviderDeleteRequest(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+
+	th.Mux.HandleFunc(providerURI, func(w http.ResponseWriter, r *http.Request) {
+		th.TestMethod(t, r, "DELETE")
+		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		w.WriteHeader(204)
+	})
+
+	err := providers.Delete(fake.ServiceClient(), providerID).ExtractErr()
+	th.AssertNoErr(t, err)
+}