def test_all(self):
batch = Batch()
Environment.get_security().set_admin(True)
from pyasm.unittest import UnittestEnvironment, Sample3dEnvironment
test_env = UnittestEnvironment()
test_env.create()
sample3d_env = Sample3dEnvironment(project_code='sample3d')
sample3d_env.create()
Project.set_project("unittest")
try:
self.access_manager = Environment.get_security().get_access_manager()
self._test_all()
finally:
# Reset access manager for tear down
Environment.get_security()._access_manager = self.access_manager
Environment.get_security().reset_access_manager()
self._tear_down()
Environment.get_security().set_admin(True)
test_env.delete()
Environment.get_security().set_admin(True)
sample3d_env.delete()
Site.pop_site()
def test_all(my):
'''entry point function'''
my.description = "Checkin unit test"
my.errors = []
Batch()
# FIXME: this is needed for the triggers to be registerd. These
# triggers have nothing to do with the web
from pyasm.web import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
Project.set_project("unittest")
try:
Command.execute_cmd(my)
# undo the command
undo = UndoCmd()
undo.execute()
finally:
test_env.delete()
def setUp(self):
# start batch environment
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.sample3d_env = Sample3dEnvironment(project_code='sample3d')
self.sample3d_env.create()
self.test_env = UnittestEnvironment()
self.test_env.create()
# set up the proper project_type, with the use the ProdDirNaming and ProdFileNaming
search = Search('sthpw/project')
search.add_filter('code', 'unittest')
self.sobj = search.get_sobject()
# store the original setting in your database
self.original_proj_type_dict = {'dir_naming_cls': self.sobj.get_value('dir_naming_cls'),
'file_naming_cls': self.sobj.get_value('file_naming_cls') }
#self.transaction = Transaction.get(create=True)
if self.sobj:
self.sobj.set_value('dir_naming_cls', 'pyasm.prod.biz.ProdDirNaming')
self.sobj.set_value('file_naming_cls', 'pyasm.prod.biz.ProdFileNaming')
self.sobj.commit()
else:
self.sobj = SearchType.create('sthpw/project_type')
self.sobj.set_value('dir_naming_cls', 'pyasm.prod.biz.ProdDirNaming')
self.sobj.set_value('file_naming_cls', 'pyasm.prod.biz.ProdFileNaming')
self.sobj.set_value('code', 'unittest')
self.sobj.commit()
def test_all(self):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
self._test_command()
self._test_trigger()
trigger_key = "triggers:cache"
Container.put(trigger_key, None)
try:
self._test_api_trigger()
self._test_insert_trigger()
# test copy project from template
self._test_copy_project()
# clear again for subsequent Client API test
trigger_key = "triggers:cache"
Container.put(trigger_key, None)
trigger_key2 = Trigger.KEY
Container.put(trigger_key2, None)
finally:
Project.set_project('unittest')
test_env.delete()
def test_all(my):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
my.transaction = Transaction.get(create=True)
try:
my.person = Person.create( "Unit", "Test",
"ComputerWorld", "Fake Unittest Person")
my.search_type = my.person.get_search_type()
my.search_id = my.person.get_id()
my.context = "test"
my.full_context = "test/subtest"
my._test_pipeline()
my._test_pipeline_connects()
my._test_schema()
my._test_snapshot()
my._test_level()
my._test_naming_util()
my._test_sobject_hierarchy()
my._test_add_tasks()
finally:
my.transaction.rollback()
Project.set_project('unittest')
test_env.delete()
def test_all(my):
test_env = UnittestEnvironment()
test_env.create()
try:
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
impl = sql.get_database_impl()
db_type = impl.get_database_type()
if db_type == "PostgreSQL":
my.prefix = '''"unittest"."public"'''
my.sthpw_prefix = '''"sthpw"."public"'''
else:
my.prefix = '''"unittest"'''
my.sthpw_prefix = '''"sthpw"'''
my._test_get_connect()
my._test_select_class()
my._test_insert_class()
my._test_update_class()
my._test_insert_and_delete()
my._test_create_table()
my._test_transaction()
my._test_order_by()
my._test_rpn_filters()
my._test_search_filter()
my._test_join()
my._test_add_drop_column()
finally:
test_env.delete()
def test_all(self):
'''entry point function'''
self.description = "Checkin unit test"
self.errors = []
Batch()
# FIXME: this is needed for the triggers to be registerd. These
# triggers have nothing to do with the web
from pyasm.web import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
self.transaction = Transaction.get(create=True)
Project.set_project("unittest")
try:
#Command.execute_cmd(self)
# undo the command
#undo = UndoCmd()
#undo.execute()
self.execute()
finally:
self.transaction.rollback()
test_env.delete()
def setUp(self):
# intialiaze the framework as a batch process
batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
def test_all(my):
Batch()
from pyasm.web.web_init import WebInit
test_env = UnittestEnvironment()
test_env.create()
try:
my._test_complete_trigger()
finally:
test_env.delete()
def test_all(self):
# start batch environment
Batch(login_code='admin')
test_env = UnittestEnvironment()
test_env.create()
Project.set_project('admin')
try:
self._test_csv_export()
finally:
test_env.delete()
def setUp(self):
# intitialize the framework as a batch process
self.batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
# remove any existing widget config entries left over
old_wdg_configs = Search.eval("@SOBJECT(config/widget_config)")
for item in old_wdg_configs:
item.delete()
def test_all(my):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
my.transaction = Transaction.get(create=True)
try:
my._test_multiple_schema()
finally:
my.transaction.rollback()
Project.set_project('unittest')
test_env.delete()
def setUp(self):
# intialiaze the framework as a batch process
batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
def test_all(my):
Batch()
from pyasm.web.web_init import WebInit
test_env = UnittestEnvironment()
test_env.create()
try:
my._test_complete_trigger()
finally:
test_env.delete()
search = Search("sthpw/pipeline")
search.add_filter("project_code", "unittest")
pipelines = search.get_sobjects()
for pipeline in pipelines:
pipeline.delete()
def test_all(my):
batch = Batch()
from pyasm.unittest import UnittestEnvironment, Sample3dEnvironment
test_env = UnittestEnvironment()
test_env.create()
sample3d_env = Sample3dEnvironment(project_code='sample3d')
sample3d_env.create()
Project.set_project("unittest")
try:
my._test_all()
finally:
#Project.set_project("unittest")
my._tear_down()
test_env.delete()
sample3d_env.delete()
def test_all(my):
test_env = UnittestEnvironment()
test_env.create()
try:
my._setup()
print
print
print
my._test_accept()
my._test_method()
my._test_custom_handler()
print
print
print
finally:
test_env.delete()
def test_all(self):
# intialiaze the framework as a batch process
batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
#from pyasm.biz import Project
#Project.set_project("unittest")
try:
self._test_transaction()
self._test_undo()
self._test_file_undo()
self._test_debug_log()
except:
Project.set_project('unittest')
self.test_env.delete()
def test_all(self):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
#TODO add the schema entry to the sample3d plugin first
#sample3d_test_env = Sample3dEnvironment()
#sample3d_test_env.create()
test_env = UnittestEnvironment()
test_env.create()
self.transaction = Transaction.get(create=True)
try:
self.person = Person.create( "Unit", "Test",
"ComputerWorld", "Fake Unittest Person")
self.search_type = self.person.get_search_type()
self.search_id = self.person.get_id()
self.search_code = self.person.get_value("code")
self.context = "test"
self.full_context = "test/subtest"
self._test_instances()
self._test_pipeline()
self._test_pipeline_connects()
self._test_schema()
self._test_snapshot()
self._test_level()
self._test_naming_util()
self._test_sobject_hierarchy()
self._test_add_tasks()
self._test_time()
finally:
self.transaction.rollback()
Project.set_project('unittest')
test_env.delete()
def test_all(my):
batch = Batch()
from pyasm.unittest import UnittestEnvironment, Sample3dEnvironment
test_env = UnittestEnvironment()
test_env.create()
sample3d_env = Sample3dEnvironment(project_code='sample3d')
sample3d_env.create()
Project.set_project("unittest")
try:
my.access_manager = Environment.get_security().get_access_manager()
my._test_all()
finally:
#Project.set_project("unittest")
Environment.get_security()._access_manager = my.access_manager
my._tear_down()
test_env.delete()
sample3d_env.delete()
def test_all(my):
'''entry point function'''
my.description = "Checkin unit test"
my.errors = []
Batch()
# FIXME: this is needed for the triggers to be registerd. These
# triggers have nothing to do with the web
from pyasm.web import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
Project.set_project("unittest")
try:
Command.execute_cmd(my)
# undo the command
undo = UndoCmd()
undo.execute()
finally:
test_env.delete()
def test_all(self):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
self._test_command()
self._test_trigger()
trigger_key = "triggers:cache"
Container.put(trigger_key, None)
try:
self._test_api_trigger()
self._test_insert_trigger()
# test copy project from template
self._test_copy_project()
# clear again for subsequent Client API test
trigger_key = "triggers:cache"
Container.put(trigger_key, None)
trigger_key2 = Trigger.KEY
Container.put(trigger_key2, None)
finally:
Project.set_project('unittest')
test_env.delete()
def test_all(self):
'''entry point function'''
self.description = "Checkin unit test"
self.errors = []
Batch()
# FIXME: this is needed for the triggers to be registerd. These
# triggers have nothing to do with the web
from pyasm.web import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
self.transaction = Transaction.get(create=True)
Project.set_project("unittest")
try:
#Command.execute_cmd(self)
# undo the command
#undo = UndoCmd()
#undo.execute()
self.execute()
finally:
self.transaction.rollback()
test_env.delete()
def test_all(my):
batch = Batch()
Environment.get_security().set_admin(True)
from pyasm.unittest import UnittestEnvironment, Sample3dEnvironment
test_env = UnittestEnvironment()
test_env.create()
sample3d_env = Sample3dEnvironment(project_code='sample3d')
sample3d_env.create()
Project.set_project("unittest")
try:
my.access_manager = Environment.get_security().get_access_manager()
my._test_all()
finally:
#Project.set_project("unittest")
Environment.get_security()._access_manager = my.access_manager
my._tear_down()
Environment.get_security().set_admin(True)
test_env.delete()
Environment.get_security().set_admin(True)
sample3d_env.delete()
Site.pop_site()
def test_all(self):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
self.transaction = Transaction.get(create=True)
Project.set_project('unittest')
try:
self.person = Person.create( "Unit", "Test",
"ComputerWorld", "Fake Unittest Person")
self._test_notification()
self.transaction = Transaction.get(create=True)
self._test_result()
finally:
self.transaction.rollback()
test_env.delete()
return
def test_all(self):
test_env = UnittestEnvironment()
test_env.create()
self.server = "http://localhost"
self.server = "http://192.168.205.180"
try:
self._setup()
print("")
print("")
print("")
self._test_accept()
self._test_method()
self._test_custom_handler()
print("")
print("")
print("")
finally:
#test_env.delete()
pass
def test_all(my):
Batch()
from pyasm.web.web_init import WebInit
test_env = UnittestEnvironment()
test_env.create()
try:
my._test_complete_trigger()
finally:
test_env.delete()
def test_all(self):
# start batch environment
Batch(login_code='admin')
test_env = UnittestEnvironment()
test_env.create()
Project.set_project('admin')
try:
self._test_csv_export()
finally:
test_env.delete()
def test_all(my):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
my.transaction = Transaction.get(create=True)
try:
my._test_multiple_schema()
finally:
my.transaction.rollback()
Project.set_project('unittest')
test_env.delete()
def test_all(self):
# intialiaze the framework as a batch process
batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
#from pyasm.biz import Project
#Project.set_project("unittest")
try:
self._test_transaction()
self._test_undo()
self._test_file_undo()
self._test_debug_log()
except:
Project.set_project('unittest')
self.test_env.delete()
def test_all(my):
test_env = UnittestEnvironment()
test_env.create()
try:
my._setup()
print
print
print
my._test_accept()
my._test_method()
my._test_custom_handler()
print
print
print
finally:
test_env.delete()
def test_all(my):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
#TODO add the schema entry to the sample3d plugin first
#sample3d_test_env = Sample3dEnvironment()
#sample3d_test_env.create()
test_env = UnittestEnvironment()
test_env.create()
my.transaction = Transaction.get(create=True)
try:
my.person = Person.create("Unit", "Test", "ComputerWorld",
"Fake Unittest Person")
my.search_type = my.person.get_search_type()
my.search_id = my.person.get_id()
my.search_code = my.person.get_value("code")
my.context = "test"
my.full_context = "test/subtest"
my._test_instances()
my._test_pipeline()
my._test_pipeline_connects()
my._test_schema()
my._test_snapshot()
my._test_level()
my._test_naming_util()
my._test_sobject_hierarchy()
my._test_add_tasks()
my._test_time()
finally:
my.transaction.rollback()
Project.set_project('unittest')
test_env.delete()
def test_all(my):
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
test_env = UnittestEnvironment()
test_env.create()
my.transaction = Transaction.get(create=True)
Project.set_project('unittest')
try:
my.person = Person.create("Unit", "Test", "ComputerWorld",
"Fake Unittest Person")
my._test_notification()
my.transaction = Transaction.get(create=True)
my._test_result()
finally:
my.transaction.rollback()
test_env.delete()
return
def test_all(self):
Batch()
from pyasm.web.web_init import WebInit
test_env = UnittestEnvironment()
test_env.create()
try:
self._test_complete_trigger()
finally:
test_env.delete()
search = Search("sthpw/pipeline")
search.add_filter("project_code", "unittest")
pipelines = search.get_sobjects()
for pipeline in pipelines:
pipeline.delete()
search = Search("sthpw/message")
search.add_filter("project_code", "unittest")
sobjects = search.get_sobjects()
for sobject in sobjects:
sobject.delete()
def test_all(self):
# start batch environment
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
sample3d_test_env = Sample3dEnvironment()
sample3d_test_env.create()
test_env = UnittestEnvironment()
test_env.create()
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
impl = sql.get_database_impl()
db_type = impl.get_database_type()
if db_type == "PostgreSQL":
self.prefix = '''"unittest"."public".'''
self.sthpw_prefix = '''"sthpw"."public".'''
elif db_type == "Sqlite":
self.prefix = ""
self.sthpw_prefix = ""
elif db_type == "SQLServer":
self.prefix = '''"unittest"."dbo".'''
self.sthpw_prefix = '''"sthpw"."dbo".'''
else:
self.prefix = '''"unittest".'''
self.sthpw_prefix = '''"sthpw".'''
self.transaction = Transaction.get(create=True)
try:
self.person = Person.create( "5", "a",
"ComputerWorld", "1")
self.person = Person.create( "4", "b",
"ComputerWorld", "3")
self.person = Person.create( "3", "c",
"ComputerWorld", "3")
self.person = Person.create( "2", "d",
"ComputerWorld", "4")
self.person = Person.create( "1", "e",
"ComputerWorld", "5")
self._test_no_id()
self._test_order_by()
self._test_search_key()
self._test_search()
self._test_multi_db_subselect()
# FIXME: this requires sample3d project
self._test_search_other_project()
self._test_search_type()
self._test_metadata()
self._test_search_type_existence()
self._test_project()
self._test_search_filter()
self._test_dates_search()
self._test_child_search()
self._test_parent_search()
self._test_add_column_search()
self._test_commit()
self._test_set_value()
self._test_search_set_value()
self._test_get_by_statement()
self._test_views()
finally:
self.transaction.rollback()
Project.set_project('unittest')
test_env.delete()
sample3d_test_env.delete()
class TransactionTest(unittest.TestCase):
def test_all(self):
# intialiaze the framework as a batch process
batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
#from pyasm.biz import Project
#Project.set_project("unittest")
try:
self._test_transaction()
self._test_undo()
self._test_file_undo()
self._test_debug_log()
except:
Project.set_project('unittest')
self.test_env.delete()
def _test_transaction(self):
# initiate a global transaction
database = "unittest"
count_sql = 'select count(*) from "person"'
transaction = Transaction.get(create=True)
# adding these 2 lines
project = Project.get_by_code(database)
db_resource = project.get_project_db_resource()
db = DbContainer.get(db_resource)
count0 = db.get_value(count_sql)
person = Person.create("Mr", "Dumpling", "Dumpling Land", "Burnt")
# check to see that one was added
count1 = db.get_value(count_sql)
self.assertEquals(count1, count0 + 1)
# FIXME: cant' delete for some reason
#person.delete()
# commit the first time
transaction.commit()
# check to see that one was added
count1 = db.get_value(count_sql)
self.assertEquals(count1, count0 + 1)
#transaction.rollback()
#person.delete()
last = TransactionLog.get_last()
last.undo()
# create another login
transaction = Transaction.get(create=True)
count0 = db.get_value(count_sql)
person = Person.create("Mr", "Dumpling", "Dumpling Land", "Burnt")
db = DbContainer.get(db_resource)
count2 = db.get_value(count_sql)
self.assertEquals(count2, count0 + 1)
transaction.rollback()
# check to see that one was removed/rolled back
count3 = db.get_value(count_sql)
self.assertEquals(count3, count0)
def _test_undo(self):
search = Search("sthpw/transaction_log")
search.add_filter("login", Environment.get_user_name())
num_transactions = search.get_count()
# delete all instances of PotatoHead
search = Search("unittest/person")
search.add_filter("name_last", "Potato Head")
people = search.do_search()
for person in people:
person.delete()
# initiate a global transaction
transaction = Transaction.get(create=True, force=True)
person = Person.create("Mr", "Potato Head", "PotatoLand",
"Pretty much looks like a potato")
person2 = Person.create("Mrs", "Potato Head", "PotatoLand",
"Pretty much looks like a potato")
person2.set_value("nationality", "PotatoCountry")
person2.commit()
transaction.commit()
search = Search("unittest/person")
search.add_filter("name_first", "Mr")
search.add_filter("name_last", "Potato Head")
person = search.get_sobject()
self.assertEquals(False, person == None)
search = Search("unittest/person")
search.add_filter("name_first", "Mr")
search.add_filter("name_last", "Potato Head")
rtn_person = search.get_sobject()
self.assertEquals(True, rtn_person != None)
# make sure we are no longer in transaction
self.assertEquals(False, transaction.is_in_transaction())
# check the transaction log
search = Search("sthpw/transaction_log")
search.add_filter("login", Environment.get_user_name())
num_transactions2 = search.get_count()
results = search.do_search()
self.assertEquals(num_transactions2, num_transactions + 1)
# get the last transaction and undo it
last = TransactionLog.get_last()
last.undo()
search = Search("unittest/person")
search.add_filter("name_first", "Mr")
search.add_filter("name_last", "Potato Head")
person = search.get_sobject()
self.assertEquals(True, person == None)
search = Search("unittest/person")
search.add_filter("name_first", "Mrs")
search.add_filter("name_last", "Potato Head")
person = search.get_sobject()
self.assertEquals(True, person == None)
def _test_file_undo(self):
tmpdir = Environment.get_tmp_dir()
dir = "%s/temp/unittest" % tmpdir
src = "%s/test_file_src" % tmpdir
src2 = "%s/test_file_src2" % tmpdir
dst = "%s/test_file_dst" % dir
dst2 = "%s/test_file_dst2" % dir
# make sure everything is clean
if os.path.exists(src):
os.unlink(src)
if os.path.exists(src2):
os.unlink(src2)
if os.path.exists(dst):
os.unlink(dst)
if os.path.exists(dst2):
os.unlink(dst2)
if os.path.exists(dir):
os.rmdir(dir)
# initiate a global transaction
transaction = Transaction.get(create=True)
# do some operations
FileUndo.mkdir(dir)
# create a file
file = open(src, "w")
file.write("whatever")
file.close()
# create a file
file = open(src2, "w")
file.write("whatever2")
file.close()
self.assertEquals(os.path.exists(src), True)
self.assertEquals(os.path.exists(src2), True)
FileUndo.move(src, dst)
FileUndo.copy(dst, dst2)
FileUndo.remove(src2)
transaction.commit()
self.assertEquals(True, os.path.exists(dir))
self.assertEquals(False, os.path.exists(src))
self.assertEquals(False, os.path.exists(src2))
self.assertEquals(True, os.path.exists(dst))
self.assertEquals(True, os.path.exists(dst2))
TransactionLog.get_last().undo()
self.assertEquals(False, os.path.exists(dir))
self.assertEquals(True, os.path.exists(src))
self.assertEquals(True, os.path.exists(src2))
self.assertEquals(False, os.path.exists(dst))
self.assertEquals(False, os.path.exists(dst2))
os.unlink(src)
os.unlink(src2)
def _test_debug_log(self):
'''tests that the debug log executes outside of a transaction'''
# initiate a global transaction
transaction = Transaction.get(create=True)
person = Person.create("Mr", "Potato Head", "PotatoLand",
"Pretty much looks like a potato")
person_id = person.get_id()
person_type = person.get_search_type()
from pyasm.biz import DebugLog
log = DebugLog.log("debug", "Unittest Debug In transaction")
log_id = log.get_id()
Person.clear_cache()
transaction.rollback()
person = Search.get_by_id(person_type, person_id)
#log = DebugLog.get_by_id(log_id)
# make sure the person is undone
self.assertEquals(None, person)
# make sure the log still exists
self.assertNotEquals(None, log)
class WidgetConfigTest(unittest.TestCase):
def setUp(self):
# intitialize the framework as a batch process
self.batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
# remove any existing widget config entries left over
old_wdg_configs = Search.eval("@SOBJECT(config/widget_config)")
for item in old_wdg_configs:
item.delete()
def test_all(self):
# set up some widget configs in the database
self.transaction = Transaction.get(create=True)
widget_config_type = 'config/widget_config'
def_config = '''
<config>
<definition>
<element name='test'>
<display class='SelectWdg'/>
</element>
</definition>
</config>
'''
config = '''
<config>
<test>
<element name='dan'/>
<element name='dan2'>
<display class='SelectWdg'/>
</element>
<element name='test'/>
<element name='test2'>
<display class='CheckboxWdg'/>
</element>
<element name='drop'/>
</test>
</config>
'''
edit_config = '''
<config>
<edit layout='EditWdg'>
<element name='asset_category'/>
<element name='code'>
<display class='EditLevelTextWdg'/>
</element>
<element name='drop'/>
</edit>
</config>
'''
edit_def_config = '''
<config>
<edit_definition>
<element name='asset_category'>
<display class='ProcessSelectWdg'/>
</element>
<element name='code'>
<display class='TextAreaWdg'/>
</element>
<element name='drop'>
<action class='DropElementAction'>
<path>path_test</path>
</action>
</element>
</edit_definition>
</config>
'''
ALL_def_config = '''
<config>
<definition>
<element name='dan'>
<display class='tactic.ui.table.ExpressionElementWdg'/>
</element>
</definition>
</config>
'''
try:
# add the ALL definition view
widget_config = SearchType.create(widget_config_type)
widget_config.set_value("search_type", "ALL")
widget_config.set_value("view", "definition")
widget_config.set_value("config", ALL_def_config)
widget_config.commit()
# add the definition view
widget_config = SearchType.create(widget_config_type)
widget_config.set_value("search_type", "unittest/person")
widget_config.set_value("view", "definition")
widget_config.set_value("config", def_config)
widget_config.commit()
# add the test view for person
widget_config = SearchType.create(widget_config_type)
widget_config.set_value("search_type", "unittest/person")
widget_config.set_value("view", "test")
widget_config.set_value("config", config)
widget_config.commit()
# add the test view for city
widget_config = SearchType.create(widget_config_type)
widget_config.set_value("search_type", "unittest/city")
widget_config.set_value("view", "test")
widget_config.set_value("config", config)
widget_config.commit()
# add the edit view
widget_config = SearchType.create(widget_config_type)
widget_config.set_value("search_type", "unittest/person")
widget_config.set_value("view", "edit")
widget_config.set_value("config", edit_config)
widget_config.commit()
# add the edit def view
widget_config = SearchType.create(widget_config_type)
widget_config.set_value("search_type", "unittest/person")
widget_config.set_value("view", "edit_definition")
widget_config.set_value("config", edit_def_config)
widget_config.commit()
self._test_get_display_handler()
self._test_get_action_handler()
finally:
self.transaction.rollback()
Project.set_project('unittest')
self.test_env.delete()
def _test_get_action_handler(self):
search_type = "unittest/person"
# get the definition directly
view = "edit"
config = WidgetConfigView.get_by_search_type(search_type, view)
action_handler = config.get_action_handler("drop")
self.assertEquals("DropElementAction", action_handler)
action_handler = config.get_action_handler("code")
self.assertEquals("", action_handler)
config = WidgetConfigView.get_by_search_type(search_type, 'test')
action_handler = config.get_action_handler("drop")
self.assertEquals("", action_handler)
# get_by_elemnet_names will get it
config = WidgetConfigView.get_by_element_names(search_type, ['drop'], 'test')
action_handler = config.get_action_handler("drop")
self.assertEquals("DropElementAction", action_handler)
options = config.get_action_options("drop")
self.assertEquals("path_test", options.get('path'))
def _test_get_display_handler(self):
search_type = "unittest/person"
# get the definition directly
view = "definition"
config = WidgetConfigView.get_by_search_type(search_type, view)
display_handler = config.get_display_handler("test")
self.assertEquals("SelectWdg", display_handler)
# use a non-existent view
view = "whatever"
config = WidgetConfigView.get_by_search_type(search_type, view)
display_handler = config.get_display_handler("test")
self.assertEquals("SelectWdg", display_handler)
# get element_names
#element_names = config.get_element_names()
#self.assertEquals(['test'], element_names)
# use an existing view
view = "test"
config = WidgetConfigView.get_by_search_type(search_type, view)
display_handler = config.get_display_handler("test")
self.assertEquals("SelectWdg", display_handler)
display_handler = config.get_display_handler("test2")
self.assertEquals("CheckboxWdg", display_handler)
display_handler = config.get_display_handler("dan")
self.assertEquals("tactic.ui.table.ExpressionElementWdg", display_handler)
city_config = WidgetConfigView.get_by_search_type('unittest/city', view)
display_handler = city_config.get_display_handler("dan")
self.assertEquals("tactic.ui.table.ExpressionElementWdg", display_handler)
display_handler = city_config.get_display_handler("dan2")
self.assertEquals("SelectWdg", display_handler)
# get element_names
element_names = config.get_element_names()
self.assertEquals(['dan','dan2','test','test2','drop'], element_names)
# get a non-existent view using local_search
view = "whatever"
config = WidgetConfigView.get_by_search_type(search_type, view, local_search=True, use_cache=False)
display_handler = config.get_display_handler("test")
self.assertEquals("SelectWdg", display_handler)
# check edit view
view = "edit"
config = WidgetConfigView.get_by_search_type(search_type, view)
display_handler = config.get_display_handler("code")
self.assertEquals("EditLevelTextWdg", display_handler)
display_handler = config.get_display_handler("asset_category")
self.assertEquals("ProcessSelectWdg", display_handler)
class SqlTest(unittest.TestCase):
def setUp(self):
# intialiaze the framework as a batch process
batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
def test_all(self):
try:
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
impl = sql.get_database_impl()
db_type = impl.get_database_type()
if db_type == "PostgreSQL":
self.prefix = '''"unittest"."public".'''
self.sthpw_prefix = '''"sthpw"."public".'''
elif db_type == "Sqlite":
self.prefix = ""
self.sthpw_prefix = ""
else:
self.prefix = '''"unittest".'''
self.sthpw_prefix = '''"sthpw".'''
self._test_get_connect()
self._test_select_class()
self._test_insert_class()
self._test_update_class()
self._test_insert_and_delete()
self._test_create_table()
self._test_transaction()
self._test_order_by()
self._test_rpn_filters()
self._test_search_filter()
self._test_join()
self._test_create_view()
# it doesn't allow dropping of a column
if db_type != 'Sqlite':
self._test_add_drop_column()
finally:
Project.set_project('unittest')
self.test_env.delete()
def _test_get_connect(self):
database = 'unittest'
project = Project.get_by_code(database)
db_resource = project.get_project_db_resource()
sql1 = DbContainer.get(db_resource)
sql2 = DbContainer.get(db_resource)
self.assertEquals(sql1, sql2)
def _test_select_class(self):
""" test a select """
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("person")
select.add_where("\"name_first\" = 'megumi'")
select.add_order_by("name_last")
statement = select.get_statement()
sql = DbContainer.get(db_res)
impl = sql.get_database_impl()
db_type = impl.get_database_type()
expected = '''SELECT %s"person".* FROM %s"person" WHERE "name_first" = 'megumi' ORDER BY "person"."name_last"''' % (
self.prefix, self.prefix)
self.assertEquals(expected, statement)
# test for doubling of apostrophe
select = Select()
select.set_database(db_res)
select.add_table("person")
select.add_filter('name_last', "john's", op='!=')
statement = select.get_statement()
expected = """SELECT %s"person".* FROM %s"person" WHERE "person"."name_last" != 'john''s'""" % (
self.prefix, self.prefix)
self.assertEquals(expected, statement)
def _test_insert_class(self):
"""test an insert"""
insert = Insert()
insert.set_table("person")
insert.set_value("name_first", "megumi")
insert.set_value("name_last", "takamori")
statement = insert.get_statement()
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
if sql.get_database_type() == "Oracle":
expected = "INSERT INTO \"person\" (\"id\", \"name_first\", \"name_last\") VALUES (\"person_id_seq\".nextval, 'megumi', 'takamori')"
elif sql.get_database_type() == "SQLServer":
expected = "INSERT INTO [person] (\"name_first\", \"name_last\") VALUES ('megumi', 'takamori')"
else:
expected = "INSERT INTO \"person\" (\"name_first\", \"name_last\") VALUES ('megumi', 'takamori')"
self.assertEquals(expected, statement)
def _test_update_class(self):
"""test an update"""
update = Update()
update.set_table("person")
update.set_value("name_first", "megumi")
update.add_where("\"person_id\" = '1'")
statement = update.get_statement()
expected = "UPDATE \"person\" SET \"name_first\" = 'megumi' WHERE \"person_id\" = '1'"
self.assertEqual(expected, statement)
def _test_insert_and_delete(self):
# ensure that we are *NOT* in a transaction
Transaction.clear_stack()
transaction = Transaction.get()
# comment out for now
#self.assertEquals( None, transaction )
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
self.assertEquals(False, sql.is_in_transaction())
count_sql = """select count(*) from "person"
where "name_first" = 'Bugs' and "name_last" = 'Bunny'"""
num_records = sql.get_int(count_sql)
self.assertEquals(0, num_records)
# test with no transaction
transaction = Transaction.get(create=True)
insert = Insert()
insert.set_table("person")
insert.set_value("name_first", "Bugs")
insert.set_value("name_last", "Bunny")
statement = insert.get_statement()
expected = '''INSERT INTO "person" ("name_first", "name_last") VALUES ('Bugs', 'Bunny')'''
self.assertEquals(expected, statement)
# with a db_res added, it should scope the database
insert = Insert()
insert.set_database(db_res)
insert.set_table("person")
insert.set_value("name_first", "Bugs")
insert.set_value("name_last", "Bunny")
statement = insert.get_statement()
expected = '''INSERT INTO %s"person" ("name_first", "name_last") VALUES ('Bugs', 'Bunny')''' % self.prefix
self.assertEquals(expected, statement)
sql.do_update(statement)
num_records = sql.get_int(count_sql)
self.assertEquals(1, num_records)
delete = """delete from "person"
where "name_first" = 'Bugs' and "name_last" = 'Bunny'"""
sql.do_update(delete)
num_records = sql.get_int(count_sql)
self.assertEquals(0, num_records)
transaction.rollback()
def _test_create_table(self):
create = CreateTable()
create.set_table("coffee")
create.add_column("id", "int4")
create.add_column("type", "varchar(10)")
create.add_column("login", "varchar(30)")
create.add_column("discussion", "text")
create.set_primary_key("id")
statement = create.get_statement()
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
if sql.get_database_type() == "Oracle":
expected = \
'''CREATE TABLE "coffee" (
"id" NUMBER,
"type" VARCHAR2(10),
"login" VARCHAR2(30),
"discussion" CLOB,
PRIMARY KEY ("id")
);'''
else:
expected = \
'''CREATE TABLE "coffee" (
"id" int4,
"type" varchar(10),
"login" varchar(30),
"discussion" text,
PRIMARY KEY ("id"));'''
statement = statement.replace("\n", "")
statement = statement.replace(" ", " ")
statement = statement.replace("\t", " ")
expected = expected.replace("\n", "")
statement = expected.replace(" ", " ")
statement = expected.replace("\t", " ")
self.assertEquals(expected, statement)
def _test_transaction(self):
"""test a transaction"""
database_type = Project.get_by_code("unittest").get_database_type()
if database_type == "MySQL":
print
print "WARNING: !!!!!!!"
print "_test_tranaction is disabled"
print "WARNING: !!!!!!!"
print
return
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
count_sql = 'select count(*) from "person"'
num_records = sql.get_int(count_sql)
# start the transaction, update and roll back
sql.start()
insert = Insert()
insert.set_table("person")
insert.set_value("name_first", "cow")
insert.set_value("name_last", "sql")
query = insert.get_statement()
sql.do_update(query)
new_num_records = sql.get_value(count_sql)
self.assertEquals(new_num_records, num_records + 1)
sql.rollback()
# dump after the rollback
new_num_records = sql.get_int(count_sql)
self.assertEqual(new_num_records, num_records)
def _test_order_by(self):
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("asset")
select.add_enum_order_by("code", ['cow', 'dog', 'horse'])
expected = '''SELECT %s"asset".* FROM %s"asset" ORDER BY ( CASE "code"
WHEN 'cow' THEN 1
WHEN 'dog' THEN 2
WHEN 'horse' THEN 3
ELSE 4 END )''' % (self.prefix, self.prefix)
statement = select.get_statement()
self.assertEqual(expected, statement)
def _test_rpn_filters(self):
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("asset")
select.add_where("begin")
select.add_where("\"code\" = 'chr001'")
select.add_where("\"code\" = 'chr002'")
select.add_where("\"code\" = 'chr003'")
select.add_where("or")
select.add_where("\"status\" = 'complete'")
select.add_where("and")
statement = select.get_statement()
expected = """SELECT %s"asset".* FROM %s"asset" WHERE ( "code" = 'chr001' OR "code" = 'chr002' OR "code" = 'chr003' ) AND "status" = 'complete'""" % (
self.prefix, self.prefix)
self.assertEquals(expected, statement)
# test some simple fringe cases
select = Select()
select.add_table("asset")
select.add_where("begin")
select.add_where("or")
select.add_where("\"status\" = 'complete'")
select.add_where("and")
statement = select.get_statement()
expected = """SELECT "asset".* FROM "asset" WHERE "status" = 'complete'"""
self.assertEquals(expected, statement)
# assumed begin
select = Select()
select.add_table("asset")
select.add_where("\"status\" = 'retired'")
select.add_where("\"code\" = 'chr001'")
select.add_where("\"code\" = 'chr002'")
select.add_where("or")
statement = select.get_statement()
expected = """SELECT "asset".* FROM "asset" WHERE "status" = 'retired' OR "code" = 'chr001' OR "code" = 'chr002'"""
self.assertEquals(expected, statement)
# add a more complex case
search = Select()
search.add_table("person")
search.add_where("begin")
search.add_where("begin")
search.add_filter("login", "joe")
search.add_filter("login", "mary")
search.add_where("and")
search.add_where("begin")
search.add_filter("attr", "tom")
search.add_filter("attr", "peter")
search.add_where("and")
search.add_where("or")
statement = search.get_statement()
expected = '''SELECT "person".* FROM "person" WHERE ( "person"."login" = 'joe' AND "person"."login" = 'mary' ) OR ( "person"."attr" = 'tom' AND "person"."attr" = 'peter' )'''
self.assertEquals(expected, statement)
# try to throw in an extra begin in the middle
project_code = "unittest"
filter_search_type = "unittest/city"
search_type = 'sthpw/sobject_list'
search = Search(search_type)
search.add_filter("project_code", project_code)
search.add_filter("search_type", filter_search_type)
search.add_op("begin")
values = ["chr001"]
columns = ['keywords']
for column in columns:
search.add_startswith_keyword_filter(column, values)
statement = search.get_statement()
expected = '''SELECT %s"sobject_list".* FROM %s"sobject_list" WHERE "sobject_list"."project_code" = 'unittest' AND "sobject_list"."search_type" = 'unittest/city' AND ( lower("sobject_list"."keywords") like lower('%% chr001%%') OR lower("sobject_list"."keywords") like lower('chr001%%') )''' % (
self.sthpw_prefix, self.sthpw_prefix)
self.assertEquals(expected, statement)
def _test_search_filter(self):
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("job")
select.add_column("request_id")
select.add_filter("code", "123MMS")
select2 = Select()
#db_res = DbResource.get_default('unittest')
select2.set_database(db_res)
select2.add_table("request")
select2.add_select_filter("id", select)
statement = select2.get_statement()
expected = '''SELECT %s"request".* FROM %s"request" WHERE "request"."id" in ( SELECT %s"job"."request_id" FROM %s"job" WHERE "job"."code" = '123MMS' )''' % (
self.prefix, self.prefix, self.prefix, self.prefix)
self.assertEquals(expected, statement)
select3 = Select()
select3.set_database(db_res)
select3.add_op("begin")
select3.add_table("request")
select3.add_select_filter("id", select)
statement = select3.get_statement()
expected = '''SELECT %s"request".* FROM %s"request" WHERE "request"."id" in ( SELECT %s"job"."request_id" FROM %s"job" WHERE "job"."code" = '123MMS' )''' % (
self.prefix, self.prefix, self.prefix, self.prefix)
self.assertEquals(expected, statement)
def _test_add_drop_column(self):
#Project.set_project('unittest')
from pyasm.command import ColumnAddCmd, ColumnDropCmd, Command
cmd = ColumnAddCmd('unittest/country', 'special_place', 'varchar(256)')
Command.execute_cmd(cmd)
search_type = 'unittest/country'
# clear cache
SearchType.clear_column_cache(search_type)
DatabaseImpl.clear_table_cache()
exists = SearchType.column_exists(search_type, 'special_place')
self.assertEquals(exists, True)
# now drop the column
cmd = ColumnDropCmd(search_type, 'special_place')
Command.execute_cmd(cmd)
# clear cache
SearchType.clear_column_cache(search_type)
cache_dict = Container.get("DatabaseImpl:column_info")
# assume database is the same as sthpw
database_type = Project.get_by_code("unittest").get_database_type()
db_resource = DbResource.get_default('unittest')
table_info = cache_dict.get("%s:%s" % (db_resource, "country"))
self.assertEquals(table_info == None, True)
key = "%s:%s" % (db_resource, "country")
cache_dict[key] = None
exists = SearchType.column_exists(search_type, 'special_place')
self.assertEquals(exists, False)
def _test_join(self):
""" test a select """
Project.set_project('unittest')
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("person")
select.add_join('person', 'city', 'city_code', 'code')
select.add_join('city', 'country', 'country_code', 'code')
select.add_order_by("name_last")
statement = select.get_statement()
self.assertEquals(
statement,
'''SELECT %s"person".* FROM %s"person" LEFT OUTER JOIN %s"city" ON "person"."city_code" = "city"."code" LEFT OUTER JOIN %s"country" ON "city"."country_code" = "country"."code" ORDER BY "person"."name_last"'''
% (self.prefix, self.prefix, self.prefix, self.prefix))
search = Search('unittest/person')
search.add_join('unittest/city', 'unittest/person')
statement = search.get_statement()
self.assertEquals(
statement,
'''SELECT %s"person".* FROM %s"person" LEFT OUTER JOIN %s"city" ON "person"."city_code" = "city"."code"'''
% (self.prefix, self.prefix, self.prefix))
statement = search.get_statement()
# this one has no schema connection, so will be ignored
search.add_join('sthpw/login', 'unittest/person')
self.assertEquals(
statement,
'''SELECT %s"person".* FROM %s"person" LEFT OUTER JOIN %s"city" ON "person"."city_code" = "city"."code"'''
% (self.prefix, self.prefix, self.prefix))
search.add_join('unittest/country', 'unittest/city')
statement = search.get_statement()
self.assertEquals(
statement,
'''SELECT %s"person".* FROM %s"person" LEFT OUTER JOIN %s"city" ON "person"."city_code" = "city"."code" LEFT OUTER JOIN %s"country" ON "city"."country_code" = "country"."code"'''
% (self.prefix, self.prefix, self.prefix, self.prefix))
def _test_create_view(self):
from sql import CreateView
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
car_columns = sql.get_columns("car")
sports_columns = sql.get_columns("sports_car_data")
search = Search("unittest/car")
search.add_join("unittest/sports_car_data")
search.add_column("*", table="car")
for sports_column in sports_columns:
if sports_column not in car_columns:
search.add_column(sports_column, table="sports_car_data")
create_view = CreateView(search=search)
create_view.set_view("sports_car")
statement = create_view.get_statement()
expected = '''CREATE VIEW "sports_car" AS SELECT "unittest"."public"."car".*, "unittest"."public"."sports_car_data"."acceleration", "unittest"."public"."sports_car_data"."horsepower", "unittest"."public"."sports_car_data"."top_speed" FROM "unittest"."public"."car" LEFT OUTER JOIN "unittest"."public"."sports_car_data" ON "car"."code" = "sports_car_data"."code"'''
self.assertEquals(expected, statement)
class NamingTest(unittest.TestCase):
def setUp(self):
# start batch environment
Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.sample3d_env = Sample3dEnvironment(project_code='sample3d')
self.sample3d_env.create()
self.test_env = UnittestEnvironment()
self.test_env.create()
# set up the proper project_type, with the use the ProdDirNaming and ProdFileNaming
search = Search('sthpw/project')
search.add_filter('code', 'unittest')
self.sobj = search.get_sobject()
# store the original setting in your database
self.original_proj_type_dict = {'dir_naming_cls': self.sobj.get_value('dir_naming_cls'),
'file_naming_cls': self.sobj.get_value('file_naming_cls') }
#self.transaction = Transaction.get(create=True)
if self.sobj:
self.sobj.set_value('dir_naming_cls', 'pyasm.prod.biz.ProdDirNaming')
self.sobj.set_value('file_naming_cls', 'pyasm.prod.biz.ProdFileNaming')
self.sobj.commit()
else:
self.sobj = SearchType.create('sthpw/project_type')
self.sobj.set_value('dir_naming_cls', 'pyasm.prod.biz.ProdDirNaming')
self.sobj.set_value('file_naming_cls', 'pyasm.prod.biz.ProdFileNaming')
self.sobj.set_value('code', 'unittest')
self.sobj.commit()
def create_snapshot(self):
# set up a real person and snapshot (as opposed to virtual)
code = 'phil'
self.person = SearchType.create( 'unittest/person' )
self.person.set_value("code",code)
self.person.set_value("name_first", "Philip")
self.person.commit()
# create a new test.txt file
file_path = "./naming_test.txt"
for i in range(0,4):
file = open(file_path, 'w')
file.write("whatever")
file.close()
checkin = FileCheckin(self.person, file_path, "main", context='naming_test')
checkin.execute()
self.snapshot = checkin.get_snapshot()
# create another test_base.txt file
file_path = "./naming_base_test.txt"
for i in range(0,4):
file = open(file_path, 'w')
file.write("whatever")
file.close()
checkin = FileCheckin(self.person, file_path, "main", context='naming_base_test')
checkin.execute()
self.base_snapshot = checkin.get_snapshot()
dir_path = "./naming_test_folder"
dir_path2 = "./.tactic_test" # test . folder
dir_path3 = "./naming_test_folder3"
dir_path4 = "./naming_test_folder4"
for path in [dir_path, dir_path2, dir_path3, dir_path4]:
if not os.path.exists(path):
os.makedirs(path)
checkin = FileCheckin(self.person, dir_path, "main", context='naming_base_test', checkin_type='auto')
checkin.execute()
self.auto_snapshot = checkin.get_snapshot()
checkin = FileCheckin(self.person, dir_path2, "main", context='naming_folder_test', snapshot_type='directory', checkin_type='auto')
checkin.execute()
self.auto_snapshot2 = checkin.get_snapshot()
# test a blank checkin_type
checkin = FileCheckin(self.person, dir_path3, "main", context='naming_base_test', snapshot_type='directory', checkin_type='')
checkin.execute()
self.auto_snapshot3 = checkin.get_snapshot()
def test_all(self):
self.transaction = Transaction.get(create=True)
try:
self.create_snapshot()
self._test_base_alias()
self._test_file_naming()
self._test_file_naming_base()
self._test_dir_naming()
# this comes after test_dir_naming so the file_object doesn't get polluted
self._test_file_naming_manual_version()
self._test_get_naming()
self._test_checkin_type()
self._test_naming_util()
finally:
self.transaction.rollback()
Project.set_project('unittest')
self.test_env.delete()
self.sample3d_env.delete()
# reset the unittest project type to whatever it was
"""
for key, value in self.original_proj_type_dict.items():
self.sobj.set_value(key, value)
self.sobj.commit()
"""
def _test_base_alias(self):
plugin_dir = Environment.get_web_dir(alias="plugins")
self.assertEquals("/plugins", plugin_dir)
plugin_dir = Environment.get_plugin_dir()
plugin_dir2 = Environment.get_asset_dir(alias="plugins")
self.assertEquals(plugin_dir, plugin_dir2)
def clear_naming(self):
Container.put("Naming:cache", None)
Container.put("Naming:cache:latest", None)
Container.put("Naming:cache:unittest:latest", None)
Container.put("Naming:cache:current", None)
Container.put("Naming:cache:unittest:current", None)
Container.put("Naming:cache:unittest", None)
Container.put("Naming:namings", None)
def _test_naming_util(self):
#self.clear_naming()
naming_util = NamingUtil()
# these should evaluate to be the same
file_naming_expr1 = ['{$PROJECT}__{context[0]}__hi_{$BASEFILE}.{$EXT}','{project.code}__{context[0]}__hi_{basefile}.{ext}']
dir_naming_expr2 = ['{$PROJECT}/{context[1]}/somedir/{@GET(.name_first)}','{project.code}/{snapshot.context[1]}/somedir/{sobject.name_first}']
process= 'light'
context = 'light/special'
type = 'ma'
version = 2
virtual_snapshot = Snapshot.create_new()
virtual_snapshot_xml = '<snapshot process=\'%s\'><file type=\'%s\'/></snapshot>' % (process, type)
virtual_snapshot.set_value("snapshot", virtual_snapshot_xml)
virtual_snapshot.set_value("process", process)
virtual_snapshot.set_value("context", context)
virtual_snapshot.set_value("snapshot_type", 'file')
virtual_snapshot.set_sobject(self.person)
virtual_snapshot.set_value("version", version)
file_name = "abc.txt"
file_obj = File(File.SEARCH_TYPE)
file_obj.set_value("file_name", file_name)
for naming_expr in file_naming_expr1:
file_name = naming_util.naming_to_file(naming_expr, self.person, virtual_snapshot, file=file_obj, file_type="main")
self.assertEquals(file_name,'unittest__light__hi_abc.txt')
for naming_expr in dir_naming_expr2:
dir_name = naming_util.naming_to_dir(naming_expr, self.person, virtual_snapshot, file=file_obj, file_type="main")
self.assertEquals(dir_name,'unittest/special/somedir/Philip')
def _test_file_naming_manual_version(self):
self.clear_naming()
naming = SearchType.create('config/naming')
naming.set_value('search_type','unittest/person')
naming.set_value('context', 'naming_test')
naming.set_value('dir_naming', '{project.code}/cut/{sobject.code}')
naming.set_value('file_naming', '{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
from pyasm.common import Environment
base_dir = Environment.get_asset_dir()
preallocated = self.snapshot.get_preallocated_path(file_type='maya', file_name='what_v005.ma',ext='ma')
self.assertEquals('%s/unittest/cut/phil/phil_v001.ma'%base_dir, preallocated)
# now turn on manual_version
naming.set_value('manual_version', True)
naming.commit()
self.clear_naming()
preallocated = self.snapshot.get_preallocated_path(file_type='maya', file_name='what_v005.ma',ext='ma')
self.assertEquals('%s/unittest/cut/phil/phil_v005.ma'%base_dir, preallocated)
# Uppercase V and more digits
preallocated = self.snapshot.get_preallocated_path(file_type='maya', file_name='what_V0010.ma',ext='ma')
self.assertEquals('%s/unittest/cut/phil/phil_v010.ma'%base_dir, preallocated)
#self.snapshot.commit()
# zero or negative version is ignored
# create a new manual version test.txt file
file_path = "./naming_v0000_test.txt"
for i in range(0,4):
file = open(file_path, 'w')
file.write("whatever")
file.close()
checkin = FileCheckin(self.person, file_path, "main", context='naming_test')
checkin.execute()
self.snapshot = checkin.get_snapshot()
self.assertEquals(11, self.snapshot.get_version())
# zero or negative version is ignored
# create a new manual version test.txt file
file_path = "./naming_v-23_test.txt"
for i in range(0,4):
file = open(file_path, 'w')
file.write("whatever")
file.close()
checkin = FileCheckin(self.person, file_path, "main", context='naming_test')
checkin.execute()
self.snapshot = checkin.get_snapshot()
self.assertEquals(12, self.snapshot.get_version())
file_path = "./naming_v025_test.txt"
for i in range(0,4):
file = open(file_path, 'w')
file.write("whatever")
file.close()
checkin = FileCheckin(self.person, file_path, "main", context='naming_test')
checkin.execute()
self.snapshot = checkin.get_snapshot()
self.assertEquals(25, self.snapshot.get_version())
naming.delete()
self.clear_naming()
def _test_file_naming_base(self):
naming = SearchType.create('config/naming')
naming.set_value('search_type','unittest/person')
naming.set_value('context', 'naming_base_test')
naming.set_value('dir_naming', '{project.code}/cut/{sobject.code}')
naming.set_value('file_naming', '{sobject.code}_v{snapshot.version}_{basefile}.{ext}')
naming.commit()
self.clear_naming()
# auto_snapshot is at v2
preallocated = self.auto_snapshot.get_preallocated_path(file_type='some_dir', file_name='racoon',ext=None)
from pyasm.common import Environment
base_dir = Environment.get_asset_dir()
self.assertEquals('%s/unittest/cut/phil/phil_v002_racoon'%base_dir, preallocated)
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon',ext=None)
self.assertEquals('%s/unittest/cut/phil/phil_v001_racoon'%base_dir, preallocated)
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon.jpg',ext='jpg')
self.assertEquals('%s/unittest/cut/phil/phil_v001_racoon.jpg'%base_dir, preallocated)
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon2.PNG')
self.assertEquals('%s/unittest/cut/phil/phil_v001_racoon2.PNG'%base_dir, preallocated)
# test file expression
naming.set_value('file_naming', '{@GET(.code)}_v{@GET(snapshot.version)}_{$BASEFILE}.{$EXT}')
naming.commit()
self.clear_naming()
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon3.jpg',ext='jpg')
self.assertEquals('%s/unittest/cut/phil/phil_v1_racoon3.jpg'%base_dir, preallocated)
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon4.PNG')
self.assertEquals('%s/unittest/cut/phil/phil_v1_racoon4.PNG'%base_dir, preallocated)
# test dir expression
naming.set_value('dir_naming', '{$PROJECT}/exp_cut/{@GET(.code)}')
naming.commit()
self.clear_naming()
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon same.iff',ext='iff')
self.assertEquals('%s/unittest/exp_cut/phil/phil_v1_racoon same.iff'%base_dir, preallocated)
# file name clean-up is disabled in 4.2: the actual check-in logic would not replace " " with "_"
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon 5.PNG')
self.assertEquals('%s/unittest/exp_cut/phil/phil_v1_racoon 5.PNG'%base_dir, preallocated)
# this one does not need clean-up
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon_5.PNG')
self.assertEquals('%s/unittest/exp_cut/phil/phil_v1_racoon_5.PNG'%base_dir, preallocated)
# test dir expression 2
naming.set_value('dir_naming', '{$PROJECT}/3D/QC/ShotWork/playblast/ByDate/{$TODAY,|([^\s]+)| }/{@GET(.name_first)}')
naming.commit()
self.clear_naming()
preallocated = self.base_snapshot.get_preallocated_path(file_type='pic', file_name='racoon same.iff',ext='iff')
today = datetime.datetime.today()
today = datetime.datetime(today.year, today.month, today.day)
today = today.strftime("%Y-%m-%d")
self.assertEquals('%s/unittest/3D/QC/ShotWork/playblast/ByDate/%s/Philip/phil_v1_racoon same.iff'%(base_dir, today), preallocated)
naming.delete()
self.clear_naming()
def _test_file_naming(self):
process = 'model'
type = 'main'
context = 'modeling'
version = 10
file_name = 'testing_image.jpg'
code = name = 'vehicle001'
asset_library = 'vehicle'
asset = SearchType.create( Asset.SEARCH_TYPE )
asset.set_value("code",code)
asset.set_value("name",name)
asset.set_value("asset_library",asset_library)
asset.set_value("asset_type","asset")
virtual_snapshot = Snapshot.create_new()
virtual_snapshot_xml = '<snapshot process=\'%s\'><file type=\'%s\'/></snapshot>' % (process, type)
virtual_snapshot.set_value("snapshot", virtual_snapshot_xml)
virtual_snapshot.set_value("context", context)
virtual_snapshot.set_value("version", version)
virtual_snapshot.set_sobject(asset)
file_obj = File(File.SEARCH_TYPE)
file_obj.set_value("file_name", file_name)
file_naming = Project.get_file_naming()
file_naming.set_sobject(asset)
file_naming.set_snapshot(virtual_snapshot)
file_naming.set_file_object(file_obj)
expected_file_name = 'vehicle001_%s_v%0.3d.jpg' %(context,version)
file_name = file_naming.get_file_name()
self.assertEquals(expected_file_name, file_name)
# try a default directory name
file_obj.set_value("file_name", "test_dir")
file_obj.set_value("base_type", "directory")
file_naming.set_file_object(file_obj)
# this should adopt the original dir name in the prefix
expected_file_name = 'test_dir_%s_v%0.3d' %(context,version)
file_name = file_naming.get_default()
self.assertEquals(expected_file_name, file_name)
#2 try a different search_type unittest/person
version = 9
file_obj.set_value("base_type", "file")
# change a different input file name
file_obj.set_value('file_name','some_maya_model.ma')
# use a real snapshot
virtual_snapshot.set_sobject(self.person)
virtual_snapshot.set_value("version", version)
# change to the test file naming class
self.sobj.set_value('file_naming_cls', 'pyasm.biz.naming_test.TestFileNaming')
self.sobj.commit()
Project.set_project('unittest')
file_naming = Project.get_file_naming()
file_naming.set_sobject(self.person)
file_naming.set_snapshot(virtual_snapshot)
file_naming.set_file_object(file_obj)
file_name = file_naming.get_file_name()
expected_file_name = 'phil_main_v009.ma'
self.assertEquals(expected_file_name, file_name)
# get_preallocated_path
type = 'ma'
#file_obj.set_value('type', type)
#file_naming.set_file_object(file_obj)
preallocated = self.snapshot.get_preallocated_path(file_type='maya', file_name='what.ma',ext='ma')
preallocated_file_name = os.path.basename(preallocated)
self.assertEquals("phil_main_v001.ma", preallocated_file_name)
preallocated = self.snapshot.get_preallocated_path(file_type='houdini', file_name='what.otl',ext='otl')
preallocated_file_name = os.path.basename(preallocated)
self.assertEquals("phil_main_v001.otl", preallocated_file_name)
preallocated = self.snapshot.get_preallocated_path(file_type='houdini', file_name='what_is.otl', ext='hipnc')
preallocated_file_name = os.path.basename(preallocated)
self.assertEquals("phil_main_v001.hipnc", preallocated_file_name)
# try an empty file naming
# change to the test file naming class
self.sobj.set_value('file_naming_cls', 'pyasm.biz.naming_test.TestFileNaming2')
self.sobj.commit()
Project.set_project('unittest')
file_naming = Project.get_file_naming()
file_naming.set_sobject(self.person)
file_naming.set_snapshot(virtual_snapshot)
file_naming.set_file_object(file_obj)
file_name = file_naming.get_file_name()
preallocated = self.snapshot.get_preallocated_path(file_type='houdini', file_name='what_is.otl', ext='hipnc')
if not os.path.exists(preallocated):
os.makedirs(preallocated)
from client.tactic_client_lib import TacticServerStub
client = TacticServerStub.get()
if os.path.isdir(preallocated):
rtn = client.add_directory(self.snapshot.get_code(), preallocated, 'houdini', mode='preallocate')
else:
rtn = client.add_file(self.snapshot.get_code(), preallocated, 'houdini', mode='preallocate')
rtn = client.get_snapshot(SearchKey.get_by_sobject(self.snapshot.get_parent()), context = 'naming_test', version = 1, include_files=True)
files = rtn.get('__files__')
# assuming the file is ordered by code
# the 1st file obj is a file and 2nd file obj is a directory
for idx, file in enumerate(files):
if idx ==0:
self.assertEquals(file.get('type'), 'main')
self.assertEquals(file.get('base_type'), 'file')
self.assertEquals(file.get('file_name'), 'naming_test_naming_test_v001.txt')
elif idx ==1:
self.assertEquals(file.get('type'), 'houdini')
self.assertEquals(file.get('base_type'), 'directory')
self.assertEquals(file.get('md5'), '')
self.assertEquals(file.get('file_name'), '')
def _test_dir_naming(self):
# change to the test dir naming class
self.sobj.set_value('dir_naming_cls', 'pyasm.biz.naming_test.TestDirNaming')
self.sobj.commit()
# 1. try a different search_type unittest/person
version = 9
code = 'phil2'
process = 'model'
type = 'main'
context = 'modeling'
asset = SearchType.create( 'unittest/person' )
asset.set_value("code",code)
asset.set_value("name_first", "Philip")
asset.commit()
# change a different input file name
file_obj = File(File.SEARCH_TYPE)
# due to new restriction of set_sobject_value().. we can't use it any more
#file_obj.set_sobject_value(asset)
sk = SearchKey.get_by_sobject(asset, use_id =True)
st = SearchKey.extract_search_type(sk)
sid = SearchKey.extract_id(sk)
file_obj.set_value('search_type', st)
file_obj.set_value('search_id', sid)
file_obj.set_value('file_name','some_maya_model.mb')
file_obj.set_value('type', type)
file_obj.set_value('base_type', 'file')
file_obj.commit()
virtual_snapshot = Snapshot.create_new()
virtual_snapshot_xml = '<snapshot process=\'%s\'><file type=\'%s\' file_code=\'%s\'/></snapshot>' % (process, type, file_obj.get_code())
virtual_snapshot.set_value("snapshot", virtual_snapshot_xml)
virtual_snapshot.set_value("context", context)
virtual_snapshot.set_sobject(asset)
virtual_snapshot.set_value("version", version)
Project.set_project('unittest')
dir_naming = Project.get_dir_naming()
dir_naming.set_sobject(asset)
dir_naming.set_snapshot(virtual_snapshot)
dir_naming.set_file_object(file_obj)
dir_name = dir_naming.get_dir()
expected_dir_name = '/assets/phil2/mb.main/v009'
expected_dir_name2 = '/phil2/mb.main/v009'
self.assertEquals(expected_dir_name, dir_name)
lib_paths = virtual_snapshot.get_all_lib_paths()
sand_paths = virtual_snapshot.get_all_lib_paths(mode='sandbox')
client_paths = virtual_snapshot.get_all_lib_paths(mode='client_repo')
base_dir = Config.get_value("checkin", "asset_base_dir", sub_key='default')
sand_base_dir = dir_naming.get_base_dir(protocol='sandbox')
client_base_dir = dir_naming.get_base_dir(protocol='client_repo')
self.assertEquals(lib_paths[0].startswith('%s%s'%(base_dir, expected_dir_name2)), True)
self.assertEquals(sand_paths[0].startswith('%s%s'%(sand_base_dir[0], expected_dir_name2)), True)
self.assertEquals(client_paths[0].startswith('%s%s'%(client_base_dir[0], expected_dir_name2)), True)
# 2 get_preallocated_path
# set version 1 here since it's the first snapshot for this sobject.
# without a virtual file_object, the file_name is empty, and so the dir ma.maya is now .maya
self.assertEquals("phil/.maya/v001", self.get_preallocated_dir())
# switch back to regular file naming
self.sobj.set_value('file_naming_cls', 'pyasm.biz.naming_test.TestFileNaming')
self.sobj.commit()
self.assertEquals("phil/ma.maya/v001", self.get_preallocated_dir())
def get_preallocated_dir(self):
preallocated = self.snapshot.get_preallocated_path(file_type='maya', file_name='what.ma',ext='ma')
preallocated_dir_name = os.path.dirname(preallocated)
preallocated_dir_name = preallocated_dir_name.replace('%s/' %Environment.get_asset_dir(), '')
# remove the base part
preallocated_dir_names = preallocated_dir_name.split('/')
preallocated_dir_name = '/'.join(preallocated_dir_names)
return preallocated_dir_name
def _test_get_naming(self):
# versionless
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/person')
naming.set_value('context', 'super')
naming.set_value('latest_versionless', 'true')
naming.set_value('dir_naming', '{project.code}/cut/VERSIONLESS/{sobject.code}')
naming.set_value('file_naming', 'versionless_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
# a context-less versionless entry for city
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/city')
naming.set_value('latest_versionless', 'true')
#naming.set_value('context', 'ingest')
naming.set_value('dir_naming', '{project.code}/cut/{snapshot.context}/VERSIONLESS/{sobject.code}')
naming.set_value('file_naming', 'versionless_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/city')
naming.set_value('dir_naming', '{project.code}/cut/{snapshot.context}/DEFAULT_CONTEXTLESS/{sobject.code}')
naming.set_value('file_naming', 'versionless_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/city')
naming.set_value('context', 'ingest')
naming.set_value('dir_naming', '{project.code}/cut/{snapshot.context}/DEFAULT/{sobject.code}')
naming.set_value('file_naming', 'versionless_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/person')
naming.set_value('context', 'icon')
naming.set_value('dir_naming', '{project.code}/cut/ICON/{sobject.code}')
naming.set_value('file_naming', 'icon_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
# use condition
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/person')
naming.set_value('context', 'icon')
naming.set_value('condition', "@GET(.name_first)=='chip'")
naming.set_value('dir_naming', '{project.code}/cut/chip_ICON/{sobject.code}')
naming.set_value('file_naming', 'chip_icon_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
# generic with search_type, snapshot_type
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/person')
naming.set_value('snapshot_type', 'file')
naming.set_value('dir_naming', '{project.code}/cut/generic_snapshot/{sobject.code}')
naming.set_value('file_naming', 'generic_snapshot_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
# generic with nothing
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/person')
naming.set_value('context', '')
naming.set_value('checkin_type', 'auto')
naming.set_value('dir_naming', '{project.code}/cut/generic/{sobject.code}')
naming.set_value('file_naming', 'generic_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
# generic with nothing
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/person')
naming.set_value('context', 'naming_base_test')
naming.set_value('dir_naming', '{project.code}/cut/generic/{sobject.code}')
naming.set_value('file_naming', 'generic_{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
naming = SearchType.create('config/naming')
naming.set_value('search_type', 'unittest/person')
naming.set_value('context', 'light')
naming.set_value('dir_naming', '{project.code}/cut/{sobject.code}')
naming.set_value('file_naming', '{sobject.code}_v{snapshot.version}.{ext}')
naming.commit()
naming2 = SearchType.create('config/naming')
naming2.set_value('search_type', 'unittest/person')
naming2.set_value('context', '*/light')
naming2.set_value('dir_naming', '{project.code}/cut')
naming2.commit()
naming3 = SearchType.create('config/naming')
naming3.set_value('search_type', 'unittest/person')
naming3.set_value('context', 'light/*')
naming3.set_value('dir_naming', '{project.code}/light')
naming3.commit()
naming4 = SearchType.create('config/naming')
naming4.set_value('search_type', 'unittest/person')
naming4.set_value('context', '*/sub1')
naming4.set_value('dir_naming', '{project.code}/sub')
naming4.commit()
naming5 = SearchType.create('config/naming')
naming5.set_value('search_type', 'unittest/person')
naming5.set_value('context', 'light/sub1')
naming5.set_value('dir_naming', '{project.code}/light/sub1')
naming5.commit()
sobject = SearchType.create('unittest/person')
sobject.set_value('name_first', 'chip')
sobject.commit()
naming6 = SearchType.create('config/naming')
naming6.set_value('sandbox_dir_naming', '{$PROJECT}/{@GET(.id)}/')
try:
naming6.commit()
except TacticException, e:
message = 'sandbox_dir_name should not end with /'
else:
class TransactionTest(unittest.TestCase):
def test_all(self):
# intialiaze the framework as a batch process
batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
#from pyasm.biz import Project
#Project.set_project("unittest")
try:
self._test_transaction()
self._test_undo()
self._test_file_undo()
self._test_debug_log()
except:
Project.set_project('unittest')
self.test_env.delete()
def _test_transaction(self):
# initiate a global transaction
database = "unittest"
count_sql = 'select count(*) from "person"'
transaction = Transaction.get(create=True)
# adding these 2 lines
project = Project.get_by_code(database)
db_resource= project.get_project_db_resource()
db = DbContainer.get(db_resource)
count0 = db.get_value(count_sql)
person = Person.create("Mr", "Dumpling", "Dumpling Land", "Burnt")
# check to see that one was added
count1 = db.get_value(count_sql)
self.assertEquals( count1, count0+1)
# FIXME: cant' delete for some reason
#person.delete()
# commit the first time
transaction.commit()
# check to see that one was added
count1 = db.get_value(count_sql)
self.assertEquals( count1, count0+1)
#transaction.rollback()
#person.delete()
last = TransactionLog.get_last()
last.undo()
# create another login
transaction = Transaction.get(create=True)
count0 = db.get_value(count_sql)
person = Person.create("Mr", "Dumpling", "Dumpling Land", "Burnt")
db = DbContainer.get(db_resource)
count2 = db.get_value(count_sql)
self.assertEquals( count2, count0+1)
transaction.rollback()
# check to see that one was removed/rolled back
count3 = db.get_value(count_sql)
self.assertEquals( count3, count0)
def _test_undo(self):
search = Search("sthpw/transaction_log")
search.add_filter("login", Environment.get_user_name() )
num_transactions = search.get_count()
# delete all instances of PotatoHead
search = Search("unittest/person")
search.add_filter("name_last", "Potato Head")
people = search.do_search()
for person in people:
person.delete()
# initiate a global transaction
transaction = Transaction.get(create=True, force=True)
person = Person.create("Mr", "Potato Head", "PotatoLand", "Pretty much looks like a potato")
person2 = Person.create("Mrs", "Potato Head", "PotatoLand", "Pretty much looks like a potato")
person2.set_value("nationality", "PotatoCountry")
person2.commit()
transaction.commit()
search = Search("unittest/person")
search.add_filter("name_first", "Mr")
search.add_filter("name_last", "Potato Head")
person = search.get_sobject()
self.assertEquals( False, person == None )
search = Search("unittest/person")
search.add_filter("name_first", "Mr")
search.add_filter("name_last", "Potato Head")
rtn_person = search.get_sobject()
self.assertEquals( True, rtn_person != None )
# make sure we are no longer in transaction
self.assertEquals( False, transaction.is_in_transaction() )
# check the transaction log
search = Search("sthpw/transaction_log")
search.add_filter("login", Environment.get_user_name() )
num_transactions2 = search.get_count()
results = search.do_search()
self.assertEquals( num_transactions2, num_transactions + 1 )
# get the last transaction and undo it
last = TransactionLog.get_last()
last.undo()
search = Search("unittest/person")
search.add_filter("name_first", "Mr")
search.add_filter("name_last", "Potato Head")
person = search.get_sobject()
self.assertEquals( True, person == None )
search = Search("unittest/person")
search.add_filter("name_first", "Mrs")
search.add_filter("name_last", "Potato Head")
person = search.get_sobject()
self.assertEquals( True, person == None )
def _test_file_undo(self):
tmpdir = Environment.get_tmp_dir()
dir = "%s/temp/unittest" % tmpdir
src = "%s/test_file_src" % tmpdir
src2 = "%s/test_file_src2" % tmpdir
dst = "%s/test_file_dst" % dir
dst2 = "%s/test_file_dst2" % dir
# make sure everything is clean
if os.path.exists(src):
os.unlink(src)
if os.path.exists(src2):
os.unlink(src2)
if os.path.exists(dst):
os.unlink(dst)
if os.path.exists(dst2):
os.unlink(dst2)
if os.path.exists(dir):
os.rmdir(dir)
# initiate a global transaction
transaction = Transaction.get(create=True)
# do some operations
FileUndo.mkdir(dir)
# create a file
file = open(src,"w")
file.write("whatever")
file.close()
# create a file
file = open(src2,"w")
file.write("whatever2")
file.close()
self.assertEquals(os.path.exists(src), True)
self.assertEquals(os.path.exists(src2), True)
FileUndo.move(src,dst)
FileUndo.copy(dst,dst2)
FileUndo.remove(src2)
transaction.commit()
self.assertEquals(True, os.path.exists(dir) )
self.assertEquals(False, os.path.exists(src) )
self.assertEquals(False, os.path.exists(src2) )
self.assertEquals(True, os.path.exists(dst) )
self.assertEquals(True, os.path.exists(dst2) )
TransactionLog.get_last().undo()
self.assertEquals(False, os.path.exists(dir) )
self.assertEquals(True, os.path.exists(src) )
self.assertEquals(True, os.path.exists(src2) )
self.assertEquals(False, os.path.exists(dst) )
self.assertEquals(False, os.path.exists(dst2) )
os.unlink(src)
os.unlink(src2)
def _test_debug_log(self):
'''tests that the debug log executes outside of a transaction'''
# initiate a global transaction
transaction = Transaction.get(create=True)
person = Person.create("Mr", "Potato Head", "PotatoLand", "Pretty much looks like a potato")
person_id = person.get_id()
person_type = person.get_search_type()
from pyasm.biz import DebugLog
log = DebugLog.log("debug", "Unittest Debug In transaction")
log_id = log.get_id()
Person.clear_cache()
transaction.rollback()
person = Search.get_by_id(person_type, person_id)
#log = DebugLog.get_by_id(log_id)
# make sure the person is undone
self.assertEquals(None, person)
# make sure the log still exists
self.assertNotEquals(None, log)
class SqlTest(unittest.TestCase):
def setUp(self):
# intialiaze the framework as a batch process
batch = Batch()
from pyasm.web.web_init import WebInit
WebInit().execute()
self.test_env = UnittestEnvironment()
self.test_env.create()
def test_all(self):
try:
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
impl = sql.get_database_impl()
db_type = impl.get_database_type()
if db_type == "PostgreSQL":
self.prefix = '''"unittest"."public".'''
self.sthpw_prefix = '''"sthpw"."public".'''
elif db_type == "Sqlite":
self.prefix = ""
self.sthpw_prefix = ""
else:
self.prefix = '''"unittest".'''
self.sthpw_prefix = '''"sthpw".'''
self._test_get_connect()
self._test_select_class()
self._test_insert_class()
self._test_update_class()
self._test_insert_and_delete()
self._test_create_table()
self._test_transaction()
self._test_order_by()
self._test_rpn_filters()
self._test_search_filter()
self._test_join()
self._test_create_view()
# it doesn't allow dropping of a column
if db_type != 'Sqlite':
self._test_add_drop_column()
finally:
Project.set_project('unittest')
self.test_env.delete()
def _test_get_connect(self):
database= 'unittest'
project = Project.get_by_code(database)
db_resource= project.get_project_db_resource()
sql1 = DbContainer.get(db_resource)
sql2 = DbContainer.get(db_resource)
self.assertEquals(sql1, sql2)
def _test_select_class(self):
""" test a select """
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("person")
select.add_where("\"name_first\" = 'megumi'")
select.add_order_by("name_last")
statement = select.get_statement()
sql = DbContainer.get(db_res)
impl = sql.get_database_impl()
db_type = impl.get_database_type()
expected = '''SELECT %s"person".* FROM %s"person" WHERE "name_first" = 'megumi' ORDER BY "person"."name_last"''' % (self.prefix, self.prefix)
self.assertEquals( expected, statement )
# test for doubling of apostrophe
select = Select()
select.set_database(db_res)
select.add_table("person")
select.add_filter('name_last', "john's", op='!=')
statement = select.get_statement()
expected = """SELECT %s"person".* FROM %s"person" WHERE "person"."name_last" != 'john''s'""" % (self.prefix, self.prefix)
self.assertEquals( expected, statement )
def _test_insert_class(self):
"""test an insert"""
insert = Insert()
insert.set_table("person");
insert.set_value("name_first", "megumi");
insert.set_value("name_last", "takamori");
statement = insert.get_statement()
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
if sql.get_database_type() == "Oracle":
expected = "INSERT INTO \"person\" (\"id\", \"name_first\", \"name_last\") VALUES (\"person_id_seq\".nextval, 'megumi', 'takamori')"
elif sql.get_database_type() == "SQLServer":
expected = "INSERT INTO [person] (\"name_first\", \"name_last\") VALUES ('megumi', 'takamori')"
else:
expected = "INSERT INTO \"person\" (\"name_first\", \"name_last\") VALUES ('megumi', 'takamori')"
self.assertEquals( expected, statement )
def _test_update_class(self):
"""test an update"""
update = Update()
update.set_table("person");
update.set_value("name_first", "megumi");
update.add_where("\"person_id\" = '1'");
statement = update.get_statement()
expected = "UPDATE \"person\" SET \"name_first\" = 'megumi' WHERE \"person_id\" = '1'"
self.assertEqual( expected, statement )
def _test_insert_and_delete(self):
# ensure that we are *NOT* in a transaction
Transaction.clear_stack()
transaction = Transaction.get()
# comment out for now
#self.assertEquals( None, transaction )
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
self.assertEquals( False, sql.is_in_transaction() )
count_sql = """select count(*) from "person"
where "name_first" = 'Bugs' and "name_last" = 'Bunny'"""
num_records = sql.get_int(count_sql)
self.assertEquals(0, num_records)
# test with no transaction
transaction = Transaction.get(create=True)
insert = Insert()
insert.set_table("person")
insert.set_value("name_first", "Bugs")
insert.set_value("name_last", "Bunny")
statement = insert.get_statement()
expected = '''INSERT INTO "person" ("name_first", "name_last") VALUES ('Bugs', 'Bunny')'''
self.assertEquals(expected, statement)
# with a db_res added, it should scope the database
insert = Insert()
insert.set_database(db_res)
insert.set_table("person")
insert.set_value("name_first", "Bugs")
insert.set_value("name_last", "Bunny")
statement = insert.get_statement()
expected = '''INSERT INTO %s"person" ("name_first", "name_last") VALUES ('Bugs', 'Bunny')''' % self.prefix
self.assertEquals(expected, statement)
sql.do_update(statement)
num_records = sql.get_int(count_sql)
self.assertEquals(1, num_records)
delete = """delete from "person"
where "name_first" = 'Bugs' and "name_last" = 'Bunny'"""
sql.do_update(delete)
num_records = sql.get_int(count_sql)
self.assertEquals(0, num_records)
transaction.rollback()
def _test_create_table(self):
create = CreateTable()
create.set_table("coffee")
create.add_column("id", "int4")
create.add_column("type", "varchar(10)")
create.add_column("login", "varchar(30)")
create.add_column("discussion", "text")
create.set_primary_key("id")
statement = create.get_statement()
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
if sql.get_database_type() == "Oracle":
expected = \
'''CREATE TABLE "coffee" (
"id" NUMBER,
"type" VARCHAR2(10),
"login" VARCHAR2(30),
"discussion" CLOB,
PRIMARY KEY ("id")
);'''
else:
expected = \
'''CREATE TABLE "coffee" (
"id" int4,
"type" varchar(10),
"login" varchar(30),
"discussion" text,
PRIMARY KEY ("id"));'''
statement = statement.replace("\n", "")
statement = statement.replace(" ", " ")
statement = statement.replace("\t", " ")
expected = expected.replace("\n", "")
statement = expected.replace(" ", " ")
statement = expected.replace("\t", " ")
self.assertEquals(expected, statement)
def _test_transaction(self):
"""test a transaction"""
database_type = Project.get_by_code("unittest").get_database_type()
if database_type == "MySQL":
print
print "WARNING: !!!!!!!"
print "_test_tranaction is disabled"
print "WARNING: !!!!!!!"
print
return
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
count_sql = 'select count(*) from "person"'
num_records = sql.get_int(count_sql)
# start the transaction, update and roll back
sql.start()
insert = Insert()
insert.set_table("person")
insert.set_value("name_first", "cow")
insert.set_value("name_last", "sql")
query = insert.get_statement()
sql.do_update(query)
new_num_records = sql.get_value(count_sql)
self.assertEquals( new_num_records, num_records+1 )
sql.rollback()
# dump after the rollback
new_num_records = sql.get_int(count_sql)
self.assertEqual( new_num_records, num_records )
def _test_order_by(self):
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("asset")
select.add_enum_order_by("code", ['cow', 'dog', 'horse'])
expected = '''SELECT %s"asset".* FROM %s"asset" ORDER BY ( CASE "code"
WHEN 'cow' THEN 1
WHEN 'dog' THEN 2
WHEN 'horse' THEN 3
ELSE 4 END )''' % (self.prefix, self.prefix)
statement = select.get_statement()
self.assertEqual(expected, statement)
def _test_rpn_filters(self):
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("asset")
select.add_where("begin")
select.add_where("\"code\" = 'chr001'")
select.add_where("\"code\" = 'chr002'")
select.add_where("\"code\" = 'chr003'")
select.add_where("or")
select.add_where("\"status\" = 'complete'")
select.add_where("and")
statement = select.get_statement()
expected = """SELECT %s"asset".* FROM %s"asset" WHERE ( "code" = 'chr001' OR "code" = 'chr002' OR "code" = 'chr003' ) AND "status" = 'complete'""" % (self.prefix, self.prefix)
self.assertEquals(expected, statement)
# test some simple fringe cases
select = Select()
select.add_table("asset")
select.add_where("begin")
select.add_where("or")
select.add_where("\"status\" = 'complete'")
select.add_where("and")
statement = select.get_statement()
expected = """SELECT "asset".* FROM "asset" WHERE "status" = 'complete'"""
self.assertEquals(expected, statement)
# assumed begin
select = Select()
select.add_table("asset")
select.add_where("\"status\" = 'retired'")
select.add_where("\"code\" = 'chr001'")
select.add_where("\"code\" = 'chr002'")
select.add_where("or")
statement = select.get_statement()
expected = """SELECT "asset".* FROM "asset" WHERE "status" = 'retired' OR "code" = 'chr001' OR "code" = 'chr002'"""
self.assertEquals(expected, statement)
# add a more complex case
search = Select()
search.add_table("person")
search.add_where("begin")
search.add_where("begin")
search.add_filter("login", "joe")
search.add_filter("login", "mary")
search.add_where("and")
search.add_where("begin")
search.add_filter("attr", "tom")
search.add_filter("attr", "peter")
search.add_where("and")
search.add_where("or")
statement = search.get_statement()
expected = '''SELECT "person".* FROM "person" WHERE ( "person"."login" = 'joe' AND "person"."login" = 'mary' ) OR ( "person"."attr" = 'tom' AND "person"."attr" = 'peter' )'''
self.assertEquals(expected, statement)
# try to throw in an extra begin in the middle
project_code = "unittest"
filter_search_type = "unittest/city"
search_type = 'sthpw/sobject_list'
search = Search(search_type)
search.add_filter("project_code", project_code)
search.add_filter("search_type", filter_search_type)
search.add_op("begin")
values = ["chr001"]
columns = ['keywords']
for column in columns:
search.add_startswith_keyword_filter(column, values)
statement = search.get_statement()
expected = '''SELECT %s"sobject_list".* FROM %s"sobject_list" WHERE "sobject_list"."project_code" = 'unittest' AND "sobject_list"."search_type" = 'unittest/city' AND ( lower("sobject_list"."keywords") like lower('%% chr001%%') OR lower("sobject_list"."keywords") like lower('chr001%%') )''' % (self.sthpw_prefix, self.sthpw_prefix)
self.assertEquals(expected, statement)
def _test_search_filter(self):
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("job")
select.add_column("request_id")
select.add_filter("code", "123MMS")
select2 = Select()
#db_res = DbResource.get_default('unittest')
select2.set_database(db_res)
select2.add_table("request")
select2.add_select_filter("id", select)
statement = select2.get_statement()
expected = '''SELECT %s"request".* FROM %s"request" WHERE "request"."id" in ( SELECT %s"job"."request_id" FROM %s"job" WHERE "job"."code" = '123MMS' )''' % (self.prefix, self.prefix, self.prefix, self.prefix)
self.assertEquals(expected, statement)
select3 = Select()
select3.set_database(db_res)
select3.add_op("begin")
select3.add_table("request")
select3.add_select_filter("id", select)
statement = select3.get_statement()
expected = '''SELECT %s"request".* FROM %s"request" WHERE "request"."id" in ( SELECT %s"job"."request_id" FROM %s"job" WHERE "job"."code" = '123MMS' )''' % (self.prefix, self.prefix, self.prefix, self.prefix)
self.assertEquals(expected, statement)
def _test_add_drop_column(self):
#Project.set_project('unittest')
from pyasm.command import ColumnAddCmd, ColumnDropCmd, Command
cmd = ColumnAddCmd('unittest/country','special_place','varchar(256)')
Command.execute_cmd(cmd)
search_type = 'unittest/country'
# clear cache
SearchType.clear_column_cache(search_type)
DatabaseImpl.clear_table_cache()
exists = SearchType.column_exists(search_type, 'special_place')
self.assertEquals(exists, True)
# now drop the column
cmd = ColumnDropCmd(search_type,'special_place')
Command.execute_cmd(cmd)
# clear cache
SearchType.clear_column_cache(search_type)
cache_dict = Container.get("DatabaseImpl:column_info")
# assume database is the same as sthpw
database_type = Project.get_by_code("unittest").get_database_type()
db_resource = DbResource.get_default('unittest')
table_info = cache_dict.get("%s:%s" % (db_resource, "country"))
self.assertEquals(table_info == None, True)
key = "%s:%s" % (db_resource, "country")
cache_dict[key] = None
exists = SearchType.column_exists(search_type, 'special_place')
self.assertEquals(exists, False)
def _test_join(self):
""" test a select """
Project.set_project('unittest')
select = Select()
db_res = DbResource.get_default('unittest')
select.set_database(db_res)
select.add_table("person")
select.add_join('person','city', 'city_code','code')
select.add_join('city','country', 'country_code','code')
select.add_order_by("name_last")
statement = select.get_statement()
self.assertEquals(statement, '''SELECT %s"person".* FROM %s"person" LEFT OUTER JOIN %s"city" ON "person"."city_code" = "city"."code" LEFT OUTER JOIN %s"country" ON "city"."country_code" = "country"."code" ORDER BY "person"."name_last"''' % (self.prefix, self.prefix, self.prefix, self.prefix) )
search = Search('unittest/person')
search.add_join('unittest/city', 'unittest/person')
statement = search.get_statement()
self.assertEquals(statement, '''SELECT %s"person".* FROM %s"person" LEFT OUTER JOIN %s"city" ON "person"."city_code" = "city"."code"''' % (self.prefix,self.prefix, self.prefix))
statement = search.get_statement()
# this one has no schema connection, so will be ignored
search.add_join('sthpw/login', 'unittest/person')
self.assertEquals(statement, '''SELECT %s"person".* FROM %s"person" LEFT OUTER JOIN %s"city" ON "person"."city_code" = "city"."code"''' % (self.prefix, self.prefix, self.prefix))
search.add_join('unittest/country', 'unittest/city')
statement = search.get_statement()
self.assertEquals(statement, '''SELECT %s"person".* FROM %s"person" LEFT OUTER JOIN %s"city" ON "person"."city_code" = "city"."code" LEFT OUTER JOIN %s"country" ON "city"."country_code" = "country"."code"''' % (self.prefix, self.prefix, self.prefix, self.prefix) )
def _test_create_view(self):
from sql import CreateView
db_res = DbResource.get_default('unittest')
sql = DbContainer.get(db_res)
car_columns = sql.get_columns("car")
sports_columns = sql.get_columns("sports_car_data")
search = Search("unittest/car")
search.add_join("unittest/sports_car_data")
search.add_column("*", table="car")
for sports_column in sports_columns:
if sports_column not in car_columns:
search.add_column(sports_column, table="sports_car_data")
create_view = CreateView(search=search)
create_view.set_view("sports_car")
statement = create_view.get_statement()
expected = '''CREATE VIEW "sports_car" AS SELECT "unittest"."public"."car".*, "unittest"."public"."sports_car_data"."acceleration", "unittest"."public"."sports_car_data"."horsepower", "unittest"."public"."sports_car_data"."top_speed" FROM "unittest"."public"."car" LEFT OUTER JOIN "unittest"."public"."sports_car_data" ON "car"."code" = "sports_car_data"."code"'''
self.assertEquals(expected, statement)
