def test_can_save_a_member6(self):
mbr = Member(
self.member.account,
{
'email':"*****@*****.**",
'fields': {'first_name':"Emma"}
})
MockAdapter.expected = {
'status': "a",
'added': True,
'member_id': 1024
}
result = mbr.save(group_ids=[1025])
self.assertIsNone(result)
self.assertEqual(mbr.account.adapter.called, 1)
self.assertEqual(mbr.account.adapter.call,
(
'POST',
'/members/add',
{
'email':"*****@*****.**",
'fields': {'first_name': "Emma"},
'group_ids': [1025]
}
))
def setUp(self):
Account.default_adapter = MockAdapter
self.member = Member(
Account(account_id="100", public_key="xxx", private_key="yyy"), {
'member_id':
1000,
'email':
u"*****@*****.**",
'status':
u"opt-out",
'member_status_id':
u"o",
'change_type':
u"u",
'last_modified_at':
datetime.now().strftime(SERIALIZED_DATETIME_FORMAT),
'member_since':
datetime.now().strftime(SERIALIZED_DATETIME_FORMAT),
'deleted_at':
None
})
self.member.account.fields._dict = {
2000: {
'shortcut_name': u"first_name"
},
2001: {
'shortcut_name': u"last_name"
}
}
def test_can_save_a_member4(self):
mbr = Member(
self.member.account,
{
'member_id': 200,
'email':"*****@*****.**",
'first_name':"Emma",
'member_status_id': MemberStatus.Active
})
MockAdapter.expected = False
with self.assertRaises(ex.MemberUpdateError):
mbr.save()
self.assertEqual(mbr.account.adapter.called, 1)
self.assertEqual(mbr.account.adapter.call,
(
'PUT',
'/members/200',
{
'member_id': 200,
'email':"*****@*****.**",
'fields': {'first_name': "Emma"},
'status_to': mbr['member_status_id']
}
))
def test_can_delete_a_member(self):
mbr = Member(self.member.account, {'email': u"*****@*****.**"})
with self.assertRaises(ex.NoMemberIdError):
mbr.delete()
self.assertEquals(self.member.account.adapter.called, 0)
self.assertFalse(self.member.is_deleted())
def find_one_by_email(self, email, deleted=False):
"""
Lazy-loads a single :class:`Member` by email address
:param email: The email address
:type email: :class:`str`
:param deleted: Whether to include deleted members
:type deleted: :class:`bool`
:rtype: :class:`Member` or :class:`None`
Usage::
>>> from emma.model.account import Account
>>> acct = Account(1234, "08192a3b4c5d6e7f", "f7e6d5c4b3a29180")
>>> acct.members.find_one_by_email("*****@*****.**") # does not exist
raises <KeyError>
>>> acct.members.find_one_by_email("*****@*****.**")
<Member{'member_id': 123, 'email': u"*****@*****.**", ...}>
>>> acct.members["*****@*****.**"]
<Member{'member_id': 123, 'email': u"*****@*****.**", ...}>
"""
path = '/members/email/%s' % email
params = {"deleted": True} if deleted else {}
members = [x for x in self._dict.values() if x['email'] == email]
if not members:
member = self.account.adapter.get(path, params)
if member is not None:
self._dict[member['member_id']] = \
Member(self.account, member)
return self._dict[member['member_id']]
else:
member = members[0]
return member
def find_one_by_member_id(self, member_id, deleted=False):
"""
Lazy-loads a single :class:`Member` by ID
:param member_id: The member identifier
:type member_id: :class:`int`
:param deleted: Whether to include deleted members
:type deleted: :class:`bool`
:rtype: :class:`Member` or :class:`None`
Usage::
>>> from emma.model.account import Account
>>> acct = Account(1234, "08192a3b4c5d6e7f", "f7e6d5c4b3a29180")
>>> acct.members.find_one_by_member_id(0) # does not exist
raises <KeyError>
>>> acct.members.find_one_by_member_id(123)
<Member{'member_id': 123, 'email': u"*****@*****.**", ...}>
>>> acct.members[123]
<Member{'member_id': 123, 'email': u"*****@*****.**", ...}>
"""
member_id = int(member_id)
path = '/members/%s' % member_id
params = {"deleted": True} if deleted else {}
if member_id not in self._dict:
raw = self.account.adapter.get(path, params)
if raw:
self._dict[member_id] = Member(self.account, raw)
return (member_id in self._dict) and self._dict[member_id] or None
def setUp(self):
Account.default_adapter = MockAdapter
self.mailings = Member(
Account(account_id="100", public_key="xxx", private_key="yyy"), {
'member_id': 1000,
'email': u"*****@*****.**",
'status': u"opt-out"
}).mailings
def test_can_add_groups_to_a_member(self):
mbr = Member(self.groups.member.account)
with self.assertRaises(ex.NoMemberIdError):
mbr.groups.save([
mbr.groups.factory({'member_group_id':1024})
])
self.assertEqual(self.groups.member.account.adapter.called, 0)
def test_can_ask_if_member_has_opted_out2(self):
member = Member(
self.member.account, {
'member_id': 1000,
'email': u"*****@*****.**",
'member_status_id': u"active"
})
has_opted_out = member.has_opted_out()
self.assertIsInstance(has_opted_out, bool)
self.assertFalse(has_opted_out)
self.assertEquals(member.account.adapter.called, 0)
def test_can_save_a_member(self):
mbr = Member(self.member.account, {'email':"*****@*****.**"})
MockAdapter.expected = {
'status': "a",
'added': True,
'member_id': 1024
}
result = mbr.save()
self.assertIsNone(result)
self.assertEqual(mbr.account.adapter.called, 1)
self.assertEqual(
mbr.account.adapter.call,
('POST', '/members/add', {'email':"*****@*****.**"}))
self.assertEqual(1024, mbr['member_id'])
self.assertEqual(MemberStatus.Active, mbr['member_status_id'])
def test_can_delete_a_member2(self):
MockAdapter.expected = None
mbr = Member(
self.member.account, {
'member_id': 200,
'email': u"*****@*****.**",
'deleted_at':
datetime.now().strftime(SERIALIZED_DATETIME_FORMAT)
})
result = mbr.delete()
self.assertIsNone(result)
self.assertEquals(mbr.account.adapter.called, 0)
self.assertTrue(mbr.is_deleted())
def test_can_delete_a_member3(self):
MockAdapter.expected = True
mbr = Member(self.member.account, {
'member_id': 200,
'email': u"*****@*****.**",
'deleted_at': None
})
result = mbr.delete()
self.assertIsNone(result)
self.assertEquals(mbr.account.adapter.called, 1)
self.assertEquals(mbr.account.adapter.call,
('DELETE', '/members/200', {}))
self.assertTrue(mbr.is_deleted())
def test_can_opt_out_a_member2(self):
member = Member(
self.member.account, {
'member_id': 1000,
'email': u"*****@*****.**",
'member_status_id': u"a"
})
MockAdapter.expected = True
self.assertFalse(member.has_opted_out())
result = member.opt_out()
self.assertIsNone(result)
self.assertEquals(member.account.adapter.called, 1)
self.assertEquals(
member.account.adapter.call,
('PUT', '/members/email/optout/[email protected]', {}))
self.assertTrue(member.has_opted_out())
def factory(self, raw=None):
"""
New :class:`Member` factory
:param raw: Raw data with which to populate class
:type raw: :class:`dict`
:rtype: :class:`Member`
Usage::
>>> from emma.model.account import Account
>>> acct = Account(1234, "08192a3b4c5d6e7f", "f7e6d5c4b3a29180")
>>> acct.members.factory()
<Member{}>
>>> acct.members.factory({'email': u"*****@*****.**"})
<Member{'email': u"*****@*****.**"}>
"""
return Member(self.account, raw)
def fetch_all_by_import_id(self, import_id):
"""
Updates the collection with a dictionary of all members from a given
import. *Does not lazy-load*
:param import_id: The import identifier
:type import_id: :class:`int` or :class:`str`
:rtype: :class:`dict` of :class:`Member` objects
Usage::
>>> from emma.model.account import Account
>>> acct = Account(1234, "08192a3b4c5d6e7f", "f7e6d5c4b3a29180")
>>> acct.members.fetch_all_by_import_id(123)
{123: <Member>, 321: <Member>, ...}
"""
path = '/members/imports/%s/members' % import_id
members = dict((x['member_id'], Member(self.account, x))
for x in self.account.adapter.get(path))
self._replace_all(members)
return members
def test_can_save_a_member3(self):
mbr = Member(
self.member.account,
{'email':"*****@*****.**",
'first_name':"Emma"})
MockAdapter.expected = {
'status': "a",
'added': True,
'member_id': 1024
}
result = mbr.save(signup_form_id="http://example.com/signup")
self.assertIsNone(result)
self.assertEqual(mbr.account.adapter.called, 1)
self.assertEqual(
mbr.account.adapter.call,
('POST', '/members/add', {
'email':"*****@*****.**",
'fields': {'first_name': "Emma"},
'signup_form_id': "http://example.com/signup"}
))
self.assertEqual(1024, mbr['member_id'])
self.assertEqual(MemberStatus.Active, mbr['member_status_id'])
def fetch_all(self, deleted=False):
"""
Lazy-loads the full set of :class:`Member` objects
:param deleted: Whether to include deleted members
:type deleted: :class:`bool`
:rtype: :class:`dict` of :class:`Member` objects
Usage::
>>> from emma.model.account import Account
>>> acct = Account(1234, "08192a3b4c5d6e7f", "f7e6d5c4b3a29180")
>>> acct.members.fetch_all()
{123: <Member>, 321: <Member>, ...}
"""
path = '/members'
params = {"deleted": True} if deleted else {}
if not self._dict:
self._dict = dict(
(x['member_id'], Member(self.account, x))
for x in self.account.adapter.paginated_get(path, params))
return self._dict
def test_can_save_a_member5(self):
mbr = Member(
self.member.account, {
'member_id': 200,
'email': u"*****@*****.**",
'fields': {
'first_name': u"Emma"
},
'member_status_id': MemberStatus.Active
})
MockAdapter.expected = True
result = mbr.save()
self.assertIsNone(result)
self.assertEquals(mbr.account.adapter.called, 1)
self.assertEquals(mbr.account.adapter.call,
('PUT', '/members/200', {
'member_id': 200,
'email': u"*****@*****.**",
'fields': {
'first_name': u"Emma"
},
'status_to': mbr['member_status_id']
}))
def fetch_all(self):
"""
Lazy-loads the full set of :class:`Member` objects
:rtype: :class:`dict` of :class:`Member` objects
Usage::
>>> from emma.model.account import Account
>>> acct = Account(1234, "08192a3b4c5d6e7f", "f7e6d5c4b3a29180")
>>> imprt = acct.imports[1024]
>>> imprt.members.fetch_all()
{200: <Member>, 201: <Member>, ...}
"""
if not 'import_id' in self.member_import:
raise ex.NoImportIdError()
path = '/members/imports/%s/members' % self.member_import['import_id']
if not self._dict:
self._dict = dict(
(x['member_id'], Member(self.member_import.account, x))
for x in self.member_import.account.adapter.paginated_get(
path))
return self._dict
def test_can_opt_out_a_member(self):
member = Member(self.member.account)
with self.assertRaises(ex.NoMemberEmailError):
member.opt_out()
self.assertEquals(member.account.adapter.called, 0)
def test_can_get_opt_out_detail_for_member2(self):
MockAdapter.expected = []
member = Member(self.member.account)
with self.assertRaises(ex.NoMemberIdError):
member.get_opt_out_detail()
self.assertEquals(member.account.adapter.called, 0)
def test_fetch_all_returns_a_dictionary(self):
member = Member(self.mailings.member.account)
mailings = MemberMailingCollection(member)
with self.assertRaises(ex.NoMemberIdError):
mailings.fetch_all()
self.assertEquals(mailings.member.account.adapter.called, 0)
def test_can_ask_if_member_has_opted_out3(self):
member = Member(self.member.account)
with self.assertRaises(ex.NoMemberStatusError):
member.has_opted_out()
self.assertEquals(member.account.adapter.called, 0)
def test_can_drop_groups_from_a_member(self):
mbr = Member(self.groups.member.account)
with self.assertRaises(ex.NoMemberIdError):
mbr.groups.delete([300, 301])
self.assertEquals(self.groups.member.account.adapter.called, 0)
def test_fetch_all_returns_a_dictionary(self):
groups = MemberGroupCollection(Member(self.groups.member.account))
with self.assertRaises(ex.NoMemberIdError):
groups.fetch_all()
self.assertEquals(groups.member.account.adapter.called, 0)
