From ab16e84c854435ccb1e1917da3a54f159b01b0fb Mon Sep 17 00:00:00 2001
From: Kirill Kuzminykh <cykooz@gmail.com>
Date: Thu, 13 Jun 2024 15:19:30 +0300
Subject: [PATCH] Fixed processing of heartbeats and a session expiration and
 addeds support of aiohttp_cors (#448)

* - Fixed processing of heartbeats and a session expiration.
- Fixed ping-pong based heartbeats for web-socket connections.
- Added arguments ``heartbeat_delay`` and ``disconnect_delay`` into ``Session.__init__()``.
- Added argument ``disconnect_delay`` into ``SessionManager.__init__()``.
- **Breaking change:** Removed argument ``timeout`` from ``Session.__init__()`` and ``SessionManager.__init__()``.
- **Breaking change:** Argument ``heartbeat`` of ``SessionManager.__init__()`` renamed into ``heartbeat_delay``.
- **Breaking change:** ``Session.registry`` renamed into ``Session.app``.
- **Breaking change:** Dropped support of Python < 3.7

* Deleted method ``SessionManager.route_url()``.

* Added release date into CHANGES.rst

* Removed commented code from tests and fixed CHANGES.rst

* - Added argument ``cors_config`` into function ``add_endpoint()`` to support of CORS settings from ``aiohttp_cors``.
- Function ``add_endpoint()`` now returns all registered routes.
- Replaced returning instances of error HTTP responses on raising its as exceptions.
- Changed name of some routes.

* Fixed GitHub actions

* Fixed GitHub actions

* Fixed GitHub actions

* Fixed version of flake8 to support Python 3.7

* Fixed typing

* Reverted pytest-timeout

* Removed embedded CORS processing.

* Added arguments ``heartbeat_delay`` and ``disconnect_delay`` into function ``add_endpoint()``.

* - Heartbeat task moved from ``SessionManager`` into ``Session``.
- Methods ``_acquire`` and ``_release`` of ``Sessions`` renamed into ``acquire`` and ``release``.

* Added processing of ``ConnectionError`` in ``StreamingTransport``.

* Fixed name of transports.

* - Changed arguments of handler function. Now handler function must be defined
  like ``async def handler(manager, session, msg):``
- Constants:

  - FRAME_OPEN
  - FRAME_CLOSE
  - FRAME_MESSAGE
  - FRAME_MESSAGE_BLOB
  - FRAME_HEARTBEAT

  replaced by ``Frame`` enums with corresponding values.
- Constants:

  - MSG_OPEN
  - MSG_MESSAGE
  - MSG_CLOSE
  - MSG_CLOSED

  replaced by ``MsgType`` enums with corresponding values.
- Constants:

  - STATE_NEW
  - STATE_OPEN
  - STATE_CLOSING
  - STATE_CLOSED

  replaced by ``SessionState`` enums with corresponding values.

* Fixed error processing in StreamingTransport

* Changed supported versions of Python.

* Added "sockjs_transport_name" into request object.

* - Updated dependencies versions.
- Fixed code style.

* Fixed dependencies.

* Fixed versions of GitHub actions.
---
 .coveragerc                           |   7 -
 .github/workflows/check_and_test.yaml |  37 ++
 .github/workflows/pythonpublish.yml   |   6 +-
 .gitignore                            |   1 +
 .travis.yml                           |  31 --
 CHANGES.rst                           |  60 +++
 MANIFEST.in                           |   1 -
 Makefile                              |  21 +-
 README.rst                            |   2 +-
 docs/Makefile                         |  67 ---
 docs/api.rst                          |  23 -
 docs/conf.py                          | 185 --------
 docs/index.rst                        |  18 -
 docs/install.rst                      |  58 ---
 docs/overview.rst                     | 175 --------
 examples/chat.html                    | 172 ++++----
 examples/chat.py                      |  41 +-
 requirements.txt                      |  20 +-
 setup.cfg                             |   9 +-
 setup.py                              |  32 +-
 sockjs-testsrv.py                     |  38 +-
 sockjs/__init__.py                    |  39 +-
 sockjs/protocol.py                    |  65 +--
 sockjs/route.py                       | 244 ++++++-----
 sockjs/session.py                     | 494 +++++++++++----------
 sockjs/transports/__init__.py         |  28 +-
 sockjs/transports/base.py             | 144 ++++---
 sockjs/transports/eventsource.py      |  23 +-
 sockjs/transports/htmlfile.py         |  44 +-
 sockjs/transports/jsonp.py            |  56 +--
 sockjs/transports/rawwebsocket.py     | 103 +++--
 sockjs/transports/utils.py            |  40 +-
 sockjs/transports/websocket.py        | 134 ++++--
 sockjs/transports/xhr.py              |  37 --
 sockjs/transports/xhr_pooling.py      |  81 ++++
 sockjs/transports/xhrsend.py          |  43 --
 sockjs/transports/xhrstreaming.py     |  17 +-
 tests/asdf                            |   0
 tests/conftest.py                     | 102 +++--
 tests/test_route.py                   | 125 ++++--
 tests/test_session.py                 | 590 +++++++++++++++-----------
 tests/test_transport.py               |  65 ++-
 tests/test_transport_eventsource.py   |  15 +-
 tests/test_transport_htmlfile.py      |  32 +-
 tests/test_transport_jsonp.py         |  41 +-
 tests/test_transport_rawwebsocket.py  |  22 +-
 tests/test_transport_websocket.py     |  52 +--
 tests/test_transport_xhr.py           |  18 +-
 tests/test_transport_xhrsend.py       |  27 +-
 tests/test_transport_xhrstreaming.py  |  14 +-
 50 files changed, 1797 insertions(+), 1902 deletions(-)
 delete mode 100644 .coveragerc
 create mode 100644 .github/workflows/check_and_test.yaml
 delete mode 100644 .travis.yml
 delete mode 100644 docs/Makefile
 delete mode 100644 docs/api.rst
 delete mode 100644 docs/conf.py
 delete mode 100644 docs/index.rst
 delete mode 100644 docs/install.rst
 delete mode 100644 docs/overview.rst
 delete mode 100644 sockjs/transports/xhr.py
 create mode 100644 sockjs/transports/xhr_pooling.py
 delete mode 100644 sockjs/transports/xhrsend.py
 delete mode 100644 tests/asdf

diff --git a/.coveragerc b/.coveragerc
deleted file mode 100644
index 639d298c..00000000
--- a/.coveragerc
+++ /dev/null
@@ -1,7 +0,0 @@
-[run]
-branch = True
-source = sockjs, tests
-omit = site-packages
-
-[html]
-directory = coverage
diff --git a/.github/workflows/check_and_test.yaml b/.github/workflows/check_and_test.yaml
new file mode 100644
index 00000000..04aa843e
--- /dev/null
+++ b/.github/workflows/check_and_test.yaml
@@ -0,0 +1,37 @@
+name: Check and Test
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+  workflow_dispatch: {}
+
+
+jobs:
+  run_tests:
+    strategy:
+      matrix:
+        python-version: [ "3.10", "3.11", "3.12" ]
+
+    name: Test on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          architecture: x64
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade setuptools
+          python -m pip install -r requirements.txt
+          python -m pip install -e .[test]
+
+      - name: Run checks and tests
+        run: |
+          make flake
+          pytest ./tests
diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml
index b143a530..bb2a83e0 100644
--- a/.github/workflows/pythonpublish.yml
+++ b/.github/workflows/pythonpublish.yml
@@ -8,15 +8,15 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Python
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install setuptools wheel twine
+        python -m pip install setuptools wheel twine
     - name: Build and publish
       env:
         TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
diff --git a/.gitignore b/.gitignore
index 7bb7b93d..8a7d23b7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@ eggs
 sources
 dist
 develop-eggs
+build
 *.egg-info
 *.pyc
 *.pyo
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 38727d34..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,31 +0,0 @@
-language: python
-python:
-  - 3.5
-  - 3.6
-  - 3.7
-  - 3.8
-install:
-  - pip install --upgrade setuptools
-  - pip install -r requirements.txt
-  - pip install codecov
-  - python setup.py develop
-
-script:
-  - make cov
-  - python setup.py check -rms
-
-
-after_success:
-
-  - codecov
-
-deploy:
-  provider: pypi
-  user: aio-libs-bot
-  password:
-    secure: "En+U4kq5LKMrOQ2g8qGBLRbTPEfgNsLIcAfs264LjAtSb9Rc8g62wJ3s2Vob5f8k848ZcBmBh+K5M75gNIYZtP2wU1p4sHvTnz5bxSkdgN9A7gdgS8UdxwbIO6dUBGz3YTlXNcbRmiSbA8CL7M8ULswVtqTwpr864q80TBlj49+HbfszI2wb9UOu7kGW9i1qFtCRSagqe6V1MWhRc0H5nD8WmwzmlxMtllJfubDA4EpqAwAPPwfxYP7QQgo8L3e5CBcbDmLwvvjXkxrOpp6yae2003AWJXFNcygcpo2mt1BRe8/bXtIxXLET0djP7sj+3yu5XTksAI2JTcGVW9PZUr+NmhTeKTrAFQ+7qW+QNWQRRYlS5SokhOEoTRPRsH2D9kYKFy0wteBNNe2TD4o09KsqQHwY+Lpr5nlJUkX5HXBrHoGSQW9lNaQEq7nutpEwiTBCAdINjmfjKMxHIXfy93XfjR2wwGIoUr94i+yWG/zIkCKwr31s5CvfRbHmntU/jFTk6cqSTfzphk+7XEMWQlw8tRh55b641IY4/PMXqSXx8oNpoK4/lvrKG0KP4wSBBLjIOVSq46VPij3YQjnN2EzqECKess2D6Wrec3JaPukLtjCnOymbMq72BstnRI41THrL6bNpyUc7OkXL9NwoU6TNSXdMZoVA2lu6nRE6F+w="
-  distributions: "sdist bdist_wheel"
-  on:
-    tags: true
-    all_branches: true
-    python: 3.6
diff --git a/CHANGES.rst b/CHANGES.rst
index 7eb64c5e..bb3e0fe7 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -2,6 +2,66 @@
 CHANGES
 =======
 
+0.13.0 (not-released)
+---------------------
+
+- Added argument ``cors_config`` into function ``add_endpoint()``
+  to support of CORS settings from ``aiohttp_cors``.
+- Added arguments ``heartbeat_delay`` and ``disconnect_delay``
+  into function ``add_endpoint()``.
+- Function ``add_endpoint()`` now returns all registered routes.
+- Replaced returning instances of error HTTP responses
+  on raising its as exceptions.
+- Changed name of some routes.
+- Heartbeat task moved from ``SessionManager`` into ``Session``.
+- Methods ``_acquire`` and ``_release`` of ``Sessions`` renamed into
+  ``acquire`` and ``release``.
+- Added processing of ``ConnectionError`` in ``StreamingTransport``.
+- Changed arguments of handler function. Now handler function must be defined
+  like ``async def handler(manager, session, msg):``
+- Constants:
+
+  - FRAME_OPEN
+  - FRAME_CLOSE
+  - FRAME_MESSAGE
+  - FRAME_MESSAGE_BLOB
+  - FRAME_HEARTBEAT
+
+  replaced by ``Frame`` enums with corresponding values.
+- Constants:
+
+  - MSG_OPEN
+  - MSG_MESSAGE
+  - MSG_CLOSE
+  - MSG_CLOSED
+
+  replaced by ``MsgType`` enums with corresponding values.
+- Constants:
+
+  - STATE_NEW
+  - STATE_OPEN
+  - STATE_CLOSING
+  - STATE_CLOSED
+
+  replaced by ``SessionState`` enums with corresponding values.
+
+
+0.12.0 (2022-02-08)
+-------------------
+
+- **Breaking change:** Removed argument ``timeout`` from ``Session.__init__()``
+  and ``SessionManager.__init__()``.
+- **Breaking change:** Argument ``heartbeat`` of ``SessionManager.__init__()``
+  renamed into ``heartbeat_delay``.
+- **Breaking change:** ``Session.registry`` renamed into ``Session.app``.
+- **Breaking change:** Deleted method ``SessionManager.route_url()``.
+- **Breaking change:** Dropped support of Python < 3.7
+- Fixed processing of heartbeats and a session expiration.
+- Fixed ping-pong based heartbeats for web-socket connections.
+- Added arguments ``heartbeat_delay`` and ``disconnect_delay`` into
+  ``Session.__init__()``.
+- Added argument ``disconnect_delay`` into ``SessionManager.__init__()``.
+
 0.11.0 (2020-10-22)
 -------------------
 
diff --git a/MANIFEST.in b/MANIFEST.in
index 831624aa..fcbcab7e 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -4,7 +4,6 @@ include README.rst
 include Makefile
 include sockjs-testsrv.py
 graft sockjs
-graft docs
 graft examples
 graft tests
 global-exclude *.pyc
diff --git a/Makefile b/Makefile
index aba1428b..2db017a9 100644
--- a/Makefile
+++ b/Makefile
@@ -4,18 +4,10 @@ FLAGS=
 
 
 flake:
-#	python setup.py check -rms
 	flake8 sockjs tests examples
-	if python -c "import sys; sys.exit(sys.version_info<(3,6))"; then \
-		black --check sockjs tests setup.py; \
-	fi
-
-fmt:
-	black sockjs tests setup.py
-
 
 develop:
-	python setup.py develop
+	pip install -e .[test]
 
 test: flake develop
 	pytest $(FLAGS) ./tests/
@@ -23,10 +15,6 @@ test: flake develop
 vtest: flake develop
 	pytest -s -v $(FLAGS) ./tests/
 
-cov cover coverage: flake develop
-	@py.test --cov=sockjs --cov-report=term --cov-report=html tests
-	@echo "open file://`pwd`/coverage/index.html"
-
 clean:
 	rm -rf `find . -name __pycache__`
 	rm -f `find . -type f -name '*.py[co]' `
@@ -40,11 +28,6 @@ clean:
 	rm -rf coverage
 	rm -rf build
 	rm -rf cover
-	make -C docs clean
 	python setup.py clean
 
-doc:
-	make -C docs html
-	@echo "open file://`pwd`/docs/_build/html/index.html"
-
-.PHONY: all build venv flake test vtest testloop cov clean doc
+.PHONY: all flake test vtest clean
diff --git a/README.rst b/README.rst
index 10625f10..c3cf70bd 100644
--- a/README.rst
+++ b/README.rst
@@ -73,7 +73,7 @@ Supported transports
 Requirements
 ------------
 
-- Python 3.5.3
+- Python 3.10.0
 
 - gunicorn 19.2.0
 
diff --git a/docs/Makefile b/docs/Makefile
deleted file mode 100644
index 8ac72307..00000000
--- a/docs/Makefile
+++ /dev/null
@@ -1,67 +0,0 @@
-# Makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    = -W
-SPHINXBUILD   = ../../../bin/sphinx-build
-PAPER         =
-
-# Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d _build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-
-.PHONY: help clean html web pickle htmlhelp latex changes linkcheck
-
-help:
-	@echo "Please use \`make <target>' where <target> is one of"
-	@echo "  html      to make standalone HTML files"
-	@echo "  pickle    to make pickle files (usable by e.g. sphinx-web)"
-	@echo "  htmlhelp  to make HTML files and a HTML help project"
-	@echo "  changes   to make an overview over all changed/added/deprecated items"
-	@echo "  linkcheck to check all external links for integrity"
-
-clean:
-	-rm -rf _build/*
-
-html:
-	mkdir -p _build/html _build/doctrees
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) _build/html
-	@echo
-	@echo "Build finished. The HTML pages are in _build/html."
-
-text:
-	mkdir -p _build/text _build/doctrees
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) _build/text
-	@echo
-	@echo "Build finished. The HTML pages are in _build/text."
-
-pickle:
-	mkdir -p _build/pickle _build/doctrees
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) _build/pickle
-	@echo
-	@echo "Build finished; now you can process the pickle files or run"
-	@echo "  sphinx-web _build/pickle"
-	@echo "to start the sphinx-web server."
-
-web: pickle
-
-htmlhelp:
-	mkdir -p _build/htmlhelp _build/doctrees
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) _build/htmlhelp
-	@echo
-	@echo "Build finished; now you can run HTML Help Workshop with the" \
-	      ".hhp project file in _build/htmlhelp."
-
-changes:
-	mkdir -p _build/changes _build/doctrees
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) _build/changes
-	@echo
-	@echo "The overview file is in _build/changes."
-
-linkcheck:
-	mkdir -p _build/linkcheck _build/doctrees
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) _build/linkcheck
-	@echo
-	@echo "Link check complete; look for any errors in the above output " \
-	      "or in _build/linkcheck/output.txt."
diff --git a/docs/api.rst b/docs/api.rst
deleted file mode 100644
index fa0eb87c..00000000
--- a/docs/api.rst
+++ /dev/null
@@ -1,23 +0,0 @@
-API
-===
-
-
-.. automodule:: pyramid_sockjs
-
-.. autofunction:: get_session_manager
-
-Session states:
-
-  .. py:data:: STATE_NEW
-
-  .. py:data:: STATE_OPEN
-
-  .. py:data:: STATE_CLOSING
-
-  .. py:data:: STATE_CLOSED
-
-.. autoclass:: Session(id)
-     :members:
-
-.. autoclass:: SessionManager
-     :members:
diff --git a/docs/conf.py b/docs/conf.py
deleted file mode 100644
index f7c2b044..00000000
--- a/docs/conf.py
+++ /dev/null
@@ -1,185 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# ptah documentation build configuration file
-#
-# This file is execfile()d with the current directory set to its containing
-# dir.
-#
-# The contents of this file are pickled, so don't put values in the
-# namespace that aren't pickleable (module imports are okay, they're
-# removed automatically).
-#
-# All configuration values have a default value; values that are commented
-# out serve to show the default value.
-
-
-# General configuration
-# ---------------------
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.intersphinx',
-              'sphinx.ext.autodoc']
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['.templates']
-
-# The suffix of source filenames.
-source_suffix = '.rst'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General substitutions.
-project = 'pyramid_sockjs'
-
-# The default replacements for |version| and |release|, also used in various
-# other places throughout the built documents.
-#
-# The short X.Y version.
-version = '2.0dev1'
-# The full version, including alpha/beta/rc tags.
-release = version
-
-# There are two options for replacing |today|: either, you set today to
-# some non-false value, then it is used:
-#today = ''
-# Else, today_fmt is used as the format for a strftime call.
-today_fmt = '%B %d, %Y'
-
-# List of documents that shouldn't be included in the build.
-#unused_docs = ['_themes/README']
-
-# List of directories, relative to source directories, that shouldn't be
-# searched for source files.
-#exclude_dirs = []
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-#default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-
-# Options for HTML output
-# -----------------------
-
-#sys.path.append(os.path.abspath('_themes'))
-#html_theme_path = ['_themes']
-#html_theme = 'pylons'
-
-# The style sheet to use for HTML and HTML Help pages. A file of that name
-# must exist either in Sphinx' static/ path, or in one of the custom paths
-# given in html_static_path.
-#html_style = 'pylons.css'
-
-# The name for this set of Sphinx documents.  If None, it defaults to
-# "<project> v<release> documentation".
-#html_title = None
-
-# A shorter title for the navigation bar.  Default is the same as
-# html_title.
-#html_short_title = None
-
-# The name of an image file (within the static path) to place at the top of
-# the sidebar.
-#html_logo = '.static/logo_hi.gif'
-
-# The name of an image file (within the static path) to use as favicon of
-# the docs.  This file should be a Windows icon file (.ico) being 16x16 or
-# 32x32 pixels large.
-#html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets)
-# here, relative to this directory. They are copied after the builtin
-# static files, so a file named "default.css" will overwrite the builtin
-# "default.css".
-#html_static_path = ['.static']
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page
-# bottom, using the given strftime format.
-html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#html_additional_pages = {}
-
-# If false, no module index is generated.
-#html_use_modindex = True
-
-# If false, no index is generated.
-#html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#html_split_index = False
-
-# If true, the reST sources are included in the HTML build as
-# _sources/<name>.
-#html_copy_source = True
-
-# If true, an OpenSearch description file will be output, and all pages
-# will contain a <link> tag referring to it.  The value of this option must
-# be the base URL from which the finished HTML is served.
-#html_use_opensearch = ''
-
-# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = ''
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'atemplatedoc'
-
-
-# Options for LaTeX output
-# ------------------------
-
-# The paper size ('letter' or 'a4').
-#latex_paper_size = 'letter'
-
-# The font size ('10pt', '11pt' or '12pt').
-#latex_font_size = '10pt'
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, document class [howto/manual]).
-latex_documents = [
-    ('index', 'atemplate.tex', 'Pyramid SockJS documentation',
-     'Developers', 'manual'),
-]
-
-# The name of an image file (relative to this directory) to place at the
-# top of the title page.
-latex_logo = '.static/logo_hi.gif'
-
-# For "manual" documents, if this is true, then toplevel headings are
-# parts, not chapters.
-#latex_use_parts = False
-
-# Additional stuff for the LaTeX preamble.
-#latex_preamble = ''
-
-# Documents to append as an appendix to all manuals.
-#latex_appendices = []
-
-# If false, no module index is generated.
-#latex_use_modindex = True
-
-#autoclass_content = 'both'
diff --git a/docs/index.rst b/docs/index.rst
deleted file mode 100644
index a70d01cd..00000000
--- a/docs/index.rst
+++ /dev/null
@@ -1,18 +0,0 @@
-Pyramid SockJS
-==============
-
-.. toctree::
-   :maxdepth: 2
-
-   overview.rst
-   install.rst
-   api.rst
-
-
-Indices and tables
-------------------
-
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`
-
diff --git a/docs/install.rst b/docs/install.rst
deleted file mode 100644
index 21835623..00000000
--- a/docs/install.rst
+++ /dev/null
@@ -1,58 +0,0 @@
-============
-Installation
-============
-
-virtualenv
-==========
-
-
-1. Install virtualenv::
-
-    $ wget https://raw.github.com/pypa/virtualenv/master/virtualenv.py
-    $ python2.7 ./virtualenv.py --no-site-packages sockjs
-
-2. Install gevent 1.0b2 (non-Windows users)::
-
-    $ ./sockjs/bin/pip install http://gevent.googlecode.com/files/gevent-1.0b2.tar.gz
-
-2. Install gevent 1.0b2 (Windows users, presuming you are running 32bit Python 2.7)::
-
-    $ ./sockjs/Scripts/easy_install http://gevent.googlecode.com/files/gevent-1.0b2-py2.7-win32.egg
-
-3. Clone pyramid_sockjs from github and then install::
-
-    $ git clone https://github.com/fafhrd91/pyramid_sockjs.git
-    $ cd pyramid_sockjs
-    $ ../sockjs/bin/python setup.py develop
-
-
-Server config
-=============
-
-To use gevent based server use following configuration
-for server section::
-
-    [server:main]
-    use = egg:pyramid_sockjs#server
-    host = 127.0.0.1
-    port = 8080
-
-To use gunicorn server use following configuation for server section, 
-gunicorn 0.14.3 or greater is required::
-
-    [server:main]
-    use = egg:gunicorn
-    host = 127.0.0.1
-    port = 8080
-    workers = 1
-    worker_class = gevent
-
-
-Chat example
-============
-
-You can run `chat` example with following command. It doesnt require
-any configuration, it runs on host ``127.0.0.1`` and port ``8080``::
-
-
-    $ ./sockjs/bin/python ./pyramid_sockjs/examples/chat.py
diff --git a/docs/overview.rst b/docs/overview.rst
deleted file mode 100644
index 9d5110ef..00000000
--- a/docs/overview.rst
+++ /dev/null
@@ -1,175 +0,0 @@
-Pyramid SockJS
-==============
-
-Overview
---------
-
-Gevent-based SockJS integration for Pyramid. SockJS interface is
-implemented as pyramid route. It runs inside wsgi app rather than wsgi server.
-It's possible to create any number of different sockjs routes, ie
-`/__sockjs__/*` or `/mycustom-sockjs/*`. also you can provide different
-session implementation and management for each of sockjs routes.
-
-Gevent based server is required for ``pyramid_sockjs``.
-For example ``gunicorn`` with gevent worker. ``pyramid_sockjs`` provides
-simple paster server runner:
-
-.. code-block:: text
-   :linenos:
-
-   [server:main]
-   use = egg:pyramid_sockjs#server
-   host = 0.0.0.0
-   port = 8080
-
-Example of sockjs route:
-
-.. code-block:: python
-
-   def main(global_settings, **settings):
-       config = Configurator(settings=settings)
-       config.add_sockjs_route()
-
-       return config.make_wsgi_app()
-
-By default :py:func:`add_sockjs_route` directive creates sockjs route
-with empty name and prefix ``/__sockjs__``, so js client code should look like:
-
-
-.. code-block:: javascript
-
-  <script src="http://cdn.sockjs.org/sockjs-0.2.min.js"></script>
-  <script>
-      var sock = new SockJS('http://localhost:8080/__sockjs__');
-
-      sock.onopen = function() {
-        console.log('open');
-      };
-
-      sock.onmessage = function(obj) {
-        console.log(obj);
-      };
-
-      sock.onclose = function() {
-        console.log('close');
-      };
-  </script>
-
-
-All interactions between client and server happen through `Sessions`.
-Its possible to override default session with custom implementation.
-Default session is very stupid, its even not possible to receive
-client messages, so in most cases it is required to replace session.
-Let's implement `echo` session as example:
-
-.. code-block:: python
-
-  from pyramid_sockjs.session import Session
-
-  class EchoSession(Session):
-
-      def on_open(self):
-          self.send('Hello')
-          self.manager.broadcast("Someone joined.")
-
-      def on_message(self, message):
-          self.send(message)
-
-      def on_close(self):
-          self.manager.broadcast("Someone left.")
-
-To use custom session implementation pass it to :py:func:`add_sockjs_route`
-directive:
-
-.. code-block:: python
-
-   def main(global_settings, **settings):
-       config = Configurator(settings=settings)
-
-       config.add_sockjs_route(session=EchoSession)
-
-       return config.make_wsgi_app()
-
-
-Sessions are managed by ``SessionManager``, each sockjs route has separate
-session manager. Session manage is addressed by same name as sockjs route.
-To get session manager use :py:func:`get_sockjs_manager`
-request function.
-
-.. code-block:: python
-
-   def main(...):
-       ...
-       config.add_sockjs_route('chat-service')
-       ...
-       config.add_route('broadcast', '/broadcast')
-       ...
-       return config.make_wsgi_app()
-
-
-   @view_config(route_name='broadcast', renderer='string')
-   def send_message(request):
-       message = request.GET.get('message')
-       if message:
-          manager = request.get_sockjs_manager('chat-service')
-      for session in manager.active_session():
-              session.send(message)
-
-       return 'Message has been sent'
-
-
-To use custom ``SessionManager`` pass it as `session_manager=` argument
-to :py:func:`add_sockjs_route` configurator directive.
-Check :py:class:`pyramid_sockjs.Session`
-and :py:class:`pyramid_sockjs.SessionManager` api for
-detailed description.
-
-
-Supported transports
---------------------
-
-* websocket (`hixie-76 <http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76>`_
-  and `hybi-10 <http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10>`_)
-* `xhr-streaming <https://secure.wikimedia.org/wikipedia/en/wiki/XMLHttpRequest#Cross-domain_requests>`_
-* `xhr-polling <https://secure.wikimedia.org/wikipedia/en/wiki/XMLHttpRequest#Cross-domain_requests>`_
-* `iframe-xhr-polling <https://developer.mozilla.org/en/DOM/window.postMessage>`_
-* iframe-eventsource (`EventSource <http://dev.w3.org/html5/eventsource/>`_ used from an.
-  `iframe via postMessage <https://developer.mozilla.org/en/DOM/window.postMessage>`_)
-* iframe-htmlfile (`HtmlFile <http://cometdaily.com/2007/11/18/ie-activexhtmlfile-transport-part-ii/>`_
-  used from an `iframe via postMessage <https://developer.mozilla.org/en/DOM/window.postMessage>`_.)
-* `jsonp-polling <https://secure.wikimedia.org/wikipedia/en/wiki/JSONP>`_
-
-
-Limitations
------------
-
-Pyramid sockjs does not support multple websocket session with same session id.
-
-gevent does not support Python 3
-
-Requirements
-------------
-
-- Python 2.6/2.7
-
-- `virtualenv <http://pypi.python.org/pypi/virtualenv>`_
-
-- `gevent 1.0b1 or greater <http://www.gevent.org/>`_
-
-- `gevent-websocket 0.3.0 or greater <http://pypi.python.org/pypi/gevent-websocket/>`_
-
-- `gunicorn 0.14.3 or greater <http://gunicorn.org/>`_
-
-
-Examples
---------
-
-You can find them in the `examples` repository at github.
-
-https://github.com/fafhrd91/pyramid_sockjs/tree/master/examples
-
-
-License
--------
-
-pyramid_sockjs is offered under the BSD license.
diff --git a/examples/chat.html b/examples/chat.html
index b576a37b..7c126637 100644
--- a/examples/chat.html
+++ b/examples/chat.html
@@ -2,88 +2,98 @@
 <html>
 <head>
   <meta charset="utf-8">
-  <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
+  <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
   <script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>
   <script>
-    $(function() {
-      var conn = null;
-
-      function log(msg) {
-        var control = $('#log');
-        control.html(control.html() + msg + '<br/>');
-        control.scrollTop(control.scrollTop() + 1000);
-      }
-
-      function connect() {
-        disconnect();
-
-        var transports = $('#protocols input:checked').map(function(){
-            return $(this).attr('id');
-        }).get();
-
-        conn = new SockJS('http://' + window.location.host + '/sockjs/', [], {debug: true, transports: transports});
-
-        log('Connecting...');
-
-        conn.onopen = function() {
-          log('Connected.');
-          update_ui();
-        };
-
-        conn.onmessage = function(e) {
-          log('Received: ' + e.data);
-        };
-
-        conn.onclose = function() {
-          log('Disconnected.');
-          conn = null;
-          update_ui();
-        };
-      }
-
-      function disconnect() {
-        if (conn != null) {
-          log('Disconnecting...');
-
-          conn.close();
-          conn = null;
-
-          update_ui();
-        }
-      }
-
-      function update_ui() {
-        var msg = '';
-
-        if (conn == null || conn.readyState != SockJS.OPEN) {
-          $('#status').text('disconnected');
-          $('#connect').text('Connect');
-        } else {
-          $('#status').text('connected (' + conn.protocol + ')');
-          $('#connect').text('Disconnect');
-        }
-      }
-
-      $('#connect').click(function() {
-        if (conn == null) {
-          connect();
-        } else {
-          disconnect();
-        }
-
-        update_ui();
-        return false;
+      $(function() {
+          let conn = null;
+
+          function log(msg)
+          {
+              const control = $('#log');
+              control.html(control.html() + msg + '<br/>');
+              control.scrollTop(control.scrollTop() + 1000);
+          }
+
+          function connect()
+          {
+              disconnect();
+
+              const transports = $('#protocols input:checked').map(function() {
+                  return $(this).attr('id');
+              }).get();
+
+              conn = new SockJS('http://' + window.location.host + '/sockjs/', [], {
+                  debug: true,
+                  transports: transports
+              });
+
+              log('Connecting...');
+
+              conn.onopen = function() {
+                  log('Connected.');
+                  update_ui();
+              };
+
+              conn.onmessage = function(e) {
+                  log('Received: ' + e.data);
+              };
+
+              conn.onclose = function() {
+                  log('Disconnected.');
+                  conn = null;
+                  update_ui();
+              };
+          }
+
+          function disconnect()
+          {
+              if (conn != null)
+              {
+                  log('Disconnecting...');
+
+                  conn.close();
+                  conn = null;
+
+                  update_ui();
+              }
+          }
+
+          function update_ui()
+          {
+              if (conn == null || conn.readyState != SockJS.OPEN)
+              {
+                  $('#status').text('disconnected');
+                  $('#connect').text('Connect');
+              } else
+              {
+                  $('#status').text('connected (' + conn.protocol + ')');
+                  $('#connect').text('Disconnect');
+              }
+          }
+
+          $('#connect').click(function() {
+              if (conn == null)
+              {
+                  connect();
+              } else
+              {
+                  disconnect();
+              }
+
+              update_ui();
+              return false;
+          });
+
+          $('form').submit(function() {
+              const text = $('#text').val();
+              log('Sending: ' + text);
+              conn.send(text);
+              $('#text').val('').focus();
+              return false;
+          });
       });
-
-      $('form').submit(function() {
-        var text = $('#text').val();
-        log('Sending: ' + text);
-        conn.send(text);
-        $('#text').val('').focus();
-        return false;
-      });
-    });
-</script>
+  </script>
 </head>
 <body>
 <h3>Chat!</h3>
@@ -129,8 +139,8 @@ <h3>Chat!</h3>
 <div id="log" style="width: 60em; height: 20em; overflow:auto; border: 1px solid black">
 </div>
 <form id="chatform">
-  <input id="text" type="text" />
-  <input type="submit" />
+  <input id="text" type="text"/>
+  <input type="submit"/>
 </form>
 </body>
 </html>
diff --git a/examples/chat.py b/examples/chat.py
index efba4801..e98f0cab 100644
--- a/examples/chat.py
+++ b/examples/chat.py
@@ -1,24 +1,28 @@
 import logging
 import os
 
+import aiohttp_cors
 from aiohttp import web
 
 import sockjs
+from sockjs import SessionManager, Session, SockjsMessage, MsgType
 
 
 CHAT_FILE = open(
     os.path.join(os.path.dirname(__file__), 'chat.html'), 'rb').read()
 
 
-async def chat_msg_handler(msg, session):
-    if session.manager is None:
-        return
-    if msg.type == sockjs.MSG_OPEN:
-        session.manager.broadcast("Someone joined.")
-    elif msg.type == sockjs.MSG_MESSAGE:
-        session.manager.broadcast(msg.data)
-    elif msg.type == sockjs.MSG_CLOSED:
-        session.manager.broadcast("Someone left.")
+async def chat_msg_handler(
+        manager: SessionManager,
+        session: Session,
+        msg: SockjsMessage,
+):
+    if msg.type == MsgType.OPEN:
+        manager.broadcast("Someone joined.")
+    elif msg.type == MsgType.MESSAGE:
+        manager.broadcast(msg.data)
+    elif msg.type == MsgType.CLOSED:
+        manager.broadcast("Someone left.")
 
 
 def index(request):
@@ -32,6 +36,23 @@ def index(request):
 
     app = web.Application()
     app.router.add_route('GET', '/', index)
-    sockjs.add_endpoint(app, chat_msg_handler, name='chat', prefix='/sockjs/')
+
+    # Configure default CORS settings.
+    cors = aiohttp_cors.setup(app, defaults={
+        '*': aiohttp_cors.ResourceOptions(
+            allow_credentials=True,
+            expose_headers='*',
+            allow_headers='*',
+            max_age=31536000,
+        )
+    })
+
+    sockjs.add_endpoint(
+        app,
+        chat_msg_handler,
+        name='chat',
+        prefix='/sockjs/',
+        cors_config=cors,
+    )
 
     web.run_app(app)
diff --git a/requirements.txt b/requirements.txt
index 571669f6..a2afe0e8 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,12 +1,8 @@
-black==20.8b1; python_version>="3.6"
-flake8==3.8.4
-docutils==0.16
-pytest==6.2.1
-pytest-aiohttp==0.3.0
-pytest-cov==2.10.1
-pytest-sugar==0.9.4
-pytest-mock==3.4.0
-pytest-timeout==1.4.2
-sphinx==3.4.1
-aiohttp==3.7.4
--e .
+flake8==7.0.0
+pytest==8.2.2
+pytest-aiohttp==1.0.5
+pytest-mock==3.14.0
+pytest-timeout==2.3.1
+aiohttp==3.9.5
+twine==5.1.0
+-e .[test]
diff --git a/setup.cfg b/setup.cfg
index 6c896046..a2ed1736 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,11 +1,14 @@
 [easy_install]
 zip_ok = false
 
+
 [flake8]
-ignore = N801,N802,N803,E226
+ignore = N801,N802,N803,E226,W503
 max-line-length = 88
 
+
 [tool:pytest]
 timeout = 3
-filterwarnings=
-    error
+#filterwarnings=
+#    error
+asyncio_mode = auto
diff --git a/setup.py b/setup.py
index 30a3f90b..2a0e4923 100644
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,9 @@
 import codecs
 import os
 import re
-from setuptools import setup, find_packages
+
+from setuptools import find_packages, setup
+
 
 with codecs.open(
     os.path.join(os.path.abspath(os.path.dirname(__file__)), "sockjs", "__init__.py"),
@@ -13,8 +15,6 @@
     except IndexError:
         raise RuntimeError("Unable to determine version.")
 
-install_requires = ["aiohttp >= 3.0.0"]
-
 
 def read(f):
     return open(os.path.join(os.path.dirname(__file__), f)).read().strip()
@@ -31,10 +31,9 @@ def read(f):
         "Intended Audience :: Developers",
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.5",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: Implementation :: CPython",
         "Topic :: Internet :: WWW/HTTP",
         "Framework :: AsyncIO",
@@ -44,8 +43,23 @@ def read(f):
     url="https://github.com/aio-libs/sockjs/",
     license="Apache 2",
     packages=find_packages(),
-    python_requires=">=3.5.3",
-    install_requires=install_requires,
+    python_requires=">=3.10.0",
+    install_requires=[
+        "aiohttp>=3.7.4",
+        "async-timeout>=4.0.3",
+    ],
+    extras_require={
+        "test": [
+            "pytest",
+            "multidict",
+            "yarl",
+            "pytest-aiohttp",
+            "pytest-mock",
+            "pytest-timeout",
+            "cykooz.testing",
+            "aiohttp_cors",
+        ],
+    },
     include_package_data=True,
     zip_safe=False,
 )
diff --git a/sockjs-testsrv.py b/sockjs-testsrv.py
index 6c2a7bce..10541285 100644
--- a/sockjs-testsrv.py
+++ b/sockjs-testsrv.py
@@ -1,5 +1,5 @@
-import asyncio
 import logging
+
 from aiohttp import web
 
 import sockjs
@@ -8,24 +8,23 @@
 from sockjs.transports.xhrstreaming import XHRStreamingTransport
 
 
-async def echoSession(msg, session):
-    if msg.type == sockjs.MSG_MESSAGE:
+async def echo_session(manager, session, msg):
+    if msg.type == sockjs.MsgType.MESSAGE:
         session.send(msg.data)
 
 
-async def closeSessionHander(msg, session):
-    if msg.type == sockjs.MSG_OPEN:
+async def close_session_handler(manager, session, msg):
+    if msg.type == sockjs.MsgType.OPEN:
         session.close()
 
 
-async def broadcastSession(msg, session):
-    if msg.type == sockjs.MSG_OPEN:
-        session.manager.broadcast(msg.data)
+async def broadcast_session(manager, session, msg):
+    if msg.type == sockjs.MsgType.OPEN:
+        manager.broadcast(msg.data)
 
 
 if __name__ == '__main__':
     """ Sockjs tests server """
-    loop = asyncio.get_event_loop()
     logging.basicConfig(level=logging.DEBUG,
                         format='%(asctime)s %(levelname)s %(message)s')
 
@@ -33,19 +32,24 @@ async def broadcastSession(msg, session):
     EventsourceTransport.maxsize = 4096
     XHRStreamingTransport.maxsize = 4096
 
-    app = web.Application(loop=loop)
+    app = web.Application()
 
     sockjs.add_endpoint(
-        app, echoSession, name='echo', prefix='/echo')
+        app, echo_session, name='echo', prefix='/echo'
+    )
     sockjs.add_endpoint(
-        app, closeSessionHander, name='close', prefix='/close')
+        app, close_session_handler, name='close', prefix='/close'
+    )
     sockjs.add_endpoint(
-        app, broadcastSession, name='broadcast', prefix='/broadcast')
+        app, broadcast_session, name='broadcast', prefix='/broadcast'
+    )
     sockjs.add_endpoint(
-        app, echoSession, name='wsoff', prefix='/disabled_websocket_echo',
+        app, echo_session, name='wsoff', prefix='/disabled_websocket_echo',
         disable_transports=('websocket',))
+
     sockjs.add_endpoint(
-        app, echoSession, name='cookie', prefix='/cookie_needed_echo',
-        cookie_needed=True)
+        app, echo_session, name='cookie', prefix='/cookie_needed_echo',
+        cookie_needed=True
+    )
 
-    web.run_app(app)
+    web.run_app(app, port=8081)
diff --git a/sockjs/__init__.py b/sockjs/__init__.py
index 090bdac1..b37cec96 100644
--- a/sockjs/__init__.py
+++ b/sockjs/__init__.py
@@ -1,27 +1,10 @@
-# pyramid_sockjs
+from .exceptions import SessionIsAcquired, SessionIsClosed
+from .protocol import SessionState, MsgType, Frame, SockjsMessage
+from .route import add_endpoint, get_manager
+from .session import Session, SessionManager
 
-# Session, SessionManager are not imported
-
-from sockjs.session import Session
-from sockjs.session import SessionManager
-from sockjs.exceptions import SessionIsClosed
-from sockjs.exceptions import SessionIsAcquired
-
-from sockjs.protocol import STATE_NEW
-from sockjs.protocol import STATE_OPEN
-from sockjs.protocol import STATE_CLOSING
-from sockjs.protocol import STATE_CLOSED
-
-from sockjs.protocol import MSG_OPEN
-from sockjs.protocol import MSG_MESSAGE
-from sockjs.protocol import MSG_CLOSE
-from sockjs.protocol import MSG_CLOSED
-
-from sockjs.route import get_manager, add_endpoint
-
-
-__version__ = "0.11.0"
 
+__version__ = "0.13.0"
 
 __all__ = (
     "get_manager",
@@ -30,12 +13,8 @@
     "SessionManager",
     "SessionIsClosed",
     "SessionIsAcquired",
-    "STATE_NEW",
-    "STATE_OPEN",
-    "STATE_CLOSING",
-    "STATE_CLOSED",
-    "MSG_OPEN",
-    "MSG_MESSAGE",
-    "MSG_CLOSE",
-    "MSG_CLOSED",
+    "SessionState",
+    "MsgType",
+    "Frame",
+    "SockjsMessage",
 )
diff --git a/sockjs/protocol.py b/sockjs/protocol.py
index cf9ba367..61c0868f 100644
--- a/sockjs/protocol.py
+++ b/sockjs/protocol.py
@@ -1,13 +1,19 @@
-import collections
+import dataclasses
+import enum
 import hashlib
 from datetime import datetime
+from typing import Union
+
 
 ENCODING = "utf-8"
 
-STATE_NEW = 0
-STATE_OPEN = 1
-STATE_CLOSING = 2
-STATE_CLOSED = 3
+
+@enum.unique
+class SessionState(enum.Enum):
+    NEW = 0
+    OPEN = 1
+    CLOSING = 2
+    CLOSED = 3
 
 
 _days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
@@ -62,11 +68,14 @@ def dthandler(obj):
 # Frames
 # ------
 
-FRAME_OPEN = "o"
-FRAME_CLOSE = "c"
-FRAME_MESSAGE = "a"
-FRAME_MESSAGE_BLOB = "a1"
-FRAME_HEARTBEAT = "h"
+
+@enum.unique
+class Frame(enum.Enum):
+    OPEN = "o"
+    CLOSE = "c"
+    MESSAGE = "a"
+    MESSAGE_BLOB = "a1"
+    HEARTBEAT = "h"
 
 
 # ------------------
@@ -74,8 +83,8 @@ def dthandler(obj):
 IFRAME_HTML = """<!DOCTYPE html>
 <html>
 <head>
-<meta http-equiv="X-UA-Compatible" content="IE=edge" />
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
   <script src="%s"></script>
   <script>
     document.domain = document.domain;
@@ -89,7 +98,6 @@ def dthandler(obj):
 </html>
 """.strip()
 
-
 IFRAME_MD5 = hashlib.md5(IFRAME_HTML.encode()).hexdigest()
 
 loads = json.loads
@@ -101,32 +109,39 @@ def dumps(data):
 
 
 def close_frame(code, reason):
-    return FRAME_CLOSE + json.dumps([code, reason], **kwargs)
+    return Frame.CLOSE.value + json.dumps([code, reason], **kwargs)
 
 
 def message_frame(message):
-    return FRAME_MESSAGE + json.dumps([message], **kwargs)
+    return Frame.MESSAGE.value + json.dumps([message], **kwargs)
 
 
 def messages_frame(messages):
-    return FRAME_MESSAGE + json.dumps(messages, **kwargs)
+    return Frame.MESSAGE.value + json.dumps(messages, **kwargs)
 
 
 # Handler messages
 # ---------------------
 
-MSG_OPEN = 1
-MSG_MESSAGE = 2
-MSG_CLOSE = 3
-MSG_CLOSED = 4
 
+@enum.unique
+class MsgType(enum.Enum):
+    OPEN = 1
+    MESSAGE = 2
+    CLOSE = 3
+    CLOSED = 4
+
+
+@dataclasses.dataclass(frozen=True)
+class SockjsMessage:
+    type: MsgType
+    data: Union[str, Exception, None]
 
-class SockjsMessage(collections.namedtuple("SockjsMessage", ["type", "data"])):
     @property
-    def tp(self):
+    def tp(self) -> MsgType:
         return self.type
 
 
-OpenMessage = SockjsMessage(MSG_OPEN, None)
-CloseMessage = SockjsMessage(MSG_CLOSE, None)
-ClosedMessage = SockjsMessage(MSG_CLOSED, None)
+OPEN_MESSAGE = SockjsMessage(MsgType.OPEN, None)
+CLOSE_MESSAGE = SockjsMessage(MsgType.CLOSE, None)
+CLOSED_MESSAGE = SockjsMessage(MsgType.CLOSED, None)
diff --git a/sockjs/route.py b/sockjs/route.py
index 6ad48aa3..09a535c9 100644
--- a/sockjs/route.py
+++ b/sockjs/route.py
@@ -1,24 +1,33 @@
 import asyncio
-import json
-import random
-import logging
 import hashlib
 import inspect
-from aiohttp import web, hdrs
+import json
+import logging
+import random
+from typing import Iterable, List, Optional, Type
+
+from aiohttp import hdrs, web
+from aiohttp.web_request import Request
+
+
+try:
+    from aiohttp_cors import CorsConfig
+except ImportError:
+    CorsConfig = None
+
+from .protocol import IFRAME_HTML
+from .session import SessionManager, HandlerType
+from .transports import transport_handlers
+from .transports.base import Transport
+from .transports.rawwebsocket import RawWebSocketTransport
+from .transports.utils import CACHE_CONTROL, cache_headers, session_cookie
 
-from sockjs.session import SessionManager
-from sockjs.protocol import IFRAME_HTML
-from sockjs.transports import handlers
-from sockjs.transports.utils import CACHE_CONTROL
-from sockjs.transports.utils import session_cookie
-from sockjs.transports.utils import cors_headers
-from sockjs.transports.utils import cache_headers
-from sockjs.transports.rawwebsocket import RawWebSocketTransport
 
 log = logging.getLogger("sockjs")
+ALL_METH_WO_OPTIONS = hdrs.METH_ALL - {hdrs.METH_OPTIONS}
 
 
-def get_manager(name, app):
+def get_manager(name, app) -> SessionManager:
     return app["__sockjs_managers__"][name]
 
 
@@ -27,22 +36,30 @@ def _gen_endpoint_name():
 
 
 def add_endpoint(
-    app,
-    handler,
+    app: web.Application,
+    handler: HandlerType,
     *,
     name="",
     prefix="/sockjs",
     manager=None,
     disable_transports=(),
     sockjs_cdn="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js",  # noqa
-    cookie_needed=True
-):
+    cookie_needed=True,
+    cors_config: Optional[CorsConfig] = None,
+    heartbeat_delay=25,
+    disconnect_delay=5,
+    debug=False,
+) -> List[web.AbstractRoute]:
+    registered_routes = []
 
     assert callable(handler), handler
     if not asyncio.iscoroutinefunction(handler) and not inspect.isgeneratorfunction(
         handler
     ):
-        handler = asyncio.coroutine(handler)
+        sync_handler = handler
+
+        async def handler(m, s, msg):
+            return sync_handler(m, s, msg)
 
     router = app.router
 
@@ -51,7 +68,14 @@ def add_endpoint(
 
     # set session manager
     if manager is None:
-        manager = SessionManager(name, app, handler)
+        manager = SessionManager(
+            name,
+            app,
+            handler,
+            heartbeat_delay,
+            disconnect_delay,
+            debug=debug,
+        )
 
     if manager.name != name:
         raise ValueError("Session manage must have same name as sockjs route")
@@ -64,83 +88,114 @@ def add_endpoint(
 
     # register routes
     route = SockJSRoute(
-        name, manager, sockjs_cdn, handlers, disable_transports, cookie_needed
+        name,
+        manager,
+        sockjs_cdn,
+        transport_handlers,
+        disable_transports,
+        cookie_needed,
     )
 
-    if prefix.endswith("/"):
-        prefix = prefix[:-1]
-
-    route_name = "sockjs-url-%s-greeting" % name
-    router.add_route(hdrs.METH_GET, prefix, route.greeting, name=route_name)
-
-    route_name = "sockjs-url-%s" % name
-    router.add_route(hdrs.METH_GET, "%s/" % prefix, route.greeting, name=route_name)
-
-    route_name = "sockjs-%s" % name
-    router.add_route(
-        hdrs.METH_ANY,
-        "%s/{server}/{session}/{transport}" % prefix,
-        route.handler,
-        name=route_name,
+    prefix = prefix.rstrip("/")
+    route_name = "sockjs-greeting-%s" % name
+    registered_routes.append(
+        router.add_route(hdrs.METH_GET, prefix, route.greeting, name=route_name)
     )
 
-    route_name = "sockjs-websocket-%s" % name
-    router.add_route(
-        hdrs.METH_GET, "%s/websocket" % prefix, route.websocket, name=route_name
+    route_name = "sockjs-greeting-ts-%s" % name
+    registered_routes.append(
+        router.add_route(hdrs.METH_GET, "%s/" % prefix, route.greeting, name=route_name)
     )
 
-    router.add_route(
-        hdrs.METH_GET, "%s/info" % prefix, route.info, name="sockjs-info-%s" % name
+    resource = router.add_resource(
+        "%s/{server}/{session}/{transport}" % prefix, name=f"sockjs-transport-{name}"
     )
-    router.add_route(
-        hdrs.METH_OPTIONS,
-        "%s/info" % prefix,
-        route.info_options,
-        name="sockjs-info-options-%s" % name,
+    for method in ALL_METH_WO_OPTIONS:
+        registered_routes.append(
+            resource.add_route(
+                method,
+                route.handler,
+            )
+        )
+
+    if "websocket-raw" not in route.disable_transports:
+        route_name = "sockjs-websocket-%s" % name
+        registered_routes.append(
+            router.add_route(
+                hdrs.METH_GET,
+                "%s/websocket" % prefix,
+                route.websocket,
+                name=route_name,
+            )
+        )
+
+    registered_routes.append(
+        router.add_route(
+            hdrs.METH_GET,
+            "%s/info" % prefix,
+            route.info,
+            name="sockjs-info-%s" % name,
+        )
     )
 
     route_name = "sockjs-iframe-%s" % name
-    router.add_route(
-        hdrs.METH_GET, "%s/iframe.html" % prefix, route.iframe, name=route_name
+    registered_routes.append(
+        router.add_route(
+            hdrs.METH_GET, "%s/iframe.html" % prefix, route.iframe, name=route_name
+        )
     )
 
     route_name = "sockjs-iframe-ver-%s" % name
-    router.add_route(
-        hdrs.METH_GET, "%s/iframe{version}.html" % prefix, route.iframe, name=route_name
+    registered_routes.append(
+        router.add_route(
+            hdrs.METH_GET,
+            "%s/iframe{version}.html" % prefix,
+            route.iframe,
+            name=route_name,
+        )
     )
 
-    # start session gc
-    manager.start()
+    app.on_cleanup.append(manager.stop)
+
+    if cors_config is not None:
+        # Configure CORS on all routes.
+        for route in registered_routes:
+            cors_config.add(route)
+
+    return registered_routes
 
 
 class SockJSRoute:
     def __init__(
         self,
-        name,
-        manager,
-        sockjs_cdn,
+        name: str,
+        manager: SessionManager,
+        sockjs_cdn: str,
         handlers,
-        disable_transports,
+        disable_transports: Iterable[str],
         cookie_needed=True,
     ):
         self.name = name
         self.manager = manager
         self.handlers = handlers
-        self.disable_transports = dict((k, 1) for k in disable_transports)
+        self.disable_transports = set(disable_transports)
         self.cookie_needed = cookie_needed
         self.iframe_html = (IFRAME_HTML % sockjs_cdn).encode("utf-8")
         self.iframe_html_hxd = hashlib.md5(self.iframe_html).hexdigest()
+        transport_names = {
+            transport_class.name for transport_class in transport_handlers.values()
+        }
+        transport_names.add("websocket-raw")
+        self._transport_names = sorted(transport_names - self.disable_transports)
 
-    async def handler(self, request):
+    async def handler(self, request: Request):
         info = request.match_info
 
         # lookup transport
-        tid = info["transport"]
-
-        if tid not in self.handlers or tid in self.disable_transports:
-            return web.HTTPNotFound()
-
-        create, transport = self.handlers[tid]
+        t_id = info["transport"]
+        transport_class: Optional[Type[Transport]] = self.handlers.get(t_id)
+        if transport_class is None or transport_class.name in self.disable_transports:
+            raise web.HTTPNotFound()
 
         # session
         manager = self.manager
@@ -149,30 +204,39 @@ async def handler(self, request):
 
         sid = info["session"]
         if not sid or "." in sid or "." in info["server"]:
-            return web.HTTPNotFound()
+            raise web.HTTPNotFound()
 
         try:
-            session = manager.get(sid, create, request=request)
+            session = transport_class.get_session(manager, sid)
         except KeyError:
-            return web.HTTPNotFound(headers=session_cookie(request))
+            raise web.HTTPNotFound(headers=session_cookie(request))
 
-        t = transport(manager, session, request)
+        request["sockjs_transport_name"] = transport_class.name
+        transport = transport_class(manager, session, request)
         try:
-            return await t.process()
-        except asyncio.CancelledError:
+            return await transport.process()
+        except (asyncio.CancelledError, web.HTTPException, ConnectionError) as e:
+            if transport.create_session:
+                await manager.remote_close(session, exc=e)
             raise
-        except web.HTTPException as exc:
-            return exc
-        except Exception:
-            log.exception("Exception in transport: %s" % tid)
-            if manager.is_acquired(session):
+        except Exception as e:
+            log.exception("Exception in transport: %s" % t_id)
+            if transport.create_session:
+                await manager.remote_close(session, exc=e)
+            raise web.HTTPInternalServerError()
+        finally:
+            if transport.create_session and manager.is_acquired(session):
+                await manager.remote_close(session)
+                await manager.remote_closed(session)
                 await manager.release(session)
-            return web.HTTPInternalServerError()
 
     async def websocket(self, request):
+        if not self.manager.started:
+            self.manager.start()
+
         # session
         sid = "%0.9d" % random.randint(1, 2147483647)
-        session = self.manager.get(sid, True, request=request)
+        session = self.manager.get(sid, True)
 
         transport = RawWebSocketTransport(self.manager, session, request)
         try:
@@ -180,33 +244,23 @@ async def websocket(self, request):
         except asyncio.CancelledError:
             raise
         except web.HTTPException as exc:
-            return exc
+            raise exc
 
     async def info(self, request):
         resp = web.Response()
         resp.headers[hdrs.CONTENT_TYPE] = "application/json;charset=UTF-8"
         resp.headers[hdrs.CACHE_CONTROL] = CACHE_CONTROL
-        resp.headers.extend(cors_headers(request.headers))
 
         info = {
             "entropy": random.randint(1, 2147483647),
-            "websocket": "websocket" not in self.disable_transports,
+            "websocket": "websocket" in self._transport_names,
             "cookie_needed": self.cookie_needed,
             "origins": ["*:*"],
+            "transports": self._transport_names,
         }
         resp.text = json.dumps(info)
         return resp
 
-    async def info_options(self, request):
-        resp = web.Response(status=204)
-        resp.headers[hdrs.CONTENT_TYPE] = "application/json;charset=UTF-8"
-        resp.headers[hdrs.CACHE_CONTROL] = CACHE_CONTROL
-        resp.headers[hdrs.ACCESS_CONTROL_ALLOW_METHODS] = "OPTIONS, GET"
-        resp.headers.extend(cors_headers(request.headers))
-        resp.headers.extend(cache_headers())
-        resp.headers.extend(session_cookie(request))
-        return resp
-
     async def iframe(self, request):
         cached = request.headers.get(hdrs.IF_NONE_MATCH)
         if cached:
@@ -215,15 +269,15 @@ async def iframe(self, request):
             response.headers.extend(cache_headers())
             return response
 
-        headers = (
-            (hdrs.CONTENT_TYPE, "text/html;charset=UTF-8"),
-            (hdrs.ETAG, self.iframe_html_hxd),
-        )
-        headers += cache_headers()
+        headers = {
+            hdrs.CONTENT_TYPE: "text/html;charset=UTF-8",
+            hdrs.ETAG: self.iframe_html_hxd,
+        }
+        headers.update(dict(cache_headers()))
         return web.Response(body=self.iframe_html, headers=headers)
 
     async def greeting(self, request):
         return web.Response(
             body=b"Welcome to SockJS!\n",
-            headers=((hdrs.CONTENT_TYPE, "text/plain; charset=UTF-8"),),
+            headers={hdrs.CONTENT_TYPE: "text/plain; charset=UTF-8"},
         )
diff --git a/sockjs/session.py b/sockjs/session.py
index 7c8c425e..126ef445 100644
--- a/sockjs/session.py
+++ b/sockjs/session.py
@@ -1,66 +1,71 @@
-import warnings
 import asyncio
-import collections
 import logging
+import warnings
+from collections import deque
 from datetime import datetime, timedelta
+from typing import Optional, Tuple, Callable, Awaitable, TypeVar, Union, Any
 
-from asyncio import ensure_future
+from aiohttp import web
 
-from .protocol import STATE_NEW, STATE_OPEN, STATE_CLOSING, STATE_CLOSED
-from .protocol import FRAME_OPEN, FRAME_CLOSE
-from .protocol import FRAME_MESSAGE, FRAME_MESSAGE_BLOB, FRAME_HEARTBEAT
+from . import SessionState
 from .exceptions import SessionIsAcquired, SessionIsClosed
-
-from .protocol import MSG_CLOSE, MSG_MESSAGE
-from .protocol import close_frame, message_frame, messages_frame
-from .protocol import SockjsMessage, OpenMessage, ClosedMessage
+from .protocol import (
+    CLOSED_MESSAGE,
+    MsgType,
+    OPEN_MESSAGE,
+    SockjsMessage,
+    close_frame,
+    message_frame,
+    messages_frame,
+    Frame,
+)
 
 
 log = logging.getLogger("sockjs")
+HandlerType = Callable[["SessionManager", "Session", SockjsMessage], Awaitable]
 
 
-class Session(object):
-    """SockJS session object
+class Session:
+    """SockJS session object.
 
     ``state``: Session state
 
     ``manager``: Session manager that hold this session
 
     ``acquired``: Acquired state, indicates that transport is using session
-
-    ``timeout``: Session timeout
-
     """
 
-    manager = None
     acquired = False
-    state = STATE_NEW
+    state = SessionState.NEW
     interrupted = False
     exception = None
+    _hb_task = None
 
     def __init__(
-        self, id, handler, request, *, timeout=timedelta(seconds=10), debug=False
+        self, session_id: str, *, heartbeat_delay=25, disconnect_delay=5, debug=False,
     ):
-        self.id = id
-        self.handler = handler
-        self.request = request
-        self.expired = False
-        self.timeout = timeout
-        self.expires = datetime.now() + timeout
+        self.id = session_id
+        self.heartbeat_delay = heartbeat_delay
+        self.disconnect_delay = disconnect_delay
+        self.next_heartbeat = datetime.now() + timedelta(seconds=heartbeat_delay)
+        self.expires: Optional[datetime] = datetime.now() + timedelta(
+            seconds=disconnect_delay
+        )
+        self.request: Optional[web.Request] = None
 
         self._hits = 0
         self._heartbeats = 0
-        self._heartbeat_transport = False
+        self._send_heartbeats = False
         self._debug = debug
         self._waiter = None
-        self._queue = collections.deque()
+        self._queue: deque[tuple[Frame, Any]] = deque()
 
     def __str__(self):
         result = ["id=%r" % (self.id,)]
 
-        if self.state == STATE_OPEN:
+        if self.state == SessionState.OPEN:
             result.append("connected")
-        elif self.state == STATE_CLOSED:
+        elif self.state == SessionState.CLOSED:
             result.append("closed")
         else:
             result.append("disconnected")
@@ -77,109 +82,111 @@ def __str__(self):
 
         return " ".join(result)
 
-    def _tick(self, timeout=None):
-        if timeout is None:
-            self.expires = datetime.now() + self.timeout
-        else:
-            self.expires = datetime.now() + timeout
+    def expire(self):
+        """Manually expire a session."""
+        expires = datetime.now()
+        if self.disconnect_delay:
+            expires += timedelta(seconds=self.disconnect_delay)
+        if not self.expires or self.expires > expires:
+            self.expires = expires
 
-    async def _acquire(self, manager, heartbeat=True):
+    @property
+    def expired(self) -> bool:
+        if self.expires:
+            return self.expires <= datetime.now()
+        return False
+
+    def acquire(self, request: web.Request) -> bool:
+        """Returns True if session has opened."""
         self.acquired = True
-        self.manager = manager
-        self._heartbeat_transport = heartbeat
+        self.request = request
+        self.expires = None
+        self._send_heartbeats = self.heartbeat_delay > 0
 
-        self._tick()
+        self.tick()
         self._hits += 1
 
-        if self.state == STATE_NEW:
-            log.debug("open session: %s", self.id)
-            self.state = STATE_OPEN
-            self._feed(FRAME_OPEN, FRAME_OPEN)
-            try:
-                await self.handler(OpenMessage, self)
-            except asyncio.CancelledError:
-                raise
-            except Exception as exc:
-                self.state = STATE_CLOSING
-                self.exception = exc
-                self.interrupted = True
-                self._feed(FRAME_CLOSE, (3000, "Internal error"))
-                log.exception("Exception in open session handling.")
+        if self.state == SessionState.NEW:
+            if self._debug:
+                log.debug("open session: %s", self.id)
+            self.state = SessionState.OPEN
+            self.feed(Frame.OPEN, Frame.OPEN.value)
+            return True
 
-    def _release(self):
+        return False
+
+    def release(self):
         self.acquired = False
-        self.manager = None
-        self._heartbeat_transport = False
+        self.request = None
+        self._send_heartbeats = False
+        if self._hb_task is not None:
+            try:
+                self._hb_task.cancel()
+            except RuntimeError:
+                pass  # an event loop already stopped
+        self._hb_task = None
 
-    def _heartbeat(self):
-        self._heartbeats += 1
-        if self._heartbeat:
-            self._feed(FRAME_HEARTBEAT, FRAME_HEARTBEAT)
+    def create_heartbeat_task(self):
+        if self._hb_task is None and self._send_heartbeats:
+            self._hb_task = asyncio.create_task(self._heartbeat_task())
 
-    def _feed(self, frame, data):
+    def tick(self, timeout=None):
+        if timeout is None:
+            self.next_heartbeat = datetime.now() + timedelta(
+                seconds=self.heartbeat_delay
+            )
+        else:
+            self.next_heartbeat = datetime.now() + timedelta(seconds=timeout)
+
+    def heartbeat(self):
+        if self._send_heartbeats:
+            self.feed(Frame.HEARTBEAT, Frame.HEARTBEAT.value)
+            self._heartbeats += 1
+
+    async def _heartbeat_task(self):
+        while True:
+            now = datetime.now()
+            if self.next_heartbeat <= now:
+                self.heartbeat()
+                self.tick()
+            delta = (self.next_heartbeat - now).total_seconds()
+            if delta > 0:
+                await asyncio.sleep(delta)
+
+    def feed(self, frame: Frame, data):
         # pack messages
-        if frame == FRAME_MESSAGE:
-            if self._queue and self._queue[-1][0] == FRAME_MESSAGE:
+        if frame == Frame.MESSAGE:
+            if self._queue and self._queue[-1][0] == Frame.MESSAGE:
                 self._queue[-1][1].append(data)
             else:
                 self._queue.append((frame, [data]))
         else:
             self._queue.append((frame, data))
 
-        # notify waiter
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            if not waiter.cancelled():
-                waiter.set_result(True)
+        self.release_waiters()
+        self.tick()
 
-    async def _wait(self, pack=True):
-        if not self._queue and self.state != STATE_CLOSED:
+    async def get_frame(self, pack=True) -> Tuple[Frame, str]:
+        if not self._queue and self.state != SessionState.CLOSED:
             assert not self._waiter
-            loop = asyncio.get_event_loop()
-            self._waiter = loop.create_future()
+            self._waiter = asyncio.Future()
             await self._waiter
 
         if self._queue:
             frame, payload = self._queue.popleft()
-            self._tick()
+            self.tick()
             if pack:
-                if frame == FRAME_CLOSE:
-                    return FRAME_CLOSE, close_frame(*payload)
-                elif frame == FRAME_MESSAGE:
-                    return FRAME_MESSAGE, messages_frame(payload)
+                match frame:
+                    case Frame.CLOSE:
+                        return frame, close_frame(*payload)
+                    case Frame.MESSAGE:
+                        return frame, messages_frame(payload)
 
             return frame, payload
         else:
             raise SessionIsClosed()
 
-    async def _remote_close(self, exc=None):
-        """close session from remote."""
-        if self.state in (STATE_CLOSING, STATE_CLOSED):
-            return
-
-        log.info("close session: %s", self.id)
-        self.state = STATE_CLOSING
-        if exc is not None:
-            self.exception = exc
-            self.interrupted = True
-        try:
-            await self.handler(SockjsMessage(MSG_CLOSE, exc), self)
-        except Exception:
-            log.exception("Exception in close handler.")
-
-    async def _remote_closed(self):
-        if self.state == STATE_CLOSED:
-            return
-
-        log.info("session closed: %s", self.id)
-        self.state = STATE_CLOSED
-        self.expire()
-        try:
-            await self.handler(ClosedMessage, self)
-        except Exception:
-            log.exception("Exception in closed handler.")
-
+    def release_waiters(self):
         # notify waiter
         waiter = self._waiter
         if waiter is not None:
@@ -187,79 +194,56 @@ async def _remote_closed(self):
             if not waiter.cancelled():
                 waiter.set_result(True)
 
-    async def _remote_message(self, msg):
-        log.debug("incoming message: %s, %s", self.id, msg[:200])
-        self._tick()
-
-        try:
-            await self.handler(SockjsMessage(MSG_MESSAGE, msg), self)
-        except Exception:
-            log.exception("Exception in message handler.")
-
-    async def _remote_messages(self, messages):
-        self._tick()
-
-        for msg in messages:
-            log.debug("incoming message: %s, %s", self.id, msg[:200])
-            try:
-                await self.handler(SockjsMessage(MSG_MESSAGE, msg), self)
-            except Exception:
-                log.exception("Exception in message handler.")
-
-    def expire(self):
-        """Manually expire a session."""
-        self.expired = True
-
-    def send(self, msg):
+    def send(self, msg: str) -> bool:
         """send message to client."""
         assert isinstance(msg, str), "String is required"
 
         if self._debug:
             log.info("outgoing message: %s, %s", self.id, str(msg)[:200])
 
-        if self.state != STATE_OPEN:
-            return
+        if self.state != SessionState.OPEN:
+            return False
 
-        self._feed(FRAME_MESSAGE, msg)
+        self.feed(Frame.MESSAGE, msg)
+        return True
 
     def send_frame(self, frm):
         """send message frame to client."""
         if self._debug:
             log.info("outgoing message: %s, %s", self.id, frm[:200])
 
-        if self.state != STATE_OPEN:
+        if self.state != SessionState.OPEN:
             return
 
-        self._feed(FRAME_MESSAGE_BLOB, frm)
+        self.feed(Frame.MESSAGE_BLOB, frm)
 
     def close(self, code=3000, reason="Go away!"):
         """close session"""
-        if self.state in (STATE_CLOSING, STATE_CLOSED):
+        if self.state in (SessionState.CLOSING, SessionState.CLOSED):
             return
 
         if self._debug:
             log.debug("close session: %s", self.id)
 
-        self.state = STATE_CLOSING
-        self._feed(FRAME_CLOSE, (code, reason))
+        self.state = SessionState.CLOSING
+        self.feed(Frame.CLOSE, (code, reason))
 
 
 _marker = object()
 
 
-class SessionManager(dict):
+class SessionManager:
     """A basic session manager."""
 
-    _hb_handle = None  # heartbeat event loop timer
-    _hb_task = None  # gc task
+    _gc_task = None
 
     def __init__(
         self,
-        name,
-        app,
-        handler,
-        heartbeat=25.0,
-        timeout=timedelta(seconds=5),
+        name: str,
+        app: web.Application,
+        handler: HandlerType,
+        heartbeat_delay=25,
+        disconnect_delay=5,
         debug=False,
     ):
         self.name = name
@@ -268,144 +252,210 @@ def __init__(
         self.handler = handler
         self.factory = Session
         self.acquired = {}
-        self.sessions = []
-        self.heartbeat = heartbeat
-        self.timeout = timeout
+        self.sessions: dict[str, Session] = {}
+        self.heartbeat_delay = heartbeat_delay
+        self.disconnect_delay = disconnect_delay
         self.debug = debug
 
-    def route_url(self, request):
-        return request.route_url(self.route_name)
-
     @property
     def started(self):
-        return self._hb_handle is not None
+        return self._gc_task is not None
 
     def start(self):
-        if not self._hb_handle:
-            loop = asyncio.get_event_loop()
-            self._hb_handle = loop.call_later(self.heartbeat, self._heartbeat)
-
-    def stop(self):
-        if self._hb_handle is not None:
-            self._hb_handle.cancel()
-            self._hb_handle = None
-        if self._hb_task is not None:
-            self._hb_task.cancel()
-            self._hb_task = None
+        if not self._gc_task:
+            self._gc_task = asyncio.create_task(self._gc_sessions_task())
 
-    def _heartbeat(self):
-        if self._hb_task is None:
-            self._hb_task = ensure_future(self._heartbeat_task())
+    async def stop(self, _app=None):
+        if self._gc_task is not None:
+            try:
+                self._gc_task.cancel()
+            except RuntimeError:
+                pass  # an event loop already stopped
+        self._gc_task = None
+        await self.clear()
 
-    async def _heartbeat_task(self):
+    async def _check_expiration(self, session: Session):
+        if session.expired:
+            if self.debug:
+                log.debug("session expired: %s", session.id)
+            # Session is to be GC'd immediately
+            if session.id in self.acquired:
+                await self.release(session)
+            if session.state == SessionState.OPEN:
+                await self.remote_close(session)
+            if session.state == SessionState.CLOSING:
+                await self.remote_closed(session)
+            return session.id
+
+    async def _gc_sessions_task(self):
+        delay = max(self.disconnect_delay, 5)
+        while True:
+            await asyncio.sleep(delay)
+            await self._gc_expired_sessions()
+
+    async def _gc_expired_sessions(self):
         sessions = self.sessions
-
         if sessions:
-            now = datetime.now()
+            tasks = [self._check_expiration(session) for session in sessions.values()]
+            expired_session_ids = await asyncio.gather(*tasks)
 
             idx = 0
-            while idx < len(sessions):
-                session = sessions[idx]
-
-                session._heartbeat()
-
-                if session.expires < now:
-                    # Session is to be GC'd immedietely
-                    if session.id in self.acquired:
-                        await self.release(session)
-                    if session.state == STATE_OPEN:
-                        await session._remote_close()
-                    if session.state == STATE_CLOSING:
-                        await session._remote_closed()
-
-                    del self[session.id]
-                    del self.sessions[idx]
+            for session_id in expired_session_ids:
+                if session_id is None:
+                    idx += 1
                     continue
+                sessions.pop(session_id, None)
 
-                idx += 1
-
-        self._hb_task = None
-        loop = asyncio.get_event_loop()
-        self._hb_handle = loop.call_later(self.heartbeat, self._heartbeat)
-
-    def _add(self, session):
+    def _add(self, session: Session):
         if session.expired:
             raise ValueError("Can not add expired session")
 
-        session.manager = self
-        session.registry = self.app
-
-        self[session.id] = session
-        self.sessions.append(session)
+        self.sessions[session.id] = session
         return session
 
-    def get(self, id, create=False, request=None, default=_marker):
-        session = super(SessionManager, self).get(id, None)
+    _T = TypeVar("_T")
+
+    def get(
+        self,
+        session_id,
+        create=False,
+        default: _T = _marker,
+    ) -> Union[Session, _T]:
+        session = self.sessions.get(session_id, None)
         if session is None:
             if create:
                 session = self._add(
                     self.factory(
-                        id,
-                        self.handler,
-                        request,
-                        timeout=self.timeout,
+                        session_id,
+                        heartbeat_delay=self.heartbeat_delay,
+                        disconnect_delay=self.disconnect_delay,
                         debug=self.debug,
                     )
                 )
             else:
                 if default is not _marker:
                     return default
-                raise KeyError(id)
+                raise KeyError(session_id)
 
         return session
 
-    async def acquire(self, s):
-        sid = s.id
+    async def acquire(self, session: Session, request: web.Request):
+        sid = session.id
 
         if sid in self.acquired:
             raise SessionIsAcquired("Another connection still open")
-        if sid not in self:
+        if sid not in self.sessions:
             raise KeyError("Unknown session")
 
-        await s._acquire(self)
+        if session.acquire(request):
+            try:
+                await self.handler(self, session, OPEN_MESSAGE)
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                session.state = SessionState.CLOSING
+                session.exception = exc
+                session.interrupted = True
+                session.feed(Frame.CLOSE, (3000, "Internal error"))
+                log.exception("Exception in open session handling.")
+
+        session.create_heartbeat_task()
 
         self.acquired[sid] = True
-        return s
+        return session
 
     def is_acquired(self, session):
         return session.id in self.acquired
 
-    async def release(self, s):
+    async def release(self, s: Session):
         if s.id in self.acquired:
-            s._release()
+            s.release()
             del self.acquired[s.id]
 
     def active_sessions(self):
-        for session in list(self.values()):
+        for session in list(self.sessions.values()):
             if not session.expired:
                 yield session
 
     async def clear(self):
         """Manually expire all sessions in the pool."""
-        for session in list(self.values()):
-            if session.state != STATE_CLOSED:
-                await session._remote_closed()
-
+        for session in list(self.sessions.values()):
+            if session.state != SessionState.CLOSED:
+                session.disconnect_delay = 0
+                await self.remote_closed(session)
         self.sessions.clear()
-        super(SessionManager, self).clear()
 
-    def broadcast(self, message):
+    def broadcast(self, message, exclude_session_ids: Optional[set] = None):
         blob = message_frame(message)
+        exclude_session_ids = exclude_session_ids or set()
 
-        for session in list(self.values()):
-            if not session.expired:
+        for session in self.sessions.values():
+            if not session.expired and session.id not in exclude_session_ids:
                 session.send_frame(blob)
 
     def __del__(self):
-        if len(self.sessions):
+        if len(self.sessions) or self._gc_task is not None:
             warnings.warn(
-                "Unclosed sessions! "
-                "Please call `await SessionManager.clear()` before del",
+                "Please call `await SessionManager.stop()` before del",
                 RuntimeWarning,
             )
-        self.stop()
+
+    async def remote_message(self, session: Session, msg):
+        """Call handler with message received from client."""
+        if self.debug:
+            log.debug("incoming message: %s, %s", session.id, msg[:200])
+        session.tick()
+
+        try:
+            await self.handler(self, session, SockjsMessage(MsgType.MESSAGE, msg))
+        except Exception:
+            log.exception("Exception in message handler.")
+
+    async def remote_messages(self, session: Session, messages):
+        """Call handler for all messages received from client."""
+        session.tick()
+
+        for msg in messages:
+            if self.debug:
+                log.debug("incoming message: %s, %s", session.id, msg[:200])
+            try:
+                await self.handler(self, session, SockjsMessage(MsgType.MESSAGE, msg))
+            except Exception:
+                log.exception("Exception in message handler.")
+
+    async def remote_close(self, session: Session, exc=None):
+        """Start session closing."""
+        if session.state in (SessionState.CLOSING, SessionState.CLOSED):
+            return
+
+        if self.debug:
+            log.info("close session: %s", session.id)
+        session.tick()
+        session.state = SessionState.CLOSING
+        if exc is not None:
+            session.exception = exc
+            session.interrupted = True
+        try:
+            await self.handler(self, session, SockjsMessage(MsgType.CLOSE, exc))
+        except Exception:
+            log.exception("Exception in close handler.")
+
+    async def remote_closed(self, session: Session):
+        """Close session."""
+        if session.state == SessionState.CLOSED:
+            return
+
+        if session.disconnect_delay and not session.expired:
+            session.expire()
+            return
+
+        if self.debug:
+            log.info("session closed: %s", session.id)
+        session.state = SessionState.CLOSED
+        session.expire()
+        try:
+            await self.handler(self, session, CLOSED_MESSAGE)
+        except Exception:
+            log.exception("Exception in closed handler.")
+
+        session.release_waiters()
diff --git a/sockjs/transports/__init__.py b/sockjs/transports/__init__.py
index d45d3ec5..1c9c75f9 100644
--- a/sockjs/transports/__init__.py
+++ b/sockjs/transports/__init__.py
@@ -1,21 +1,19 @@
 # sockjs transports
-
-from .jsonp import JSONPolling
-from .websocket import WebSocketTransport
-from .htmlfile import HTMLFileTransport
 from .eventsource import EventsourceTransport
-from .xhr import XHRTransport
-from .xhrsend import XHRSendTransport
+from .htmlfile import HTMLFileTransport
+from .jsonp import JSONPolling, JSONPollingSend
+from .websocket import WebSocketTransport
+from .xhr_pooling import XHRTransport, XHRSendTransport
 from .xhrstreaming import XHRStreamingTransport
 
 
-handlers = {
-    "websocket": (True, WebSocketTransport),
-    "xhr": (True, XHRTransport),
-    "xhr_send": (False, XHRSendTransport),
-    "xhr_streaming": (True, XHRStreamingTransport),
-    "jsonp": (True, JSONPolling),
-    "jsonp_send": (False, JSONPolling),
-    "htmlfile": (True, HTMLFileTransport),
-    "eventsource": (True, EventsourceTransport),
+transport_handlers = {
+    "websocket": WebSocketTransport,
+    "xhr": XHRTransport,
+    "xhr_send": XHRSendTransport,
+    "xhr_streaming": XHRStreamingTransport,
+    "jsonp": JSONPolling,
+    "jsonp_send": JSONPollingSend,
+    "htmlfile": HTMLFileTransport,
+    "eventsource": EventsourceTransport,
 }
diff --git a/sockjs/transports/base.py b/sockjs/transports/base.py
index 421fb928..dcfa4949 100644
--- a/sockjs/transports/base.py
+++ b/sockjs/transports/base.py
@@ -1,83 +1,111 @@
-import aiohttp
+import abc
 import asyncio
 
+from aiohttp import web
+from aiohttp.web_exceptions import HTTPClientError, HTTPError
+
 from ..exceptions import SessionIsAcquired, SessionIsClosed
-from ..protocol import close_frame, ENCODING
-from ..protocol import STATE_CLOSING, STATE_CLOSED, FRAME_CLOSE, FRAME_MESSAGE
+from ..protocol import (
+    ENCODING,
+    close_frame,
+    SessionState,
+    Frame,
+)
+from ..session import Session, SessionManager
+
+
+class HTTPClientClosedConnection(HTTPClientError):
+    status_code = 499
 
 
-class Transport:
-    def __init__(self, manager, session, request):
+class Transport(abc.ABC):
+    name: str
+    create_session = True
+
+    @classmethod
+    def get_session(cls, manager: SessionManager, session_id: str) -> Session:
+        return manager.get(session_id, create=cls.create_session)
+
+    def __init__(
+        self,
+        manager: SessionManager,
+        session: Session,
+        request: web.Request,
+    ):
         self.manager = manager
         self.session = session
         self.request = request
 
+    @abc.abstractmethod
+    async def process(self) -> web.StreamResponse:
+        pass
 
-class StreamingTransport(Transport):
 
+class StreamingTransport(Transport, abc.ABC):
     timeout = None
-    maxsize = 131072  # 128K bytes
+    maxsize = 128 * 1024
 
-    def __init__(self, manager, session, request):
+    def __init__(self, manager: SessionManager, session: Session, request: web.Request):
         super().__init__(manager, session, request)
-
         self.size = 0
         self.response = None
 
-    async def send(self, text):
-        blob = (text + "\n").encode(ENCODING)
-        await self.response.write(blob)
-
-        self.size += len(blob)
-        if self.size > self.maxsize:
-            return True
-        else:
-            return False
+    async def _send(self, text: str):
+        try:
+            blob = text.encode(ENCODING)
+            await self.response.write(blob)
+            self.size += len(blob)
+            return self.size > self.maxsize
+        except ConnectionResetError as e:
+            raise HTTPClientClosedConnection() from e
 
     async def handle_session(self):
         assert self.response is not None, "Response is not specified."
 
         # session was interrupted
         if self.session.interrupted:
-            await self.send(close_frame(1002, "Connection interrupted"))
+            await self._send(close_frame(1002, "Connection interrupted"))
+            return
 
         # session is closing or closed
-        elif self.session.state in (STATE_CLOSING, STATE_CLOSED):
-            await self.session._remote_closed()
-            await self.send(close_frame(3000, "Go away!"))
-
-        else:
-            # acquire session
-            try:
-                await self.manager.acquire(self.session)
-            except SessionIsAcquired:
-                await self.send(close_frame(2010, "Another connection still open"))
-            else:
-                try:
-                    while True:
-                        if self.timeout:
-                            try:
-                                frame, text = await asyncio.wait_for(
-                                    self.session._wait(), timeout=self.timeout
-                                )
-                            except asyncio.futures.TimeoutError:
-                                frame, text = FRAME_MESSAGE, "a[]"
-                        else:
-                            frame, text = await self.session._wait()
-
-                        if frame == FRAME_CLOSE:
-                            await self.session._remote_closed()
-                            await self.send(text)
-                            return
-                        else:
-                            stop = await self.send(text)
-                            if stop:
-                                break
-                except asyncio.CancelledError:
-                    await self.session._remote_close(exc=aiohttp.ClientConnectionError)
-                    await self.session._remote_closed()
-                    raise
-                except SessionIsClosed:
-                    pass
-                finally:
-                    await self.manager.release(self.session)
+        if self.session.state in (SessionState.CLOSING, SessionState.CLOSED):
+            await self.manager.remote_closed(self.session)
+            await self._send(close_frame(3000, "Go away!"))
+            return
+
+        # acquire session
+        try:
+            await self.manager.acquire(self.session, self.request)
+        except SessionIsAcquired:
+            await self._send(close_frame(2010, "Another connection still open"))
+            return
+
+        try:
+            while True:
+                if self.timeout:
+                    try:
+                        frame, text = await asyncio.wait_for(
+                            self.session.get_frame(),
+                            timeout=self.timeout,
+                        )
+                    except asyncio.futures.TimeoutError:
+                        frame, text = Frame.MESSAGE, "a[]"
+                else:
+                    frame, text = await self.session.get_frame()
+
+                if frame == Frame.CLOSE:
+                    await self.manager.remote_closed(self.session)
+                    await self._send(text)
+                    break
+
+                stop = await self._send(text)
+                if stop:
+                    break
+        except (asyncio.CancelledError, ConnectionError, HTTPError) as e:
+            await self.manager.remote_close(self.session, exc=e)
+            await self.manager.remote_closed(self.session)
+            raise
+        except SessionIsClosed:
+            pass
+        finally:
+            await self.manager.release(self.session)
diff --git a/sockjs/transports/eventsource.py b/sockjs/transports/eventsource.py
index 2419c9a5..0681ddac 100644
--- a/sockjs/transports/eventsource.py
+++ b/sockjs/transports/eventsource.py
@@ -1,21 +1,19 @@
-""" iframe-eventsource transport """
-from aiohttp import web, hdrs
-from sockjs.protocol import ENCODING
+"""iframe-eventsource transport"""
+
+from aiohttp import hdrs, web
+from multidict import MultiDict
 
 from .base import StreamingTransport
 from .utils import CACHE_CONTROL, session_cookie
 
 
 class EventsourceTransport(StreamingTransport):
-    async def send(self, text):
-        blob = "".join(("data: ", text, "\r\n\r\n")).encode(ENCODING)
-        await self.response.write(blob)
+    name = "eventsource"
+    create_session = True
 
-        self.size += len(blob)
-        if self.size > self.maxsize:
-            return True
-        else:
-            return False
+    async def _send(self, text: str):
+        text = "".join(("data: ", text, "\r\n\r\n"))
+        return await super()._send(text)
 
     async def process(self):
         headers = (
@@ -25,8 +23,9 @@ async def process(self):
         headers += session_cookie(self.request)
 
         # open sequence (sockjs protocol)
-        resp = self.response = web.StreamResponse(headers=headers)
+        resp = self.response = web.StreamResponse(headers=MultiDict(headers))
         await resp.prepare(self.request)
+        # Opera needs one more new line at the start.
         await resp.write(b"\r\n")
 
         # handle session
diff --git a/sockjs/transports/htmlfile.py b/sockjs/transports/htmlfile.py
index 7264a2e6..240a89f5 100644
--- a/sockjs/transports/htmlfile.py
+++ b/sockjs/transports/htmlfile.py
@@ -1,10 +1,13 @@
-""" iframe-htmlfile transport """
+"""iframe-htmlfile transport"""
+
 import re
-from aiohttp import web, hdrs
 
-from ..protocol import dumps, ENCODING
+from aiohttp import hdrs, web
+from multidict import MultiDict
+
 from .base import StreamingTransport
-from .utils import CACHE_CONTROL, session_cookie, cors_headers
+from .utils import CACHE_CONTROL, session_cookie
+from ..protocol import dumps
 
 
 PRELUDE1 = b"""
@@ -25,35 +28,25 @@
 
 
 class HTMLFileTransport(StreamingTransport):
-
-    maxsize = 131072  # 128K bytes
+    name = "htmlfile"
+    create_session = True
     check_callback = re.compile(r"^[a-zA-Z0-9_\.]+$")
 
-    async def send(self, text):
-        blob = ("<script>\np(%s);\n</script>\r\n" % dumps(text)).encode(ENCODING)
-        await self.response.write(blob)
-
-        self.size += len(blob)
-        if self.size > self.maxsize:
-            return True
-        else:
-            return False
+    async def _send(self, text: str):
+        text = "<script>\np(%s);\n</script>\r\n" % dumps(text)
+        return await super()._send(text)
 
     async def process(self):
         request = self.request
 
-        try:
-            callback = request.query.get("c", None)
-        except Exception:
-            callback = request.GET.get("c", None)
-
+        callback = request.query.get("c")
         if callback is None:
-            await self.session._remote_closed()
-            return web.HTTPInternalServerError(text='"callback" parameter required')
+            await self.manager.remote_closed(self.session)
+            raise web.HTTPInternalServerError(text='"callback" parameter required')
 
         elif not self.check_callback.match(callback):
-            await self.session._remote_closed()
-            return web.HTTPInternalServerError(text='invalid "callback" parameter')
+            await self.manager.remote_closed(self.session)
+            raise web.HTTPInternalServerError(text='invalid "callback" parameter')
 
         headers = (
             (hdrs.CONTENT_TYPE, "text/html; charset=UTF-8"),
@@ -61,10 +54,9 @@ async def process(self):
             (hdrs.CONNECTION, "close"),
         )
         headers += session_cookie(request)
-        headers += cors_headers(request.headers)
 
         # open sequence (sockjs protocol)
-        resp = self.response = web.StreamResponse(headers=headers)
+        resp = self.response = web.StreamResponse(headers=MultiDict(headers))
         await resp.prepare(self.request)
         await resp.write(
             b"".join((PRELUDE1, callback.encode("utf-8"), PRELUDE2, b" " * 1024))
diff --git a/sockjs/transports/jsonp.py b/sockjs/transports/jsonp.py
index ed1d4ec8..3c2099cf 100644
--- a/sockjs/transports/jsonp.py
+++ b/sockjs/transports/jsonp.py
@@ -1,51 +1,50 @@
 """jsonp transport"""
+
 import re
 from urllib.parse import unquote_plus
 
-from aiohttp import web, hdrs
+from aiohttp import hdrs, web
+from multidict import MultiDict
 
 from .base import StreamingTransport
-from .utils import CACHE_CONTROL, session_cookie, cors_headers
-from ..protocol import dumps, loads, ENCODING
+from .utils import CACHE_CONTROL, session_cookie
+from ..protocol import ENCODING, dumps, loads
 
 
 class JSONPolling(StreamingTransport):
-
+    name = "jsonp-polling"
+    create_session = True
+    maxsize = 0
     check_callback = re.compile(r"^[a-zA-Z0-9_\.]+$")
     callback = ""
 
-    async def send(self, text):
-        data = "/**/%s(%s);\r\n" % (self.callback, dumps(text))
-        await self.response.write(data.encode(ENCODING))
-        return True
+    async def _send(self, text: str):
+        text = "/**/%s(%s);\r\n" % (self.callback, dumps(text))
+        return await super()._send(text)
 
     async def process(self):
+        manager = self.manager
         session = self.session
         request = self.request
         meth = request.method
 
         if request.method == hdrs.METH_GET:
-            try:
-                callback = self.callback = request.query.get("c")
-            except Exception:
-                callback = self.callback = request.GET.get("c")
-
+            callback = self.callback = request.query.get("c")
             if not callback:
-                await self.session._remote_closed()
-                return web.HTTPInternalServerError(text='"callback" parameter required')
+                await self.manager.remote_closed(self.session)
+                raise web.HTTPInternalServerError(text='"callback" parameter required')
 
             elif not self.check_callback.match(callback):
-                await self.session._remote_closed()
-                return web.HTTPInternalServerError(text='invalid "callback" parameter')
+                await self.manager.remote_closed(self.session)
+                raise web.HTTPInternalServerError(text='invalid "callback" parameter')
 
             headers = (
                 (hdrs.CONTENT_TYPE, "application/javascript; charset=UTF-8"),
                 (hdrs.CACHE_CONTROL, CACHE_CONTROL),
             )
             headers += session_cookie(request)
-            headers += cors_headers(request.headers)
 
-            resp = self.response = web.StreamResponse(headers=headers)
+            resp = self.response = web.StreamResponse(headers=MultiDict(headers))
             await resp.prepare(request)
 
             await self.handle_session()
@@ -57,28 +56,33 @@ async def process(self):
             ctype = request.content_type.lower()
             if ctype == "application/x-www-form-urlencoded":
                 if not data.startswith(b"d="):
-                    return web.HTTPInternalServerError(text="Payload expected.")
+                    raise web.HTTPInternalServerError(text="Payload expected.")
 
                 data = unquote_plus(data[2:].decode(ENCODING))
             else:
                 data = data.decode(ENCODING)
 
             if not data:
-                return web.HTTPInternalServerError(text="Payload expected.")
+                raise web.HTTPInternalServerError(text="Payload expected.")
 
             try:
                 messages = loads(data)
             except Exception:
-                return web.HTTPInternalServerError(text="Broken JSON encoding.")
+                raise web.HTTPInternalServerError(text="Broken JSON encoding.")
 
-            await session._remote_messages(messages)
+            await manager.remote_messages(session, messages)
 
             headers = (
-                (hdrs.CONTENT_TYPE, "text/html;charset=UTF-8"),
+                (hdrs.CONTENT_TYPE, "text/plain;charset=UTF-8"),
                 (hdrs.CACHE_CONTROL, CACHE_CONTROL),
             )
             headers += session_cookie(request)
-            return web.Response(body=b"ok", headers=headers)
+            return web.Response(body=b"ok", headers=MultiDict(headers))
 
         else:
-            return web.HTTPBadRequest(text="No support for such method: %s" % meth)
+            raise web.HTTPBadRequest(text="No support for such method: %s" % meth)
+
+
+class JSONPollingSend(JSONPolling):
+    name = "jsonp-polling"
+    create_session = False
diff --git a/sockjs/transports/rawwebsocket.py b/sockjs/transports/rawwebsocket.py
index 3997952d..15415ab3 100644
--- a/sockjs/transports/rawwebsocket.py
+++ b/sockjs/transports/rawwebsocket.py
@@ -1,78 +1,127 @@
 """raw websocket transport."""
-import asyncio
-from aiohttp import web
 
+import asyncio
 from asyncio import ensure_future
+from typing import Optional
+from uuid import uuid4
+
+from aiohttp import web
+from async_timeout import timeout
 
 from .base import Transport
+from .utils import cancel_tasks
 from ..exceptions import SessionIsClosed
-from ..protocol import FRAME_CLOSE, FRAME_MESSAGE, FRAME_MESSAGE_BLOB, FRAME_HEARTBEAT
+from ..protocol import Frame
+from ..session import Session, SessionManager
 
 
 class RawWebSocketTransport(Transport):
-    async def server(self, ws, session):
+    name = "websocket-raw"
+    heartbeat_timeout = 10
+
+    @classmethod
+    def get_session(cls, manager: SessionManager, session_id: str) -> Session:
+        # For WebSockets, as opposed to other transports, it is valid to
+        # reuse `session_id`. The lifetime of SockJS WebSocket session is
+        # defined by a lifetime of underlying WebSocket connection. It is
+        # correct to have two separate sessions sharing the same
+        # `session_id` at the same time.
+
+        # Generate unique session_id based on given ID.
+        orig_session_id = session_id
+        while session_id in manager.sessions:
+            session_id = "%s-%s" % (orig_session_id, uuid4().hex[-8:])
+        return super().get_session(manager, session_id)
+
+    def __init__(self, manager: SessionManager, session: Session, request: web.Request):
+        super().__init__(manager, session, request)
+        self._pong_event = asyncio.Event()
+        self._wait_pong_task: Optional[asyncio.Task] = None
+
+    async def server(self, ws: web.WebSocketResponse):
         while True:
             try:
-                frame, data = await session._wait(pack=False)
+                frame, data = await self.session.get_frame(pack=False)
             except SessionIsClosed:
                 break
 
-            if frame == FRAME_MESSAGE:
+            if frame == Frame.MESSAGE:
                 for text in data:
                     await ws.send_str(text)
-            elif frame == FRAME_MESSAGE_BLOB:
+            elif frame == Frame.MESSAGE_BLOB:
                 data = data[1:]
                 if data.startswith("["):
                     data = data[1:-1]
                 await ws.send_str(data)
-            elif frame == FRAME_HEARTBEAT:
+            elif frame == Frame.HEARTBEAT:
                 await ws.ping()
-            elif frame == FRAME_CLOSE:
+                if self._wait_pong_task is None:
+                    self._wait_pong_task = asyncio.create_task(self._wait_pong())
+                    self._wait_pong_task.add_done_callback(self._wait_done_callback)
+            elif frame == Frame.CLOSE:
                 try:
-                    await ws.close(message="Go away!")
+                    await ws.close(message=b"Go away!")
                 finally:
-                    await session._remote_closed()
+                    await self.manager.remote_closed(self.session)
+
+    async def _wait_pong(self):
+        try:
+            async with timeout(self.heartbeat_timeout):
+                await self._pong_event.wait()
+        except asyncio.TimeoutError:
+            self.session.close(3000, "No response from heartbeat")
+        finally:
+            self._pong_event.clear()
+
+    def _wait_done_callback(self, _):
+        self._wait_pong_task = None
 
-    async def client(self, ws, session):
+    async def client(self, ws: web.WebSocketResponse):
         while True:
             msg = await ws.receive()
+            if self._wait_pong_task is not None:
+                self._pong_event.set()
 
             if msg.type == web.WSMsgType.text:
                 if not msg.data:
                     continue
-                await self.session._remote_message(msg.data)
+                await self.manager.remote_message(self.session, msg.data)
             elif msg.type == web.WSMsgType.close:
-                await self.session._remote_close()
+                await self.manager.remote_close(self.session)
             elif msg.type in (web.WSMsgType.closed, web.WSMsgType.closing):
-                await self.session._remote_closed()
+                await self.manager.remote_closed(self.session)
                 break
             elif msg.type == web.WSMsgType.PONG:
-                self.session._tick()
+                self.session.tick()
+            elif msg.type == web.WSMsgType.PING:
+                await ws.pong(msg.data)
+                self.session.tick()
 
     async def process(self):
         # start websocket connection
-        ws = self.ws = web.WebSocketResponse(autoping=False)
+        ws = web.WebSocketResponse(autoping=False)
         await ws.prepare(self.request)
 
         try:
-            await self.manager.acquire(self.session)
+            await self.manager.acquire(self.session, self.request)
         except Exception:  # should use specific exception
-            await ws.close(message="Go away!")
+            await ws.close(message=b"Go away!")
             return ws
 
-        server = ensure_future(self.server(ws, self.session))
-        client = ensure_future(self.client(ws, self.session))
+        server = ensure_future(self.server(ws))
+        client = ensure_future(self.client(ws))
         try:
-            await asyncio.wait((server, client), return_when=asyncio.FIRST_COMPLETED)
+            await asyncio.wait(
+                (server, client),
+                return_when=asyncio.FIRST_COMPLETED,
+            )
         except asyncio.CancelledError:
             raise
         except Exception as exc:
-            await self.session._remote_close(exc)
+            await self.manager.remote_close(self.session, exc)
         finally:
+            self.session.expire()
             await self.manager.release(self.session)
-            if not server.done():
-                server.cancel()
-            if not client.done():
-                client.cancel()
+            await cancel_tasks(server, client, self._wait_pong_task)
 
         return ws
diff --git a/sockjs/transports/utils.py b/sockjs/transports/utils.py
index b70da21e..2033acb8 100644
--- a/sockjs/transports/utils.py
+++ b/sockjs/transports/utils.py
@@ -1,23 +1,12 @@
+import asyncio
 import http.cookies
-from aiohttp import hdrs
 from datetime import datetime, timedelta
 
+import async_timeout
+from aiohttp import hdrs
 
-CACHE_CONTROL = "no-store, no-cache, no-transform, must-revalidate, max-age=0"
-
-
-def cors_headers(headers, nocreds=False):
-    origin = headers.get(hdrs.ORIGIN, "*")
-    cors = ((hdrs.ACCESS_CONTROL_ALLOW_ORIGIN, origin),)
-
-    ac_headers = headers.get(hdrs.ACCESS_CONTROL_REQUEST_HEADERS)
-    if ac_headers:
-        cors += ((hdrs.ACCESS_CONTROL_ALLOW_HEADERS, ac_headers),)
 
-    if origin != "*":
-        return cors + ((hdrs.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true"),)
-    else:
-        return cors
+CACHE_CONTROL = "no-store, no-cache, no-transform, must-revalidate, max-age=0"
 
 
 def session_cookie(request):
@@ -30,7 +19,7 @@ def session_cookie(request):
 
 td365 = timedelta(days=365)
 td365seconds = str(
-    (td365.microseconds + (td365.seconds + td365.days * 24 * 3600) * 10 ** 6) // 10 ** 6
+    (td365.microseconds + (td365.seconds + td365.days * 24 * 3600) * 10**6) // 10**6
 )
 
 
@@ -41,3 +30,22 @@ def cache_headers():
         (hdrs.CACHE_CONTROL, "max-age=%s, public" % td365seconds),
         (hdrs.EXPIRES, d.strftime("%a, %d %b %Y %H:%M:%S")),
     )
+
+
+async def cancel_tasks(*coros_or_futures, timeout=1):
+    """Cancel all not stopped coroutine or feature before exit
+    from this context manager.
+    """
+    futures = [asyncio.ensure_future(cf) for cf in coros_or_futures if cf]
+    waiting_to_complete = []
+    for fut in futures:
+        if not fut.cancelled() and fut.done():
+            continue
+        fut.cancel()
+        waiting_to_complete.append(fut)
+    if waiting_to_complete:
+        try:
+            async with async_timeout.timeout(timeout):
+                await asyncio.gather(*waiting_to_complete, return_exceptions=True)
+        except asyncio.TimeoutError:
+            pass
diff --git a/sockjs/transports/websocket.py b/sockjs/transports/websocket.py
index 6d5d3622..e4e0979b 100644
--- a/sockjs/transports/websocket.py
+++ b/sockjs/transports/websocket.py
@@ -1,35 +1,88 @@
 """websocket transport"""
-import asyncio
-from aiohttp import web
 
+import asyncio
+import logging
 from asyncio import ensure_future
+from typing import Optional
+from uuid import uuid4
+
+from aiohttp import web
+from aiohttp.web_exceptions import HTTPMethodNotAllowed
+from async_timeout import timeout
 
 from .base import Transport
+from .utils import cancel_tasks
 from ..exceptions import SessionIsClosed
-from ..protocol import STATE_CLOSED, FRAME_CLOSE
-from ..protocol import loads, close_frame
+from ..protocol import SessionState, Frame, close_frame, loads
+from ..session import Session, SessionManager
+
+
+log = logging.getLogger("sockjs")
 
 
 class WebSocketTransport(Transport):
-    async def server(self, ws, session):
+    name = "websocket"
+    heartbeat_timeout = 10
+
+    @classmethod
+    def get_session(cls, manager: SessionManager, session_id: str) -> Session:
+        # For WebSockets, as opposed to other transports, it is valid to
+        # reuse `session_id`. The lifetime of SockJS WebSocket session is
+        # defined by a lifetime of underlying WebSocket connection. It is
+        # correct to have two separate sessions sharing the same
+        # `session_id` at the same time.
+
+        # Generate unique session_id based on given ID.
+        orig_session_id = session_id
+        while session_id in manager.sessions:
+            session_id = "%s-%s" % (orig_session_id, uuid4().hex[-8:])
+        return super().get_session(manager, session_id)
+
+    def __init__(self, manager: SessionManager, session: Session, request: web.Request):
+        super().__init__(manager, session, request)
+        self._pong_event = asyncio.Event()
+        self._wait_pong_task: Optional[asyncio.Task] = None
+
+    async def server(self, ws: web.WebSocketResponse):
         while True:
             try:
-                frame, data = await session._wait()
+                frame, data = await self.session.get_frame()
             except SessionIsClosed:
                 break
-            try:
-                await ws.send_str(data)
-            except OSError:
-                pass  # ignore 'cannot write to closed transport'
-            if frame == FRAME_CLOSE:
+
+            if frame == Frame.HEARTBEAT:
+                await ws.ping()
+                log.debug("Send WS PING")
+                if self._wait_pong_task is None:
+                    self._wait_pong_task = asyncio.create_task(self._wait_pong())
+                    self._wait_pong_task.add_done_callback(self._wait_done_callback)
+                continue
+
+            await ws.send_str(data)
+
+            if frame == Frame.CLOSE:
                 try:
                     await ws.close()
                 finally:
-                    await session._remote_closed()
+                    await self.manager.remote_closed(self.session)
+
+    async def _wait_pong(self):
+        try:
+            async with timeout(self.heartbeat_timeout):
+                await self._pong_event.wait()
+        except asyncio.TimeoutError:
+            self.session.close(3000, "No response from heartbeat")
+        finally:
+            self._pong_event.clear()
 
-    async def client(self, ws, session):
+    def _wait_done_callback(self, _):
+        self._wait_pong_task = None
+
+    async def client(self, ws: web.WebSocketResponse):
         while True:
             msg = await ws.receive()
+            if self._wait_pong_task is not None:
+                self._pong_event.set()
 
             if msg.type == web.WSMsgType.text:
                 data = msg.data
@@ -39,43 +92,56 @@ async def client(self, ws, session):
                 try:
                     text = loads(data)
                 except Exception as exc:
-                    await session._remote_close(exc)
-                    await session._remote_closed()
+                    await self.manager.remote_close(self.session, exc)
+                    await self.manager.remote_closed(self.session)
                     await ws.close(message=b"broken json")
                     break
 
                 if data.startswith("["):
-                    await session._remote_messages(text)
+                    await self.manager.remote_messages(self.session, text)
                 else:
-                    await session._remote_message(text)
-
+                    await self.manager.remote_message(self.session, text)
+            elif msg.type == web.WSMsgType.PONG:
+                log.debug("Received WS PONG")
+                self.session.tick()
+            elif msg.type == web.WSMsgType.PING:
+                log.debug("Received WS PING")
+                await ws.pong(msg.data)
+                self.session.tick()
             elif msg.type == web.WSMsgType.close:
-                await session._remote_close()
+                await self.manager.remote_close(self.session)
             elif msg.type in (web.WSMsgType.closed, web.WSMsgType.closing):
-                await session._remote_closed()
+                await self.manager.remote_closed(self.session)
                 break
 
     async def process(self):
+        if self.request.method != "GET":
+            # WebSocket should only accept GET
+            raise HTTPMethodNotAllowed(
+                self.request.method,
+                ["GET"],
+                body=b"",
+                content_type="",
+            )
+
         # start websocket connection
-        ws = self.ws = web.WebSocketResponse()
+        ws = web.WebSocketResponse(autoping=False)
         await ws.prepare(self.request)
 
         # session was interrupted
         if self.session.interrupted:
-            await self.ws.send_str(close_frame(1002, "Connection interrupted"))
-
-        elif self.session.state == STATE_CLOSED:
-            await self.ws.send_str(close_frame(3000, "Go away!"))
-
+            await ws.send_str(close_frame(1002, "Connection interrupted"))
+        elif self.session.state == SessionState.CLOSED:
+            await ws.send_str(close_frame(3000, "Go away!"))
         else:
             try:
-                await self.manager.acquire(self.session)
+                await self.manager.acquire(self.session, self.request)
             except Exception:  # should use specific exception
-                await self.ws.send_str(close_frame(3000, "Go away!"))
+                await ws.send_str(close_frame(3000, "Go away!"))
                 await ws.close()
                 return ws
-            server = ensure_future(self.server(ws, self.session))
-            client = ensure_future(self.client(ws, self.session))
+            server = ensure_future(self.server(ws))
+            client = ensure_future(self.client(ws))
             try:
                 await asyncio.wait(
                     (server, client), return_when=asyncio.FIRST_COMPLETED
@@ -83,12 +149,10 @@ async def process(self):
             except asyncio.CancelledError:
                 raise
             except Exception as exc:
-                await self.session._remote_close(exc)
+                await self.manager.remote_close(self.session, exc)
             finally:
+                self.session.expire()
                 await self.manager.release(self.session)
-                if not server.done():
-                    server.cancel()
-                if not client.done():
-                    client.cancel()
+                await cancel_tasks(server, client, self._wait_pong_task)
 
         return ws
diff --git a/sockjs/transports/xhr.py b/sockjs/transports/xhr.py
deleted file mode 100644
index 14b5df79..00000000
--- a/sockjs/transports/xhr.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from aiohttp import web, hdrs
-
-from .base import StreamingTransport
-from .utils import CACHE_CONTROL, session_cookie, cors_headers, cache_headers
-
-
-class XHRTransport(StreamingTransport):
-    """Long polling derivative transports,
-    used for XHRPolling and JSONPolling."""
-
-    maxsize = 0
-
-    async def process(self):
-        request = self.request
-
-        if request.method == hdrs.METH_OPTIONS:
-            headers = (
-                (hdrs.CONTENT_TYPE, "application/javascript; charset=UTF-8"),
-                (hdrs.ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS, POST"),
-            )
-            headers += session_cookie(request)
-            headers += cors_headers(request.headers)
-            headers += cache_headers()
-            return web.Response(status=204, headers=headers)
-
-        headers = (
-            (hdrs.CONTENT_TYPE, "application/javascript; charset=UTF-8"),
-            (hdrs.CACHE_CONTROL, CACHE_CONTROL),
-        )
-        headers += session_cookie(request)
-        headers += cors_headers(request.headers)
-
-        resp = self.response = web.StreamResponse(headers=headers)
-        await resp.prepare(request)
-
-        await self.handle_session()
-        return resp
diff --git a/sockjs/transports/xhr_pooling.py b/sockjs/transports/xhr_pooling.py
new file mode 100644
index 00000000..e05f194a
--- /dev/null
+++ b/sockjs/transports/xhr_pooling.py
@@ -0,0 +1,81 @@
+from aiohttp import hdrs, web
+from multidict import MultiDict
+
+from .base import StreamingTransport, Transport
+from .utils import CACHE_CONTROL, cache_headers, session_cookie
+from ..protocol import loads, ENCODING
+
+
+class XHRTransport(StreamingTransport):
+    """Long polling derivative transports,
+    used for XHRPolling and JSONPolling."""
+
+    name = "xhr-polling"
+    create_session = True
+    maxsize = 0
+
+    async def _send(self, text: str):
+        return await super()._send(text + "\n")
+
+    async def process(self):
+        request = self.request
+
+        if request.method == hdrs.METH_OPTIONS:
+            headers = (
+                (hdrs.CONTENT_TYPE, "application/javascript; charset=UTF-8"),
+                (hdrs.ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS, POST"),
+            )
+            headers += session_cookie(request)
+            headers += cache_headers()
+            return web.Response(status=204, headers=MultiDict(headers))
+
+        headers = (
+            (hdrs.CONTENT_TYPE, "application/javascript; charset=UTF-8"),
+            (hdrs.CACHE_CONTROL, CACHE_CONTROL),
+        )
+        headers += session_cookie(request)
+
+        resp = self.response = web.StreamResponse(headers=MultiDict(headers))
+        await resp.prepare(request)
+
+        await self.handle_session()
+        return resp
+
+
+class XHRSendTransport(Transport):
+    name = "xhr-polling"
+    create_session = False
+
+    async def process(self):
+        request = self.request
+
+        if request.method not in (hdrs.METH_GET, hdrs.METH_POST, hdrs.METH_OPTIONS):
+            raise web.HTTPForbidden(text="Method is not allowed")
+
+        if self.request.method == hdrs.METH_OPTIONS:
+            headers = (
+                (hdrs.ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS, POST"),
+                (hdrs.CONTENT_TYPE, "application/javascript; charset=UTF-8"),
+            )
+            headers += session_cookie(request)
+            headers += cache_headers()
+            return web.Response(status=204, headers=MultiDict(headers))
+
+        data = await request.read()
+        if not data:
+            raise web.HTTPInternalServerError(text="Payload expected.")
+
+        try:
+            messages = loads(data.decode(ENCODING))
+        except Exception:
+            raise web.HTTPInternalServerError(text="Broken JSON encoding.")
+
+        await self.manager.remote_messages(self.session, messages)
+
+        headers = (
+            (hdrs.CONTENT_TYPE, "text/plain; charset=UTF-8"),
+            (hdrs.CACHE_CONTROL, CACHE_CONTROL),
+        )
+        headers += session_cookie(request)
+
+        return web.Response(status=204, headers=MultiDict(headers))
diff --git a/sockjs/transports/xhrsend.py b/sockjs/transports/xhrsend.py
deleted file mode 100644
index 2a512eea..00000000
--- a/sockjs/transports/xhrsend.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from aiohttp import web, hdrs
-
-from ..protocol import loads, ENCODING
-from .base import Transport
-from .utils import CACHE_CONTROL, session_cookie, cors_headers, cache_headers
-
-
-class XHRSendTransport(Transport):
-    async def process(self):
-        request = self.request
-
-        if request.method not in (hdrs.METH_GET, hdrs.METH_POST, hdrs.METH_OPTIONS):
-            return web.HTTPForbidden(text="Method is not allowed")
-
-        if self.request.method == hdrs.METH_OPTIONS:
-            headers = (
-                (hdrs.ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS, POST"),
-                (hdrs.CONTENT_TYPE, "application/javascript; charset=UTF-8"),
-            )
-            headers += session_cookie(request)
-            headers += cors_headers(request.headers)
-            headers += cache_headers()
-            return web.Response(status=204, headers=headers)
-
-        data = await request.read()
-        if not data:
-            return web.HTTPInternalServerError(text="Payload expected.")
-
-        try:
-            messages = loads(data.decode(ENCODING))
-        except Exception:
-            return web.HTTPInternalServerError(text="Broken JSON encoding.")
-
-        await self.session._remote_messages(messages)
-
-        headers = (
-            (hdrs.CONTENT_TYPE, "text/plain; charset=UTF-8"),
-            (hdrs.CACHE_CONTROL, CACHE_CONTROL),
-        )
-        headers += session_cookie(request)
-        headers += cors_headers(request.headers)
-
-        return web.Response(status=204, headers=headers)
diff --git a/sockjs/transports/xhrstreaming.py b/sockjs/transports/xhrstreaming.py
index bd15c2d6..f2fcd943 100644
--- a/sockjs/transports/xhrstreaming.py
+++ b/sockjs/transports/xhrstreaming.py
@@ -1,14 +1,18 @@
-from aiohttp import web, hdrs
+from aiohttp import hdrs, web
+from multidict import MultiDict
 
 from .base import StreamingTransport
-from .utils import CACHE_CONTROL, session_cookie, cors_headers, cache_headers
+from .utils import CACHE_CONTROL, cache_headers, session_cookie
 
 
 class XHRStreamingTransport(StreamingTransport):
-
-    maxsize = 131072  # 128K bytes
+    name = "xhr-streaming"
+    create_session = True
     open_seq = b"h" * 2048 + b"\n"
 
+    async def _send(self, text: str):
+        return await super()._send(text + "\n")
+
     async def process(self):
         request = self.request
         headers = (
@@ -18,15 +22,14 @@ async def process(self):
         )
 
         headers += session_cookie(request)
-        headers += cors_headers(request.headers)
 
         if request.method == hdrs.METH_OPTIONS:
             headers += ((hdrs.ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS, POST"),)
             headers += cache_headers()
-            return web.Response(status=204, headers=headers)
+            return web.Response(status=204, headers=MultiDict(headers))
 
         # open sequence (sockjs protocol)
-        resp = self.response = web.StreamResponse(headers=headers)
+        resp = self.response = web.StreamResponse(headers=MultiDict(headers))
         resp.force_close()
         await resp.prepare(request)
         await resp.write(self.open_seq)
diff --git a/tests/asdf b/tests/asdf
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/conftest.py b/tests/conftest.py
index 6802d52f..164383ea 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,30 +1,28 @@
 import asyncio
-
-from datetime import timedelta
+from typing import Optional
 from unittest import mock
 
+import aiohttp_cors
 import pytest
-
 from aiohttp import web
+from aiohttp.test_utils import TestClient, make_mocked_coro, make_mocked_request
 from aiohttp.web_urldispatcher import UrlMappingMatchInfo
-from aiohttp.test_utils import make_mocked_request, make_mocked_coro
 from multidict import CIMultiDict
 from yarl import URL
 
-from sockjs import Session, SessionManager, transports
+from sockjs import Session, SessionManager, add_endpoint, transports
 from sockjs.route import SockJSRoute
 
 
-@pytest.fixture
-def app():
+@pytest.fixture(name="app")
+def app_fixture():
     return web.Application()
 
 
 @pytest.fixture
 def make_fut():
     def maker(val, makemock=True):
-        loop = asyncio.get_event_loop()
-        fut = loop.create_future()
+        fut = asyncio.Future()
         fut.set_result(val)
 
         if makemock:
@@ -39,41 +37,24 @@ def maker(val, makemock=True):
 
 @pytest.fixture
 def make_handler():
-    def maker(result, coro=True, exc=False):
+    def maker(result, exc=False):
         if result is None:
             result = []
         output = result
 
-        def handler(msg, s):
+        async def handler(manager, s, msg):
             if exc:
                 raise ValueError((msg, s))
             output.append((msg, s))
 
-        if coro:
-
-            async def async_handler(msg, s):
-                return handler(msg, s)
-
-            return async_handler
-        else:
-            return handler
-
-    return maker
-
-
-@pytest.fixture
-def make_route(make_handler, app):
-    def maker(handlers=transports.handlers):
-        handler = make_handler([])
-        sm = SessionManager("sm", app, handler)
-        return SockJSRoute("sm", sm, "http:sockjs-cdn", handlers, (), True)
+        return handler
 
     return maker
 
 
 @pytest.fixture
 def make_request(app):
-    def maker(method, path, query_params={}, headers=None, match_info=None):
+    def maker(method, path, query_params=None, headers=None, match_info=None):
         path = URL(path)
         if query_params:
             path = path.with_query(query_params)
@@ -98,7 +79,9 @@ def maker(method, path, query_params={}, headers=None, match_info=None):
         transport = mock.Mock()
         transport._drain_helper = make_mocked_coro()
         loop = asyncio.get_event_loop()
-        ret = make_mocked_request(method, str(path), headers, writer=writer, loop=loop)
+        ret = make_mocked_request(
+            method, str(path), headers, writer=writer, transport=transport, loop=loop
+        )
 
         if match_info is None:
             match_info = UrlMappingMatchInfo({}, mock.Mock())
@@ -112,23 +95,62 @@ def maker(method, path, query_params={}, headers=None, match_info=None):
 @pytest.fixture
 def make_session(make_handler, make_request):
     def maker(
-        name="test", timeout=timedelta(10), request=None, handler=None, result=None
+        name="test", disconnect_delay=10, manager: Optional[SessionManager] = None
     ):
-        if request is None:
-            request = make_request("GET", "/TestPath/")
-
-        if handler is None:
-            handler = make_handler(result)
-        return Session(name, handler, request, timeout=timeout, debug=True)
+        session = Session(name, disconnect_delay=disconnect_delay, debug=True)
+        if manager:
+            manager.sessions[session.id] = session
+        return session
 
     return maker
 
 
 @pytest.fixture
-def make_manager(app, make_handler, make_session):
+async def make_manager(app, make_handler, make_session):
+    managers = []
+
     def maker(handler=None):
         if handler is None:
             handler = make_handler([])
-        return SessionManager("sm", app, handler, debug=True)
+        manager = SessionManager("sm", app, handler, debug=True)
+        managers.append(manager)
+        return manager
+
+    yield maker
+
+    for sm in managers:
+        await sm.stop()
+
+
+@pytest.fixture
+def make_route(make_manager, make_handler, app):
+    def maker(handlers=transports.transport_handlers):
+        sm = make_manager()
+        app.on_cleanup.append(sm.stop)
+        return SockJSRoute("sm", sm, "http:sockjs-cdn", handlers, (), True)
 
     return maker
+
+
+@pytest.fixture(name="test_client")
+async def test_client_fixture(app, aiohttp_client, make_handler) -> TestClient:
+    handler = make_handler(None)
+    # Configure default CORS settings.
+    cors = aiohttp_cors.setup(
+        app,
+        defaults={
+            "*": aiohttp_cors.ResourceOptions(
+                allow_credentials=True,
+                expose_headers="*",
+                allow_headers="*",
+                max_age=31536000,
+            )
+        },
+    )
+    add_endpoint(
+        app,
+        handler,
+        name="main",
+        cors_config=cors,
+    )
+    return await aiohttp_client(app)
diff --git a/tests/test_route.py b/tests/test_route.py
index c0c390a7..75b967c0 100644
--- a/tests/test_route.py
+++ b/tests/test_route.py
@@ -1,9 +1,15 @@
 import asyncio
 
+import pytest
 from aiohttp import web
+from aiohttp.test_utils import TestClient
+from cykooz.testing import D
 from multidict import CIMultiDict
 
 from sockjs import protocol
+from sockjs.route import ALL_METH_WO_OPTIONS
+from sockjs.transports import transport_handlers
+from sockjs.transports.base import Transport
 
 
 async def test_info(make_route, make_request):
@@ -15,6 +21,15 @@ async def test_info(make_route, make_request):
 
     assert info["websocket"]
     assert info["cookie_needed"]
+    assert info["transports"] == [
+        "eventsource",
+        "htmlfile",
+        "jsonp-polling",
+        "websocket",
+        "websocket-raw",
+        "xhr-polling",
+        "xhr-streaming",
+    ]
 
 
 async def test_info_entropy(make_route, make_request):
@@ -30,22 +45,6 @@ async def test_info_entropy(make_route, make_request):
     assert entropy1 != entropy2
 
 
-async def test_info_options(make_route, make_request):
-    route = make_route()
-    request = make_request("OPTIONS", "/sm/")
-    response = await route.info_options(request)
-
-    assert response.status == 204
-
-    headers = response.headers
-    assert "Access-Control-Max-Age" in headers
-    assert "Cache-Control" in headers
-    assert "Expires" in headers
-    assert "Set-Cookie" in headers
-    assert "access-control-allow-credentials" in headers
-    assert "access-control-allow-origin" in headers
-
-
 async def test_greeting(make_route, make_request):
     route = make_route()
     request = make_request("GET", "/sm/")
@@ -62,8 +61,8 @@ async def test_iframe(make_route, make_request):
     text = """<!DOCTYPE html>
 <html>
 <head>
-<meta http-equiv="X-UA-Compatible" content="IE=edge" />
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
   <script src="http:sockjs-cdn"></script>
   <script>
     document.domain = document.domain;
@@ -94,8 +93,8 @@ async def test_handler_unknown_transport(make_route, make_request):
     route = make_route()
     request = make_request("GET", "/sm/", match_info={"transport": "unknown"})
 
-    res = await route.handler(request)
-    assert isinstance(res, web.HTTPNotFound)
+    with pytest.raises(web.HTTPNotFound):
+        await route.handler(request)
 
 
 async def test_handler_emptry_session(make_route, make_request):
@@ -103,8 +102,8 @@ async def test_handler_emptry_session(make_route, make_request):
     request = make_request(
         "GET", "/sm/", match_info={"transport": "websocket", "session": ""}
     )
-    res = await route.handler(request)
-    assert isinstance(res, web.HTTPNotFound)
+    with pytest.raises(web.HTTPNotFound):
+        await route.handler(request)
 
 
 async def test_handler_bad_session_id(make_route, make_request):
@@ -114,8 +113,8 @@ async def test_handler_bad_session_id(make_route, make_request):
         "/sm/",
         match_info={"transport": "websocket", "session": "test.1", "server": "000"},
     )
-    res = await route.handler(request)
-    assert isinstance(res, web.HTTPNotFound)
+    with pytest.raises(web.HTTPNotFound):
+        await route.handler(request)
 
 
 async def test_handler_bad_server_id(make_route, make_request):
@@ -125,8 +124,8 @@ async def test_handler_bad_server_id(make_route, make_request):
         "/sm/",
         match_info={"transport": "websocket", "session": "test", "server": "test.1"},
     )
-    res = await route.handler(request)
-    assert isinstance(res, web.HTTPNotFound)
+    with pytest.raises(web.HTTPNotFound):
+        await route.handler(request)
 
 
 async def test_new_session_before_read(make_route, make_request):
@@ -136,8 +135,8 @@ async def test_new_session_before_read(make_route, make_request):
         "/sm/",
         match_info={"transport": "xhr_send", "session": "s1", "server": "000"},
     )
-    res = await route.handler(request)
-    assert isinstance(res, web.HTTPNotFound)
+    with pytest.raises(web.HTTPNotFound):
+        await route.handler(request)
 
 
 async def _test_transport(make_route, make_request):
@@ -148,14 +147,15 @@ async def _test_transport(make_route, make_request):
 
     params = []
 
-    class Transport:
+    class FakeTransport(Transport):
         def __init__(self, manager, session, request):
+            super().__init__(manager, session, request)
             params.append((manager, session, request))
 
         def process(self):
             return web.HTTPOk()
 
-    route = make_route(handlers={"test": (True, Transport)})
+    route = make_route(handlers={"test": FakeTransport})
     res = await route.handler(request)
     assert isinstance(res, web.HTTPOk)
     assert params[0] == (route.manager, route.manager["s1"], request)
@@ -170,16 +170,19 @@ async def test_fail_transport(make_route, make_request):
 
     params = []
 
-    class Transport:
+    class FakeTransport(Transport):
+        name = "test"
+
         def __init__(self, manager, session, request):
+            super().__init__(manager, session, request)
             params.append((manager, session, request))
 
         def process(self):
             raise Exception("Error")
 
-    route = make_route(handlers={"test": (True, Transport)})
-    res = await route.handler(request)
-    assert isinstance(res, web.HTTPInternalServerError)
+    route = make_route(handlers={"test": FakeTransport})
+    with pytest.raises(web.HTTPInternalServerError):
+        await route.handler(request)
 
 
 async def test_release_session_for_failed_transport(make_route, make_request):
@@ -189,20 +192,19 @@ async def test_release_session_for_failed_transport(make_route, make_request):
         match_info={"transport": "test", "session": "s1", "server": "000"},
     )
 
-    class Transport:
-        def __init__(self, manager, session, request):
-            self.manager = manager
-            self.session = session
+    class FakeTransport(Transport):
+        name = "test"
+        create_session = True
 
         async def process(self):
-            await self.manager.acquire(self.session)
+            await self.manager.acquire(self.session, self.request)
             raise Exception("Error")
 
-    route = make_route(handlers={"test": (True, Transport)})
-    res = await route.handler(request)
-    assert isinstance(res, web.HTTPInternalServerError)
+    route = make_route(handlers={"test": FakeTransport})
+    with pytest.raises(web.HTTPInternalServerError):
+        await route.handler(request)
 
-    s1 = route.manager["s1"]
+    s1 = route.manager.sessions["s1"]
     assert not route.manager.is_acquired(s1)
 
 
@@ -226,3 +228,40 @@ async def _test_raw_websocket_fail(make_route, make_request):
     request = make_request("GET", "/sm/")
     res = await route.websocket(request)
     assert not isinstance(res, web.HTTPNotFound)
+
+
+@pytest.mark.parametrize(
+    ('url', 'method'),
+    [
+        ('/sockjs', "GET"),
+        ('/sockjs/', "GET"),
+        ('/sockjs/info', "GET"),
+    ] + [
+        (f'/sockjs/serv1/234/{transport}', method)
+        for transport in transport_handlers.keys()
+        for method in ALL_METH_WO_OPTIONS
+    ] + [
+        ('/sockjs/websocket', "GET"),
+        ('/sockjs/iframe.html', "GET"),
+        ('/sockjs/iframe12.html', "GET"),
+    ]
+)
+async def test_cors_preflight(test_client: TestClient, url, method):
+    origin = "http://my_example.com"
+    headers = {
+        "HOST": "server.example.com",
+        "ACCESS-CONTROL-REQUEST-METHOD": method,
+        "ACCESS-CONTROL-REQUEST-HEADERS": "origin, x-requested-with",
+        "ORIGIN": origin,
+    }
+
+    response = await test_client.options(url, headers=headers)
+    assert response.status in (200, 204)
+
+    headers = response.headers
+    assert dict(headers) == D({
+        "Access-Control-Allow-Origin": origin,
+        "Access-Control-Allow-Methods": method,
+        "Access-Control-Allow-Credentials": "true",
+        "Access-Control-Max-Age": "31536000"
+    })
diff --git a/tests/test_session.py b/tests/test_session.py
index 85b9cfd6..648d08b4 100644
--- a/tests/test_session.py
+++ b/tests/test_session.py
@@ -1,34 +1,36 @@
 import asyncio
-from unittest import mock
+from asyncio import ensure_future
 from datetime import datetime, timedelta
-
-from aiohttp import web
+from unittest import mock
 
 import pytest
+from aiohttp import web
 
-from asyncio import ensure_future
-
-from sockjs import Session, SessionIsClosed, protocol, SessionIsAcquired
+from sockjs import (
+    Session,
+    SessionIsAcquired,
+    SessionIsClosed,
+    protocol,
+    SessionState,
+    Frame,
+)
 
 
 class TestSession:
-    async def test_ctor(self, mocker, make_handler, make_request):
+    async def test_ctor(self, mocker):
         dt = mocker.patch("sockjs.session.datetime")
         now = dt.now.return_value = datetime.now()
 
-        handler = make_handler([])
-        request = make_request("GET", "/TestPath")
-        session = Session("id", handler, request)
-
+        session = Session("id")
         assert session.id == "id"
         assert not session.expired
-        assert session.expires == now + timedelta(seconds=10)
+        assert session.expires == now + timedelta(seconds=5)
 
         assert session._hits == 0
         assert session._heartbeats == 0
-        assert session.state == protocol.STATE_NEW
+        assert session.state == SessionState.NEW
 
-        session = Session("id", handler, request, timeout=timedelta(seconds=15))
+        session = Session("id", disconnect_delay=15)
 
         assert session.id == "id"
         assert not session.expired
@@ -36,22 +38,22 @@ async def test_ctor(self, mocker, make_handler, make_request):
 
     async def test_str(self, make_session):
         session = make_session("test")
-        session.state = protocol.STATE_OPEN
+        session.state = SessionState.OPEN
 
         assert str(session) == "id='test' connected"
 
         session._hits = 10
         session._heartbeats = 50
-        session.state = protocol.STATE_CLOSING
+        session.state = SessionState.CLOSING
         assert str(session) == "id='test' disconnected hits=10 heartbeats=50"
 
-        session._feed(protocol.FRAME_MESSAGE, "msg")
+        session.feed(Frame.MESSAGE, "msg")
         assert str(session) == "id='test' disconnected queue[1] hits=10 heartbeats=50"
 
-        session.state = protocol.STATE_CLOSED
+        session.state = SessionState.CLOSED
         assert str(session) == "id='test' closed queue[1] hits=10 heartbeats=50"
 
-        session.state = protocol.STATE_OPEN
+        session.state = SessionState.OPEN
         session.acquired = True
         expected = "id='test' connected acquired queue[1] hits=10 heartbeats=50"
         assert str(session) == expected
@@ -62,48 +64,55 @@ async def test_tick(self, mocker, make_session):
         session = make_session("test")
 
         now = dt.now.return_value = now + timedelta(hours=1)
-        session._tick()
-        assert session.expires == now + session.timeout
+        session.tick()
+        assert session.next_heartbeat == now + timedelta(
+            seconds=session.heartbeat_delay
+        )
 
     async def test_tick_different_timeoutk(self, mocker, make_session):
         dt = mocker.patch("sockjs.session.datetime")
         now = dt.now.return_value = datetime.now()
-        session = make_session("test", timeout=timedelta(seconds=20))
+        session = make_session("test", disconnect_delay=20)
 
         now = dt.now.return_value = now + timedelta(hours=1)
-        session._tick()
-        assert session.expires == now + timedelta(seconds=20)
+        session.tick()
+        assert session.next_heartbeat == now + timedelta(
+            seconds=session.heartbeat_delay
+        )
 
     async def test_tick_custom(self, mocker, make_session):
         dt = mocker.patch("sockjs.session.datetime")
         now = dt.now.return_value = datetime.now()
-        session = make_session("test", timeout=timedelta(seconds=20))
+        session = make_session("test", disconnect_delay=20)
 
         now = dt.now.return_value = now + timedelta(hours=1)
-        session._tick(timedelta(seconds=30))
-        assert session.expires == now + timedelta(seconds=30)
+        session.tick(30)
+        assert session.next_heartbeat == now + timedelta(seconds=30)
 
     async def test_heartbeat(self, make_session):
         session = make_session("test")
+        session._send_heartbeats = True
         assert session._heartbeats == 0
-        session._heartbeat()
+        session.heartbeat()
         assert session._heartbeats == 1
-        session._heartbeat()
+        session.heartbeat()
         assert session._heartbeats == 2
 
     async def test_heartbeat_transport(self, make_session):
         session = make_session("test")
-        session._heartbeat_transport = True
-        session._heartbeat()
-        assert list(session._queue) == [
-            (protocol.FRAME_HEARTBEAT, protocol.FRAME_HEARTBEAT)
-        ]
+        session._send_heartbeats = True
+        session.heartbeat()
+        assert list(session._queue) == [(Frame.HEARTBEAT, Frame.HEARTBEAT.value)]
 
-    async def test_expire(self, make_session):
-        session = make_session("test")
-        assert not session.expired
+    async def test_expire(self, make_session, mocker):
+        dt = mocker.patch("sockjs.session.datetime")
+        now = dt.now.return_value = datetime.now()
 
+        session = make_session("test", disconnect_delay=5)
         session.expire()
+        assert session.expires == now + timedelta(seconds=5)
+        assert not session.expired
+        dt.now.return_value = now + timedelta(seconds=5)
         assert session.expired
 
     async def test_send(self, make_session):
@@ -111,10 +120,10 @@ async def test_send(self, make_session):
         session.send("message")
         assert list(session._queue) == []
 
-        session.state = protocol.STATE_OPEN
+        session.state = SessionState.OPEN
         session.send("message")
 
-        assert list(session._queue) == [(protocol.FRAME_MESSAGE, ["message"])]
+        assert list(session._queue) == [(Frame.MESSAGE, ["message"])]
 
     async def test_send_non_str(self, make_session):
         session = make_session("test")
@@ -126,280 +135,374 @@ async def test_send_frame(self, make_session):
         session.send_frame('a["message"]')
         assert list(session._queue) == []
 
-        session.state = protocol.STATE_OPEN
+        session.state = SessionState.OPEN
         session.send_frame('a["message"]')
 
-        assert list(session._queue) == [(protocol.FRAME_MESSAGE_BLOB, 'a["message"]')]
+        assert list(session._queue) == [(Frame.MESSAGE_BLOB, 'a["message"]')]
 
     async def test_feed(self, make_session):
         session = make_session("test")
-        session._feed(protocol.FRAME_OPEN, protocol.FRAME_OPEN)
-        session._feed(protocol.FRAME_MESSAGE, "msg")
-        session._feed(protocol.FRAME_CLOSE, (3001, "reason"))
+        session.feed(Frame.OPEN, Frame.OPEN.value)
+        session.feed(Frame.MESSAGE, "msg")
+        session.feed(Frame.CLOSE, (3001, "reason"))
 
         assert list(session._queue) == [
-            (protocol.FRAME_OPEN, protocol.FRAME_OPEN),
-            (protocol.FRAME_MESSAGE, ["msg"]),
-            (protocol.FRAME_CLOSE, (3001, "reason")),
+            (Frame.OPEN, Frame.OPEN.value),
+            (Frame.MESSAGE, ["msg"]),
+            (Frame.CLOSE, (3001, "reason")),
         ]
 
     async def test_feed_msg_packing(self, make_session):
         session = make_session("test")
-        session._feed(protocol.FRAME_MESSAGE, "msg1")
-        session._feed(protocol.FRAME_MESSAGE, "msg2")
-        session._feed(protocol.FRAME_CLOSE, (3001, "reason"))
-        session._feed(protocol.FRAME_MESSAGE, "msg3")
+        session.feed(Frame.MESSAGE, "msg1")
+        session.feed(Frame.MESSAGE, "msg2")
+        session.feed(Frame.CLOSE, (3001, "reason"))
+        session.feed(Frame.MESSAGE, "msg3")
 
         assert list(session._queue) == [
-            (protocol.FRAME_MESSAGE, ["msg1", "msg2"]),
-            (protocol.FRAME_CLOSE, (3001, "reason")),
-            (protocol.FRAME_MESSAGE, ["msg3"]),
+            (Frame.MESSAGE, ["msg1", "msg2"]),
+            (Frame.CLOSE, (3001, "reason")),
+            (Frame.MESSAGE, ["msg3"]),
         ]
 
     async def test_feed_with_waiter(self, make_session):
-        loop = asyncio.get_event_loop()
         session = make_session("test")
-        session._waiter = waiter = loop.create_future()
-        session._feed(protocol.FRAME_MESSAGE, "msg")
+        session._waiter = waiter = asyncio.Future()
+        session.feed(Frame.MESSAGE, "msg")
 
-        assert list(session._queue) == [(protocol.FRAME_MESSAGE, ["msg"])]
+        assert list(session._queue) == [(Frame.MESSAGE, ["msg"])]
         assert session._waiter is None
         assert waiter.done()
 
     async def test_wait(self, make_session):
         s = make_session("test")
-        s.state = protocol.STATE_OPEN
+        s.state = SessionState.OPEN
 
         async def send():
             await asyncio.sleep(0.001)
-            s._feed(protocol.FRAME_MESSAGE, "msg1")
+            s.feed(Frame.MESSAGE, "msg1")
 
         ensure_future(send())
-        frame, payload = await s._wait()
-        assert frame == protocol.FRAME_MESSAGE
+        frame, payload = await s.get_frame()
+        assert frame == Frame.MESSAGE
         assert payload == 'a["msg1"]'
 
     async def test_wait_closed(self, make_session):
         s = make_session("test")
-        s.state = protocol.STATE_CLOSED
+        s.state = SessionState.CLOSED
         with pytest.raises(SessionIsClosed):
-            await s._wait()
+            await s.get_frame()
 
     async def test_wait_message(self, make_session):
         s = make_session("test")
-        s.state = protocol.STATE_OPEN
-        s._feed(protocol.FRAME_MESSAGE, "msg1")
-        frame, payload = await s._wait()
-        assert frame == protocol.FRAME_MESSAGE
+        s.state = SessionState.OPEN
+        s.feed(Frame.MESSAGE, "msg1")
+        frame, payload = await s.get_frame()
+        assert frame == Frame.MESSAGE
         assert payload == 'a["msg1"]'
 
     async def test_wait_close(self, make_session):
         s = make_session("test")
-        s.state = protocol.STATE_OPEN
-        s._feed(protocol.FRAME_CLOSE, (3000, "Go away!"))
-        frame, payload = await s._wait()
-        assert frame == protocol.FRAME_CLOSE
+        s.state = SessionState.OPEN
+        s.feed(Frame.CLOSE, (3000, "Go away!"))
+        frame, payload = await s.get_frame()
+        assert frame == Frame.CLOSE
         assert payload == 'c[3000,"Go away!"]'
 
     async def test_wait_message_unpack(self, make_session):
         s = make_session("test")
-        s.state = protocol.STATE_OPEN
-        s._feed(protocol.FRAME_MESSAGE, "msg1")
-        frame, payload = await s._wait(pack=False)
-        assert frame == protocol.FRAME_MESSAGE
+        s.state = SessionState.OPEN
+        s.feed(Frame.MESSAGE, "msg1")
+        frame, payload = await s.get_frame(pack=False)
+        assert frame == Frame.MESSAGE
         assert payload == ["msg1"]
 
     async def test_wait_close_unpack(self, make_session):
         s = make_session("test")
-        s.state = protocol.STATE_OPEN
-        s._feed(protocol.FRAME_CLOSE, (3000, "Go away!"))
-        frame, payload = await s._wait(pack=False)
-        assert frame == protocol.FRAME_CLOSE
+        s.state = SessionState.OPEN
+        s.feed(Frame.CLOSE, (3000, "Go away!"))
+        frame, payload = await s.get_frame(pack=False)
+        assert frame == Frame.CLOSE
         assert payload == (3000, "Go away!")
 
     async def test_close(self, make_session):
         session = make_session("test")
-        session.state = protocol.STATE_OPEN
+        session.state = SessionState.OPEN
         session.close()
-        assert session.state == protocol.STATE_CLOSING
-        assert list(session._queue) == [(protocol.FRAME_CLOSE, (3000, "Go away!"))]
+        assert session.state == SessionState.CLOSING
+        assert list(session._queue) == [(Frame.CLOSE, (3000, "Go away!"))]
 
     async def test_close_idempotent(self, make_session):
         session = make_session("test")
-        session.state = protocol.STATE_CLOSED
+        session.state = SessionState.CLOSED
         session.close()
-        assert session.state == protocol.STATE_CLOSED
+        assert session.state == SessionState.CLOSED
         assert list(session._queue) == []
 
-    async def test_acquire_new_session(self, make_session):
-        manager = object()
+    async def test_acquire_new_session(
+        self,
+        make_manager,
+        make_session,
+        make_request,
+        make_handler,
+    ):
         messages = []
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session(manager=manager)
+        assert session.state == SessionState.NEW
+        assert session._hb_task is None
+        assert not session._send_heartbeats
+
+        await manager.acquire(session, request=make_request("GET", "/test/"))
+        assert session.state == SessionState.OPEN
+        assert session._send_heartbeats
+        assert session._hb_task is not None
+        assert list(session._queue) == [(Frame.OPEN, Frame.OPEN.value)]
+        assert messages == [(protocol.OPEN_MESSAGE, session)]
+
+        hb_task = session._hb_task
+        session.release()
+        assert not session._send_heartbeats
+        assert session._hb_task is None
+        assert hb_task._must_cancel
 
-        session = make_session(result=messages)
-        assert session.state == protocol.STATE_NEW
-
-        await session._acquire(manager)
-        assert session.state == protocol.STATE_OPEN
-        assert session.manager is manager
-        assert session._heartbeat_transport
-        assert list(session._queue) == [(protocol.FRAME_OPEN, protocol.FRAME_OPEN)]
-        assert messages == [(protocol.OpenMessage, session)]
-
-    async def test_acquire_exception_in_handler(self, make_session):
+    async def test_acquire_exception_in_handler(
+        self, make_manager, make_session, make_request
+    ):
         async def handler(msg, s):
             raise ValueError
 
-        session = make_session(handler=handler)
-        assert session.state == protocol.STATE_NEW
+        sm = make_manager(handler)
+        session = make_session(manager=sm)
+        assert session.state == SessionState.NEW
 
-        await session._acquire(object())
-        assert session.state == protocol.STATE_CLOSING
-        assert session._heartbeat_transport
+        await sm.acquire(session, request=make_request("GET", "/test/"))
+        assert session.state == SessionState.CLOSING
+        assert session._send_heartbeats
         assert session.interrupted
         assert list(session._queue) == [
-            (protocol.FRAME_OPEN, protocol.FRAME_OPEN),
-            (protocol.FRAME_CLOSE, (3000, "Internal error")),
+            (Frame.OPEN, Frame.OPEN.value),
+            (Frame.CLOSE, (3000, "Internal error")),
         ]
 
-    async def test_remote_close(self, make_session):
+    async def test_remote_close(self, make_session, make_manager, make_handler):
         messages = []
-        session = make_session(result=messages)
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session(manager=manager)
 
-        await session._remote_close()
+        await manager.remote_close(session)
         assert not session.interrupted
-        assert session.state == protocol.STATE_CLOSING
-        assert messages == [(protocol.SockjsMessage(protocol.MSG_CLOSE, None), session)]
+        assert session.state == SessionState.CLOSING
+        assert messages == [
+            (protocol.SockjsMessage(protocol.MsgType.CLOSE, None), session)
+        ]
 
-    async def test_remote_close_idempotent(self, make_session):
+    async def test_remote_close_idempotent(
+        self,
+        make_session,
+        make_manager,
+        make_handler,
+    ):
         messages = []
-        session = make_session(result=messages)
-        session.state = protocol.STATE_CLOSED
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session()
+        session.state = SessionState.CLOSED
 
-        await session._remote_close()
-        assert session.state == protocol.STATE_CLOSED
+        await manager.remote_close(session)
+        assert session.state == SessionState.CLOSED
         assert messages == []
 
-    async def test_remote_close_with_exc(self, make_session):
+    async def test_remote_close_with_exc(
+        self,
+        make_session,
+        make_manager,
+        make_handler,
+    ):
         messages = []
-        session = make_session(result=messages)
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session(manager=manager)
 
         exc = ValueError()
-        await session._remote_close(exc=exc)
+        await manager.remote_close(session, exc=exc)
         assert session.interrupted
-        assert session.state == protocol.STATE_CLOSING
-        assert messages == [(protocol.SockjsMessage(protocol.MSG_CLOSE, exc), session)]
+        assert session.state == SessionState.CLOSING
+        assert messages == [
+            (protocol.SockjsMessage(protocol.MsgType.CLOSE, exc), session)
+        ]
 
-    async def test_remote_close_exc_in_handler(self, make_session, make_handler):
+    async def test_remote_close_exc_in_handler(
+        self,
+        make_session,
+        make_manager,
+        make_handler,
+    ):
         handler = make_handler([], exc=True)
-        session = make_session(handler=handler)
+        manager = make_manager(handler)
+        session = make_session()
 
-        await session._remote_close()
+        await manager.remote_close(session)
         assert not session.interrupted
-        assert session.state == protocol.STATE_CLOSING
+        assert session.state == SessionState.CLOSING
 
-    async def test_remote_closed(self, make_session):
+    async def test_remote_closed(self, make_session, make_manager, make_handler):
         messages = []
-        session = make_session(result=messages)
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session(manager=manager)
+
+        await manager.remote_closed(session)
+        assert session.expires > datetime.now()
+        assert not session.expired
+        assert session.state == SessionState.NEW
+        assert messages == []
 
-        await session._remote_closed()
+        session.expires = datetime.now()
         assert session.expired
-        assert session.state == protocol.STATE_CLOSED
-        assert messages == [(protocol.ClosedMessage, session)]
+        await manager.remote_closed(session)
+        assert session.state == SessionState.CLOSED
+        assert messages == [(protocol.CLOSED_MESSAGE, session)]
 
-    async def test_remote_closed_idempotent(self, make_session):
+        # Without delay
         messages = []
-        session = make_session(result=messages)
-        session.state = protocol.STATE_CLOSED
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session(disconnect_delay=0)
+        await manager.remote_closed(session)
+        assert session.expired
+        await manager.remote_closed(session)
+        assert session.state == SessionState.CLOSED
+        assert messages == [(protocol.CLOSED_MESSAGE, session)]
+
+    async def test_remote_closed_idempotent(
+        self,
+        make_session,
+        make_manager,
+        make_handler,
+    ):
+        messages = []
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session()
+        session.state = SessionState.CLOSED
 
-        await session._remote_closed()
-        assert session.state == protocol.STATE_CLOSED
+        await manager.remote_closed(session)
+        assert session.state == SessionState.CLOSED
         assert messages == []
 
-    async def test_remote_closed_with_waiter(self, make_session):
+    async def test_remote_closed_with_waiter(
+        self,
+        make_session,
+        make_manager,
+        make_handler,
+    ):
         messages = []
-        session = make_session(result=messages)
-        loop = asyncio.get_event_loop()
-        session._waiter = waiter = loop.create_future()
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session(manager=manager, disconnect_delay=0)
+        session._waiter = waiter = asyncio.Future()
 
-        await session._remote_closed()
+        now = datetime.now()
+        await manager.remote_closed(session)
         assert waiter.done()
+        assert session.expires <= now
         assert session.expired
         assert session._waiter is None
-        assert session.state == protocol.STATE_CLOSED
-        assert messages == [(protocol.ClosedMessage, session)]
-
-    async def test_remote_closed_exc_in_handler(self, make_handler, make_session):
+        assert session.state == SessionState.CLOSED
+        assert messages == [(protocol.CLOSED_MESSAGE, session)]
+
+    async def test_remote_closed_exc_in_handler(
+        self,
+        make_session,
+        make_manager,
+        make_handler,
+    ):
         handler = make_handler([], exc=True)
-        session = make_session(handler=handler)
+        manager = make_manager(handler)
+        session = make_session(disconnect_delay=0)
 
-        await session._remote_closed()
+        now = datetime.now()
+        await manager.remote_closed(session)
+        assert session.expires <= now
         assert session.expired
-        assert session.state == protocol.STATE_CLOSED
+        assert session.state == SessionState.CLOSED
 
-    async def test_remote_message(self, make_session):
+    async def test_remote_message(self, make_session, make_manager, make_handler):
         messages = []
-        session = make_session(result=messages)
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session(manager=manager)
 
-        await session._remote_message("msg")
+        await manager.remote_message(session, "msg")
         assert messages == [
-            (protocol.SockjsMessage(protocol.MSG_MESSAGE, "msg"), session)
+            (protocol.SockjsMessage(protocol.MsgType.MESSAGE, "msg"), session)
         ]
 
-    async def test_remote_message_exc(self, make_handler, make_session):
+    async def test_remote_message_exc(self, make_session, make_manager, make_handler):
         messages = []
         handler = make_handler(messages, exc=True)
-        session = make_session(handler=handler)
+        manager = make_manager(handler)
+        session = make_session()
 
-        await session._remote_message("msg")
+        await manager.remote_message(session, "msg")
         assert messages == []
 
-    async def test_remote_messages(self, make_session):
+    async def test_remote_messages(self, make_session, make_manager, make_handler):
         messages = []
-        session = make_session(result=messages)
+        handler = make_handler(result=messages)
+        manager = make_manager(handler)
+        session = make_session(manager=manager)
 
-        await session._remote_messages(("msg1", "msg2"))
+        await manager.remote_messages(session, ("msg1", "msg2"))
         assert messages == [
-            (protocol.SockjsMessage(protocol.MSG_MESSAGE, "msg1"), session),
-            (protocol.SockjsMessage(protocol.MSG_MESSAGE, "msg2"), session),
+            (protocol.SockjsMessage(protocol.MsgType.MESSAGE, "msg1"), session),
+            (protocol.SockjsMessage(protocol.MsgType.MESSAGE, "msg2"), session),
         ]
 
-    async def test_remote_messages_exc(self, make_handler, make_session):
+    async def test_remote_messages_exc(self, make_session, make_manager, make_handler):
         messages = []
         handler = make_handler(messages, exc=True)
-        session = make_session(handler=handler)
+        manager = make_manager(handler)
+        session = make_session()
 
-        await session._remote_messages(("msg1", "msg2"))
+        await manager.remote_messages(session, ("msg1", "msg2"))
         assert messages == []
 
 
 class TestSessionManager:
     async def test_request_available(self, make_manager, make_request):
         sm = make_manager()
-        s = sm.get("test", True, make_request("GET", "/test/"))
+        s = sm.get("test", True)
+        assert s.request is None
+        await sm.acquire(s, make_request("GET", "/test/"))
+        assert s.request is not None
         assert isinstance(s.request, web.Request)
 
     async def test_fresh(self, make_manager, make_session):
         sm = make_manager()
         s = make_session()
         sm._add(s)
-        assert "test" in sm
+        assert "test" in sm.sessions
 
     async def test_add(self, make_manager, make_session):
         sm = make_manager()
         s = make_session()
 
         sm._add(s)
-        assert "test" in sm
-        assert sm["test"] is s
-        assert s.manager is sm
+        assert "test" in sm.sessions
+        assert sm.sessions["test"] is s
 
     async def test_add_expired(self, make_manager, make_session):
         sm = make_manager()
-        s = make_session()
-        s.expire()
+        session = make_session(disconnect_delay=0)
+        session.expire()
+        assert session.expires <= datetime.now()
 
         with pytest.raises(ValueError):
-            sm._add(s)
+            sm._add(session)
 
     async def test_get(self, make_manager, make_session):
         sm = make_manager()
@@ -421,58 +524,58 @@ async def test_get_with_create(self, make_manager):
         sm = make_manager()
 
         s = sm.get("test", True)
-        assert s.id in sm
+        assert s.id in sm.sessions
         assert isinstance(s, Session)
 
-    async def test_acquire(self, make_manager, make_session):
+    async def test_acquire(self, make_manager, make_session, make_request):
         sm = make_manager()
         s1 = make_session()
         sm._add(s1)
-        s1._acquire = mock.Mock()
-        loop = asyncio.get_event_loop()
-        s1._acquire.return_value = loop.create_future()
-        s1._acquire.return_value.set_result(1)
+        s1.acquire = mock.Mock()
+        s1.acquire.return_value = asyncio.Future()
+        s1.acquire.return_value.set_result(True)
 
-        s2 = await sm.acquire(s1)
+        s2 = await sm.acquire(s1, request=make_request("GET", "/test/"))
 
         assert s1 is s2
         assert s1.id in sm.acquired
         assert sm.acquired[s1.id]
         assert sm.is_acquired(s1)
-        assert s1._acquire.called
+        assert s1.acquire.called
 
-    async def test_acquire_unknown(self, make_manager, make_session):
+    async def test_acquire_unknown(self, make_manager, make_session, make_request):
         sm = make_manager()
         s = make_session()
         with pytest.raises(KeyError):
-            await sm.acquire(s)
+            await sm.acquire(s, request=make_request("GET", "/test/"))
 
-    async def test_acquire_locked(self, make_manager, make_session):
+    async def test_acquire_locked(self, make_manager, make_session, make_request):
         sm = make_manager()
         s = make_session()
         sm._add(s)
-        await sm.acquire(s)
+        await sm.acquire(s, request=make_request("GET", "/test/"))
 
         with pytest.raises(SessionIsAcquired):
-            await sm.acquire(s)
+            await sm.acquire(s, request=make_request("GET", "/test/"))
 
-    async def test_release(self, make_manager):
+    async def test_release(self, make_manager, make_request):
         sm = make_manager()
         s = sm.get("test", True)
-        s._release = mock.Mock()
+        s.release = mock.Mock()
 
-        await sm.acquire(s)
+        await sm.acquire(s, request=make_request("GET", "/test/"))
         await sm.release(s)
 
         assert "test" not in sm.acquired
         assert not sm.is_acquired(s)
-        assert s._release.called
+        assert s.release.called
 
     async def test_active_sessions(self, make_manager):
         sm = make_manager()
 
         s1 = sm.get("test1", True)
         s2 = sm.get("test2", True)
+        s2.disconnect_delay = 0
         s2.expire()
 
         active = list(sm.active_sessions())
@@ -483,131 +586,104 @@ async def test_broadcast(self, make_manager):
         sm = make_manager()
 
         s1 = sm.get("test1", True)
-        s1.state = protocol.STATE_OPEN
+        s1.state = SessionState.OPEN
         s2 = sm.get("test2", True)
-        s2.state = protocol.STATE_OPEN
+        s2.state = SessionState.OPEN
         sm.broadcast("msg")
 
-        assert list(s1._queue) == [(protocol.FRAME_MESSAGE_BLOB, 'a["msg"]')]
-        assert list(s2._queue) == [(protocol.FRAME_MESSAGE_BLOB, 'a["msg"]')]
+        assert list(s1._queue) == [(Frame.MESSAGE_BLOB, 'a["msg"]')]
+        assert list(s2._queue) == [(Frame.MESSAGE_BLOB, 'a["msg"]')]
 
     async def test_clear(self, make_manager):
         sm = make_manager()
 
         s1 = sm.get("s1", True)
-        s1.state = protocol.STATE_OPEN
+        s1.state = SessionState.OPEN
         s2 = sm.get("s2", True)
-        s2.state = protocol.STATE_OPEN
+        s2.state = SessionState.OPEN
 
         await sm.clear()
 
-        assert not bool(sm)
+        assert not bool(sm.sessions)
         assert s1.expired
         assert s2.expired
-        assert s1.state == protocol.STATE_CLOSED
-        assert s2.state == protocol.STATE_CLOSED
+        assert s1.state == SessionState.CLOSED
+        assert s2.state == SessionState.CLOSED
 
-    async def test_heartbeat(self, make_manager):
+    async def test_gc_task(self, make_manager):
         sm = make_manager()
         assert not sm.started
-        assert sm._hb_task is None
+        assert sm._gc_task is None
 
         sm.start()
         assert sm.started
-        assert sm._hb_handle is not None
-
-        sm._heartbeat()
-        assert sm._hb_task is not None
+        assert sm._gc_task is not None
 
-        hb_task = sm._hb_task
+        gc_task = sm._gc_task
 
-        sm.stop()
+        await sm.stop()
         assert not sm.started
-        assert sm._hb_handle is None
-        assert sm._hb_task is None
-        assert hb_task._must_cancel
-
-    async def test_heartbeat_task(self, make_manager):
-        sm = make_manager()
-        sm._hb_task = mock.Mock()
-
-        await sm._heartbeat_task()
-        assert sm.started
-        assert sm._hb_task is None
+        assert sm._gc_task is None
+        assert gc_task._must_cancel
 
-    async def test_gc_expire(self, make_manager, make_session):
+    async def test_gc_expire(self, make_manager, make_session, make_request):
         sm = make_manager()
-        s = make_session()
-
-        sm._add(s)
-        await sm.acquire(s)
+        s = make_session(manager=sm)
+        await sm.acquire(s, request=make_request("GET", "/test/"))
         await sm.release(s)
 
-        s.expires = datetime.now() - timedelta(seconds=30)
+        now = datetime.now()
+        s.expires = now - timedelta(seconds=30)
+        assert s.expired
 
-        await sm._heartbeat_task()
-        assert s.id not in sm
+        await sm._gc_expired_sessions()
+        assert s.id not in sm.sessions
         assert s.expired
-        assert s.state == protocol.STATE_CLOSED
+        assert s.state == SessionState.CLOSED
 
-    async def test_gc_expire_acquired(self, make_manager, make_session):
+    async def test_gc_expire_acquired(self, make_manager, make_session, make_request):
         sm = make_manager()
-        s = make_session()
-        sm._add(s)
-        await sm.acquire(s)
+        s = make_session(manager=sm)
+        await sm.acquire(s, request=make_request("GET", "/test/"))
         s.expires = datetime.now() - timedelta(seconds=30)
-        await sm._heartbeat_task()
+        await sm._gc_expired_sessions()
 
-        assert s.id not in sm
+        assert s.id not in sm.sessions
         assert s.id not in sm.acquired
         assert s.expired
-        assert s.state == protocol.STATE_CLOSED
+        assert s.state == SessionState.CLOSED
 
-    async def test_gc_one_expire(self, make_manager, make_session):
+    async def test_gc_one_expire(self, make_manager, make_session, make_request):
         sm = make_manager()
-        s1 = make_session("id1")
-        s2 = make_session("id2")
-
-        sm._add(s1)
-        sm._add(s2)
-        await sm.acquire(s1)
-        await sm.acquire(s2)
+        s1 = make_session("id1", manager=sm)
+        s2 = make_session("id2", manager=sm)
+        await sm.acquire(s1, request=make_request("GET", "/test/"))
+        await sm.acquire(s2, request=make_request("GET", "/test/"))
         await sm.release(s1)
         await sm.release(s2)
 
         s1.expires = datetime.now() - timedelta(seconds=30)
 
-        await sm._heartbeat_task()
-        assert s1.id not in sm
-        assert s2.id in sm
+        await sm._gc_expired_sessions()
+        assert s1.id not in sm.sessions
+        assert s2.id in sm.sessions
 
     async def test_emits_warning_on_del(self, make_manager, make_session):
-
         sm = make_manager()
-        s1 = make_session("id1")
-        s2 = make_session("id2")
-
-        sm._add(s1)
-        sm._add(s2)
+        make_session("id1", manager=sm)
+        make_session("id2", manager=sm)
 
         with pytest.warns(RuntimeWarning) as warning:
             getattr(sm, "__del__")()
-            msg = (
-                "Unclosed sessions! Please call "
-                "`await SessionManager.clear()` before del"
-            )
+            msg = "Please call `await SessionManager.stop()` before del"
             assert warning[0].message.args[0] == msg
 
     async def test_does_not_emits_warning_on_del_if_no_sessions(
         self, make_manager, make_session
     ):
-
         sm = make_manager()
-        s1 = make_session("id1")
-        s2 = make_session("id2")
-
-        sm._add(s1)
-        sm._add(s2)
+        make_session("id1", manager=sm)
+        make_session("id2", manager=sm)
 
         await sm.clear()
         getattr(sm, "__del__")()
diff --git a/tests/test_transport.py b/tests/test_transport.py
index 706c109b..24c3d820 100644
--- a/tests/test_transport.py
+++ b/tests/test_transport.py
@@ -1,86 +1,79 @@
 from unittest import mock
-from aiohttp import web
 
 import pytest
+from aiohttp import web
 from aiohttp.test_utils import make_mocked_coro
 
-from sockjs import protocol
+from sockjs import SessionState
 from sockjs.transports import base
 
 
+class FakeStreamingTransport(base.StreamingTransport):
+    async def _send(self, text: str):
+        return await super()._send(text + "\n")
+
+    async def process(self):
+        raise NotImplementedError
+
+
 @pytest.fixture
 def make_transport(make_manager, make_request, make_handler, make_fut):
-    def maker(method="GET", path="/", query_params={}):
+    def maker(method="GET", path="/", query_params=None):
         handler = make_handler(None)
         manager = make_manager(handler)
         request = make_request(method, path, query_params=query_params)
         request.app.freeze()
-        session = manager.get("TestSessionStreaming", create=True, request=request)
-        return base.StreamingTransport(manager, session, request)
+        session = manager.get("TestSessionStreaming", create=True)
+        return FakeStreamingTransport(manager, session, request)
 
     return maker
 
 
-async def test_transport_ctor(make_request):
-    manager = object()
-    session = object()
-    request = make_request("GET", "/")
-
-    transport = base.Transport(manager, session, request)
-    assert transport.manager is manager
-    assert transport.session is session
-    assert transport.request is request
-
-
 async def test_streaming_send(make_transport):
     trans = make_transport()
 
     resp = trans.response = mock.Mock()
     resp.write = make_mocked_coro(None)
-    stop = await trans.send("text data")
+    stop = await trans._send("text data")
     assert not stop
     assert trans.size == len(b"text data\n")
     resp.write.assert_called_with(b"text data\n")
 
     trans.maxsize = 1
-    stop = await trans.send("text data")
+    stop = await trans._send("text data")
     assert stop
 
 
 async def test_handle_session_interrupted(make_transport, make_fut):
     trans = make_transport()
     trans.session.interrupted = True
-    trans.send = make_fut(1)
+    trans._send = make_fut(1)
     trans.response = web.StreamResponse()
     await trans.handle_session()
-    trans.send.assert_called_with('c[1002,"Connection interrupted"]')
+    trans._send.assert_called_with('c[1002,"Connection interrupted"]')
 
 
 async def test_handle_session_closing(make_transport, make_fut):
     trans = make_transport()
-    trans.send = make_fut(1)
+    manager = trans.manager
+    trans._send = make_fut(1)
     trans.session.interrupted = False
-    trans.session.state = protocol.STATE_CLOSING
-    trans.session._remote_closed = make_fut(1)
+    trans.session.state = SessionState.CLOSING
+    manager.remote_closed = make_fut(1)
     trans.response = web.StreamResponse()
     await trans.handle_session()
-    trans.session._remote_closed.assert_called_with()
-    trans.send.assert_called_with('c[3000,"Go away!"]')
+    manager.remote_closed.assert_called()
+    trans._send.assert_called_with('c[3000,"Go away!"]')
 
 
 async def test_handle_session_closed(make_transport, make_fut):
     trans = make_transport()
-    trans.send = make_fut(1)
+    manager = trans.manager
+    trans._send = make_fut(1)
     trans.session.interrupted = False
-    trans.session.state = protocol.STATE_CLOSED
-    trans.session._remote_closed = make_fut(1)
+    trans.session.state = SessionState.CLOSED
+    manager.remote_closed = make_fut(1)
     trans.response = web.StreamResponse()
     await trans.handle_session()
-    trans.session._remote_closed.assert_called_with()
-    trans.send.assert_called_with('c[3000,"Go away!"]')
-
-
-async def test_session_has_request(make_transport, make_fut):
-    transp = make_transport(method="POST")
-    transp.session._remote_messages = make_fut(1)
-    assert isinstance(transp.session.request, web.Request)
+    manager.remote_closed.assert_called()
+    trans._send.assert_called_with('c[3000,"Go away!"]')
diff --git a/tests/test_transport_eventsource.py b/tests/test_transport_eventsource.py
index c81925a0..4906f668 100644
--- a/tests/test_transport_eventsource.py
+++ b/tests/test_transport_eventsource.py
@@ -1,5 +1,4 @@
 from unittest import mock
-from aiohttp import web
 
 import pytest
 from aiohttp.test_utils import make_mocked_coro
@@ -9,12 +8,12 @@
 
 @pytest.fixture
 def make_transport(make_manager, make_request, make_handler, make_fut):
-    def maker(method="GET", path="/", query_params={}):
+    def maker(method="GET", path="/", query_params=None):
         handler = make_handler(None)
         manager = make_manager(handler)
         request = make_request(method, path, query_params=query_params)
         request.app.freeze()
-        session = manager.get("TestSessionEventSource", create=True, request=request)
+        session = manager.get("TestSessionEventSource", create=True)
         return EventsourceTransport(manager, session, request)
 
     return maker
@@ -25,13 +24,13 @@ async def test_streaming_send(make_transport):
 
     resp = trans.response = mock.Mock()
     resp.write = make_mocked_coro(None)
-    stop = await trans.send("text data")
+    stop = await trans._send("text data")
     resp.write.assert_called_with(b"data: text data\r\n\r\n")
     assert not stop
     assert trans.size == len(b"data: text data\r\n\r\n")
 
     trans.maxsize = 1
-    stop = trans.send("text data")
+    stop = await trans._send("text data")
     assert stop
 
 
@@ -41,9 +40,3 @@ async def test_process(make_transport, make_fut):
     resp = await transp.process()
     assert transp.handle_session.called
     assert resp.status == 200
-
-
-async def test_session_has_request(make_transport, make_fut):
-    transp = make_transport(method="POST")
-    transp.session._remote_messages = make_fut(1)
-    assert isinstance(transp.session.request, web.Request)
diff --git a/tests/test_transport_htmlfile.py b/tests/test_transport_htmlfile.py
index 281bab79..6d8e77dc 100644
--- a/tests/test_transport_htmlfile.py
+++ b/tests/test_transport_htmlfile.py
@@ -1,7 +1,7 @@
 from unittest import mock
-from aiohttp import web
 
 import pytest
+from aiohttp import web
 from aiohttp.test_utils import make_mocked_coro
 
 from sockjs.transports import htmlfile
@@ -9,12 +9,12 @@
 
 @pytest.fixture
 def make_transport(make_manager, make_request, make_handler, make_fut):
-    def maker(method="GET", path="/", query_params={}):
+    def maker(method="GET", path="/", query_params=None):
         handler = make_handler(None)
         manager = make_manager(handler)
         request = make_request(method, path, query_params=query_params)
         request.app.freeze()
-        session = manager.get("TestSessionHtmlFile", create=True, request=request)
+        session = manager.get("TestSessionHtmlFile", create=True)
         return htmlfile.HTMLFileTransport(manager, session, request)
 
     return maker
@@ -25,13 +25,13 @@ async def test_streaming_send(make_transport):
 
     resp = trans.response = mock.Mock()
     resp.write = make_mocked_coro(None)
-    stop = await trans.send("text data")
+    stop = await trans._send("text data")
     resp.write.assert_called_with(b'<script>\np("text data");\n</script>\r\n')
     assert not stop
     assert trans.size == len(b'<script>\np("text data");\n</script>\r\n')
 
     trans.maxsize = 1
-    stop = trans.send("text data")
+    stop = await trans._send("text data")
     assert stop
 
 
@@ -46,24 +46,18 @@ async def test_process(make_transport, make_fut):
 async def test_process_no_callback(make_transport, make_fut):
     transp = make_transport()
     transp.session = mock.Mock()
-    transp.session._remote_closed = make_fut(1)
+    transp.manager.remote_closed = make_fut(1)
 
-    resp = await transp.process()
-    assert transp.session._remote_closed.called
-    assert resp.status == 500
+    with pytest.raises(web.HTTPInternalServerError):
+        await transp.process()
+    assert transp.manager.remote_closed.called
 
 
 async def test_process_bad_callback(make_transport, make_fut):
     transp = make_transport(query_params={"c": "calback!!!!"})
     transp.session = mock.Mock()
-    transp.session._remote_closed = make_fut(1)
-
-    resp = await transp.process()
-    assert transp.session._remote_closed.called
-    assert resp.status == 500
-
+    transp.manager.remote_closed = make_fut(1)
 
-async def test_session_has_request(make_transport, make_fut):
-    transp = make_transport(method="POST")
-    transp.session._remote_messages = make_fut(1)
-    assert isinstance(transp.session.request, web.Request)
+    with pytest.raises(web.HTTPInternalServerError):
+        await transp.process()
+    assert transp.manager.remote_closed.called
diff --git a/tests/test_transport_jsonp.py b/tests/test_transport_jsonp.py
index 449f213c..1109d984 100644
--- a/tests/test_transport_jsonp.py
+++ b/tests/test_transport_jsonp.py
@@ -1,8 +1,7 @@
 from unittest import mock
 
-from aiohttp import web
-
 import pytest
+from aiohttp import web
 from aiohttp.test_utils import make_mocked_coro
 
 from sockjs.transports import jsonp
@@ -10,11 +9,11 @@
 
 @pytest.fixture
 def make_transport(make_request, make_manager, make_handler, make_fut):
-    def maker(method="GET", path="/", query_params={}):
+    def maker(method="GET", path="/", query_params=None):
         handler = make_handler(None)
         manager = make_manager(handler)
         request = make_request(method, path, query_params=query_params)
-        session = manager.get("TestSessionJsonP", create=True, request=request)
+        session = manager.get("TestSessionJsonP", create=True)
         request.app.freeze()
         return jsonp.JSONPolling(manager, session, request)
 
@@ -27,7 +26,7 @@ async def test_streaming_send(make_transport):
 
     resp = trans.response = mock.Mock()
     resp.write = make_mocked_coro(None)
-    stop = await trans.send("text data")
+    stop = await trans._send("text data")
     resp.write.assert_called_with(b'/**/cb("text data");\r\n')
     assert stop
 
@@ -43,33 +42,32 @@ async def test_process(make_transport, make_fut):
 async def test_process_no_callback(make_transport, make_fut):
     transp = make_transport()
     transp.session = mock.Mock()
-    transp.session._remote_closed = make_fut(1)
+    transp.manager.remote_closed = make_fut(1)
 
-    resp = await transp.process()
-    assert transp.session._remote_closed.called
-    assert resp.status == 500
+    with pytest.raises(web.HTTPInternalServerError):
+        await transp.process()
+    assert transp.manager.remote_closed.called
 
 
 async def test_process_bad_callback(make_transport, make_fut):
     transp = make_transport(query_params={"c": "calback!!!!"})
     transp.session = mock.Mock()
-    transp.session._remote_closed = make_fut(1)
+    transp.manager.remote_closed = make_fut(1)
 
-    resp = await transp.process()
-    assert transp.session._remote_closed.called
-    assert resp.status == 500
+    with pytest.raises(web.HTTPInternalServerError):
+        await transp.process()
+    assert transp.manager.remote_closed.called
 
 
 async def test_process_not_supported(make_transport):
     transp = make_transport(method="PUT")
-    resp = await transp.process()
-    assert resp.status == 400
+    with pytest.raises(web.HTTPBadRequest):
+        await transp.process()
 
 
 async def xtest_process_bad_encoding(make_transport, make_fut):
     transp = make_transport(method="POST")
     transp.request.read = make_fut(b"test")
-    transp.request.content_type
     transp.request._content_type = "application/x-www-form-urlencoded"
     resp = await transp.process()
     assert resp.status == 500
@@ -78,7 +76,6 @@ async def xtest_process_bad_encoding(make_transport, make_fut):
 async def xtest_process_no_payload(make_transport, make_fut):
     transp = make_transport(method="POST")
     transp.request.read = make_fut(b"d=")
-    transp.request.content_type
     transp.request._content_type = "application/x-www-form-urlencoded"
     resp = await transp.process()
     assert resp.status == 500
@@ -93,14 +90,8 @@ async def xtest_process_bad_json(make_transport, make_fut):
 
 async def xtest_process_message(make_transport, make_fut):
     transp = make_transport(method="POST")
-    transp.session._remote_messages = make_fut(1)
+    transp.manager.remote_messages = make_fut(1)
     transp.request.read = make_fut(b'["msg1","msg2"]')
     resp = await transp.process()
     assert resp.status == 200
-    transp.session._remote_messages.assert_called_with(["msg1", "msg2"])
-
-
-async def test_session_has_request(make_transport, make_fut):
-    transp = make_transport(method="POST")
-    transp.session._remote_messages = make_fut(1)
-    assert isinstance(transp.session.request, web.Request)
+    transp.manager.remote_messages.assert_called_with(["msg1", "msg2"])
diff --git a/tests/test_transport_rawwebsocket.py b/tests/test_transport_rawwebsocket.py
index bac60964..62e5f0b3 100644
--- a/tests/test_transport_rawwebsocket.py
+++ b/tests/test_transport_rawwebsocket.py
@@ -1,22 +1,22 @@
-from unittest import mock
 from asyncio import Future
+from unittest import mock
 
 import pytest
+from aiohttp import WSMessage, WSMsgType
 
 from sockjs.exceptions import SessionIsClosed
-from sockjs.protocol import FRAME_CLOSE, FRAME_HEARTBEAT
+from sockjs.protocol import Frame
 from sockjs.transports.rawwebsocket import RawWebSocketTransport
-
-from aiohttp import WSMessage, WSMsgType
+from sockjs.transports.utils import cancel_tasks
 
 
 @pytest.fixture
 def make_transport(make_request, make_fut):
-    def maker(method="GET", path="/", query_params={}):
+    def maker(method="GET", path="/", query_params=None):
         manager = mock.Mock()
         session = mock.Mock()
         session._remote_closed = make_fut(1)
-        session._wait = make_fut((FRAME_CLOSE, ""))
+        session._get_frame = make_fut((Frame.CLOSE, ""))
         request = make_request(method, path, query_params=query_params)
         request.app.freeze()
         return RawWebSocketTransport(manager, session, request)
@@ -42,7 +42,7 @@ async def xtest_ticks_pong(make_transport, make_fut):
     session = transp.session
 
     await transp.client(ws, session)
-    assert session._tick.called
+    assert session.tick.called
 
 
 async def test_sends_ping(make_transport, make_fut):
@@ -55,13 +55,15 @@ async def test_sends_ping(make_transport, make_fut):
     ws.ping.side_effect = [future]
 
     hb_future = Future()
-    hb_future.set_result((FRAME_HEARTBEAT, b""))
+    hb_future.set_result((Frame.HEARTBEAT, b""))
 
     session_close_future = Future()
     session_close_future.set_exception(SessionIsClosed)
 
     session = mock.Mock()
-    session._wait.side_effect = [hb_future, session_close_future]
+    session.get_frame.side_effect = [hb_future, session_close_future]
+    transp.session = session
 
-    await transp.server(ws, session)
+    await transp.server(ws)
     assert ws.ping.called
+    await cancel_tasks(transp._wait_pong_task)
diff --git a/tests/test_transport_websocket.py b/tests/test_transport_websocket.py
index 2b1ef593..6f9defcc 100644
--- a/tests/test_transport_websocket.py
+++ b/tests/test_transport_websocket.py
@@ -1,27 +1,26 @@
 import asyncio
+import datetime
 from asyncio import Future
 from unittest import mock
 
-from aiohttp import web, WSMessage, WSMsgType
-
 import pytest
-
+from aiohttp import WSMessage, WSMsgType
 from aiohttp.test_utils import make_mocked_coro
 
-from sockjs import SessionManager, MSG_OPEN, MSG_CLOSED, MSG_MESSAGE
-from sockjs.protocol import FRAME_CLOSE
+from sockjs import MsgType, Session, Frame
+from sockjs.protocol import SockjsMessage
 from sockjs.transports import WebSocketTransport
 
 
 @pytest.fixture
 def make_transport(make_manager, make_request, make_handler, make_fut):
-    def maker(method="GET", path="/", query_params={}, handler=None):
+    def maker(method="GET", path="/", query_params=None, handler=None):
         handler = handler or make_handler(None)
         manager = make_manager(handler)
         request = make_request(method, path, query_params=query_params)
         request.app.freeze()
-        session = manager.get("TestSessionWebsocket", create=True, request=request)
-        session._wait = make_fut((FRAME_CLOSE, ""))
+        session = manager.get("TestSessionWebsocket", create=True)
+        session.get_frame = make_fut((Frame.CLOSE, ""))
         return WebSocketTransport(manager, session, request)
 
     return maker
@@ -32,6 +31,8 @@ async def xtest_process_release_acquire_and_remote_closed(make_transport):
     transp.session.interrupted = False
     transp.manager.acquire = make_mocked_coro()
     transp.manager.release = make_mocked_coro()
+    transp.manager.remote_closed = make_mocked_coro()
+
     resp = await transp.process()
     await transp.manager.clear()
 
@@ -39,7 +40,7 @@ async def xtest_process_release_acquire_and_remote_closed(make_transport):
     assert resp.headers.get("upgrade", "").lower() == "websocket"
     assert resp.headers.get("connection", "").lower() == "upgrade"
 
-    transp.session._remote_closed.assert_called_once_with()
+    assert transp.manager.remote_closed.called
     assert transp.manager.acquire.called
     assert transp.manager.release.called
 
@@ -47,35 +48,35 @@ async def xtest_process_release_acquire_and_remote_closed(make_transport):
 async def test_server_close(app, make_manager, make_request):
     reached_closed = False
 
-    loop = asyncio.get_event_loop()
+    loop = asyncio.get_running_loop()
 
-    async def handler(msg, session):
+    async def handler(manager, session: Session, msg: SockjsMessage):
         nonlocal reached_closed
-        if msg.tp == MSG_OPEN:
-            asyncio.ensure_future(session._remote_message("TESTMSG"))
-            pass
-
-        elif msg.tp == MSG_MESSAGE:
+        if msg.type == MsgType.OPEN:
             # To reproduce the ordering which makes the issue
             loop.call_later(0.05, session.close)
-        elif msg.tp == MSG_CLOSED:
+        elif msg.type == MsgType.MESSAGE:
+            # To reproduce the ordering which makes the issue
+            loop.call_later(0.05, session.close)
+        elif msg.type == MsgType.CLOSED:
             reached_closed = True
 
     app.freeze()
 
-    request = make_request("GET", "/", query_params={})
-    manager = SessionManager("sm", app, handler, debug=True)
+    request = make_request("GET", "/")
+    manager = make_manager(handler)
     session = manager.get("test", create=True)
 
     transp = WebSocketTransport(manager, session, request)
     await transp.process()
 
-    assert reached_closed is True
-
+    assert reached_closed is False
+    assert session.expires
+    assert not session.expired
+    session.expires = datetime.datetime.now()
+    await manager._gc_expired_sessions()
 
-async def test_session_has_request(make_transport, make_fut):
-    transp = make_transport(method="POST")
-    assert isinstance(transp.session.request, web.Request)
+    assert reached_closed is True
 
 
 async def test_frames(make_transport, make_handler):
@@ -111,8 +112,7 @@ async def test_frames(make_transport, make_handler):
         close_frame,
     ]
 
-    session = transp.session
-    await transp.client(ws, session)
+    await transp.client(ws)
 
     assert result[0][0].data == "single_msg"
     assert result[1][0].data == "msg1"
diff --git a/tests/test_transport_xhr.py b/tests/test_transport_xhr.py
index f6aa25b9..e9ccf0f7 100644
--- a/tests/test_transport_xhr.py
+++ b/tests/test_transport_xhr.py
@@ -1,19 +1,17 @@
-from aiohttp import web
-
 import pytest
 
-from sockjs.transports import xhr
+from sockjs.transports import xhr_pooling
 
 
 @pytest.fixture
 def make_transport(make_manager, make_request, make_handler, make_fut):
-    def maker(method="GET", path="/", query_params={}):
+    def maker(method="GET", path="/", query_params=None):
         handler = make_handler(None)
         manager = make_manager(handler)
         request = make_request(method, path, query_params=query_params)
         request.app.freeze()
-        session = manager.get("TestSessionXhr", create=True, request=request)
-        return xhr.XHRTransport(manager, session, request)
+        session = manager.get("TestSessionXhr", create=True)
+        return xhr_pooling.XHRTransport(manager, session, request)
 
     return maker
 
@@ -26,13 +24,7 @@ async def test_process(make_transport, make_fut):
     assert resp.status == 200
 
 
-async def test_process_OPTIONS(make_transport):
+async def test_process_options(make_transport):
     transp = make_transport(method="OPTIONS")
     resp = await transp.process()
     assert resp.status == 204
-
-
-async def test_session_has_request(make_transport, make_fut):
-    transp = make_transport()
-    transp.session._remote_messages = make_fut(1)
-    assert isinstance(transp.session.request, web.Request)
diff --git a/tests/test_transport_xhrsend.py b/tests/test_transport_xhrsend.py
index 5ad64d5a..e7b4cf14 100644
--- a/tests/test_transport_xhrsend.py
+++ b/tests/test_transport_xhrsend.py
@@ -1,27 +1,26 @@
-from aiohttp import web
-
 import pytest
+from aiohttp import web
 
-from sockjs.transports import xhrsend
+from sockjs.transports import xhr_pooling
 
 
 @pytest.fixture
 def make_transport(make_manager, make_request, make_handler, make_fut):
-    def maker(method="GET", path="/", query_params={}):
+    def maker(method="GET", path="/", query_params=None):
         handler = make_handler(None)
         manager = make_manager(handler)
         request = make_request(method, path, query_params=query_params)
         request.app.freeze()
-        session = manager.get("TestSessionXhrSend", create=True, request=request)
-        return xhrsend.XHRSendTransport(manager, session, request)
+        session = manager.get("TestSessionXhrSend", create=True)
+        return xhr_pooling.XHRSendTransport(manager, session, request)
 
     return maker
 
 
 async def test_not_supported_meth(make_transport):
     transp = make_transport(method="PUT")
-    resp = await transp.process()
-    assert resp.status == 403
+    with pytest.raises(web.HTTPForbidden):
+        await transp.process()
 
 
 async def xtest_no_payload(make_transport, make_fut):
@@ -40,20 +39,14 @@ async def xtest_bad_json(make_transport, make_fut):
 
 async def xtest_post_message(make_transport, make_fut):
     transp = make_transport()
-    transp.session._remote_messages = make_fut(1)
+    transp.manager.remote_messages = make_fut(1)
     transp.request.read = make_fut(b'["msg1","msg2"]')
     resp = await transp.process()
     assert resp.status == 204
-    transp.session._remote_messages.assert_called_with(["msg1", "msg2"])
+    transp.manager.remote_messages.assert_called_with(["msg1", "msg2"])
 
 
-async def test_OPTIONS(make_transport):
+async def test_options(make_transport):
     transp = make_transport(method="OPTIONS")
     resp = await transp.process()
     assert resp.status == 204
-
-
-async def test_session_has_request(make_transport, make_fut):
-    transp = make_transport(method="POST")
-    transp.session._remote_messages = make_fut(1)
-    assert isinstance(transp.session.request, web.Request)
diff --git a/tests/test_transport_xhrstreaming.py b/tests/test_transport_xhrstreaming.py
index 4f27621a..060664c4 100644
--- a/tests/test_transport_xhrstreaming.py
+++ b/tests/test_transport_xhrstreaming.py
@@ -1,5 +1,3 @@
-from aiohttp import web
-
 import pytest
 
 from sockjs.transports import xhrstreaming
@@ -7,12 +5,12 @@
 
 @pytest.fixture
 def make_transport(make_manager, make_request, make_handler, make_fut):
-    def maker(method="GET", path="/", query_params={}):
+    def maker(method="GET", path="/", query_params=None):
         handler = make_handler(None)
         manager = make_manager(handler)
         request = make_request(method, path, query_params=query_params)
         request.app.freeze()
-        session = manager.get("TestSessionXhrStreaming", create=True, request=request)
+        session = manager.get("TestSessionXhrStreaming", create=True)
         return xhrstreaming.XHRStreamingTransport(manager, session, request)
 
     return maker
@@ -26,13 +24,7 @@ async def test_process(make_transport, make_fut):
     assert resp.status == 200
 
 
-async def test_process_OPTIONS(make_transport):
+async def test_process_options(make_transport):
     transp = make_transport(method="OPTIONS")
     resp = await transp.process()
     assert resp.status == 204
-
-
-async def test_session_has_request(make_transport, make_fut):
-    transp = make_transport(method="POST")
-    transp.session._remote_messages = make_fut(1)
-    assert isinstance(transp.session.request, web.Request)