tests/app/melange/utils/test_lists.py

# Copyright 2013 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.

"""Tests for functions in the lists module."""

import unittest

from google.appengine.ext import db
from google.appengine.ext import ndb

from melange.utils import lists

from soc.modules.gsoc.models import organization as org_model
from soc.modules.gsoc.models import profile as profile_model
from soc.modules.gsoc.models import program as program_model
from soc.modules.gsoc.models import project as project_model

from soc.modules.seeder.logic.seeder import logic as seeder_logic


NDB_TEST_LIST_ID = 'test_list_ndb'
DB_TEST_LIST_ID = 'test_list_db'


class TestToListItemDict(unittest.TestCase):
  """Unit tests for toListItemDict function."""

  def testToListItemDict(self):
    """Tests whether correct is dict is returned for a db model."""
    class Book(db.Model):
      item_freq = db.StringProperty()
      freq = db.IntegerProperty()
      details = db.TextProperty()
      released = db.BooleanProperty()
      owner = db.ReferenceProperty()

    class Author(db.Model):
      name = db.StringProperty()

    entity = Book()
    entity.item_freq = '5'
    entity.freq = 4
    entity.details = 'Test Entity'
    entity.released = True
    entity.owner = Author(name='Foo Bar').put()
    entity.put()

    columns = [
        ('details', lambda ent: ent.details),
        ('freq', lambda ent: '%s - %s' % (ent.item_freq, ent.freq)),
        ('released', lambda ent: "Yes" if ent.released else "No"),
        ('author', lambda ent: ent.owner.name)
    ]

    list_item_dict = lists.toListItemDict(entity, columns)

    expected_dict = {'details': 'Test Entity', 'freq': '5 - 4',
                     'released': 'Yes', 'author': 'Foo Bar'}

    self.assertEqual(list_item_dict, expected_dict)


class TestSimpleColumn(unittest.TestCase):
  """Unit tests for SimpleColumn class."""

  def testGetListData(self):
    """Tests getListData method."""
    class TestModel(db.Model):
      name = db.StringProperty()
      value = db.IntegerProperty()

    test_entity = TestModel(name='test_name', value=1)

    name_column = lists.SimpleColumn('name', 'Name')
    value_column = lists.SimpleColumn('value', 'Value')

    self.assertEqual(test_entity.name, name_column.getValue(test_entity))
    self.assertEqual(test_entity.value, value_column.getValue(test_entity))


class TestGSoCProjectsColumns(unittest.TestCase):
  """Unit tests for implementations of Column class for GSoCProjects."""

  def setUp(self):
    self.program = seeder_logic.seed(program_model.GSoCProgram)
    self.organization = seeder_logic.seed(org_model.GSoCOrganization,
        {'scope': self.program, 'program': self.program})
    self.student = seeder_logic.seed(
        profile_model.GSoCProfile, {'key_name': 'student'})

    # seed a project for above organization, program and student
    project_properties = {
        'parent': self.student,
        'scope': self.program,
        'org': self.organization
    }

    self.project = seeder_logic.seed(
        project_model.GSoCProject, project_properties)

  def testKeyColumn(self):
    """Tests KeyColumn class."""
    key_column = lists.KeyColumn('key', 'Key')
    expected_value = '%s/%s' % (
        self.project.parent_key().name(), self.project.key().id())
    self.assertEqual(expected_value, key_column.getValue(self.project))

  def testStudentColumn(self):
    """Tests StudentColumn class."""
    student_column = lists.StudentColumn('student', 'Student')
    expected_value = self.student.key().name()
    self.assertEqual(expected_value, student_column.getValue(self.project))

  def testOrganizationColumn(self):
    """Tests OrganizationColumn class."""
    org_column = lists.OraganizationColumn('organization', 'Organization')
    expected_value = self.organization.name
    self.assertEqual(expected_value, org_column.getValue(self.project))


class TestDBModel(db.Model):
  """Used to create db entities for tests."""
  name = db.StringProperty()
  value = db.IntegerProperty()


