tests/app/summerofcode/views/test_connection.py

# Copyright 2014 the Melange authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Unit tests for connection related views."""

import mock
import unittest

from soc.modules.gsoc.views.helper import request_data

from melange.logic import connection as connection_logic
from melange.models import connection as connection_model
from melange.models import organization as org_model
from melange.request import access
from melange.request import exception
from melange.views import connection as connection_view

from seeder import connection as connection_seeder
from seeder import profile as profile_seeder
from seeder import program as program_seeder
from seeder import sponsor as sponsor_seeder
from seeder import user as user_seeder

from summerofcode.views import connection as soc_connection_view
from summerofcode.views.helper import urls

from tests import org_utils
from tests import profile_utils
from tests import test_utils


_TEST_MESSAGE_CONTENT = 'Test message content'

def _getStartAsOrgUrl(org):
  """Returns URL to 'Start Connection As Organization' page for
  the specified organization.

  Args:
    org: Organization entity.

  Returns:
    The URL to 'Start Connection As Organization' page.
  """
  return '/gsoc/connection/start/org/%s' % org.key.id()


def _getStartAsUserUrl(org):
  """Returns URL to 'Start Connection As User' page for
  the specified organization.

  Args:
    org: Organization entity.

  Returns:
    The URL to 'Start Connection As Organization' page.
  """
  return '/gsoc/connection/start/user/%s' % org.key.id()


def _getManageAsUserUrl(connection):
  """Returns URL to 'Manage Connection As User' page for the specified
  connection entity.

  Args:
    connection: connection entity.

  Returns:
    The URL to 'Manage Connection As User' for the specified connection.
  """
  return '/gsoc/connection/manage/user/%s/%s' % (
      connection.key.parent().id(), connection.key.id())


def _getListConnectionsForOrgAdminUrl(profile):
  """Returns URL to 'List Connections For Org Admin' page for the specified
  profile entity.

  Args:
    profile: profile entity.

  Returns:
    The URL to 'List Connection For Org Admin' for the specified profile.
  """
  return '/gsoc/connection/list/org/%s' % profile.key.id()


def _getListForUserUrl(program):
  """Returns URL to 'List Connections For User' page for the specified user.

  Args:
    program: Program entity.

  Returns:
    URL to 'List Connections For User' page.
  """
  return '/gsoc/connection/list/user/%s' % program.key().name()


def _getPickOrganizationToConnectUrl(program):
  """Returns URL to 'Pick Organization To Connect' page for the specified user.

  Args:
    program: Program entity.

  Returns:
    URL to 'List Connections For User' page.
  """
  return '/gsoc/connection/pick/%s' % program.key().name()


def _getManageAsOrgUrl(connection):
  """Returns URL to 'Manage Connection As Org' page for the specified
  connection entity.

  Args:
    connection: connection entity.

  Returns:
    The URL to 'Manage Connection As Org' for the specified connection.
  """
  return '/gsoc/connection/manage/org/%s/%s' % (
      connection.key.parent().id(), connection.key.id())


def _getMarkAsSeenByOrgUrl(connection):
  """Returns URL to 'Mark Connection As Seen By Org' handler for the specified
  connection entity.

  Args:
    connection: connection entity.

  Returns:
    The URL to 'Mark Connection As Seen By Org' for the specified connection.
  """
  return '/gsoc/connection/mark_as_seen/org/%s/%s' % (
      connection.key.parent().id(), connection.key.id())


def _getMarkAsSeenByUserUrl(connection):
  """Returns URL to 'Mark Connection As Seen By User' handler for the specified
  connection entity.

  Args:
    connection: connection entity.

  Returns:
    The URL to 'Mark Connection As Seen By User' for the specified connection.
  """
  return '/gsoc/connection/mark_as_seen/user/%s/%s' % (
      connection.key.parent().id(), connection.key.id())


