import unittest

from app import app
from initdb import setup_database_for_testing, finished_database_for_testing
from data import model

NO_ACCESS_USER = 'freshuser'
READ_ACCESS_USER = 'reader'
ADMIN_ACCESS_USER = 'devtable'
PUBLIC_USER = 'public'
RANDOM_USER = 'randomuser'
OUTSIDE_ORG_USER = 'outsideorg'

ADMIN_ROBOT_USER = 'devtable+dtrobot'

ORGANIZATION = 'buynlarge'

SIMPLE_REPO = 'simple'
PUBLIC_REPO = 'publicrepo'
RANDOM_REPO = 'randomrepo'

OUTSIDE_ORG_REPO = 'coolrepo'

ORG_REPO = 'orgrepo'
ANOTHER_ORG_REPO = 'anotherorgrepo'

# Note: The shared repo has devtable as admin, public as a writer and reader as a reader.
SHARED_REPO = 'shared'

class TestVisibleRepositories(unittest.TestCase):
  def setUp(self):
    setup_database_for_testing(self)
    self.app = app.test_client()
    self.ctx = app.test_request_context()
    self.ctx.__enter__()

  def tearDown(self):
    finished_database_for_testing(self)
    self.ctx.__exit__(True, None, None)

  def assertDoesNotHaveRepo(self, username, name):
    repos = list(model.repository.get_visible_repositories(username))
    names = [repo.name for repo in repos]
    self.assertNotIn(name, names)

  def assertHasRepo(self, username, name):
    repos = list(model.repository.get_visible_repositories(username))
    names = [repo.name for repo in repos]
    self.assertIn(name, names)

  def test_noaccess(self):
    repos = list(model.repository.get_visible_repositories(NO_ACCESS_USER))
    names = [repo.name for repo in repos]
    self.assertEquals(0, len(names))

    # Try retrieving public repos now.
    repos = list(model.repository.get_visible_repositories(NO_ACCESS_USER, include_public=True))
    names = [repo.name for repo in repos]
    self.assertIn(PUBLIC_REPO, names)


  def test_public(self):
    self.assertHasRepo(PUBLIC_USER, PUBLIC_REPO)
    self.assertHasRepo(PUBLIC_USER, SHARED_REPO)

    self.assertDoesNotHaveRepo(PUBLIC_USER, SIMPLE_REPO)
    self.assertDoesNotHaveRepo(PUBLIC_USER, RANDOM_REPO)
    self.assertDoesNotHaveRepo(PUBLIC_USER, OUTSIDE_ORG_REPO)

  def test_reader(self):
    self.assertHasRepo(READ_ACCESS_USER, SHARED_REPO)
    self.assertHasRepo(READ_ACCESS_USER, ORG_REPO)

    self.assertDoesNotHaveRepo(READ_ACCESS_USER, SIMPLE_REPO)
    self.assertDoesNotHaveRepo(READ_ACCESS_USER, RANDOM_REPO)
    self.assertDoesNotHaveRepo(READ_ACCESS_USER, OUTSIDE_ORG_REPO)
    self.assertDoesNotHaveRepo(READ_ACCESS_USER, PUBLIC_REPO)

  def test_random(self):
    self.assertHasRepo(RANDOM_USER, RANDOM_REPO)

    self.assertDoesNotHaveRepo(RANDOM_USER, SIMPLE_REPO)
    self.assertDoesNotHaveRepo(RANDOM_USER, SHARED_REPO)
    self.assertDoesNotHaveRepo(RANDOM_USER, ORG_REPO)
    self.assertDoesNotHaveRepo(RANDOM_USER, ANOTHER_ORG_REPO)
    self.assertDoesNotHaveRepo(RANDOM_USER, PUBLIC_REPO)

  def test_admin(self):
    self.assertHasRepo(ADMIN_ACCESS_USER, SIMPLE_REPO)
    self.assertHasRepo(ADMIN_ACCESS_USER, SHARED_REPO)

    self.assertHasRepo(ADMIN_ACCESS_USER, ORG_REPO)
    self.assertHasRepo(ADMIN_ACCESS_USER, ANOTHER_ORG_REPO)

    self.assertDoesNotHaveRepo(ADMIN_ACCESS_USER, OUTSIDE_ORG_REPO)

if __name__ == '__main__':
  unittest.main()