diff --git a/test/h2/test_frames.py b/test/h2/test_frames.py
index 313ef4054..310336b07 100644
--- a/test/h2/test_frames.py
+++ b/test/h2/test_frames.py
@@ -3,43 +3,59 @@ import tutils
 
 from nose.tools import assert_equal
 
-# TODO test stream association if valid or not
-
-
 def test_invalid_flags():
     tutils.raises(
         ValueError,
         DataFrame,
-        ContinuationFrame.FLAG_END_HEADERS,
-        0x1234567,
-        'foobar')
+        flags=ContinuationFrame.FLAG_END_HEADERS,
+        stream_id=0x1234567,
+        payload='foobar')
 
 
 def test_frame_equality():
-    a = DataFrame(6, Frame.FLAG_END_STREAM, 0x1234567, 'foobar')
-    b = DataFrame(6, Frame.FLAG_END_STREAM, 0x1234567, 'foobar')
+    a = DataFrame(
+        length=6,
+        flags=Frame.FLAG_END_STREAM,
+        stream_id=0x1234567,
+        payload='foobar')
+    b = DataFrame(
+        length=6,
+        flags=Frame.FLAG_END_STREAM,
+        stream_id=0x1234567,
+        payload='foobar')
     assert_equal(a, b)
 
 
 def test_too_large_frames():
-    DataFrame(6, Frame.FLAG_END_STREAM, 0x1234567)
+    DataFrame(
+        length=6,
+        flags=Frame.FLAG_END_STREAM,
+        stream_id=0x1234567)
 
 
 def test_data_frame_to_bytes():
-    f = DataFrame(6, Frame.FLAG_END_STREAM, 0x1234567, 'foobar')
+    f = DataFrame(
+        length=6,
+        flags=Frame.FLAG_END_STREAM,
+        stream_id=0x1234567,
+        payload='foobar')
     assert_equal(f.to_bytes().encode('hex'), '000006000101234567666f6f626172')
 
     f = DataFrame(
-        11,
-        Frame.FLAG_END_STREAM | Frame.FLAG_PADDED,
-        0x1234567,
-        'foobar',
+        length=11,
+        flags=(Frame.FLAG_END_STREAM | Frame.FLAG_PADDED),
+        stream_id=0x1234567,
+        payload='foobar',
         pad_length=3)
     assert_equal(
         f.to_bytes().encode('hex'),
         '00000a00090123456703666f6f626172000000')
 
-    f = DataFrame(6, Frame.FLAG_NO_FLAGS, 0x0, 'foobar')
+    f = DataFrame(
+        length=6,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
+        payload='foobar')
     tutils.raises(ValueError, f.to_bytes)
 
 
