complete offer.smtp tests devel
authorSandro Knauß <knauss@netzguerilla.net>
Sat, 18 Feb 2012 17:13:38 +0100
branchdevel
changeset 169 aabc04843d25
parent 168 42b55855e3a6
child 170 2a16943f1d05
complete offer.smtp tests
iro/model/message.py
iro/offer/provider.py
iro/offer/smtp.py
tests/smtp.py
--- a/iro/model/message.py	Wed Feb 15 14:43:37 2012 +0100
+++ b/iro/model/message.py	Sat Feb 18 17:13:38 2012 +0100
@@ -19,8 +19,9 @@
         return not self.__eq__(other)
 
 class SMS(Message):
-    def __init__(self, cont):
+    def __init__(self, cont, from_ = None):
         Message.__init__(self, cont, typ="sms")
+        self.from_ = from_
 
     def sendto(self,anbieter,recipients):
         anbieter.sendSMS(self,recipients)
--- a/iro/offer/provider.py	Wed Feb 15 14:43:37 2012 +0100
+++ b/iro/offer/provider.py	Sat Feb 18 17:13:38 2012 +0100
@@ -1,10 +1,9 @@
 from functools import partial
 
 class Provider():
-    def __init__(self, name, config, routes=[], typs=[]):
+    def __init__(self, name, config, typs={}):
         self.name = name
         self.config = config
-        self.routes=routes
         self.typs=typs
         self.testmode = False
         
--- a/iro/offer/smtp.py	Wed Feb 15 14:43:37 2012 +0100
+++ b/iro/offer/smtp.py	Sat Feb 18 17:13:38 2012 +0100
@@ -21,7 +21,7 @@
 
 class SMTP(Provider):
     def __init__(self, name, config):
-        Provider.__init__(self,name,config,["std"],["mail"])
+        Provider.__init__(self,name,config,{"mail":[None]})
         
 
     def loadConfig(self):
@@ -50,40 +50,39 @@
                raise NeededOption(self.name, n) 
 
     def send(self,mail,recipient):   
+        if not self.testmode:
+            if self.bSSL:
+                smtp = smtplib.SMTP_SSL(self.host,self.port)
+            else:
+                smtp = smtplib.SMTP(self.host,self.port)
+            
+            if self.bTLS:
+                smtp.starttls()
+           
+            if not self.user == "":
+                smtp.login(self.user,self.password)
         try:
+            frm=self.send_from
+            
+            if mail.getFrom():
+                frm = mail.getFrom()
+            
+            tmpmail=copy.deepcopy(mail)
+            tmpmail.content['From'] = frm 
+            tmpmail.content['To']=recipient
             if not self.testmode:
-                if self.bSSL:
-                    smtp = smtplib.SMTP_SSL(self.host,self.port)
-                else:
-                    smtp = smtplib.SMTP(self.host,self.port)
-                
-                if self.bTLS:
-                    smtp.starttls()
-               
-                if not self.user == "":
-                    smtp.login(self.user,self.password)
-            try:
-                frm=self.send_from
-                
-                if mail.getFrom():
-                    frm = mail.getFrom()
-                
-                tmpmail=copy.deepcopy(mail)
-                tmpmail.content['From'] = frm 
-                tmpmail.content['To']=recipient
-                if not self.testmode:
-                    smtp.sendmail(frm,  recipient, tmpmail.as_string())
-                return Status(self, "std")
-            finally:
-                smtp.quit()
-        except Exception as e:
-            return Status(self,"std",e)
+                smtp.sendmail(frm,  recipient, tmpmail.as_string())
+            return Status(self, "std")
+        finally:
+            smtp.quit()
 
     def getSendFunc(self, typ, route):
-        if typ != "mail":
+        try:
+            if route not in self.typs[typ]:
+                raise NoRoute(route)
+        except KeyError:
             raise NoTyp(route)
-        elif  route != "std":
-            raise NoRoute(route)
+        
         return self.send
 
 providers["smtp"]=SMTP
--- a/tests/smtp.py	Wed Feb 15 14:43:37 2012 +0100
+++ b/tests/smtp.py	Sat Feb 18 17:13:38 2012 +0100
@@ -5,7 +5,10 @@
 import base64
 from smtp_helper import TestSMTPServer
 
+from mock import patch, Mock
+import smtplib
 
+from iro.error import NoRoute, NoTyp, NeededOption, UnknownOption
 from iro.model.message import Mail
 from iro.offer.smtp import SMTP
 
@@ -20,15 +23,21 @@
     def tearDown(self):
         self.smtp_server.close()
 
+    def getSMTP(self, c=None):
+        ret={"send_from":"send@t.de",
+            "host":HOST,
+            "port":PORT,
+            "user":"",
+            "password":"",
+            }
+
+        if c:
+            ret.update(c)
+
+        return SMTP("test",ret.items())
+
     def testSendMail(self):
-        c=[("send_from","send@t.de"),
-            ("host",HOST),
-            ("port",PORT),
-            ("user",""),
-            ("password",""),
-            ]
-
-        p=SMTP("test",c)
+        p=self.getSMTP()
         content = "sadfadfgwertsdgsdf\n\nsdfgaerasdfsad\nadfasdf"
         status = p.send(Mail("sub", content, None), "t@t.de")
 
