RBK/Model/db.py

@@ -72,7 +72,7 @@ class Database(QObject):
         self.relayRemoveField.connect(self.fieldModel.removeField)
 
         runQuery(self.db, "CREATE TABLE Rulebook(GameName TEXT NOT NULL, GameVersion TEXT NOT NULL, RulebookName TEXT PRIMARY KEY NOT NULL, Core TEXT NOT NULL, CoreRulebook TEXT, CoreRulebookHash TEXT)")
-        result = runQuery(self.db, 'INSERT INTO Rulebook (GameName, GameVersion, RulebookName, Core, CoreRulebook) VALUES ("{0}", "{1}", "{2}", "{3}", "{4}")'.format(game, version, rbk, core, corerbk, hash))
+        result = runQuery(self.db, 'INSERT INTO Rulebook (GameName, GameVersion, RulebookName, Core, CoreRulebook, CoreRulebookHash) VALUES ("{0}", "{1}", "{2}", "{3}", "{4}", "{5}")'.format(game, version, rbk, core, corerbk, corehash))
 
         if core=='True':
             self.addDataType('DataTypes')
@@ -85,7 +85,7 @@ class Database(QObject):
 
         if core=='False':
             coreFilename = 'Rulebooks/{0}/{1}/{2}.rbk'.format(game, version, corerbk)
-            openCoreRulebook(coreFilename)
+            self.openCoreRulebook(coreFilename)
         return True
 
 

RBK/Tests/test_NewCoreRulebookTestCase.py

@@ -4,7 +4,6 @@ import string
 
 from RBK.Model.db import Database
 
-#@pytest.fixture
 def generateTestData():
     return ''.join(random.choice(string.ascii_letters) \
                     for i in range(random.randrange(32)))
@@ -31,8 +30,8 @@ def dataFieldIndices(request):
 
 
 @pytest.fixture(scope='module', params=[('Field Name', ('Name', \
-                                                        'Rulebook PDF Destination', \
-                                                        'Character Sheet Field')),
+                                                'Rulebook PDF Destination', \
+                                                'Character Sheet Field')),
                                          ('Type', 'Text'), \
                                          ('Constraints', 'maxLength(50)'), \
                                          ('User Editable?', 'False') \
@@ -117,7 +116,8 @@ def test_DataTypesTableExists(db, datatypes):
     assert 'DataTypes' in db.models
 
 def test_DataTypeFound(db, datatypes):
-    assert db.models['DataTypes'].record(datatypes[0]).value('DataType') == datatypes[1]
+    assert db.models['DataTypes'].record(datatypes[0]).value('DataType') == \
+                                                                  datatypes[1]
 
 
 ##########################
@@ -135,7 +135,7 @@ def test_OtherTableExists(db, tabletypes, datatypes):
 def test_StructColumnCount(db, datatypes):
     assert db.models[tablename('Struct', datatypes[1])].columnCount() == 4
 
-def test_StructRowcount(db, datatypes):
+def test_StructRowCount(db, datatypes):
     assert db.models[tablename('Struct', datatypes[1])].rowCount() == 3
 
 def test_StructNameFieldExists(db, datatypes, structFieldIndices):
@@ -143,9 +143,13 @@ def test_StructNameFieldExists(db, datatypes, structFieldIndices):
 
 def test_RowsExists(db, datatypes, structFieldIndices):
     if structFieldIndices[0]=='Field Name':
-        assert db.models[tablename('Struct', datatypes[1])].record(datatypes[0]).value(structFieldIndices[0]) == structFieldIndices[1][datatypes[0]]
+        assert db.models[tablename('Struct', datatypes[1])].record( \
+                        datatypes[0]).value(structFieldIndices[0]) == \
+                        structFieldIndices[1][datatypes[0]]
     else:
-        assert db.models[tablename('Struct', datatypes[1])].record(datatypes[0]).value(structFieldIndices[0]) == structFieldIndices[1]
+        assert db.models[tablename('Struct', datatypes[1])].record( \
+                        datatypes[0]).value(structFieldIndices[0]) == \
+                        structFieldIndices[1]
 
 
 ##########################