@@ -63,26 +79,26 @@ def test_data_frame_from_bytes():
 
 def test_data_frame_human_readable():
     f = DataFrame(
-        11,
-        Frame.FLAG_END_STREAM | Frame.FLAG_PADDED,
-        0x1234567,
-        'foobar',
+        length=11,
+        flags=(Frame.FLAG_END_STREAM | Frame.FLAG_PADDED),
+        stream_id=0x1234567,
+        payload='foobar',
         pad_length=3)
     assert f.human_readable()
 
 
 def test_headers_frame_to_bytes():
     f = HeadersFrame(
-        6,
-        Frame.FLAG_NO_FLAGS,
-        0x1234567,
+        length=6,
+        flags=(Frame.FLAG_NO_FLAGS),
+        stream_id=0x1234567,
         headers=[('host', 'foo.bar')])
     assert_equal(f.to_bytes().encode('hex'), '000007010001234567668594e75e31d9')
 
     f = HeadersFrame(
-        10,
-        HeadersFrame.FLAG_PADDED,
-        0x1234567,
+        length=10,
+        flags=(HeadersFrame.FLAG_PADDED),
+        stream_id=0x1234567,
         headers=[('host', 'foo.bar')],
         pad_length=3)
     assert_equal(
@@ -90,9 +106,9 @@ def test_headers_frame_to_bytes():
         '00000b01080123456703668594e75e31d9000000')
 
     f = HeadersFrame(
-        10,
-        HeadersFrame.FLAG_PRIORITY,
-        0x1234567,
+        length=10,
+        flags=(HeadersFrame.FLAG_PRIORITY),
+        stream_id=0x1234567,
         headers=[('host', 'foo.bar')],
         exclusive=True,
         stream_dependency=0x7654321,
@@ -102,9 +118,9 @@ def test_headers_frame_to_bytes():
         '00000c012001234567876543212a668594e75e31d9')
 
     f = HeadersFrame(
-        14,
-        HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY,
-        0x1234567,
+        length=14,
+        flags=(HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY),
+        stream_id=0x1234567,
         headers=[('host', 'foo.bar')],
         pad_length=3,
         exclusive=True,
@@ -115,9 +131,9 @@ def test_headers_frame_to_bytes():
         '00001001280123456703876543212a668594e75e31d9000000')
 
     f = HeadersFrame(
-        14,
-        HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY,
-        0x1234567,
+        length=14,
+        flags=(HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY),
+        stream_id=0x1234567,
         headers=[('host', 'foo.bar')],
         pad_length=3,
         exclusive=False,
@@ -127,7 +143,11 @@ def test_headers_frame_to_bytes():
         f.to_bytes().encode('hex'),
         '00001001280123456703076543212a668594e75e31d9000000')
 
-    f = HeadersFrame(6, Frame.FLAG_NO_FLAGS, 0x0, 'foobar')
+    f = HeadersFrame(
+        length=6,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
+        headers=[('host', 'foo.bar')])
     tutils.raises(ValueError, f.to_bytes)
 
 
