def setUp(self):
self.user = ALISSUser.objects.create_user("*****@*****.**", "passwurd")
self.client.login(username='******', password='******')
t,u,c,s = Fixtures.create_users()
self.user = c
self.user.is_editor = True
self.user.save()
# Create an Organisation for 2 services
self.org = Fixtures.create_organisation(t, u, self.user)
self.new_org = Fixtures.create_organisation(t,u,u)
# Create a service which has been reviewed recently and is represented by user.
self.recently_reviewed_service = Fixtures.create_service(self.org)
utc = pytz.UTC
current_date = datetime.now()
current_date = utc.localize(current_date)
in_range_date = (current_date - timedelta(weeks=5))
self.recently_reviewed_service.last_edited = in_range_date
self.recently_reviewed_service.save()
# Create a service which is outwith review range but is represented by user.
self.unreviewed_service = Service.objects.create(name="Old Service", description="An old service which needs to be reviewed.", organisation=self.org, created_by=self.org.created_by, updated_by=self.org.updated_by)
utc = pytz.UTC
current_date = datetime.now()
current_date = utc.localize(current_date)
outwith_range_date = (current_date - timedelta(weeks=8))
self.unreviewed_service.last_edited = outwith_range_date
self.unreviewed_service.save()
# Create a service which is not represented by the user.
self.different_user_editor = Service.objects.create(name="Different Editor Service", description="A service which isn't edited by the other user.", organisation=self.new_org, created_by=self.new_org.created_by)
def setUp(self):
self.user = ALISSUser.objects.create_user("*****@*****.**",
"passwurd")
self.client.login(username='******', password='******')
self.organisation = Fixtures.create_organisation(self.user)
self.service = Fixtures.create_service(self.organisation)
self.non_edit_user = ALISSUser.objects.create_user(
"*****@*****.**", "passwurd")
def setUp(self):
self.random = ALISSUser.objects.create_user("*****@*****.**",
"passwurd")
self.user, self.editor, self.claimant, self.staff = Fixtures.create_users(
)
self.client.login(username=self.claimant.email, password='******')
self.organisation = Fixtures.create_organisation(
self.user, self.editor, self.claimant)
def setUp(self):
t, u, c, _ = Fixtures.create_users()
self.org = Fixtures.create_organisation(t, u, c)
self.service = Service.objects.create(name="My First Service",
description="A handy service",
organisation=self.org,
created_by=t,
updated_by=u)
def setUp(self):
t, u, c, s = Fixtures.create_users()
self.org = Fixtures.create_organisation(t, u, c)
self.service = Fixtures.create_service(self.org)
self.org2 = Organisation.objects.create(
name="Scottish Optometrist Society",
description="Description of organisation",
created_by=self.org.created_by,
updated_by=self.org.updated_by)
def test_service_edit_without_claimant(self):
new_org = Fixtures.create_organisation(self.organisation.created_by, self.organisation.created_by)
new_service = Fixtures.create_service(new_org)
edit_path = reverse('service_edit', kwargs={ 'pk': new_service.pk })
self.assertEqual(self.client.get(edit_path).status_code, 302)
self.client.login(username=self.user.email, password='******')
self.assertEqual(self.client.get(edit_path).status_code, 200)
self.client.login(username=self.editor.email, password='******')
self.assertEqual(self.client.get(edit_path).status_code, 200)
self.client.login(username=self.staff.email, password='******')
self.assertEqual(self.client.get(edit_path).status_code, 200)
def tearDown(self):
Fixtures.organisation_teardown()
for organisation in Organisation.objects.filter(
name="Banana Unpublished"):
organisation.delete()
for organisation in Organisation.objects.filter(
name="Banana Published"):
organisation.delete()
for organisation in Organisation.objects.filter(
name="an updated organisation"):
organisation.delete()
def setUp(self):
self.user, self.editor, self.claimant, self.staff = Fixtures.create_users(
)
self.client.login(username='******', password='******')
self.organisation = Fixtures.create_organisation(
self.user, self.editor, self.claimant)
self.org2 = Organisation.objects.create(
name="Another's Test Org",
description="A test description",
created_by=self.user,
published=True)
def setUp(self):
t, u, c, s = Fixtures.create_users()
self.org = Fixtures.create_organisation(t, u, c)
l = Location.objects.create(name="my location",
street_address="my street",
locality="a locality",
postal_code="FK1 5XA",
latitude=50.0,
longitude=13.0,
organisation=self.org,
created_by=t,
updated_by=u)
def setUp(self):
t, u, c, _ = Fixtures.create_users()
self.org = Fixtures.create_organisation(t, u, c)
self.org2 = Organisation.objects.create(
name="Test0rg",
description="A test description",
created_by=self.org.created_by,
updated_by=self.org.updated_by)
self.org3 = Organisation.objects.create(
name="Another org",
description="A Test0rg description",
created_by=self.org.created_by,
updated_by=self.org.updated_by)
location1 = Fixtures.create_location(self.org)
location2 = Fixtures.create_another_location(self.org)
self.s1 = Service.objects.create(name="Food For All",
description="A handy food activity",
organisation=self.org,
created_by=t,
updated_by=u)
self.s2 = Service.objects.create(
name="Physical Fun",
description="Physical activity classes",
organisation=self.org,
created_by=t,
updated_by=u)
self.s3 = Service.objects.create(
name="Step Fit 1",
description="Physical activity classes",
organisation=self.org,
created_by=t,
updated_by=u)
self.s4 = Service.objects.create(
name="Step Fit 2",
description="Phyzical activiti classes",
organisation=self.org,
created_by=t,
updated_by=u)
self.s1.locations.add(location1)
self.s1.save()
self.s2.locations.add(location1)
self.s2.save()
self.s3.locations.add(location1)
self.s3.save()
self.s4.locations.add(location2)
self.s4.save()
pks = [self.s1.pk, self.s2.pk, self.s3.pk, self.s4.pk]
self.queryset = get_services(Fixtures.es_connection(), pks)
def test_organisation_added_to_index(self):
queryset = Fixtures.es_organisation_connection()
indexed_organisation = get_organisation_by_id(queryset, self.org.id)[0]
self.assertEqual(indexed_organisation.id, str(self.org.id))
self.assertEqual(indexed_organisation.name, self.org.name)
self.assertEqual(indexed_organisation.description, self.org.description)
self.assertEqual(indexed_organisation.published, self.org.published)
def test_rename_is_reflected_in_index(self):
self.org.name = "Renamed Test Org"
self.org.save()
queryset = Fixtures.es_connection()
indexed_service = get_service(queryset, self.service.id)[0]
self.assertEqual(indexed_service['organisation']['name'],
self.org.name)
def test_adding_category_triggers_reindex(self):
c = Category.objects.create(name='Children', slug='children')
self.service.categories.add(c)
self.service.save()
queryset = Fixtures.es_connection()
result = get_service(queryset, self.service.id)[0]
self.assertEqual(result['categories'][0]['name'], 'Children')
def setUp(self):
self.service = Fixtures.create()
self.category = Category.objects.get(slug="conditions")
self.service.categories.add(self.category)
self.service.save()
self.postcode = Postcode.objects.get(place_name='Glasgow')
self.postcode.generate_place_name_slug()
def test_organisation_filter_organisations_by_query(self):
queryset = Fixtures.es_organisation_connection()
self.org.name = "banana weird"
self.org.save()
result = filter_organisations_by_query(queryset, "banana")
result = order_organistations_by_created_on(result).execute()
self.assertEqual(result[0].name, self.org.name)
def test_org_delete_cascades(self):
queryset = Fixtures.es_connection()
service_id = self.service.id
Organisation.objects.get(name="TestOrg").delete()
s = Service.objects.filter(name="My First Service").exists()
self.assertFalse(s)
result = get_service(queryset, service_id)
self.assertEqual(len(result), 0)
def test_organisation_valid_update_one_service_redirects_to_org_detail(
self):
Fixtures.create_service(self.organisation)
self.assertEqual(self.organisation.services.count(), 1)
response = self.client.post(
reverse('organisation_edit', kwargs={'pk': self.organisation.pk}),
{
'name': 'an updated organisation',
'description': 'a full description'
})
self.organisation.refresh_from_db()
self.assertEqual(self.organisation.name, 'an updated organisation')
self.assertEqual(response.status_code, 302)
self.assertRedirects(
response,
reverse('organisation_detail_slug',
kwargs={'slug': self.organisation.slug}))
def test_is_edited_by_without_claimant(self):
o = Fixtures.create_organisation(self.org.created_by, self.org.created_by)
staff = ALISSUser.objects.get(email="*****@*****.**")
editor = ALISSUser.objects.filter(is_editor=True).first()
punter = ALISSUser.objects.create(name="Ms Random", email="*****@*****.**")
self.assertTrue(o.is_edited_by(o.created_by))
self.assertTrue(o.is_edited_by(staff))
self.assertTrue(o.is_edited_by(editor))
self.assertFalse(o.is_edited_by(punter))
def test_service_not_in_removed_category(self):
queryset = Fixtures.es_connection()
c = Category.objects.get(slug='food-nutrition')
self.service.categories.add(c)
self.service.save()
indexed_service = get_service(queryset, self.service.id)[0]
self.assertEqual(len(indexed_service['categories']), 1)
c.delete()
indexed_service = get_service(queryset, self.service.id)[0]
self.assertEqual(len(indexed_service['categories']), 0)
def test_organisation_query(self):
org_queryset = get_organisations(
Fixtures.es_organisation_connection(),
[self.org3.pk, self.org2.pk, self.org.pk])
result = filter_organisations_by_query(org_queryset, "TestOrg")
x = result.execute()
order = keyword_order(result)
orgs = Organisation.objects.filter(id__in=order["ids"]).order_by(
order["order"])
self.assertTrue(self.org2 in orgs) #basic test for travis
self.assertTrue(self.org in orgs)
def test_unpublished_service_is_not_indexed(self):
queryset = Fixtures.es_connection()
self.org.published = False
self.org.save()
unpublished_service = Service.objects.create(
name="My Second Service",
description="A handy service",
organisation=self.org,
created_by=self.org.created_by)
result = get_service(queryset, unpublished_service.id)
self.assertEqual(len(result), 0)
def test_organisation_publish(self):
queryset = Fixtures.es_connection()
org_queryset = Fixtures.es_organisation_connection()
self.organisation.published = False
self.organisation.save()
unpublished_service = Fixtures.create_service(self.organisation)
index_result = get_service(queryset, unpublished_service.id)
self.client.login(username='******', password='******')
self.assertEqual(len(index_result), 0)
response = self.client.post(
reverse('organisation_publish',
kwargs={'pk': self.organisation.pk}))
self.organisation.refresh_from_db()
index_result = get_service(queryset, unpublished_service.id)
self.assertEqual(len(index_result), 1)
self.assertTrue(self.organisation.published)
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, (reverse('organisation_unpublished')))
org_index_result = get_organisation_by_id(org_queryset,
self.organisation.id)
self.assertEqual(len(org_index_result), 1)
def test_specificity_of_organisation_search(self):
queryset = Fixtures.es_organisation_connection()
exact_query = "Scottish Optometrist Society"
inexact_query = "Scottish Optometrist Society Glasgow"
undesired_query = "Scottish Ontology Society"
result_exact_query = filter_organisations_by_query(queryset, exact_query).execute()
result_inexact_query = filter_organisations_by_query(queryset, inexact_query).execute()
result_undesired_query = filter_organisations_by_query(queryset, undesired_query).execute()
while len(result_inexact_query) == 0:
inexact_query = inexact_query[:-1]
result_inexact_query = filter_organisations_by_query(queryset, inexact_query).execute()
self.assertEqual(result_exact_query[0].name, self.org2.name)
self.assertEqual(result_inexact_query[0].name, self.org2.name)
def test_organisation_filter_organisations_by_query_published(self):
queryset = Fixtures.es_organisation_connection()
published_org = Organisation.objects.create(name="Banana Published")
unpublished_org = Organisation.objects.create(name="Banana Unpublished")
unpublished_org.published = False
unpublished_org.save()
result_all = filter_organisations_by_query(queryset, "Banana")
result_all = order_organistations_by_created_on(result_all).execute()
result_published = filter_organisations_by_query_published(queryset, "Banana")
result_published = order_organistations_by_created_on(result_published).execute()
self.assertEqual(unpublished_org.published, False)
self.assertEqual(result_all[0].name, unpublished_org.name)
self.assertEqual(result_published[0].name, published_org.name)
def test_service_has_renamed_category(self):
c = Category.objects.get(slug='food-nutrition')
self.service.categories.add(c)
self.service.save()
c.name = "food and nutrition"
c.save()
queryset = Fixtures.es_connection()
indexed_service = get_service(queryset, self.service.id)[0]
is_categorised = c.services.filter(id=self.service.id).exists()
is_reindexed = c.name == indexed_service['categories'][0]['name']
self.assertTrue(is_categorised)
self.assertTrue(is_reindexed)
def test_is_edited_by_without_claimant(self):
o = Fixtures.create_organisation(self.org.created_by,
self.org.created_by)
s = Service.objects.create(name="My Other Service",
description="A handy service",
organisation=o,
created_by=o.created_by,
updated_by=o.created_by)
editor = ALISSUser.objects.filter(is_editor=True).first()
punter = ALISSUser.objects.create(name="Ms Random",
email="*****@*****.**")
staff = ALISSUser.objects.create(name="Ms Staff",
email="*****@*****.**",
is_staff=True)
self.assertTrue(s.is_edited_by(staff))
self.assertTrue(s.is_edited_by(s.organisation.created_by))
self.assertTrue(s.is_edited_by(editor))
self.assertFalse(s.is_edited_by(punter))
def test_service_last_edited_valid_update(self):
old_last_edited_db = self.service.last_edited
category = Category.objects.first()
response = self.client.post(reverse('service_edit', kwargs={ 'pk': self.service.pk }),{
'name': 'an updated service',
'description': 'a full description',
'categories': [category.pk],
'service_areas': [ServiceArea.objects.first().pk]
})
self.service.refresh_from_db()
queryset = Fixtures.es_connection()
result = get_service(queryset, self.service.id)[0]
new_last_edited_db = self.service.last_edited
new_last_edited_db_string = datetime.strftime(new_last_edited_db, '%Y-%m-%dT%H:%M:%S.%f%z')
new_last_edited_db_string = new_last_edited_db_string.split('+0000')[0] + '+00:00'
new_last_edited_es = result.last_edited
self.assertFalse(old_last_edited_db == new_last_edited_db)
self.assertEqual(new_last_edited_db_string, new_last_edited_es)
def test_service_valid_update(self):
category = Category.objects.first()
response = self.client.post(reverse('service_edit', kwargs={ 'pk': self.service.pk }),{
'name': 'an updated service',
'description': 'a full description',
'categories': [category.pk],
'service_areas': [ServiceArea.objects.first().pk]
})
self.service.refresh_from_db()
queryset = Fixtures.es_connection()
result = get_service(queryset, self.service.id)[0]
category_count = len(result['categories'])
self.assertEqual(category_count, 1)
self.assertEqual(result['categories'][0]['name'], category.name)
self.assertEqual(self.service.name, 'an updated service')
self.assertEqual(self.service.slug, 'an-updated-service')
self.assertEqual(self.service.updated_by, self.claimant)
self.assertEqual(response.status_code, 302)
def setUp(self):
self.service = Fixtures.create()
self.client = Client()
self.service_area = ServiceArea.objects.create(name="Glasgow City",
code="S12000046",
type=2)
self.service.service_areas.add(self.service_area)
self.json = [{
"type": "Feature",
"properties": {
"objectid": 367,
"lad18cd": "S12000046",
"lad18nm": "Glasgow City",
"lad18nmw": " ",
"bng_e": 261534,
"bng_n": 667033,
"long": -4.21478987,
"lat": 55.87649918,
"st_lengthshape": 87924.48121595873,
"st_areashape": 178587434.4940189
},
"geometry": {
"type":
"Polygon",
"coordinates": [[[-4.22757646963653, 55.84081553872844],
[-4.220433264726125, 55.83310425737028],
[-4.203007300727329, 55.844130518897764],
[-4.198829334532107, 55.83364798685698],
[-4.1804898990481405, 55.83560899707189],
[-4.172507226824287, 55.82296684476971],
[-4.130597432692027, 55.833279606480424],
[-4.11115145611575, 55.82586813565916],
[-4.107031799473984, 55.83465258585653],
[-4.102168742410194, 55.84250963744821],
[-4.074704107764738, 55.84411998674332],
[-4.088392245481783, 55.85384163365652],
[-4.07170515706163, 55.861265911112824],
[-4.0788068400535575, 55.88159950475184],
[-4.125307155035274, 55.88806399060322],
[-4.164381219874791, 55.883579446485044],
[-4.161513411101066, 55.89796798928821],
[-4.180416081418078, 55.90490867347386],
[-4.23635858978936, 55.896837124435116],
[-4.268383291163433, 55.9284934924348],
[-4.29804968016659, 55.92916718621031],
[-4.301264046518112, 55.91636316093881],
[-4.290421039505743, 55.91179233824439],
[-4.327840412927068, 55.899689581141544],
[-4.348485417356666, 55.90523469625339],
[-4.346215139629732, 55.916491741547055],
[-4.379617070281586, 55.92098003574179],
[-4.38995268453848, 55.91051121707005],
[-4.375474565129326, 55.900024310313725],
[-4.393185434590535, 55.889146094405824],
[-4.353433592083708, 55.87373892258495],
[-4.364671452280923, 55.855324020386945],
[-4.3808725531791355, 55.856341638812914],
[-4.368029290969201, 55.84543955689139],
[-4.381413610864957, 55.82314784365725],
[-4.367452746966189, 55.81770031827132],
[-4.372059266506329, 55.79476489137978],
[-4.333448420839391, 55.79287413281156],
[-4.3262378658889675, 55.80844527340661],
[-4.29262476699183, 55.813935584676024],
[-4.260682240293996, 55.811014284814924],
[-4.268245839347655, 55.791639837344164],
[-4.25074091092872, 55.784885787523535],
[-4.226698115233537, 55.781274889272446],
[-4.2239299554509, 55.79194394392795],
[-4.204285017833057, 55.800446051142366],
[-4.214529591879311, 55.8150721321777],
[-4.22548763203423, 55.81217257653224],
[-4.233751583019541, 55.81865629355188],
[-4.22757646963653, 55.84081553872844]]]
}
}]
def test_service_update_reindexes(self):
queryset = Fixtures.es_connection()
self.service.name = "My Updated Service"
self.service.save()
result = get_service(queryset, self.service.id)[0]
self.assertEqual(result['name'], self.service.name)
