Skip to content

Commit a24011e

Browse files
stainless-app[bot]stainless-bot
stainless-app[bot]
authored and
stainless-bot
committedNov 20, 2024·
feat(api): api update (#3638)
·
v4.2.0v4.0.0
1 parent 0368162 commit a24011e

23 files changed

+19936
-3046
lines changed
 

‎.stats.yml

+2-2
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,2 @@
1-
configured_endpoints: 1408
2-
openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare%2Fcloudflare-9482a52799bf82c48325ec6462f86b2c70ade8214816411c9b104620ac94f73e.yml
1+
configured_endpoints: 1448
2+
openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare%2Fcloudflare-46a81b24a8d697e3c5a31b8d3d7342a90e5af1e669ff4e463a6809cf6cb03771.yml

‎api.md

+131-6
Large diffs are not rendered by default.

‎filters/filter.go

+677
Large diffs are not rendered by default.

‎filters/filter_test.go

+213
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,213 @@
1+
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2+
3+
package filters_test
4+
5+
import (
6+
"context"
7+
"errors"
8+
"os"
9+
"testing"
10+
11+
"github.com/cloudflare/cloudflare-go/v3"
12+
"github.com/cloudflare/cloudflare-go/v3/filters"
13+
"github.com/cloudflare/cloudflare-go/v3/internal/testutil"
14+
"github.com/cloudflare/cloudflare-go/v3/option"
15+
)
16+
17+
func TestFilterNew(t *testing.T) {
18+
t.Skip("TODO: investigate broken test")
19+
baseURL := "http://localhost:4010"
20+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
21+
baseURL = envURL
22+
}
23+
if !testutil.CheckTestServer(t, baseURL) {
24+
return
25+
}
26+
client := cloudflare.NewClient(
27+
option.WithBaseURL(baseURL),
28+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
29+
option.WithAPIEmail("user@example.com"),
30+
)
31+
_, err := client.Filters.New(context.TODO(), filters.FilterNewParams{
32+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
33+
Expression: cloudflare.F("(http.request.uri.path ~ \".*wp-login.php\" or http.request.uri.path ~ \".*xmlrpc.php\") and ip.addr ne 172.16.22.155"),
34+
})
35+
if err != nil {
36+
var apierr *cloudflare.Error
37+
if errors.As(err, &apierr) {
38+
t.Log(string(apierr.DumpRequest(true)))
39+
}
40+
t.Fatalf("err should be nil: %s", err.Error())
41+
}
42+
}
43+
44+
func TestFilterUpdate(t *testing.T) {
45+
t.Skip("TODO: investigate broken test")
46+
baseURL := "http://localhost:4010"
47+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
48+
baseURL = envURL
49+
}
50+
if !testutil.CheckTestServer(t, baseURL) {
51+
return
52+
}
53+
client := cloudflare.NewClient(
54+
option.WithBaseURL(baseURL),
55+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
56+
option.WithAPIEmail("user@example.com"),
57+
)
58+
_, err := client.Filters.Update(
59+
context.TODO(),
60+
"372e67954025e0ba6aaa6d586b9e0b61",
61+
filters.FilterUpdateParams{
62+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
63+
Body: map[string]interface{}{},
64+
},
65+
)
66+
if err != nil {
67+
var apierr *cloudflare.Error
68+
if errors.As(err, &apierr) {
69+
t.Log(string(apierr.DumpRequest(true)))
70+
}
71+
t.Fatalf("err should be nil: %s", err.Error())
72+
}
73+
}
74+
75+
func TestFilterListWithOptionalParams(t *testing.T) {
76+
baseURL := "http://localhost:4010"
77+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
78+
baseURL = envURL
79+
}
80+
if !testutil.CheckTestServer(t, baseURL) {
81+
return
82+
}
83+
client := cloudflare.NewClient(
84+
option.WithBaseURL(baseURL),
85+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
86+
option.WithAPIEmail("user@example.com"),
87+
)
88+
_, err := client.Filters.List(context.TODO(), filters.FilterListParams{
89+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
90+
ID: cloudflare.F("372e67954025e0ba6aaa6d586b9e0b61"),
91+
Description: cloudflare.F("browsers"),
92+
Expression: cloudflare.F("php"),
93+
Page: cloudflare.F(1.000000),
94+
Paused: cloudflare.F(false),
95+
PerPage: cloudflare.F(5.000000),
96+
Ref: cloudflare.F("FIL-100"),
97+
})
98+
if err != nil {
99+
var apierr *cloudflare.Error
100+
if errors.As(err, &apierr) {
101+
t.Log(string(apierr.DumpRequest(true)))
102+
}
103+
t.Fatalf("err should be nil: %s", err.Error())
104+
}
105+
}
106+
107+
func TestFilterDelete(t *testing.T) {
108+
baseURL := "http://localhost:4010"
109+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
110+
baseURL = envURL
111+
}
112+
if !testutil.CheckTestServer(t, baseURL) {
113+
return
114+
}
115+
client := cloudflare.NewClient(
116+
option.WithBaseURL(baseURL),
117+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
118+
option.WithAPIEmail("user@example.com"),
119+
)
120+
_, err := client.Filters.Delete(
121+
context.TODO(),
122+
"372e67954025e0ba6aaa6d586b9e0b61",
123+
filters.FilterDeleteParams{
124+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
125+
},
126+
)
127+
if err != nil {
128+
var apierr *cloudflare.Error
129+
if errors.As(err, &apierr) {
130+
t.Log(string(apierr.DumpRequest(true)))
131+
}
132+
t.Fatalf("err should be nil: %s", err.Error())
133+
}
134+
}
135+
136+
func TestFilterBulkDelete(t *testing.T) {
137+
baseURL := "http://localhost:4010"
138+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
139+
baseURL = envURL
140+
}
141+
if !testutil.CheckTestServer(t, baseURL) {
142+
return
143+
}
144+
client := cloudflare.NewClient(
145+
option.WithBaseURL(baseURL),
146+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
147+
option.WithAPIEmail("user@example.com"),
148+
)
149+
_, err := client.Filters.BulkDelete(context.TODO(), filters.FilterBulkDeleteParams{
150+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
151+
})
152+
if err != nil {
153+
var apierr *cloudflare.Error
154+
if errors.As(err, &apierr) {
155+
t.Log(string(apierr.DumpRequest(true)))
156+
}
157+
t.Fatalf("err should be nil: %s", err.Error())
158+
}
159+
}
160+
161+
func TestFilterBulkUpdate(t *testing.T) {
162+
baseURL := "http://localhost:4010"
163+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
164+
baseURL = envURL
165+
}
166+
if !testutil.CheckTestServer(t, baseURL) {
167+
return
168+
}
169+
client := cloudflare.NewClient(
170+
option.WithBaseURL(baseURL),
171+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
172+
option.WithAPIEmail("user@example.com"),
173+
)
174+
_, err := client.Filters.BulkUpdate(context.TODO(), filters.FilterBulkUpdateParams{
175+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
176+
})
177+
if err != nil {
178+
var apierr *cloudflare.Error
179+
if errors.As(err, &apierr) {
180+
t.Log(string(apierr.DumpRequest(true)))
181+
}
182+
t.Fatalf("err should be nil: %s", err.Error())
183+
}
184+
}
185+
186+
func TestFilterGet(t *testing.T) {
187+
baseURL := "http://localhost:4010"
188+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
189+
baseURL = envURL
190+
}
191+
if !testutil.CheckTestServer(t, baseURL) {
192+
return
193+
}
194+
client := cloudflare.NewClient(
195+
option.WithBaseURL(baseURL),
196+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
197+
option.WithAPIEmail("user@example.com"),
198+
)
199+
_, err := client.Filters.Get(
200+
context.TODO(),
201+
"372e67954025e0ba6aaa6d586b9e0b61",
202+
filters.FilterGetParams{
203+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
204+
},
205+
)
206+
if err != nil {
207+
var apierr *cloudflare.Error
208+
if errors.As(err, &apierr) {
209+
t.Log(string(apierr.DumpRequest(true)))
210+
}
211+
t.Fatalf("err should be nil: %s", err.Error())
212+
}
213+
}

‎firewall/accessrule.go

+1,547-81
Large diffs are not rendered by default.

‎firewall/accessrule_test.go

