def jumpLogin(self):
driver = self.driver
try:
# 文件中读取cookie
conf = Configs()
file_path = conf.getCookieFilePath() # 获取cookie.txt文件目录
f = open(file_path, 'r')
s = f.readline()
f.close()
c = re.split(',', s)
cookie = {'name': c[0], 'value': c[1]}
# 添加cookie信息
driver.add_cookie({
'name': cookie.get('name'),
'value': cookie.get('value')
})
driver.get(self.base_url)
es = driver.find_elements_by_xpath('//*[@id="root"]/div/div[1]/ul/li')
es[0].click() # 判断是否已跳过登录，若没有则此处会报错，进而调用登录模块
except:
login.login(self) # 调用登录模块
time.sleep(0.5)
ckl = driver.get_cookies() # 将最新cookie写入cookie.txt文件
for ckd in ckl: # 注:(ckl:为列表，其中放的字典；ck_c:为字典)
pass
s = ckd['name'] + ',' + ckd['value'] # 拼接cookie信息
f = open(file_path, 'w') # 写入最新cookie的name和value
f.write(s)
f.close()
def __init__(self):
if (self.__initialized): return
self.__initialized = True
# check whether running in beaker
self.server = self.get_delivered_param("RUN_SERVER")
if self.server == "":
# Run by rhsm config file
self.confs = Configs(RHSM_CONF)
self.server = self.confs._confs["server"]
if self.server == "sam":
self.samhostip = self.confs._confs["samhostip"]
self.samhostname = self.confs._confs["samhostname"]
self.configure_sam_host(self.samhostname, self.samhostip)
elif self.server == "stage":
stage_name = self.confs._confs["stagename"]
self.configure_stage_host(stage_name)
elif self.server == "candlepin":
pass
else:
if self.server == "sam":
# Run by delivered param
self.samhostip = self.get_delivered_param("SAM_IP")
self.samhostname = self.get_delivered_param("SAM_HOSTNAME")
self.configure_sam_host(self.samhostname, self.samhostip)
elif self.server == "stage":
stage_name = self.get_delivered_param("STAGE_NAME")
self.configure_stage_host(stage_name)
elif self.server == "candlepin":
pass
def setUpModule():
print("整个文件开始时执行\n")
global driver_a, logger_a, conf_a
conf_a = Configs() # 实例化配置对象
driver_a = conf_a.getDriver() # 获得Driver
driver_a.implicitly_wait(20)
driver_a.maximize_window()
logger_a = Logs.getLogger() # 获得日志
def initialize_process(
): # pragma: no cover - This will be mocked in the tests an never runs.
'''Initializes the newly forked process'''
config_file_path = os.environ.get("BINARY_SKY_CONFIG_FILE")
logging_config_path = os.environ.get("BINARY_SKY_LOGGING_FILE")
Configs().load_configs(config_file_path)
Logger().load_configs(logging_config_path)
MemcachedDatabase().initialize()
def load_configs(current_directory):
from utils.configs import Configs
configs = Configs()
configs.load_configs(
os.path.join(current_directory, '..', 'sample_configs',
'tests.config'))
return configs
def initialize(self):
'''Initializes the database by setting required key-values.'''
self._hooks = []
mc = MemcachedConnection()
mc.config_connection(Configs().get_server_database_port())
mc_connection = mc.get_connection()
mc_connection.add("all_robots", [])
def setUp(self):
self.logger = Logs.getLogger()
self.conf = Configs()
self.driver = self.conf.getDriver() # 浏览器对象
self.base_url = self.conf.getURL() # 获取URL
self.driver.implicitly_wait(30)
self.driver.maximize_window()
self.verificationErrors = []
self.accept_next_alert = True
self.logger.info('初始化采购管理完成')
def __init__(self):
if (self.__initialized): return
self.__initialized = True
self.confs = Configs(RHSM_GUI_CONF)
self.server = self.confs._confs["server"]
if self.server == "sam":
self.configure_sam_host(self.confs._confs["samhostname"],
self.confs._confs["samhostip"])
elif self.server == "stage":
self.configure_stage_host(self.confs._confs["stage_name"])
elif self.server == "candlepin":
pass
def __init__(self):
self._world = World()
configs = Configs()
self._result = {
'world_size': '{0},{1}'.format(*self._world.get_size()),
'plant_max_age': configs.get_plant_max_age(),
'plant_matured_age': configs.get_plant_matured_age(),
'action_delay': configs.get_robots_actions_delay(),
'maximum_energy': configs.get_robots_maximum_energy(),
'birth_required_honor': configs.get_robots_birth_required_honor()
}
def __init__(self, in_test_data_catalog, sheet=0, title_line=True):
# 初始化测试用例数据根目录，精确到每个环境的根目录
conf = Configs()
self.file_path = conf.getDataPath()
excel_path = self.file_path + '\\' + in_test_data_catalog
if os.path.exists(excel_path):
self.excel = excel_path
else:
raise FileNotFoundError('文件不存在！')
self.sheet = sheet
self.title_line = title_line
self._data = list()
def test_not_enough_honor(self):
'''Tests a robot with few honors, trying to give birth.'''
population_control = PopulationControl()
database = MemcachedDatabase()
configs = Configs()
robot = database.get_robot(TestGiveBirth.ROBOT_ID, for_update=True)
robot.set_honor(configs.get_robots_birth_required_honor() - 1)
database.commit()
with self.assertRaises(NotEnoughHonorError):
population_control.execute_command("123", "give_birth",
[TestGiveBirth.ROBOT_ID])
database.rollback()
def __init__(self):
self._authenticator = Authenticator()
self._database = MemcachedDatabase()
configs = Configs()
self._robots_action_delay = configs.get_robots_actions_delay() / 1000
self._actions = {'status': StatusAction(),
'sense': SenseAction(),
'move': MoveAction(),
'plant': PlantAction(),
'pick_water': PickWaterAction(),
'info': InfoAction(),
'eat': EatAction(),
'water': WaterAction()}
def findReport(self):
print('寻找最新测试报告')
self.log.info('寻找最新测试报告')
# 找文件路径
conf = Configs() # 实例化配置对象
result_dir = conf.getReportPath() # 获取报告存放路径
lists = os.listdir(result_dir) # 获取目录中的所有文件列表
lists.sort(key=lambda fn: os.path.getatime(result_dir + "\\" + fn)
if not os.path.isdir(result_dir + "\\" + fn) else 0)
print('最新测试报告为：' + lists[-1])
self.log.info('已找到最新测试报告')
# 【os.path.join()】:join()方法用来连接字符串，通过路径与文件名的拼接，我们将得到目录下最新被创建的的文件名的完整路径。
file_new = os.path.join(result_dir, lists[-1]) # 获取最新文件的完整路径
self.log.info('已获取最新测试报告文件绝对路径')
print('最新测试报告路径为：', file_new)
return file_new
def test_info(self):
'''Test received information.'''
action = InfoAction()
world = World()
configs = Configs()
robot = Robot("test_info_action_1293", "123")
info = action.do_action(robot, [robot.get_id()])
self.assertEqual(info['world_size'],
'{0},{1}'.format(*world.get_size()))
self.assertEqual(info['plant_max_age'], configs.get_plant_max_age())
self.assertEqual(info['plant_matured_age'],
configs.get_plant_matured_age())
self.assertEqual(info['action_delay'],
configs.get_robots_actions_delay())
self.assertEqual(info['birth_required_honor'],
configs.get_robots_birth_required_honor())
class Logs(object):
"""只能创建为单例"""
__instance = None # 私有的类属性(instance:实例)
def __new__(cls):
if cls.__instance is None:
cls.__instance = object.__new__(cls)
return cls.__instance
else:
return cls.__instance # 返回上一次创建对象的引用
logger = None
# 日志级别
levels = {"n": logging.NOTSET,
"d": logging.DEBUG,
"i": logging.INFO,
"w": logging.WARN,
"e": logging.ERROR,
"c": logging.CRITICAL}
log_level = "d" # 设置最低日志级别
log_max_byte = 10 * 1024 * 1024 # 设定日志文件最大内存
log_backup_count = 5 # 当第一个文件写满后最大备份日志文件数
conf = Configs() # 创建配置对象
log_path = conf.getLogPath() # 获取不同环境下的日志路径
log_file = log_path + r'\scm_test.log'
@staticmethod
def getLogger():
if Logs.logger is not None:
return Logs.logger
Logs.logger = logging.Logger("oggingmodule.FinalLogger")
log_handler = logging.handlers.RotatingFileHandler(filename=Logs.log_file,
maxBytes=Logs.log_max_byte,
backupCount=Logs.log_backup_count,
encoding='UTF-8')
log_fmt = logging.Formatter("%(asctime)s-【scm测试日志 :--%(levelname)s :--%(message)s :--%(filename)s:%(lineno)d")
log_handler.setFormatter(log_fmt)
Logs.logger.addHandler(log_handler)
Logs.logger.setLevel(Logs.levels.get(Logs.log_level))
return Logs.logger
def test_eating_matured(self):
'''Tests when robot eat a matured plant.'''
world = World()
database = MemcachedDatabase()
action_manager = ActionManager()
plant = Plant()
plant.set_age(Configs().get_plant_matured_age() + 1)
world.plant(plant, TestEatAction.LOCATION)
database.commit()
robot = database.get_robot(TestEatAction.ROBOT_ID, for_update=True)
robot.set_energy(10)
database.commit()
action_manager.do_action("123", "eat", [TestEatAction.ROBOT_ID])
database.commit()
updated_robot = database.get_robot(TestEatAction.ROBOT_ID)
self.assertGreater(updated_robot.get_energy(), robot.get_energy())
def test_ok(self):
'''Tests a valid situation.'''
population_control = PopulationControl()
database = MemcachedDatabase()
configs = Configs()
robot = database.get_robot(TestGiveBirth.ROBOT_ID, for_update=True)
robot.set_honor(configs.get_robots_birth_required_honor() + 1)
database.commit()
new_password = population_control.execute_command(
"123", "give_birth", [TestGiveBirth.ROBOT_ID])
database.commit()
updated_robot = database.get_robot(TestGiveBirth.ROBOT_ID,
for_update=False)
self.assertEqual(updated_robot.get_honor(), 1)
self.assertTrue(isinstance(new_password, str))
self.assertEqual(len(new_password), 16)
def __init__(self, id, password, name=""):
super(Robot, self).__init__()
if not isinstance(name, str) or len(name) > MAX_ROBOT_NAME:
raise LongRobotNameError("Robot name cannot be longer than {0}".format(MAX_ROBOT_NAME))
configs = Configs()
self._id = id
self._name = name
self._alive = True
self._password = password
self._x = 0
self._y = 0
self._has_water = False
self._energy = configs.get_robots_initial_energy()
self._maximum_energy = configs.get_robots_maximum_energy()
self._life = configs.get_robots_initial_life()
self._honor = 0
self._last_executed_action_time = 0
def load_configs(config_file):
configs = Configs()
configs.load_configs(config_file)
return configs
import os
import torch
from torch import optim
from torch.utils.data import DataLoader
from utils.loss import HDRLoss
from utils.HDRutils import tonemap
from utils.dataprocessor import dump_sample
from dataset.HDR import KalantariTestDataset
from models.NHDRRNet import NHDRRNet
from utils.configs import Configs
# Get configurations
configs = Configs()
# Load dataset
test_dataset = KalantariTestDataset(configs=configs)
test_dataloader = DataLoader(test_dataset, batch_size=1, shuffle=True)
# Build NHDRRNet model from configs
model = NHDRRNet()
if configs.multigpu is False:
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model.to(device)
else:
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
if device == torch.device('cpu'):
raise EnvironmentError('No GPUs, cannot initialize multigpu training.')
model.to(device)
# Define optimizer
def __init__(self):
self._database = MemcachedDatabase()
self._configs = Configs()
def __init__(self):
# 得到相应截图目录
conf = Configs()
self.path = conf.getScreenshotPath()
def setUp(self):
self.log = Logs.getLogger()
self.verificationErrors = []
self.accept_next_alert = True
self.conf = Configs() # 创建配置对象
self.log.info('登录测试初始化完成')
def __exit__(self, *args):
# Setting back everything to their original values.
World._single_instance = self._original_world_instance
MemcachedDatabase._single_instance = self._original_database_instance
MemcachedConnection().config_connection(Configs().get_server_database_port())
self._memcached_process.terminate()
def test_robot_simulation(self):
'''This test simulates a full game scenario.'''
database = MemcachedDatabase()
world = World()
configs = Configs()
print()
print("Simulating a robot playing the game. This may take a while.")
# Creating a world for the robot to live in.
# The world map is:
#
# 000000
# 000222
# 000144
# 000144
row01 = [
MapSquare(MapSquareTypes.SOIL, (0, 30)),
MapSquare(MapSquareTypes.SOIL, (1, 30)),
MapSquare(MapSquareTypes.SOIL, (2, 30)),
MapSquare(MapSquareTypes.SOIL, (3, 30)),
MapSquare(MapSquareTypes.SOIL, (4, 30)),
MapSquare(MapSquareTypes.SOIL, (5, 30))
]
row02 = [
MapSquare(MapSquareTypes.SOIL, (0, 31)),
MapSquare(MapSquareTypes.SOIL, (1, 31)),
MapSquare(MapSquareTypes.SOIL, (2, 31)),
MapSquare(MapSquareTypes.ROCK, (3, 31)),
MapSquare(MapSquareTypes.ROCK, (4, 31)),
MapSquare(MapSquareTypes.ROCK, (5, 31))
]
row03 = [
MapSquare(MapSquareTypes.SOIL, (0, 32)),
MapSquare(MapSquareTypes.SOIL, (1, 32)),
MapSquare(MapSquareTypes.SOIL, (2, 32)),
MapSquare(MapSquareTypes.SAND, (3, 32)),
MapSquare(MapSquareTypes.WATER, (4, 32)),
MapSquare(MapSquareTypes.WATER, (5, 32))
]
row04 = [
MapSquare(MapSquareTypes.SOIL, (0, 33)),
MapSquare(MapSquareTypes.SOIL, (1, 33)),
MapSquare(MapSquareTypes.SOIL, (2, 33)),
MapSquare(MapSquareTypes.SAND, (3, 33)),
MapSquare(MapSquareTypes.WATER, (4, 33)),
MapSquare(MapSquareTypes.WATER, (5, 33))
]
database.add_square_row(row01)
database.add_square_row(row02)
database.add_square_row(row03)
database.add_square_row(row04)
# Creating parent of our robot.
parent_robot = Robot("parent_robot_1982.345", "123", name="Parent")
parent_robot.set_honor(configs.get_robots_birth_required_honor() + 1)
world.add_robot(parent_robot, (2, 31))
database.commit()
# Giving birth to our hero.
result = self.post_request({
'command': 'give_birth',
'password': '******',
'args': ["parent_robot_1982.345"]
})
self.assertEqual(result['status'], 200, result)
born_password = result['result']
# Robot requests a born.
result = self.post_request({
'command': 'born',
'password': born_password,
'args': [parent_robot.get_id()]
})
self.assertEqual(result['status'], 200)
robot_id = result['result']['robot_id']
password = result['result']['password']
# Getting status.
result = self.post_request({
'command': 'status',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
self.assertTrue(result['result']['alive'])
self.assertFalse(result['result']['has_water'])
self.assertEqual(result['result']['location'], "2,30")
# Moving somewhere to plan a corp.
# Note that parent robot is on the south. So, we have to turn around it.
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'W']
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'S']
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'S']
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'E']
})
self.assertEqual(result['status'], 200, result)
# We are at the location. Checking if its correct.
result = self.post_request({
'command': 'status',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
self.assertEqual(result['result']['location'], "2,32")
# Planting a corp here.
result = self.post_request({
'command': 'plant',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
# Checking if it is planted.
result = self.post_request({
'command': 'sense',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
self.assertEqual(result['result']['2,32']['surface_type'],
MapSquareTypes.SOIL)
self.assertIsNotNone(result['result']['2,32']['plant'])
# Going to pick water.
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'E']
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'E']
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'pick_water',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'status',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
self.assertTrue(result['result']['has_water'])
# Getting back to the plant location.
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'W']
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'W']
})
self.assertEqual(result['status'], 200, result)
# Watering
result = self.post_request({
'command': 'water',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
# Checking
result = self.post_request({
'command': 'sense',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
# It lost some water already.
self.assertGreater(result['result']['2,32']['plant']['water_level'],
70)
# Plant should be matured by now. Eating!
result = self.post_request({
'command': 'status',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
previous_energy = result['result']['energy']
result = self.post_request({
'command': 'eat',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'status',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 200, result)
self.assertGreater(result['result']['energy'], previous_energy)
# Now, trying some bad moves!
# Trying to plant on a sand.
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'E']
})
self.assertEqual(result['status'], 200, result)
result = self.post_request({
'command': 'plant',
'password': password,
'args': [robot_id]
})
self.assertEqual(result['status'], 500, result)
self.assertEqual(result['error_code'], 'CannotPlantHereError')
# Trying to move to a rock.
result = self.post_request({
'command': 'move',
'password': password,
'args': [robot_id, 'N']
})
self.assertEqual(result['status'], 500, result)
self.assertEqual(result['error_code'], 'LocationIsBlockedError')
def is_matured(self):
return (self._age >= Configs().get_plant_matured_age())
def __init__(self):
self._authenticator = Authenticator()
self._database = MemcachedDatabase()
self._world = World()
self._id_generator = IDGenerator()
self._configs = Configs()
def __init__(self):
super().__init__()
self._world = World()
self._plant_energy = Configs().get_plant_energy()
def __init__(self):
'''
Parse configure file
'''
self.confs = Configs(self.conf_file_name)
self.product_name = self.confs._confs["version"]
