def test_spool_no_time_no_user_error(self):
     """Ensure that `spool` raises `NoUserError` if the user attribute is
     not a real system user.
     """
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir,
             user='asjdfgkhkgaskqtjwhkjwetghqekjtbkwthbjkltwhwklt')
     c.spool()

 def test_buildfile_valid_archive(self):
     """Ensure that `buildfile` works with a well-formed `archive`
     attribute.
     """
     c = CallFile(self.call, self.action, archive=True,
             spool_dir=self.spool_dir)
     ok_('Archive: yes' in ''.join(c.buildfile()))

 def test_spool_no_time_no_user_permission_error(self):
     """Ensure that `spool` raises `NoUserPermissionError` if the user
     specified does not have permissions to write to the Asterisk spooling
     directory.
     """
     c = CallFile(self.call, self.action, spool_dir='/', user='root')
     c.spool()

 def test_spool_no_time_no_user(self):
     """Ensure `spool` works when no `time` attribute is supplied, and no
     `user` attribute exists.
     """
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir)
     c.spool()
     ok_((path(c.spool_dir) / path(c.filename)).abspath().exists())

 def test_spool_no_time_user(self):
     """Ensure that `spool` works when no `time` attribute is specified, and
     a valid `user` attribute exists.
     """
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir,
             user=getuser())
     c.spool()

    def test_spool_no_time_no_spool_permission_error(self):
        """Ensure that `spool` raises `NoSpoolPermissionError` if the user
        doesn't have permissions to write to `spool_dir`.

        NOTE: This test WILL fail if the user account you run this test under
        has write access to the / directory on your local filesystem.
        """
        c = CallFile(self.call, self.action, spool_dir='/')
        c.spool()

def dialout():
    call_from = request.args.get('from', '')
    call_to = request.args.get('to', '')
    cfrom = 'SIP/{}@hotvoip'.format(call_from)
    cto = 'SIP/{}@hotvoip'.format(call_to)
    c = Call(cfrom)
    a = Application('Dial', cto)
    cf = CallFile(c, a)
    cf.spool()
    return 'dialed'

def localcall():
    call_from = request.args.get('from', '')
    call_to = request.args.get('to', '')
    if call_from and call_to:
        cfrom = 'SIP/{}'.format(call_from)
        logging.debug(cfrom)
        cto = 'SIP/{}'.format(call_to)
        logging.debug(cto)
        c = Call(cfrom)
        a = Application('Dial', cto)
        cf = CallFile(c, a)
        cf.spool()
    else:
        return "no call made"
    return "call made"

 def test_is_valid_invalid_spool_dir(self):
     """Ensure `is_valid` fails given an invalid `spool_dir` attribute."""
     c = CallFile(self.call, self.action, spool_dir='/woot')
     assert_false(c.is_valid())

 def test_is_valid_invalid_action(self):
     """Ensure `is_valid` fails given an invalid `action` attribute."""
     c = CallFile(self.call, 'action', spool_dir=self.spool_dir)
     assert_false(c.is_valid())

 def test_is_valid_invalid_call(self):
     """Ensure `is_valid` fails given an invalid `call` attribute."""
     c = CallFile('call', self.action, spool_dir=self.spool_dir)
     assert_false(c.is_valid())

 def test_is_valid_valid_call_is_valid(self):
     """Ensure `is_valid` works when `call.is_valid()` works."""
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir)
     ok_(c.is_valid())

 def test_is_valid_valid_spool_dir(self):
     """Ensure `is_valid` works using a valid `spool_dir` attribute."""
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir)
     ok_(c.is_valid())

 def test_str(self):
     """Ensure `__str__` works."""
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir)
     ok_('archive' in c.__str__() and 'user' in c.__str__() and
         'spool_dir' in c.__str__())

 def test_spool_time_no_user(self):
     """Ensure that `spool` works when given a valid `time` parameter."""
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir)
     d = datetime.now()
     c.spool(d)
     eq_((path(c.tempdir) / path(c.filename)).abspath().atime, mktime(d.timetuple()))

 def test_is_valid_invalid_call_is_valid(self):
     """Ensure `is_valid` fails when `call.is_valid()` fails."""
     c = CallFile(Call('channel', wait_time='10'), self.action,
             spool_dir=self.spool_dir)
     assert_false(c.is_valid())

 def test_buildfile_invalid_archive(self):
     """Ensure `buildfile` works when `archive` is false."""
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir)
     assert_false('Archive:' in ''.join(c.buildfile()))

 def test_writefile_creates_file(self):
     """Ensure that `writefile` actually generates a call file on the disk.
     """
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir)
     c.writefile()
     ok_((path(c.tempdir) / path(c.filename)).abspath().exists())

 def test_buildfile_is_valid(self):
     """Ensure `buildfile` works with well-formed attributes."""
     c = CallFile(self.call, self.action, spool_dir=self.spool_dir)
     ok_(c.buildfile())

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author: Joshua
# @E-Mail: [email protected]
# @Date:   2015-04-29 17:52:36
# @About test.py

from pycall import CallFile, Call, Application
call = Call('SIP/flowroute/13694182569')
action = Application('Playback', 'hello-world')
c = CallFile(call, action)
c.spool()