oship-dev team mailing list archive

[noreply@xxxxxxxxxxxxx]

------------------------------------------------------------
revno: 469
committer: Wagner Francisco Mezaroba <wagner@wagner-laptop>
branch nick: oship
timestamp: Wed 2010-08-11 11:04:23 -0300
message:
  Adding ItemTable methods and its tests. Bug #607524.
modified:
  src/oship/openehr/rm/data_structures/item_structure/__init__.py
  src/oship/openehr/rm/data_structures/item_structure/tests/item_structure.py


--
lp:oship
https://code.launchpad.net/~oship-dev/oship/devel

Your team OSHIP Development Team is subscribed to branch lp:oship.
To unsubscribe from this branch go to https://code.launchpad.net/~oship-dev/oship/devel/+edit-subscription

=== modified file 'src/oship/openehr/rm/data_structures/item_structure/__init__.py'
--- src/oship/openehr/rm/data_structures/item_structure/__init__.py	2010-08-09 00:00:47 +0000
+++ src/oship/openehr/rm/data_structures/item_structure/__init__.py	2010-08-11 14:04:23 +0000
@@ -44,8 +44,8 @@
                 return item
         return None
 
-    def ithItem(n):
-        return items[n]
+    def ithItem(self, n):
+        return self.items[n]
 
     def asHierarchy():
         u"""Generate a CEN EN13606-compatible hierarchy consisting of a single
@@ -90,47 +90,69 @@
 
     def __init__(self, rows, uid, atnodeid, name, atdetails, fdraudit, links, parent):
         ItemStructure.__init__(self, uid, atnodeid, name, atdetails, fdraudit, links, parent)
-        self.rows=rows
-
-    def rowCount():
-        u"""Return number of rows as an integer."""
-
-    def columnCount():
-        u"""Return the number of columns as an integer."""
-
-    def rowNames():
-        u"""Return the List of row names as DvText items."""
-
-    def columnNames():
-        u"""Return the List of column names as DvText items."""
-
-    def ithRow(n):
-        u"""Return the 'n' ith row as a Cluster."""
-
-    def hasRowWithName(a_key):
-        u"""Return True if a_key exists as a row name."""
-
-    def hasColumnWithName(a_key):
-        u"""Return True if a_key exists as a column name."""
-
-    def namedRow(a_key):
-        u"""Return the row whose first column has the name a_key."""
-
-    def hasRowWithKeys(keys):
+        if rows is None:
+            self.rows = []
+        else:
+            self.rows=rows
+
+    def rowCount(self):
+        return len(self.rows)
+
+    def columnCount(self):
+        return 0 if len(self.rows) < 1 else len(self.rows[0].items)
+
+    def rowNames(self):
+        return [row.name for row in self.rows]
+
+    def columnNames(self):
+        if len(self.rows) > 0:
+            row = self.rows[0]
+            return [column.name for column in row.items]
+        return []
+
+    def ithRow(self, n):
+        return self.rows[n]
+
+    def hasRowWithName(self, aKey):
+        if aKey is None or len(aKey.strip()) == 0:
+            raise ValueError('key must no be None or empty')
+        for row in self.rows:
+            if len(row.items) > 0 and row.items[0].name.value == aKey:
+                return True                
+        return False
+
+    def hasColumnWithName(self,aKey):
+        if aKey is None or len(aKey.strip()) == 0:
+            raise ValueError('key must no be None or empty')
+        for row in self.rows:
+            for column in row.items:
+                if column.name.value == aKey:
+                    return True
+        return False
+
+    def namedRow(self,aKey):
+        if not self.hasRowWithName(aKey):
+            raise ValueError('There is no row whose first column has the name: ' + aKey)        
+        for row in self.rows:
+            if len(row.items) > 0 and row.items[0].name.value == aKey:
+                return row 
+
+
+    def hasRowWithKeys(self,keys):
         u"""Return True if a row's first n columns contain the names of set of
         keys."""
 
-    def rowWithKeys(keys):
+    def rowWithKeys(self,keys):
         u"""Return the row whose first n columns contain the names in the set
         of keys."""
 
-    def elementAtCell(i, j):
+    def elementAtCell(self,i, j):
         u"""
         NOTE: In the specs this is called elementAtCellij. I think it should be
         changed. Return the element at the intersection of column i and row j.
         i and j are integers. """
 
-    def elementAtNamedCell(row_key, col_key):
+    def elementAtNamedCell(self,row_key, col_key):
         u"""Return the element at the intersection or col_key and row_key """
 
     def asHierarchy():

=== modified file 'src/oship/openehr/rm/data_structures/item_structure/tests/item_structure.py'
--- src/oship/openehr/rm/data_structures/item_structure/tests/item_structure.py	2010-08-09 00:00:47 +0000
+++ src/oship/openehr/rm/data_structures/item_structure/tests/item_structure.py	2010-08-11 14:04:23 +0000
@@ -8,9 +8,13 @@
 
 from oship.openehr.rm.data_structures.item_structure import ItemList
 from oship.openehr.rm.data_structures.item_structure.representation import Element
+
+from oship.openehr.rm.data_structures.item_structure import ItemTable
+from oship.openehr.rm.data_structures.item_structure.representation import Cluster
+
 from oship.openehr.rm.datatypes.text import DvText
 
-class EventTest(unittest.TestCase):
+class ItemListTest(unittest.TestCase):
 
     def setUp(self):
         self.element1Name = DvText(u'element1',None,None,None,None,None)
@@ -29,10 +33,6 @@
         self.anEmptyList = None
         self.aList = None
 
-    def createElement(self, aName):
-        elementName = DvText(aName,None,None,None,None,None)
-        return Element(None,None,aName,None,elementName,None,None,None,None)
-
     def createAList(self, items=None):
         aListName = DvText(u'A Simple ItemList',None,None,None,None,None)
         return ItemList(items,None,u'A Simple ItemList',aListName,None,None,None,None)
@@ -53,7 +53,7 @@
         for name in (self.element1Name, self.element2Name, self.element3Name):
             self.assertTrue(name in listNames)
 
-    def testNamedItemiWithEmptyName(self):
+    def testNamedItemWithEmptyName(self):
         name = '  '
         self.assertRaises(ValueError, self.aList.namedItem, name)
 
@@ -68,9 +68,127 @@
         self.assertEqual(None, self.aList.namedItem(u'an invalid name'))
 
     def testIthItem(self):
-        self.assertEqual(self.items[0], self.aList.items[0])
+        self.assertEqual(self.items[0], self.aList.ithItem(0))
 
     def testIthItemWithInvalidIndex(self):
-        self.assertRaises(IndexError, self.items.__getitem__, 20)
-
+        self.assertRaises(IndexError, self.aList.ithItem, 20)
+
+class ItemTableTest(unittest.TestCase):
+
+    def setUp(self):
+        self.cluster1Name = DvText(u'cluster1',None,None,None,None,None)
+        self.cluster2Name = DvText(u'cluster2',None,None,None,None,None)
+        self.cluster3Name = DvText(u'cluster3',None,None,None,None,None)
+        self.cluster1 = self.createCluster(self.cluster1Name)
+        self.cluster2 = self.createCluster(self.cluster2Name)
+        self.cluster3 = self.createCluster(self.cluster3Name)
+        self.rows = [self.cluster1, self.cluster2, self.cluster3]
+
+        self.anEmptyTable = self.createATable()
+        self.aTable = self.createATable(self.rows)
+
+    def tearDown(self):
+        self.aTable = None
+
+    def createCluster(self, name):
+        self.element1Name = DvText(u'element1',None,None,None,None,None)
+        self.element2Name = DvText(u'element2',None,None,None,None,None)
+        self.element3Name = DvText(u'element3',None,None,None,None,None)
+
+        self.element1 = Element(None,None,None,None,self.element1Name,None,None,None,None)
+        self.element2 = Element(None,None,None,None,self.element2Name,None,None,None,None)
+        self.element3 = Element(None,None,None,None,self.element3Name,None,None,None,None)
+
+        self.items = [self.element1, self.element2, self.element3]
+        return Cluster(None,name,name,None,None,None,self.items,None)
+
+    def createATable(self, rows=None):
+        tableName = DvText(u'A Simple ItemTable',None,None,None,None,None)
+        return ItemTable(rows,None,u'A Simple ItemTable',tableName,None,None,None,None)
+
+    def testRowCountWithEmptyTable(self):
+        self.assertEqual(0, self.anEmptyTable.rowCount())
+
+    def testRowCountWithNotEmptyTable(self):
+        self.assertEqual(len(self.rows), self.aTable.rowCount())
+
+    def testColumnCountWithEmptyTable(self):
+        self.assertEqual(0, self.anEmptyTable.columnCount())
+
+    def testColumnCountWithNotEmptyTable(self):
+        self.assertEqual(len(self.items), self.aTable.columnCount())
+
+    def testRowNamesWithEmptyTable(self):
+        rowNames = self.anEmptyTable.rowNames()
+        self.assertEquals(0, len(rowNames))
+
+    def testRowNamesWithNotEmptyTable(self):
+        rowNames = self.aTable.rowNames()
+        self.assertEquals(len(self.rows), len(rowNames))
+        for name in (self.cluster1Name, self.cluster2Name, self.cluster3Name):
+            self.assertTrue(name in rowNames)
+
+    def testColumnNamesWithEmptyTable(self):
+        columnNames = self.anEmptyTable.columnNames()
+        self.assertEquals(0, len(columnNames))
+
+    def testColumnNamesWithNotEmptyTable(self):
+        columnNames = self.aTable.columnNames()
+        self.assertEquals(len(self.items), len(columnNames))
+        for name in (self.element1Name, self.element2Name, self.element3Name):
+            self.assertTrue(name in columnNames)
+
+    def testIthRow(self):
+        self.assertEqual(self.rows[0], self.aTable.ithRow(0))
+
+    def testIthRowWithInvalidIndex(self):
+        self.assertRaises(IndexError, self.aTable.ithRow, 20)
+
+    def testHasRowWithExistentName(self):
+        self.assertTrue(self.aTable.hasRowWithName(u'element1'))
+
+    def testHasRowWithInexistentName(self):
+        self.assertFalse(self.aTable.hasRowWithName(u'inexistent name'))
+
+    def testHasRowWithEmptyName(self):
+        self.assertRaises(ValueError, self.aTable.hasRowWithName, u'   ')
+
+    def testHasRowWithNoneName(self):
+        self.assertRaises(ValueError, self.aTable.hasRowWithName, None)
+
+    def testHasColumnWithExistentName(self):
+        self.assertTrue(self.aTable.hasColumnWithName(u'element1'))
+
+    def testHasColumnWithInexistentName(self):
+        self.assertFalse(self.aTable.hasColumnWithName(u'inexistent name'))
+
+    def testHasColumnWithEmptyName(self):
+        self.assertRaises(ValueError, self.aTable.hasColumnWithName, u'   ')
+
+    def testHasRowColumnNoneName(self):
+        self.assertRaises(ValueError, self.aTable.hasColumnWithName, None)
+
+    def testNamedRowWithInexistentName(self):
+        name = u'inexistent name'
+        self.assertRaises(ValueError, self.aTable.namedRow, name)
+
+    def testNamedRowWithExistentName(self):
+        name = u'element1'
+        self.assertEqual(self.cluster1, self.aTable.namedRow(name))
+
+"""
+    def testNamedItemiWithEmptyName(self):
+        name = '  '
+        self.assertRaises(ValueError, self.aList.namedItem, name)        
+
+    def testNamedItemWithNoneName(self):
+        self.assertRaises(ValueError, self.aList.namedItem, None)
+
+    def testNamedItemWithValidNames(self):
+        for item in self.items:
+            self.assertEqual(item, self.aList.namedItem(item.name.value))
+
+    def testNamedItemWithInvalidName(self):
+        self.assertEqual(None, self.aList.namedItem(u'an invalid name'))
+"""