# -*- coding: utf-8 -*-
# 测试用例
# 作者: 陈磊
# 时间: 2019-11-28


from __future__ import division

from WorkCase import CaseBase
from WorkUtils.UtilsLog import UtilsLog
from WorkUtils.UtilsDataBase import UtilsDataBase
from WorkUtils.UtilsResponse import UtilsResponse

from WorkData.Argus.hosts import DataHosts
from WorkData.Zabbix.interface import DataInterface

import allure
from WorkCase.APP import AppBase


@allure.feature("测试模块：device.create")
class TestDeviceCreate(object):
    log = UtilsLog()
    env = CaseBase().app_environment
    host = env["host"]
    db_url = env["db_url"]
    db_port = env["db_port"]
    db_user = env["db_user"]
    db_pw = env["db_pw"]
    db_base = env["db_base"]
    db_base_zabbix = env["db_base_zabbix"]

    login_name = "SS测试用户名"
    base_id = 10
    base_password = "123456"

    base_type_agent = 126
    base_type_snmp = 127
    base_ip = "172.16.3.170"
    base_dns = "sanshi.zmops.com"
    base_port = 161

    base_name = "SS 自动化专用"
    base_business_id_1 = "12"
    base_business_id_2 = "13"

    @classmethod
    def setup_class(cls):
        cls.log.debug("开始执行测试套件.......")
        session = UtilsDataBase().conn_mysql(db_url=cls.db_url, db_port=cls.db_port, db_base=cls.db_base, db_user=cls.db_user, db_pw=cls.db_pw)
        DataHosts().delete_like_host_name(session=session, host_name=cls.base_name)

    @classmethod
    def teardown_class(cls):
        cls.log.debug("结束执行测试套件.......")

    def setup_method(self):
        self.log.debug("测试用例执行开始...")

        self.app = AppBase(host=self.host)
        self.app.update_members_del_flag(session=self.db_session(), members_id=self.base_id, value=CaseBase().del_flag["OFF"])
        self.app.update_members_status(session=self.db_session(), members_id=self.base_id, value=CaseBase().status["ON"])
        self.token = self.app.get_base_token(login_name=self.login_name, base_password=self.base_password)

    def teardown_method(self):
        self.log.debug("测试用例执行结束...")
        self.app.update_members_del_flag(session=self.db_session(), members_id=self.base_id, value=CaseBase().del_flag["OFF"])
        self.app.update_members_status(session=self.db_session(), members_id=self.base_id, value=CaseBase().status["ON"])

    @allure.step("连接数据库：Argus")
    def db_session(self):
        session = UtilsDataBase().conn_mysql(db_url=self.db_url, db_port=self.db_port, db_base=self.db_base, db_user=self.db_user, db_pw=self.db_pw)
        return session

    @allure.step("连接数据库：Zabbix")
    def db_session_zabbix(self):
        session = UtilsDataBase().conn_mysql(db_url=self.db_url, db_port=self.db_port, db_base=self.db_base_zabbix, db_user=self.db_user, db_pw=self.db_pw)
        return session

    @allure.step("查询表：hosts")
    def select_hosts(self, hostid=None, host_name=None, available=None, monitor_status=None):
        session = self.db_session()
        sql = DataHosts().select_all_from_allKeys(session=session, hostid=hostid, host_name=host_name, available=available, monitor_status=monitor_status)
        return sql

    @allure.step("查询表：interface")
    def select_interface(self, hostid=None):
        session = self.db_session_zabbix()
        sql = DataInterface().select_all_from_allKeys(session=session, hostid=hostid)
        return sql

    @allure.step("校验Zabbix接口数据")
    def check_interface(self, host_id, _type, useip, ip, dns, port):
        sql = self.select_interface(hostid=host_id)
        assert sql != []
        for x, y in enumerate(sql):
            assert y.main == 1
            assert y.type == _type
            assert y.useip == useip
            assert y.ip == ip
            assert y.dns == dns
            assert y.port == str(port)
            assert x == 0

    @allure.step("校验查询结果")
    def check_select(self, response, name, manage_ip, manage_level, host_type, parent_host,
                     monitor_status, iplist, dns, monitor_interface, ops_person, factoryId,
                     model, version, serialnumber, description, snmp_community, ipmi_authtype, ipmi_privilege,
                     ipmi_username, ipmi_password, businessIds, hostTypeTree, businessTree):
        data = UtilsResponse().get_data(response=response)
        sql = self.select_hosts(hostid=data)
        assert sql != []
        for x, y in enumerate(sql):
            assert y.host_name == name
            assert y.asset_code != ""
            assert y.manage_ip == manage_ip
            # assert y.departmentid == departmentid
            assert y.manage_level == manage_level
            assert y.host_type == host_type
            assert y.parent_host == parent_host
            # assert y.available == available
            assert y.monitor_status == monitor_status
            assert y.iplist == iplist
            assert y.dns == dns
            assert int(y.monitor_interface) == monitor_interface
            assert y.business_ids == businessIds
            assert y.host_type_tree == hostTypeTree
            assert y.business_tree == businessTree
            # assert y.port == port
            assert y.ops_person == ops_person
            assert y.factory_id == factoryId
            assert y.model == model
            assert y.version == version
            assert y.serialnumber == serialnumber
            assert y.description == description
            assert y.snmp_community == snmp_community
            assert y.ipmi_authtype == ipmi_authtype
            assert y.ipmi_privilege == ipmi_privilege
            assert y.ipmi_username == ipmi_username
            assert y.ipmi_password == ipmi_password
            assert x == 0

    @allure.step("校验查询结果")
    def check_monitor_type(self, response, name, monitor_type):
        data = UtilsResponse().get_data(response=response)
        sql = self.select_hosts(hostid=data)
        assert sql != []
        for x, y in enumerate(sql):
            assert y.host_name == name
            assert y.monitor_type == monitor_type

    @allure.title("device.create：token未传")
    @allure.story("创建资产：token未传")
    @allure.severity("blocker")
    def test_case_01(self):
        response = self.app.device_create()
        self.app.check_code(response=response, code=2001)
        self.app.check_msg(response=response, msg="无token，请重新登录")

    @allure.title("device.create：token的用户已删除")
    @allure.story("创建资产：token的用户已删除")
    @allure.severity("blocker")
    def test_case_02(self):
        self.app.update_members_del_flag(session=self.db_session(), members_id=self.base_id, value=CaseBase().del_flag["ON"])
        response = self.app.device_create(token=self.token)
        self.app.check_code(response=response, code=2004)
        self.app.check_msg(response=response, msg="用户不存在")

    @allure.title("device.create：token的用户已禁用")
    @allure.story("创建资产：token的用户已禁用")
    @allure.severity("blocker")
    def test_case_03(self):
        self.app.update_members_status(session=self.db_session(), members_id=self.base_id, value=CaseBase().status["OFF"])
        response = self.app.device_create(token=self.token)
        self.app.check_code(response=response, code=2003)
        self.app.check_msg(response=response, msg="账户已被禁用")

    @allure.title("device.create：创建agent资产,ip识别")
    @allure.story("创建资产：创建agent资产,ip识别")
    @allure.severity("blocker")
    def test_case_04(self):
        name = self.base_name + "04"
        response = self.app.device_create(token=self.token, hostName=name, hostType=self.base_type_agent,
                                          iplist=self.base_ip, monitorInterface=self.base_port,
                                          monitorType=1, manageLevel=1)
        host_id = UtilsResponse().get_data(response=response)
        self.app.check_code(response=response, code=0)
        self.check_monitor_type(response=response, name=name, monitor_type=1)
        self.check_interface(host_id=host_id, _type=1, useip=1, ip=self.base_ip, dns="", port=self.base_port)

    @allure.title("device.create：创建agent资产,dns识别")
    @allure.story("创建资产：创建agent资产,dns识别")
    @allure.severity("blocker")
    def test_case_05(self):
        name = self.base_name + "05"
        response = self.app.device_create(token=self.token, hostName=name, hostType=self.base_type_agent,
                                          dns=self.base_dns,
                                          monitorInterface=self.base_port, monitorType=2, manageLevel=1)
        host_id = UtilsResponse().get_data(response=response)
        self.app.check_code(response=response, code=0)
        self.check_monitor_type(response=response, name=name, monitor_type=2)
        self.check_interface(host_id=host_id, _type=1, useip=0, ip="", dns=self.base_dns, port=self.base_port)

    @allure.title("device.create：创建snmp资产,ip识别")
    @allure.story("创建资产：创建snmp资产,ip识别")
    @allure.severity("blocker")
    def test_case_06(self):
        name = self.base_name + "06"
        response = self.app.device_create(token=self.token, hostName=name, hostType=self.base_type_snmp,
                                          iplist=self.base_ip, monitorInterface=self.base_port,
                                          monitorType=1, manageLevel=1)
        host_id = UtilsResponse().get_data(response=response)
        self.app.check_code(response=response, code=0)
        self.check_monitor_type(response=response, name=name, monitor_type=1)
        self.check_interface(host_id=host_id, _type=2, useip=1, ip=self.base_ip, dns="", port=self.base_port)

    @allure.title("device.create：创建snmp资产,dns识别")
    @allure.story("创建资产：创建snmp资产,dns识别")
    @allure.severity("blocker")
    def test_case_07(self):
        name = self.base_name + "07"
        response = self.app.device_create(token=self.token, hostName=name, hostType=self.base_type_snmp,
                                          dns=self.base_dns,
                                          monitorInterface=self.base_port, monitorType=2, manageLevel=1)
        host_id = UtilsResponse().get_data(response=response)
        self.app.check_code(response=response, code=0)
        self.check_monitor_type(response=response, name=name, monitor_type=2)
        self.check_interface(host_id=host_id, _type=2, useip=0, ip="", dns=self.base_dns, port=self.base_port)

    @allure.title("device.create：创建资产-所有字段")
    @allure.story("创建资产：创建资产-所有字段")
    def test_case_08(self):
        name = self.base_name + "08"
        response = self.app.device_create(token=self.token, hostName=name, hostType=self.base_type_agent,
                                          iplist=self.base_ip, monitorInterface=self.base_port,
                                          monitorType=1, manageLevel=1, parentHost=1,
                                          businessIds=self.base_business_id_1 + "," + self.base_business_id_2,
                                          hostTypeTree="hostTypeTree",
                                          businessTree="businessTree",
                                          opsPerson=11, snmpCommunity="snmpCommunity",
                                          ipmiAuthtype=1, ipmiPrivilege=1, ipmiUsername="ipmiUsername", ipmiPassword="ipmiPassword",
                                          factoryId=1, model="model", version="version", serialnumber="serialnumber", description="description",
                                          monitorStatus=1)
        self.app.check_code(response=response, code=0)
        self.check_select(response=response, name=name, manage_ip=self.base_ip, manage_level=1, host_type=self.base_type_agent, monitor_status=1,
                          iplist=self.base_ip, dns=None, monitor_interface=self.base_port, ops_person=11, snmp_community="snmpCommunity",
                          ipmi_authtype=1, ipmi_privilege=1, ipmi_username="ipmiUsername", ipmi_password="ipmiPassword", parent_host=1,
                          factoryId=1, model="model", version="version", serialnumber="serialnumber", description="description",
                          businessIds=self.base_business_id_1 + "," + self.base_business_id_2,
                          hostTypeTree="hostTypeTree",
                          businessTree="businessTree")


if __name__ == "__main__":
    from WorkUtils.UtilsPyTest import UtilsPyTest
    from WorkUtils.UtilsCmd import UtilsCmd

    import os

    # 执行自动化测试用例
    case_info = os.path.split(__file__)
    case = UtilsCmd().pytest_cmd()
    r = UtilsPyTest(case=case, case_info=case_info)
    r.run_main()

    # a = TestDeviceCreate()
    # a.setup_class()
    # a.setup_method()
    # a.test_case_04()
