def test_work_trash(self): product = self.anna_mdl_work.create_product("abc") utils.add_file_to_directory(product.directory, "product_file.txt") # test trash work and its wip product self.anna_mdl_work.trash() self.assertFalse(os.path.exists(product.directory)) self.assertFalse(os.path.exists(self.anna_mdl_work.directory))
def test_work_status(self): # test new work file is reported, even in subdirectory utils.add_file_to_directory(self.anna_mdl_work.directory, "new_file.txt") # test new product files are reported, even in subdirectory subdir_path = os.path.join(self.anna_mdl_work.directory, "subdir") os.makedirs(subdir_path) utils.add_file_to_directory(subdir_path, "subfile.txt") # test work file edit are reported with open(os.path.join(self.anna_mdl_work.directory, "work.blend"), 'a') as f: f.write("another_line") self.assertEqual( self.anna_mdl_work.status(), { '/new_file.txt': 'added', '/subdir/subfile.txt': 'added', '/work.blend': 'edited' }) # test work file deletion is reported os.remove(os.path.join(self.anna_mdl_work.directory, "work.blend")) self.assertEqual( self.anna_mdl_work.status(), { '/new_file.txt': 'added', '/subdir/subfile.txt': 'added', '/work.blend': 'removed' })
def _initResource(self): self.anna_mdl = self.prj.create_resource("anna", "mdl") self.anna_mdl_work = self.anna_mdl.checkout() utils.add_file_to_directory(self.anna_mdl_work.directory, "work.blend") self.anna_abc_product = self.anna_mdl_work.create_product("abc") utils.add_file_to_directory(self.anna_abc_product.directory, "anna.abc") self.anna_mdl_commit = self.anna_mdl_work.commit()
def test_happy_path(self): add_file_to_directory(self.directory_a["path"]) transfer_files(self.directory_a["path"], self.directory_b["path"]) a_files = [f for f in listdir(self.a_path) if isfile(join(self.a_path, f))] b_files = [f for f in listdir(self.b_path) if isfile(join(self.b_path, f))] self.assertEqual(len(a_files), 0) self.assertEqual(len(b_files), 1)
def test_work_revert(self): # make some change in the work folder utils.add_file_to_directory(self.anna_mdl_work.directory) with open(os.path.join(self.anna_mdl_work.directory, "work.blend"), "a") as work_file: work_file.write("something") # test there's changes self.assertTrue(len(self.anna_mdl_work.status()) == 2) self.anna_mdl_work.revert() # test there's no more changes self.assertTrue(len(self.anna_mdl_work.status()) == 0)
def test_template_resource(self): template_mdl = self.prj.create_template("mdl") template_mdl_work = template_mdl.checkout() template_mdl_work.create_product("abc") utils.add_file_to_directory(template_mdl_work.directory) template_mdl_work.commit() template_mdl_work.trash() froga_mdl = self.prj.create_resource("froga", "mdl") froga_mdl_work = froga_mdl.checkout() self.assertTrue( os.path.exists( os.path.join(froga_mdl_work.get_products_directory(), "abc")))
def listen_for_device(neut): while neut.state == ProgramState.ready_for_device: # for testing: if not os.path.isdir(PATH_TO_DEVICE): os.mkdir(PATH_TO_DEVICE) add_file_to_directory(PATH_TO_DEVICE) # end for testing if os.path.isdir(PATH_TO_DEVICE): op_1_key = neut.get_key_by_name("op-1") op_1_key.file_path = PATH_TO_DEVICE print("ready for commands!") neut.state = ProgramState.ready_for_commands return neut
def test_multiple_repository_types(self): local_repo_name = "local_test_storage" self.cnx.add_repository(name=local_repo_name, adapter="file_storage", path=os.path.join(utils.file_storage_path, local_repo_name).replace( "\\", "/")) template_resource = self.prj.create_resource( "_template", "rig", repository="local_test_storage") template_work = template_resource.checkout() utils.add_file_to_directory(template_work.directory, "template_work.txt") template_work.commit() # self.assertTrue(os.path.exists(os.path.join(user_works, "test\\rig\\_template"))) template_work.trash() self.prj.purge_unused_user_products() self.assertFalse( os.path.exists( os.path.join(utils.sandbox_work_path, test_project_name, "_template-rig"))) template_resource.checkout() self.assertTrue( os.path.exists( os.path.join(utils.sandbox_work_path, test_project_name, "_template-rig"))) # test moving resource between repo self.assertTrue( os.path.exists( os.path.join(utils.file_storage_path, local_repo_name, test_project_name, "work", "rig", "_template"))) template_resource.set_repository(self.prj.cfg.default_repository) self.assertFalse( os.path.exists( os.path.join(utils.file_storage_path, local_repo_name, test_project_name, "work", "rig", "_template"))) # test commit the resource utils.add_file_to_directory(template_work.directory) template_work.commit() # test moving resource between repo when the resource is locked template_resource.set_lock(True, "another_user") with self.assertRaises(PulseError): template_resource.set_repository("serverB")
def test_scenario(self): # register to project with user login cli_cmd_list([ 'get_project', test_project_name, "--adapter mysql", '--settings "' + self.db_url + '"' ]) # create a modeling resource cli_cmd_list(['create_resource', 'ch_anna-mdl']) anna_mdl_path = os.path.join(cfg.sandbox_work_path, test_project_name, 'ch_anna-mdl') self.assertTrue(os.path.exists(anna_mdl_path)) os.chdir(anna_mdl_path) cli_cmd_list(['create_output', 'abc']) anna_abc_path = os.path.join(cfg.sandbox_products_path, test_project_name, 'ch_anna-mdl', 'v001', 'abc') self.assertTrue(os.path.exists(anna_abc_path)) # commit work cfg.add_file_to_directory(anna_abc_path) cli_cmd_list(['commit']) # create a surface resource cli_cmd_list(['create_resource', 'ch_anna-surfacing']) anna_surfacing_path = os.path.join(cfg.sandbox_work_path, test_project_name, 'ch_anna-surfacing') os.chdir(anna_surfacing_path) # add mdl as input and commit cli_cmd_list(['add_input', 'ch_anna-mdl.abc@1']) cfg.add_file_to_directory(anna_surfacing_path) cli_cmd_list(['commit']) # trash works # but first move out from the work directory, unless the directory won't move os.chdir(cli_project_path) cli_cmd_list(['trash', 'ch_anna-surfacing']) self.assertFalse(os.path.exists(anna_surfacing_path)) cli_cmd_list(['trash', 'ch_anna-mdl']) self.assertFalse(os.path.exists(anna_mdl_path)) # now try to check out the surface and check the mdl is restored too cli_cmd_list(['checkout', 'ch_anna-surfacing']) self.assertTrue(os.path.exists(anna_abc_path))
def test_environment_variables_in_project_path(self): # set up env var os.environ['PULSE_TEST'] = utils.test_data_output_path # create a project which use this variables in its work and product path prj = self.cnx.create_project("env_var", "$PULSE_TEST/works", product_user_root="$PULSE_TEST/products", default_repository="local_test_storage") # create a resource resource = prj.create_resource("ch_anna", "model") # check out the resource work = resource.checkout() # test its location self.assertTrue( os.path.exists( os.path.join(utils.test_data_output_path, "works/env_var/ch_anna-model"))) # add an output product abc_product = work.create_product("abc") # test the product folder location self.assertTrue( os.path.exists( os.path.join(utils.test_data_output_path, "products/env_var/ch_anna-model/V001/abc"))) # commit utils.add_file_to_directory(work.directory) work.commit() # trash work.trash(no_backup=True) prj.purge_unused_user_products() self.assertFalse( os.path.exists( os.path.join(utils.test_data_output_path, "works/env_var/ch_anna/model/V001/abc"))) # create another resource surf_resource = prj.create_resource("ch_anna", "surfacing") surf_work = surf_resource.checkout() # require this product surf_work.add_input(abc_product) # test the product location self.assertTrue( os.path.exists( os.path.join(utils.test_data_output_path, "products/env_var/ch_anna-model/V001/abc")))
def test_recursive_dependencies_download(self): anna_surf_resource = self.prj.create_resource("ch_anna", "surfacing") anna_surf_work = anna_surf_resource.checkout() anna_surf_textures = anna_surf_work.create_product("textures") utils.add_file_to_directory(anna_surf_textures.directory, "product_file.txt") anna_surf_work.commit(comment="test generated product") anna_rig_resource = self.prj.create_resource("ch_anna", "rigging") anna_rig_work = anna_rig_resource.checkout() anna_rig_actor = anna_rig_work.create_product("actor_anim") anna_rig_actor.add_input(anna_surf_textures) anna_rig_work.commit() anna_rig_work.trash() anna_surf_work.trash() self.prj.purge_unused_user_products() self.assertFalse(os.path.exists(anna_surf_textures.directory)) anim_resource = self.prj.create_resource("sh003", "anim") anim_work = anim_resource.checkout() anim_work.add_input(anna_rig_actor) self.assertTrue(os.path.exists(anna_surf_textures.directory))
def test_same_user_work_and_product_directory(self): prj = self.cnx.create_project(project_name=test_project_name, work_user_root=utils.sandbox_work_path, default_repository="local_test_storage") resource = prj.create_resource("ch_anna", "model") work = resource.checkout() abc_product = work.create_product("abc") utils.add_file_to_directory(abc_product.directory, filename="model.abc") # check the work status don't list the product twice self.assertTrue(len(work.status()) == 1) # check when the work is trashed and there's a commit product, the commit product stay work.commit() utils.add_file_to_directory(work.directory, filename="change.blend") work_subfolder = os.path.join(work.directory, "subfolder") os.makedirs(work_subfolder) work.commit() work.trash() self.assertTrue(os.path.exists(abc_product.directory)) self.assertFalse(os.path.exists(work_subfolder)) # check the purge_unused_product delete the work directory prj.purge_unused_user_products() self.assertFalse(os.path.exists(work.directory)) # check the previous commit product are not uploaded again when the work is commit work = resource.checkout() utils.add_file_to_directory(work.directory, filename="change_two.blend") self.assertTrue(len(work.status()) == 1)
def test_work_update(self): # commit a new version (2), and trash it utils.add_file_to_directory(self.anna_mdl_work.directory, "new_file.txt") self.anna_mdl_work.commit() self.anna_mdl_work.trash() # checkout to version 1, and test the new file is not there work = self.anna_mdl.checkout(index=1) self.assertFalse( os.path.exists( os.path.join(self.anna_mdl_work.directory, "new_file.txt"))) # update the work, check the new file is there time.sleep(1) work.update() self.assertTrue( os.path.exists( os.path.join(self.anna_mdl_work.directory, "new_file.txt"))) # change the work file, test the update will raise an error utils.add_file_to_directory(self.anna_mdl_work.directory, "new_file2.txt") with self.assertRaises(PulseError): work.update()
def test_check_out_from_another_resource(self): shader_work_file = "shader_work_file.ma" shader_product_file = "shader_product_file.ma" source_resource = self.prj.create_resource("source", "surface") source_work = source_resource.checkout() utils.add_file_to_directory(source_work.directory, shader_work_file) source_product = source_work.create_product("shader") utils.add_file_to_directory(source_product.directory, shader_product_file) source_work.commit() anna_shd_resource = self.prj.create_resource( "ch_anna", "surface", source_resource=source_resource) anna_shd_work = anna_shd_resource.checkout() self.assertTrue( os.path.exists( os.path.join(anna_shd_work.directory, shader_work_file))) self.assertTrue( os.path.exists( os.path.join( anna_shd_work.get_product("shader").directory, shader_product_file)))
def test_scenario(self): # register to project with user login cli_cmd_list([ 'get_project', test_project_name, "--adapter json_db", '--settings "' + cfg.json_db_path + '"' ]) # create a modeling resource cli_cmd_list(['create_resource', 'ch_anna-mdl']) anna_mdl_path = os.path.join(cfg.sandbox_work_path, test_project_name, 'ch_anna-mdl') self.assertTrue(os.path.exists(anna_mdl_path)) os.chdir(anna_mdl_path) cli_cmd_list(['create_output', 'abc']) anna_abc_path = os.path.join(cfg.sandbox_products_path, test_project_name, 'ch_anna-mdl', 'v001', 'abc') self.assertTrue(os.path.exists(anna_abc_path)) # commit work cfg.add_file_to_directory(anna_mdl_path) cli_cmd_list(['commit']) # create a surface resource cli_cmd_list(['create_resource', 'ch_anna-surfacing']) anna_surfacing_path = os.path.join(cfg.sandbox_work_path, test_project_name, 'ch_anna-surfacing') os.chdir(anna_surfacing_path) # add mdl as input and commit cli_cmd_list(['add_input', 'ch_anna-mdl.abc@1']) cfg.add_file_to_directory(anna_surfacing_path) cli_cmd_list(['commit']) # trash works # but first move out from the work directory, unless the directory won't move os.chdir(cli_project_path) cli_cmd_list(['trash', 'ch_anna-surfacing']) self.assertFalse(os.path.exists(anna_surfacing_path)) cli_cmd_list(['trash', 'ch_anna-mdl']) self.assertFalse(os.path.exists(anna_mdl_path)) # now try to check out the surface and check the mdl is restored too cli_cmd_list(['checkout', 'ch_anna-surfacing']) self.assertTrue(os.path.exists(anna_abc_path)) # lock surfacing by another user (easier to simulate with with API) anna_surfacing_resource = self.prj.get_resource("ch_anna", "surfacing") anna_surfacing_resource.set_lock(True, user="******") # try to commit changes, and ensure there's a dedicated message for this error cfg.add_file_to_directory(anna_surfacing_path, "a_work_file.txt") os.chdir(anna_surfacing_path) cli_cmd_list(['commit'])
def test_complete_scenario(self): # create a resource based on this template anna_mdl_resource = self.prj.create_resource("ch_anna", "modeling") self.assertEqual(anna_mdl_resource.last_version, 0) # checkout, and check directories are created anna_mdl_work = anna_mdl_resource.checkout() self.assertTrue(os.path.exists(anna_mdl_work.directory)) # by default products should not exists self.assertFalse(os.path.exists( anna_mdl_work.get_products_directory())) # commit should fail if nothing is change in work with self.assertRaises(PulseError): anna_mdl_work.commit("very first time") # create a new file in work directory and try to commit again new_file = "test_complete.txt" utils.add_file_to_directory(anna_mdl_work.directory, new_file) self.assertEqual(anna_mdl_work.status(), {"/" + new_file: 'added'}) anna_mdl_work.commit("add a file") self.assertEqual(anna_mdl_resource.last_version, 1) # create a product anna_mdl_v2_abc = anna_mdl_work.create_product("ABC") # now products directory should exists self.assertTrue(os.path.exists(anna_mdl_work.get_products_directory())) utils.add_file_to_directory(anna_mdl_v2_abc.directory, "test.abc") # create a new commit anna_mdl_work.commit("some abc produced") self.assertEqual(anna_mdl_resource.last_version, 2) # create a new resource hat_mdl_resource = self.prj.create_resource("hat", "modeling") self.assertEqual(hat_mdl_resource.last_version, 0) hat_mdl_work = hat_mdl_resource.checkout() hat_mdl_work.add_input(anna_mdl_v2_abc) # test the product registration self.assertEqual(hat_mdl_work.get_inputs()[0].uri, "ch_anna-modeling.ABC@2") # check the work registration to product self.assertTrue( hat_mdl_work.directory in anna_mdl_v2_abc.get_product_users()) # check you can't remove a product if it's used by a work with self.assertRaises(Exception): anna_mdl_v2_abc.remove_from_user_products() hat_mdl_work.commit("with input") self.assertEqual(hat_mdl_resource.last_version, 1) # trash the hat hat_mdl_work.trash() self.assertTrue( hat_mdl_work.directory not in anna_mdl_v2_abc.get_product_users()) # check the unused time for the product self.assertTrue(anna_mdl_v2_abc.get_unused_time() > 0) # remove the product self.prj.purge_unused_user_products() # checkout the work hat_mdl_work = hat_mdl_resource.checkout() hat_mdl_work.remove_input(anna_mdl_v2_abc) anna_mdl_work.trash()