diff --git a/CHANGELOG.md b/CHANGELOG.md index 630584be..e03aa755 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,11 @@ FEATURES - Add `UseInboundWebhookOnNumber` response field to service create, fetch and update response structs - Add `UseInboundWebhookOnNumber` input field to service create and update input structs +### Video + +- **New Resource:** Composition Settings +- **New Resource:** Recording Settings + ## v0.17.0 (2021-05-08) FIXES diff --git a/definitions/service/video/v1/api.json b/definitions/service/video/v1/api.json index 90a7a218..2c863a86 100644 --- a/definitions/service/video/v1/api.json +++ b/definitions/service/video/v1/api.json @@ -1558,6 +1558,116 @@ } } ] + }, + { + "name": "Recording Settings", + "packageName": "recording_settings", + "function": { + "parameters": {} + }, + "documentation": { + "description": "Client for managing the default recording settings", + "twilioDocsLink": "https://www.twilio.com/docs/video/api/encrypted-recordings" + }, + "operations": [ + { + "name": "Fetch", + "http": { + "uri": "/RecordingSettings/Default", + "method": "Get" + }, + "documentation": { + "description": "retrieves the default recording settings", + "twilioDocsLink": "https://www.twilio.com/docs/video/api/encrypted-recordings#http-get" + }, + "response": { + "name": "FetchRecordingSettingsResponse", + "structure": "RecordingSettingsResponse", + "documentation": { + "description": "defines the response fields for the retrieved recording settings" + } + } + }, + { + "name": "Update", + "http": { + "uri": "/RecordingSettings/Default", + "method": "Post" + }, + "documentation": { + "description": "modifies default recording settings", + "twilioDocsLink": "https://www.twilio.com/docs/video/api/encrypted-recordings#http-post" + }, + "input": { + "structure": "UpdateRecordingSettingsInput", + "documentation": { + "description": "defines input fields for updating recording settings" + } + }, + "response": { + "name": "UpdateRecordingSettingsResponse", + "structure": "RecordingSettingsResponse", + "documentation": { + "description": "defines the response fields for the updated recording settings" + } + } + } + ] + }, + { + "name": "Composition Settings", + "packageName": "composition_settings", + "function": { + "parameters": {} + }, + "documentation": { + "description": "Client for managing the default composition settings", + "twilioDocsLink": "https://www.twilio.com/docs/video/api/encrypted-compositions" + }, + "operations": [ + { + "name": "Fetch", + "http": { + "uri": "/CompositionSettings/Default", + "method": "Get" + }, + "documentation": { + "description": "retrieves the default composition settings", + "twilioDocsLink": "https://www.twilio.com/docs/video/api/encrypted-compositions#http-get" + }, + "response": { + "name": "FetchCompositionSettingsResponse", + "structure": "CompositionSettingsResponse", + "documentation": { + "description": "defines the response fields for the retrieved composition settings" + } + } + }, + { + "name": "Update", + "http": { + "uri": "/CompositionSettings/Default", + "method": "Post" + }, + "documentation": { + "description": "modifies default composition settings", + "twilioDocsLink": "https://www.twilio.com/docs/video/api/encrypted-compositions#http-post" + }, + "input": { + "structure": "UpdateCompositionSettingsInput", + "documentation": { + "description": "defines input fields for updating composition settings" + } + }, + "response": { + "name": "UpdateCompositionSettingsResponse", + "structure": "CompositionSettingsResponse", + "documentation": { + "description": "defines the response fields for the updated composition settings" + } + } + } + ] } ], "structures": { @@ -2556,6 +2666,200 @@ } ] }, + "UpdateRecordingSettingsInput": { + "type": "URLEncoded", + "properties": [ + { + "name": "FriendlyName", + "type": "string", + "value": "FriendlyName", + "required": true, + "validation": { + "ignore": true + } + }, + { + "name": "AWSCredentialSid", + "type": "string", + "value": "AwsCredentialsSid", + "required": false + }, + { + "name": "EncryptionKeySid", + "type": "string", + "value": "EncryptionKeySid", + "required": false + }, + { + "name": "AWSS3URL", + "type": "string", + "value": "AwsS3Url", + "required": false + }, + { + "name": "AWSStorageEnabled", + "type": "bool", + "value": "AwsStorageEnabled", + "required": false + }, + { + "name": "EncryptionEnabled", + "type": "bool", + "value": "EncryptionEnabled", + "required": false + } + ] + }, + "RecordingSettingsResponse": { + "type": "JSON", + "properties": [ + { + "name": "AccountSid", + "type": "string", + "value": "account_sid", + "required": true + }, + { + "name": "FriendlyName", + "type": "string", + "value": "friendly_name", + "required": true + }, + { + "name": "AWSCredentialSid", + "type": "string", + "value": "aws_credentials_sid", + "required": false + }, + { + "name": "EncryptionKeySid", + "type": "string", + "value": "encryption_key_sid", + "required": false + }, + { + "name": "AWSS3URL", + "type": "string", + "value": "aws_s3_url", + "required": false + }, + { + "name": "AWSStorageEnabled", + "type": "bool", + "value": "aws_storage_enabled", + "required": false + }, + { + "name": "EncryptionEnabled", + "type": "bool", + "value": "encryption_enabled", + "required": false + }, + { + "name": "URL", + "type": "string", + "value": "url", + "required": true + } + ] + }, + "UpdateCompositionSettingsInput": { + "type": "URLEncoded", + "properties": [ + { + "name": "FriendlyName", + "type": "string", + "value": "FriendlyName", + "required": true, + "validation": { + "ignore": true + } + }, + { + "name": "AWSCredentialSid", + "type": "string", + "value": "AwsCredentialsSid", + "required": false + }, + { + "name": "EncryptionKeySid", + "type": "string", + "value": "EncryptionKeySid", + "required": false + }, + { + "name": "AWSS3URL", + "type": "string", + "value": "AwsS3Url", + "required": false + }, + { + "name": "AWSStorageEnabled", + "type": "bool", + "value": "AwsStorageEnabled", + "required": false + }, + { + "name": "EncryptionEnabled", + "type": "bool", + "value": "EncryptionEnabled", + "required": false + } + ] + }, + "CompositionSettingsResponse": { + "type": "JSON", + "properties": [ + { + "name": "AccountSid", + "type": "string", + "value": "account_sid", + "required": true + }, + { + "name": "FriendlyName", + "type": "string", + "value": "friendly_name", + "required": true + }, + { + "name": "AWSCredentialSid", + "type": "string", + "value": "aws_credentials_sid", + "required": false + }, + { + "name": "EncryptionKeySid", + "type": "string", + "value": "encryption_key_sid", + "required": false + }, + { + "name": "AWSS3URL", + "type": "string", + "value": "aws_s3_url", + "required": false + }, + { + "name": "AWSStorageEnabled", + "type": "bool", + "value": "aws_storage_enabled", + "required": false + }, + { + "name": "EncryptionEnabled", + "type": "bool", + "value": "encryption_enabled", + "required": false + }, + { + "name": "URL", + "type": "string", + "value": "url", + "required": true + } + ] + }, "MetaResponse": { "type": "JSON", "properties": [ diff --git a/service/video/tests/acceptance/video_acceptance_test.go b/service/video/tests/acceptance/video_acceptance_test.go index c3f0e034..86f56b9a 100644 --- a/service/video/tests/acceptance/video_acceptance_test.go +++ b/service/video/tests/acceptance/video_acceptance_test.go @@ -11,6 +11,8 @@ import ( "github.com/RJPearson94/twilio-sdk-go" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_hook" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_hooks" + "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_settings" + "github.com/RJPearson94/twilio-sdk-go/service/video/v1/recording_settings" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/room" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/rooms" "github.com/RJPearson94/twilio-sdk-go/session/credentials" @@ -62,7 +64,6 @@ var _ = Describe("Video Acceptance Tests", func() { }) Expect(updateErr).To(BeNil()) Expect(updateResp).ToNot(BeNil()) - }) }) @@ -113,6 +114,38 @@ var _ = Describe("Video Acceptance Tests", func() { }) }) + Describe("Given the video recording settings clients", func() { + It("Then the recording settings is created, fetched and updated", func() { + recordingSettingsClient := videoSession.RecordingSettings() + + fetchResp, fetchErr := recordingSettingsClient.Fetch() + Expect(fetchErr).To(BeNil()) + Expect(fetchResp).ToNot(BeNil()) + + updateResp, updateErr := recordingSettingsClient.Update(&recording_settings.UpdateRecordingSettingsInput{ + FriendlyName: "Basic Recording Setting", + }) + Expect(updateErr).To(BeNil()) + Expect(updateResp).ToNot(BeNil()) + }) + }) + + Describe("Given the video composition settings clients", func() { + It("Then the composition settings is created, fetched and updated", func() { + compositionSettingsClient := videoSession.CompositionSettings() + + fetchResp, fetchErr := compositionSettingsClient.Fetch() + Expect(fetchErr).To(BeNil()) + Expect(fetchResp).ToNot(BeNil()) + + updateResp, updateErr := compositionSettingsClient.Update(&composition_settings.UpdateCompositionSettingsInput{ + FriendlyName: "Basic Composition Setting", + }) + Expect(updateErr).To(BeNil()) + Expect(updateResp).ToNot(BeNil()) + }) + }) + // TODO Add Recording tests // TODO Add Room Recording tests // TODO Add Composition tests diff --git a/service/video/tests/unit/testdata/compositionSettingsEnterpriseResponse.json b/service/video/tests/unit/testdata/compositionSettingsEnterpriseResponse.json new file mode 100644 index 00000000..3559428c --- /dev/null +++ b/service/video/tests/unit/testdata/compositionSettingsEnterpriseResponse.json @@ -0,0 +1,10 @@ +{ + "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + "friendly_name": "Enterprise Composition Settings", + "aws_credentials_sid": "CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + "encryption_key_sid": "CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1", + "aws_s3_url": "https://test-bucket.s3.amazonaws.com/composition/", + "aws_storage_enabled": true, + "encryption_enabled": false, + "url": "https://video.twilio.com/v1/CompositionSettings/Default" +} diff --git a/service/video/tests/unit/testdata/compositionSettingsResponse.json b/service/video/tests/unit/testdata/compositionSettingsResponse.json new file mode 100644 index 00000000..7f8d0b4b --- /dev/null +++ b/service/video/tests/unit/testdata/compositionSettingsResponse.json @@ -0,0 +1,5 @@ +{ + "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + "friendly_name": "Basic Composition Settings", + "url": "https://video.twilio.com/v1/CompositionSettings/Default" +} diff --git a/service/video/tests/unit/testdata/recordingSettingsEnterpriseResponse.json b/service/video/tests/unit/testdata/recordingSettingsEnterpriseResponse.json new file mode 100644 index 00000000..a7756756 --- /dev/null +++ b/service/video/tests/unit/testdata/recordingSettingsEnterpriseResponse.json @@ -0,0 +1,10 @@ +{ + "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + "friendly_name": "Enterprise Recording Settings", + "aws_credentials_sid": "CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + "encryption_key_sid": "CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1", + "aws_s3_url": "https://test-bucket.s3.amazonaws.com/recording/", + "aws_storage_enabled": true, + "encryption_enabled": false, + "url": "https://video.twilio.com/v1/RecordingSettings/Default" +} diff --git a/service/video/tests/unit/testdata/recordingSettingsResponse.json b/service/video/tests/unit/testdata/recordingSettingsResponse.json new file mode 100644 index 00000000..d8d3062b --- /dev/null +++ b/service/video/tests/unit/testdata/recordingSettingsResponse.json @@ -0,0 +1,5 @@ +{ + "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + "friendly_name": "Basic Recording Settings", + "url": "https://video.twilio.com/v1/RecordingSettings/Default" +} diff --git a/service/video/tests/unit/video_v1_test.go b/service/video/tests/unit/video_v1_test.go index cc6b7042..ecde8345 100644 --- a/service/video/tests/unit/video_v1_test.go +++ b/service/video/tests/unit/video_v1_test.go @@ -15,8 +15,10 @@ import ( "github.com/RJPearson94/twilio-sdk-go/service/video" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_hook" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_hooks" + "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_settings" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/compositions" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/recording" + "github.com/RJPearson94/twilio-sdk-go/service/video/v1/recording_settings" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/recordings" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/room" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/room/participant" @@ -2411,7 +2413,7 @@ var _ = Describe("Video V1", func() { fixture, _ := ioutil.ReadFile("testdata/internalServerErrorResponse.json") resp := make(map[string]interface{}) json.Unmarshal(fixture, &resp) - return httpmock.NewJsonResponse(404, resp) + return httpmock.NewJsonResponse(500, resp) }, ) @@ -2491,6 +2493,278 @@ var _ = Describe("Video V1", func() { }) }) }) + + Describe("Given I have the composition settings client", func() { + compositionSettingsClient := videoSession.CompositionSettings() + + Describe("When the composition settings resource is successfully retrieved", func() { + httpmock.RegisterResponder("GET", "https://video.twilio.com/v1/CompositionSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/compositionSettingsResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(200, resp) + }, + ) + + resp, err := compositionSettingsClient.Fetch() + It("Then no error should be returned", func() { + Expect(err).To(BeNil()) + }) + + It("Then the get composition settings resource response should be returned", func() { + Expect(resp).ToNot(BeNil()) + Expect(resp.AccountSid).To(Equal("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")) + Expect(resp.FriendlyName).To(Equal("Basic Composition Settings")) + Expect(resp.AWSCredentialSid).To(BeNil()) + Expect(resp.EncryptionKeySid).To(BeNil()) + Expect(resp.AWSS3URL).To(BeNil()) + Expect(resp.AWSStorageEnabled).To(BeNil()) + Expect(resp.EncryptionEnabled).To(BeNil()) + Expect(resp.URL).To(Equal("https://video.twilio.com/v1/CompositionSettings/Default")) + }) + }) + + Describe("When the composition settings resource is successfully retrieved for enterprise account", func() { + httpmock.RegisterResponder("GET", "https://video.twilio.com/v1/CompositionSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/compositionSettingsEnterpriseResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(200, resp) + }, + ) + + resp, err := compositionSettingsClient.Fetch() + It("Then no error should be returned", func() { + Expect(err).To(BeNil()) + }) + + It("Then the get composition settings resource response should be returned", func() { + Expect(resp).ToNot(BeNil()) + Expect(resp.AccountSid).To(Equal("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")) + Expect(resp.FriendlyName).To(Equal("Enterprise Composition Settings")) + Expect(resp.AWSCredentialSid).To(Equal(utils.String("CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))) + Expect(resp.EncryptionKeySid).To(Equal(utils.String("CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1"))) + Expect(resp.AWSS3URL).To(Equal(utils.String("https://test-bucket.s3.amazonaws.com/composition/"))) + Expect(resp.AWSStorageEnabled).To(Equal(utils.Bool(true))) + Expect(resp.EncryptionEnabled).To(Equal(utils.Bool(false))) + Expect(resp.URL).To(Equal("https://video.twilio.com/v1/CompositionSettings/Default")) + }) + }) + + Describe("When the composition settings resource api returns a 500", func() { + httpmock.RegisterResponder("GET", "https://video.twilio.com/v1/CompositionSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/internalServerErrorResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(500, resp) + }, + ) + + resp, err := compositionSettingsClient.Fetch() + It("Then an error should be returned", func() { + ExpectInternalServerError(err) + }) + + It("Then the get composition settings response should be nil", func() { + Expect(resp).To(BeNil()) + }) + }) + + Describe("When the composition settings resource is successfully updated", func() { + updateInput := &composition_settings.UpdateCompositionSettingsInput{ + FriendlyName: "Basic Composition Settings", + } + + httpmock.RegisterResponder("POST", "https://video.twilio.com/v1/CompositionSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/compositionSettingsResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(200, resp) + }, + ) + + resp, err := compositionSettingsClient.Update(updateInput) + It("Then no error should be returned", func() { + Expect(err).To(BeNil()) + }) + + It("Then the update composition settings resource response should be returned", func() { + Expect(resp).ToNot(BeNil()) + Expect(resp.AccountSid).To(Equal("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")) + Expect(resp.FriendlyName).To(Equal("Basic Composition Settings")) + Expect(resp.AWSCredentialSid).To(BeNil()) + Expect(resp.EncryptionKeySid).To(BeNil()) + Expect(resp.AWSS3URL).To(BeNil()) + Expect(resp.AWSStorageEnabled).To(BeNil()) + Expect(resp.EncryptionEnabled).To(BeNil()) + Expect(resp.URL).To(Equal("https://video.twilio.com/v1/CompositionSettings/Default")) + }) + }) + + Describe("When the composition settings resource api returns a 500", func() { + updateInput := &composition_settings.UpdateCompositionSettingsInput{ + FriendlyName: "Basic Composition Settings", + } + + httpmock.RegisterResponder("POST", "https://video.twilio.com/v1/CompositionSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/internalServerErrorResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(500, resp) + }, + ) + + resp, err := compositionSettingsClient.Update(updateInput) + It("Then an error should be returned", func() { + ExpectInternalServerError(err) + }) + + It("Then the update composition settings response should be nil", func() { + Expect(resp).To(BeNil()) + }) + }) + }) + + Describe("Given I have the recording settings client", func() { + recordingSettingsClient := videoSession.RecordingSettings() + + Describe("When the recording settings resource is successfully retrieved", func() { + httpmock.RegisterResponder("GET", "https://video.twilio.com/v1/RecordingSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/recordingSettingsResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(200, resp) + }, + ) + + resp, err := recordingSettingsClient.Fetch() + It("Then no error should be returned", func() { + Expect(err).To(BeNil()) + }) + + It("Then the get recording settings resource response should be returned", func() { + Expect(resp).ToNot(BeNil()) + Expect(resp.AccountSid).To(Equal("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")) + Expect(resp.FriendlyName).To(Equal("Basic Recording Settings")) + Expect(resp.AWSCredentialSid).To(BeNil()) + Expect(resp.EncryptionKeySid).To(BeNil()) + Expect(resp.AWSS3URL).To(BeNil()) + Expect(resp.AWSStorageEnabled).To(BeNil()) + Expect(resp.EncryptionEnabled).To(BeNil()) + Expect(resp.URL).To(Equal("https://video.twilio.com/v1/RecordingSettings/Default")) + }) + }) + + Describe("When the recording settings resource is successfully retrieved for enterprise account", func() { + httpmock.RegisterResponder("GET", "https://video.twilio.com/v1/RecordingSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/recordingSettingsEnterpriseResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(200, resp) + }, + ) + + resp, err := recordingSettingsClient.Fetch() + It("Then no error should be returned", func() { + Expect(err).To(BeNil()) + }) + + It("Then the get recording settings resource response should be returned", func() { + Expect(resp).ToNot(BeNil()) + Expect(resp.AccountSid).To(Equal("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")) + Expect(resp.FriendlyName).To(Equal("Enterprise Recording Settings")) + Expect(resp.AWSCredentialSid).To(Equal(utils.String("CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))) + Expect(resp.EncryptionKeySid).To(Equal(utils.String("CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1"))) + Expect(resp.AWSS3URL).To(Equal(utils.String("https://test-bucket.s3.amazonaws.com/recording/"))) + Expect(resp.AWSStorageEnabled).To(Equal(utils.Bool(true))) + Expect(resp.EncryptionEnabled).To(Equal(utils.Bool(false))) + Expect(resp.URL).To(Equal("https://video.twilio.com/v1/RecordingSettings/Default")) + }) + }) + + Describe("When the recording settings resource api returns a 500", func() { + httpmock.RegisterResponder("GET", "https://video.twilio.com/v1/RecordingSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/internalServerErrorResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(500, resp) + }, + ) + + resp, err := recordingSettingsClient.Fetch() + It("Then an error should be returned", func() { + ExpectInternalServerError(err) + }) + + It("Then the get recording settings response should be nil", func() { + Expect(resp).To(BeNil()) + }) + }) + + Describe("When the recording settings resource is successfully updated", func() { + updateInput := &recording_settings.UpdateRecordingSettingsInput{ + FriendlyName: "Basic Recording Settings", + } + + httpmock.RegisterResponder("POST", "https://video.twilio.com/v1/RecordingSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/recordingSettingsResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(200, resp) + }, + ) + + resp, err := recordingSettingsClient.Update(updateInput) + It("Then no error should be returned", func() { + Expect(err).To(BeNil()) + }) + + It("Then the update recording settings resource response should be returned", func() { + Expect(resp).ToNot(BeNil()) + Expect(resp.AccountSid).To(Equal("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")) + Expect(resp.FriendlyName).To(Equal("Basic Recording Settings")) + Expect(resp.AWSCredentialSid).To(BeNil()) + Expect(resp.EncryptionKeySid).To(BeNil()) + Expect(resp.AWSS3URL).To(BeNil()) + Expect(resp.AWSStorageEnabled).To(BeNil()) + Expect(resp.EncryptionEnabled).To(BeNil()) + Expect(resp.URL).To(Equal("https://video.twilio.com/v1/RecordingSettings/Default")) + }) + }) + + Describe("When the recording settings resource api returns a 500", func() { + updateInput := &recording_settings.UpdateRecordingSettingsInput{ + FriendlyName: "Basic Recording Settings", + } + + httpmock.RegisterResponder("POST", "https://video.twilio.com/v1/RecordingSettings/Default", + func(req *http.Request) (*http.Response, error) { + fixture, _ := ioutil.ReadFile("testdata/internalServerErrorResponse.json") + resp := make(map[string]interface{}) + json.Unmarshal(fixture, &resp) + return httpmock.NewJsonResponse(500, resp) + }, + ) + + resp, err := recordingSettingsClient.Update(updateInput) + It("Then an error should be returned", func() { + ExpectInternalServerError(err) + }) + + It("Then the update recording settings response should be nil", func() { + Expect(resp).To(BeNil()) + }) + }) + }) }) func ExpectInvalidInputError(err error) { diff --git a/service/video/v1/client.go b/service/video/v1/client.go index ad359063..7831d14e 100644 --- a/service/video/v1/client.go +++ b/service/video/v1/client.go @@ -6,8 +6,10 @@ import ( "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_hook" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_hooks" + "github.com/RJPearson94/twilio-sdk-go/service/video/v1/composition_settings" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/compositions" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/recording" + "github.com/RJPearson94/twilio-sdk-go/service/video/v1/recording_settings" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/recordings" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/room" "github.com/RJPearson94/twilio-sdk-go/service/video/v1/rooms" @@ -19,14 +21,16 @@ import ( type Video struct { client *client.Client - Composition func(string) *composition.Client - CompositionHook func(string) *composition_hook.Client - CompositionHooks *composition_hooks.Client - Compositions *compositions.Client - Recording func(string) *recording.Client - Recordings *recordings.Client - Room func(string) *room.Client - Rooms *rooms.Client + Composition func(string) *composition.Client + CompositionHook func(string) *composition_hook.Client + CompositionHooks *composition_hooks.Client + CompositionSettings func() *composition_settings.Client + Compositions *compositions.Client + Recording func(string) *recording.Client + RecordingSettings func() *recording_settings.Client + Recordings *recordings.Client + Room func(string) *room.Client + Rooms *rooms.Client } // NewWithClient creates a new instance of the client with a HTTP client @@ -44,14 +48,16 @@ func NewWithClient(client *client.Client) *Video { Sid: compositionHookSid, }) }, - CompositionHooks: composition_hooks.New(client), - Compositions: compositions.New(client), + CompositionHooks: composition_hooks.New(client), + CompositionSettings: func() *composition_settings.Client { return composition_settings.New(client) }, + Compositions: compositions.New(client), Recording: func(recordingSid string) *recording.Client { return recording.New(client, recording.ClientProperties{ Sid: recordingSid, }) }, - Recordings: recordings.New(client), + RecordingSettings: func() *recording_settings.Client { return recording_settings.New(client) }, + Recordings: recordings.New(client), Room: func(roomSid string) *room.Client { return room.New(client, room.ClientProperties{ Sid: roomSid, diff --git a/service/video/v1/composition_settings/api_op_client.go b/service/video/v1/composition_settings/api_op_client.go new file mode 100644 index 00000000..63fb71f0 --- /dev/null +++ b/service/video/v1/composition_settings/api_op_client.go @@ -0,0 +1,17 @@ +// Package composition_settings contains auto-generated files. DO NOT MODIFY +package composition_settings + +import "github.com/RJPearson94/twilio-sdk-go/client" + +// Client for managing the default composition settings +// See https://www.twilio.com/docs/video/api/encrypted-compositions for more details +type Client struct { + client *client.Client +} + +// New creates a new instance of the composition settings client +func New(client *client.Client) *Client { + return &Client{ + client: client, + } +} diff --git a/service/video/v1/composition_settings/api_op_fetch.go b/service/video/v1/composition_settings/api_op_fetch.go new file mode 100644 index 00000000..bd110c3e --- /dev/null +++ b/service/video/v1/composition_settings/api_op_fetch.go @@ -0,0 +1,43 @@ +// Package composition_settings contains auto-generated files. DO NOT MODIFY +package composition_settings + +import ( + "context" + "net/http" + + "github.com/RJPearson94/twilio-sdk-go/client" +) + +// FetchCompositionSettingsResponse defines the response fields for the retrieved composition settings +type FetchCompositionSettingsResponse struct { + AWSCredentialSid *string `json:"aws_credentials_sid,omitempty"` + AWSS3URL *string `json:"aws_s3_url,omitempty"` + AWSStorageEnabled *bool `json:"aws_storage_enabled,omitempty"` + AccountSid string `json:"account_sid"` + EncryptionEnabled *bool `json:"encryption_enabled,omitempty"` + EncryptionKeySid *string `json:"encryption_key_sid,omitempty"` + FriendlyName string `json:"friendly_name"` + URL string `json:"url"` +} + +// Fetch retrieves the default composition settings +// See https://www.twilio.com/docs/video/api/encrypted-compositions#http-get for more details +// Context is defaulted to Background. See https://golang.org/pkg/context/#Background for more information +func (c Client) Fetch() (*FetchCompositionSettingsResponse, error) { + return c.FetchWithContext(context.Background()) +} + +// FetchWithContext retrieves the default composition settings +// See https://www.twilio.com/docs/video/api/encrypted-compositions#http-get for more details +func (c Client) FetchWithContext(context context.Context) (*FetchCompositionSettingsResponse, error) { + op := client.Operation{ + Method: http.MethodGet, + URI: "/CompositionSettings/Default", + } + + response := &FetchCompositionSettingsResponse{} + if err := c.client.Send(context, op, nil, response); err != nil { + return nil, err + } + return response, nil +} diff --git a/service/video/v1/composition_settings/api_op_update.go b/service/video/v1/composition_settings/api_op_update.go new file mode 100644 index 00000000..0e80b024 --- /dev/null +++ b/service/video/v1/composition_settings/api_op_update.go @@ -0,0 +1,58 @@ +// Package composition_settings contains auto-generated files. DO NOT MODIFY +package composition_settings + +import ( + "context" + "net/http" + + "github.com/RJPearson94/twilio-sdk-go/client" +) + +// UpdateCompositionSettingsInput defines input fields for updating composition settings +type UpdateCompositionSettingsInput struct { + AWSCredentialSid *string `form:"AwsCredentialsSid,omitempty"` + AWSS3URL *string `form:"AwsS3Url,omitempty"` + AWSStorageEnabled *bool `form:"AwsStorageEnabled,omitempty"` + EncryptionEnabled *bool `form:"EncryptionEnabled,omitempty"` + EncryptionKeySid *string `form:"EncryptionKeySid,omitempty"` + FriendlyName string `form:"FriendlyName"` +} + +// UpdateCompositionSettingsResponse defines the response fields for the updated composition settings +type UpdateCompositionSettingsResponse struct { + AWSCredentialSid *string `json:"aws_credentials_sid,omitempty"` + AWSS3URL *string `json:"aws_s3_url,omitempty"` + AWSStorageEnabled *bool `json:"aws_storage_enabled,omitempty"` + AccountSid string `json:"account_sid"` + EncryptionEnabled *bool `json:"encryption_enabled,omitempty"` + EncryptionKeySid *string `json:"encryption_key_sid,omitempty"` + FriendlyName string `json:"friendly_name"` + URL string `json:"url"` +} + +// Update modifies default composition settings +// See https://www.twilio.com/docs/video/api/encrypted-compositions#http-post for more details +// Context is defaulted to Background. See https://golang.org/pkg/context/#Background for more information +func (c Client) Update(input *UpdateCompositionSettingsInput) (*UpdateCompositionSettingsResponse, error) { + return c.UpdateWithContext(context.Background(), input) +} + +// UpdateWithContext modifies default composition settings +// See https://www.twilio.com/docs/video/api/encrypted-compositions#http-post for more details +func (c Client) UpdateWithContext(context context.Context, input *UpdateCompositionSettingsInput) (*UpdateCompositionSettingsResponse, error) { + op := client.Operation{ + Method: http.MethodPost, + URI: "/CompositionSettings/Default", + ContentType: client.URLEncoded, + } + + if input == nil { + input = &UpdateCompositionSettingsInput{} + } + + response := &UpdateCompositionSettingsResponse{} + if err := c.client.Send(context, op, input, response); err != nil { + return nil, err + } + return response, nil +} diff --git a/service/video/v1/recording_settings/api_op_client.go b/service/video/v1/recording_settings/api_op_client.go new file mode 100644 index 00000000..40714e90 --- /dev/null +++ b/service/video/v1/recording_settings/api_op_client.go @@ -0,0 +1,17 @@ +// Package recording_settings contains auto-generated files. DO NOT MODIFY +package recording_settings + +import "github.com/RJPearson94/twilio-sdk-go/client" + +// Client for managing the default recording settings +// See https://www.twilio.com/docs/video/api/encrypted-recordings for more details +type Client struct { + client *client.Client +} + +// New creates a new instance of the recording settings client +func New(client *client.Client) *Client { + return &Client{ + client: client, + } +} diff --git a/service/video/v1/recording_settings/api_op_fetch.go b/service/video/v1/recording_settings/api_op_fetch.go new file mode 100644 index 00000000..1de732f3 --- /dev/null +++ b/service/video/v1/recording_settings/api_op_fetch.go @@ -0,0 +1,43 @@ +// Package recording_settings contains auto-generated files. DO NOT MODIFY +package recording_settings + +import ( + "context" + "net/http" + + "github.com/RJPearson94/twilio-sdk-go/client" +) + +// FetchRecordingSettingsResponse defines the response fields for the retrieved recording settings +type FetchRecordingSettingsResponse struct { + AWSCredentialSid *string `json:"aws_credentials_sid,omitempty"` + AWSS3URL *string `json:"aws_s3_url,omitempty"` + AWSStorageEnabled *bool `json:"aws_storage_enabled,omitempty"` + AccountSid string `json:"account_sid"` + EncryptionEnabled *bool `json:"encryption_enabled,omitempty"` + EncryptionKeySid *string `json:"encryption_key_sid,omitempty"` + FriendlyName string `json:"friendly_name"` + URL string `json:"url"` +} + +// Fetch retrieves the default recording settings +// See https://www.twilio.com/docs/video/api/encrypted-recordings#http-get for more details +// Context is defaulted to Background. See https://golang.org/pkg/context/#Background for more information +func (c Client) Fetch() (*FetchRecordingSettingsResponse, error) { + return c.FetchWithContext(context.Background()) +} + +// FetchWithContext retrieves the default recording settings +// See https://www.twilio.com/docs/video/api/encrypted-recordings#http-get for more details +func (c Client) FetchWithContext(context context.Context) (*FetchRecordingSettingsResponse, error) { + op := client.Operation{ + Method: http.MethodGet, + URI: "/RecordingSettings/Default", + } + + response := &FetchRecordingSettingsResponse{} + if err := c.client.Send(context, op, nil, response); err != nil { + return nil, err + } + return response, nil +} diff --git a/service/video/v1/recording_settings/api_op_update.go b/service/video/v1/recording_settings/api_op_update.go new file mode 100644 index 00000000..b5f2d5bf --- /dev/null +++ b/service/video/v1/recording_settings/api_op_update.go @@ -0,0 +1,58 @@ +// Package recording_settings contains auto-generated files. DO NOT MODIFY +package recording_settings + +import ( + "context" + "net/http" + + "github.com/RJPearson94/twilio-sdk-go/client" +) + +// UpdateRecordingSettingsInput defines input fields for updating recording settings +type UpdateRecordingSettingsInput struct { + AWSCredentialSid *string `form:"AwsCredentialsSid,omitempty"` + AWSS3URL *string `form:"AwsS3Url,omitempty"` + AWSStorageEnabled *bool `form:"AwsStorageEnabled,omitempty"` + EncryptionEnabled *bool `form:"EncryptionEnabled,omitempty"` + EncryptionKeySid *string `form:"EncryptionKeySid,omitempty"` + FriendlyName string `form:"FriendlyName"` +} + +// UpdateRecordingSettingsResponse defines the response fields for the updated recording settings +type UpdateRecordingSettingsResponse struct { + AWSCredentialSid *string `json:"aws_credentials_sid,omitempty"` + AWSS3URL *string `json:"aws_s3_url,omitempty"` + AWSStorageEnabled *bool `json:"aws_storage_enabled,omitempty"` + AccountSid string `json:"account_sid"` + EncryptionEnabled *bool `json:"encryption_enabled,omitempty"` + EncryptionKeySid *string `json:"encryption_key_sid,omitempty"` + FriendlyName string `json:"friendly_name"` + URL string `json:"url"` +} + +// Update modifies default recording settings +// See https://www.twilio.com/docs/video/api/encrypted-recordings#http-post for more details +// Context is defaulted to Background. See https://golang.org/pkg/context/#Background for more information +func (c Client) Update(input *UpdateRecordingSettingsInput) (*UpdateRecordingSettingsResponse, error) { + return c.UpdateWithContext(context.Background(), input) +} + +// UpdateWithContext modifies default recording settings +// See https://www.twilio.com/docs/video/api/encrypted-recordings#http-post for more details +func (c Client) UpdateWithContext(context context.Context, input *UpdateRecordingSettingsInput) (*UpdateRecordingSettingsResponse, error) { + op := client.Operation{ + Method: http.MethodPost, + URI: "/RecordingSettings/Default", + ContentType: client.URLEncoded, + } + + if input == nil { + input = &UpdateRecordingSettingsInput{} + } + + response := &UpdateRecordingSettingsResponse{} + if err := c.client.Send(context, op, input, response); err != nil { + return nil, err + } + return response, nil +}