@@ -188,9 +208,9 @@ def test_headers_frame_from_bytes():
 
 def test_headers_frame_human_readable():
     f = HeadersFrame(
-        7,
-        HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY,
-        0x1234567,
+        length=7,
+        flags=(HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY),
+        stream_id=0x1234567,
         headers=[],
         pad_length=3,
         exclusive=False,
@@ -199,9 +219,9 @@ def test_headers_frame_human_readable():
     assert f.human_readable()
 
     f = HeadersFrame(
-        14,
-        HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY,
-        0x1234567,
+        length=14,
+        flags=(HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY),
+        stream_id=0x1234567,
         headers=[('host', 'foo.bar')],
         pad_length=3,
         exclusive=False,
@@ -212,27 +232,35 @@ def test_headers_frame_human_readable():
 
 def test_priority_frame_to_bytes():
     f = PriorityFrame(
-        5,
-        Frame.FLAG_NO_FLAGS,
-        0x1234567,
+        length=5,
+        flags=(Frame.FLAG_NO_FLAGS),
+        stream_id=0x1234567,
         exclusive=True,
         stream_dependency=0x7654321,
         weight=42)
     assert_equal(f.to_bytes().encode('hex'), '000005020001234567876543212a')
 
     f = PriorityFrame(
-        5,
-        Frame.FLAG_NO_FLAGS,
-        0x1234567,
+        length=5,
+        flags=(Frame.FLAG_NO_FLAGS),
+        stream_id=0x1234567,
         exclusive=False,
         stream_dependency=0x7654321,
         weight=21)
     assert_equal(f.to_bytes().encode('hex'), '0000050200012345670765432115')
 
-    f = PriorityFrame(5, Frame.FLAG_NO_FLAGS, 0x0, stream_dependency=0x1234567)
+    f = PriorityFrame(
+        length=5,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
+        stream_dependency=0x1234567)
     tutils.raises(ValueError, f.to_bytes)
 
-    f = PriorityFrame(5, Frame.FLAG_NO_FLAGS, 0x1234567, stream_dependency=0x0)
+    f = PriorityFrame(
+        length=5,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
+        stream_dependency=0x0)
     tutils.raises(ValueError, f.to_bytes)
 
 
@@ -260,9 +288,9 @@ def test_priority_frame_from_bytes():
 
 def test_priority_frame_human_readable():
     f = PriorityFrame(
-        5,
-        Frame.FLAG_NO_FLAGS,
-        0x1234567,
+        length=5,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
         exclusive=False,
         stream_dependency=0x7654321,
         weight=21)
@@ -270,10 +298,17 @@ def test_priority_frame_human_readable():
 
 
 def test_rst_stream_frame_to_bytes():
-    f = RstStreamFrame(4, Frame.FLAG_NO_FLAGS, 0x1234567, error_code=0x7654321)
+    f = RstStreamFrame(
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
+        error_code=0x7654321)
     assert_equal(f.to_bytes().encode('hex'), '00000403000123456707654321')
 
-    f = RstStreamFrame(4, Frame.FLAG_NO_FLAGS, 0x0)
+    f = RstStreamFrame(
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0)
     tutils.raises(ValueError, f.to_bytes)
 
 
@@ -288,28 +323,39 @@ def test_rst_stream_frame_from_bytes():
 
 
 def test_rst_stream_frame_human_readable():
-    f = RstStreamFrame(4, Frame.FLAG_NO_FLAGS, 0x1234567, error_code=0x7654321)
+    f = RstStreamFrame(
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
+        error_code=0x7654321)
     assert f.human_readable()
 
 
 def test_settings_frame_to_bytes():
-    f = SettingsFrame(0, Frame.FLAG_NO_FLAGS, 0x0)
+    f = SettingsFrame(
+        length=0,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0)
     assert_equal(f.to_bytes().encode('hex'), '000000040000000000')
 
-    f = SettingsFrame(0, SettingsFrame.FLAG_ACK, 0x0)
+    f = SettingsFrame(
+        length=0,
+        flags=SettingsFrame.FLAG_ACK,
+        stream_id=0x0)
     assert_equal(f.to_bytes().encode('hex'), '000000040100000000')
 
     f = SettingsFrame(
-        6,
-        SettingsFrame.FLAG_ACK, 0x0,
+        length=6,
+        flags=SettingsFrame.FLAG_ACK,
+        stream_id=0x0,
         settings={
             SettingsFrame.SETTINGS.SETTINGS_ENABLE_PUSH: 1})
     assert_equal(f.to_bytes().encode('hex'), '000006040100000000000200000001')
 
     f = SettingsFrame(
-        12,
-        Frame.FLAG_NO_FLAGS,
-        0x0,
+        length=12,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
         settings={
             SettingsFrame.SETTINGS.SETTINGS_ENABLE_PUSH: 1,
             SettingsFrame.SETTINGS.SETTINGS_MAX_CONCURRENT_STREAMS: 0x12345678})
@@ -317,7 +363,10 @@ def test_settings_frame_to_bytes():
         f.to_bytes().encode('hex'),
         '00000c040000000000000200000001000312345678')
 
-    f = SettingsFrame(0, Frame.FLAG_NO_FLAGS, 0x1234567)
+    f = SettingsFrame(
+        length=0,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567)
     tutils.raises(ValueError, f.to_bytes)
 
 
@@ -361,13 +410,17 @@ def test_settings_frame_from_bytes():
 
 
 def test_settings_frame_human_readable():
-    f = SettingsFrame(12, Frame.FLAG_NO_FLAGS, 0x0, settings={})
+    f = SettingsFrame(
+        length=12,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
+        settings={})
     assert f.human_readable()
 
     f = SettingsFrame(
-        12,
-        Frame.FLAG_NO_FLAGS,
-        0x0,
+        length=12,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
         settings={
             SettingsFrame.SETTINGS.SETTINGS_ENABLE_PUSH: 1,
             SettingsFrame.SETTINGS.SETTINGS_MAX_CONCURRENT_STREAMS: 0x12345678})
@@ -376,30 +429,38 @@ def test_settings_frame_human_readable():
 
 def test_push_promise_frame_to_bytes():
     f = PushPromiseFrame(
-        10,
-        Frame.FLAG_NO_FLAGS,
-        0x1234567,
-        0x7654321,
-        'foobar')
+        length=10,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
+        promised_stream=0x7654321,
+        header_block_fragment='foobar')
     assert_equal(
         f.to_bytes().encode('hex'),
         '00000a05000123456707654321666f6f626172')
 
     f = PushPromiseFrame(
-        14,
-        HeadersFrame.FLAG_PADDED,
-        0x1234567,
-        0x7654321,
-        'foobar',
+        length=14,
+        flags=HeadersFrame.FLAG_PADDED,
+        stream_id=0x1234567,
+        promised_stream=0x7654321,
+        header_block_fragment='foobar',
         pad_length=3)
     assert_equal(
         f.to_bytes().encode('hex'),
         '00000e0508012345670307654321666f6f626172000000')
 