class NoConnectionExistsAccessCheckerTest(unittest.TestCase):
  """Unit tests for NoConnectionExistsAccessChecker class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    sponsor = sponsor_seeder.seedSponsor()
    program = program_seeder.seedGSoCProgram(sponsor_key=sponsor.key())
    self.organization = org_utils.seedSOCOrganization(program.key())

    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    self.profile = profile_seeder.seedProfile(program.key(), user=user)

    kwargs = {
        'sponsor': sponsor.key().name(),
        'program': program.program_id,
        'organization': self.organization.org_id,
        }
    self.data = request_data.RequestData(None, None, kwargs)

  def testNoConnectionExists(self):
    """Tests that access is granted if no connection exists."""
    access_checker = (
        connection_view.NoConnectionExistsAccessChecker(urls.UrlNames))
    access_checker.checkAccess(self.data, None)

  def testConnectionExists(self):
    """Tests that access is denied if connection already exists."""
    # seed a connection between the profile and organization
    connection_seeder.seedConnection(
        self.profile.key, self.organization.key)

    access_checker = (
        connection_view.NoConnectionExistsAccessChecker(urls.UrlNames))
    with self.assertRaises(exception.Redirect):
      access_checker.checkAccess(self.data, None)


class StartConnectionAsOrgTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for StartConnectionAsOrg class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()
    self.org.status = org_model.Status.ACCEPTED
    self.org.put()

  def _assertPageTemplatesUsed(self, response):
    """Asserts that all templates for the tested page are used."""
    self.assertResponseOkAndGSoCTemplatesUsed(response)
    self.assertTemplateUsed(response, 'modules/gsoc/form_base.html')

  def testPageLoads(self):
    """Tests that page loads properly."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    response = self.get(_getStartAsOrgUrl(self.org))
    self.assertResponseOK(response)
    self._assertPageTemplatesUsed(response)

  def testConnectionStartedForNonStudent(self):
    """Tests that connection is created successfully for non-students."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    first_profile = profile_seeder.seedProfile(self.program.key())
    second_profile = profile_seeder.seedProfile(self.program.key())

    post_data = {
        'role': connection_model.MENTOR_ROLE,
        'users': '%s, %s' % (
            first_profile.profile_id, second_profile.profile_id)
        }
    response = self.post(_getStartAsOrgUrl(self.org), post_data)
    self.assertResponseRedirect(
        response, _getListConnectionsForOrgAdminUrl(profile))

    # check that connection with the first profile is created
    connection = connection_model.Connection.query(
        connection_model.Connection.organization == self.org.key,
        ancestor=first_profile.key).get()
    self.assertIsNotNone(connection)
    self.assertEqual(connection.org_role, connection_model.MENTOR_ROLE)
    self.assertEqual(connection.user_role, connection_model.NO_ROLE)

    # connection has been seen by the organization, since it creates it
    # and has not been seen by the user yet
    self.assertTrue(connection.seen_by_org)
    self.assertFalse(connection.seen_by_user)

    # check that connection is not initialized by the user
    self.assertFalse(connection.init_by_user)

    # check that auto-generated message is created
    message = connection_model.ConnectionMessage.query(
        ancestor=connection.key).get()
    self.assertIsNotNone(message)
    self.assertTrue(message.is_auto_generated)
    self.assertEqual(
        message.content,
        connection_logic._ORG_STARTED_CONNECTION % (
            profile.public_name,
            connection_model.VERBOSE_ROLE_NAMES[connection_model.MENTOR_ROLE]))

    # check that an email to the user has been sent
    self.assertEmailSent(to=first_profile.contact.email)

    # check that connection with the second profile is created
    connection = connection_model.Connection.query(
        connection_model.Connection.organization == self.org.key,
        ancestor=second_profile.key).get()
    self.assertIsNotNone(connection)
    self.assertEqual(connection.org_role, connection_model.MENTOR_ROLE)
    self.assertEqual(connection.user_role, connection_model.NO_ROLE)

    # check that an email to the user has been sent
    self.assertEmailSent(to=second_profile.contact.email)

  def testCustomMessage(self):
    """Tests that connection is started with a custom message."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    other_profile = profile_seeder.seedProfile(self.program.key())

    post_data = {
        'role': connection_model.MENTOR_ROLE,
        'users': other_profile.profile_id,
        'message': _TEST_MESSAGE_CONTENT,
        }
    self.post(_getStartAsOrgUrl(self.org), post_data)

    # check that a message has been created
    connection = connection_model.Connection.query(
        connection_model.Connection.organization == self.org.key,
        ancestor=other_profile.key).get()
    message = connection_model.ConnectionMessage.query(
        connection_model.ConnectionMessage.author == profile.key,
        ancestor=connection.key).get()
    self.assertIsNotNone(message)
    self.assertEqual(message.content, _TEST_MESSAGE_CONTENT)
    self.assertFalse(message.is_auto_generated)

  def testConnectionNotStartedForStudent(self):
    """Tests that connection is not created for a student."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    profile = profile_seeder.seedStudent(self.program)

    post_data = {
        'role': connection_model.MENTOR_ROLE,
        'users': '%s' % profile.profile_id
        }
    response = self.post(_getStartAsOrgUrl(self.org), post_data)
    self.assertResponseBadRequest(response)

    # check that no connection has been created
    connection = connection_model.Connection.query(
        connection_model.Connection.organization == self.org.key,
        ancestor=profile.key).get()
    self.assertIsNone(connection)


class StartConnectionAsUserTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for ShowConnectionAsUser class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()
    self.org.status = org_model.Status.ACCEPTED
    self.org.put()

  def testConnectionExists(self):
    """Tests that exception is raised when connection already exists."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(self.program.key(), user=user)
    connection = connection_seeder.seedConnection(profile.key, self.org.key)

    # check that user is redirected when a connection exists
    response = self.get(_getStartAsUserUrl(self.org))
    self.assertResponseRedirect(response, _getManageAsUserUrl(connection))

    # check that bad request is raised when a connection already exists
    # on POST request after access checker concludes
    with mock.patch.object(
        soc_connection_view.START_CONNECTION_AS_USER, 'access_checker',
        new=access.ALL_ALLOWED_ACCESS_CHECKER):
      response = self.post(_getStartAsUserUrl(self.org))
      self.assertResponseBadRequest(response)

  @mock.patch.object(
      connection_logic, 'unacceptedConnectionsLimitReached', return_value=True)
  def testUnacceptedConnectionsLimitReached(self, mock_func):
    """Tests that exception is raised when limit of connections is reached."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(self.program.key(), user=user)

    response = self.get(_getStartAsUserUrl(self.org))
    self.assertResponseForbidden(response)

    # check that bad request is raised when a connection already exists
    # on POST request after access checker concludes
    with mock.patch.object(
        soc_connection_view.START_CONNECTION_AS_USER, 'access_checker',
        new=access.ALL_ALLOWED_ACCESS_CHECKER):
      response = self.post(_getStartAsUserUrl(self.org))
      self.assertResponseBadRequest(response)

  def testStudentProfile(self):
    """Tests that exception is raised when student profile starts connection."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedStudent(self.program, user=user)

    # check that user is forbidden to access the page
    response = self.get(_getStartAsUserUrl(self.org))
    self.assertResponseForbidden(response)

    # check that bad request is raised on POST request
    # even when access checker gets through
    with mock.patch.object(
        soc_connection_view.START_CONNECTION_AS_USER, 'access_checker',
        new=access.ALL_ALLOWED_ACCESS_CHECKER):
      response = self.post(_getStartAsUserUrl(self.org))
      self.assertResponseBadRequest(response)

  def testNonStudentProfile(self):
    """Tests that connection is created for a non-student profile."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(self.program.key(), user=user)

    # seed an admin for the organization
    org_admin = profile_seeder.seedProfile(
        self.program.key(), admin_for=[self.org.key])

    post_data = {'role': connection_model.ROLE}
    response = self.post(_getStartAsUserUrl(self.org), post_data)

    # check that a new connection is created
    connection = connection_model.Connection.query(
        connection_model.Connection.organization == self.org.key,
        ancestor=profile.key).get()
    self.assertIsNotNone(connection)
    self.assertEqual(connection.org_role, connection_model.NO_ROLE)
    self.assertEqual(connection.user_role, connection_model.ROLE)

    # connection has not been seen by the organization yet
    # and has been seen by the user since he or she created it
    self.assertFalse(connection.seen_by_org)
    self.assertTrue(connection.seen_by_user)

    # check that connection is created by the user
    self.assertTrue(connection.init_by_user)

    # check that auto-generated message is created
    message = connection_model.ConnectionMessage.query(
        ancestor=connection.key).get()
    self.assertIsNotNone(message)
    self.assertTrue(message.is_auto_generated)
    self.assertEqual(
        message.content,
        connection_logic._USER_STARTED_CONNECTION)

    # check that a message has been sent to the organization admin
    self.assertEmailSent(to=org_admin.contact.email)

    # check that the user is redirected to 'Manage Connection' page
    self.assertResponseRedirect(response, _getManageAsUserUrl(connection))


class ManageConnectionAsOrgTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for ManageConnectionAsOrg class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()

    # seed a profile for a connected user
    profile = profile_seeder.seedProfile(self.program.key())

    self.connection = connection_seeder.seedConnection(
        profile.key, self.org.key)

  def testPageLoads(self):
    """Tests that page loads properly."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    response = self.get(_getManageAsOrgUrl(self.connection))
    self.assertResponseOK(response)

  def testSendNewMessage(self):
    """Tests that sending a new connection message works."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    last_modified = self.connection.last_modified

    post_data = {
        connection_view.MESSAGE_FORM_NAME: '',
        'content': _TEST_MESSAGE_CONTENT,
        }
    response = self.post(_getManageAsOrgUrl(self.connection), post_data)
    self.assertResponseRedirect(response, _getManageAsOrgUrl(self.connection))

    # check that a new message is created
    query = connection_model.ConnectionMessage.query(
        ancestor=self.connection.key)
    message = query.get()
    self.assertIsNotNone(message)
    self.assertEqual(message.content, _TEST_MESSAGE_CONTENT)
    self.assertFalse(message.is_auto_generated)
    self.assertEqual(message.author, profile.key)

    # check that last_modified property is updated
    self.assertGreater(self.connection.key.get().last_modified, last_modified)

    # check that seed_by_user property is cleared
    self.assertFalse(self.connection.key.get().seen_by_user)


class ManageConnectionAsUserTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for ManageConnectionAsUser class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()

    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(self.program.key(), user=user)
    self.connection = connection_seeder.seedConnection(
        profile.key, self.org.key)

  def testPageLoads(self):
    """Tests that page loads properly."""
    response = self.get(_getManageAsUserUrl(self.connection))
    self.assertResponseOK(response)

  def testSendNewMessage(self):
    """Tests that sending a new connection message works."""
    last_modified = self.connection.last_modified

    post_data = {
        connection_view.MESSAGE_FORM_NAME: '',
        'content': _TEST_MESSAGE_CONTENT,
        }
    response = self.post(_getManageAsUserUrl(self.connection), post_data)
    self.assertResponseRedirect(response, _getManageAsUserUrl(self.connection))

    # check that a new message is created
    query = connection_model.ConnectionMessage.query(
        ancestor=self.connection.key)
    message = query.get()
    self.assertIsNotNone(message)
    self.assertEqual(message.content, _TEST_MESSAGE_CONTENT)
    self.assertFalse(message.is_auto_generated)
    self.assertEqual(message.author, self.connection.key.parent())

    # check that last_modified property is updated
    self.assertGreater(self.connection.key.get().last_modified, last_modified)

    # check that seen_by_org property is cleared
    self.assertFalse(self.connection.key.get().seen_by_org)


class ListConnectionsForUserTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for ListConnectionsForUser class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()

  def _assertPageTemplatesUsed(self, response):
    """Asserts that all templates for the tested page are used."""
    self.assertResponseOkAndGSoCTemplatesUsed(response)
    self.assertTemplateUsed(response,
        'summerofcode/connection/connection_list.html')
    self.assertTemplateUsed(response,
        'summerofcode/_list_component.html')

  def testPageLoads(self):
    """Tests that page loads properly."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(self.program.key(), user=user)

    response = self.get(_getListForUserUrl(self.program))
    self.assertResponseOK(response)
    self._assertPageTemplatesUsed(response)

  def testListData(self):
    """Tests that correct list data is loaded."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(self.program.key(), user=user)

    first_org = org_utils.seedSOCOrganization(
        self.program.key(), status=org_model.Status.ACCEPTED)
    connection_seeder.seedConnection(profile.key, first_org.key)

    other_org = org_utils.seedSOCOrganization(
        self.program.key(), status=org_model.Status.ACCEPTED)
    connection_seeder.seedConnection(profile.key, other_org.key)

    list_data = self.getListData(_getListForUserUrl(self.program), 0)

    # check that all two connections are listed
    self.assertEqual(len(list_data), 2)


class PickOrganizationToConnectPageTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for PickOrganizationToConnectPage class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()

  def testPageLoads(self):
    """Tests that the page loads properly."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(self.program.key(), user=user)

    response = self.get(_getPickOrganizationToConnectUrl(self.program))
    self.assertResponseOK(response)

  def testListDataLoads(self):
    """Tests that the list data loads properly."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(self.program.key(), user=user)

    # the org is already accepted
    self.org.status = org_model.Status.ACCEPTED
    self.org.put()

    list_data = self.getListData(
        _getPickOrganizationToConnectUrl(self.program), 0)

    # check that the organization is listed
    self.assertEqual(len(list_data), 1)


_NUMBER_OF_CONNECTIONS_FOR_MAIN_ORG = 3
_NUMBER_OF_CONNECTIONS_FOR_SECOND_ORG = 2
_NUMBER_OF_CONNECTIONS_FOR_THIRD_ORG = 5

class OrgAdminConnectionListTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for OrgAdminConnectionList class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()

  def testPageLoads(self):
    """Tests that page loads properly."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    url = _getListConnectionsForOrgAdminUrl(profile)
    response = self.get(url)
    self.assertResponseOK(response)

  def testListData(self):
    """Tests that all connections for orgs administrated by user are listed."""
    # seed another organization which is administrated by the user
    second_org = org_utils.seedSOCOrganization(self.program.key())

    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(
        self.program.key(), user=user,
        admin_for=[self.org.key, second_org.key])

    # seed a few connections for first organization
    for _ in range(_NUMBER_OF_CONNECTIONS_FOR_MAIN_ORG):
      other_profile = profile_seeder.seedProfile(self.program.key())
      connection_seeder.seedConnection(other_profile.key, self.org.key)

    for _ in range(_NUMBER_OF_CONNECTIONS_FOR_SECOND_ORG):
      other_profile = profile_seeder.seedProfile(self.program.key())
      connection_seeder.seedConnection(other_profile.key, second_org.key)

    # seed another organization which is not administrated by the user
    third_org = org_utils.seedSOCOrganization(self.program.key())

    # seed a few connections for the other organization
    for _ in range(_NUMBER_OF_CONNECTIONS_FOR_THIRD_ORG):
      other_profile = profile_seeder.seedProfile(self.program.key())
      connection_seeder.seedConnection(other_profile.key, third_org.key)

    list_data = self.getListData(
        _getListConnectionsForOrgAdminUrl(profile), 0)

    # check that all connections are listed: the ones created above for the main
    # org and the second plus two for the organization admin itself
    self.assertEqual(
        len(list_data),
        _NUMBER_OF_CONNECTIONS_FOR_MAIN_ORG +
        _NUMBER_OF_CONNECTIONS_FOR_SECOND_ORG + 2)


class MarkConnectionAsSeenByOrgTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for MarkConnectionAsSeenByOrg class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()

    # seed another profile for a connected user
    other_profile = profile_seeder.seedProfile(self.program.key())
    self.connection = connection_seeder.seedConnection(
        other_profile.key, self.org.key, seen_by_org=False)

  @unittest.skip(
      'This request should fail instead of raising NotImplementedError')
  def testGetMethodForbidden(self):
    """Tests that GET method is not permitted."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    response = self.get(_getMarkAsSeenByOrgUrl(self.connection))
    self.assertResponseForbidden(response)

  def testConnectionMarkedAsSeen(self):
    """Tests that connection is successfully marked as seen by organization."""
    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile_seeder.seedProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    response = self.post(_getMarkAsSeenByOrgUrl(self.connection))
    self.assertResponseOK(response)

    # check that connection is marked as seen by organization
    connection = self.connection.key.get()
    self.assertTrue(connection.seen_by_org)


class MarkConnectionAsSeenByUserTest(test_utils.GSoCDjangoTestCase):
  """Unit tests for MarkConnectionAsSeenByUser class."""

  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.init()

    user = user_seeder.seedUser()
    profile_utils.loginNDB(user)
    profile = profile_seeder.seedProfile(self.program.key(), user=user)

    self.connection = connection_seeder.seedConnection(
        profile.key, self.org.key, seen_by_user=False)

  @unittest.skip(
      'This request should fail instead of raising NotImplementedError')
  def testGetMethodForbidden(self):
    """Tests that GET method is not permitted."""
    response = self.get(_getMarkAsSeenByUserUrl(self.connection))
    self.assertResponseForbidden(response)

  def testConnectionMarkedAsSeen(self):
    """Tests that connection is successfully marked as seen by user."""
    response = self.post(_getMarkAsSeenByUserUrl(self.connection))
    self.assertResponseOK(response)

    # check that connection is marked as seen by organization
    connection = self.connection.key.get()
    self.assertTrue(connection.seen_by_user)