@@ -161,4 +165,5 @@ def test_DataRowcount(db, datatypes):
     assert db.models[tablename('Data', datatypes[1])].rowCount() == 0
 
 def test_DataNameFieldExists(db, datatypes, dataFieldIndices):
-    assert db.models[tablename('Data', datatypes[1])].fieldIndex(dataFieldIndices) > -1
+    assert db.models[tablename('Data', datatypes[1])].fieldIndex( \
+                                                        dataFieldIndices) > -1

RBK/Tests/test_NewNonCoreRulebook.py

@@ -0,0 +1,193 @@
+import pytest
+import random
+import string
+
+from RBK.Model.db import Database
+from RBK.Model.Functions import runQuery, isError
+
+def generateTestData():
+    return ''.join(random.choice(string.ascii_letters) \
+                    for i in range(random.randrange(32)))
+
+@pytest.fixture(scope='module', params=['Struct', 'Data'])
+def tabletypes(request):
+    return request.param
+
+@pytest.fixture(scope='module', params=[(0, 'Actions'), \
+                                        (1, 'Currencies'), \
+                                        (2, 'Character') \
+                                       ])
+def datatypes(request):
+    return request.param
+
+
+@pytest.fixture(scope='module', params=['Name', \
+                                        'Rulebook PDF Destination', \
+                                        'Character Sheet Field' \
+                                        ])
+def dataFieldIndices(request):
+    return request.param
+
+
+@pytest.fixture(scope='module', params=[('Field Name', ('Name', \
+                                                'Rulebook PDF Destination', \
+                                                'Character Sheet Field')),
+                                         ('Type', 'Text'), \
+                                         ('Constraints', 'maxLength(50)'), \
+                                         ('User Editable?', 'False') \
+                                        ])
+def structFieldIndices(request):
+    return request.param
+
+@pytest.fixture(scope='module')
+def game(db):
+    return db.models['Rulebook'].record(0).value('GameName')
+
+@pytest.fixture(scope='module')
+def version(db):
+    return db.models['Rulebook'].record(0).value('GameVersion')
+
+@pytest.fixture(scope='module')
+def rbk():
+    return generateTestData()
+
+@pytest.fixture(scope='module')
+def core():
+    return 'False'
+
+@pytest.fixture(scope='module')
+def corerbk(db):
+    return db.models['Rulebook'].record(0).value('CoreRulebook')
+
+@pytest.fixture(scope='module')
+def corehash(db):
+    return db.models['Rulebook'].record(0).value('CoreRulebookHash')
+
+@pytest.fixture(scope='module')
+def nonCoreDBName(game, version, rbk):
+    return 'Rulebooks/' + game + '/' + version + '/' + rbk + '.rbk'
+
+@pytest.fixture(scope='module')
+def coreDBName(game, version, corerbk):
+    return 'Rulebooks/' + game + '/' + version + '/' + corerbk + '.rbk'
+
+
+@pytest.fixture(scope='module')
+def db(rbk, core):
+    database = Database()
+    result = runQuery(database.rulebooks, 'SELECT * FROM Rulebooks WHERE GameName = "Tests" AND Core = "True" LIMIT 1')
+    if not isError(result):
+        f = result.getValue()[0]
+        database.newRulebook(f.value('GameName'), f.value('GameVersion'), \
+                             rbk, core, \
+                             f.value('RulebookName'), f.value('Hash'))
+    yield database
+    database.closeRulebook()
+
+
+##########################
+#
+# Rulebook Table
+#
+##########################
+
+def test_RulebookTable(db):
+        assert 'Rulebook' in db.models
+
+def test_RulebookHasGameName(db, game):
+    gamename = db.models['Rulebook'].record(0).value('GameName')
+    assert gamename == game
+
+def test_RulebookHasGameVersion(db, version):
+    gameversion = db.models['Rulebook'].record(0).value('GameVersion')
+    assert gameversion == version
+
+def test_RulebookHasRulebookName(db, rbk):
+    gamerbkname = db.models['Rulebook'].record(0).value('RulebookName')
+    assert gamerbkname == rbk
+
+# For Core, should be True
+def test_RulebookHasCore(db, core):
+    iamcore = db.models['Rulebook'].record(0).value('Core')
+    assert iamcore == core
+
+# For Core, should be empty string
+def test_RulebookHasCoreRulebook(db, corerbk):
+    gamecorerbk = db.models['Rulebook'].record(0).value('CoreRulebook')
+    assert gamecorerbk == corerbk
+
+# For Core, should be empty string
+def test_RulebookHasCoreRulebookHash(db, corehash):
+    gamecorehash = db.models['Rulebook'].record(0).value('CoreRulebookHash')
+    assert gamecorehash == corehash
+
+##########################
+#
+# DataTypes Table
+#
+##########################
+
+def test_DataTypesTableExists(db, datatypes):
+    assert 'DataTypes' in db.models
+
+def test_DataTypeFound(db, datatypes):
+    assert db.models['DataTypes'].record(datatypes[0]).value('DataType') == \
+                                                                  datatypes[1]
+
+
+##########################
+#
+# Struct Tables
+#
+##########################
+
+def tablename(tt, dt):
+    return tt + ' ' + dt
+
+def test_OtherTableExists(db, tabletypes, datatypes):
+    assert tablename(tabletypes, datatypes[1]) in db.models
+
+def test_StructFromCoreRulebook(db, datatypes, coreDBName):
+    assert db.models[tablename('Struct', \
+              datatypes[1])].database().databaseName() == coreDBName
+
+def test_StructColumnCount(db, datatypes):
+    assert db.models[tablename('Struct', datatypes[1])].columnCount() == 4
+
+def test_StructRowCount(db, datatypes):
+    assert db.models[tablename('Struct', datatypes[1])].rowCount() == 3
+
+def test_StructNameFieldExists(db, datatypes, structFieldIndices):
+    assert db.models[tablename('Struct', \
+              datatypes[1])].fieldIndex(structFieldIndices[0]) > -1
+
+def test_RowsExists(db, datatypes, structFieldIndices):
+    if structFieldIndices[0]=='Field Name':
+        assert db.models[tablename('Struct', datatypes[1])].record( \
+                        datatypes[0]).value(structFieldIndices[0]) == \
+                        structFieldIndices[1][datatypes[0]]
+    else:
+        assert db.models[tablename('Struct', datatypes[1])].record( \
+                        datatypes[0]).value(structFieldIndices[0]) == \
+                        structFieldIndices[1]
+
+
+##########################
+#
+# Data Tables
+#
+##########################
+
+def test_DataFromNonCoreRulebook(db, datatypes, nonCoreDBName):
+    assert db.models[tablename('Data', \
+              datatypes[1])].database().databaseName() == nonCoreDBName
+
+def test_DataColumnCount(db, datatypes):
+    assert db.models[tablename('Data', datatypes[1])].columnCount() == 3
+
+def test_DataRowcount(db, datatypes):
+    assert db.models[tablename('Data', datatypes[1])].rowCount() == 0
+
+def test_DataNameFieldExists(db, datatypes, dataFieldIndices):
+    assert db.models[tablename('Data', datatypes[1])].fieldIndex( \
+                                                        dataFieldIndices) > -1