-    f = PushPromiseFrame(4, Frame.FLAG_NO_FLAGS, 0x0, 0x1234567)
+    f = PushPromiseFrame(
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
+        promised_stream=0x1234567)
     tutils.raises(ValueError, f.to_bytes)
 
-    f = PushPromiseFrame(4, Frame.FLAG_NO_FLAGS, 0x1234567, 0x0)
+    f = PushPromiseFrame(
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
+        promised_stream=0x0)
     tutils.raises(ValueError, f.to_bytes)
 
 
@@ -424,27 +485,38 @@ def test_push_promise_frame_from_bytes():
 
 def test_push_promise_frame_human_readable():
     f = PushPromiseFrame(
-        14,
-        HeadersFrame.FLAG_PADDED,
-        0x1234567,
-        0x7654321,
-        'foobar',
+        length=14,
+        flags=HeadersFrame.FLAG_PADDED,
+        stream_id=0x1234567,
+        promised_stream=0x7654321,
+        header_block_fragment='foobar',
         pad_length=3)
     assert f.human_readable()
 
 
 def test_ping_frame_to_bytes():
-    f = PingFrame(8, PingFrame.FLAG_ACK, 0x0, payload=b'foobar')
+    f = PingFrame(
+        length=8,
+        flags=PingFrame.FLAG_ACK,
+        stream_id=0x0,
+        payload=b'foobar')
     assert_equal(
         f.to_bytes().encode('hex'),
         '000008060100000000666f6f6261720000')
 
-    f = PingFrame(8, Frame.FLAG_NO_FLAGS, 0x0, payload=b'foobardeadbeef')
+    f = PingFrame(
+        length=8,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
+        payload=b'foobardeadbeef')
     assert_equal(
         f.to_bytes().encode('hex'),
         '000008060000000000666f6f6261726465')
 
-    f = PingFrame(8, Frame.FLAG_NO_FLAGS, 0x1234567)
+    f = PingFrame(
+        length=8,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567)
     tutils.raises(ValueError, f.to_bytes)
 
 
@@ -467,15 +539,19 @@ def test_ping_frame_from_bytes():
 
 
 def test_ping_frame_human_readable():
-    f = PingFrame(8, PingFrame.FLAG_ACK, 0x0, payload=b'foobar')
+    f = PingFrame(
+        length=8,
+        flags=PingFrame.FLAG_ACK,
+        stream_id=0x0,
+        payload=b'foobar')
     assert f.human_readable()
 
 
 def test_goaway_frame_to_bytes():
     f = GoAwayFrame(
-        8,
-        Frame.FLAG_NO_FLAGS,
-        0x0,
+        length=8,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
         last_stream=0x1234567,
         error_code=0x87654321,
         data=b'')
@@ -484,9 +560,9 @@ def test_goaway_frame_to_bytes():
         '0000080700000000000123456787654321')
 
     f = GoAwayFrame(
-        14,
-        Frame.FLAG_NO_FLAGS,
-        0x0,
+        length=14,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
         last_stream=0x1234567,
         error_code=0x87654321,
         data=b'foobar')