+96
Original file line numberDiff line numberDiff line change
@@ -82,3 +82,99 @@ func TestAccessRuleListWithOptionalParams(t *testing.T) {
8282
t.Fatalf("err should be nil: %s", err.Error())
8383
}
8484
}
85+
86+
func TestAccessRuleDeleteWithOptionalParams(t *testing.T) {
87+
t.Skip("TODO: investigate broken test")
88+
baseURL := "http://localhost:4010"
89+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
90+
baseURL = envURL
91+
}
92+
if !testutil.CheckTestServer(t, baseURL) {
93+
return
94+
}
95+
client := cloudflare.NewClient(
96+
option.WithBaseURL(baseURL),
97+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
98+
option.WithAPIEmail("user@example.com"),
99+
)
100+
_, err := client.Firewall.AccessRules.Delete(
101+
context.TODO(),
102+
"023e105f4ecef8ad9ca31a8372d0c353",
103+
firewall.AccessRuleDeleteParams{
104+
AccountID: cloudflare.F("account_id"),
105+
},
106+
)
107+
if err != nil {
108+
var apierr *cloudflare.Error
109+
if errors.As(err, &apierr) {
110+
t.Log(string(apierr.DumpRequest(true)))
111+
}
112+
t.Fatalf("err should be nil: %s", err.Error())
113+
}
114+
}
115+
116+
func TestAccessRuleEditWithOptionalParams(t *testing.T) {
117+
t.Skip("TODO: investigate broken test")
118+
baseURL := "http://localhost:4010"
119+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
120+
baseURL = envURL
121+
}
122+
if !testutil.CheckTestServer(t, baseURL) {
123+
return
124+
}
125+
client := cloudflare.NewClient(
126+
option.WithBaseURL(baseURL),
127+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
128+
option.WithAPIEmail("user@example.com"),
129+
)
130+
_, err := client.Firewall.AccessRules.Edit(
131+
context.TODO(),
132+
"023e105f4ecef8ad9ca31a8372d0c353",
133+
firewall.AccessRuleEditParams{
134+
Configuration: cloudflare.F[firewall.AccessRuleEditParamsConfigurationUnion](firewall.AccessRuleIPConfigurationParam{
135+
Target: cloudflare.F(firewall.AccessRuleIPConfigurationTargetIP),
136+
Value: cloudflare.F("198.51.100.4"),
137+
}),
138+
Mode: cloudflare.F(firewall.AccessRuleEditParamsModeBlock),
139+
AccountID: cloudflare.F("account_id"),
140+
Notes: cloudflare.F("This rule is enabled because of an event that occurred on date X."),
141+
},
142+
)
143+
if err != nil {
144+
var apierr *cloudflare.Error
145+
if errors.As(err, &apierr) {
146+
t.Log(string(apierr.DumpRequest(true)))
147+
}
148+
t.Fatalf("err should be nil: %s", err.Error())
149+
}
150+
}
151+
152+
func TestAccessRuleGetWithOptionalParams(t *testing.T) {
153+
t.Skip("TODO: investigate broken test")
154+
baseURL := "http://localhost:4010"
155+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
156+
baseURL = envURL
157+
}
158+
if !testutil.CheckTestServer(t, baseURL) {
159+
return
160+
}
161+
client := cloudflare.NewClient(
162+
option.WithBaseURL(baseURL),
163+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
164+
option.WithAPIEmail("user@example.com"),
165+
)
166+
_, err := client.Firewall.AccessRules.Get(
167+
context.TODO(),
168+
"023e105f4ecef8ad9ca31a8372d0c353",
169+
firewall.AccessRuleGetParams{
170+
AccountID: cloudflare.F("account_id"),
171+
},
172+
)
173+
if err != nil {
174+
var apierr *cloudflare.Error
175+
if errors.As(err, &apierr) {
176+
t.Log(string(apierr.DumpRequest(true)))
177+
}
178+
t.Fatalf("err should be nil: %s", err.Error())
179+
}
180+
}

‎firewall/lockdown.go

+646
Large diffs are not rendered by default.

‎firewall/lockdown_test.go

+176
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,176 @@
1+
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2+
3+
package firewall_test
4+
5+
import (
6+
"context"
7+
"errors"
8+
"os"
9+
"testing"
10+
"time"
11+
12+
"github.com/cloudflare/cloudflare-go/v3"
13+
"github.com/cloudflare/cloudflare-go/v3/firewall"
14+
"github.com/cloudflare/cloudflare-go/v3/internal/testutil"
15+
"github.com/cloudflare/cloudflare-go/v3/option"
16+
)
17+
18+
func TestLockdownNew(t *testing.T) {
19+
t.Skip("TODO: investigate broken test")
20+
baseURL := "http://localhost:4010"
21+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
22+
baseURL = envURL
23+
}
24+
if !testutil.CheckTestServer(t, baseURL) {
25+
return
26+
}
27+
client := cloudflare.NewClient(
28+
option.WithBaseURL(baseURL),
29+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
30+
option.WithAPIEmail("user@example.com"),
31+
)
32+
_, err := client.Firewall.Lockdowns.New(context.TODO(), firewall.LockdownNewParams{
33+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
34+
Configurations: cloudflare.F([]firewall.ConfigurationItemUnionParam{firewall.LockdownIPConfigurationParam{
35+
Target: cloudflare.F(firewall.LockdownIPConfigurationTargetIP),
36+
Value: cloudflare.F("198.51.100.4"),
37+
}}),
38+
URLs: cloudflare.F([]firewall.OverrideURLParam{"shop.example.com/*"}),
39+
})
40+
if err != nil {
41+
var apierr *cloudflare.Error
42+
if errors.As(err, &apierr) {
43+
t.Log(string(apierr.DumpRequest(true)))
44+
}
45+
t.Fatalf("err should be nil: %s", err.Error())
46+
}
47+
}
48+
49+
func TestLockdownUpdate(t *testing.T) {
50+
t.Skip("TODO: investigate broken test")
51+
baseURL := "http://localhost:4010"
52+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
53+
baseURL = envURL
54+
}
55+
if !testutil.CheckTestServer(t, baseURL) {
56+
return
57+
}
58+
client := cloudflare.NewClient(
59+
option.WithBaseURL(baseURL),
60+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
61+
option.WithAPIEmail("user@example.com"),
62+
)
63+
_, err := client.Firewall.Lockdowns.Update(
64+
context.TODO(),
65+
"372e67954025e0ba6aaa6d586b9e0b59",
66+
firewall.LockdownUpdateParams{
67+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
68+
Configurations: cloudflare.F([]firewall.ConfigurationItemUnionParam{firewall.LockdownIPConfigurationParam{
69+
Target: cloudflare.F(firewall.LockdownIPConfigurationTargetIP),
70+
Value: cloudflare.F("198.51.100.4"),
71+
}}),
72+
URLs: cloudflare.F([]firewall.OverrideURLParam{"shop.example.com/*"}),
73+
},
74+
)
75+
if err != nil {
76+
var apierr *cloudflare.Error
77+
if errors.As(err, &apierr) {
78+
t.Log(string(apierr.DumpRequest(true)))
79+
}
80+
t.Fatalf("err should be nil: %s", err.Error())
81+
}
82+
}
83+
84+
func TestLockdownListWithOptionalParams(t *testing.T) {
85+
baseURL := "http://localhost:4010"
86+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
87+
baseURL = envURL
88+
}
89+
if !testutil.CheckTestServer(t, baseURL) {
90+
return
91+
}
92+
client := cloudflare.NewClient(
93+
option.WithBaseURL(baseURL),
94+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
95+
option.WithAPIEmail("user@example.com"),
96+
)
97+
_, err := client.Firewall.Lockdowns.List(context.TODO(), firewall.LockdownListParams{
98+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
99+
CreatedOn: cloudflare.F(time.Now()),
100+
Description: cloudflare.F("endpoints"),
101+
DescriptionSearch: cloudflare.F("endpoints"),
102+
IP: cloudflare.F("1.2.3.4"),
103+
IPRangeSearch: cloudflare.F("1.2.3.0/16"),
104+
IPSearch: cloudflare.F("1.2.3.4"),
105+
ModifiedOn: cloudflare.F(time.Now()),
106+
Page: cloudflare.F(1.000000),
107+
PerPage: cloudflare.F(1.000000),
108+
Priority: cloudflare.F(5.000000),
109+
URISearch: cloudflare.F("/some/path"),
110+
})
111+
if err != nil {
112+
var apierr *cloudflare.Error
113+
if errors.As(err, &apierr) {
114+
t.Log(string(apierr.DumpRequest(true)))
115+
}
116+
t.Fatalf("err should be nil: %s", err.Error())
117+
}
118+
}
119+
120+
func TestLockdownDelete(t *testing.T) {
121+
baseURL := "http://localhost:4010"
122+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
123+
baseURL = envURL
124+
}
125+
if !testutil.CheckTestServer(t, baseURL) {
126+
return
127+
}
128+
client := cloudflare.NewClient(
129+
option.WithBaseURL(baseURL),
130+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
131+
option.WithAPIEmail("user@example.com"),
132+
)
133+
_, err := client.Firewall.Lockdowns.Delete(
134+
context.TODO(),
135+
"372e67954025e0ba6aaa6d586b9e0b59",
136+
firewall.LockdownDeleteParams{
137+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
138+
},
139+
)
140+
if err != nil {
141+
var apierr *cloudflare.Error
142+
if errors.As(err, &apierr) {
143+
t.Log(string(apierr.DumpRequest(true)))
144+
}
145+
t.Fatalf("err should be nil: %s", err.Error())
146+
}
147+
}
148+
149+
func TestLockdownGet(t *testing.T) {
150+
baseURL := "http://localhost:4010"
151+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
152+
baseURL = envURL
153+
}
154+
if !testutil.CheckTestServer(t, baseURL) {
155+
return
156+
}
157+
client := cloudflare.NewClient(
158+
option.WithBaseURL(baseURL),
159+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
160+
option.WithAPIEmail("user@example.com"),
161+
)
162+
_, err := client.Firewall.Lockdowns.Get(
163+
context.TODO(),
164+
"372e67954025e0ba6aaa6d586b9e0b59",
165+
firewall.LockdownGetParams{
166+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
167+
},
168+
)
169+
if err != nil {
170+
var apierr *cloudflare.Error
171+
if errors.As(err, &apierr) {
172+
t.Log(string(apierr.DumpRequest(true)))
173+
}
174+
t.Fatalf("err should be nil: %s", err.Error())
175+
}
176+
}