@@ -46,14 +55,7 @@
         self.assertEqual(base64.b64decode(msg.get_payload()),content)
 
     def testSendMailExtraFrm(self):
-        c=[("send_from","send@t.de"),
-            ("host",HOST),
-            ("port",PORT),
-            ("user",""),
-            ("password",""),
-            ]
-
-        p=SMTP("test",c)
+        p=self.getSMTP()
         content = ""
         status = p.send(Mail("sub", content, "f@t.de"), "t@t.de")
 
@@ -67,30 +69,85 @@
         self.assertEqual(msg.get_all("From"),["f@t.de"])
 
     def testSendMailException(self):
-        c=[("send_from","send@t.de"),
-            ("host",HOST),
-            ("port",PORT-1),
-            ("user",""),
-            ("password",""),
-            ]
-
-        p=SMTP("test",c)
+        p=self.getSMTP({"port":PORT-1})
         content = ""
-        status = p.send(Mail("sub", content, "f@t.de"), "t@t.de")
-        self.assertEqual(status.status, status.ERROR)
-        self.assertIsInstance(status.error,IOError)
-        self.assertEqual(status.error.errno,111)
+        self.assertRaises(IOError, p.send, Mail("sub", content, "f@t.de"), "t@t.de")
 
         self.assertEqual(len(self.smtp_server.rcvd), 0)
 
-    def testNeededOption(self):
-        pass
-    testNeededOption.todo = "test NeededOption is not implemented"
+    @patch("smtplib.SMTP_SSL")
+    def testSSLSendMail(self,mock_ssl):
+        def se(*args):
+            return smtplib.SMTP(*args)
+        mock_ssl.side_effect=se
+
+        p=self.getSMTP({"SSL":True})
+        content = "sadfadfgwertsdgsdf\n\nsdfgaerasdfsad\nadfasdf"
+        status = p.send(Mail("sub", content, None), "t@t.de")
+
+        self.assertEqual(mock_ssl.call_count,1)
+        self.assertEqual(status.status, status.GOOD)
+
+        self.assertEqual(len(self.smtp_server.rcvd), 1)
+
+    @patch("smtplib.SMTP")
+    def testTLSSendMail(self,mock_smtp):
+        mock_s = Mock()
+        mock_smtp.return_value = mock_s
+
+        p=self.getSMTP({"TLS":True})
+        content = "sadfadfgwertsdgsdf\n\nsdfgaerasdfsad\nadfasdf"
+        status = p.send(Mail("sub", content, None), "t@t.de")
+        
+        mock_s.starttls.assert_called_once_with()
+        self.assertEqual(mock_s.sendmail.call_count,1)
+        self.assertEqual([i[0] for i in mock_s.method_calls],["starttls","sendmail","quit"])
+        self.assertEqual(status.status, status.GOOD)
+
+    @patch("smtplib.SMTP")
+    def testLoginSendMail(self,mock_smtp):
+        mock_s = Mock()
+        mock_smtp.return_value = mock_s
 
-    def testUnknownOption(self):
-        pass
-    testUnknownOption.todo = "test UnknownOption is not implemented"
+        p=self.getSMTP({"user":"user","password":"pw"})
+        content = "sadfadfgwertsdgsdf\n\nsdfgaerasdfsad\nadfasdf"
+        status = p.send(Mail("sub", content, None), "t@t.de")
+        
+        mock_s.login.assert_called_once_with("user","pw")
+        self.assertEqual(mock_s.sendmail.call_count,1)
+        self.assertEqual([i[0] for i in mock_s.method_calls],["login","sendmail","quit"])
+        self.assertEqual(status.status, status.GOOD)
+
+    
+    def testNeededOption(self):
+        c={"send_from":"send@t.de",
+            "host":HOST,
+            "port":PORT,
+            "user":"u",
+            "password":"p",
+            }
+        s=SMTP("test",c.items())
+        self.assertEqual(s.send_from, "send@t.de")
+        self.assertEqual(s.host, HOST)
+        self.assertEqual(s.port, PORT)
+        self.assertEqual(s.user, "u")
+        self.assertEqual(s.password, "p")
+        self.assertEqual(s.bSSL,False)
+        self.assertEqual(s.bTLS,False)
+
+        c.update({"TLS":True, "SSL":True})
+        s=SMTP("test", c.items())
+        self.assertEqual(s.bSSL,True)
+        self.assertEqual(s.bTLS,True)
+        
+        del c["host"]
+        self.assertRaises(NeededOption,SMTP,"test",c.items())
+
+        c = {"unknown":""}
+        self.assertRaises(UnknownOption,SMTP,"test",c.items())
 
     def testSendFunc(self):
-        pass
-    testSendFunc.todo = "test getSendFunc is not implemented"
+        s = self.getSMTP()
+        self.assertEqual(s.getSendFunc("mail",None), s.send)
+        self.assertRaises(NoRoute,s.getSendFunc,"mail","foo")
+        self.assertRaises(NoTyp,s.getSendFunc,"mail2","foo")