class TestNDBModel(ndb.Model):
  """Used to create ndb entities for tests."""
  name = ndb.StringProperty()
  value = ndb.IntegerProperty()


class TestDatastoreReaderForDB(unittest.TestCase):
  """Unit tests for DatastoreReaderForDB class."""
  def setUp(self):
    for i in range(10):
      TestDBModel(name='name %s' % i, value=i, key_name='id %s' % i).put()

    name = lists.SimpleColumn('name', 'Name')
    value = lists.SimpleColumn('value', 'Value')

    self.list_reader = lists.DatastoreReaderForDB()

    test_list = lists.List(DB_TEST_LIST_ID, 0, TestDBModel, [name, value],
                           self.list_reader)

    # Register the above list in the lists module
    lists.LISTS[DB_TEST_LIST_ID] = test_list

  def testGetListDataWithStartAndLimit(self):
    """Tests getGetListData method with parameters start and limit specified."""

    query = TestDBModel.all()
    start = str(TestDBModel.get_by_key_name('id 3').key())

    item_list, next_key = self.list_reader.getListData(
        DB_TEST_LIST_ID, query, start, 5)

    expected_list = [{'Name': 'name %s' % i, 'Value': i} for i in range(3, 8)]
    expected_next_key = str(TestDBModel.get_by_key_name('id 8').key())

    self.assertListEqual(item_list, expected_list)
    self.assertEqual(next_key, expected_next_key)

  def testGetListDataWithStart(self):
    """Tests getGetListData with parameter start specified but not limit."""
    query = TestDBModel.all()
    start = str(TestDBModel.get_by_key_name('id 3').key())

    item_list, next_key = self.list_reader.getListData(
        DB_TEST_LIST_ID, query, start=start)

    # All the items after specified id should be returned. Returned next key
    # should indicate final batch.
    expected_list = [{'Name': 'name %s' % i, 'Value': i} for i in range(3, 10)]
    expected_next_key = lists.FINAL_BATCH

    self.assertListEqual(item_list, expected_list)
    self.assertEqual(next_key, expected_next_key)

  def testGetListDataWithLimit(self):
    """Tests getGetListData with parameter limit specified but not start."""
    query = TestDBModel.all()

    item_list, next_key = self.list_reader.getListData(
        DB_TEST_LIST_ID, query, limit=5)

    # First five entities should be returned.
    expected_list = [{'Name': 'name %s' % i, 'Value': i} for i in range(0, 5)]
    expected_next_key = str(TestDBModel.get_by_key_name('id 5').key())

    self.assertListEqual(item_list, expected_list)
    self.assertEqual(next_key, expected_next_key)

  def testGetListDataWithoutStartOrLimit(self):
    """Tests getGetListData with parameter start or limit not specified."""
    query = TestDBModel.all()

    item_list, next_key = self.list_reader.getListData(
        DB_TEST_LIST_ID, query)

    # All the items in the list should be returned. Returned next key should
    # indicate final batch.
    expected_list = [{'Name': 'name %s' % i, 'Value': i} for i in range(0, 10)]
    expected_next_key = lists.FINAL_BATCH

    self.assertListEqual(item_list, expected_list)
    self.assertEqual(next_key, expected_next_key)