‎firewall/rule.go

+1,146
Large diffs are not rendered by default.

‎firewall/rule_test.go

+297
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,297 @@
1+
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2+
3+
package firewall_test
4+
5+
import (
6+
"context"
7+
"errors"
8+
"os"
9+
"testing"
10+
11+
"github.com/cloudflare/cloudflare-go/v3"
12+
"github.com/cloudflare/cloudflare-go/v3/filters"
13+
"github.com/cloudflare/cloudflare-go/v3/firewall"
14+
"github.com/cloudflare/cloudflare-go/v3/internal/testutil"
15+
"github.com/cloudflare/cloudflare-go/v3/option"
16+
)
17+
18+
func TestRuleNewWithOptionalParams(t *testing.T) {
19+
t.Skip("TODO: investigate broken test")
20+
baseURL := "http://localhost:4010"
21+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
22+
baseURL = envURL
23+
}
24+
if !testutil.CheckTestServer(t, baseURL) {
25+
return
26+
}
27+
client := cloudflare.NewClient(
28+
option.WithBaseURL(baseURL),
29+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
30+
option.WithAPIEmail("user@example.com"),
31+
)
32+
_, err := client.Firewall.Rules.New(context.TODO(), firewall.RuleNewParams{
33+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
34+
Action: cloudflare.F(firewall.RuleNewParamsAction{
35+
Mode: cloudflare.F(firewall.RuleNewParamsActionModeSimulate),
36+
Response: cloudflare.F(firewall.RuleNewParamsActionResponse{
37+
Body: cloudflare.F("<error>This request has been rate-limited.</error>"),
38+
ContentType: cloudflare.F("text/xml"),
39+
}),
40+
Timeout: cloudflare.F(86400.000000),
41+
}),
42+
Filter: cloudflare.F(filters.FirewallFilterParam{
43+
Description: cloudflare.F("Restrict access from these browsers on this address range."),
44+
Expression: cloudflare.F("(http.request.uri.path ~ \".*wp-login.php\" or http.request.uri.path ~ \".*xmlrpc.php\") and ip.addr ne 172.16.22.155"),
45+
Paused: cloudflare.F(false),
46+
Ref: cloudflare.F("FIL-100"),
47+
}),
48+
})
49+
if err != nil {
50+
var apierr *cloudflare.Error
51+
if errors.As(err, &apierr) {
52+
t.Log(string(apierr.DumpRequest(true)))
53+
}
54+
t.Fatalf("err should be nil: %s", err.Error())
55+
}
56+
}
57+
58+
func TestRuleUpdateWithOptionalParams(t *testing.T) {
59+
t.Skip("TODO: investigate broken test")
60+
baseURL := "http://localhost:4010"
61+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
62+
baseURL = envURL
63+
}
64+
if !testutil.CheckTestServer(t, baseURL) {
65+
return
66+
}
67+
client := cloudflare.NewClient(
68+
option.WithBaseURL(baseURL),
69+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
70+
option.WithAPIEmail("user@example.com"),
71+
)
72+
_, err := client.Firewall.Rules.Update(
73+
context.TODO(),
74+
"372e67954025e0ba6aaa6d586b9e0b60",
75+
firewall.RuleUpdateParams{
76+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
77+
Action: cloudflare.F(firewall.RuleUpdateParamsAction{
78+
Mode: cloudflare.F(firewall.RuleUpdateParamsActionModeSimulate),
79+
Response: cloudflare.F(firewall.RuleUpdateParamsActionResponse{
80+
Body: cloudflare.F("<error>This request has been rate-limited.</error>"),
81+
ContentType: cloudflare.F("text/xml"),
82+
}),
83+
Timeout: cloudflare.F(86400.000000),
84+
}),
85+
Filter: cloudflare.F(filters.FirewallFilterParam{
86+
Description: cloudflare.F("Restrict access from these browsers on this address range."),
87+
Expression: cloudflare.F("(http.request.uri.path ~ \".*wp-login.php\" or http.request.uri.path ~ \".*xmlrpc.php\") and ip.addr ne 172.16.22.155"),
88+
Paused: cloudflare.F(false),
89+
Ref: cloudflare.F("FIL-100"),
90+
}),
91+
},
92+
)
93+
if err != nil {
94+
var apierr *cloudflare.Error
95+
if errors.As(err, &apierr) {
96+
t.Log(string(apierr.DumpRequest(true)))
97+
}
98+
t.Fatalf("err should be nil: %s", err.Error())
99+
}
100+
}
101+
102+
func TestRuleListWithOptionalParams(t *testing.T) {
103+
baseURL := "http://localhost:4010"
104+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
105+
baseURL = envURL
106+
}
107+
if !testutil.CheckTestServer(t, baseURL) {
108+
return
109+
}
110+
client := cloudflare.NewClient(
111+
option.WithBaseURL(baseURL),
112+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
113+
option.WithAPIEmail("user@example.com"),
114+
)
115+
_, err := client.Firewall.Rules.List(context.TODO(), firewall.RuleListParams{
116+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
117+
ID: cloudflare.F("372e67954025e0ba6aaa6d586b9e0b60"),
118+
Action: cloudflare.F("block"),
119+
Description: cloudflare.F("mir"),
120+
Page: cloudflare.F(1.000000),
121+
Paused: cloudflare.F(false),
122+
PerPage: cloudflare.F(5.000000),
123+
})
124+
if err != nil {
125+
var apierr *cloudflare.Error
126+
if errors.As(err, &apierr) {
127+
t.Log(string(apierr.DumpRequest(true)))
128+
}
129+
t.Fatalf("err should be nil: %s", err.Error())
130+
}
131+
}
132+
133+
func TestRuleDelete(t *testing.T) {
134+
baseURL := "http://localhost:4010"
135+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
136+
baseURL = envURL
137+
}
138+
if !testutil.CheckTestServer(t, baseURL) {
139+
return
140+
}
141+
client := cloudflare.NewClient(
142+
option.WithBaseURL(baseURL),
143+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
144+
option.WithAPIEmail("user@example.com"),
145+
)
146+
_, err := client.Firewall.Rules.Delete(
147+
context.TODO(),
148+
"372e67954025e0ba6aaa6d586b9e0b60",
149+
firewall.RuleDeleteParams{
150+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
151+
},
152+
)
153+
if err != nil {
154+
var apierr *cloudflare.Error
155+
if errors.As(err, &apierr) {
156+
t.Log(string(apierr.DumpRequest(true)))
157+
}
158+
t.Fatalf("err should be nil: %s", err.Error())
159+
}
160+
}
161+
162+
func TestRuleBulkDelete(t *testing.T) {
163+
baseURL := "http://localhost:4010"
164+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
165+
baseURL = envURL
166+
}
167+
if !testutil.CheckTestServer(t, baseURL) {
168+
return
169+
}
170+
client := cloudflare.NewClient(
171+
option.WithBaseURL(baseURL),
172+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
173+
option.WithAPIEmail("user@example.com"),
174+
)
175+
_, err := client.Firewall.Rules.BulkDelete(context.TODO(), firewall.RuleBulkDeleteParams{
176+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
177+
})
178+
if err != nil {
179+
var apierr *cloudflare.Error
180+
if errors.As(err, &apierr) {
181+
t.Log(string(apierr.DumpRequest(true)))
182+
}
183+
t.Fatalf("err should be nil: %s", err.Error())
184+
}
185+
}
186+
187+
func TestRuleBulkEdit(t *testing.T) {
188+
baseURL := "http://localhost:4010"
189+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
190+
baseURL = envURL
191+
}
192+
if !testutil.CheckTestServer(t, baseURL) {
193+
return
194+
}
195+
client := cloudflare.NewClient(
196+
option.WithBaseURL(baseURL),
197+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
198+
option.WithAPIEmail("user@example.com"),
199+
)
200+
_, err := client.Firewall.Rules.BulkEdit(context.TODO(), firewall.RuleBulkEditParams{
201+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
202+
Body: map[string]interface{}{},
203+
})
204+
if err != nil {
205+
var apierr *cloudflare.Error
206+
if errors.As(err, &apierr) {
207+
t.Log(string(apierr.DumpRequest(true)))
208+
}
209+
t.Fatalf("err should be nil: %s", err.Error())
210+
}
211+
}
212+
213+
func TestRuleBulkUpdate(t *testing.T) {
214+
baseURL := "http://localhost:4010"
215+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
216+
baseURL = envURL
217+
}
218+
if !testutil.CheckTestServer(t, baseURL) {
219+
return
220+
}
221+
client := cloudflare.NewClient(
222+
option.WithBaseURL(baseURL),
223+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
224+
option.WithAPIEmail("user@example.com"),
225+
)
226+
_, err := client.Firewall.Rules.BulkUpdate(context.TODO(), firewall.RuleBulkUpdateParams{
227+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
228+
Body: map[string]interface{}{},
229+
})
230+
if err != nil {
231+
var apierr *cloudflare.Error
232+
if errors.As(err, &apierr) {
233+
t.Log(string(apierr.DumpRequest(true)))
234+
}
235+
t.Fatalf("err should be nil: %s", err.Error())
236+
}
237+
}
238+
239+
func TestRuleEdit(t *testing.T) {
240+
t.Skip("TODO: investigate broken test")
241+
baseURL := "http://localhost:4010"
242+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
243+
baseURL = envURL
244+
}
245+
if !testutil.CheckTestServer(t, baseURL) {
246+
return
247+
}
248+
client := cloudflare.NewClient(
249+
option.WithBaseURL(baseURL),
250+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
251+
option.WithAPIEmail("user@example.com"),
252+
)
253+
_, err := client.Firewall.Rules.Edit(
254+
context.TODO(),
255+
"372e67954025e0ba6aaa6d586b9e0b60",
256+
firewall.RuleEditParams{
257+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
258+
},
259+
)
260+
if err != nil {
261+
var apierr *cloudflare.Error
262+
if errors.As(err, &apierr) {
263+
t.Log(string(apierr.DumpRequest(true)))
264+
}
265+
t.Fatalf("err should be nil: %s", err.Error())
266+
}
267+
}
268+
269+
func TestRuleGetWithOptionalParams(t *testing.T) {
270+
baseURL := "http://localhost:4010"
271+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
272+
baseURL = envURL
273+
}
274+
if !testutil.CheckTestServer(t, baseURL) {
275+
return
276+
}
277+
client := cloudflare.NewClient(
278+
option.WithBaseURL(baseURL),
279+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
280+
option.WithAPIEmail("user@example.com"),
281+
)
282+
_, err := client.Firewall.Rules.Get(
283+
context.TODO(),
284+
"372e67954025e0ba6aaa6d586b9e0b60",
285+
firewall.RuleGetParams{
286+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
287+
ID: cloudflare.F("372e67954025e0ba6aaa6d586b9e0b60"),
288+
},
289+
)
290+
if err != nil {
291+
var apierr *cloudflare.Error
292+
if errors.As(err, &apierr) {
293+
t.Log(string(apierr.DumpRequest(true)))
294+
}
295+
t.Fatalf("err should be nil: %s", err.Error())
296+
}
297+
}

