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 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): 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 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)