class TestDatastoreReaderForNDB(unittest.TestCase):
  """Unit tests for DatastoreReaderForDB class."""
  def setUp(self):
    for i in range(10):
      TestNDBModel(name='name %s' % i, value=i, id='id %s' % i).put()

    name = lists.SimpleColumn('name', 'Name')
    value = lists.SimpleColumn('value', 'Value')

    self.list_reader = lists.DatastoreReaderForNDB()

    test_list = lists.List(NDB_TEST_LIST_ID, 0, TestNDBModel, [name, value],
                           self.list_reader)

    lists.LISTS[NDB_TEST_LIST_ID] = test_list

  def testGetListDataWWithStartAndLimit(self):
    """Tests getGetListData method."""
    query = TestNDBModel.query()
    start = str(ndb.Key(TestNDBModel, 'id 3').to_old_key())

    item_list, next_key = self.list_reader.getListData(
        NDB_TEST_LIST_ID, query, start, 5)

    expected_list = [{'Name': 'name %s' % i, 'Value': i} for i in range(3, 8)]
    expected_next_key = str(ndb.Key(TestNDBModel, 'id 8').to_old_key())

    self.assertListEqual(item_list, expected_list)
    self.assertEqual(next_key, expected_next_key)

  def testGetListDataWithStart(self):
    """Tests getGetListData with parameter start specified but not limit."""
    query = TestNDBModel.query()
    start = str(ndb.Key(TestNDBModel, 'id 3').to_old_key())

    item_list, next_key = self.list_reader.getListData(
        NDB_TEST_LIST_ID, query, start=start)

    # All the items after specified id should be returned. Returned next key
    # should indicate final batch.
    expected_list = [{'Name': 'name %s' % i, 'Value': i} for i in range(3, 10)]
    expected_next_key = lists.FINAL_BATCH

    self.assertListEqual(item_list, expected_list)
    self.assertEqual(next_key, expected_next_key)

  def testGetListDataWithLimit(self):
    """Tests getGetListData with parameter limit specified but not start."""
    query = TestNDBModel.query()

    item_list, next_key = self.list_reader.getListData(
        NDB_TEST_LIST_ID, query, limit=5)

    # First five entities should be returned.
    expected_list = [{'Name': 'name %s' % i, 'Value': i} for i in range(0, 5)]
    expected_next_key = str(ndb.Key(TestNDBModel, 'id 5').to_old_key())

    self.assertListEqual(item_list, expected_list)
    self.assertEqual(next_key, expected_next_key)

  def testGetListDataWithoutStartOrLimit(self):
    """Tests getGetListData with parameter start or limit not specified."""
    query = TestNDBModel.query()

    item_list, next_key = self.list_reader.getListData(
        NDB_TEST_LIST_ID, query)

    # All the items in the list should be returned. Returned next key should
    # indicate final batch.
    expected_list = [{'Name': 'name %s' % i, 'Value': i} for i in range(0, 10)]
    expected_next_key = lists.FINAL_BATCH

    self.assertListEqual(item_list, expected_list)
    self.assertEqual(next_key, expected_next_key)


class TestCacheReader(unittest.TestCase):
  """Unit tests for CacheReader class"""
  # TODO:(Aruna)complete this class
  pass


class TestGetDataId(unittest.TestCase):
  """Unit tests for the getDataId function."""

  def testWithNDBQuery(self):
    """Tests getDataId function with ndb query objects."""
    query = TestNDBModel.query().filter(TestNDBModel.name == 'foo')
    same_query = TestNDBModel.query().filter(TestNDBModel.name == 'foo')
    # queries that represent same data should have same data id.
    self.assertEqual(lists.getDataId(query), lists.getDataId(same_query))

    # queries that represent different data should have different data ids.
    different_query = TestNDBModel.query().filter(TestNDBModel.name == 'bar')
    self.assertNotEqual(lists.getDataId(query),
                        lists.getDataId(different_query))

    different_query = TestNDBModel.query().filter(TestNDBModel.value == 9)
    self.assertNotEqual(lists.getDataId(query),
                        lists.getDataId(different_query))

  def testWithDBQuery(self):
    """Tests getDataId function with db query objects."""
    query = TestDBModel.all().filter('name', 'foo')
    same_query = TestDBModel.all().filter('name', 'foo')
    # queries that represent same data should have the same data id.
    self.assertEqual(lists.getDataId(query), lists.getDataId(same_query))

    # queries that represent different data should have different data ids.
    different_query = TestDBModel.all().filter('name', 'bar')
    self.assertNotEqual(lists.getDataId(query),
                        lists.getDataId(different_query))
    different_query = TestDBModel.all().filter('value', 'bar')
    self.assertNotEqual(lists.getDataId(query),
                        lists.getDataId(different_query))