‎firewall/uarule.go

+585
Large diffs are not rendered by default.

‎firewall/uarule_test.go

+169
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,169 @@
1+
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2+
3+
package firewall_test
4+
5+
import (
6+
"context"
7+
"errors"
8+
"os"
9+
"testing"
10+
11+
"github.com/cloudflare/cloudflare-go/v3"
12+
"github.com/cloudflare/cloudflare-go/v3/firewall"
13+
"github.com/cloudflare/cloudflare-go/v3/internal/testutil"
14+
"github.com/cloudflare/cloudflare-go/v3/option"
15+
)
16+
17+
func TestUARuleNewWithOptionalParams(t *testing.T) {
18+
t.Skip("TODO: investigate broken test")
19+
baseURL := "http://localhost:4010"
20+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
21+
baseURL = envURL
22+
}
23+
if !testutil.CheckTestServer(t, baseURL) {
24+
return
25+
}
26+
client := cloudflare.NewClient(
27+
option.WithBaseURL(baseURL),
28+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
29+
option.WithAPIEmail("user@example.com"),
30+
)
31+
_, err := client.Firewall.UARules.New(context.TODO(), firewall.UARuleNewParams{
32+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
33+
Configuration: cloudflare.F[firewall.UARuleNewParamsConfigurationUnion](firewall.AccessRuleIPConfigurationParam{
34+
Target: cloudflare.F(firewall.AccessRuleIPConfigurationTargetIP),
35+
Value: cloudflare.F("198.51.100.4"),
36+
}),
37+
Mode: cloudflare.F(firewall.UARuleNewParamsModeBlock),
38+
})
39+
if err != nil {
40+
var apierr *cloudflare.Error
41+
if errors.As(err, &apierr) {
42+
t.Log(string(apierr.DumpRequest(true)))
43+
}
44+
t.Fatalf("err should be nil: %s", err.Error())
45+
}
46+
}
47+
48+
func TestUARuleUpdateWithOptionalParams(t *testing.T) {
49+
t.Skip("TODO: investigate broken test")
50+
baseURL := "http://localhost:4010"
51+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
52+
baseURL = envURL
53+
}
54+
if !testutil.CheckTestServer(t, baseURL) {
55+
return
56+
}
57+
client := cloudflare.NewClient(
58+
option.WithBaseURL(baseURL),
59+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
60+
option.WithAPIEmail("user@example.com"),
61+
)
62+
_, err := client.Firewall.UARules.Update(
63+
context.TODO(),
64+
"372e67954025e0ba6aaa6d586b9e0b59",
65+
firewall.UARuleUpdateParams{
66+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
67+
Configuration: cloudflare.F[firewall.UARuleUpdateParamsConfigurationUnion](firewall.AccessRuleIPConfigurationParam{
68+
Target: cloudflare.F(firewall.AccessRuleIPConfigurationTargetIP),
69+
Value: cloudflare.F("198.51.100.4"),
70+
}),
71+
Mode: cloudflare.F(firewall.UARuleUpdateParamsModeBlock),
72+
},
73+
)
74+
if err != nil {
75+
var apierr *cloudflare.Error
76+
if errors.As(err, &apierr) {
77+
t.Log(string(apierr.DumpRequest(true)))
78+
}
79+
t.Fatalf("err should be nil: %s", err.Error())
80+
}
81+
}
82+
83+
func TestUARuleListWithOptionalParams(t *testing.T) {
84+
baseURL := "http://localhost:4010"
85+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
86+
baseURL = envURL
87+
}
88+
if !testutil.CheckTestServer(t, baseURL) {
89+
return
90+
}
91+
client := cloudflare.NewClient(
92+
option.WithBaseURL(baseURL),
93+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
94+
option.WithAPIEmail("user@example.com"),
95+
)
96+
_, err := client.Firewall.UARules.List(context.TODO(), firewall.UARuleListParams{
97+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
98+
Description: cloudflare.F("abusive"),
99+
DescriptionSearch: cloudflare.F("abusive"),
100+
Page: cloudflare.F(1.000000),
101+
PerPage: cloudflare.F(1.000000),
102+
UASearch: cloudflare.F("Safari"),
103+
})
104+
if err != nil {
105+
var apierr *cloudflare.Error
106+
if errors.As(err, &apierr) {
107+
t.Log(string(apierr.DumpRequest(true)))
108+
}
109+
t.Fatalf("err should be nil: %s", err.Error())
110+
}
111+
}
112+
113+
func TestUARuleDelete(t *testing.T) {
114+
baseURL := "http://localhost:4010"
115+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
116+
baseURL = envURL
117+
}
118+
if !testutil.CheckTestServer(t, baseURL) {
119+
return
120+
}
121+
client := cloudflare.NewClient(
122+
option.WithBaseURL(baseURL),
123+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
124+
option.WithAPIEmail("user@example.com"),
125+
)
126+
_, err := client.Firewall.UARules.Delete(
127+
context.TODO(),
128+
"372e67954025e0ba6aaa6d586b9e0b59",
129+
firewall.UARuleDeleteParams{
130+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
131+
},
132+
)
133+
if err != nil {
134+
var apierr *cloudflare.Error
135+
if errors.As(err, &apierr) {
136+
t.Log(string(apierr.DumpRequest(true)))
137+
}
138+
t.Fatalf("err should be nil: %s", err.Error())
139+
}
140+
}
141+
142+
func TestUARuleGet(t *testing.T) {
143+
baseURL := "http://localhost:4010"
144+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
145+
baseURL = envURL
146+
}
147+
if !testutil.CheckTestServer(t, baseURL) {
148+
return
149+
}
150+
client := cloudflare.NewClient(
151+
option.WithBaseURL(baseURL),
152+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
153+
option.WithAPIEmail("user@example.com"),
154+
)
155+
_, err := client.Firewall.UARules.Get(
156+
context.TODO(),
157+
"372e67954025e0ba6aaa6d586b9e0b59",
158+
firewall.UARuleGetParams{
159+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
160+
},
161+
)
162+
if err != nil {
163+
var apierr *cloudflare.Error
164+
if errors.As(err, &apierr) {
165+
t.Log(string(apierr.DumpRequest(true)))
166+
}
167+
t.Fatalf("err should be nil: %s", err.Error())
168+
}
169+
}

