def test_01_send_sms_regexp_success(self):
responses.add(responses.POST, self.post_url, body=self.success_body)
# Here we need to send the SMS
r = self.regexp_provider.submit_message("+49 123/456-78", "Hello")
self.assertTrue(r)
p = HttpSMSProvider._mangle_phone("+49 123/456-78", self.config_regexp)
self.assertEqual("4912345678", p)
# Replace + with 00
p = HttpSMSProvider._mangle_phone("+49 123/456-78",
{"REGEXP": r"/\+/00/"})
self.assertEqual("0049 123/456-78", p)
p = self.regexp_provider._mangle_phone("+49 123/456-78",
{"REGEXP": r"/[\+/]//"})
self.assertEqual("49 123456-78", p)
# An invalid regexp is caught and a log error is written. The same
# phone number is returned
p = HttpSMSProvider._mangle_phone("+49 123/456-78",
{"REGEXP": r"/+/00/"})
self.assertEqual("+49 123/456-78", p)
# Only use leading numbers and not the rest
p = HttpSMSProvider._mangle_phone("12345abcdef",
{"REGEXP": r"/^([0-9]+).*/\1/"})
self.assertEqual("12345", p)
# Known limitation: The slash in the replace statement does not work!
p = HttpSMSProvider._mangle_phone("12.34.56.78",
{"REGEXP": r"/\./\//"})
self.assertEqual("12.34.56.78", p)
def test_01_send_sms_regexp_success(self):
responses.add(responses.POST,
self.post_url,
body=self.success_body)
# Here we need to send the SMS
r = self.regexp_provider.submit_message("+49 123/456-78", "Hello")
self.assertTrue(r)
p = HttpSMSProvider._mangle_phone("+49 123/456-78", self.config_regexp)
self.assertEqual("4912345678", p)
# Replace + with 00
p = HttpSMSProvider._mangle_phone("+49 123/456-78", {"REGEXP": "/\+/00/"})
self.assertEqual("0049 123/456-78", p)
p = self.regexp_provider._mangle_phone("+49 123/456-78", {"REGEXP": "/[\+/]//"})
self.assertEqual("49 123456-78", p)
# An invalid regexp is caught and a log error is written. The same
# phone number is returned
p = HttpSMSProvider._mangle_phone("+49 123/456-78", {"REGEXP": "/+/00/"})
self.assertEqual("+49 123/456-78", p)
# Only use leading numbers and not the rest
p = HttpSMSProvider._mangle_phone("12345abcdef", {"REGEXP": "/^([0-9]+).*/\\1/"})
self.assertEqual("12345", p)
# Known limitation: The slash in the replace statement does not work!
p = HttpSMSProvider._mangle_phone("12.34.56.78", {"REGEXP": "/\./\//"})
self.assertEqual("12.34.56.78", p)
def setUp(self):
self.post_provider = HttpSMSProvider()
self.post_provider.load_config(self.config_post)
self.get_provider = HttpSMSProvider()
self.get_provider.load_config(self.config_get)
self.simple_provider = HttpSMSProvider()
self.simple_provider.load_config(self.config_simple)
self.auth_provider = HttpSMSProvider()
self.auth_provider.load_config(self.config_basicauth)
self.missing_provider = HttpSMSProvider()
self.missing_provider.load_config(self.config_missing)
def setUp(self):
self.post_provider = HttpSMSProvider()
self.post_provider.load_config(self.config_post)
self.get_provider = HttpSMSProvider()
self.get_provider.load_config(self.config_get)
self.simple_provider = HttpSMSProvider()
self.simple_provider.load_config(self.config_simple)
self.auth_provider = HttpSMSProvider()
self.auth_provider.load_config(self.config_basicauth)
self.missing_provider = HttpSMSProvider()
self.missing_provider.load_config(self.config_missing)
class HttpSMSTestCase(MyTestCase):
post_url = "http://smsgateway.com/sms_send_api.cgi"
config_post = {
"URL": post_url,
"PARAMETER": {
"from": "0170111111",
"password": "******",
"sender": "name",
"account": "company_ltd"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "destination",
"HTTP_Method": "POST",
"PROXY": "http://*****:*****@your-proxy:8080",
"RETURN_SUCCESS": "ID"
}
get_url = "http://api.clickatell.com/http/sendmsg"
config_get = {
"URL": get_url,
"PARAMETER": {
"user": "******",
"password": "******",
"api_id": "12980436"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
"HTTP_Method": "GET",
"PROXY": "http://*****:*****@1.2.3.4:8080",
"RETURN_FAIL": "Failed"
}
simple_url = "http://some.other.service"
config_simple = {
"URL": simple_url,
"PARAMETER": {
"user": "******",
"password": "******",
"api_id": "12980436"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
missing_url = "http://some.missing.url"
config_missing = {
"PARAMETER": {
"user": "******",
"password": "******",
"api_id": "12980436"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
basic_url = "https://*****:*****@secret.gateway/some/path"
config_basicauth = {
"URL": basic_url,
"PARAMETER": {
"user": "******",
"password": "******",
"api_id": "12980436"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
success_body = "ID 12345"
fail_body = "Sent SMS Failed"
def setUp(self):
self.post_provider = HttpSMSProvider()
self.post_provider.load_config(self.config_post)
self.get_provider = HttpSMSProvider()
self.get_provider.load_config(self.config_get)
self.simple_provider = HttpSMSProvider()
self.simple_provider.load_config(self.config_simple)
self.auth_provider = HttpSMSProvider()
self.auth_provider.load_config(self.config_basicauth)
self.missing_provider = HttpSMSProvider()
self.missing_provider.load_config(self.config_missing)
@responses.activate
def test_01_send_sms_post_success(self):
responses.add(responses.POST, self.post_url, body=self.success_body)
# Here we need to send the SMS
r = self.post_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_02_send_sms_post_fail(self):
responses.add(responses.POST, self.post_url, body=self.fail_body)
# Here we need to send the SMS
self.assertRaises(SMSError, self.post_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_03_send_sms_get_success(self):
responses.add(responses.GET, self.get_url, body=self.success_body)
# Here we need to send the SMS
r = self.get_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_04_send_sms_get_fail(self):
responses.add(responses.GET, self.get_url, body=self.fail_body)
# Here we need to send the SMS
self.assertRaises(SMSError, self.get_provider.submit_message, "123456",
"Hello")
@responses.activate
def test_05_simple_service_success(self):
responses.add(responses.GET, self.simple_url, status=200)
r = self.simple_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_06_simple_service_fail(self):
responses.add(responses.GET,
self.simple_url,
body="noting",
status=401)
self.assertRaises(SMSError, self.simple_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_07_missing_fail(self):
responses.add(responses.GET, self.missing_url)
self.assertRaises(SMSError, self.missing_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_08_auth_success(self):
responses.add(responses.GET, self.basic_url)
r = self.auth_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_08_auth_fail(self):
responses.add(responses.GET, self.basic_url, status=401)
self.assertRaises(SMSError, self.missing_provider.submit_message,
"123456", "Hello")
class HttpSMSTestCase(MyTestCase):
post_url = "http://smsgateway.com/sms_send_api.cgi"
config_post = {
"URL": post_url,
"PARAMETER": {
"from": "0170111111",
"password": "******",
"sender": "name",
"account": "company_ltd"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "destination",
"HTTP_Method": "POST",
"PROXY": "http://*****:*****@your-proxy:8080",
"RETURN_SUCCESS": "ID"
}
config_regexp = {
"URL": post_url,
"PARAMETER": {
"from": "0170111111",
"password": "******",
"sender": "name",
"account": "company_ltd"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "destination",
"HTTP_Method": "POST",
"PROXY": "http://*****:*****@your-proxy:8080",
"RETURN_SUCCESS": "ID",
"REGEXP": "/[+-/. ]//"
}
get_url = "http://api.clickatell.com/http/sendmsg"
config_get = {
"URL": get_url,
"PARAMETER": {
"user": "******",
"password": "******",
"api_id": "12980436"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
"HTTP_Method": "GET",
"PROXY": "http://*****:*****@1.2.3.4:8080",
"RETURN_FAIL": "Failed"
}
simple_url = "http://some.other.service"
config_simple = {
"URL": simple_url,
"PARAMETER": {
"user": "******",
"password": "******",
"api_id": "12980436"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
missing_url = "http://some.missing.url"
config_missing = {
"PARAMETER": {
"user": "******",
"password": "******",
"api_id": "12980436"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
basic_url = "https://*****:*****@secret.gateway/some/path"
config_basicauth = {
"URL": basic_url,
"PARAMETER": {
"user": "******",
"password": "******",
"api_id": "12980436"
},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
success_body = "ID 12345"
fail_body = "Sent SMS Failed"
def setUp(self):
self.post_provider = HttpSMSProvider()
self.post_provider.load_config(self.config_post)
self.regexp_provider = HttpSMSProvider()
self.regexp_provider.load_config(self.config_regexp)
self.get_provider = HttpSMSProvider()
self.get_provider.load_config(self.config_get)
self.simple_provider = HttpSMSProvider()
self.simple_provider.load_config(self.config_simple)
self.auth_provider = HttpSMSProvider()
self.auth_provider.load_config(self.config_basicauth)
self.missing_provider = HttpSMSProvider()
self.missing_provider.load_config(self.config_missing)
@responses.activate
def test_01_send_sms_post_success(self):
responses.add(responses.POST, self.post_url, body=self.success_body)
# Here we need to send the SMS
r = self.post_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_01_send_sms_regexp_success(self):
responses.add(responses.POST, self.post_url, body=self.success_body)
# Here we need to send the SMS
r = self.regexp_provider.submit_message("+49 123/456-78", "Hello")
self.assertTrue(r)
p = HttpSMSProvider._mangle_phone("+49 123/456-78", self.config_regexp)
self.assertEqual("4912345678", p)
# Replace + with 00
p = HttpSMSProvider._mangle_phone("+49 123/456-78",
{"REGEXP": r"/\+/00/"})
self.assertEqual("0049 123/456-78", p)
p = self.regexp_provider._mangle_phone("+49 123/456-78",
{"REGEXP": r"/[\+/]//"})
self.assertEqual("49 123456-78", p)
# An invalid regexp is caught and a log error is written. The same
# phone number is returned
p = HttpSMSProvider._mangle_phone("+49 123/456-78",
{"REGEXP": r"/+/00/"})
self.assertEqual("+49 123/456-78", p)
# Only use leading numbers and not the rest
p = HttpSMSProvider._mangle_phone("12345abcdef",
{"REGEXP": r"/^([0-9]+).*/\1/"})
self.assertEqual("12345", p)
# Known limitation: The slash in the replace statement does not work!
p = HttpSMSProvider._mangle_phone("12.34.56.78",
{"REGEXP": r"/\./\//"})
self.assertEqual("12.34.56.78", p)
@responses.activate
def test_02_send_sms_post_fail(self):
responses.add(responses.POST, self.post_url, body=self.fail_body)
# Here we need to send the SMS
self.assertRaises(SMSError, self.post_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_03_send_sms_get_success(self):
responses.add(responses.GET, self.get_url, body=self.success_body)
# Here we need to send the SMS
r = self.get_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_04_send_sms_get_fail(self):
responses.add(responses.GET, self.get_url, body=self.fail_body)
# Here we need to send the SMS
self.assertRaises(SMSError, self.get_provider.submit_message, "123456",
"Hello")
@responses.activate
def test_05_simple_service_success(self):
responses.add(responses.GET, self.simple_url, status=200)
r = self.simple_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_06_simple_service_fail(self):
responses.add(responses.GET,
self.simple_url,
body="noting",
status=401)
self.assertRaises(SMSError, self.simple_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_07_missing_fail(self):
responses.add(responses.GET, self.missing_url)
self.assertRaises(SMSError, self.missing_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_08_auth_success(self):
responses.add(responses.GET, self.basic_url)
r = self.auth_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_08_auth_fail(self):
responses.add(responses.GET, self.basic_url, status=401)
self.assertRaises(SMSError, self.missing_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_10_new_smsgateway(self):
identifier = "myGW"
provider_module = "privacyidea.lib.smsprovider.HttpSMSProvider" \
".HttpSMSProvider"
id = set_smsgateway(identifier,
provider_module,
description="test",
options={
"HTTP_METHOD": "POST",
"URL": "http://example.com",
"RETURN_SUCCESS": "ID",
"text": "{otp}",
"phone": "{phone}"
},
headers={"Authorization": "QWERTZ"})
self.assertTrue(id > 0)
sms = create_sms_instance(identifier)
responses.add(responses.POST,
"http://example.com",
body=self.success_body)
# Here we need to send the SMS
r = sms.submit_message("123456", "Hello")
self.assertTrue(r)
delete_smsgateway(identifier)
@responses.activate
def test_11_send_nonascii_sms_post_success(self):
responses.add(responses.POST, self.post_url, body=self.success_body)
# Here we need to send the SMS
r = self.post_provider.submit_message("123456", u"Hallöle Smørrebrød")
self.assertTrue(r)
class HttpSMSTestCase(MyTestCase):
post_url = "http://smsgateway.com/sms_send_api.cgi"
config_post = {"URL": post_url,
"PARAMETER": {"from": "0170111111",
"password": "******",
"sender": "name",
"account": "company_ltd"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "destination",
"HTTP_Method": "POST",
"PROXY": "http://*****:*****@your-proxy:8080",
"RETURN_SUCCESS": "ID"
}
get_url = "http://api.clickatell.com/http/sendmsg"
config_get = {"URL": get_url,
"PARAMETER": {"user": "******",
"password": "******",
"api_id": "12980436"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
"HTTP_Method": "GET",
"PROXY": "http://*****:*****@1.2.3.4:8080",
"RETURN_FAIL": "Failed"
}
simple_url = "http://some.other.service"
config_simple = {"URL": simple_url,
"PARAMETER": {"user": "******",
"password": "******",
"api_id": "12980436"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
missing_url = "http://some.missing.url"
config_missing = {"PARAMETER": {"user": "******",
"password": "******",
"api_id": "12980436"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
basic_url = "https://*****:*****@secret.gateway/some/path"
config_basicauth = {"URL": basic_url,
"PARAMETER": {"user": "******",
"password": "******",
"api_id": "12980436"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
success_body = "ID 12345"
fail_body = "Sent SMS Failed"
def setUp(self):
self.post_provider = HttpSMSProvider()
self.post_provider.load_config(self.config_post)
self.get_provider = HttpSMSProvider()
self.get_provider.load_config(self.config_get)
self.simple_provider = HttpSMSProvider()
self.simple_provider.load_config(self.config_simple)
self.auth_provider = HttpSMSProvider()
self.auth_provider.load_config(self.config_basicauth)
self.missing_provider = HttpSMSProvider()
self.missing_provider.load_config(self.config_missing)
@responses.activate
def test_01_send_sms_post_success(self):
responses.add(responses.POST,
self.post_url,
body=self.success_body)
# Here we need to send the SMS
r = self.post_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_02_send_sms_post_fail(self):
responses.add(responses.POST,
self.post_url,
body=self.fail_body)
# Here we need to send the SMS
self.assertRaises(SMSError, self.post_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_03_send_sms_get_success(self):
responses.add(responses.GET,
self.get_url,
body=self.success_body)
# Here we need to send the SMS
r = self.get_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_04_send_sms_get_fail(self):
responses.add(responses.GET,
self.get_url,
body=self.fail_body)
# Here we need to send the SMS
self.assertRaises(SMSError, self.get_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_05_simple_service_success(self):
responses.add(responses.GET,
self.simple_url,
status=200)
r = self.simple_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_06_simple_service_fail(self):
responses.add(responses.GET,
self.simple_url,
body="noting",
status=401)
self.assertRaises(SMSError, self.simple_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_07_missing_fail(self):
responses.add(responses.GET,
self.missing_url)
self.assertRaises(SMSError, self.missing_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_08_auth_success(self):
responses.add(responses.GET,
self.basic_url)
r = self.auth_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_08_auth_fail(self):
responses.add(responses.GET,
self.basic_url,
status=401)
self.assertRaises(SMSError, self.missing_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_10_new_smsgateway(self):
identifier = "myGW"
provider_module = "privacyidea.lib.smsprovider.HttpSMSProvider" \
".HttpSMSProvider"
id = set_smsgateway(identifier, provider_module, description="test",
options={"HTTP_METHOD": "POST",
"URL": "http://example.com",
"RETURN_SUCCESS": "ID",
"text": "{otp}",
"phone": "{phone}"})
self.assertTrue(id > 0)
sms = create_sms_instance(identifier)
responses.add(responses.POST,
"http://example.com",
body=self.success_body)
# Here we need to send the SMS
r = sms.submit_message("123456", "Hello")
self.assertTrue(r)
delete_smsgateway(identifier)
@responses.activate
def test_11_send_nonascii_sms_post_success(self):
responses.add(responses.POST,
self.post_url,
body=self.success_body)
# Here we need to send the SMS
r = self.post_provider.submit_message("123456", u"Hallöle Smørrebrød")
self.assertTrue(r)
class HttpSMSTestCase(MyTestCase):
post_url = "http://smsgateway.com/sms_send_api.cgi"
config_post = {"URL": post_url,
"PARAMETER": {"from": "0170111111",
"password": "******",
"sender": "name",
"account": "company_ltd"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "destination",
"HTTP_Method": "POST",
"PROXY": "http://*****:*****@your-proxy:8080",
"RETURN_SUCCESS": "ID"
}
config_regexp = {"URL": post_url,
"PARAMETER": {"from": "0170111111",
"password": "******",
"sender": "name",
"account": "company_ltd"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "destination",
"HTTP_Method": "POST",
"PROXY": "http://*****:*****@your-proxy:8080",
"RETURN_SUCCESS": "ID",
"REGEXP": "/[+-/. ]//"
}
get_url = "http://api.clickatell.com/http/sendmsg"
config_get = {"URL": get_url,
"PARAMETER": {"user": "******",
"password": "******",
"api_id": "12980436"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
"HTTP_Method": "GET",
"PROXY": "http://*****:*****@1.2.3.4:8080",
"RETURN_FAIL": "Failed"
}
simple_url = "http://some.other.service"
config_simple = {"URL": simple_url,
"PARAMETER": {"user": "******",
"password": "******",
"api_id": "12980436"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
missing_url = "http://some.missing.url"
config_missing = {"PARAMETER": {"user": "******",
"password": "******",
"api_id": "12980436"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
basic_url = "https://*****:*****@secret.gateway/some/path"
config_basicauth = {"URL": basic_url,
"PARAMETER": {"user": "******",
"password": "******",
"api_id": "12980436"},
"SMS_TEXT_KEY": "text",
"SMS_PHONENUMBER_KEY": "to",
}
success_body = "ID 12345"
fail_body = "Sent SMS Failed"
def setUp(self):
self.post_provider = HttpSMSProvider()
self.post_provider.load_config(self.config_post)
self.regexp_provider = HttpSMSProvider()
self.regexp_provider.load_config(self.config_regexp)
self.get_provider = HttpSMSProvider()
self.get_provider.load_config(self.config_get)
self.simple_provider = HttpSMSProvider()
self.simple_provider.load_config(self.config_simple)
self.auth_provider = HttpSMSProvider()
self.auth_provider.load_config(self.config_basicauth)
self.missing_provider = HttpSMSProvider()
self.missing_provider.load_config(self.config_missing)
@responses.activate
def test_01_send_sms_post_success(self):
responses.add(responses.POST,
self.post_url,
body=self.success_body)
# Here we need to send the SMS
r = self.post_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_01_send_sms_regexp_success(self):
responses.add(responses.POST,
self.post_url,
body=self.success_body)
# Here we need to send the SMS
r = self.regexp_provider.submit_message("+49 123/456-78", "Hello")
self.assertTrue(r)
p = HttpSMSProvider._mangle_phone("+49 123/456-78", self.config_regexp)
self.assertEqual("4912345678", p)
# Replace + with 00
p = HttpSMSProvider._mangle_phone("+49 123/456-78", {"REGEXP": "/\+/00/"})
self.assertEqual("0049 123/456-78", p)
p = self.regexp_provider._mangle_phone("+49 123/456-78", {"REGEXP": "/[\+/]//"})
self.assertEqual("49 123456-78", p)
# An invalid regexp is caught and a log error is written. The same
# phone number is returned
p = HttpSMSProvider._mangle_phone("+49 123/456-78", {"REGEXP": "/+/00/"})
self.assertEqual("+49 123/456-78", p)
# Only use leading numbers and not the rest
p = HttpSMSProvider._mangle_phone("12345abcdef", {"REGEXP": "/^([0-9]+).*/\\1/"})
self.assertEqual("12345", p)
# Known limitation: The slash in the replace statement does not work!
p = HttpSMSProvider._mangle_phone("12.34.56.78", {"REGEXP": "/\./\//"})
self.assertEqual("12.34.56.78", p)
@responses.activate
def test_02_send_sms_post_fail(self):
responses.add(responses.POST,
self.post_url,
body=self.fail_body)
# Here we need to send the SMS
self.assertRaises(SMSError, self.post_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_03_send_sms_get_success(self):
responses.add(responses.GET,
self.get_url,
body=self.success_body)
# Here we need to send the SMS
r = self.get_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_04_send_sms_get_fail(self):
responses.add(responses.GET,
self.get_url,
body=self.fail_body)
# Here we need to send the SMS
self.assertRaises(SMSError, self.get_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_05_simple_service_success(self):
responses.add(responses.GET,
self.simple_url,
status=200)
r = self.simple_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_06_simple_service_fail(self):
responses.add(responses.GET,
self.simple_url,
body="noting",
status=401)
self.assertRaises(SMSError, self.simple_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_07_missing_fail(self):
responses.add(responses.GET,
self.missing_url)
self.assertRaises(SMSError, self.missing_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_08_auth_success(self):
responses.add(responses.GET,
self.basic_url)
r = self.auth_provider.submit_message("123456", "Hello")
self.assertTrue(r)
@responses.activate
def test_08_auth_fail(self):
responses.add(responses.GET,
self.basic_url,
status=401)
self.assertRaises(SMSError, self.missing_provider.submit_message,
"123456", "Hello")
@responses.activate
def test_10_new_smsgateway(self):
identifier = "myGW"
provider_module = "privacyidea.lib.smsprovider.HttpSMSProvider" \
".HttpSMSProvider"
id = set_smsgateway(identifier, provider_module, description="test",
options={"HTTP_METHOD": "POST",
"URL": "http://example.com",
"RETURN_SUCCESS": "ID",
"text": "{otp}",
"phone": "{phone}"})
self.assertTrue(id > 0)
sms = create_sms_instance(identifier)
responses.add(responses.POST,
"http://example.com",
body=self.success_body)
# Here we need to send the SMS
r = sms.submit_message("123456", "Hello")
self.assertTrue(r)
delete_smsgateway(identifier)
@responses.activate
def test_11_send_nonascii_sms_post_success(self):
responses.add(responses.POST,
self.post_url,
body=self.success_body)
# Here we need to send the SMS
r = self.post_provider.submit_message("123456", u"Hallöle Smørrebrød")
self.assertTrue(r)