@@ -495,16 +571,17 @@ def test_goaway_frame_to_bytes():
         '00000e0700000000000123456787654321666f6f626172')
 
     f = GoAwayFrame(
-        8,
-        Frame.FLAG_NO_FLAGS,
-        0x1234567,
+        length=8,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
         last_stream=0x1234567,
         error_code=0x87654321)
     tutils.raises(ValueError, f.to_bytes)
 
 
 def test_goaway_frame_from_bytes():
-    f = Frame.from_bytes('0000080700000000000123456787654321'.decode('hex'))
+    f = Frame.from_bytes(
+        '0000080700000000000123456787654321'.decode('hex'))
     assert isinstance(f, GoAwayFrame)
     assert_equal(f.length, 8)
     assert_equal(f.TYPE, GoAwayFrame.TYPE)
@@ -528,9 +605,9 @@ def test_goaway_frame_from_bytes():
 
 def test_go_away_frame_human_readable():
     f = GoAwayFrame(
-        14,
-        Frame.FLAG_NO_FLAGS,
-        0x0,
+        length=14,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
         last_stream=0x1234567,
         error_code=0x87654321,
         data=b'foobar')
@@ -539,23 +616,23 @@ def test_go_away_frame_human_readable():
 
 def test_window_update_frame_to_bytes():
     f = WindowUpdateFrame(
-        4,
-        Frame.FLAG_NO_FLAGS,
-        0x0,
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
         window_size_increment=0x1234567)
     assert_equal(f.to_bytes().encode('hex'), '00000408000000000001234567')
 
     f = WindowUpdateFrame(
-        4,
-        Frame.FLAG_NO_FLAGS,
-        0x1234567,
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
         window_size_increment=0x7654321)
     assert_equal(f.to_bytes().encode('hex'), '00000408000123456707654321')
 
     f = WindowUpdateFrame(
-        4,
-        Frame.FLAG_NO_FLAGS,
-        0x0,
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x0,
         window_size_increment=0xdeadbeef)
     tutils.raises(ValueError, f.to_bytes)
 
@@ -575,22 +652,26 @@ def test_window_update_frame_from_bytes():
 
 def test_window_update_frame_human_readable():
     f = WindowUpdateFrame(
-        4,
-        Frame.FLAG_NO_FLAGS,
-        0x1234567,
+        length=4,
+        flags=Frame.FLAG_NO_FLAGS,
+        stream_id=0x1234567,
         window_size_increment=0x7654321)
     assert f.human_readable()
 
 
 def test_continuation_frame_to_bytes():
     f = ContinuationFrame(
-        6,
-        ContinuationFrame.FLAG_END_HEADERS,
-        0x1234567,
-        'foobar')
+        length=6,
+        flags=ContinuationFrame.FLAG_END_HEADERS,
+        stream_id=0x1234567,
+        header_block_fragment='foobar')
     assert_equal(f.to_bytes().encode('hex'), '000006090401234567666f6f626172')
 
-    f = ContinuationFrame(6, ContinuationFrame.FLAG_END_HEADERS, 0x0, 'foobar')
+    f = ContinuationFrame(
+        length=6,
+        flags=ContinuationFrame.FLAG_END_HEADERS,
+        stream_id=0x0,
+        header_block_fragment='foobar')
     tutils.raises(ValueError, f.to_bytes)
 
 
@@ -606,8 +687,8 @@ def test_continuation_frame_from_bytes():
 
 def test_continuation_frame_human_readable():
     f = ContinuationFrame(
-        6,
-        ContinuationFrame.FLAG_END_HEADERS,
-        0x1234567,
-        'foobar')
+        length=6,
+        flags=ContinuationFrame.FLAG_END_HEADERS,
+        stream_id=0x1234567,
+        header_block_fragment='foobar')
     assert f.human_readable()