‎firewall/wafoverride.go

+604
Large diffs are not rendered by default.

‎firewall/wafoverride_test.go

+169
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,169 @@
1+
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2+
3+
package firewall_test
4+
5+
import (
6+
"context"
7+
"errors"
8+
"os"
9+
"testing"
10+
11+
"github.com/cloudflare/cloudflare-go/v3"
12+
"github.com/cloudflare/cloudflare-go/v3/firewall"
13+
"github.com/cloudflare/cloudflare-go/v3/internal/testutil"
14+
"github.com/cloudflare/cloudflare-go/v3/option"
15+
)
16+
17+
func TestWAFOverrideNew(t *testing.T) {
18+
t.Skip("TODO: investigate broken test")
19+
baseURL := "http://localhost:4010"
20+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
21+
baseURL = envURL
22+
}
23+
if !testutil.CheckTestServer(t, baseURL) {
24+
return
25+
}
26+
client := cloudflare.NewClient(
27+
option.WithBaseURL(baseURL),
28+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
29+
option.WithAPIEmail("user@example.com"),
30+
)
31+
_, err := client.Firewall.WAF.Overrides.New(context.TODO(), firewall.WAFOverrideNewParams{
32+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
33+
URLs: cloudflare.F([]firewall.OverrideURLParam{"shop.example.com/*"}),
34+
})
35+
if err != nil {
36+
var apierr *cloudflare.Error
37+
if errors.As(err, &apierr) {
38+
t.Log(string(apierr.DumpRequest(true)))
39+
}
40+
t.Fatalf("err should be nil: %s", err.Error())
41+
}
42+
}
43+
44+
func TestWAFOverrideUpdateWithOptionalParams(t *testing.T) {
45+
t.Skip("TODO: investigate broken test")
46+
baseURL := "http://localhost:4010"
47+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
48+
baseURL = envURL
49+
}
50+
if !testutil.CheckTestServer(t, baseURL) {
51+
return
52+
}
53+
client := cloudflare.NewClient(
54+
option.WithBaseURL(baseURL),
55+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
56+
option.WithAPIEmail("user@example.com"),
57+
)
58+
_, err := client.Firewall.WAF.Overrides.Update(
59+
context.TODO(),
60+
"de677e5818985db1285d0e80225f06e5",
61+
firewall.WAFOverrideUpdateParams{
62+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
63+
ID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
64+
RewriteAction: cloudflare.F(firewall.RewriteActionParam{
65+
Block: cloudflare.F(firewall.RewriteActionBlockChallenge),
66+
Challenge: cloudflare.F(firewall.RewriteActionChallengeChallenge),
67+
Default: cloudflare.F(firewall.RewriteActionDefaultChallenge),
68+
Disable: cloudflare.F(firewall.RewriteActionDisableChallenge),
69+
Simulate: cloudflare.F(firewall.RewriteActionSimulateChallenge),
70+
}),
71+
Rules: cloudflare.F(firewall.WAFRuleParam{
72+
"100015": firewall.WAFRuleItemChallenge,
73+
}),
74+
URLs: cloudflare.F([]firewall.OverrideURLParam{"shop.example.com/*"}),
75+
},
76+
)
77+
if err != nil {
78+
var apierr *cloudflare.Error
79+
if errors.As(err, &apierr) {
80+
t.Log(string(apierr.DumpRequest(true)))
81+
}
82+
t.Fatalf("err should be nil: %s", err.Error())
83+
}
84+
}
85+
86+
func TestWAFOverrideListWithOptionalParams(t *testing.T) {
87+
baseURL := "http://localhost:4010"
88+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
89+
baseURL = envURL
90+
}
91+
if !testutil.CheckTestServer(t, baseURL) {
92+
return
93+
}
94+
client := cloudflare.NewClient(
95+
option.WithBaseURL(baseURL),
96+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
97+
option.WithAPIEmail("user@example.com"),
98+
)
99+
_, err := client.Firewall.WAF.Overrides.List(context.TODO(), firewall.WAFOverrideListParams{
100+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
101+
Page: cloudflare.F(1.000000),
102+
PerPage: cloudflare.F(5.000000),
103+
})
104+
if err != nil {
105+
var apierr *cloudflare.Error
106+
if errors.As(err, &apierr) {
107+
t.Log(string(apierr.DumpRequest(true)))
108+
}
109+
t.Fatalf("err should be nil: %s", err.Error())
110+
}
111+
}
112+
113+
func TestWAFOverrideDelete(t *testing.T) {
114+
baseURL := "http://localhost:4010"
115+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
116+
baseURL = envURL
117+
}
118+
if !testutil.CheckTestServer(t, baseURL) {
119+
return
120+
}
121+
client := cloudflare.NewClient(
122+
option.WithBaseURL(baseURL),
123+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
124+
option.WithAPIEmail("user@example.com"),
125+
)
126+
_, err := client.Firewall.WAF.Overrides.Delete(
127+
context.TODO(),
128+
"de677e5818985db1285d0e80225f06e5",
129+
firewall.WAFOverrideDeleteParams{
130+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
131+
},
132+
)
133+
if err != nil {
134+
var apierr *cloudflare.Error
135+
if errors.As(err, &apierr) {
136+
t.Log(string(apierr.DumpRequest(true)))
137+
}
138+
t.Fatalf("err should be nil: %s", err.Error())
139+
}
140+
}
141+
142+
func TestWAFOverrideGet(t *testing.T) {
143+
baseURL := "http://localhost:4010"
144+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
145+
baseURL = envURL
146+
}
147+
if !testutil.CheckTestServer(t, baseURL) {
148+
return
149+
}
150+
client := cloudflare.NewClient(
151+
option.WithBaseURL(baseURL),
152+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
153+
option.WithAPIEmail("user@example.com"),
154+
)
155+
_, err := client.Firewall.WAF.Overrides.Get(
156+
context.TODO(),
157+
"de677e5818985db1285d0e80225f06e5",
158+
firewall.WAFOverrideGetParams{
159+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
160+
},
161+
)
162+
if err != nil {
163+
var apierr *cloudflare.Error
164+
if errors.As(err, &apierr) {
165+
t.Log(string(apierr.DumpRequest(true)))
166+
}
167+
t.Fatalf("err should be nil: %s", err.Error())
168+
}
169+
}

‎firewall/wafpackage.go

+298
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,21 @@
33
package firewall
44

55
import (
6+
"context"
7+
"errors"
8+
"fmt"
9+
"net/http"
10+
"net/url"
11+
"reflect"
12+
13+
"github.com/cloudflare/cloudflare-go/v3/internal/apijson"
14+
"github.com/cloudflare/cloudflare-go/v3/internal/apiquery"
15+
"github.com/cloudflare/cloudflare-go/v3/internal/param"
16+
"github.com/cloudflare/cloudflare-go/v3/internal/requestconfig"
617
"github.com/cloudflare/cloudflare-go/v3/option"
18+
"github.com/cloudflare/cloudflare-go/v3/packages/pagination"
19+
"github.com/cloudflare/cloudflare-go/v3/shared"
20+
"github.com/tidwall/gjson"
721
)
822

