def test_destroy(self):
        """Test removing a team."""
        response = self.client.post(self.url, data=self.data)
        eq_(response.status_code, 200)

        db = get_session(self.app)
        eq_(0, db.query(Team).count())

def statusize():
    """Posts a status from the web."""
    db = get_session(current_app)

    user_id = session.get('user_id')
    if not user_id:
        return forbidden('You must be logged in to statusize!')

    user = db.query(User).get(user_id)

    message = request.form.get('message', '')

    if not message:
        return page_not_found('You cannot statusize nothing!')

    status = Status(user_id=user.id, content=message, content_html=message)

    project = request.form.get('project', '')
    if project:
        project = db.query(Project).filter_by(id=project).first()
        if project:
            status.project_id = project.id

    # TODO: reply handling

    db.add(status)
    db.commit()

    # Try to go back from where we came.
    referer = request.headers.get('referer', url_for('status.index'))
    redirect_url = request.form.get('redirect_to', referer)
    return redirect(redirect_url)

    def globals():
        db = get_session(app)

        ctx = dict()

        # Projects, teams and current user
        ctx['projects'] = db.query(Project).order_by(Project.name)
        ctx['teams'] = db.query(Team).order_by(Team.name)
        ctx['weeks'] = get_weeks()
        ctx['current_user'] = None
        if session and 'user_id' in session:
            user = db.query(User).get(session['user_id'])
            if user:
                ctx['current_user'] = user

        # Time stuff
        ctx['today'] = date.today()
        ctx['yesterday'] = date.today() - timedelta(1)

        # CSRF
        def csrf_field():
            return ('<div style="display: none;">'
                    '<input type="hidden" name="_csrf_token" value="%s">'
                    '</div>' % csrf._get_token())
        ctx['csrf'] = csrf_field

        return ctx

    def test_new_profile_create_missing_data(self):
        """Test profile creation attempts with missing data."""
        db = get_session(self.app)
        u = db.query(User)

        # No email
        data = {'email': '', 'username': 'new-username',
                'github_handle': 'test-handle', 'name': 'Test User'}
        response = self.client.post('/profile/new/', data=data)
        eq_(response.status_code, 200)
        eq_(u.count(), 0)

        # No username
        data = {'email': '[email protected]', 'username': '',
                'github_handle': 'test-handle', 'name': 'Test User'}
        response = self.client.post('/profile/new/', data=data)
        eq_(response.status_code, 200)
        eq_(u.count(), 0)

        # No name
        data = {'email': '[email protected]', 'username': 'new-username',
                'github_handle': 'test-handle', 'name': ''}
        response = self.client.post('/profile/new/', data=data)
        eq_(response.status_code, 200)
        eq_(u.count(), 0)

        # No GitHub handle
        data = {'email': '[email protected]', 'username': 'new-username',
                'github_handle': '', 'name': 'Test User'}
        response = self.client.post('/profile/new/', data=data)
        eq_(response.status_code, 302)
        eq_(u.count(), 1)

def new_profile():
    """Create a new user profile"""
    if (not (session or request.method == 'POST') or 'user_id' in session
            or not ('email' in session or 'email' in request.form)):
        return redirect(url_for('status.index'))

    data = MultiDict()
    try:
        data['email'] = session['email']
        session.pop('email')
    except KeyError:
        pass

    if request.method == 'POST':
        data = request.form

    form = ProfileForm(data)

    if request.method == 'POST' and form.validate():
        db = get_session(current_app)
        u = User(name=data['name'], email=data['email'],
                 username=data['username'], slug=data['username'],
                 github_handle=data['github_handle'])
        db.add(u)
        db.commit()

        session['email'] = u.email
        session['user_id'] = u.id

        flash('Your profile was created.', 'success')

        return redirect(url_for('status.index'))

    return render_template('users/new_profile.html', form=form)

