def test_server_run(self) -> None:
mock_socket = mock.Mock()
with mock.patch('socket.socket') as mock_sendall:
mock_sendall.return_value.recv.return_value = b''
mock_socket.recv.return_value = b'GET /zxc HTTP/1.1\r\n\r\n'
server = webserver.WebServer(mock_socket)
self.assertEqual(server.run(), None)
def main():
logging.getLogger().setLevel(logging.DEBUG)
camera_handler = ch.CameraHandler()
video_handler = vh.VideoHandler()
server = controller = None
try:
logging.warning("Main controller starting...")
controller = mc.MainController(camera_handler, video_handler)
controller.start()
logging.warning("Server starting...")
server = ws.WebServer(camera_handler, controller.get_detection_state)
server.start(ws.ADDRESS, ws.PORT)
except KeyboardInterrupt:
ws.WebServer.streaming = False
camera_handler.close_camera()
if server:
server.stop()
if controller:
controller.stop()
controller.join()
logging.warning("Everything closed...")
def test_server_delete1(self) -> None:
request = b'DELETE /index.py HTTP/1.1\r\n'
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = webserver.WebServer(connection)
with self.assertRaises(OSError):
with mock.patch('os.remove') as _:
server.http_request_parse(request)
def test_server_get(self) -> None:
request = b'GET /index.py HTTP/1.1\r\n'
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = webserver.WebServer(connection)
with mock.patch('socket.socket') as mock_sendall:
mock_sendall.return_value.recv.return_value = b''
with self.assertRaises(OSError):
server.http_request_parse(request)
def GlobalSetUp():
ChromeDriverTest._http_server = webserver.WebServer(
chrome_paths.GetTestData())
if _ANDROID_PACKAGE:
ChromeDriverTest._adb = android_commands.AndroidCommands()
host_port = ChromeDriverTest._http_server._server.server_port
forwarder.Forwarder.Map([(host_port, host_port)],
ChromeDriverTest._adb)
def test_server_head1(self) -> None:
request = b'HEAD aaa/index.py HTTP/1.1\r\n'
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = webserver.WebServer(connection)
with self.assertRaises(OSError):
with mock.patch('builtins.open',
mock.mock_open(read_data='data')) as _:
server.http_request_parse(request)
def __init__(self):
self.config = Config()
self.mcu = MCU()
self.detecting = Detecting()
# fb = Firebase()
ws = webserver.WebServer()
dl = DataLogger()
def GlobalSetUp():
def respondWithUserAgentString(request):
return request.GetHeader('User-Agent')
MobileEmulationCapabilityTest._http_server = webserver.WebServer(
chrome_paths.GetTestData())
MobileEmulationCapabilityTest._http_server.SetCallbackForPath(
'/userAgent', respondWithUserAgentString)
def test_server_insert_put(self) -> None:
request = 'PUT /index.py HTTP/1.1\r\n'
connection = mock.Mock()
connection.recv.return_value = b'a b c\r\nd f\r\n\r\n'
server = webserver.WebServer(connection)
with mock.patch('builtins.open',
mock.mock_open(read_data='data')) as _:
self.assertEqual(server.do_insert(request, 'w',
'Connection: close'), None)
def setUpClass(cls):
"""Starts the server for the necessary pages for testing."""
# make a temp dir to place test logs into
cls.log_dir = tempfile.mkdtemp()
try:
cls.http_server = webserver.WebServer(chrome_paths.GetTestData())
cls.server_url = cls.http_server.GetUrl()
except Exception:
cls.tearDownClass()
raise
def GlobalSetUp():
ChromeDriverTest._http_server = webserver.WebServer(
chrome_paths.GetTestData())
if _ANDROID_PACKAGE:
ChromeDriverTest._adb = android_commands.AndroidCommands()
ChromeDriverTest._forwarder = forwarder.Forwarder(ChromeDriverTest._adb,
'Debug')
host_port = ChromeDriverTest._http_server._server.server_port
ChromeDriverTest._forwarder.Run(
[(host_port, host_port)], valgrind_tools.BaseTool(), '127.0.0.1')
def test_server_insert_does_not_exist(self) -> None:
request = 'POST /index.py HTTP/1.1\r\n'
connection = mock.Mock()
connection.recv.return_value = b'a b c\r\nd f\r\n\r\n'
connection.sendall.side_effect = IOError
server = webserver.WebServer(connection)
with mock.patch('builtins.open',
mock.mock_open(read_data='data')) as _:
with self.assertRaises(IOError):
self.assertEqual(server.do_insert(request, 'a',
'Connection: close'), None)
def GlobalSetUp():
ChromeDriverTest._http_server = webserver.WebServer(
chrome_paths.GetTestData())
ChromeDriverTest._sync_server = webserver.SyncWebServer()
if _ANDROID_PACKAGE_KEY:
ChromeDriverTest._device = device_utils.DeviceUtils(
android_commands.GetAttachedDevices()[0])
http_host_port = ChromeDriverTest._http_server._server.server_port
sync_host_port = ChromeDriverTest._sync_server._server.server_port
forwarder.Forwarder.Map(
[(http_host_port, http_host_port), (sync_host_port, sync_host_port)],
ChromeDriverTest._device)
def __runWebServer(port, d, n, t):
global document_root, maay_core, templateFile
document_root = d
maay_core = n
templateFile = t
try:
ws = webserver.WebServer(port)
except socket.error, e:
raise WebServerError(e[1])
def initialize(apiversion, factories, gui_player):
"""Called every time the plugin is loaded. This happens both at application
startup time and at document startup time"""
if not gui_player:
# This is the initial initialize call, before a document
# is opened. Ignore, we'll get another one later.
print 'pyamplugin_trace: initialize() called without document'
return
print 'pyamplugin_trace: initialize() called for document'
# Create the trace object, the web server and the embedder helper object that
# will insert the trace object into the player (once it is initialized)
collector = tracer.TracePlayerFeedback()
server = webserver.WebServer()
server.setTracer(collector)
old_embedder = gui_player.get_embedder()
embedder = TraceEmbedder(old_embedder, collector, server)
gui_player.set_embedder(embedder)
def __init__(self):
QWidget.__init__(self)
self.db = db.DB()
self.db.init_dbs()
self.db.init_schemas()
feeds = self.db.get_feeds()
if len(feeds) == 0:
rsss = open('rss.txt')
site_name = ""
for rss in rsss:
if rss.startswith("\t"):
rss = rss.strip()
url = rss[rss.find(":") + 1:]
name = site_name + "-" + rss[:rss.find(":")]
self.db.save_feed(name, url, "")
else:
rss = rss.strip()
site_name = rss[:rss.find(":")]
self.server = webserver.WebServer(self)
self.server.start()
self.crawler = feedcrawl.Crawler(self)
self.crawler.start()
self.icon = QIcon(':/images/icon.png')
self.setLayout(QVBoxLayout())
self.web = QWebView()
self.web.load(QUrl("http://localhost:5000/"))
self.layout().addWidget(self.web)
self.setWindowTitle(u"Smart News Reader Just For You")
self.setWindowFlags(Qt.Tool)
self.resize(600, 400)
self.createActions()
self.createTrayIcon()
def __init__(self):
self.info = properties.Properties().load('rocket.properties')
print(self.info.get('name') + ' is starting...')
self.camera = Camera(self)
self.i2c = busio.I2C(board.SCL, board.SDA)
self.altimeter = altimeter.Altimeter(self.i2c)
self.accelerometer = None
self.state = state.State(self)
self.launchpad = launchpad.Client(self.info.get('name'))
self.launchpad.on_pair_handler = lambda launchpad: self.pair(launchpad)
self.launchpad.on_arm_handler = lambda: self.arm()
self.launchpad.on_disarm_handler = lambda: self.disarm()
self.launchpad.connect()
self.webserver = webserver.WebServer(self).start()
self.led = gpiozero.LED(10)
self.led.blink(1, 1, 3)
print(self.info.get('name') + ' is ready!')
return
def startWebserver(self):
address = self.conf["listen"]
self.webserver = webserver.WebServer(self.makeRouteMap(), address)
self.server = Thread(target=self.webserver.run)
self.server.daemon = True
self.server.start()
def main():
# Start a server instance on the default port (8888)
server = webserver.WebServer()
server.start_server()
def GlobalSetUp():
ChromeDriverTest._http_server = webserver.WebServer(
chrome_paths.GetTestData())
def test_server_options(self) -> None:
request = b'OPTIONS /index.py HTTP/1.1\r\n'
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = webserver.WebServer(connection)
with self.assertRaises(OSError):
server.http_request_parse(request)
log.setLevel(logging.DEBUG)
http = logging.getlogger("http")
webs = logging.getlogger("webs")
http.setLevel(logging.DEBUG)
webs.setLevel(logging.DEBUG)
log.info ("WebserverTest")
import sys
print(sys.path)
https = http_server.HttpServer(sys.path[0] + "/../web")
server = webserver.WebServer(https)
server.modeStation()
# 2 tasks
def ledR():
log.info("Starting ledR")
led = machine.Pin(5, mode=machine.Pin.OUT)
total = 0
yield
while True:
total += 1
if led.value() == 1:
led.value(0)
else:
led.value(1)
def unregister(self, fd):
del self._events[fd.fileno()]
self._poll.unregister(fd)
def poll(self, timeout=-1):
for event in self._poll.ipoll(timeout):
print(event)
fd = event[0]
self._events[fd.fileno()](self, fd)
buttons.setup()
nm = wifi.NetworkManager()
nm.run_sta()
poller = Poller()
webserver.WebServer(poller, nm)
print("entering event loop")
sensors.setup()
import micropython
import umqtt.robust2 as mqtt
client = mqtt.MQTTClient("beehive", "192.168.1.108")
client.connect()
print("client connected")
while True:
for i in range(10):
print("start", i)
client.publish(b"foobar", b"start")
def test_server_init(self) -> None:
mock_socket = mock.Mock()
server = webserver.WebServer(mock_socket)
self.assertEqual(server.client_connection, mock_socket)
def setUpClass(cls):
"""Starts the server for the necessary pages for testing."""
cls.http_server = webserver.WebServer(chrome_paths.GetTestData())
cls.server_url = cls.http_server.GetUrl()
