def test_local_imkdir(self):
     # local setup
     mytestdir = "testingimkdir"
     # assertions
     assertiCmdFail(s.adminsession, "ils -L " + mytestdir, "LIST", mytestdir)  # should not be listed
     assertiCmd(s.adminsession, "imkdir " + mytestdir)  # imkdir
     assertiCmd(s.adminsession, "ils -L " + mytestdir, "LIST", mytestdir)  # should be listed

    def test_icp_r(self):
        base_name_source = "test_icp_r_dir_source"
        user_session = s.sessions[1]
        file_names = set(self.iput_r_large_collection(user_session, base_name_source, file_count=1000, file_size=100)[1])

        base_name_target = "test_icp_r_dir_target"
        assertiCmd(user_session, "icp -r " + base_name_source + " " + base_name_target, "EMPTY")
        assertiCmd(user_session, "ils", "LIST", base_name_target)
        rods_files_source = set(runCmd_ils_to_entries(user_session.runCmd("ils", [base_name_source])))
        self.assertTrue(file_names == rods_files_source,
                        msg="Files missing from rods source:\n" + str(file_names-rods_files_source) + "\n\n" + \
                            "Extra files in rods source:\n" + str(rods_files_source-file_names))

        rods_files_target = set(runCmd_ils_to_entries(user_session.runCmd("ils", [base_name_target])))
        self.assertTrue(file_names == rods_files_target,
                        msg="Files missing from rods target:\n" + str(file_names-rods_files_target) + "\n\n" + \
                            "Extra files in rods target:\n" + str(rods_files_target-file_names))     

        vault_files_post_icp_source = set(os.listdir(os.path.join(get_vault_session_path(user_session),
                                                                  base_name_source)))

        self.assertTrue(file_names == vault_files_post_icp_source,
                        msg="Files missing from vault:\n" + str(file_names-vault_files_post_icp_source) + "\n\n" + \
                            "Extra files in vault:\n" + str(vault_files_post_icp_source-file_names))


        vault_files_post_icp_target = set(os.listdir(os.path.join(get_vault_session_path(user_session),
                                                                  base_name_target)))
        self.assertTrue(file_names == vault_files_post_icp_target,
                        msg="Files missing from vault:\n" + str(file_names-vault_files_post_icp_target) + "\n\n" + \
                            "Extra files in vault:\n" + str(vault_files_post_icp_target-file_names))

    def test_issue_2420(self):
        # manipulate the core.re to enable host access control
        corefile = get_irods_config_dir() + "/core.re"
        backupcorefile = corefile + "--" + self._testMethodName
        shutil.copy(corefile, backupcorefile)
        os.system(
            '''sed -e '/^acAclPolicy {msiAclPolicy("STRICT"); }/iacAclPolicy {ON($userNameClient == "quickshare") { } }' /etc/irods/core.re > /tmp/irods/core.re''')
        time.sleep(1)  # remove once file hash fix is commited #2279
        os.system("cp /tmp/irods/core.re /etc/irods/core.re")
        time.sleep(1)  # remove once file hash fix is commited #2279

        # restart the server to reread the new core.re
        os.system(get_irods_top_level_dir() + "/iRODS/irodsctl stop")
        os.system(get_irods_top_level_dir() + "/iRODS/irodsctl start")

        assertiCmd(s.adminsession, "ils", "LIST", "tempZone")

        # look for the error "unable to read session variable $userNameClient."
        p = subprocess.Popen(
            ['grep "unable to read session variable $userNameClient."  ../../iRODS/server/log/rodsLog.*'], shell=True, stdout=subprocess.PIPE)
        result = p.communicate()[0]

        # restore the original core.re
        shutil.copy(backupcorefile, corefile)
        os.remove(backupcorefile)

        # check the results for the error
        assert(-1 == result.find("userNameClient"))

    def test_server_config_environment_variables(self):
        # set log level to get all the things
        os.environ['spLogLevel'] = '11'

        # set a random environment value to find in the log
        svr_cfg_file = get_irods_config_dir() + "/server_config.json"
        os.system("cp %s %sOrig" % (svr_cfg_file, svr_cfg_file))

        with open(svr_cfg_file) as f:
            svr_cfg = json.load(f)
        the_value = 'THIS_IS_THE_VALUE'
        svr_cfg['environment_variables']['foo_bar'] = the_value
        mod_json_file(svr_cfg_file, svr_cfg)

        # bounce the server to get the new env variable
        os.system(get_irods_top_level_dir() + "/iRODS/irodsctl stop")
        os.system(get_irods_top_level_dir() + "/iRODS/irodsctl start")

        assertiCmd(s.adminsession, "ils", "LIST", "tempZone")

        # look for the error "unable to read session variable $userNameClient."
        p = subprocess.Popen(
            ['grep "' + the_value + '"  ../../iRODS/server/log/rodsLog.*'], shell=True, stdout=subprocess.PIPE)
        result = p.communicate()[0]

        del os.environ['spLogLevel']
        os.system("mv %sOrig %s" % (svr_cfg_file, svr_cfg_file))

        os.system(get_irods_top_level_dir() + "/iRODS/irodsctl stop")
        os.system(get_irods_top_level_dir() + "/iRODS/irodsctl start")

        # check the results for the error
        assert(-1 != result.find(the_value))

 def test_local_imkdir_with_trailing_slash(self):
     # local setup
     mytestdir = "testingimkdirwithslash"
     # assertions
     assertiCmdFail(s.adminsession, "ils -L " + mytestdir + "/", "LIST", mytestdir)  # should not be listed
     assertiCmd(s.adminsession, "imkdir " + mytestdir + "/")  # imkdir
     assertiCmd(s.adminsession, "ils -L " + mytestdir, "LIST", mytestdir)  # should be listed

 def test_local_imkdir_with_trailing_slash_already_exists(self):
     # local setup
     mytestdir = "testingimkdirwithslash"
     # assertions
     assertiCmd(s.adminsession, "imkdir " + mytestdir + "/")  # imkdir
     assertiCmdFail(s.adminsession, "imkdir " + mytestdir)  # should fail, already exists
     assertiCmdFail(s.adminsession, "imkdir " + mytestdir + "/")  # should fail, already exists

 def test_local_imkdir_with_parent(self):
     # local setup
     mytestdir = "parent/testingimkdirwithparent"
     # assertions
     assertiCmdFail(s.adminsession, "ils -L " + mytestdir, "LIST", mytestdir)  # should not be listed
     assertiCmd(s.adminsession, "imkdir -p " + mytestdir)  # imkdir with parent
     assertiCmd(s.adminsession, "ils -L " + mytestdir, "LIST", mytestdir)  # should be listed

    def test_iput_overwrite_others_file__ticket_2086(self):
        # pre state
        assertiCmd(s.adminsession,"ils -L","LIST",self.testfile) # should be listed

        # local setup
        filename = "overwritefile.txt"
        filepath = create_local_testfile(filename)

        # alice tries to put
        homepath = "/home/"+s.adminsession.getUserName()+"/"+s.adminsession.sessionId+"/"+self.testfile
        logicalpath = "/"+s.adminsession.getZoneName()+homepath
        assertiCmd(s.sessions[1],"iput "+filepath+" "+logicalpath,"ERROR","CAT_NO_ACCESS_PERMISSION") # iput

        # check physicalpaths (of all replicas)
        cmdout = s.adminsession.runCmd('ils',['-L'])
        print "[ils -L]:"
        print "["+cmdout[0]+"]"
        lines = cmdout[0].splitlines()
        for l in cmdout[0].splitlines():
            if "demoResc" in l:
                if "/session-" in l:
                    physicalpath = l.split()[2]
                    # check file is on disk
                    print "[ls -l "+physicalpath+"]:"
                    os.system("ls -l "+physicalpath)
                    assert os.path.exists(physicalpath)

        # local cleanup
        output = commands.getstatusoutput( 'rm '+filepath )

 def test_curl_post(self):
     rule_file = self.rules_dir + "curlPost.r"
     print "-- running "+rule_file
     
     # will have to dynamically pass form_data to the rule once that's fixed
     form_data = "Sent from iRODS"
     c.assertiCmd(s.adminsession,"irule -F "+rule_file, "LIST", form_data)

 def test_irm_specific_replica(self):
     assertiCmd(s.adminsession,"ils -L "+self.testfile,"LIST",self.testfile) # should be listed
     assertiCmd(s.adminsession,"irepl -R "+self.testresc+" "+self.testfile) # creates replica
     assertiCmd(s.adminsession,"ils -L "+self.testfile,"LIST",self.testfile) # should be listed twice
     assertiCmd(s.adminsession,"irm -n 0 "+self.testfile) # remove original from grid
     assertiCmd(s.adminsession,"ils -L "+self.testfile,"LIST",["1 "+self.testresc,self.testfile]) # replica 1 should be there
     assertiCmdFail(s.adminsession,"ils -L "+self.testfile,"LIST",["0 "+s.adminsession.getDefResource(),self.testfile]) # replica 0 should be gone
     trashpath = "/"+s.adminsession.getZoneName()+"/trash/home/"+s.adminsession.getUserName()+"/"+s.adminsession.sessionId
     assertiCmdFail(s.adminsession,"ils -L "+trashpath+"/"+self.testfile,"LIST",["0 "+s.adminsession.getDefResource(),self.testfile]) # replica should not be in trash

 def test_local_iput_physicalpath_no_permission(self):
     # local setup
     datafilename = "newfile.txt"
     f = open(datafilename,'wb')
     f.write("TESTFILE -- ["+datafilename+"]")
     f.close()
     # assertions
     assertiCmd(s.adminsession,"iput -p /newfileinroot.txt "+datafilename,"ERROR",["UNIX_FILE_CREATE_ERR","Permission denied"]) # should fail to write
     # local cleanup
     output = commands.getstatusoutput( 'rm '+datafilename )

    def test_imeta_set_single_object_abandoned_avu_triple_to_double_empty_unit(self):
        user = s.sessions[1].get_username()

        set_and_check_avu(user, 'att0', 'val0', 'unt0')

        assertiCmd(s.adminsession, 'imeta rm -u %s %s %s %s' % (user, 'att0', 'val0', 'unt0'))

        set_and_check_avu(user, 'att0', 'val0', '""')

        assertiCmdFail(s.adminsession, 'imeta ls -u ' + user + ' att0', 'STDOUT', 'units: unt0')

    def setUp(self):
        ResourceBase.__init__(self)
        s.twousers_up()
        self.run_resource_setup()

        usernames = [ss.get_username() for ss in s.sessions]
        assertiCmd(s.adminsession, 'iadmin lu', 'STDOUT_MULTILINE', usernames)

        for u in usernames:
            assertiCmd(s.adminsession, 'imeta ls -u ' + u, 'STDOUT', 'None')

 def test_local_iget(self):
     # local setup
     localfile = "local.txt"
     # assertions
     assertiCmd(s.adminsession,"iget "+self.testfile+" "+localfile) # iget
     output = commands.getstatusoutput( 'ls '+localfile )
     print "  output: ["+output[1]+"]"
     assert output[1] == localfile
     # local cleanup
     output = commands.getstatusoutput( 'rm '+localfile )

 def test_iscan_local_file(self):
     assertiCmd( s.sessions[1], 'iscan non_existent_file', 'STDERR', 'ERROR: scanObj: non_existent_file does not exist' )
     existent_file = os.path.join( s.sessions[1]._session_dir, 'existent_file' )
     pydevtest_common.touch( existent_file )
     assertiCmd( s.sessions[1], 'iscan ' + existent_file, 'STDOUT', existent_file + ' is not registered in iRODS' )
     assertiCmd( s.sessions[1], 'iput ' + existent_file );
     output = getiCmdOutput( s.sessions[1], '''iquest "SELECT DATA_PATH WHERE DATA_NAME = 'existent_file'"''' )[0]
     data_path = output.strip().strip('-').strip()[12:]
     assertiCmd( s.sessions[1], 'iscan ' + data_path );
     assertiCmd( s.sessions[1], 'irm -f existent_file' );

 def test_local_iput_relative_physicalpath_into_server_bin(self):
     # local setup
     datafilename = "newfile.txt"
     f = open(datafilename,'wb')
     f.write("TESTFILE -- ["+datafilename+"]")
     f.close()
     # assertions
     relpath = "relativephysicalpath.txt"
     assertiCmd(s.sessions[1],"iput -p "+relpath+" "+datafilename,"ERROR","absolute") # should error
     # local cleanup
     output = commands.getstatusoutput( 'rm '+datafilename )

 def test_local_iput_checksum(self):
     # local setup
     datafilename = "newfile.txt"
     f = open(datafilename,'wb')
     f.write("TESTFILE -- ["+datafilename+"]")
     f.close()
     # assertions
     assertiCmd(s.adminsession,"iput -K "+datafilename) # iput
     assertiCmd(s.adminsession,"ils -L","LIST","d60af3eb3251240782712eab3d8ef3b1") # check proper checksum
     # local cleanup
     output = commands.getstatusoutput( 'rm '+datafilename )

    def setUp(self):
        ResourceBase.__init__(self)
        s.twousers_up()
        shutil.copy2('/bin/cp', RODSHOME + '/server/bin/cmd/mycp')
        shutil.copy2(FILESDIR + '/myWorkFlow', RODSHOME + '/server/bin/cmd/')
        shutil.copy2(FILESDIR + '/tt', RODSHOME + '/server/bin/cmd/')
        assertiCmd(s.adminsession, "iput -f " + FILESDIR + "/PHOTO.JPG /tempZone/home/rods")
	getiCmdOutput(s.adminsession, "irm -rf /tempZone/home/rods/workflow")
        assertiCmd(s.adminsession, "imkdir -p /tempZone/home/rods/workflow")

        self.run_resource_setup()

 def test_create_and_remove_coordinating_resource(self):
     testresc1 = "testResc1"
     assertiCmdFail(s.adminsession,"iadmin lr","LIST",testresc1) # should not be listed
     output = commands.getstatusoutput("hostname")
     hostname = output[1]
     assertiCmd(s.adminsession,"iadmin mkresc "+testresc1+" replication", "LIST", "Creating") # replication
     assertiCmd(s.adminsession,"iadmin lr","LIST",testresc1) # should be listed
     assertiCmd(s.adminsession,"iadmin lr "+testresc1,"LIST",["resc_net","EMPTY_RESC_HOST"]) # should have empty host
     assertiCmd(s.adminsession,"iadmin lr "+testresc1,"LIST",["resc_def_path","EMPTY_RESC_PATH"]) # should have empty path
     assertiCmd(s.adminsession,"iadmin rmresc "+testresc1) # good remove
     assertiCmdFail(s.adminsession,"iadmin lr","LIST",testresc1) # should be gone

 def test_local_iput_with_changed_target_filename(self):
     # local setup
     datafilename = "newfile.txt"
     f = open(datafilename,'wb')
     f.write("TESTFILE -- ["+datafilename+"]")
     f.close()
     # assertions
     changedfilename = "different.txt"
     assertiCmd(s.adminsession,"iput "+datafilename+" "+changedfilename) # should complete
     assertiCmd(s.adminsession,"ils -L "+changedfilename,"LIST",changedfilename) # should be listed
     # local cleanup
     output = commands.getstatusoutput( 'rm '+datafilename )