def _test_import_success(self):
     # first export
     resp = self._do_successful_export(1)
     file = resp.data
     # import
     upload_path = get_path('import', 'json')
     resp = self._upload(file, upload_path, 'event.zip')
     self.assertEqual(resp.status_code, 200)
     self.assertIn('task_url', resp.data)
     task_url = json.loads(resp.data)['task_url']
     # wait for done
     while True:
         resp = self.app.get(task_url)
         if 'SUCCESS' in resp.data:
             self.assertIn('result', resp.data)
             dic = json.loads(resp.data)['result']
             break
         if resp.status_code != 200:
             self.assertTrue(False, 'FAIL')
         logging.info(resp.data)
         time.sleep(2)
     # check internals
     self.assertEqual(dic['id'], 2)
     self.assertEqual(dic['name'], 'TestEvent')
     self.assertIn('fb.com', json.dumps(dic['social_links']), dic)
     # get to check final
     resp = self.app.get(get_path(2))
     self.assertEqual(resp.status_code, 200)
     self.assertIn('TestEvent', resp.data)

 def test_export_media(self):
     """
     test successful export of media, unicode and more
     """
     resp = self._put(get_path(1), {'logo': 'https://placehold.it/350x150'})
     self.assertIn('placehold', resp.data, resp.data)
     # set speaker photo so that its export is checked
     resp = self._put(get_path(1, 'speakers', 1), {'photo': 'https://placehold.it/350x150'})
     # set sponsor photo so that its export is checked
     resp = self._put(get_path(1, 'sponsors', 1), {'photo': 'https://placehold.it/350x150'})
     # set event title as unicode
     resp = self._put(get_path(1), {'organizer_name': 'SandraMüllrick'})
     # export and unzip files
     self._create_set()
     dr = 'static/uploads/test_event_import'
     data = open(dr + '/event', 'r').read()
     self.assertIn('images/logo', data)
     # test unicode in file
     self.assertIn('ü', data)
     self.assertNotIn('\u', data)  # unicode escape
     obj = json.loads(data)
     logo_data = open(dr + obj['logo'], 'r').read()
     self.assertTrue(len(logo_data) > 10)
     # test meta.json
     data = open(dr + '/meta', 'r').read()
     self.assertIn('http', data)

 def test_media_successful_uploads(self):
     """
     Test successful uploads of relative and direct links,
     both types of media
     """
     self._create_set()
     self._update_json('event', 'background_image', '/bg.png')
     self._create_file('bg.png')
     self._update_json('speakers', 'photo', '/spkr.png', 1)
     self._create_file('spkr.png')
     self._update_json('sponsors', 'logo', 'http://google.com/favicon.ico', 1)
     # import
     data = self._make_zip_from_dir()
     event_dic = self._do_succesful_import(data)
     # checks
     resp = self.app.get(event_dic['background_image'])
     self.assertEqual(resp.status_code, 200)
     # speaker
     photo = self._get_event_value(
         get_path(2, 'speakers', 2), 'photo'
     )
     resp = self.app.get(photo)
     self.assertEqual(resp.status_code, 200)
     self.assertIn('http://', photo)
     # sponsor
     logo = self._get_event_value(
         get_path(2, 'sponsors', 2), 'logo'
     )
     self.assertIn('sponsors', logo)
     self.assertNotEqual(logo, 'http://google.com/favicon.ico')
     resp = self.app.get(logo)
     self.assertEqual(resp.status_code, 200)

 def _test_model(self, name):
     """
     Tests -
     1. When just one item, check if next and prev urls are empty
     2. When one more item added, limit results to 1 and see if
         next is not empty
     3. start from position 2 and see if prev is not empty
     """
     login(self.app, u'[email protected]', u'test')
     if name == 'event':
         path = get_path('page')
     else:
         path = get_path(1, name + 's', 'page')
     data = self._json_from_url(path)
     self.assertEqual(data['next'], '')
     self.assertEqual(data['previous'], '')
     # add second service
     with app.test_request_context():
         create_event(name='TestEvent2')
         create_services(1)
     data = self._json_from_url(path + '?limit=1')
     self.assertIn('start=2', data['next'])
     self.assertEqual(data['previous'], '')
     # check from start=2
     data = self._json_from_url(path + '?start=2')
     self.assertIn('limit=1', data['previous'])
     self.assertEqual(data['next'], '')
     self.assertIn('http', data['previous'])  # check absolute link

 def _test_model(self, name, data):
     """
     1. Test getting JWT token with wrong credentials and getting 401
     2. Get JWT token with right credentials
     3. Send a sample successful POST request
     """
     path = get_path() if name == 'event' else get_path(1, name + 's')
     # get access token
     response = self._send_login_request('wrong_password')
     self.assertEqual(response.status_code, 401)
     response = self._send_login_request('test')
     self.assertEqual(response.status_code, 200)
     token = json.loads(response.data)['access_token']
     # send a post request
     response = self.app.post(
         path,
         data=json.dumps(data),
         headers={
             'content-type': 'application/json',
             'Authorization': 'JWT %s' % token
         }
     )
     self.assertNotEqual(response.status_code, 401)
     self.assertEqual(response.status_code, 201)
     self.assertIn('Test' + str(name).title(), response.data)

 def _test_model(self, name, data, fields=[]):
     """
     Sets a random value to each of the :fields in :data and makes
     sure POST request failed
     """
     path = get_path() if name == 'event' else get_path(1, name + 's')
     self._login_user()
     for field in fields:
         data_copy = data.copy()
         data_copy[field] = '[email protected][email protected]'
         response = self.post_request(path, data_copy)
         self.assertEqual(response.status_code, 400)

 def _test_model(self, name, data):
     if name == 'event':
         return
     with app.test_request_context():
         path = get_path() if name == 'event' else get_path(1, name + 's')
         response = self.app.post(
             path,
             data=json.dumps(data),
             headers={
                 'content-type': 'application/json'
             }
         )
         self.assertEqual(response.status_code, 403)  # permission denied

 def _test_model(self, name, data, api_model, path=None):
     # strip data
     data = data.copy()
     for i in api_model:
         if not api_model[i].required:
             data.pop(i, None)
     # test
     if not path:
         path = get_path() if name == 'event' else get_path(1, name + 's')
     self._login_user()
     response = self.post_request(path, data)
     self.assertEqual(201, response.status_code, msg=response.data)
     self.assertIn('Test' + name[0].upper() + name[1:], response.data)

 def test_session_api_extended(self):
     self._login_user()
     path = get_path(1, 'tracks')
     self.post_request(path, POST_TRACK_DATA)
     path = get_path(1, 'microlocations')
     self.post_request(path, POST_MICROLOCATION_DATA)
     path = get_path(1, 'speakers')
     self.post_request(path, POST_SPEAKER_DATA)
     # create session json
     data = POST_SESSION_DATA.copy()
     data['track_id'] = 1
     data['microlocation_id'] = 1
     data['speaker_ids'] = [1]
     resp = self.post_request(get_path(1, 'sessions'), data)
     self.assertEqual(resp.status_code, 201)
     for i in ['TestTrack', 'TestSpeaker', 'TestMicrolocation']:
         self.assertIn(i, resp.data, i)

 def test_export_no_event(self):
     path = get_path(2, 'export', 'json')
     resp = self._post(path, {})
     if resp.status_code == 404:  # when celery not running
         return
     task_url = json.loads(resp.data)['task_url']
     resp = self.app.get(task_url)
     self.assertEqual(resp.status_code, 404)

 def test_speaker_api(self):
     path = get_path(1, 'speakers', 1)
     # logged in and check
     self._test_path(path, 'TestSpeaker_1', 'email', 'mobile')
     # logged out, private fields not present
     logout(self.app)
     resp = self.app.get(path)
     self.assertNotIn('email', resp.data)
     self.assertNotIn('mobile', resp.data)

 def _test_import_ots(self):
     dir_path = 'samples/ots16'
     shutil.make_archive(dir_path, 'zip', dir_path)
     file = open(dir_path + '.zip', 'r').read()
     os.remove(dir_path + '.zip')
     upload_path = get_path('import', 'json')
     resp = self._upload(file, upload_path, 'event.zip')
     self.assertEqual(resp.status_code, 200)
     self.assertIn('Open Tech Summit', resp.data)

 def test_api(self):
     login(self.app, u'[email protected]', u'test')
     path = get_path('page')
     response = self.app.get(path)
     self.assertEqual(response.status_code, 404, msg=response.data)
     with app.test_request_context():
         create_event()
     response = self.app.get(path)
     self.assertEqual(response.status_code, 200)
     self.assertIn('TestEvent', response.data)

 def test_session(self):
     session = POST_SESSION_DATA.copy()
     SESSION_FORM['comments']['require'] = 1
     session['comments'] = None
     form_str = json.dumps(SESSION_FORM, separators=(',', ':'))
     with app.test_request_context():
         update_or_create(CustomForms, event_id=1, session_form=form_str)
     path = get_path(1, 'sessions')
     resp = self.post(path, session)
     self.assertEqual(resp.status_code, 400)

 def _test_model(self, name, data, fields=None):
     """
     Sets a random value to each of the :fields in :data and makes
     sure PUT request failed.
     At last check if original value had prevailed
     """
     if fields is None:
         fields = []
     path = get_path(1) if name == 'event' else get_path(1, name + 's', 1)
     self._login_user()
     for field in fields:
         data_copy = data.copy()
         data_copy[field] = '[email protected][email protected]'
         response = self._put(path, data_copy)
         self.assertEqual(response.status_code, 400)
     # make sure field is not updated
     response = self.app.get(path)
     self.assertIn('Test%s_1' % str(name).title(), response.data)
     self.assertNotIn('"Test%s"' % str(name).title(), response.data)

 def test_speaker(self):
     speaker = POST_SPEAKER_DATA.copy()
     SPEAKER_FORM['github']['require'] = 1
     speaker['github'] = None
     form_str = json.dumps(SPEAKER_FORM, separators=(',', ':'))
     with app.test_request_context():
         update_or_create(CustomForms, event_id=1, speaker_form=form_str)
     path = get_path(1, 'speakers')
     resp = self.post(path, speaker)
     self.assertEqual(resp.status_code, 400)

 def test_event_api(self):
     self.app = Setup.create_app()
     with app.test_request_context():
         register(self.app, u'[email protected]', u'test')
         login(self.app, u'[email protected]', u'test')
         # Non existing event
         event_id = 1
         path = get_path(event_id)
         response = self.app.get(path)
         self.assertEqual(response.status_code, 404)
         self.assertIn('does not exist', response.data)

 def _test_model(self, name, data, path=None, exclude=[]):
     if not path:
         path = get_path(1) if name == 'event' else get_path(1, name + 's', 1)
     self._login_user()
     data_copy = data.copy()
     # loop over keys
     for i in data_copy:
         if i in exclude:
             continue
         # get old
         resp_old = self.app.get(path)
         self.assertEqual(resp_old.status_code, 200)
         # update
         resp = self._put(path, {i: data_copy[i]})
         self.assertEqual(200, resp.status_code,
                          msg='Key: %s\nMsg: %s' % (i, resp.data))
         # check persistence
         status = self._test_change_json(resp_old.data, resp.data, i)
         if status:
             self.assertTrue(0, msg='Key %s changed in %s' % (status, i))

    def test_session_type_api(self):
        self._login_user()
        # Create a session type
        path = get_path(1, 'sessions', 'types')
        data = POST_SESSION_TYPE_DATA
        response = self.app.post(
            path,
            data=json.dumps(data),
            headers={'Content-Type': 'application/json'}
        )
        self.assertEqual(response.status_code, 201)

        # Delete the session type
        path = get_path(1, 'sessions', 'types', 1)
        response = self.app.delete(path)
        self.assertEqual(response.status_code, 200)
        self.assertIn('TestSessionType', response.data)

        # Test if it's in session types
        path = get_path(1, 'sessions', 'types')
        response = self.app.get(path)
        self.assertEqual(response.status_code, 200)
        self.assertNotIn('TestSessionType', response.data)

    def _test_model(self, name, data):
        """
        Logs in a user and creates model.
        Tests for 200 status on deletion and for the deleted object.
        Tests that the deleted object no longer exists.
        """
        self._login_user()
        path = get_path() if name == 'event' else get_path(1, name + 's')
        response = self.app.post(
            path,
            data=json.dumps(data),
            headers={'Content-Type': 'application/json'}
        )
        self.assertEqual(response.status_code, 201)

        path = get_path(1) if name == 'event' else get_path(1, name + 's', 1)
        response = self.app.delete(path)
        self.assertEqual(response.status_code, 200)
        self.assertIn('Test' + str(name).title(), response.data)

        response = self.app.get(path)
        self.assertEqual(response.status_code, 404)
        self.assertIn('does not exist', response.data)