Exemple #1
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.ip_messaging.v2.services("ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                       .channels.create(x_twilio_webhook_enabled="true")

        headers = {
            'X-Twilio-Webhook-Enabled': "true",
        }
        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://ip-messaging.twilio.com/v2/Services/ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Channels',
                headers=headers,
            ))
Exemple #2
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.ip_messaging.v1.credentials.create(type="gcm")

        values = {
            'Type': "gcm",
        }

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://ip-messaging.twilio.com/v1/Credentials',
                data=values,
            ))
Exemple #3
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.chat.v2.services(sid="ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                               .channels(sid="CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                               .members.create(identity="identity")

        values = {'Identity': "identity"}

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://chat.twilio.com/v2/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Channels/CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Members',
                data=values,
            ))
 def test_create_request(self):
     self.holodeck.mock(Response(500, ''))
     
     with self.assertRaises(TwilioException):
         self.client.preview.wireless.commands.create(device="device", command="command")
     
     values = {
         'Device': "device",
         'Command': "command",
     }
     
     self.holodeck.assert_has_request(Request(
         'post',
         'https://preview.twilio.com/wireless/Commands',
         data=values,
     ))
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.api.v2010.accounts(sid="ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .incoming_phone_numbers(sid="PNaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .assigned_add_ons.create(installed_add_on_sid="XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")

        values = {'InstalledAddOnSid': "XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://api.twilio.com/2010-04-01/Accounts/ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/IncomingPhoneNumbers/PNaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/AssignedAddOns.json',
                data=values,
            ))
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.sync.v1.services(sid="ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                               .sync_maps(sid="MPaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                               .sync_map_items.create(key="key", data="{}")

        values = {'Key': "key", 'Data': serialize.object("{}")}

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://sync.twilio.com/v1/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Maps/MPaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Items',
                data=values,
            ))
Exemple #7
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.proxy.v1.services.create(unique_name="unique_name")

        values = {
            'UniqueName': "unique_name",
        }

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://proxy.twilio.com/v1/Services',
                data=values,
            ))
    def test_fetch_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.authy.v1.services(sid="ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                .entities(identity="identity").fetch(twilio_authy_sandbox_mode="twilio_authy_sandbox_mode")

        headers = {
            'Twilio-Authy-Sandbox-Mode': "twilio_authy_sandbox_mode",
        }
        self.holodeck.assert_has_request(
            Request(
                'get',
                'https://authy.twilio.com/v1/Services/ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Entities/identity',
                headers=headers,
            ))
Exemple #9
0
    def test_update_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.conversations.v1.services("ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                        .users("USXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").update(x_twilio_webhook_enabled="true")

        headers = {
            'X-Twilio-Webhook-Enabled': "true",
        }
        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://conversations.twilio.com/v1/Services/ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Users/USXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
                headers=headers,
            ))
Exemple #10
0
    def test_fetch_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.preview.trusted_comms.brands_information().fetch(
                if_none_match="if_none_match")

        headers = {
            'If-None-Match': "if_none_match",
        }
        self.holodeck.assert_has_request(
            Request(
                'get',
                'https://preview.twilio.com/TrustedComms/BrandsInformation',
                headers=headers,
            ))
Exemple #11
0
    def test_update_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.taskrouter.v1.workspaces("WSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                     .tasks("WTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").update(if_match="if_match")

        headers = {
            'If-Match': "if_match",
        }
        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://taskrouter.twilio.com/v1/Workspaces/WSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Tasks/WTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
                headers=headers,
            ))
    def test_update_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.preview.sync.services(sid="ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                    .sync_maps(sid="MPaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                    .sync_map_permissions(identity="identity").update(read=True, write=True, manage=True)

        values = {'Read': True, 'Write': True, 'Manage': True}

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://preview.twilio.com/Sync/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Maps/MPaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Permissions/identity',
                data=values,
            ))
Exemple #13
0
    def test_delete_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.preview.sync.services(sid="ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                    .documents(sid="ETXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").delete(if_match="if_match")

        headers = {
            'If-Match': "if_match",
        }
        self.holodeck.assert_has_request(
            Request(
                'delete',
                'https://preview.twilio.com/Sync/Services/ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Documents/ETXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
                headers=headers,
            ))
Exemple #14
0
    def test_delete_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.api.v2010.accounts("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                 .sip \
                                 .domains("SDXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                 .auth \
                                 .calls \
                                 .ip_access_control_list_mappings("ALXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").delete()

        self.holodeck.assert_has_request(
            Request(
                'delete',
                'https://api.twilio.com/2010-04-01/Accounts/ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/SIP/Domains/SDXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Auth/Calls/IpAccessControlListMappings/ALXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.json',
            ))
Exemple #15
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.preview.acc_security.services.create(name="name")

        values = {
            'Name': "name",
        }

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://preview.twilio.com/Verification/Services',
                data=values,
            ))
