olctest base on pytest driver

秒速五厘米 2021-12-01 15:16 453阅读 0赞

MyDemo for pytest driver

  1. #!/usr/bin/env python3
  3. import json
  4. import binascii
  5. import asn1tools
  6. import paho.mqtt.client as mqtt
  7. import requests
  8. import logging
  9. import serial
  10. import threading
  11. import time
  12. import datetime
  13. import random
  14. from enum import Enum
  15. from queue import Queue
  18. class ResponseCode(Enum):
  19.     CREATED = 2 << 5 | 1
  20.     DELETED = 2 << 5 | 2
  21.     VALID = 2 << 5 | 3
  22.     CHANGED = 2 << 5 | 4
  23.     CONTENT = 2 << 5 | 5
  24.     CONTINUE = 2 << 5 | 31
  26.     BAD_REQUEST = 4 << 5 | 0
  27.     UNAUTHORIZED = 4 << 5 | 1
  28.     BAD_OPTION = 4 << 5 | 2
  29.     FORBIDDEN = 4 << 5 | 3
  30.     NOT_FOUND = 4 << 5 | 4
  31.     METHOD_NOT_ALLOWED = 4 << 5 | 5
  32.     NOT_ACCEPTABLE = 4 << 5 | 6
  33.     REQUEST_ENTITY_INCOMPLETE = 4 << 5 | 8
  34.     CONFLICT = 4 << 5 | 9
  35.     PRECONDITION_FAILED = 4 << 5 | 12
  36.     REQUEST_ENTITY_TOO_LARGE = 4 << 5 | 13
  37.     UNSUPPORTED_CONTENT_FORMAT = 4 << 5 | 15
  38.     UNPROCESSABLE_ENTITY = 4 << 5 | 22
  40.     INTERNAL_SERVER_ERROR = 5 << 5 | 0
  41.     NOT_IMPLEMENTED = 5 << 5 | 1
  42.     BAD_GATEWAY = 5 << 5 | 2
  43.     SERVICE_UNAVAILABLE = 5 << 5 | 3
  44.     GATEWAY_TIMEOUT = 5 << 5 | 4
  45.     PROXY_NOT_SUPPORTED = 5 << 5 | 5
  48. class CoapMessage:
  50.     def load(self, dict_obj):
  51.         for p in self.__dict__:
  52.             if p == 'block2' and dict_obj[p] is not None:
  53.                 bob = BlockOptionBean()
  54.                 bob.load(dict_obj[p])
  55.                 self.__dict__[p] = bob
  56.             else:
  57.                 self.__dict__[p] = dict_obj[p]
  59.     def __str__(self):
  60.         attrs = ", ".join("{}={}".format(k, getattr(self, k)) for k in self.__dict__.keys())
  61.         return "[{}: {}]".format(self.__class__.__name__, attrs)
  64. class RequestBean(CoapMessage):
  66.     def __init__(self):
  67.         self.type = None
  68.         self.code = None
  69.         self.url = None
  70.         self.contentFormat = None
  71.         self.payload = None
  72.         self.block2 = None
  75. class ResponseBean(CoapMessage):
  77.     def __init__(self):
  78.         self.code = None
  79.         self.contentFormat = None
  80.         self.payload = None
  81.         self.block2 = None
  84. class BlockOptionBean(CoapMessage):
  86.     def __init__(self):
  87.         self.szx = None
  88.         self.m = None
  89.         self.num = None
  92. class TriggerTool:
  94.     def trigger(self):
  95.         pass
  98. class UartTriggerTool:
  100.     def __init__(self, uart):
  101.         self.uart = uart
  103.     def trigger(self):
  104.         logging.debug('uart trigger sync')
  105.         self.uart.send('')
  106.         time.sleep(1)
  107.         self.uart.send('sync')
  110. class HttpTriggerTool:
  112.     def trigger(self):
  113.         logging.debug('trigger sync')
  114.         url = 'http://127.0.0.1:18000/api/v1/simulator/sms'
  115.         requests.post(url, 'test sms tirggered.')
  118. class ManualTriggerTool:
  120.     def __init__(self, timeout):
  121.         self.timeout = timeout
  123.     def trigger(self):
  124.         logging.info('please trigger the sync within %d seconds.' % self.timeout)
  125.         time.sleep(self.timeout + 2)
  128. class SerialTool:
  129.     encoding = 'ascii'
  130.     error_policy = 'ignore'
  132.     def __init__(self, port, baud, logfile):
  133.         self.port = port
  134.         self.baud = baud
  135.         self.logfile = logfile
  136.         self.terminated = None
  137.         self.serial = None
  138.         self._thread = None
  140.     def loop(self):
  141.         self.serial = serial.Serial(self.port, self.baud)
  142.         logging.info('serial open status is %s' % self.serial.is_open)
  143.         f = open(self.logfile, 'a')
  144.         while not self.terminated:
  145.             try:
  146.                 text = self.serial.readline()
  147.                 text = str(text, encoding=self.encoding, errors=self.error_policy)
  148.                 text = text.replace("\r", '')
  149.                 text = text.replace("\n", '')
  150.                 text = '%s -- %s\n' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S %f'), text)
  151.                 f.write(text)
  152.                 f.flush()
  153.             except BaseException as e:
  154.                 logging.error('serial thread: %s' % e)
  155.         f.close()
  156.         self.serial.close()
  157.         self.serial = None
  159.     def loop_start(self):
  160.         if self._thread is None:
  161.             self.terminated = False
  162.             self._thread = threading.Thread(target=self.loop)
  163.             self._thread.daemon = True
  164.             self._thread.start()
  166.     def loop_stop(self):
  167.         if self._thread is not None:
  168.             self.terminated = True
  169.             self.serial.cancel_read()
  170.             if threading.current_thread() != self._thread:
  171.                 self._thread.join()
  172.                 self._thread = None
  174.     def send(self, text):
  175.         if self.serial is not None and self.serial.is_open:
  176.             text = text + "\r"
  177.             text = text.encode(encoding=self.encoding, errors=self.error_policy)
  178.             self.serial.write(text)
  179.         else:
  180.             logging.error('serial port is not opened.')
  183. class MqttTool:
  185.     def __init__(self, host, port, qos, timeout):
  186.         self.host = host
  187.         self.port = port
  188.         self.qos = qos
  189.         self.queue = Queue()
  190.         self.mqtt_client = None
  191.         self.timeout = timeout
  193.     def on_message(self, client, userdata, msg):
  194.         logging.debug('get a message: %s' % msg)
  195.         self.queue.put(msg)
  197.     def subscribe(self, topic):
  198.         self.mqtt_client.subscribe(topic, self.qos)
  199.         logging.debug('subscribe to %s' % topic)
  201.     def unsubscribe(self, topic):
  202.         self.mqtt_client.unsubscribe(topic)
  203.         logging.debug('unsubscribe %s' % topic)
  205.     def receive_msg(self, timeout=None):
  206.         logging.debug('waiting for message.')
  207.         if timeout is None:
  208.             timeout = self.timeout
  209.         return self.queue.get(timeout=timeout)
  211.     def publish(self, topic, blob):
  212.         self.mqtt_client.publish(topic, blob)
  214.     def loop_start(self):
  215.         if self.mqtt_client is None:
  216.             self.mqtt_client = mqtt.Client()
  217.             self.mqtt_client.on_message = self.on_message
  218.             self.mqtt_client.connect(self.host, self.port, self.timeout)
  219.             self.mqtt_client.loop_start()
  221.     def loop_stop(self):
  222.         if self.mqtt_client is not None:
  223.             self.mqtt_client.loop_stop()
  224.             self.mqtt_client.disconnect()
  225.             self.mqtt_client = None
  228. class ParserTool:
  229.     scheme_file = 'ctc-message-schema.asn1',
  230.     codec = 'uper'
  232.     def __init__(self):
  233.         self.asn1compiler = asn1tools.compile_files(self.scheme_file, self.codec)
  234.         self.obj_names = {
  235.     'POST /s/2': ('SyncRequest', 'SyncResponse2'),
  236.                           'GET /s/2': ('', 'SyncResponse2')}
  238.     def serialize(self, obj):
  239.         if isinstance(obj, ResponseCode):
  240.             return obj.name
  241.         else:
  242.             return obj.__dict__
  244.     def asn1_encode(self, name, bean):
  245.         return self.asn1compiler.encode(name, bean, check_constraints=True)
  247.     def asn1_decode(self, name, blob):
  248.         return self.asn1compiler.decode(name, blob, check_constraints=True)
  250.     def get_resource_path(self, request_bean):
  251.         url = request_bean.url
  252.         if url.startswith('coaps'):
  253.             url = url[8:]
  254.         i = url.index('/')
  255.         return url[i:]
  257.     def get_obj_path(self, resource_path):
  258.         tmp = resource_path.split('/')
  259.         if len(tmp) == 4:
  260.             return '/%s/%s/_/%s' % (tmp[1], tmp[2], tmp[3])
  261.         return resource_path
  263.     def get_obj_name(self, code, path):
  264.         key = '%s %s' % (code, path)
  265.         return self.obj_names[key]
  267.     def decode_request_payload(self, request_bean):
  268.         if request_bean.payload is not None and len(request_bean.payload) > 0:
  269.             path = self.get_resource_path(request_bean)
  270.             path = self.get_obj_path(path)
  271.             names = self.get_obj_name(request_bean.code, path)
  272.             asnobj = self.asn1_decode(names[0], binascii.a2b_base64(request_bean.payload))
  273.             logging.info('request asn1: %s' % asnobj)
  274.             return asnobj
  276.     def decode_request(self, mqtt_message):
  277.         obj = json.loads(mqtt_message.payload.decode('utf-8'))
  278.         req = RequestBean()
  279.         req.load(obj)
  280.         return req
  282.     def encode_response_payload(self, name, bean):
  283.         logging.info('response asn1: %s' % bean)
  284.         s = self.asn1_encode(name, bean)
  285.         return s
  287.     def encode_response(self, response_bean):
  288.         data = json.dumps(response_bean, ensure_ascii=True, default=self.serialize)
  289.         return bytes(data, 'utf-8')
  292. class BaseClient:
  293.     APPLICATION_OCTET_STREAM = 42
  294.     TOPIC_PREFIX = 'olc'
  296.     def __init__(self, trigger, mqclient, timeout, identity):
  297.         self.parser = ParserTool()
  298.         self.trigger = trigger
  299.         self.mqclient = mqclient
  300.         self.timeout = timeout
  301.         self.identity = identity
  302.         identity = binascii.hexlify(identity.encode(encoding='utf-8'))
  303.         identity = identity.decode()
  304.         self.topic_request = '/%s/%s/request' % (self.TOPIC_PREFIX, identity)
  305.         self.topic_reqponse = '/%s/%s/response' % (self.TOPIC_PREFIX, identity)
  306.         self.mqclient.subscribe(self.topic_request)
  308.     def random_data(self, len):
  309.         tmp = []
  310.         for i in range(len):
  311.             tmp.append(random.randint(0, 255))
  312.         return bytes(tmp)
  314.     def get_seconds_20000101(self, dt=None):
  315.         if dt is None:
  316.             dt = datetime.datetime.now()
  317.         s = (dt - datetime.datetime(2000, 1, 1, 0, 0, 0)).total_seconds()
  318.         return int(s)
  320.     def send_resp(self, code, data=None, block2=None):
  321.         resp = ResponseBean()
  322.         resp.code = code
  323.         if data is not None:
  324.             resp.contentFormat = self.APPLICATION_OCTET_STREAM
  325.             data = binascii.b2a_base64(data)
  326.             data = str(data, 'utf-8')
  327.             data = data.replace('\n', '').replace('\r', '')
  328.             resp.payload = data
  329.         if block2 is not None:
  330.             resp.block2 = block2
  331.         logging.info('send response: %s' % resp)
  332.         blob = self.parser.encode_response(resp)
  333.         self.mqclient.publish(self.topic_reqponse, blob)
  335.     def send_resp_bean(self, code, name, bean):
  336.         data = self.parser.encode_response_payload(name, bean)
  337.         return self.send_resp(code, data)
  339.     def send_resp_block2(self, code, data, m, szx, num):
  340.         bob = BlockOptionBean()
  341.         bob.m = m
  342.         bob.szx = szx
  343.         bob.num = num
  344.         return self.send_resp(code, data, bob)
  346.     def send_resp_sync(self, resource, sr, seconds=None):
  347.         if seconds is None:
  348.             seconds = self.get_seconds_20000101()
  349.         resp = {
  350.     'resourcePaths': resource, 'revision': sr, 'currentUtcTime': {
  351.     'secondsSince20000101': seconds}}
  352.         self.send_resp_bean(code=ResponseCode.CONTENT, name='SyncResponse2', bean=resp)
  354.     def receive_req(self, timeout=None):
  355.         if timeout is None:
  356.             timeout = self.timeout
  357.         msg = self.mqclient.receive_msg(timeout)
  358.         req = self.parser.decode_request(msg)
  359.         logging.info('receive request: %s' % req)
  360.         return req
  362.     def do_resource_sync(self, resource, sr=None):
  363.         self.trigger.trigger()
  364.         while True:
  365.             req = self.receive_req()
  366.             if req.url.endswith('/s/2') and req.code == 'POST':
  367.                 if sr is None:
  368.                     asnobj = self.parser.decode_request_payload(req)
  369.                     sr = int(asnobj['revision']) + 1
  370.                 self.send_resp_sync(resource, sr)
  371.                 return sr
  372.             elif req.url.endswith('/s/2') and req.code == 'GET' and sr is not None:
  373.                 self.send_resp_sync(resource, sr)
  374.                 return sr
  376.     def do_empty_sync(self, sr=None):
  377.         return self.do_resource_sync(resource=[], sr=sr)
  379.     def test_case(self):
  380.         pass
  383. class PostSyncClient(BaseClient):
  385.     def __init__(self, trigger, mqclient, timeout, identity, res_paths, res_responses):
  386.         super().__init__(trigger, mqclient, timeout, identity)
  387.         self.res_paths = res_paths
  388.         self.res_responses = res_responses
  389.         self.res_count = None
  391.     def test_case(self):
  392.         time.sleep(2)
  393.         sr = 0
  394.         state = 100
  395.         self.res_count = 0
  396.         while True:
  397.             if state == 100:
  398.                 self.trigger.trigger()
  399.                 state = 200
  400.             elif state == 200:
  401.                 req = self.receive_req()
  402.                 if req.url.endswith('/s/2') and req.code == 'POST':
  403.                     asnobj = self.parser.decode_request_payload(req)
  404.                     sr = int(asnobj['revision']) + 1
  405.                     self.send_resp_sync(self.res_paths, sr)
  406.                     state = 300
  407.             elif state == 300:
  408.                 req = self.receive_req()
  409.                 if req.url.endswith('/s/2') and req.code == 'POST':
  410.                     self.parser.decode_request_payload(req)
  411.                     self.send_resp_sync([], sr)
  412.                     state = 400
  413.                 else:
  414.                     for p in self.res_responses:
  415.                         if req.url.endswith(p):
  416.                             code = self.res_responses[p][0]
  417.                             name = self.res_responses[p][1]
  418.                             resp = self.res_responses[p][2]
  419.                             if code is None:
  420.                                 raise Exception("the response code shouldn't be none")
  421.                             if code in (ResponseCode.CONTENT, ResponseCode.CREATED, ResponseCode.CHANGED,
  422.                                         ResponseCode.DELETED, ResponseCode.VALID, ResponseCode.CONTINUE):
  423.                                 if isinstance(resp, dict):
  424.                                     self.send_resp_bean(code=code, name=name, bean=resp)
  425.                                 elif isinstance(resp, bytes) or isinstance(resp, bytearray):
  426.                                     self.send_resp(code=code, data=resp)
  427.                             else:
  428.                                 self.send_resp(code=code)
  429.                             self.res_count += 1
  430.                         else:
  431.                             logging.error('unknown resource request %s' % req.url)
  432.             elif state == 400:
  433.                 # consume report log messages.
  434.                 flag = True
  435.                 try:
  436.                     req = self.receive_req()
  437.                 except:
  438.                     logging.debug('finished')
  439.                     flag = False
  440.                     state = 500
  441.                 if flag:
  442.                     self.parser.decode_request_payload(req)
  443.                     logging.info('receive report bean: %s' % req)
  444.                     self.send_resp(code=ResponseCode.CONTENT)
  445.             elif state == 500:
  446.                 time.sleep(60)
  447.                 break
  450. class OtaClient(BaseClient):
  452.     def __init__(self, trigger, mqclient, timeout, identity, filename):
  453.         super().__init__(trigger, mqclient, timeout, identity)
  454.         self.bin = None
  455.         self.rr = binascii.hexlify(self.random_data(20))
  457.     def read_file(self, filename):
  458.         with open(filename, 'rb') as f:
  459.             self.bin = f.read()
  460.             f.close()
  462.     def handle_blocks(self, req):
  463.         if req.url.endswith('/p/fu/%s/0' % self.rr) and req.code == 'GET':
  464.             if req.block2 is not None:
  465.                 return True
  466.             else:
  467.                 logging.error('block2 is not found')
  468.                 self.send_resp(ResponseCode.REQUEST_ENTITY_INCOMPLETE)
  469.                 return False
  471.     def handle_block0(self, req):
  472.         if self.handle_blocks(req):
  473.             if req.block2.num == 0:
  474.                 sz = 1 << (req.block2.szx + 4)
  475.                 data = self.bin[:sz]
  476.                 pass
  477.         return False
  479.     def test_case(self):
  480.         time.sleep(2)
  481.         state = 100
  482.         sr = None
  483.         while True:
  484.             if state == 100:
  485.                 sr = self.do_resource_sync(['/p/fu/%s' % self.rr])
  486.                 state = 300
  487.             elif state == 300:
  488.                 req = self.receive_req()
  489.                 if req.url.endswith('/p/fu/%s/0' % self.rr) and req.code == 'GET':
  490.                     if req.block2 is None:
  491.                         logging.error('block2 is not found')
  492.                         self.send_resp(ResponseCode.REQUEST_ENTITY_INCOMPLETE)
  493.                     else:
  494.                         sz = 1 << (req.block2.szx + 4)
  495.                         a = sz * req.block2.num
  496.                         b = a + sz
  497.                         last_num = (len(self.bin) + sz - 1) / sz
  498.                         if a >= len(self.bin):
  499.                             logging.error('the data range [%d:%d] is out of file length. ' % (a, b))
  500.                             self.send_resp(ResponseCode.REQUEST_ENTITY_TOO_LARGE)
  501.                         else:
  502.                             if b >= self.bin[a:b]:
  503.                                 data = self.bin[a:]
  504.                             else:
  505.                                 data = self.bin[a:b]
  506.                             self.send_resp_block2(ResponseCode.CONTENT, data=data, m=req.block2.num < last_num, szx=req.block2.szx,
  507.                                                   num=req.block2.num)
  508.                 elif req.url.endswith('/s/2') and req.code == 'POST':
  509.                     self.parser.decode_request_payload(req)
  510.                     self.send_resp_sync([], sr)
  511.                 elif req.url.endswith('/s/2') and req.code == 'GET':
  512.                     self.send_resp_sync(['/p/fu/%s' % self.rr], sr)
  513.                 elif req.url.endswith('/p/fs/0') and req.code == 'POST':
  514.                     self.parser.decode_request_payload(req)
  515.                     break
  518. class UnhappySyncClient(BaseClient):
  520.     def __init__(self, trigger, mqclient, timeout, identity, error_code):
  521.         super().__init__(trigger, mqclient, timeout, identity)
  522.         self.error_code = error_code
  524.     def test_case(self):
  525.         time.sleep(2)
  526.         self.trigger.trigger()
  527.         while True:
  528.             req = self.receive_req()
  529.             if req.url.endswith('/s/2') and req.code == 'POST':
  530.                 self.parser.decode_request_payload(req)
  531.                 self.send_resp(code=self.error_code)
  532.                 time.sleep(60)
  533.                 break
  536. class NilSyncClient(BaseClient):
  538.     def __init__(self, trigger, mqclient, timeout, identity):
  539.         super().__init__(trigger, mqclient, timeout, identity)
  541.     def test_case(self):
  542.         time.sleep(2)
  543.         self.trigger.trigger()
  544.         while True:
  545.             req = self.receive_req()
  546.             if req.url.endswith('/s/2') and req.code == 'POST':
  547.                 self.parser.decode_request_payload(req)
  548.                 self.send_resp(code=ResponseCode.CONTENT)
  549.                 time.sleep(60)
  550.                 break
  553. class WrongSyncClient(BaseClient):
  555.     def __init__(self, trigger, mqclient, timeout, identity):
  556.         super().__init__(trigger, mqclient, timeout, identity)
  558.     def test_case(self):
  559.         time.sleep(2)
  560.         self.trigger.trigger()
  561.         while True:
  562.             req = self.receive_req()
  563.             if req.url.endswith('/s/2') and req.code == 'POST':
  564.                 self.parser.decode_request_payload(req)
  565.                 self.send_resp_bean(code=ResponseCode.CONTENT, name='Override', bean={
  566.     'nominalLightLevel': 10000, 'enabled': 1})
  567.                 time.sleep(60)
  568.                 break
  571. class MessySyncClient(BaseClient):
  573.     def __init__(self, trigger, mqclient, timeout, identity):
  574.         super().__init__(trigger, mqclient, timeout, identity)
  576.     def test_case(self):
  577.         time.sleep(2)
  578.         self.trigger.trigger()
  579.         while True:
  580.             req = self.receive_req()
  581.             if req.url.endswith('/s/2') and req.code == 'POST':
  582.                 self.parser.decode_request_payload(req)
  583.                 data = self.random_data(20)
  584.                 self.send_resp(code=ResponseCode.CONTENT, data=data)
  585.                 time.sleep(60)
  586.                 break
  589. class ExtremitySyncClient(BaseClient):
  591.     def __init__(self, trigger, mqclient, timeout, identity, bean):
  592.         super().__init__(trigger, mqclient, timeout, identity)
  593.         self.bean = bean
  594.         self.res_cnt = None
  595.         self.res_abn_cnt = None
  597.     def test_case(self):
  598.         time.sleep(2)
  599.         state = 100
  600.         self.res_cnt = 0
  601.         self.res_abn_cnt = 0
  602.         while True:
  603.             if state == 100:
  604.                 self.trigger.trigger()
  605.                 state = 200
  606.             elif state == 200:
  607.                 req = self.receive_req()
  608.                 if req.url.endswith('/s/2') and req.code == 'POST':
  609.                     asnobj = self.parser.decode_request_payload(req)
  610.                     if self.bean['revision'] < 0:
  611.                         self.bean['revision'] = int(asnobj['revision']) + 1
  612.                     self.send_resp_bean(code=ResponseCode.CONTENT, name='SyncResponse2', bean=self.bean)
  613.                     if len(self.bean['resourcePaths']) == 0:
  614.                         state = 300
  615.                     else:
  616.                         state = 250
  617.             elif state == 250:
  618.                 req = self.receive_req()
  619.                 if req.url.endswith('/s/2') and req.code == 'POST':
  620.                     asnobj = self.parser.decode_request_payload(req)
  621.                     sr = int(asnobj['revision'])
  622.                     self.send_resp_sync([], sr)
  623.                     state = 300
  624.                 else:
  625.                     flag = False
  626.                     for r in self.bean['resourcePaths']:
  627.                         if r in req.url:
  628.                             self.send_resp(ResponseCode.NOT_FOUND)
  629.                             self.res_cnt += 1
  630.                             flag = True
  631.                     if not flag:
  632.                         logging.error('unkown resource path %s' % req.url)
  633.                         self.res_abn_cnt += 1
  634.             elif state == 300:
  635.                 time.sleep(60)
  636.                 break
  639. class CaseSuites:
  641.     def __init__(self, mqclient, trigger, timeout, identity):
  642.         self.mqclient = mqclient
  643.         self.trigger = trigger
  644.         self.timeout = timeout
  645.         self.identity = identity
  647.         self.basis = BaseClient(trigger=self.trigger,
  648.                                 mqclient=self.mqclient,
  649.                                 timeout=self.timeout,
  650.                                 identity=self.identity)
  652.         self.ov_client = PostSyncClient(trigger=self.trigger,
  653.                                         mqclient=self.mqclient,
  654.                                         timeout=self.timeout,
  655.                                         identity=self.identity,
  656.                                         res_paths=[],
  657.                                         res_responses={})
  658.         self.ov_revision = 1
  660.         self.ota_client = OtaClient(trigger=self.trigger,
  661.                                     mqclient=self.mqclient,
  662.                                     timeout=self.timeout,
  663.                                     identity=self.identity,
  664.                                     filename='aaa.bin')
  666.         self.unhappysync = UnhappySyncClient(trigger=self.trigger,
  667.                                              mqclient=self.mqclient,
  668.                                              timeout=self.timeout,
  669.                                              identity=self.identity,
  670.                                              error_code=None)
  672.         self.emptysync = NilSyncClient(trigger=self.trigger,
  673.                                        mqclient=self.mqclient,
  674.                                        timeout=self.timeout,
  675.                                        identity=self.identity)
  677.         self.wrongsync = WrongSyncClient(trigger=self.trigger,
  678.                                          mqclient=self.mqclient,
  679.                                          timeout=self.timeout,
  680.                                          identity=self.identity)
  682.         self.messysync = MessySyncClient(trigger=self.trigger,
  683.                                          mqclient=self.mqclient,
  684.                                          timeout=self.timeout,
  685.                                          identity=self.identity)
  687.         self.extremitysync = ExtremitySyncClient(trigger=self.trigger,
  688.                                                  mqclient=self.mqclient,
  689.                                                  timeout=self.timeout,
  690.                                                  identity=self.identity,
  691.                                                  bean=None)
  693.     def base_func(self):
  694.         return self.basis
  696.     def override(self, dim):
  697.         self.ov_client.res_paths = ['/l/ov/%d' % self.ov_revision]
  698.         self.ov_client.res_responses = {
  699.     '/l/ov/%d/0' % self.ov_revision: (ResponseCode.CONTENT, 'Override', {
  700.     'nominalLightLevel': dim, 'enabled': 1})}
  701.         self.ov_revision += 1
  702.         return self.ov_client
  704.     def remove_override(self):
  705.         self.ov_client.res_paths = ['/l/ov/0']
  706.         self.ov_client.res_responses = {}
  707.         self.ov_revision += 1
  708.         return self.ov_client
  710.     def duplicate_override(self):
  711.         self.ov_client.res_paths = ['/l/ov/%d' % self.ov_revision]
  712.         self.ov_client.res_responses = {
  713.     '/l/ov/%d/0' % self.ov_revision: (ResponseCode.CONTENT, 'Override', {
  714.     'nominalLightLevel': 100, 'enabled': 1})}
  715.         return self.ov_client
  717.     def error_override(self, code):
  718.         self.ov_client.res_paths = ['/l/ov/%d' % self.ov_revision]
  719.         self.ov_client.res_responses = {
  720.     '/l/ov/%d/0' % self.ov_revision: (code, None, None)}
  721.         return self.ov_client
  723.     def ota(self):
  724.         return OtaClient(trigger=self.trigger,
  725.                          mqclient=self.mqclient,
  726.                          timeout=self.timeout,
  727.                          identity=self.identity)
  729.     def unhappy_sync(self, error_code):
  730.         self.unhappysync.error_code = error_code
  731.         return self.unhappysync
  733.     def empty_sync(self):
  734.         return self.emptysync
  736.     def wrong_sync(self):
  737.         return self.wrongsync
  739.     def messy_sync(self):
  740.         return self.messysync
  742.     def extremity_sync(self, bean):
  743.         self.extremitysync.bean = bean
  744.         return self.extremitysync

转载于:https://www.cnblogs.com/mftang2018/p/10919411.html

发表评论

表情：
评论列表 （有 0 条评论，453人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Base on QC Automation Framework v1.0

    从事自动化测试及自动化测试框架开发已经好多年了，大大小小的自动化框架也开发了不少，由于比较懒，很少在网上Share，今天突然有开个自己BLOG和大家讨论一下自动化测试相关的知识

    た 入场券た 入场券/ 0 赞/ 252 阅读