def profile():
    """Shows the user's profile page."""
    db = get_session(current_app)

    user_id = session.get('user_id')
    if not user_id:
        return forbidden('You must be logged in to see a profile!')

    user = db.query(User).get(user_id)

    if request.method == 'POST':
        data = request.form
    else:
        data = MultiDict(user.dictify())

    form = ProfileForm(data)

    if request.method == 'POST' and form.validate():
        user.name = data['name']
        user.username = data['username']
        user.slug = data['username']
        user.github_handle = data['github_handle']
        db.add(user)
        db.commit()
        flash('Your profile was updated.', 'success')

    return render_template('users/profile.html', form=form)

    def test_update(self):
        """Test update team info."""
        response = self.client.post(self.url, data=self.data)
        eq_(response.status_code, 200)

        db = get_session(self.app)
        team = db.query(Team).filter_by(slug=self.data['slug']).one()
        eq_(team.name, self.data['name'])

 def saving_func(*args, **kwargs):
     save = kwargs.pop('save', False)
     ret = func(*args, **kwargs)
     if save:
         db = get_session(current_app)
         db.add(ret)
         db.commit()
     return ret

def index_feed():
    """Output every status in an Atom feed."""
    db = get_session(current_app)

    statuses = db.query(Status).filter_by(reply_to=None)\
        .order_by(desc(Status.created))

    return render_feed('All status updates', statuses)

def update_team():
    """Update a team's info."""
    db = get_session(current_app)

    try:
        team = _get_team()
    except ApiError, e:
        return api_error(e.code, str(e))

def timesince_last_update():
    """Get the time since the users last update in seconds"""
    db = get_session(current_app)

    try:
        user = _get_user()
    except ApiError, e:
        return api_error(e.code, str(e))

def destroy_team():
    """Removes a team."""
    db = get_session(current_app)

    try:
        team = _get_team()
    except ApiError, e:
        return api_error(e.code, str(e))

def create_team_member():
    """Add a user to the team."""
    db = get_session(current_app)

    try:
        team = _get_team()
        user = _get_user()
    except ApiError, e:
        return api_error(e.code, str(e))

def destroy_team_member():
    """Remove a user from the team."""
    db = get_session(current_app)

    try:
        team = _get_team()
        user = _get_user()
    except ApiError, e:
        return api_error(e.code, str(e))

    def test_no_name(self):
        """Test team creation with no name."""
        self.data.pop('name')
        response = self.client.post(self.url, data=self.data)
        eq_(response.status_code, 200)

        db = get_session(self.app)
        team = db.query(Team).filter_by(slug=self.data['slug']).one()
        eq_(team.name, self.data['slug'])

    def test_create(self):
        """Test creation of a team."""
        response = self.client.post(self.url, data=self.data)
        eq_(response.status_code, 200)

        db = get_session(self.app)
        team = db.query(Team).filter_by(slug=self.data["slug"]).one()
        eq_(team.slug, self.data["slug"])
        eq_(team.name, self.data["name"])

    def test_destroy_team_member(self):
        """Test team member deletion."""
        eq_(1, self.team.users.count())

        response = self.client.post(self.url, data=self.data)
        eq_(response.status_code, 200)

        db = get_session(self.app)
        team = db.query(Team).filter_by(slug=self.data['slug']).one()
        eq_(0, team.users.count())

def project_timeline():
    """Get a collection of the project's recent status updates."""
    db = get_session(current_app)
    MAX = current_app.config.get('API2_TIMELINE_MAX_RESULTS',
                                 TIMELINE_MAX_RESULTS)

    try:
        params = _get_timeline_params()
    except ApiError, e:
        return api_error(e.code, str(e))

def user_timeline():
    """Get a collection of the user's recent status updates."""
    app = current_app
    db = get_session(app)
    MAX = app.config.get("API2_TIMELINE_MAX_RESULTS", TIMELINE_MAX_RESULTS)

    try:
        params = _get_params(request)
    except ApiError, e:
        return api_error(400, str(e))

 def statuses(self):
     """Return all statuses from this team."""
     db = get_session(current_app)
     user_ids = [u.id for u in self.users]
     if user_ids:
         return db.query(Status).filter(Status.user_id.in_(user_ids))
     else:
         # There are no users in this team but SQLAlchemy doesn't like
         # in_([]) queries so we short circuit with `0=1`. This also allows
         # other calls to be chained onto the query.
         return db.query(Status).filter('0=1')