923
// WAFPackageService contains methods and other services that help with interacting
@@ -28,3 +42,287 @@ func NewWAFPackageService(opts ...option.RequestOption) (r *WAFPackageService) {
2842
r.Rules = NewWAFPackageRuleService(opts...)
2943
return
3044
}
45+
46+
// Fetches WAF packages for a zone.
47+
//
48+
// **Note:** Applies only to the
49+
// [previous version of WAF managed rules](https://developers.cloudflare.com/support/firewall/managed-rules-web-application-firewall-waf/understanding-waf-managed-rules-web-application-firewall/).
50+
func (r *WAFPackageService) List(ctx context.Context, params WAFPackageListParams, opts ...option.RequestOption) (res *pagination.V4PagePaginationArray[WAFPackageListResponse], err error) {
51+
var raw *http.Response
52+
opts = append(r.Options[:], opts...)
53+
opts = append([]option.RequestOption{option.WithResponseInto(&raw)}, opts...)
54+
if params.ZoneID.Value == "" {
55+
err = errors.New("missing required zone_id parameter")
56+
return
57+
}
58+
path := fmt.Sprintf("zones/%s/firewall/waf/packages", params.ZoneID)
59+
cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, params, &res, opts...)
60+
if err != nil {
61+
return nil, err
62+
}
63+
err = cfg.Execute()
64+
if err != nil {
65+
return nil, err
66+
}
67+
res.SetPageConfig(cfg, raw)
68+
return res, nil
69+
}
70+
71+
// Fetches WAF packages for a zone.
72+
//
73+
// **Note:** Applies only to the
74+
// [previous version of WAF managed rules](https://developers.cloudflare.com/support/firewall/managed-rules-web-application-firewall-waf/understanding-waf-managed-rules-web-application-firewall/).
75+
func (r *WAFPackageService) ListAutoPaging(ctx context.Context, params WAFPackageListParams, opts ...option.RequestOption) *pagination.V4PagePaginationArrayAutoPager[WAFPackageListResponse] {
76+
return pagination.NewV4PagePaginationArrayAutoPager(r.List(ctx, params, opts...))
77+
}
78+
79+
// Fetches the details of a WAF package.
80+
//
81+
// **Note:** Applies only to the
82+
// [previous version of WAF managed rules](https://developers.cloudflare.com/support/firewall/managed-rules-web-application-firewall-waf/understanding-waf-managed-rules-web-application-firewall/).
83+
func (r *WAFPackageService) Get(ctx context.Context, packageID string, query WAFPackageGetParams, opts ...option.RequestOption) (res *WAFPackageGetResponse, err error) {
84+
opts = append(r.Options[:], opts...)
85+
if query.ZoneID.Value == "" {
86+
err = errors.New("missing required zone_id parameter")
87+
return
88+
}
89+
if packageID == "" {
90+
err = errors.New("missing required package_id parameter")
91+
return
92+
}
93+
path := fmt.Sprintf("zones/%s/firewall/waf/packages/%s", query.ZoneID, packageID)
94+
err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
95+
return
96+
}
97+
98+
type WAFPackageListResponse = interface{}
99+
100+
type WAFPackageGetResponse struct {
101+
// This field can have the runtime type of [[]shared.ResponseInfo].
102+
Errors interface{} `json:"errors"`
103+
// This field can have the runtime type of [[]shared.ResponseInfo].
104+
Messages interface{} `json:"messages"`
105+
// This field can have the runtime type of [interface{}].
106+
Result interface{} `json:"result"`
107+
// Whether the API call was successful
108+
Success WAFPackageGetResponseSuccess `json:"success"`
109+
JSON wafPackageGetResponseJSON `json:"-"`
110+
union WAFPackageGetResponseUnion
111+
}
112+
113+
// wafPackageGetResponseJSON contains the JSON metadata for the struct
114+
// [WAFPackageGetResponse]
115+
type wafPackageGetResponseJSON struct {
116+
Errors apijson.Field
117+
Messages apijson.Field
118+
Result apijson.Field
119+
Success apijson.Field
120+
raw string
121+
ExtraFields map[string]apijson.Field
122+
}
123+
124+
func (r wafPackageGetResponseJSON) RawJSON() string {
125+
return r.raw
126+
}
127+
128+
func (r *WAFPackageGetResponse) UnmarshalJSON(data []byte) (err error) {
129+
*r = WAFPackageGetResponse{}
130+
err = apijson.UnmarshalRoot(data, &r.union)
131+
if err != nil {
132+
return err
133+
}
134+
return apijson.Port(r.union, &r)
135+
}
136+
137+
// AsUnion returns a [WAFPackageGetResponseUnion] interface which you can cast to
138+
// the specific types for more type safety.
139+
//
140+
// Possible runtime types of the union are
141+
// [firewall.WAFPackageGetResponseFirewallAPIResponseSingle],
142+
// [firewall.WAFPackageGetResponseResult].
143+
func (r WAFPackageGetResponse) AsUnion() WAFPackageGetResponseUnion {
144+
return r.union
145+
}
146+
147+
// Union satisfied by [firewall.WAFPackageGetResponseFirewallAPIResponseSingle] or
148+
// [firewall.WAFPackageGetResponseResult].
149+
type WAFPackageGetResponseUnion interface {
150+
implementsFirewallWAFPackageGetResponse()
151+
}
152+
153+
func init() {
154+
apijson.RegisterUnion(
155+
reflect.TypeOf((*WAFPackageGetResponseUnion)(nil)).Elem(),
156+
"",
157+
apijson.UnionVariant{
158+
TypeFilter: gjson.JSON,
159+
Type: reflect.TypeOf(WAFPackageGetResponseFirewallAPIResponseSingle{}),
160+
},
161+
apijson.UnionVariant{
162+
TypeFilter: gjson.JSON,
163+
Type: reflect.TypeOf(WAFPackageGetResponseResult{}),
164+
},
165+
)
166+
}
167+
168+
type WAFPackageGetResponseFirewallAPIResponseSingle struct {
169+
Errors []shared.ResponseInfo `json:"errors,required"`
170+
Messages []shared.ResponseInfo `json:"messages,required"`
171+
Result interface{} `json:"result,required"`
172+
// Whether the API call was successful
173+
Success WAFPackageGetResponseFirewallAPIResponseSingleSuccess `json:"success,required"`
174+
JSON wafPackageGetResponseFirewallAPIResponseSingleJSON `json:"-"`
175+
}
176+
177+
// wafPackageGetResponseFirewallAPIResponseSingleJSON contains the JSON metadata
178+
// for the struct [WAFPackageGetResponseFirewallAPIResponseSingle]
179+
type wafPackageGetResponseFirewallAPIResponseSingleJSON struct {
180+
Errors apijson.Field
181+
Messages apijson.Field
182+
Result apijson.Field
183+
Success apijson.Field
184+
raw string
185+
ExtraFields map[string]apijson.Field
186+
}
187+
188+
func (r *WAFPackageGetResponseFirewallAPIResponseSingle) UnmarshalJSON(data []byte) (err error) {
189+
return apijson.UnmarshalRoot(data, r)
190+
}
191+
192+
func (r wafPackageGetResponseFirewallAPIResponseSingleJSON) RawJSON() string {
193+
return r.raw
194+
}
195+
196+
func (r WAFPackageGetResponseFirewallAPIResponseSingle) implementsFirewallWAFPackageGetResponse() {}
197+
198+
// Whether the API call was successful
199+
type WAFPackageGetResponseFirewallAPIResponseSingleSuccess bool
200+
201+
const (
202+
WAFPackageGetResponseFirewallAPIResponseSingleSuccessTrue WAFPackageGetResponseFirewallAPIResponseSingleSuccess = true
203+
)
204+
205+
func (r WAFPackageGetResponseFirewallAPIResponseSingleSuccess) IsKnown() bool {
206+
switch r {
207+
case WAFPackageGetResponseFirewallAPIResponseSingleSuccessTrue:
208+
return true
209+
}
210+
return false
211+
}
212+
213+
type WAFPackageGetResponseResult struct {
214+
Result interface{} `json:"result"`
215+
JSON wafPackageGetResponseResultJSON `json:"-"`
216+
}
217+
218+
// wafPackageGetResponseResultJSON contains the JSON metadata for the struct
219+
// [WAFPackageGetResponseResult]
220+
type wafPackageGetResponseResultJSON struct {
221+
Result apijson.Field
222+
raw string
223+
ExtraFields map[string]apijson.Field
224+
}
225+
226+
func (r *WAFPackageGetResponseResult) UnmarshalJSON(data []byte) (err error) {
227+
return apijson.UnmarshalRoot(data, r)
228+
}
229+
230+
func (r wafPackageGetResponseResultJSON) RawJSON() string {
231+
return r.raw
232+
}
233+
234+
func (r WAFPackageGetResponseResult) implementsFirewallWAFPackageGetResponse() {}
235+
236+
// Whether the API call was successful
237+
type WAFPackageGetResponseSuccess bool
238+
239+
const (
240+
WAFPackageGetResponseSuccessTrue WAFPackageGetResponseSuccess = true
241+
)
242+
243+
func (r WAFPackageGetResponseSuccess) IsKnown() bool {
244+
switch r {
245+
case WAFPackageGetResponseSuccessTrue:
246+
return true
247+
}
248+
return false
249+
}
250+
251+
type WAFPackageListParams struct {
252+
// Identifier
253+
ZoneID param.Field[string] `path:"zone_id,required"`
254+
// The direction used to sort returned packages.
255+
Direction param.Field[WAFPackageListParamsDirection] `query:"direction"`
256+
// When set to `all`, all the search requirements must match. When set to `any`,
257+
// only one of the search requirements has to match.
258+
Match param.Field[WAFPackageListParamsMatch] `query:"match"`
259+
// The name of the WAF package.
260+
Name param.Field[string] `query:"name"`
261+
// The field used to sort returned packages.
262+
Order param.Field[WAFPackageListParamsOrder] `query:"order"`
263+
// The page number of paginated results.
264+
Page param.Field[float64] `query:"page"`
265+
// The number of packages per page.
266+
PerPage param.Field[float64] `query:"per_page"`
267+
}
268+
269+
// URLQuery serializes [WAFPackageListParams]'s query parameters as `url.Values`.
270+
func (r WAFPackageListParams) URLQuery() (v url.Values) {
271+
return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
272+
ArrayFormat: apiquery.ArrayQueryFormatRepeat,
273+
NestedFormat: apiquery.NestedQueryFormatDots,
274+
})
275+
}
276+
277+
// The direction used to sort returned packages.
278+
type WAFPackageListParamsDirection string
279+
280+
const (
281+
WAFPackageListParamsDirectionAsc WAFPackageListParamsDirection = "asc"
282+
WAFPackageListParamsDirectionDesc WAFPackageListParamsDirection = "desc"
283+
)
284+
285+
func (r WAFPackageListParamsDirection) IsKnown() bool {
286+
switch r {
287+
case WAFPackageListParamsDirectionAsc, WAFPackageListParamsDirectionDesc:
288+
return true
289+
}
290+
return false
291+
}
292+
293+
// When set to `all`, all the search requirements must match. When set to `any`,
294+
// only one of the search requirements has to match.
295+
type WAFPackageListParamsMatch string
296+
297+
const (
298+
WAFPackageListParamsMatchAny WAFPackageListParamsMatch = "any"
299+
WAFPackageListParamsMatchAll WAFPackageListParamsMatch = "all"
300+
)
301+
302+
func (r WAFPackageListParamsMatch) IsKnown() bool {
303+
switch r {
304+
case WAFPackageListParamsMatchAny, WAFPackageListParamsMatchAll:
305+
return true
306+
}
307+
return false
308+
}
309+
310+
// The field used to sort returned packages.
311+
type WAFPackageListParamsOrder string
312+
313+
const (
314+
WAFPackageListParamsOrderName WAFPackageListParamsOrder = "name"
315+
)
316+
317+
func (r WAFPackageListParamsOrder) IsKnown() bool {
318+
switch r {
319+
case WAFPackageListParamsOrderName:
320+
return true
321+
}
322+
return false
323+
}
324+
325+
type WAFPackageGetParams struct {
326+
// Identifier
327+
ZoneID param.Field[string] `path:"zone_id,required"`
328+
}

