def test_list_inactive(self):
inactive_type = SegmentTypeFactory(is_active=False)
SegmentFactory.create(type=inactive_type)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()['data']), 20)
def test_activity_segment_admin(self):
event = EventFactory.create()
event_url = reverse('admin:events_event_change', args=(event.id, ))
response = self.client.get(event_url)
self.assertNotContains(response, 'Segment:')
segment_type = SegmentTypeFactory.create()
SegmentFactory.create_batch(5, type=segment_type)
response = self.client.get(event_url)
self.assertContains(response, 'Segment:')
def setUp(self):
super(SegmentTypeListAPITestCase, self).setUp()
self.client = JSONAPITestClient()
self.url = reverse('segment-type-list')
self.user = BlueBottleUserFactory()
for i in range(5):
segment_type = SegmentTypeFactory.create()
SegmentFactory.create_batch(3, type=segment_type)
def test_segment_admin(self):
segment_type = SegmentTypeFactory.create()
SegmentFactory.create_batch(5, type=segment_type)
segment_url = reverse('admin:segments_segmenttype_change',
args=(segment_type.id, ))
response = self.client.get(segment_url)
self.assertContains(response, 'Segment')
list_url = reverse('admin:segments_segmenttype_changelist')
response = self.client.get(list_url)
self.assertContains(response, 'Number of segments')
def test_user_created_segments_list(self, authenticate_request):
team = SegmentTypeFactory.create(name='Team')
team_segment = SegmentFactory.create(
name='Online Marketing',
type=team,
)
SegmentFactory.create(name='Direct Marketing', type=team)
with self.settings(TOKEN_AUTH={}):
user, created = self.auth.authenticate()
self.assertEqual(authenticate_request.call_count, 1)
self.assertTrue(created)
self.assertEqual(user.email, '*****@*****.**')
self.assertTrue(team_segment in user.segments.all())
def test_filter_segment_mismatch(self):
first = EventFactory.create(status='open', )
first_segment = SegmentFactory.create()
first.segments.add(first_segment)
second_segment = SegmentFactory.create()
first.segments.add(second_segment)
EventFactory.create(status='open')
response = self.client.get(self.url + '?filter[segment.{}]={}'.format(
first_segment.type.slug, second_segment.pk),
user=self.owner)
data = json.loads(response.content)
self.assertEqual(data['meta']['pagination']['count'], 0)
def setUp(self):
team_type = SegmentTypeFactory.create(name='Team')
self.team = SegmentFactory.create(name='Online Marketing',
type=team_type)
self.other_team = SegmentFactory.create(name='Direct Marketing',
type=team_type)
unit_type = SegmentTypeFactory.create(name='Unit')
self.unit = SegmentFactory.create(name='Marketing', type=unit_type)
SegmentFactory.create(name='Communications', type=unit_type)
self.user = BlueBottleUserFactory()
self.user.segments.add(self.team)
self.user.segments.add(self.unit)
super(ActivitySegmentsTestCase, self).setUp()
def setUp(self):
super(SegmentListAPITestCase, self).setUp()
self.client = JSONAPITestClient()
self.url = reverse('segment-list')
self.user = BlueBottleUserFactory()
self.segment_type = SegmentTypeFactory.create()
self.segments = SegmentFactory.create_batch(20, type=self.segment_type)
def test_user_created_segments_list_no_match(self, authenticate_request):
member_settings = MemberPlatformSettings.load()
member_settings.create_segments = False
member_settings.save()
team = SegmentTypeFactory.create(name='Team')
SegmentFactory.create(
name='Online Marketing',
type=team,
)
SegmentFactory.create(name='Direct Marketing', type=team)
with self.settings(TOKEN_AUTH={}):
user, created = self.auth.authenticate()
self.assertEqual(authenticate_request.call_count, 1)
self.assertTrue(created)
self.assertEqual(user.email, '*****@*****.**')
self.assertEqual(len(user.segments.all()), 0)
def test_export_user_segments(self):
from_date = now() - timedelta(weeks=2)
to_date = now() + timedelta(weeks=1)
users = BlueBottleUserFactory.create_batch(5)
segment_type = SegmentTypeFactory.create(name='Department')
engineering = SegmentFactory.create(type=segment_type,
name='Engineering')
rubbish = SegmentFactory.create(type=segment_type, name='Rubbish')
users[0].segments.add(engineering)
initiative = InitiativeFactory.create(owner=users[0])
assignment = AssignmentFactory.create(owner=users[1],
initiative=initiative)
assignment.segments.add(engineering)
assignment.segments.add(rubbish)
ApplicantFactory.create(activity=assignment, user=users[2])
data = {'from_date': from_date, 'to_date': to_date, '_save': 'Confirm'}
tenant = connection.tenant
result = plain_export(Exporter, tenant=tenant, **data)
book = xlrd.open_workbook(result)
self.assertEqual(book.sheet_by_name('Users').ncols, 12)
self.assertEqual(
book.sheet_by_name('Users').cell(0, 11).value, 'Department')
t = 0
while t < book.sheet_by_name('Users').nrows:
if book.sheet_by_name('Users').cell(t, 5).value == users[0].email:
self.assertEqual(
book.sheet_by_name('Users').cell(t, 11).value,
'Engineering')
t += 1
self.assertEqual(
book.sheet_by_name('Tasks').cell(0, 23).value, 'Department')
t = 0
while t < book.sheet_by_name('Users').nrows:
if book.sheet_by_name('Users').cell(t, 5).value == users[0].email:
self.assertTrue(
book.sheet_by_name('Tasks').cell(t, 23).value in
['Engineering, Rubbish', 'Rubbish, Engineering'])
t += 1
def test_search_segment_name(self):
first = EventFactory.create(status='open', )
first.segments.add(SegmentFactory(name='Online Marketing'))
EventFactory.create(status='open')
response = self.client.get(self.url + '?filter[search]=marketing',
user=self.owner)
data = json.loads(response.content)
self.assertEqual(data['meta']['pagination']['count'], 1)
self.assertEqual(data['data'][0]['id'], str(first.pk))
def test_user_updated_segments(self, authenticate_request):
user = BlueBottleUserFactory.create(remote_id='*****@*****.**')
team = SegmentTypeFactory.create(name='Team')
team_segment = SegmentFactory.create(name='Online Marketing',
type=team)
user.segments.add(
SegmentFactory.create(name='Direct Marketing', type=team))
unit = SegmentTypeFactory.create(name='Unit')
unit_segment = SegmentFactory.create(name='Marketing', type=unit)
user.segments.add(
SegmentFactory.create(name='Communications', type=unit))
with self.settings(TOKEN_AUTH={}):
user, created = self.auth.authenticate()
self.assertEqual(authenticate_request.call_count, 1)
self.assertFalse(created)
self.assertEqual(user.email, '*****@*****.**')
self.assertEqual(len(user.segments.all()), 2)
self.assertTrue(team_segment in user.segments.all())
self.assertTrue(unit_segment in user.segments.all())
def test_user_created_segments_alternative_name(self,
authenticate_request):
team = SegmentTypeFactory.create(name='Team')
team_segment = SegmentFactory.create(
name='Online Marketing',
type=team,
alternate_names=['Marketing, online'])
SegmentFactory.create(name='Direct Marketing', type=team)
unit = SegmentTypeFactory.create(name='Unit')
unit_segment = SegmentFactory.create(name='Marketing', type=unit)
SegmentFactory.create(name='Communications', type=unit)
with self.settings(TOKEN_AUTH={}):
user, created = self.auth.authenticate()
self.assertEqual(authenticate_request.call_count, 1)
self.assertTrue(created)
self.assertEqual(user.email, '*****@*****.**')
self.assertTrue(team_segment in user.segments.all())
self.assertTrue(unit_segment in user.segments.all())