RBK/Tests/test_OpenCoreRulebook.py

@@ -0,0 +1,182 @@
+import pytest
+import random
+import string
+
+from RBK.Model.db import Database
+from RBK.Model.Functions import runQuery, isError
+
+@pytest.fixture(scope='module', params=['Struct', 'Data'])
+def tabletypes(request):
+    return request.param
+
+
+@pytest.fixture(scope='module', params=[(0, 'Actions'), \
+                                        (1, 'Currencies'), \
+                                        (2, 'Character') \
+                                       ])
+def datatypes(request):
+    return request.param
+
+
+@pytest.fixture(scope='module', params=['Name', \
+                                        'Rulebook PDF Destination', \
+                                        'Character Sheet Field' \
+                                        ])
+def dataFieldIndices(request):
+    return request.param
+
+
+@pytest.fixture(scope='module', params=[('Field Name', ('Name', \
+                                                'Rulebook PDF Destination', \
+                                                'Character Sheet Field')),
+                                         ('Type', 'Text'), \
+                                         ('Constraints', 'maxLength(50)'), \
+                                         ('User Editable?', 'False') \
+                                        ])
+def structFieldIndices(request):
+    return request.param
+
+@pytest.fixture(scope='module')
+def game(db):
+    return db.models['Rulebook'].record(0).value('GameName')
+
+@pytest.fixture(scope='module')
+def version(db):
+    return db.models['Rulebook'].record(0).value('GameVersion')
+
+@pytest.fixture(scope='module')
+def rbk(db):
+    return db.models['Rulebook'].record(0).value('RulebookName')
+
+@pytest.fixture(scope='module')
+def core():
+    return 'True'
+
+@pytest.fixture(scope='module')
+def corerbk():
+    return ''
+
+@pytest.fixture(scope='module')
+def corehash():
+    return ''
+
+@pytest.fixture(scope='module')
+def db():
+    database = Database()
+    result = runQuery(database.rulebooks, 'SELECT * FROM Rulebooks WHERE GameName = "Tests" AND Core = "True" LIMIT 1')
+    if not isError(result):
+        f = result.getValue()[0]
+        filename = 'Rulebooks/' + \
+                   f.value('GameName') + '/' + \
+                   f.value('GameVersion') + '/' + \
+                   f.value('RulebookName') + '.rbk'
+        ok = database.openRulebook(filename)
+        if ok:
+            print('Rulebook ' + filename + ' opened.')
+        else:
+            print('Cannot open Rulebook ' + filename)
+            exit(5)
+    else:
+        print('Cannot open Rulebook ' + filename)
+        exit(5)
+    yield database
+    database.closeRulebook()
+
+
+##########################
+#
+# Rulebook Table
+#
+##########################
+
+def test_RulebookTable(db):
+        assert 'Rulebook' in db.models
+
+def test_RulebookHasGameName(db, game):
+    gamename = db.models['Rulebook'].record(0).value('GameName')
+    assert gamename == game
+
+def test_RulebookHasGameVersion(db, version):
+    gameversion = db.models['Rulebook'].record(0).value('GameVersion')
+    assert gameversion == version
+
+def test_RulebookHasRulebookName(db, rbk):
+    gamerbkname = db.models['Rulebook'].record(0).value('RulebookName')
+    assert gamerbkname == rbk
+
+# For Core, should be True
+def test_RulebookHasCore(db, core):
+    iamcore = db.models['Rulebook'].record(0).value('Core')
+    assert iamcore == core
+
+# For Core, should be empty string
+def test_RulebookHasCoreRulebook(db, corerbk):
+    gamecorerbk = db.models['Rulebook'].record(0).value('CoreRulebook')
+    assert gamecorerbk == corerbk
+
+# For Core, should be empty string
+def test_RulebookHasCoreRulebookHash(db, corehash):
+    gamecorehash = db.models['Rulebook'].record(0).value('CoreRulebookHash')
+    assert gamecorehash == corehash
+
+##########################
+#
+# DataTypes Table
+#
+##########################
+
+def test_DataTypesTableExists(db, datatypes):
+    assert 'DataTypes' in db.models
+
+def test_DataTypeFound(db, datatypes):
+    assert db.models['DataTypes'].record(datatypes[0]).value('DataType') == \
+                                                                  datatypes[1]
+
+
+##########################
+#
+# Struct Tables
+#
+##########################
+
+def tablename(tt, dt):
+    return tt + ' ' + dt
+
+def test_OtherTableExists(db, tabletypes, datatypes):
+    assert tablename(tabletypes, datatypes[1]) in db.models
+
+def test_StructColumnCount(db, datatypes):
+    assert db.models[tablename('Struct', datatypes[1])].columnCount() == 4
+
+def test_StructRowCount(db, datatypes):
+    assert db.models[tablename('Struct', datatypes[1])].rowCount() == 3
+
+def test_StructNameFieldExists(db, datatypes, structFieldIndices):
+    assert db.models[tablename('Struct', datatypes[1])].fieldIndex(structFieldIndices[0]) > -1
+
+def test_RowsExists(db, datatypes, structFieldIndices):
+    if structFieldIndices[0]=='Field Name':
+        assert db.models[tablename('Struct', datatypes[1])].record( \
+                        datatypes[0]).value(structFieldIndices[0]) == \
+                        structFieldIndices[1][datatypes[0]]
+    else:
+        assert db.models[tablename('Struct', datatypes[1])].record( \
+                        datatypes[0]).value(structFieldIndices[0]) == \
+                        structFieldIndices[1]
+
+
+##########################
+#
+# Data Tables
+#
+##########################
+
+def test_DataColumnCount(db, datatypes):
+    assert db.models[tablename('Data', datatypes[1])].columnCount() == 3
+
+def test_DataRowcount(db, datatypes):
+    assert db.models[tablename('Data', datatypes[1])].rowCount() == 0
+
+def test_DataNameFieldExists(db, datatypes, dataFieldIndices):
+    assert db.models[tablename('Data', datatypes[1])].fieldIndex( \
+                                                        dataFieldIndices) > -1