‎firewall/wafpackage_test.go

+76
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2+
3+
package firewall_test
4+
5+
import (
6+
"context"
7+
"errors"
8+
"os"
9+
"testing"
10+
11+
"github.com/cloudflare/cloudflare-go/v3"
12+
"github.com/cloudflare/cloudflare-go/v3/firewall"
13+
"github.com/cloudflare/cloudflare-go/v3/internal/testutil"
14+
"github.com/cloudflare/cloudflare-go/v3/option"
15+
)
16+
17+
func TestWAFPackageListWithOptionalParams(t *testing.T) {
18+
t.Skip("TODO: investigate broken test")
19+
baseURL := "http://localhost:4010"
20+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
21+
baseURL = envURL
22+
}
23+
if !testutil.CheckTestServer(t, baseURL) {
24+
return
25+
}
26+
client := cloudflare.NewClient(
27+
option.WithBaseURL(baseURL),
28+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
29+
option.WithAPIEmail("user@example.com"),
30+
)
31+
_, err := client.Firewall.WAF.Packages.List(context.TODO(), firewall.WAFPackageListParams{
32+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
33+
Direction: cloudflare.F(firewall.WAFPackageListParamsDirectionAsc),
34+
Match: cloudflare.F(firewall.WAFPackageListParamsMatchAny),
35+
Name: cloudflare.F("USER"),
36+
Order: cloudflare.F(firewall.WAFPackageListParamsOrderName),
37+
Page: cloudflare.F(1.000000),
38+
PerPage: cloudflare.F(5.000000),
39+
})
40+
if err != nil {
41+
var apierr *cloudflare.Error
42+
if errors.As(err, &apierr) {
43+
t.Log(string(apierr.DumpRequest(true)))
44+
}
45+
t.Fatalf("err should be nil: %s", err.Error())
46+
}
47+
}
48+
49+
func TestWAFPackageGet(t *testing.T) {
50+
baseURL := "http://localhost:4010"
51+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
52+
baseURL = envURL
53+
}
54+
if !testutil.CheckTestServer(t, baseURL) {
55+
return
56+
}
57+
client := cloudflare.NewClient(
58+
option.WithBaseURL(baseURL),
59+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
60+
option.WithAPIEmail("user@example.com"),
61+
)
62+
_, err := client.Firewall.WAF.Packages.Get(
63+
context.TODO(),
64+
"023e105f4ecef8ad9ca31a8372d0c353",
65+
firewall.WAFPackageGetParams{
66+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
67+
},
68+
)
69+
if err != nil {
70+
var apierr *cloudflare.Error
71+
if errors.As(err, &apierr) {
72+
t.Log(string(apierr.DumpRequest(true)))
73+
}
74+
t.Fatalf("err should be nil: %s", err.Error())
75+
}
76+
}

‎pagerules/pagerule.go

+4,490-456
Large diffs are not rendered by default.

‎pagerules/pagerule_test.go

+10-18
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ import (
1212
"github.com/cloudflare/cloudflare-go/v3/internal/testutil"
1313
"github.com/cloudflare/cloudflare-go/v3/option"
1414
"github.com/cloudflare/cloudflare-go/v3/pagerules"
15+
"github.com/cloudflare/cloudflare-go/v3/zones"
1516
)
1617