Exemple #16
0
    def test_update_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.api.v2010.accounts(sid="ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .calls(sid="CAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .feedback().update(quality_score=1)

        values = {'QualityScore': 1}

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://api.twilio.com/2010-04-01/Accounts/ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Calls/CAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Feedback.json',
                data=values,
            ))
    def test_list_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.api.v2010.accounts("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                 .sip \
                                 .domains("SDXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                 .auth \
                                 .registrations \
                                 .credential_list_mappings.list()

        self.holodeck.assert_has_request(
            Request(
                'get',
                'https://api.twilio.com/2010-04-01/Accounts/ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/SIP/Domains/SDXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Auth/Registrations/CredentialListMappings.json',
            ))
Exemple #18
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.chat.v1.services.create(friendly_name="friendly_name")

        values = {
            'FriendlyName': "friendly_name",
        }

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://chat.twilio.com/v1/Services',
                data=values,
            ))
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.api.v2010.accounts(sid="ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .sip \
                                 .credential_lists(sid="CLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .credentials.create(username="******", password="******")

        values = {'Username': "******", 'Password': "******", }

        self.holodeck.assert_has_request(Request(
            'post',
            'https://api.twilio.com/2010-04-01/Accounts/ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/SIP/CredentialLists/CLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Credentials.json',
            data=values,
        ))
Exemple #20
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.notify.v1.services(sid="ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .users(identity="NUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .segment_memberships.create(segment="segment")

        values = {'Segment': "segment"}

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://notify.twilio.com/v1/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Users/NUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/SegmentMemberships',
                data=values,
            ))
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.preview.marketplace.installed_add_ons.create(available_add_on_sid="XBaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", accept_terms_of_service=True)

        values = {
            'AvailableAddOnSid': "XBaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            'AcceptTermsOfService': True,
        }

        self.holodeck.assert_has_request(Request(
            'post',
            'https://preview.twilio.com/marketplace/InstalledAddOns',
            data=values,
        ))
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.api.v2010.accounts(sid="ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .sip \
                                 .domains(sid="SDaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                 .credential_list_mappings.create(credential_list_sid="CLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")

        values = {'CredentialListSid': "CLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}

        self.holodeck.assert_has_request(Request(
            'post',
            'https://api.twilio.com/2010-04-01/Accounts/ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/SIP/Domains/SDaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/CredentialListMappings.json',
            data=values,
        ))
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.proxy.v1.services(sid="KSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                .short_codes.create(sid="SCaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")

        values = {
            'Sid': "SCaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
        }

        self.holodeck.assert_has_request(Request(
            'post',
            'https://proxy.twilio.com/v1/Services/KSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/ShortCodes',
            data=values,
        ))
 def test_create_request(self):
     self.holodeck.mock(Response(500, ''))
     
     with self.assertRaises(TwilioException):
         self.client.ip_messaging.v1.services(sid="ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                    .users.create(identity="identity")
     
     values = {
         'Identity': "identity",
     }
     
     self.holodeck.assert_has_request(Request(
         'post',
         'https://ip-messaging.twilio.com/v1/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Users',
         data=values,
     ))
Exemple #25
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.conversations.v1.conversations("CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                        .participants.create(x_twilio_webhook_enabled="true")

        headers = {
            'X-Twilio-Webhook-Enabled': "true",
        }
        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://conversations.twilio.com/v1/Conversations/CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Participants',
                headers=headers,
            ))
Exemple #26
0
    def test_delete_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.conversations.v1.conversations("CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                        .messages("IMXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").delete(x_twilio_webhook_enabled="true")

        headers = {
            'X-Twilio-Webhook-Enabled': "true",
        }
        self.holodeck.assert_has_request(
            Request(
                'delete',
                'https://conversations.twilio.com/v1/Conversations/CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Messages/IMXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
                headers=headers,
            ))
Exemple #27
0
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.preview.understand.services(sid="UAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                          .intents(sid="UDaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
                                          .fields.create(field_type="field_type", unique_name="unique_name")

        values = {'FieldType': "field_type", 'UniqueName': "unique_name"}

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://preview.twilio.com/understand/Services/UAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Intents/UDaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Fields',
                data=values,
            ))
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.wireless.v1.commands.create(command="command")

        values = {
            'Command': "command",
        }

        self.holodeck.assert_has_request(
            Request(
                'post',
                'https://wireless.twilio.com/v1/Commands',
                data=values,
            ))
    def test_delete_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.chat.v2.services(sid="ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                               .channels(sid="CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").delete(x_twilio_webhook_enabled="true")

        headers = {
            'X-Twilio-Webhook-Enabled': "true",
        }
        self.holodeck.assert_has_request(
            Request(
                'delete',
                'https://chat.twilio.com/v2/Services/ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Channels/CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
                headers=headers,
            ))
    def test_create_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.api.v2010.accounts(sid="ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                 .sip \
                                 .ip_access_control_lists(sid="ALXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                 .ip_addresses.create(friendly_name="friendly_name", ip_address="ip_address")

        values = {'FriendlyName': "friendly_name", 'IpAddress': "ip_address", }

        self.holodeck.assert_has_request(Request(
            'post',
            'https://api.twilio.com/2010-04-01/Accounts/ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/SIP/IpAccessControlLists/ALXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/IpAddresses.json',
            data=values,
        ))