github.com/vnpaycloud-console/gophercloud/v2@v2.0.5/openstack/db/v1/configurations/testing/requests_test.go (about)

     1  package testing
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/db/v1/configurations"
     8  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/db/v1/instances"
     9  	"github.com/vnpaycloud-console/gophercloud/v2/pagination"
    10  	th "github.com/vnpaycloud-console/gophercloud/v2/testhelper"
    11  	fake "github.com/vnpaycloud-console/gophercloud/v2/testhelper/client"
    12  	"github.com/vnpaycloud-console/gophercloud/v2/testhelper/fixture"
    13  )
    14  
    15  var (
    16  	configID = "{configID}"
    17  	_baseURL = "/configurations"
    18  	resURL   = _baseURL + "/" + configID
    19  
    20  	dsID               = "{datastoreID}"
    21  	versionID          = "{versionID}"
    22  	paramID            = "{paramID}"
    23  	dsParamListURL     = "/datastores/" + dsID + "/versions/" + versionID + "/parameters"
    24  	dsParamGetURL      = "/datastores/" + dsID + "/versions/" + versionID + "/parameters/" + paramID
    25  	globalParamListURL = "/datastores/versions/" + versionID + "/parameters"
    26  	globalParamGetURL  = "/datastores/versions/" + versionID + "/parameters/" + paramID
    27  )
    28  
    29  func TestList(t *testing.T) {
    30  	th.SetupHTTP()
    31  	defer th.TeardownHTTP()
    32  	fixture.SetupHandler(t, _baseURL, "GET", "", ListConfigsJSON, 200)
    33  
    34  	count := 0
    35  	err := configurations.List(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
    36  		count++
    37  		actual, err := configurations.ExtractConfigs(page)
    38  		th.AssertNoErr(t, err)
    39  
    40  		expected := []configurations.Config{ExampleConfig}
    41  		th.AssertDeepEquals(t, expected, actual)
    42  
    43  		return true, nil
    44  	})
    45  
    46  	th.AssertEquals(t, 1, count)
    47  	th.AssertNoErr(t, err)
    48  }
    49  
    50  func TestGet(t *testing.T) {
    51  	th.SetupHTTP()
    52  	defer th.TeardownHTTP()
    53  	fixture.SetupHandler(t, resURL, "GET", "", GetConfigJSON, 200)
    54  
    55  	config, err := configurations.Get(context.TODO(), fake.ServiceClient(), configID).Extract()
    56  	th.AssertNoErr(t, err)
    57  	th.AssertDeepEquals(t, &ExampleConfig, config)
    58  }
    59  
    60  func TestCreate(t *testing.T) {
    61  	th.SetupHTTP()
    62  	defer th.TeardownHTTP()
    63  	fixture.SetupHandler(t, _baseURL, "POST", CreateReq, CreateConfigJSON, 200)
    64  
    65  	opts := configurations.CreateOpts{
    66  		Datastore: &configurations.DatastoreOpts{
    67  			Type:    "a00000a0-00a0-0a00-00a0-000a000000aa",
    68  			Version: "b00000b0-00b0-0b00-00b0-000b000000bb",
    69  		},
    70  		Description: "example description",
    71  		Name:        "example-configuration-name",
    72  		Values: map[string]any{
    73  			"collation_server": "latin1_swedish_ci",
    74  			"connect_timeout":  120,
    75  		},
    76  	}
    77  
    78  	config, err := configurations.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
    79  	th.AssertNoErr(t, err)
    80  	th.AssertDeepEquals(t, &ExampleConfigWithValues, config)
    81  }
    82  
    83  func TestUpdate(t *testing.T) {
    84  	th.SetupHTTP()
    85  	defer th.TeardownHTTP()
    86  	fixture.SetupHandler(t, resURL, "PATCH", UpdateReq, "", 200)
    87  
    88  	opts := configurations.UpdateOpts{
    89  		Values: map[string]any{
    90  			"connect_timeout": 300,
    91  		},
    92  	}
    93  
    94  	err := configurations.Update(context.TODO(), fake.ServiceClient(), configID, opts).ExtractErr()
    95  	th.AssertNoErr(t, err)
    96  }
    97  
    98  func TestReplace(t *testing.T) {
    99  	th.SetupHTTP()
   100  	defer th.TeardownHTTP()
   101  	fixture.SetupHandler(t, resURL, "PUT", UpdateReq, "", 202)
   102  
   103  	opts := configurations.UpdateOpts{
   104  		Values: map[string]any{
   105  			"connect_timeout": 300,
   106  		},
   107  	}
   108  
   109  	err := configurations.Replace(context.TODO(), fake.ServiceClient(), configID, opts).ExtractErr()
   110  	th.AssertNoErr(t, err)
   111  }
   112  
   113  func TestDelete(t *testing.T) {
   114  	th.SetupHTTP()
   115  	defer th.TeardownHTTP()
   116  	fixture.SetupHandler(t, resURL, "DELETE", "", "", 202)
   117  
   118  	err := configurations.Delete(context.TODO(), fake.ServiceClient(), configID).ExtractErr()
   119  	th.AssertNoErr(t, err)
   120  }
   121  
   122  func TestListInstances(t *testing.T) {
   123  	th.SetupHTTP()
   124  	defer th.TeardownHTTP()
   125  	fixture.SetupHandler(t, resURL+"/instances", "GET", "", ListInstancesJSON, 200)
   126  
   127  	expectedInstance := instances.Instance{
   128  		ID:   "d4603f69-ec7e-4e9b-803f-600b9205576f",
   129  		Name: "json_rack_instance",
   130  	}
   131  
   132  	pages := 0
   133  	err := configurations.ListInstances(fake.ServiceClient(), configID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
   134  		pages++
   135  
   136  		actual, err := instances.ExtractInstances(page)
   137  		if err != nil {
   138  			return false, err
   139  		}
   140  
   141  		th.AssertDeepEquals(t, actual, []instances.Instance{expectedInstance})
   142  
   143  		return true, nil
   144  	})
   145  
   146  	th.AssertNoErr(t, err)
   147  	th.AssertEquals(t, 1, pages)
   148  }
   149  
   150  func TestListDSParams(t *testing.T) {
   151  	th.SetupHTTP()
   152  	defer th.TeardownHTTP()
   153  	fixture.SetupHandler(t, dsParamListURL, "GET", "", ListParamsJSON, 200)
   154  
   155  	pages := 0
   156  	err := configurations.ListDatastoreParams(fake.ServiceClient(), dsID, versionID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
   157  		pages++
   158  
   159  		actual, err := configurations.ExtractParams(page)
   160  		if err != nil {
   161  			return false, err
   162  		}
   163  
   164  		expected := []configurations.Param{
   165  			{Max: 1, Min: 0, Name: "innodb_file_per_table", RestartRequired: true, Type: "integer"},
   166  			{Max: 4294967296, Min: 0, Name: "key_buffer_size", RestartRequired: false, Type: "integer"},
   167  			{Max: 65535, Min: 2, Name: "connect_timeout", RestartRequired: false, Type: "integer"},
   168  			{Max: 4294967296, Min: 0, Name: "join_buffer_size", RestartRequired: false, Type: "integer"},
   169  		}
   170  
   171  		th.AssertDeepEquals(t, actual, expected)
   172  
   173  		return true, nil
   174  	})
   175  
   176  	th.AssertNoErr(t, err)
   177  	th.AssertEquals(t, 1, pages)
   178  }
   179  
   180  func TestGetDSParam(t *testing.T) {
   181  	th.SetupHTTP()
   182  	defer th.TeardownHTTP()
   183  	fixture.SetupHandler(t, dsParamGetURL, "GET", "", GetParamJSON, 200)
   184  
   185  	param, err := configurations.GetDatastoreParam(context.TODO(), fake.ServiceClient(), dsID, versionID, paramID).Extract()
   186  	th.AssertNoErr(t, err)
   187  
   188  	expected := &configurations.Param{
   189  		Max: 1, Min: 0, Name: "innodb_file_per_table", RestartRequired: true, Type: "integer",
   190  	}
   191  
   192  	th.AssertDeepEquals(t, expected, param)
   193  }
   194  
   195  func TestListGlobalParams(t *testing.T) {
   196  	th.SetupHTTP()
   197  	defer th.TeardownHTTP()
   198  	fixture.SetupHandler(t, globalParamListURL, "GET", "", ListParamsJSON, 200)
   199  
   200  	pages := 0
   201  	err := configurations.ListGlobalParams(fake.ServiceClient(), versionID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
   202  		pages++
   203  
   204  		actual, err := configurations.ExtractParams(page)
   205  		if err != nil {
   206  			return false, err
   207  		}
   208  
   209  		expected := []configurations.Param{
   210  			{Max: 1, Min: 0, Name: "innodb_file_per_table", RestartRequired: true, Type: "integer"},
   211  			{Max: 4294967296, Min: 0, Name: "key_buffer_size", RestartRequired: false, Type: "integer"},
   212  			{Max: 65535, Min: 2, Name: "connect_timeout", RestartRequired: false, Type: "integer"},
   213  			{Max: 4294967296, Min: 0, Name: "join_buffer_size", RestartRequired: false, Type: "integer"},
   214  		}
   215  
   216  		th.AssertDeepEquals(t, actual, expected)
   217  
   218  		return true, nil
   219  	})
   220  
   221  	th.AssertNoErr(t, err)
   222  	th.AssertEquals(t, 1, pages)
   223  }
   224  
   225  func TestGetGlobalParam(t *testing.T) {
   226  	th.SetupHTTP()
   227  	defer th.TeardownHTTP()
   228  	fixture.SetupHandler(t, globalParamGetURL, "GET", "", GetParamJSON, 200)
   229  
   230  	param, err := configurations.GetGlobalParam(context.TODO(), fake.ServiceClient(), versionID, paramID).Extract()
   231  	th.AssertNoErr(t, err)
   232  
   233  	expected := &configurations.Param{
   234  		Max: 1, Min: 0, Name: "innodb_file_per_table", RestartRequired: true, Type: "integer",
   235  	}
   236  
   237  	th.AssertDeepEquals(t, expected, param)
   238  }