def setUp(self):
""" Set up test fixtures """
self.header_class = httpresponse.ResponseHeader
self.valid_headers = {
'simple': dict(code=200, ),
'ok': dict(code=200, ),
'ok-protocol': dict(
code=200,
protocol="HTTP/1.1",
),
'content-type-bogus': dict(
code=200,
content_type="BoGuS",
),
}
for key, params in self.valid_headers.items():
args = params.get('args', dict())
code = params['code']
args['code'] = code
protocol = params.get('protocol')
if protocol is not None:
args['protocol'] = protocol
content_type = params.get('content_type')
if content_type is not None:
args['content_type'] = content_type
params['args'] = args
instance = self.header_class(**args)
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict=self.valid_headers)
def setUp(self):
""" Set up test fixtures """
self.response_class = httpresponse.Response
self.valid_responses = {
'simple': dict(
header = Stub_ResponseHeader(code = 200),
),
'payload': dict(
header = Stub_ResponseHeader(code = 200),
data = object(),
),
}
for key, params in self.valid_responses.items():
args = params.get('args', dict())
header = params['header']
args['header'] = header
data = params.get('data')
if data is not None:
args['data'] = data
params['args'] = args
instance = self.response_class(**args)
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict = self.valid_responses
)
def setUp(self):
""" Set up test fixtures """
self.response_class = httpresponse.Response
self.valid_responses = {
'simple': dict(header=Stub_ResponseHeader(code=200), ),
'payload': dict(
header=Stub_ResponseHeader(code=200),
data=object(),
),
}
for key, params in self.valid_responses.items():
args = params.get('args', dict())
header = params['header']
args['header'] = header
data = params.get('data')
if data is not None:
args['data'] = data
params['args'] = args
instance = self.response_class(**args)
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict=self.valid_responses)
def setUp(self):
""" Set up test fixtures """
self.mock_outfile = StringIO()
self.server_class = server.GracieServer
scaffold.mock("server.OpenIDServer",
mock_obj=Stub_OpenIDServer,
outfile=self.mock_outfile)
scaffold.mock("server.OpenIDStore",
mock_obj=Stub_OpenIDStore,
outfile=self.mock_outfile)
scaffold.mock("server.ConsumerAuthStore",
mock_obj=Stub_ConsumerAuthStore,
outfile=self.mock_outfile)
scaffold.mock("server.SessionManager",
mock_obj=Stub_SessionManager,
outfile=self.mock_outfile)
scaffold.mock("server.HTTPServer",
mock_obj=Stub_HTTPServer,
outfile=self.mock_outfile)
scaffold.mock("server.HTTPRequestHandler",
mock_obj=Stub_HTTPRequestHandler,
outfile=self.mock_outfile)
self.valid_servers = {
'simple': dict(),
'with-opts': dict(opts=dict(
foo="spam",
bar="eggs",
), ),
'datadir': dict(
opts=dict(datadir="/foo/bar", ),
datadir="/foo/bar",
),
}
for key, params in self.valid_servers.items():
args = params.get('args')
if not args:
args = dict()
opts = make_default_opts()
opts._update_loose(params.get('opts', dict()))
params['opts'] = opts
args.update(dict(
socket_params=None,
opts=opts,
))
instance = self.server_class(**args)
params['args'] = args
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict=self.valid_servers)
def setUp(self):
""" Set up test fixtures """
self.server_class = httpserver.HTTPServer
self.stub_handler_class = Stub_HTTPRequestHandler
self.mock_handler_class = Mock('HTTPRequestHandler')
self.server_bind_prev = httpserver.BaseHTTPServer.server_bind
httpserver.BaseHTTPServer.server_bind = stub_server_bind
self.stdout_prev = sys.stdout
self.stdout_test = StringIO()
sys.stdout = self.stdout_test
self.valid_servers = {
'simple': dict(
address = ('', 80),
),
}
for key, params in self.valid_servers.items():
args = params.get('args')
address = params.get('address')
handler_class = params.setdefault(
'handler_class', self.stub_handler_class)
opts = make_default_opts()
gracie_server = params.setdefault(
'gracie_server', Stub_GracieServer(address, opts)
)
if not args:
args = dict(
server_address = params['address'],
RequestHandlerClass = params['handler_class'],
gracie_server = params['gracie_server'],
)
instance = self.server_class(**args)
params['args'] = args
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict = self.valid_servers
)
def setUp(self):
""" Set up test fixtures """
self.server_class = httpserver.HTTPServer
self.stub_handler_class = Stub_HTTPRequestHandler
self.mock_handler_class = Mock('HTTPRequestHandler')
self.server_bind_prev = httpserver.BaseHTTPServer.server_bind
httpserver.BaseHTTPServer.server_bind = stub_server_bind
self.stdout_prev = sys.stdout
self.stdout_test = StringIO()
sys.stdout = self.stdout_test
self.valid_servers = {
'simple': dict(address=('', 80), ),
}
for key, params in self.valid_servers.items():
args = params.get('args')
address = params.get('address')
handler_class = params.setdefault('handler_class',
self.stub_handler_class)
opts = make_default_opts()
gracie_server = params.setdefault('gracie_server',
Stub_GracieServer(address, opts))
if not args:
args = dict(
server_address=params['address'],
RequestHandlerClass=params['handler_class'],
gracie_server=params['gracie_server'],
)
instance = self.server_class(**args)
params['args'] = args
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict=self.valid_servers)
def setUp(self):
""" Set up test fixtures """
self.header_class = httpresponse.ResponseHeader
self.valid_headers = {
'simple': dict(
code = 200,
),
'ok': dict(
code = 200,
),
'ok-protocol': dict(
code = 200,
protocol = "HTTP/1.1",
),
'content-type-bogus': dict(
code = 200,
content_type = "BoGuS",
),
}
for key, params in self.valid_headers.items():
args = params.get('args', dict())
code = params['code']
args['code'] = code
protocol = params.get('protocol')
if protocol is not None:
args['protocol'] = protocol
content_type = params.get('content_type')
if content_type is not None:
args['content_type'] = content_type
params['args'] = args
instance = self.header_class(**args)
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict = self.valid_headers
)
def setUp(self):
""" Set up test fixtures """
self.page_class = pagetemplate.Page
Mixin_PageTemplateFixture.setUp(self)
self.valid_pages = {
'simple':
dict(),
'welcome':
dict(
title="Welcome",
content="Lorem ipsum dolor sic amet",
),
'result':
dict(
title="Result",
content="Here is your result: $result.",
values=dict(result="thribble", ),
),
'authenticated':
dict(
title="Logged in",
content="Lorem ipsum dolor sic amet",
auth_entry=dict(
id=1010,
name="fred",
fullname="Fred Nurk",
),
),
}
for key, params in self.valid_pages.items():
args = params.get('args')
if args is None:
args = dict()
title = params.get('title')
if title is not None:
args.update(dict(title=title))
params['args'] = args
instance = self.page_class(**args)
content = params.get('content')
if content is not None:
instance.content = content
values = params.get('values', dict())
if 'auth_entry' not in values:
values.update({'auth_entry': None})
values.update(
dict(
server_version="FooBar v0.0",
server_location="frobnitz:9779",
root_url="/",
server_url="/openidserver",
login_url="/login",
logout_url="/logout",
))
instance.values.update(values)
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict=self.valid_pages)
def setUp(self):
""" Set up test fixtures """
self.app_class = gracied.Gracie
self.stdout_prev = sys.stdout
self.stdout_test = StringIO()
sys.stdout = self.stdout_test
self.parser_error_prev = gracied.OptionParser.error
gracied.OptionParser.error = Mock("OptionParser.error",
raises=SystemExit)
self.stub_server_class = Stub_GracieServer
self.mock_server_class = Mock('GracieServer_class')
self.mock_server_class.mock_returns = Mock('GracieServer')
self.server_class_prev = gracied.GracieServer
gracied.GracieServer = self.stub_server_class
self.default_port_prev = gracied.default_port
gracied.default_port = 7654
self.valid_apps = {
'simple':
dict(),
'argv_loglevel_debug':
dict(options=["--log-level", "debug"], ),
'change-host':
dict(
options=["--host", "frobnitz"],
host="frobnitz",
),
'change-port':
dict(
options=["--port", "9779"],
port=9779,
),
'change-address':
dict(
options=["--host", "frobnitz", "--port", "9779"],
host="frobnitz",
port=9779,
),
'change-root-url':
dict(
options=["--root-url", "http://spudnik/spam"],
root_url="http://spudnik/spam",
),
'change-address-and-root-url':
dict(
options=[
"--host",
"frobnitz",
"--port",
"9779",
"--root-url",
"http://spudnik/spam",
],
host="frobnitz",
port=9779,
root_url="http://frobnitz/spam",
),
}
for key, params in self.valid_apps.items():
argv = ["progname"]
options = params.get('options', None)
if options:
argv.extend(options)
params['argv'] = argv
args = dict(argv=argv)
params['args'] = args
instance = self.app_class(**args)
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict=self.valid_apps)
def setUp(self):
""" Set up test fixtures """
self.app_class = gracied.Gracie
self.stdout_prev = sys.stdout
self.stdout_test = StringIO()
sys.stdout = self.stdout_test
self.parser_error_prev = gracied.OptionParser.error
gracied.OptionParser.error = Mock(
"OptionParser.error",
raises=SystemExit)
self.stub_server_class = Stub_GracieServer
self.mock_server_class = Mock('GracieServer_class')
self.mock_server_class.mock_returns = Mock('GracieServer')
self.server_class_prev = gracied.GracieServer
gracied.GracieServer = self.stub_server_class
self.default_port_prev = gracied.default_port
gracied.default_port = 7654
self.valid_apps = {
'simple': dict(
),
'argv_loglevel_debug': dict(
options = ["--log-level", "debug"],
),
'change-host': dict(
options = ["--host", "frobnitz"],
host = "frobnitz",
),
'change-port': dict(
options = ["--port", "9779"],
port = 9779,
),
'change-address': dict(
options = ["--host", "frobnitz", "--port", "9779"],
host = "frobnitz",
port = 9779,
),
'change-root-url': dict(
options = ["--root-url", "http://spudnik/spam"],
root_url = "http://spudnik/spam",
),
'change-address-and-root-url': dict(
options = [
"--host", "frobnitz", "--port", "9779",
"--root-url", "http://spudnik/spam",
],
host = "frobnitz",
port = 9779,
root_url = "http://frobnitz/spam",
),
}
for key, params in self.valid_apps.items():
argv = ["progname"]
options = params.get('options', None)
if options:
argv.extend(options)
params['argv'] = argv
args = dict(
argv=argv
)
params['args'] = args
instance = self.app_class(**args)
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict = self.valid_apps
)
def setUp(self):
""" Set up test fixtures """
self.handler_class = httprequest.HTTPRequestHandler
self.stdout_prev = sys.stdout
self.stdout_test = StringIO()
sys.stdout = self.stdout_test
self.response_class_prev = httprequest.Response
self.response_header_class_prev = httprequest.ResponseHeader
self.page_class_prev = httprequest.pagetemplate.Page
self.cookie_name_prev = httprequest.session_cookie_name
self.dispatch_method_prev = self.handler_class._dispatch
httprequest.Response = Mock('Response_class')
httprequest.Response.mock_returns = Mock('Response')
httprequest.ResponseHeader = Mock('ResponseHeader_class')
httprequest.ResponseHeader.mock_returns = Mock('ResponseHeader')
httprequest.pagetemplate.Page = Mock('Page_class')
httprequest.pagetemplate.Page.mock_returns = Mock('Page')
httprequest.session_cookie_name = "TEST_session"
mock_openid_server = Mock('openid_server')
self.valid_requests = {
'get-bogus': dict(
request = Stub_Request("GET", "/bogus"),
),
'get-root': dict(
request = Stub_Request("GET", "/"),
),
'no-cookie': dict(
request = Stub_Request("GET", "/"),
),
'unknown-cookie': dict(
request = Stub_Request("GET", "/",
header = [
("Cookie", "TEST_session=DECAFBAD"),
],
),
session_id = "DECAFBAD",
),
'good-cookie': dict(
identity_name = "fred",
request = Stub_Request("GET", "/",
header = [
("Cookie", "TEST_session=DEADBEEF-fred"),
],
),
session = dict(
session_id = "DEADBEEF-fred",
username = "******",
),
),
'id-bogus': dict(
identity_name = "bogus",
request = Stub_Request("GET", "/id/bogus"),
),
'id-fred': dict(
identity_name = "fred",
request = Stub_Request("GET", "/id/fred"),
),
'logout': dict(
request = Stub_Request("GET", "/logout"),
),
'login': dict(
request = Stub_Request("GET", "/login"),
),
'nobutton-login': dict(
request = Stub_Request("POST", "/login",
query = dict(
username="******",
password="******",
),
),
),
'cancel-login': dict(
request = Stub_Request("POST", "/login",
query = dict(
username="******",
password="******",
cancel="Cancel",
),
),
),
'login-bogus': dict(
identity_name = "bogus",
request = Stub_Request("POST", "/login",
query = dict(
username="******",
password="******",
submit="Sign in",
),
),
),
'login-fred-wrong': dict(
identity_name = "fred",
request = Stub_Request("POST", "/login",
query = dict(
username="******",
password="******",
submit="Sign in",
),
),
),
'login-fred-okay': dict(
identity_name = "fred",
request = Stub_Request("POST", "/login",
query = dict(
username="******",
password="******",
submit="Sign in",
),
),
),
'openid-no-query': dict(
request = Stub_Request("GET", "/openidserver"),
),
'openid-bogus-query': dict(
request = Stub_Request("GET", "/openidserver",
query = {
"foo.bar": "spam",
"flim.flam": "",
"wibble.wobble": "eggs",
},
),
),
'openid-query-associate': dict(
request = Stub_Request("GET", "/openidserver",
query = {
"openid.mode": "associate",
"openid.session_type": "",
},
),
),
'openid-query-checkid_immediate-no-session': dict(
request = Stub_Request("GET", "/openidserver",
header = [],
query = {
"openid.mode": "checkid_immediate",
"openid.identity": "http://example.org:0/id/fred",
"openid.return_to": "http://example.com/",
},
),
),
'openid-query-checkid_setup-no-session': dict(
request = Stub_Request("GET", "/openidserver",
header = [],
query = {
"openid.mode": "checkid_setup",
"openid.identity": "http://example.org:0/id/fred",
"openid.return_to": "http://example.com/",
},
),
),
'openid-query-checkid_immediate-other-session': dict(
request = Stub_Request("GET", "/openidserver",
header = [
("Cookie", "TEST_session=DEADBEEF-bill"),
],
query = {
"openid.mode": "checkid_immediate",
"openid.identity": "http://example.org:0/id/fred",
"openid.return_to": "http://example.com/",
},
),
session = dict(
session_id = "DEADBEEF-bill",
username = "******",
),
),
'openid-query-checkid_setup-other-session': dict(
request = Stub_Request("GET", "/openidserver",
header = [
("Cookie", "TEST_session=DEADBEEF-bill"),
],
query = {
"openid.mode": "checkid_setup",
"openid.identity": "http://example.org:0/id/fred",
"openid.return_to": "http://example.com/",
},
),
session = dict(
session_id = "DEADBEEF-bill",
username = "******",
),
),
'openid-query-checkid_immediate-right-session': dict(
request = Stub_Request("GET", "/openidserver",
header = [
("Cookie", "TEST_session=DEADBEEF-fred"),
],
query = {
"openid.mode": "checkid_immediate",
"openid.identity": "http://example.org:0/id/fred",
"openid.return_to": "http://example.com/",
},
),
session = dict(
session_id = "DEADBEEF-fred",
username = "******",
),
),
'openid-query-checkid_setup-right-session': dict(
request = Stub_Request("GET", "/openidserver",
header = [
("Cookie", "TEST_session=DEADBEEF-fred"),
],
query = {
"openid.mode": "checkid_setup",
"openid.identity": "http://example.org:0/id/fred",
"openid.return_to": "http://example.com/",
},
),
session = dict(
session_id = "DEADBEEF-fred",
username = "******",
),
),
'openid-cancel-login': dict(
request = Stub_Request("POST", "/login",
header = [
("Cookie", "TEST_session=DEADBEEF"),
],
query = dict(
username = "******",
password = "******",
cancel = "Cancel",
),
),
session = dict(
session_id = "DEADBEEF",
last_openid_request = Stub_OpenIDRequest(
http_query = {'openid.mode': "checkid_setup"},
params = dict(
identity = "http://example.org:0/id/fred",
trust_root = "http://example.com/",
return_to = "http://example.com/account",
),
),
),
),
'openid-login-bill-other': dict(
identity_name = "fred",
request = Stub_Request("POST", "/login",
header = [
("Cookie", "TEST_session=DEADBEEF"),
],
query = dict(
username="******",
password="******",
submit="Sign in",
),
),
session = dict(
session_id = "DEADBEEF",
last_openid_request = Stub_OpenIDRequest(
http_query = {'openid.mode': "checkid_setup"},
params = dict(
identity = "http://example.org:0/id/fred",
trust_root = "http://example.com/",
return_to = "http://example.com/account",
),
),
),
),
'openid-login-fred-okay': dict(
identity_name = "fred",
request = Stub_Request("POST", "/login",
header = [
("Cookie", "TEST_session=DEADBEEF"),
],
query = dict(
username="******",
password="******",
submit="Sign in",
),
),
session = dict(
session_id = "DEADBEEF",
last_openid_request = Stub_OpenIDRequest(
http_query = {'openid.mode': "checkid_setup"},
params = dict(
identity = "http://example.org:0/id/fred",
trust_root = "http://example.com/",
return_to = "http://example.com/account",
),
),
),
),
}
logging.basicConfig(stream=self.stdout_test)
for key, params in self.valid_requests.items():
args = params.get('args')
request = params['request']
opts = Stub_OptionValues(dict(
host = "example.org",
port = 0,
root_url = "http://example.org:0/",
))
gracie_server = Stub_GracieServer(opts)
sess_manager = gracie_server.sess_manager
session = params.get('session', dict())
sess_manager.create_session(session)
server = params.setdefault(
'server',
gracie_server.http_server
)
mock_openid_request = self._make_mock_openid_request(
request.query
)
mock_openid_server = self._make_mock_openid_server(
mock_openid_request
)
server.gracie_server.openid_server = mock_openid_server
if not args:
args = dict(
request = request.connection(),
client_address = (opts.host, opts.port),
server = server,
)
params['args'] = args
self.iterate_params = scaffold.make_params_iterator(
default_params_dict = self.valid_requests
)
version = Stub_GracieServer.version
self.expect_server_version = "Gracie/%(version)s" % vars()
python_version = sys.version.split()[0]
self.expect_sys_version = "Python/%(python_version)s" % vars()
def setUp(self):
""" Set up test fixtures """
self.page_class = pagetemplate.Page
Mixin_PageTemplateFixture.setUp(self)
self.valid_pages = {
'simple': dict(
),
'welcome': dict(
title = "Welcome",
content = "Lorem ipsum dolor sic amet",
),
'result': dict(
title = "Result",
content = "Here is your result: $result.",
values = dict(
result = "thribble",
),
),
'authenticated': dict(
title = "Logged in",
content = "Lorem ipsum dolor sic amet",
auth_entry = dict(
id = 1010,
name = "fred",
fullname = "Fred Nurk",
),
),
}
for key, params in self.valid_pages.items():
args = params.get('args')
if args is None:
args = dict()
title = params.get('title')
if title is not None:
args.update(dict(title=title))
params['args'] = args
instance = self.page_class(**args)
content = params.get('content')
if content is not None:
instance.content = content
values = params.get('values', dict())
if 'auth_entry' not in values:
values.update({'auth_entry': None})
values.update(dict(
server_version = "FooBar v0.0",
server_location = "frobnitz:9779",
root_url = "/",
server_url = "/openidserver",
login_url = "/login",
logout_url = "/logout",
))
instance.values.update(values)
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict = self.valid_pages
)
def setUp(self):
""" Set up test fixtures """
self.mock_outfile = StringIO()
self.server_class = server.GracieServer
scaffold.mock("server.OpenIDServer",
mock_obj=Stub_OpenIDServer,
outfile=self.mock_outfile)
scaffold.mock("server.OpenIDStore",
mock_obj=Stub_OpenIDStore,
outfile=self.mock_outfile)
scaffold.mock("server.ConsumerAuthStore",
mock_obj=Stub_ConsumerAuthStore,
outfile=self.mock_outfile)
scaffold.mock("server.SessionManager",
mock_obj=Stub_SessionManager,
outfile=self.mock_outfile)
scaffold.mock("server.HTTPServer",
mock_obj=Stub_HTTPServer,
outfile=self.mock_outfile)
scaffold.mock("server.HTTPRequestHandler",
mock_obj=Stub_HTTPRequestHandler,
outfile=self.mock_outfile)
self.valid_servers = {
'simple': dict(
),
'with-opts': dict(
opts = dict(
foo="spam",
bar="eggs",
),
),
'datadir': dict(
opts = dict(
datadir = "/foo/bar",
),
datadir = "/foo/bar",
),
}
for key, params in self.valid_servers.items():
args = params.get('args')
if not args:
args = dict()
opts = make_default_opts()
opts._update_loose(params.get('opts', dict()))
params['opts'] = opts
args.update(dict(
socket_params=None,
opts=opts,
))
instance = self.server_class(**args)
params['args'] = args
params['instance'] = instance
self.iterate_params = scaffold.make_params_iterator(
default_params_dict = self.valid_servers
)