1718
func TestPageruleNewWithOptionalParams(t *testing.T) {
@@ -29,12 +30,9 @@ func TestPageruleNewWithOptionalParams(t *testing.T) {
2930
)
3031
_, err := client.Pagerules.New(context.TODO(), pagerules.PageruleNewParams{
3132
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
32-
Actions: cloudflare.F([]pagerules.PageruleNewParamsAction{{
33-
ID: cloudflare.F(pagerules.PageruleNewParamsActionsIDForwardingURL),
34-
Value: cloudflare.F(pagerules.PageruleNewParamsActionsValue{
35-
StatusCode: cloudflare.F(pagerules.PageruleNewParamsActionsValueStatusCode301),
36-
URL: cloudflare.F("http://www.example.com/somewhere/$1/astring/$2/anotherstring/$3"),
37-
}),
33+
Actions: cloudflare.F([]pagerules.PageruleNewParamsActionUnion{zones.BrowserCheckParam{
34+
ID: cloudflare.F(zones.BrowserCheckIDBrowserCheck),
35+
Value: cloudflare.F(zones.BrowserCheckValueOn),
3836
}}),
3937
Targets: cloudflare.F([]pagerules.TargetParam{{
4038
Constraint: cloudflare.F(pagerules.TargetConstraintParam{
@@ -73,12 +71,9 @@ func TestPageruleUpdateWithOptionalParams(t *testing.T) {
7371
"023e105f4ecef8ad9ca31a8372d0c353",
7472
pagerules.PageruleUpdateParams{
7573
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
76-
Actions: cloudflare.F([]pagerules.PageruleUpdateParamsAction{{
77-
ID: cloudflare.F(pagerules.PageruleUpdateParamsActionsIDForwardingURL),
78-
Value: cloudflare.F(pagerules.PageruleUpdateParamsActionsValue{
79-
StatusCode: cloudflare.F(pagerules.PageruleUpdateParamsActionsValueStatusCode301),
80-
URL: cloudflare.F("http://www.example.com/somewhere/$1/astring/$2/anotherstring/$3"),
81-
}),
74+
Actions: cloudflare.F([]pagerules.PageruleUpdateParamsActionUnion{zones.BrowserCheckParam{
75+
ID: cloudflare.F(zones.BrowserCheckIDBrowserCheck),
76+
Value: cloudflare.F(zones.BrowserCheckValueOn),
8277
}}),
8378
Targets: cloudflare.F([]pagerules.TargetParam{{
8479
Constraint: cloudflare.F(pagerules.TargetConstraintParam{
@@ -176,12 +171,9 @@ func TestPageruleEditWithOptionalParams(t *testing.T) {
176171
"023e105f4ecef8ad9ca31a8372d0c353",
177172
pagerules.PageruleEditParams{
178173
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
179-
Actions: cloudflare.F([]pagerules.PageruleEditParamsAction{{
180-
ID: cloudflare.F(pagerules.PageruleEditParamsActionsIDForwardingURL),
181-
Value: cloudflare.F(pagerules.PageruleEditParamsActionsValue{
182-
StatusCode: cloudflare.F(pagerules.PageruleEditParamsActionsValueStatusCode301),
183-
URL: cloudflare.F("http://www.example.com/somewhere/$1/astring/$2/anotherstring/$3"),
184-
}),
174+
Actions: cloudflare.F([]pagerules.PageruleEditParamsActionUnion{zones.BrowserCheckParam{
175+
ID: cloudflare.F(zones.BrowserCheckIDBrowserCheck),
176+
Value: cloudflare.F(zones.BrowserCheckValueOn),
185177
}}),
186178
Priority: cloudflare.F(int64(0)),
187179
Status: cloudflare.F(pagerules.PageruleEditParamsStatusActive),

‎pagerules/setting.go

-104
This file was deleted.

‎pagerules/setting_test.go

-40
This file was deleted.

‎rate_limits/ratelimit.go

+1,315
Large diffs are not rendered by default.

‎rate_limits/ratelimit_test.go

+206
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,206 @@
1+
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2+
3+
package rate_limits_test
4+
5+
import (
6+
"context"
7+
"errors"
8+
"os"
9+
"testing"
10+
11+
"github.com/cloudflare/cloudflare-go/v3"
12+
"github.com/cloudflare/cloudflare-go/v3/internal/testutil"
13+
"github.com/cloudflare/cloudflare-go/v3/option"
14+
"github.com/cloudflare/cloudflare-go/v3/rate_limits"
15+
)
16+
17+
func TestRateLimitNewWithOptionalParams(t *testing.T) {
18+
t.Skip("TODO: investigate broken test")
19+
baseURL := "http://localhost:4010"
20+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
21+
baseURL = envURL
22+
}
23+
if !testutil.CheckTestServer(t, baseURL) {
24+
return
25+
}
26+
client := cloudflare.NewClient(
27+
option.WithBaseURL(baseURL),
28+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
29+
option.WithAPIEmail("user@example.com"),
30+
)
31+
_, err := client.RateLimits.New(context.TODO(), rate_limits.RateLimitNewParams{
32+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
33+
Action: cloudflare.F(rate_limits.RateLimitNewParamsAction{
34+
Mode: cloudflare.F(rate_limits.RateLimitNewParamsActionModeSimulate),
35+
Response: cloudflare.F(rate_limits.RateLimitNewParamsActionResponse{
36+
Body: cloudflare.F("<error>This request has been rate-limited.</error>"),
37+
ContentType: cloudflare.F("text/xml"),
38+
}),
39+
Timeout: cloudflare.F(86400.000000),
40+
}),
41+
Match: cloudflare.F(rate_limits.RateLimitNewParamsMatch{
42+
Headers: cloudflare.F([]rate_limits.RateLimitNewParamsMatchHeader{{
43+
Name: cloudflare.F("Cf-Cache-Status"),
44+
Op: cloudflare.F(rate_limits.RateLimitNewParamsMatchHeadersOpEq),
45+
Value: cloudflare.F("HIT"),
46+
}}),
47+
Request: cloudflare.F(rate_limits.RateLimitNewParamsMatchRequest{
48+
Methods: cloudflare.F([]rate_limits.Methods{rate_limits.MethodsGet, rate_limits.MethodsPost}),
49+
Schemes: cloudflare.F([]string{"HTTP", "HTTPS"}),
50+
URL: cloudflare.F("*.example.org/path*"),
51+
}),
52+
Response: cloudflare.F(rate_limits.RateLimitNewParamsMatchResponse{
53+
OriginTraffic: cloudflare.F(true),
54+
}),
55+
}),
56+
Period: cloudflare.F(900.000000),
57+
Threshold: cloudflare.F(60.000000),
58+
})
59+
if err != nil {
60+
var apierr *cloudflare.Error
61+
if errors.As(err, &apierr) {
62+
t.Log(string(apierr.DumpRequest(true)))
63+
}
64+
t.Fatalf("err should be nil: %s", err.Error())
65+
}
66+
}
67+
68+
func TestRateLimitListWithOptionalParams(t *testing.T) {
69+
baseURL := "http://localhost:4010"
70+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
71+
baseURL = envURL
72+
}
73+
if !testutil.CheckTestServer(t, baseURL) {
74+
return
75+
}
76+
client := cloudflare.NewClient(
77+
option.WithBaseURL(baseURL),
78+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
79+
option.WithAPIEmail("user@example.com"),
80+
)
81+
_, err := client.RateLimits.List(context.TODO(), rate_limits.RateLimitListParams{
82+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
83+
Page: cloudflare.F(1.000000),
84+
PerPage: cloudflare.F(1.000000),
85+
})
86+
if err != nil {
87+
var apierr *cloudflare.Error
88+
if errors.As(err, &apierr) {
89+
t.Log(string(apierr.DumpRequest(true)))
90+
}
91+
t.Fatalf("err should be nil: %s", err.Error())
92+
}
93+
}
94+
95+
func TestRateLimitDelete(t *testing.T) {
96+
baseURL := "http://localhost:4010"
97+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
98+
baseURL = envURL
99+
}
100+
if !testutil.CheckTestServer(t, baseURL) {
101+
return
102+
}
103+
client := cloudflare.NewClient(
104+
option.WithBaseURL(baseURL),
105+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
106+
option.WithAPIEmail("user@example.com"),
107+
)
108+
_, err := client.RateLimits.Delete(
109+
context.TODO(),
110+
"372e67954025e0ba6aaa6d586b9e0b59",
111+
rate_limits.RateLimitDeleteParams{
112+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
113+
},
114+
)
115+
if err != nil {
116+
var apierr *cloudflare.Error
117+
if errors.As(err, &apierr) {
118+
t.Log(string(apierr.DumpRequest(true)))
119+
}
120+
t.Fatalf("err should be nil: %s", err.Error())
121+
}
122+
}
123+
124+
func TestRateLimitEditWithOptionalParams(t *testing.T) {
125+
t.Skip("TODO: investigate broken test")
126+
baseURL := "http://localhost:4010"
127+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
128+
baseURL = envURL
129+
}
130+
if !testutil.CheckTestServer(t, baseURL) {
131+
return
132+
}
133+
client := cloudflare.NewClient(
134+
option.WithBaseURL(baseURL),
135+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
136+
option.WithAPIEmail("user@example.com"),
137+
)
138+
_, err := client.RateLimits.Edit(
139+
context.TODO(),
140+
"372e67954025e0ba6aaa6d586b9e0b59",
141+
rate_limits.RateLimitEditParams{
142+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
143+
Action: cloudflare.F(rate_limits.RateLimitEditParamsAction{
144+
Mode: cloudflare.F(rate_limits.RateLimitEditParamsActionModeSimulate),
145+
Response: cloudflare.F(rate_limits.RateLimitEditParamsActionResponse{
146+
Body: cloudflare.F("<error>This request has been rate-limited.</error>"),
147+
ContentType: cloudflare.F("text/xml"),
148+
}),
149+
Timeout: cloudflare.F(86400.000000),
150+
}),
151+
Match: cloudflare.F(rate_limits.RateLimitEditParamsMatch{
152+
Headers: cloudflare.F([]rate_limits.RateLimitEditParamsMatchHeader{{
153+
Name: cloudflare.F("Cf-Cache-Status"),
154+
Op: cloudflare.F(rate_limits.RateLimitEditParamsMatchHeadersOpEq),
155+
Value: cloudflare.F("HIT"),
156+
}}),
157+
Request: cloudflare.F(rate_limits.RateLimitEditParamsMatchRequest{
158+
Methods: cloudflare.F([]rate_limits.Methods{rate_limits.MethodsGet, rate_limits.MethodsPost}),
159+
Schemes: cloudflare.F([]string{"HTTP", "HTTPS"}),
160+
URL: cloudflare.F("*.example.org/path*"),
161+
}),
162+
Response: cloudflare.F(rate_limits.RateLimitEditParamsMatchResponse{
163+
OriginTraffic: cloudflare.F(true),
164+
}),
165+
}),
166+
Period: cloudflare.F(900.000000),
167+
Threshold: cloudflare.F(60.000000),
168+
},
169+
)
170+
if err != nil {
171+
var apierr *cloudflare.Error
172+
if errors.As(err, &apierr) {
173+
t.Log(string(apierr.DumpRequest(true)))
174+
}
175+
t.Fatalf("err should be nil: %s", err.Error())
176+
}
177+
}
178+
179+
func TestRateLimitGet(t *testing.T) {
180+
baseURL := "http://localhost:4010"
181+
if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
182+
baseURL = envURL
183+
}
184+
if !testutil.CheckTestServer(t, baseURL) {
185+
return
186+
}
187+
client := cloudflare.NewClient(
188+
option.WithBaseURL(baseURL),
189+
option.WithAPIKey("144c9defac04969c7bfad8efaa8ea194"),
190+
option.WithAPIEmail("user@example.com"),
191+
)
192+
_, err := client.RateLimits.Get(
193+
context.TODO(),
194+
"372e67954025e0ba6aaa6d586b9e0b59",
195+
rate_limits.RateLimitGetParams{
196+
ZoneID: cloudflare.F("023e105f4ecef8ad9ca31a8372d0c353"),
197+
},
198+
)
199+
if err != nil {
200+
var apierr *cloudflare.Error
201+
if errors.As(err, &apierr) {
202+
t.Log(string(apierr.DumpRequest(true)))
203+
}
204+
t.Fatalf("err should be nil: %s", err.Error())
205+
}
206+
}

‎zones/setting.go

+7,083-2,339
Large diffs are not rendered by default.

0 commit comments

Comments
 (0)
Please sign in to comment.