def test_detail_get_past(self): occ = get(Occurrence, place=F(point=F(geometry=geos.Point(y=0, x=0)))) uri = self.resource().get_resource_uri(occ) resp = self.client.get(uri, data=self.auth_params) resp_dict = try_json_loads(resp.content) self.assertIsNone(resp_dict, 'Returned unexpected existing occurrence') self.assertResponseCode(resp, 410)
def test_detail_get_future(self): occ = get(Occurrence, start_date=datetime.datetime.now().date() + datetime.timedelta(days=30), place=F(point=F(geometry=geos.Point(y=0, x=0)))) uri = self.resource().get_resource_uri(occ) resp = self.client.get(uri, data=self.auth_params) resp_dict = try_json_loads(resp.content) self.assertIsNotNone(resp_dict, 'Malformed response') self.assertResponseCode(resp, 200) self.assertEqual(uri, resp_dict['resource_uri'], 'Unexpected resource uri in response') event_field = resp_dict.get('event') self.assertIsInstance( event_field, basestring, 'Did not find expected reference to associated event URI') place_field = resp_dict.get('place') self.assertIsInstance(place_field, dict, 'Full occurrence does not have place dict') point_field = place_field.get('point') self.assertIsInstance(point_field, dict, 'Full occurrence dict does not have point dict') city_field = point_field.get('city') self.assertIsInstance(city_field, dict, 'Full occurrence dict does not have city dict')
def test_message_shout_attachments(self): """ Result contains distinct shouts that has message attachments, linked to requested conversation """ c2 = G(Conversation, type=CONVERSATION_TYPE_CHAT, creator=self.user1) m1 = G(Message, user=self.user1, conversation=self.c1) m2 = G(Message, user=self.user1, conversation=c2) shout1 = self.create_shout(user=self.user1, category=F(name='velo', slug='velo'), item=F(name='Marin')) shout2 = self.create_shout(user=self.user1, category=F(name='flower', slug='flower'), item=F(name='Rose')) shout1.message_attachments.add( G(MessageAttachment, type=MESSAGE_ATTACHMENT_TYPE_SHOUT, message=m1, conversation=self.c1), G(MessageAttachment, type=MESSAGE_ATTACHMENT_TYPE_SHOUT, message=m1, conversation=self.c1), ) shout2.message_attachments.add( G(MessageAttachment, type=MESSAGE_ATTACHMENT_TYPE_SHOUT, message=m2, conversation=c2)) self.login(self.user1) resp = self.client.get(self.get_url(self.c1.pk)) self.assert200(resp) self.assert_ids_equal(self.decode_json(resp)['results'], [shout1])
def test_adapt_existing_valid(self): occurrence = G(Occurrence, place=F(point=F(geometry=geos.Point(y=0, x=0)))) existing_prices = {G(Price, occurrence=occurrence, quantity=quantity) for quantity in self.quantities} prices = self.adaptor.adapt_m2o(self.event_response, occurrence=occurrence.id) for created, price in prices: self.assertFalse(created, 'Price object created despite existing match') self.assertIn(price, existing_prices, 'Price object returned is not the existing match')
def test_adapt_new_valid(self): occurrence = G(Occurrence, place=F(point=F(geometry=geos.Point(y=0, x=0)))) prices = self.adaptor.adapt_m2o(self.event_response, occurrence=occurrence.id) for created, price in prices: self.assertTrue(created, 'Price object was not newly created') self.assertIsInstance(price, Price, 'Unexpected type of price object') self.assertIn(price.quantity, self.quantities, 'Unexpected quantity value') self.assertEqual(u'dollars', price.units, 'Unexpected units value')
def test_adapt_new_invalid(self): occurrence = G(Occurrence, place=F(point=F(geometry=geos.Point(y=40.7601, x=-73.9925)))) created_prices = self.adaptor.adapt_m2o(self.invalid_response, occurrence=occurrence.id) self.assertTrue(all(not created for created, price in created_prices), 'Price object created despite invalid data') self.assertTrue(all(price is None for created, price in created_prices), 'Price object returned despite invalid data')
def test_look_up_alias_with_many_parameters(self): self.assertEquals({'a': 1, 'b': 2}, look_up_alias(a=1, b=2)) self.assertEquals({'a': 1, 'b_c': 2}, look_up_alias(a=1, b_c=2)) self.assertEquals({'a': 1, 'b': F(c=2)}, look_up_alias(a=1, b__c=2)) self.assertEquals({ 'a': F(b=1), 'c': F(d=2) }, look_up_alias(a__b=1, c__d=2))
def test_m2m_with_many_elements(self): instance = G(ModelWithRelationships, integer=1000, manytomany=[F(integer=1001), F(integer=1002)]) self.assertEquals(1000, instance.integer) self.assertEquals(1001, instance.manytomany.all()[0].integer) self.assertEquals(1002, instance.manytomany.all()[1].integer)
def test_list_get_future(self): get(Occurrence, start_date=datetime.datetime.now().date() + datetime.timedelta(days=10), place=F(point=F(geometry=geos.Point(y=0, x=0)))) resp = self.client.get(self.uri, data=self.auth_params) self.assertResponseCode(resp, 200) self.assertResponseMetaList(resp, 1)
def slot_initial_data(db): G(Slot, zone=F(num=1), mon=True, start_time=time(8, 0), end_time=time(9, 59)) G(Slot, zone=F(num=1), mon=True, start_time=time(14, 0), end_time=time(15, 59)) good_data = { 'zone': reverse('heating:zone-detail', args=[1]), 'mode': 'E', 'start_time': '10:00', 'end_time': '14:00', 'mon': True } return good_data
def test_string_representation(self): start = timezone.make_aware(datetime.datetime(2015, 2, 25, 17, 24), timezone.get_default_timezone()) end = timezone.make_aware(datetime.datetime(2015, 3, 18, 18, 12), timezone.get_default_timezone()) derog = G(Derogation, start_dt=start, end_dt=end, mode='H', zones=[F(num=2), F(num=3)]) assert str(derog) == "25/02-17:24->18/03-18:12 H Z2-Z3"
def test_look_up_alias_as_f_with_all_params_combination(self): assert {'a': 1} == look_up_alias(a=1) assert {'a': 1, 'b': 2} == look_up_alias(a=1, b=2) assert {'a': F(b=1)} == look_up_alias(a__b=1) assert {'a': F(b=1), 'c': 2} == look_up_alias(a__b=1, c=2) assert {'a': F(b=1), 'c': F(d=2)} == look_up_alias(a__b=1, c__d=2) assert {'a': F(b=1, c=2)} == look_up_alias(a__b=1, a__c=2) assert {'a': F(b=1, c=F(d=2))} == look_up_alias(a__b=1, a__c__d=2) assert { 'a': F(b=1, c=F(d=2)), 'e': F(f=3), 'g': 4 } == look_up_alias(a__b=1, a__c__d=2, e__f=3, g=4)
def derogation_initial_data(db): G(Derogation, zones=[F(num=1)], start_dt=datetime(2016, 9, 12, 22, 0), end_dt=datetime(2016, 9, 13, 5, 59)) G(Derogation, zones=[F(num=1)], start_dt=datetime(2016, 9, 13, 14, 0), end_dt=datetime(2016, 9, 13, 21, 59)) good_data = { 'zones': [reverse('heating:zone-detail', args=[1])], 'mode': 'E', 'start_dt': '2016-09-13T06:00', 'end_dt': '2016-09-13T14:00', 'start_initial': '2016-09-13T05:59' } return good_data
def test_no_cascade_if_super_entity_exists(self): """ Tests that super entities arent synced again if they have already been synced. """ account = G(Account, team=F(team_group=F())) self.assertTrue(Account.objects.exists()) self.assertTrue(Team.objects.exists()) self.assertTrue(TeamGroup.objects.exists()) entity_syncer = EntitySyncer() entity_syncer.sync_entities_and_relationships(account) # Verify that only the account and team reside in the entity syncer cache. This means that # the syncing didnt percolate all the way to the team group self.assertEquals(len(entity_syncer._synced_entity_cache), 2)
def test_look_up_alias_with_just_one_parameter(self): assert {'a': 1} == look_up_alias(a=1) assert {'a': F()} == look_up_alias(a=F()) assert {'a_b': 1} == look_up_alias(a_b=1) assert {'a': F(b=1)} == look_up_alias(a__b=1) assert {'a_b': F(c=1)} == look_up_alias(a_b__c=1) assert {'a': F(b=F(c=1))} == look_up_alias(a__b__c=1) assert {'a_b': F(c_d=F(e_f=1))} == look_up_alias(a_b__c_d__e_f=1)
def test_message_media_attachments(self): """ Result contains message attachments linked to requested conversation """ m = G(Message, user=self.user1, conversation=self.c1) G(MessageAttachment, type=MESSAGE_ATTACHMENT_TYPE_MEDIA, message=m, conversation=self.c1, images=['http://s3.com/media.png'], videos=[F(url='http://yout.com/abc')]) G(MessageAttachment, type=MESSAGE_ATTACHMENT_TYPE_SHOUT, message=m, conversation=self.c1) self.login(self.user1) resp = self.client.get(self.get_url(self.c1.pk)) self.assert200(resp) resp_results = self.decode_json(resp)['results'] self.assertEqual(len(resp_results), 1) self.assertEqual(resp_results[0]['images'], ['http://s3.com/media.png']) self.assertEqual([v['url'] for v in resp_results[0]['videos']], ['http://yout.com/abc']) # only media fields are present self.assertFalse( set(resp_results[0].keys()) & set(['shout', 'location', 'profile']))
def test_two_properties_same_object(self): instance = G(ModelWithRelationships, integer=1000, foreignkey=F(integer=1001, integer_b=1002)) assert instance.integer == 1000 assert instance.foreignkey.integer == 1001 assert instance.foreignkey.integer_b == 1002
def g_email(**kwargs): view_uid = kwargs.pop('view_uid', uuid.uuid4()) context = kwargs.pop('context', None) if context is not None: return G(Email, view_uid=view_uid, event=F(context=context), **kwargs) else: return G(Email, view_uid=view_uid, **kwargs)
def setUp(self): self.data_auth = { 'password': '******', 'username': '******', } self.client = APIClient() self.user = User.objects.create_user( email='*****@*****.**', first_name='test', last_name='edw', **self.data_auth, ) self.token = self.client.post( reverse('login'), data=self.data_auth, ).json()['token'] self.task_description = 'test_description' self.task_other_description = 't-rf-rx' self.task = G(Task, user=self.user, description=self.task_description) self.task_other = G(Task, user=F(), description=self.task_other_description) self.url_task_list = reverse('api:task-list') self.url_detail_task = reverse('api:task-detail', args=[self.task.id]) self.url_detail_task2 = reverse('api:task-detail', args=[self.task_other.id])
def test_place_filters(self): datetimes = (datetime.datetime(*d) for d in ((2100, 1, 2, 0, 0), (2100, 1, 1, 12, 00), (2100, 1, 1, 23, 00))) place = get(Place, point=F(geometry=geos.Point(x=0, y=0))) matched_events = { self.make_event_fixture(start_date=dt.date(), start_time=dt.time(), place=place) for dt in datetimes } self.make_event_fixture() # throw in a non-match query_params = dict(**self.auth_params) query_params.update( **{'place': PlaceFilterOptions()._uri_from_obj(place)}) resp = self.client.get(self.uri, data=query_params) self.assertResponseCode(resp, 200) self.assertResponseMetaList(resp, len(matched_events)) json_resp = try_json_loads(resp.content) resource = api_v1._registry['eventsummary'] matched_events_sorted = sorted( matched_events, key=lambda e: e.occurrences.all()[0].start_datetime) for matched_event, event_summary_json in zip(matched_events_sorted, json_resp['objects']): event_summary = resource.get_via_uri( event_summary_json['resource_uri']) self.assertIn(event_summary.event, matched_events, 'Should not be part of search results') self.assertEqual(matched_event, event_summary.event, 'Unexpected order')
def test_look_up_alias_with_just_one_parameter(self): self.assertEquals({'a': 1}, look_up_alias(a=1)) self.assertEquals({'a': F()}, look_up_alias(a=F())) self.assertEquals({'a_b': 1}, look_up_alias(a_b=1)) self.assertEquals({'a': F(b=1)}, look_up_alias(a__b=1)) self.assertEquals({'a_b': F(c=1)}, look_up_alias(a_b__c=1)) self.assertEquals({'a': F(b=F(c=1))}, look_up_alias(a__b__c=1)) self.assertEquals({'a_b': F(c_d=F(e_f=1))}, look_up_alias(a_b__c_d__e_f=1))
def test_user_guide_info_admin(self): guide_info_admin = GuideInfoAdmin(GuideInfo, self.site) guide_info_obj = G(GuideInfo, guide=F(guide_name='test_name')) self.assertEqual( guide_info_admin.list_display, ('user', 'guide_name', 'is_finished', 'finished_time')) self.assertEqual(guide_info_admin.guide_name(guide_info_obj), 'test_name')
def setUpTestData(cls): cls.user1 = cls.create_user(username='******', email='*****@*****.**') cls.page1 = G(Page, user=cls.user1, creator=cls.user1, name='page1', slug='page1', category=F(name='pagecat', slug='pagecat'))
def test_adapt_existing_valid(self): # place uniqueness: title, point existing_place = G(Place, title='Swing 46 Jazz and Supper Club', point=F(geometry=geos.Point(0, 0), address=self.point_address, city=City.objects.create(city='New York', state='NY') )) created, place = self.adaptor.adapt(self.event_response) self.assertFalse(created, 'Place object created despite existing match') self.assertEqual(existing_place, place, 'Place object returned is not the existing match')
def make_event_fixture( concrete_category=Category.objects.get(slug='music'), start_date=datetime.date(2063, 1, 1), start_time=datetime.time(), place=None): event = get(Event, concrete_category=concrete_category, secret_key='f' * 10) place = place or F(point=F(geometry=geos.Point(x=0, y=0))) occurrence = get(Occurrence, event=event, place=place, start_date=start_date, start_time=start_time) get(Price, occurrence=occurrence) event.save() return event
def test_message_shout_attachmet_is_saved(self): """ Shout attachment is saved in message """ shout = self.create_shout( user=self.user1, category=F(name='velo', slug='velo'), item=F(name='Marin')) self.login(self.user1) resp = self.client.post(self.get_url(self.c1.pk), { 'text': 'm1', 'attachments': [ { 'shout': {'id': shout.pk} }, ] }) attachment = self.assert_one_attachment( resp, 'm1', MESSAGE_ATTACHMENT_TYPE_SHOUT) self.assertEqual(attachment.attached_object.pk, shout.pk)
def test_using_look_up_alias(self): instance = G(ModelWithRelationships, integer=1000, foreignkey__integer=1001, selfforeignkey__integer=1002, onetoone__integer=1003, manytomany=[ F(integer=1004), F(integer=1005), F(selfforeignkey__integer=1006) ]) assert instance.integer == 1000 assert instance.foreignkey.integer == 1001 assert instance.selfforeignkey.integer == 1002 assert instance.onetoone.integer == 1003 assert instance.manytomany.all()[0].integer == 1004 assert instance.manytomany.all()[1].integer == 1005 assert instance.manytomany.all()[2].selfforeignkey.integer == 1006
def create_shout(cls, **kwargs): if 'post_ptr' not in kwargs: kwargs['post_ptr'] = G( Post, user=cls.create_user(username=cls.get_random_string(10))) if 'category' not in kwargs: kwargs['category'] = F() if 'user' not in kwargs: kwargs['user'] = cls.create_user( username=cls.get_random_string(10)) return G(Shout, **kwargs)
def test_using_look_up_alias(self): instance = G(ModelWithRelationships, integer=1000, foreignkey__integer=1001, selfforeignkey__integer=1002, onetoone__integer=1003, manytomany=[ F(integer=1004), F(integer=1005), F(selfforeignkey__integer=1006) ]) self.assertEquals(1000, instance.integer) self.assertEquals(1001, instance.foreignkey.integer) self.assertEquals(1002, instance.selfforeignkey.integer) self.assertEquals(1003, instance.onetoone.integer) self.assertEquals(1004, instance.manytomany.all()[0].integer) self.assertEquals(1005, instance.manytomany.all()[1].integer) self.assertEquals(1006, instance.manytomany.all()[2].selfforeignkey.integer)
def test_adapt_existing_valid(self): event, place = G(Event), G(Place, point=F(geometry=geos.Point(y=0, x=0))) existing_occurrences = {G(Occurrence, event=event, start_date=start_date, start_time=self.expected_start_time, place=place) for start_date in self.expected_start_dates } occurrences = self.adaptor.adapt_m2o(self.event_response, event=event.id, place=place.id) for created, occurrence in occurrences: self.assertFalse(created, 'Occurrence created despite existing match') self.assertIsInstance(occurrence, Occurrence, 'Occurrence type expected') self.assertIn(occurrence, existing_occurrences, 'Occurrence object returned is not the existing match')