def test_parse_first_node():
test_stuff = parse_first_node.__doc__.split("```")
tinst = eval(utils.dedent(test_stuff[1]))
tstr = reflow(remove_comments(utils.dedent(test_stuff[2])))
uinst, leftovers = parse_first_node(tstr)
assert isinstance(uinst, StoryNode), (
"Failed to parse a node from:\n```\n{}\n``".format(tstr)
)
assert leftovers.strip() == "", (
"Parsed node had leftovers:\n```\n{}\n```".format(leftovers)
)
rstr = render_node(tinst)
urstr = render_node(uinst)
ruinst, leftovers = parse_first_node(rstr)
assert isinstance(ruinst, StoryNode), (
"Failed to re-parse a node from:\n```\n{}\n``".format(rstr)
)
assert leftovers.strip() == "", (
"Re-parsed node had leftovers:\n```\n{}\n```".format(leftovers)
)
assert tinst == uinst, (
(
"Parsed Story doesn't match eval'd version:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(str(tinst), str(uinst), "\n ".join(diff(tinst, uinst)))
)
assert rstr == urstr, (
(
"Rendered Story doesn't match re-rendered version:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(
str(rstr),
str(urstr),
"\n ".join(diff(rstr, urstr))
)
)
assert tinst == ruinst, (
(
"Re-parsed Story doesn't match original:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(
str(tinst),
str(ruinst),
"\n ".join(diff(tinst, ruinst))
)
)
return True
def test_packable():
test_stuff = cls._pack_.__doc__.split("```")
tinst = eval(utils.dedent(test_stuff[1]))
tobj = eval(utils.dedent(test_stuff[2]))
uinst = unpack(tobj, cls)
pobj = pack(tinst)
urec = unpack(pobj, cls)
prec = pack(uinst)
assert tinst == uinst, (
(
"Unpacked object doesn't match eval'd version:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(str(tinst), str(uinst), "\n ".join(diff(tinst, uinst)))
)
assert pobj == tobj, (
(
"Packed object doesn't match given:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(
str(tobj),
str(pobj),
"\n ".join(diff(tobj, pobj))
)
)
assert tinst == urec, (
(
"Pack/unpacked object doesn't match:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(
str(tinst),
str(urec),
"\n ".join(diff(tinst, urec))
)
)
assert tobj == prec, (
(
"Unpack/packed object doesn't match:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(
str(tobj),
str(prec),
"\n ".join(diff(tobj, prec))
)
)
return True
def authenticate(client_id=None, client_secret=None, tokens=[], token=None):
if not client_id:
client_id = os.environ.get('FACEBOOK_INSIGHTS_CLIENT_ID')
if not client_secret:
client_secret = os.environ.get('FACEBOOK_INSIGHTS_CLIENT_SECRET')
secrets = client_id and client_secret
credentials = token or tokens
if secrets:
tokens = oauth.authorize(client_id, client_secret)
elif credentials:
pass
else:
raise KeyError(
utils.dedent("""
Authentication requires either one or more tokens,
or a client_id and client_secret passed to this
function or available in the environment as
FACEBOOK_INSIGHTS_CLIENT_ID and
FACEBOOK_INSIGHTS_CLIENT_SECRET.
"""))
if token:
return graph.Page(token)
else:
return [graph.Page(token) for token in tokens]
def test_parse_story():
test_stuff = parse_story.__doc__.split("```")
tinst = eval(utils.dedent(test_stuff[1]))
tstr = utils.dedent(test_stuff[2])
uinst = parse_story(tstr)
rstr = render_story(tinst)
urstr = render_story(uinst)
ruinst = parse_story(rstr)
assert tinst == uinst, (
(
"Parsed Story doesn't match eval'd version:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(str(tinst), str(uinst), "\n ".join(diff(tinst, uinst)))
)
assert rstr == urstr, (
(
"Rendered Story doesn't match re-rendered version:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(
str(rstr),
str(urstr),
"\n ".join(diff(rstr, urstr))
)
)
assert tinst == ruinst, (
(
"Re-parsed Story doesn't match original:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(
str(tinst),
str(ruinst),
"\n ".join(diff(tinst, ruinst))
)
)
return True
def _format_lines(self):
"""Splits the test string and adds _Answer objects to denote
prompts.
"""
self._lines = []
for line in utils.dedent(self['test']).splitlines():
if not line:
continue
elif line.startswith(self.PS1) or line.startswith(self.PS2):
self._lines.append(line)
elif line.startswith('#'):
# Assume the last object in lines is an _Answer.
self._lines[-1].update(line)
else:
# Wrap the doctest answer in an object.
self._lines.append(_Answer(line))
def __init__(self, **fields):
super().__init__(**fields)
self["question"] = utils.dedent(self["question"])
self["answer"] = utils.dedent(self["answer"])
def assertFormat(self, expect, json):
self.assertEqual(utils.dedent(expect), utils.prettyformat(json))
def __init__(self, **fields):
super().__init__(**fields)
self['setup'] = utils.dedent(self['setup'])
self['teardown'] = utils.dedent(self['teardown'])
self['cache'] = utils.dedent(self['cache'])
def __init__(self, **fields):
super().__init__(**fields)
self['question'] = utils.dedent(self['question'])
self['answer'] = utils.dedent(self['answer'])
def the_test():
nonlocal fcn
test_stuff = fcn.__doc__.split("```")
native_module = sys.modules[fcn.__module__]
native_context = native_module.__dict__
test_eval_true = []
test_cmp_equal = []
test_raises = []
for raw in test_stuff:
test = raw.strip()
if not test or test[0] not in ">?=x!":
continue
ttype = test[0]
test = utils.dedent(test[1:]).strip()
if ttype == '>':
test_eval_true.append(test)
elif ttype == '?':
test_cmp_equal.append((test, []))
elif ttype == '=':
if test_cmp_equal:
test_cmp_equal[-1][1].append(test)
else:
test_cmp_equal.append((test, []))
elif ttype == 'x':
test_raises.append((test, []))
elif ttype == '!':
if test_raises:
test_raises[-1][1].append(test)
else:
test_raises.append((test, []))
for test in test_eval_true:
assert eval(test, native_context), "Eval test failed:\n" + test
for test, against in test_cmp_equal:
base = eval(test, native_context)
for ag in against:
agval = eval(ag, native_context)
assert base == agval, (
(
"Test items not equal:\n```\n{}\n```\n{}\n```"
"\nDifferences:\n {}"
).format(
base,
agval,
"\n ".join(diff(base, agval))
)
)
for test, accept in test_raises:
accept = tuple(eval(a, native_context) for a in accept)
try:
eval(test, native_context)
assert False, "Test failed to raise an error. Expected:\n {}".format(
utils.or_strlist(a.__name__ for a in alternatives)
)
except accept:
pass
except Exception as e:
assert False, "Test raised unexpected {} error.".format(
e.__class__.__name__
)
return True