RBK/Tests/test_OpenNonCoreRulebook.py

@@ -0,0 +1,199 @@
+import pytest
+import random
+import string
+
+from RBK.Model.db import Database
+from RBK.Model.Functions import runQuery, isError
+
+@pytest.fixture(scope='module', params=['Struct', 'Data'])
+def tabletypes(request):
+    return request.param
+
+@pytest.fixture(scope='module', params=[(0, 'Actions'), \
+                                        (1, 'Currencies'), \
+                                        (2, 'Character') \
+                                       ])
+def datatypes(request):
+    return request.param
+
+
+@pytest.fixture(scope='module', params=['Name', \
+                                        'Rulebook PDF Destination', \
+                                        'Character Sheet Field' \
+                                        ])
+def dataFieldIndices(request):
+    return request.param
+
+
+@pytest.fixture(scope='module', params=[('Field Name', ('Name', \
+                                                'Rulebook PDF Destination', \
+                                                'Character Sheet Field')),
+                                         ('Type', 'Text'), \
+                                         ('Constraints', 'maxLength(50)'), \
+                                         ('User Editable?', 'False') \
+                                        ])
+def structFieldIndices(request):
+    return request.param
+
+@pytest.fixture(scope='module')
+def game(db):
+    return db.models['Rulebook'].record(0).value('GameName')
+
+@pytest.fixture(scope='module')
+def version(db):
+    return db.models['Rulebook'].record(0).value('GameVersion')
+
+@pytest.fixture(scope='module')
+def rbk(db):
+    return db.models['Rulebook'].record(0).value('RulebookName')
+
+@pytest.fixture(scope='module')
+def core():
+    return 'False'
+
+@pytest.fixture(scope='module')
+def corerbk(db):
+    return db.models['Rulebook'].record(0).value('CoreRulebook')
+
+@pytest.fixture(scope='module')
+def corehash(db):
+    return db.models['Rulebook'].record(0).value('CoreRulebookHash')
+
+@pytest.fixture(scope='module')
+def nonCoreDBName(game, version, rbk):
+    return 'Rulebooks/' + game + '/' + version + '/' + rbk + '.rbk'
+
+@pytest.fixture(scope='module')
+def coreDBName(game, version, corerbk):
+    return 'Rulebooks/' + game + '/' + version + '/' + corerbk + '.rbk'
+
+
+@pytest.fixture(scope='module')
+def db():
+    database = Database()
+    result = runQuery(database.rulebooks, 'SELECT * FROM Rulebooks WHERE GameName = "Tests" AND Core = "False" LIMIT 1')
+    if not isError(result):
+        f = result.getValue()[0]
+        filename = 'Rulebooks/' + \
+                   f.value('GameName') + '/' + \
+                   f.value('GameVersion') + '/' + \
+                   f.value('RulebookName') + '.rbk'
+        ok = database.openRulebook(filename)
+        if ok:
+            print('Rulebook ' + filename + ' opened.')
+        else:
+            print('Cannot open Rulebook ' + filename)
+            exit(5)
+    else:
+        print('Cannot open Rulebook ' + filename)
+        exit(5)
+    yield database
+    database.closeRulebook()
+
+
+##########################
+#
+# Rulebook Table
+#
+##########################
+
+def test_RulebookTable(db):
+        assert 'Rulebook' in db.models
+
+def test_RulebookHasGameName(db, game):
+    gamename = db.models['Rulebook'].record(0).value('GameName')
+    assert gamename == game
+
+def test_RulebookHasGameVersion(db, version):
+    gameversion = db.models['Rulebook'].record(0).value('GameVersion')
+    assert gameversion == version
+
+def test_RulebookHasRulebookName(db, rbk):
+    gamerbkname = db.models['Rulebook'].record(0).value('RulebookName')
+    assert gamerbkname == rbk
+
+# For Core, should be True
+def test_RulebookHasCore(db, core):
+    iamcore = db.models['Rulebook'].record(0).value('Core')
+    assert iamcore == core
+
+# For Core, should be empty string
+def test_RulebookHasCoreRulebook(db, corerbk):
+    gamecorerbk = db.models['Rulebook'].record(0).value('CoreRulebook')
+    assert gamecorerbk == corerbk
+
+# For Core, should be empty string
+def test_RulebookHasCoreRulebookHash(db, corehash):
+    gamecorehash = db.models['Rulebook'].record(0).value('CoreRulebookHash')
+    assert gamecorehash == corehash
+
+##########################
+#
+# DataTypes Table
+#
+##########################
+
+def test_DataTypesTableExists(db, datatypes):
+    assert 'DataTypes' in db.models
+
+def test_DataTypeFound(db, datatypes):
+    assert db.models['DataTypes'].record(datatypes[0]).value('DataType') == \
+                                                                  datatypes[1]
+
+
+##########################
+#
+# Struct Tables
+#
+##########################
+
+def tablename(tt, dt):
+    return tt + ' ' + dt
+
+def test_OtherTableExists(db, tabletypes, datatypes):
+    assert tablename(tabletypes, datatypes[1]) in db.models
+
+def test_StructFromCoreRulebook(db, datatypes, coreDBName):
+    assert db.models[tablename('Struct', \
+              datatypes[1])].database().databaseName() == coreDBName
+
+def test_StructColumnCount(db, datatypes):
+    assert db.models[tablename('Struct', datatypes[1])].columnCount() == 4
+
+def test_StructRowCount(db, datatypes):
+    assert db.models[tablename('Struct', datatypes[1])].rowCount() == 3
+
+def test_StructNameFieldExists(db, datatypes, structFieldIndices):
+    assert db.models[tablename('Struct', \
+              datatypes[1])].fieldIndex(structFieldIndices[0]) > -1
+
+def test_RowsExists(db, datatypes, structFieldIndices):
+    if structFieldIndices[0]=='Field Name':
+        assert db.models[tablename('Struct', datatypes[1])].record( \
+                        datatypes[0]).value(structFieldIndices[0]) == \
+                        structFieldIndices[1][datatypes[0]]
+    else:
+        assert db.models[tablename('Struct', datatypes[1])].record( \
+                        datatypes[0]).value(structFieldIndices[0]) == \
+                        structFieldIndices[1]
+
+
+##########################
+#
+# Data Tables
+#
+##########################
+
+def test_DataFromNonCoreRulebook(db, datatypes, nonCoreDBName):
+    assert db.models[tablename('Data', \
+              datatypes[1])].database().databaseName() == nonCoreDBName
+
+def test_DataColumnCount(db, datatypes):
+    assert db.models[tablename('Data', datatypes[1])].columnCount() == 3
+
+def test_DataRowcount(db, datatypes):
+    assert db.models[tablename('Data', datatypes[1])].rowCount() == 0
+
+def test_DataNameFieldExists(db, datatypes, dataFieldIndices):
+    assert db.models[tablename('Data', datatypes[1])].fieldIndex( \
+                                                        dataFieldIndices) > -1