def test_get_str_projname(self, mock_getitem, mock_verify_user):
        mock_getitem.return_value = self.project

        with app.test_request_context(self.template_url % self.project_name):
            p = Projects()
            response = p.get(self.project_name)
            self.assertEqual(response.status_code, 200)
        self.assertTrue(mock_verify_user.called)
    def _generic_getitem_case(self, project_name_or_id, mock_first):
        mock_first.return_value = self.project

        with app.test_request_context(self.template_url % project_name_or_id):
            endpoint = Projects()
            project = endpoint[project_name_or_id]
            self.assertEqual(project, self.project)

        self.assertTrue(mock_first.called)
    def test_get_project_none_found(self, mock_first):
        mock_first.return_value = None

        with self.assertRaises(Projects.ProjectNotFoundError):
            with app.test_request_context(
                            self.template_url % self.project_name):
                endpoint = Projects()
                _ = endpoint[self.project_name]

        self.assertTrue(mock_first.called)
    def test_delitem_no_error(self, mock_delete, mock_getitem):
        mock_getitem.return_value = self.project

        with app.test_request_context(
            self.template_url % self.project_name
        ):
            endpoint = Projects()
            del endpoint[self.project_name]

        self.assertTrue(mock_getitem.called)
        self.assertTrue(mock_delete.called)
    def test_delitem_no_project_found(self, mock_delete, mock_getitem):
        mock_getitem.side_effect = Projects.ProjectNotFoundError()

        with self.assertRaises(Projects.ProjectNotFoundError):
            with app.test_request_context(
                self.template_url % self.project_name
            ):
                endpoint = Projects()
                del endpoint[self.project_name]

        self.assertTrue(mock_getitem.called)
        self.assertFalse(mock_delete.called)
    def test_delete_proj_not_found(self, mock_abort, mock_getitem,
                                   mock_verify_user):
        with self.assertRaises(Projects.ProjectNotFoundError):
            with app.test_request_context(
                            self.template_url % self.project_name):
                endpoint = Projects()
                endpoint.delete(self.project_name)

        self.assertTrue(mock_verify_user.called)
        self.assertTrue(mock_getitem.called)
        self.assertEqual(
            mock.call(404), mock_abort.call_args
        )
    def test_delete_str_project(
            self, mock_delete, mock_first, mock_verify_user
    ):
        mock_first.return_value = self.project

        with app.test_request_context(self.template_url % self.project_name):
            p = Projects()
            response = p.delete(self.project_name)

            self.assertEqual(response.status_code, 200)

        self.assertTrue(mock_verify_user.called)
        self.assertEqual(mock.call(self.project), mock_delete.call_args)
    def test_get_project_not_found(
            self, mock_abort, mock_getitem, mock_auth
    ):
        mock_getitem.side_effect = Projects.ProjectNotFoundError()

        with app.test_request_context(self.template_url % self.project_name):
            with self.assertRaises(Projects.ProjectNotFoundError):
                p = Projects()
                p.get(self.project_name)

        self.assertEqual(mock.call(404), mock_abort.call_args)
        self.assertTrue(mock_auth.called)
        self.assertTrue(mock_getitem.called)
 def setUp(self):
     TestParseSearchQueryParams.setUp(self)
     self.contains_string = 'string'
     self.context = app.test_request_context(
         '%s?ends_with=%s' % (self.url, self.contains_string))
 def setUp(self):
     TestParseSearchQueryParams.setUp(self)
     self.context = app.test_request_context(self.url)
    if config_object.LOGFILE is not None:
        logging.basicConfig(filename=config_object.LOGFILE)


set_logfile()


@db_session()
def create_root_user(session):
    """
    If no root user is found in the DB, it makes a root user with
    the credentials given in the config

    :param ContextManagedSession session: The session to be used for making
        the root user
    """
    user = session.query(Administrator).filter_by(
        username=conf.ROOT_USER).first()
    if not user:
        user = Administrator(conf.ROOT_USER, conf.ROOT_PASSWORD,
                             conf.ROOT_EMAIL)
        session.add(user)


if __name__ == "__main__":
    metadata.create_all(bind=conf.DATABASE_ENGINE)
    with app.test_request_context():
        create_root_user()

    app.run(host=conf.IP_ADDRESS, port=conf.PORT, debug=conf.DEBUG)
 def setUp(self):
     TestParseSearchQueryParams.setUp(self)
     self.contains_string = 'string'
     self.context = app.test_request_context(
         '%s?starts_with=%s' % (self.url, self.contains_string)
     )
 def setUp(self):
     TestParseSearchQueryParams.setUp(self)
     self.context = app.test_request_context(self.url)