github
/
gixy
mirror of https://github.com/yandex/gixy
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add Python 3.9 to 3.13 support, Drop all other version 

* Remove __future__ imports
* Use relative imports
* Remove six
* Remove argparse
* Replace nose with pynose
* Replace deprecated testing functions
* Fix flake8 warnings
* Update dependency info in requirements, setup.py and rpmspec
pull/148/head
Shen-Ta Hsieh 2025-03-19 03:27:48 +08:00
parent 6f68624a75
commit 2c789d9684
24 changed files with 217 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gixy/cli/argparser.py
View File

@ -1,7 +1,7 @@
# flake8: noqa # flake8: noqa
from configargparse import * from configargparse import *
from six.moves import StringIO from io import StringIO
from gixy.core.plugins_manager import PluginsManager from gixy.core.plugins_manager import PluginsManager
@ -119,7 +119,8 @@ class ArgsParser(ArgumentParser):
config_file_keys = self.get_possible_config_keys(action) config_file_keys = self.get_possible_config_keys(action)
if config_file_keys and not action.is_positional_arg and \ if config_file_keys and not action.is_positional_arg and \
already_on_command_line(existing_command_line_args, already_on_command_line(existing_command_line_args,
action.option_strings): action.option_strings,
self.prefix_chars):
value = getattr(parsed_namespace, action.dest, None) value = getattr(parsed_namespace, action.dest, None)
if value is not None: if value is not None:
if type(value) is bool: if type(value) is bool:

21
gixy/core/regexp.py
View File

@ -1,4 +1,3 @@
import six
import logging import logging
import re import re
import random import random
@ -13,7 +12,7 @@ LOG = logging.getLogger(__name__)
def _build_reverse_list(original): def _build_reverse_list(original):
result = [] result = []
for c in range(1, 126): for c in range(1, 126):
c = six.unichr(c) c = chr(c)
if c not in original: if c not in original:
result.append(c) result.append(c)
return frozenset(result) return frozenset(result)
@ -35,7 +34,7 @@ CATEGORIES = {
'0123456789_')), '0123456789_')),
sre_parse.CATEGORY_LINEBREAK: frozenset('\n'), sre_parse.CATEGORY_LINEBREAK: frozenset('\n'),
sre_parse.CATEGORY_NOT_LINEBREAK: _build_reverse_list(frozenset('\n')), sre_parse.CATEGORY_NOT_LINEBREAK: _build_reverse_list(frozenset('\n')),
'ANY': [six.unichr(x) for x in range(1, 127) if x != 10] 'ANY': [chr(x) for x in range(1, 127) if x != 10]
} }
CATEGORIES_NAMES = { CATEGORIES_NAMES = {
@ -94,10 +93,10 @@ def _gen_combinator(variants, _merge=True):
producted = itertools.product(*res) producted = itertools.product(*res)
if _merge: if _merge:
# TODO(buglloc): ??! # TODO(buglloc): ??!
return list(six.moves.map(_merge_variants, producted)) return list(map(_merge_variants, producted))
return producted return producted
elif _merge: elif _merge:
return list(six.moves.map(_merge_variants, [res])) return list(map(_merge_variants, [res]))
return res return res
@ -178,7 +177,7 @@ class LiteralToken(Token):
type = sre_parse.LITERAL type = sre_parse.LITERAL
def _parse(self): def _parse(self):
self.char = six.unichr(self.token[1]) self.char = chr(self.token[1])
def can_contain(self, char, skip_literal=True): def can_contain(self, char, skip_literal=True):
if skip_literal: if skip_literal:
@ -199,7 +198,7 @@ class NotLiteralToken(Token):
type = sre_parse.NOT_LITERAL type = sre_parse.NOT_LITERAL
def _parse(self): def _parse(self):
self.char = six.unichr(self.token[1]) self.char = chr(self.token[1])
self.gen_char_list = list(_build_reverse_list(frozenset(self.char))) self.gen_char_list = list(_build_reverse_list(frozenset(self.char)))
def can_contain(self, char, skip_literal=True): def can_contain(self, char, skip_literal=True):
@ -225,8 +224,8 @@ class RangeToken(Token):
def _parse(self): def _parse(self):
self.left_code = self.token[1][0] self.left_code = self.token[1][0]
self.right_code = self.token[1][1] self.right_code = self.token[1][1]
self.left = six.unichr(self.left_code) self.left = chr(self.left_code)
self.right = six.unichr(self.right_code) self.right = chr(self.right_code)
def can_contain(self, char, skip_literal=True): def can_contain(self, char, skip_literal=True):
return self.left <= char <= self.right return self.left <= char <= self.right
@ -238,7 +237,7 @@ class RangeToken(Token):
if self.can_contain(context.char): if self.can_contain(context.char):
return context.char return context.char
return six.unichr(random.randint(self.token[1][0], self.token[1][1])) return chr(random.randint(self.token[1][0], self.token[1][1]))
def __str__(self): def __str__(self):
return '{left}-{right}'.format(left=self.left, right=self.right) return '{left}-{right}'.format(left=self.left, right=self.right)
@ -657,7 +656,7 @@ class InToken(Token):
elif isinstance(child, LiteralToken): elif isinstance(child, LiteralToken):
blacklisted.add(child.char) blacklisted.add(child.char)
elif isinstance(child, RangeToken): elif isinstance(child, RangeToken):
blacklisted.update(six.unichr(c) for c in six.moves.range(child.left_code, child.right_code + 1)) blacklisted.update(chr(c) for c in range(child.left_code, child.right_code + 1))
elif isinstance(child, CategoryToken): elif isinstance(child, CategoryToken):
blacklisted.update(child.char_list) blacklisted.update(child.char_list)
else: else:

4
gixy/core/sre_parse/sre_parse.py
View File

@ -10,11 +10,9 @@
# See the sre.py file for information on usage and redistribution. # See the sre.py file for information on usage and redistribution.
# #
from __future__ import print_function
"""Internal support module for sre""" """Internal support module for sre"""
from sre_constants import * from .sre_constants import *
SPECIAL_CHARS = ".\\[{()*+?^$|" SPECIAL_CHARS = ".\\[{()*+?^$|"
REPEAT_CHARS = "*+?{" REPEAT_CHARS = "*+?{"

1
gixy/formatters/_jinja.py
View File

@ -1,4 +1,3 @@
from __future__ import absolute_import
from jinja2 import Environment, PackageLoader from jinja2 import Environment, PackageLoader
from gixy.utils.text import to_text from gixy.utils.text import to_text

6
gixy/formatters/base.py
View File

@ -1,5 +1,3 @@
from __future__ import absolute_import
import gixy import gixy
from gixy.directives import block from gixy.directives import block
@ -74,10 +72,10 @@ class BaseFormatter(object):
for leap in tree.children: for leap in tree.children:
if leap not in points: if leap not in points:
continue continue
printable = type(leap) not in self.skip_parents printable = all(not isinstance(leap, p) for p in self.skip_parents)
# Special hack for includes # Special hack for includes
# TODO(buglloc): fix me # TODO(buglloc): fix me
have_parentheses = type(leap) != block.IncludeBlock have_parentheses = not isinstance(leap, block.IncludeBlock)
if printable: if printable:
if leap.is_block: if leap.is_block:

2
gixy/formatters/console.py
View File

@ -1,5 +1,3 @@
from __future__ import absolute_import
from gixy.formatters.base import BaseFormatter from gixy.formatters.base import BaseFormatter
from gixy.formatters._jinja import load_template from gixy.formatters._jinja import load_template

2
gixy/formatters/json.py
View File

@ -1,5 +1,3 @@
from __future__ import absolute_import
import json import json
from gixy.formatters.base import BaseFormatter from gixy.formatters.base import BaseFormatter

2
gixy/formatters/text.py
View File

@ -1,5 +1,3 @@
from __future__ import absolute_import
from gixy.formatters.base import BaseFormatter from gixy.formatters.base import BaseFormatter
from gixy.formatters._jinja import load_template from gixy.formatters._jinja import load_template

29
gixy/parser/raw_parser.py
View File

@ -1,10 +1,10 @@
import logging import logging
import codecs import codecs
import six import re
from cached_property import cached_property from cached_property import cached_property
from pyparsing import ( from pyparsing import (
Literal, Suppress, White, Word, alphanums, Forward, Group, Optional, Combine, Literal, Suppress, Word, alphanums, Forward, Group, Optional, Combine,
Keyword, OneOrMore, ZeroOrMore, Regex, QuotedString, nestedExpr, ParseResults) Keyword, OneOrMore, ZeroOrMore, Regex, QuotedString, nestedExpr, ParseResults)
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -17,7 +17,7 @@ class NginxQuotedString(QuotedString):
# '^https?:\/\/yandex\.ru\/\00\'\"' -> ^https?:\/\/yandex\.ru\/\00'" # '^https?:\/\/yandex\.ru\/\00\'\"' -> ^https?:\/\/yandex\.ru\/\00'"
# TODO(buglloc): research and find another special characters! # TODO(buglloc): research and find another special characters!
self.escCharReplacePattern = '\\\\(\'|")' self.unquote_scan_re = re.compile("(\\\\t|\\\\r|\\\\n)|(\\\\\"|\\\\')|(\\n|.)")
class RawParser(object): class RawParser(object):
@ -29,7 +29,7 @@ class RawParser(object):
""" """
Returns the parsed tree. Returns the parsed tree.
""" """
if isinstance(data, six.binary_type): if isinstance(data, bytes):
if data[:3] == codecs.BOM_UTF8: if data[:3] == codecs.BOM_UTF8:
encoding = 'utf-8-sig' encoding = 'utf-8-sig'
else: else:
@ -49,7 +49,6 @@ class RawParser(object):
left_bracket = Suppress("{") left_bracket = Suppress("{")
right_bracket = Suppress("}") right_bracket = Suppress("}")
semicolon = Suppress(";") semicolon = Suppress(";")
space = White().suppress()
keyword = Word(alphanums + ".+-_/") keyword = Word(alphanums + ".+-_/")
path = Word(alphanums + ".-_/") path = Word(alphanums + ".-_/")
variable = Word("$_-" + alphanums) variable = Word("$_-" + alphanums)
@ -71,23 +70,22 @@ class RawParser(object):
# so we capture all content between parentheses and then parse it :( # so we capture all content between parentheses and then parse it :(
# TODO(buglloc): may be use something better? # TODO(buglloc): may be use something better?
condition_body = ( condition_body = (
(if_modifier + Optional(space) + value) | (if_modifier + value) |
(variable + Optional(space + if_modifier + Optional(space) + value)) (variable + Optional(if_modifier + value))
) )
condition = Regex(r'\((?:[^()\n\r\\]|(?:\(.*\))|(?:\\.))+?\)')\ condition = Regex(r'\((?:[^()\n\r\\]|(?:\(.*\))|(?:\\.))+?\)')\
.setParseAction(lambda s, l, t: condition_body.parseString(t[0][1:-1])) .setParseAction(lambda s, loc, toks: condition_body.parseString(toks[0][1:-1]))
# rules # rules
include = ( include = (
Keyword("include") + Keyword("include") +
space +
value + value +
semicolon semicolon
)("include") )("include")
directive = ( directive = (
keyword + keyword +
ZeroOrMore(space + value) + ZeroOrMore(value) +
semicolon semicolon
)("directive") )("directive")
@ -103,7 +101,7 @@ class RawParser(object):
hash_value = Group( hash_value = Group(
value + value +
ZeroOrMore(space + value) + ZeroOrMore(value) +
semicolon semicolon
)("hash_value") )("hash_value")
@ -136,8 +134,7 @@ class RawParser(object):
location_block << ( location_block << (
Keyword("location") + Keyword("location") +
Group( Group(
Optional(space + location_modifier) + Optional(location_modifier) + value) +
Optional(space) + value) +
Suppress(Optional(comment)) + Suppress(Optional(comment)) +
Group( Group(
left_bracket + left_bracket +
@ -147,7 +144,7 @@ class RawParser(object):
hash_block << ( hash_block << (
keyword + keyword +
Group(OneOrMore(space + value)) + Group(OneOrMore(value)) +
Group( Group(
left_bracket + left_bracket +
Optional(OneOrMore(hash_value)) + Optional(OneOrMore(hash_value)) +
@ -156,7 +153,7 @@ class RawParser(object):
generic_block << ( generic_block << (
keyword + keyword +
Group(ZeroOrMore(space + value)) + Group(ZeroOrMore(value)) +
Suppress(Optional(comment)) + Suppress(Optional(comment)) +
Group( Group(
left_bracket + left_bracket +
@ -166,7 +163,7 @@ class RawParser(object):
unparsed_block << ( unparsed_block << (
keyword + keyword +
Group(ZeroOrMore(space + value)) + Group(ZeroOrMore(value)) +
nestedExpr(opener="{", closer="}") nestedExpr(opener="{", closer="}")
)("unparsed_block") )("unparsed_block")

17
gixy/utils/text.py
View File

@ -1,12 +1,8 @@
from __future__ import absolute_import
from six import PY3, text_type, binary_type
def to_bytes(obj, encoding='latin1', errors='strict', nonstring='replace'): def to_bytes(obj, encoding='latin1', errors='strict', nonstring='replace'):
if isinstance(obj, binary_type): if isinstance(obj, bytes):
return obj return obj
if isinstance(obj, text_type): if isinstance(obj, str):
try: try:
# Try this first as it's the fastest # Try this first as it's the fastest
return obj.encode(encoding, errors) return obj.encode(encoding, errors)
@ -36,10 +32,10 @@ def to_bytes(obj, encoding='latin1', errors='strict', nonstring='replace'):
def to_text(obj, encoding='latin1', errors='strict', nonstring='replace'): def to_text(obj, encoding='latin1', errors='strict', nonstring='replace'):
if isinstance(obj, text_type): if isinstance(obj, str):
return obj return obj
if isinstance(obj, binary_type): if isinstance(obj, bytes):
try: try:
return obj.decode(encoding, errors) return obj.decode(encoding, errors)
except UnicodeEncodeError: except UnicodeEncodeError:
@ -66,7 +62,4 @@ def to_text(obj, encoding='latin1', errors='strict', nonstring='replace'):
return to_text(value, encoding, errors) return to_text(value, encoding, errors)
if PY3: to_native = to_text
to_native = to_text
else:
to_native = to_bytes

10
requirements.dev.txt
View File

@ -1,5 +1,5 @@
nose>=1.3.7 pynose>=1.5.4
mock>=2.0.0 mock>=5.2.0
coverage>=4.3 coverage>=7.7.0
flake8>=3.2 flake8>=7.1.2
tox>=2.7.0 tox>=4.24.2

10
requirements.txt
View File

@ -1,6 +1,4 @@
pyparsing>=1.5.5,<3 pyparsing>=3.2.1
cached-property>=1.2.0 cached-property>=2.0.1
argparse>=1.4.0 Jinja2>=3.1.5
six>=1.1.0 ConfigArgParse>=1.7
Jinja2>=2.8
ConfigArgParse>=0.11.0

11
rpm/gixy.spec
View File

@ -14,11 +14,14 @@ BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
BuildArch: noarch BuildArch: noarch
BuildRequires: python-devel python-setuptools BuildRequires: python-devel
BuildRequires: python-setuptools
Requires: python-setuptools python-six >= 1.1.0 python-jinja >= 2.8 Requires: python-setuptools
Requires: python2-cached_property >= 1.2.0 python2-configargparse >= 0.11.0 Requires: python-jinja >= 3.1.5
Requires: python-argparse >= 1.4.0 pyparsing >= 1.5.5 python-markupsafe Requires: python-cached_property >= 2.0.1
Requires: python2-configargparse >= 1.7
Requires: pyparsing >= 3.2.1
Provides: %{name} = %{verion}-%{release} Provides: %{name} = %{verion}-%{release}

19
setup.py
View File

@ -16,13 +16,12 @@ setup(
author='Yandex IS Team', author='Yandex IS Team',
author_email='buglloc@yandex.ru', author_email='buglloc@yandex.ru',
url='https://github.com/yandex/gixy', url='https://github.com/yandex/gixy',
python_requires='>=3.9',
install_requires=[ install_requires=[
'pyparsing>=1.5.5,<3', 'pyparsing>=3.2.1',
'cached-property>=1.2.0', 'cached-property>=2.0.1',
'argparse>=1.4.0;python_version<"3.2"', 'Jinja2>=3.1.5',
'six>=1.1.0', 'ConfigArgParse>=1.7'
'Jinja2>=2.8',
'ConfigArgParse>=0.11.0'
], ],
entry_points={ entry_points={
'console_scripts': ['gixy=gixy.cli.main:main'], 'console_scripts': ['gixy=gixy.cli.main:main'],
@ -36,7 +35,13 @@ setup(
'Intended Audience :: Developers', 'Intended Audience :: Developers',
'Topic :: Security', 'Topic :: Security',
'Topic :: Software Development :: Quality Assurance', 'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing' 'Topic :: Software Development :: Testing',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3 :: 3.9',
'Programming Language :: Python :: 3 :: 3.10',
'Programming Language :: Python :: 3 :: 3.11',
'Programming Language :: Python :: 3 :: 3.12',
'Programming Language :: Python :: 3 :: 3.13',
], ],
include_package_data=True include_package_data=True
) )

90
tests/core/test_context.py
View File

@ -1,12 +1,12 @@
from nose.tools import with_setup, assert_equals, assert_not_equals, assert_true from nose.tools import with_setup, assert_equal, assert_not_equal, assert_true
from gixy.core.context import get_context, pop_context, push_context, purge_context, CONTEXTS, Context from gixy.core.context import get_context, pop_context, push_context, purge_context, CONTEXTS
from gixy.directives.block import Root from gixy.directives.block import Root
from gixy.core.variable import Variable from gixy.core.variable import Variable
from gixy.core.regexp import Regexp from gixy.core.regexp import Regexp
def setup(): def setup():
assert_equals(len(CONTEXTS), 0) assert_equal(len(CONTEXTS), 0)
def tear_down(): def tear_down():
@ -17,39 +17,39 @@ def tear_down():
def test_push_pop_context(): def test_push_pop_context():
root_a = Root() root_a = Root()
push_context(root_a) push_context(root_a)
assert_equals(len(CONTEXTS), 1) assert_equal(len(CONTEXTS), 1)
root_b = Root() root_b = Root()
push_context(root_b) push_context(root_b)
assert_equals(len(CONTEXTS), 2) assert_equal(len(CONTEXTS), 2)
poped = pop_context() poped = pop_context()
assert_equals(len(CONTEXTS), 1) assert_equal(len(CONTEXTS), 1)
assert_equals(poped.block, root_b) assert_equal(poped.block, root_b)
poped = pop_context() poped = pop_context()
assert_equals(len(CONTEXTS), 0) assert_equal(len(CONTEXTS), 0)
assert_equals(poped.block, root_a) assert_equal(poped.block, root_a)
@with_setup(setup, tear_down) @with_setup(setup, tear_down)
def test_push_get_purge_context(): def test_push_get_purge_context():
root = Root() root = Root()
push_context(root) push_context(root)
assert_equals(len(CONTEXTS), 1) assert_equal(len(CONTEXTS), 1)
assert_equals(get_context().block, root) assert_equal(get_context().block, root)
root = Root() root = Root()
push_context(root) push_context(root)
assert_equals(len(CONTEXTS), 2) assert_equal(len(CONTEXTS), 2)
assert_equals(get_context().block, root) assert_equal(get_context().block, root)
purge_context() purge_context()
assert_equals(len(CONTEXTS), 0) assert_equal(len(CONTEXTS), 0)
@with_setup(setup, tear_down) @with_setup(setup, tear_down)
def test_add_variables(): def test_add_variables():
context = push_context(Root()) context = push_context(Root())
assert_equals(len(context.variables['index']), 0) assert_equal(len(context.variables['index']), 0)
assert_equals(len(context.variables['name']), 0) assert_equal(len(context.variables['name']), 0)
one_str_var = Variable('1') one_str_var = Variable('1')
context.add_var('1', one_str_var) context.add_var('1', one_str_var)
@ -58,32 +58,32 @@ def test_add_variables():
some_var = Variable('some') some_var = Variable('some')
context.add_var('some', some_var) context.add_var('some', some_var)
assert_equals(len(context.variables['index']), 1) assert_equal(len(context.variables['index']), 1)
assert_equals(context.variables['index'][1], one_int_var) assert_equal(context.variables['index'][1], one_int_var)
assert_equals(len(context.variables['name']), 1) assert_equal(len(context.variables['name']), 1)
assert_equals(context.variables['name']['some'], some_var) assert_equal(context.variables['name']['some'], some_var)
context.clear_index_vars() context.clear_index_vars()
assert_equals(len(context.variables['index']), 0) assert_equal(len(context.variables['index']), 0)
assert_equals(len(context.variables['name']), 1) assert_equal(len(context.variables['name']), 1)
assert_equals(context.variables['name']['some'], some_var) assert_equal(context.variables['name']['some'], some_var)
@with_setup(setup, tear_down) @with_setup(setup, tear_down)
def test_get_variables(): def test_get_variables():
context = push_context(Root()) context = push_context(Root())
assert_equals(len(context.variables['index']), 0) assert_equal(len(context.variables['index']), 0)
assert_equals(len(context.variables['name']), 0) assert_equal(len(context.variables['name']), 0)
one_var = Variable(1) one_var = Variable(1)
context.add_var(1, one_var) context.add_var(1, one_var)
some_var = Variable('some') some_var = Variable('some')
context.add_var('some', some_var) context.add_var('some', some_var)
assert_equals(context.get_var(1), one_var) assert_equal(context.get_var(1), one_var)
assert_equals(context.get_var('some'), some_var) assert_equal(context.get_var('some'), some_var)
# Checks not existed variables, for now context may return None # Checks not existed variables, for now context may return None
assert_equals(context.get_var(0), None) assert_equal(context.get_var(0), None)
assert_equals(context.get_var('not_existed'), None) assert_equal(context.get_var('not_existed'), None)
# Checks builtins variables # Checks builtins variables
assert_true(context.get_var('uri')) assert_true(context.get_var('uri'))
assert_true(context.get_var('document_uri')) assert_true(context.get_var('document_uri'))
@ -94,41 +94,41 @@ def test_get_variables():
@with_setup(setup, tear_down) @with_setup(setup, tear_down)
def test_context_depend_variables(): def test_context_depend_variables():
push_context(Root()) push_context(Root())
assert_equals(len(get_context().variables['index']), 0) assert_equal(len(get_context().variables['index']), 0)
assert_equals(len(get_context().variables['name']), 0) assert_equal(len(get_context().variables['name']), 0)
get_context().add_var(1, Variable(1, value='one')) get_context().add_var(1, Variable(1, value='one'))
get_context().add_var('some', Variable('some', value='some')) get_context().add_var('some', Variable('some', value='some'))
assert_equals(get_context().get_var(1).value, 'one') assert_equal(get_context().get_var(1).value, 'one')
assert_equals(get_context().get_var('some').value, 'some') assert_equal(get_context().get_var('some').value, 'some')
# Checks top context variables are still exists # Checks top context variables are still exists
push_context(Root()) push_context(Root())
assert_equals(get_context().get_var(1).value, 'one') assert_equal(get_context().get_var(1).value, 'one')
assert_equals(get_context().get_var('some').value, 'some') assert_equal(get_context().get_var('some').value, 'some')
# Checks variable overriding # Checks variable overriding
get_context().add_var('some', Variable('some', value='some_new')) get_context().add_var('some', Variable('some', value='some_new'))
get_context().add_var('foo', Variable('foo', value='foo')) get_context().add_var('foo', Variable('foo', value='foo'))
assert_not_equals(get_context().get_var('some').value, 'some') assert_not_equal(get_context().get_var('some').value, 'some')
assert_equals(get_context().get_var('some').value, 'some_new') assert_equal(get_context().get_var('some').value, 'some_new')
assert_equals(get_context().get_var('foo').value, 'foo') assert_equal(get_context().get_var('foo').value, 'foo')
assert_equals(get_context().get_var(1).value, 'one') assert_equal(get_context().get_var(1).value, 'one')
# Checks variables after restore previous context # Checks variables after restore previous context
pop_context() pop_context()
assert_not_equals(get_context().get_var('some').value, 'some_new') assert_not_equal(get_context().get_var('some').value, 'some_new')
assert_equals(get_context().get_var('some').value, 'some') assert_equal(get_context().get_var('some').value, 'some')
assert_equals(get_context().get_var('foo'), None) assert_equal(get_context().get_var('foo'), None)
assert_equals(get_context().get_var(1).value, 'one') assert_equal(get_context().get_var(1).value, 'one')
@with_setup(setup, tear_down) @with_setup(setup, tear_down)
def test_push_failed_with_regexp_py35_gixy_10(): def test_push_failed_with_regexp_py35_gixy_10():
push_context(Root()) push_context(Root())
assert_equals(len(get_context().variables['index']), 0) assert_equal(len(get_context().variables['index']), 0)
assert_equals(len(get_context().variables['name']), 0) assert_equal(len(get_context().variables['name']), 0)
regexp = Regexp('^/some/(.*?)') regexp = Regexp('^/some/(.*?)')
for name, group in regexp.groups.items(): for name, group in regexp.groups.items():

20
tests/core/test_regexp.py
View File

@ -1,4 +1,4 @@
from nose.tools import assert_true, assert_false, assert_equals from nose.tools import assert_true, assert_false, assert_equal
from gixy.core.regexp import Regexp from gixy.core.regexp import Regexp
''' '''
@ -88,7 +88,7 @@ def test_to_string():
(r'foo', 'foo'), (r'foo', 'foo'),
(r'(1)(2)(?:3)', '(1)(2)(?:3)'), (r'(1)(2)(?:3)', '(1)(2)(?:3)'),
(r'(1)((2)|(?:3))', '(1)((?:(2)|(?:3)))'), (r'(1)((2)|(?:3))', '(1)((?:(2)|(?:3)))'),
(r'\w|1|3-5|[a-z]', '(?:[\w]|1|3\\-5|[a-z])'), (r'\w|1|3-5|[a-z]', '(?:[\\w]|1|3\\-5|[a-z])'),
(r'(1|(?:3)|([4-6]))', '((?:1|(?:3)|([4-6])))'), (r'(1|(?:3)|([4-6]))', '((?:1|(?:3)|([4-6])))'),
(r'(1|(?:3)|(?P<aaa>[4-6]))', '((?:1|(?:3)|([4-6])))'), (r'(1|(?:3)|(?P<aaa>[4-6]))', '((?:1|(?:3)|([4-6])))'),
(r'^sss', '^sss'), (r'^sss', '^sss'),
@ -258,26 +258,26 @@ def test_generate():
def test_strict_generate(): def test_strict_generate():
reg = Regexp('^foo|bar', strict=True) reg = Regexp('^foo|bar', strict=True)
assert_equals(sorted(reg.generate('|', anchored=True)), sorted(['^foo', '^bar'])) assert_equal(sorted(reg.generate('|', anchored=True)), sorted(['^foo', '^bar']))
def test_gen_anchor(): def test_gen_anchor():
reg = Regexp('^some$') reg = Regexp('^some$')
val = next(reg.generate('', anchored=False)) val = next(reg.generate('', anchored=False))
assert_equals(val, 'some') assert_equal(val, 'some')
reg = Regexp('^some$') reg = Regexp('^some$')
val = next(reg.generate('', anchored=True)) val = next(reg.generate('', anchored=True))
assert_equals(val, '^some$') assert_equal(val, '^some$')
reg = Regexp('^some$', strict=True) reg = Regexp('^some$', strict=True)
val = next(reg.generate('', anchored=False)) val = next(reg.generate('', anchored=False))
assert_equals(val, 'some') assert_equal(val, 'some')
reg = Regexp('^some$', strict=True) reg = Regexp('^some$', strict=True)
val = next(reg.generate('', anchored=True)) val = next(reg.generate('', anchored=True))
assert_equals(val, '^some$') assert_equal(val, '^some$')
def test_group_can_contains(): def test_group_can_contains():
@ -345,12 +345,12 @@ def check_negative_startswith(regexp, char, strict):
def check_groups_names(regexp, groups): def check_groups_names(regexp, groups):
reg = Regexp(regexp) reg = Regexp(regexp)
assert_equals(set(reg.groups.keys()), set(groups)) assert_equal(set(reg.groups.keys()), set(groups))
def check_to_string(regexp, string): def check_to_string(regexp, string):
reg = Regexp(regexp) reg = Regexp(regexp)
assert_equals(str(reg), string) assert_equal(str(reg), string)
def check_positive_must_contain(regexp, char): def check_positive_must_contain(regexp, char):
@ -399,4 +399,4 @@ def check_negative_must_startswith(regexp, char, strict):
def check_generate(regexp, values): def check_generate(regexp, values):
reg = Regexp(regexp) reg = Regexp(regexp)
assert_equals(sorted(reg.generate('|', anchored=True)), sorted(values)) assert_equal(sorted(reg.generate('|', anchored=True)), sorted(values))

5
tests/core/test_variable.py
View File

@ -1,9 +1,10 @@
from nose.tools import assert_true, assert_false, assert_equals, with_setup from nose.tools import assert_true, assert_false, assert_equal, with_setup
from gixy.core.context import get_context, push_context, purge_context from gixy.core.context import get_context, push_context, purge_context
from gixy.directives.block import Root from gixy.directives.block import Root
from gixy.core.regexp import Regexp from gixy.core.regexp import Regexp
from gixy.core.variable import Variable from gixy.core.variable import Variable
def setup(): def setup():
push_context(Root()) push_context(Root())
@ -17,7 +18,7 @@ def test_literal():
var = Variable(name='simple', value='$uri', have_script=False) var = Variable(name='simple', value='$uri', have_script=False)
assert_false(var.depends) assert_false(var.depends)
assert_false(var.regexp) assert_false(var.regexp)
assert_equals(var.value, '$uri') assert_equal(var.value, '$uri')
assert_false(var.can_startswith('$')) assert_false(var.can_startswith('$'))
assert_false(var.can_contain('i')) assert_false(var.can_contain('i'))

45
tests/directives/test_block.py
View File

@ -1,7 +1,8 @@
from nose.tools import assert_equals, assert_true, assert_false from nose.tools import assert_equal, assert_true, assert_false
from tests.asserts import assert_is_instance, assert_is_none, assert_is_not_none from tests.asserts import assert_is_instance, assert_is_none, assert_is_not_none
from gixy.parser.nginx_parser import NginxParser from gixy.parser.nginx_parser import NginxParser
from gixy.directives.block import * from gixy.directives.block import Block, HttpBlock, ServerBlock, LocationBlock, IfBlock, MapBlock, GeoBlock
# TODO(buglloc): what about include block? # TODO(buglloc): what about include block?
@ -51,7 +52,7 @@ server {
assert_is_instance(directive, ServerBlock) assert_is_instance(directive, ServerBlock)
assert_true(directive.is_block) assert_true(directive.is_block)
assert_true(directive.self_context) assert_true(directive.self_context)
assert_equals([d.args[0] for d in directive.get_names()], ['_', 'cool.io']) assert_equal([d.args[0] for d in directive.get_names()], ['_', 'cool.io'])
assert_false(directive.provide_variables) assert_false(directive.provide_variables)
@ -67,7 +68,7 @@ location / {
assert_true(directive.self_context) assert_true(directive.self_context)
assert_true(directive.provide_variables) assert_true(directive.provide_variables)
assert_is_none(directive.modifier) assert_is_none(directive.modifier)
assert_equals(directive.path, '/') assert_equal(directive.path, '/')
assert_false(directive.is_internal) assert_false(directive.is_internal)
@ -91,8 +92,8 @@ location = / {
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, LocationBlock) assert_is_instance(directive, LocationBlock)
assert_equals(directive.modifier, '=') assert_equal(directive.modifier, '=')
assert_equals(directive.path, '/') assert_equal(directive.path, '/')
def test_if(): def test_if():
@ -106,7 +107,7 @@ if ($some) {
assert_true(directive.is_block) assert_true(directive.is_block)
assert_false(directive.self_context) assert_false(directive.self_context)
assert_false(directive.provide_variables) assert_false(directive.provide_variables)
assert_equals(directive.variable, '$some') assert_equal(directive.variable, '$some')
assert_is_none(directive.operand) assert_is_none(directive.operand)
assert_is_none(directive.value) assert_is_none(directive.value)
@ -119,8 +120,8 @@ if (-f /some) {
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, IfBlock) assert_is_instance(directive, IfBlock)
assert_equals(directive.operand, '-f') assert_equal(directive.operand, '-f')
assert_equals(directive.value, '/some') assert_equal(directive.value, '/some')
assert_is_none(directive.variable) assert_is_none(directive.variable)
@ -132,9 +133,9 @@ if ($http_some = '/some') {
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, IfBlock) assert_is_instance(directive, IfBlock)
assert_equals(directive.variable, '$http_some') assert_equal(directive.variable, '$http_some')
assert_equals(directive.operand, '=') assert_equal(directive.operand, '=')
assert_equals(directive.value, '/some') assert_equal(directive.value, '/some')
def test_block_some_flat(): def test_block_some_flat():
@ -152,7 +153,7 @@ def test_block_some_flat():
for d in ['default_type', 'sendfile', 'keepalive_timeout']: for d in ['default_type', 'sendfile', 'keepalive_timeout']:
c = directive.some(d, flat=True) c = directive.some(d, flat=True)
assert_is_not_none(c) assert_is_not_none(c)
assert_equals(c.name, d) assert_equal(c.name, d)
def test_block_some_not_flat(): def test_block_some_not_flat():
@ -183,9 +184,9 @@ def test_block_find_flat():
directive = _get_parsed(config) directive = _get_parsed(config)
finds = directive.find('directive', flat=True) finds = directive.find('directive', flat=True)
assert_equals(len(finds), 2) assert_equal(len(finds), 2)
assert_equals([x.name for x in finds], ['directive', 'directive']) assert_equal([x.name for x in finds], ['directive', 'directive'])
assert_equals([x.args[0] for x in finds], ['1', '2']) assert_equal([x.args[0] for x in finds], ['1', '2'])
def test_block_find_not_flat(): def test_block_find_not_flat():
@ -200,9 +201,9 @@ def test_block_find_not_flat():
directive = _get_parsed(config) directive = _get_parsed(config)
finds = directive.find('directive', flat=False) finds = directive.find('directive', flat=False)
assert_equals(len(finds), 1) assert_equal(len(finds), 1)
assert_equals([x.name for x in finds], ['directive']) assert_equal([x.name for x in finds], ['directive'])
assert_equals([x.args[0] for x in finds], ['1']) assert_equal([x.args[0] for x in finds], ['1'])
def test_block_map(): def test_block_map():
@ -218,7 +219,7 @@ map $some_var $some_other_var {
assert_true(directive.is_block) assert_true(directive.is_block)
assert_false(directive.self_context) assert_false(directive.self_context)
assert_true(directive.provide_variables) assert_true(directive.provide_variables)
assert_equals(directive.variable, 'some_other_var') assert_equal(directive.variable, 'some_other_var')
def test_block_geo_two_vars(): def test_block_geo_two_vars():
@ -234,7 +235,7 @@ geo $some_var $some_other_var {
assert_true(directive.is_block) assert_true(directive.is_block)
assert_false(directive.self_context) assert_false(directive.self_context)
assert_true(directive.provide_variables) assert_true(directive.provide_variables)
assert_equals(directive.variable, 'some_other_var') assert_equal(directive.variable, 'some_other_var')
def test_block_geo_one_var(): def test_block_geo_one_var():
@ -250,4 +251,4 @@ geo $some_var {
assert_true(directive.is_block) assert_true(directive.is_block)
assert_false(directive.self_context) assert_false(directive.self_context)
assert_true(directive.provide_variables) assert_true(directive.provide_variables)
assert_equals(directive.variable, 'some_var') assert_equal(directive.variable, 'some_var')

72
tests/directives/test_directive.py
View File

@ -1,7 +1,7 @@
from nose.tools import assert_equals, assert_false, assert_true from nose.tools import assert_equal, assert_false, assert_true
from tests.asserts import assert_is_instance from tests.asserts import assert_is_instance
from gixy.parser.nginx_parser import NginxParser from gixy.parser.nginx_parser import NginxParser
from gixy.directives.directive import * from gixy.directives.directive import Directive, AddHeaderDirective, SetDirective, RewriteDirective, RootDirective
def _get_parsed(config): def _get_parsed(config):
@ -14,9 +14,9 @@ def test_directive():
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, Directive) assert_is_instance(directive, Directive)
assert_equals(directive.name, 'some') assert_equal(directive.name, 'some')
assert_equals(directive.args, ['foo', 'bar']) assert_equal(directive.args, ['foo', 'bar'])
assert_equals(str(directive), 'some foo bar;') assert_equal(str(directive), 'some foo bar;')
def test_add_header(): def test_add_header():
@ -24,12 +24,12 @@ def test_add_header():
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, AddHeaderDirective) assert_is_instance(directive, AddHeaderDirective)
assert_equals(directive.name, 'add_header') assert_equal(directive.name, 'add_header')
assert_equals(directive.args, ['X-Foo', 'bar']) assert_equal(directive.args, ['X-Foo', 'bar'])
assert_equals(directive.header, 'x-foo') assert_equal(directive.header, 'x-foo')
assert_equals(directive.value, 'bar') assert_equal(directive.value, 'bar')
assert_false(directive.always) assert_false(directive.always)
assert_equals(str(directive), 'add_header X-Foo bar;') assert_equal(str(directive), 'add_header X-Foo bar;')
def test_add_header_always(): def test_add_header_always():
@ -37,12 +37,12 @@ def test_add_header_always():
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, AddHeaderDirective) assert_is_instance(directive, AddHeaderDirective)
assert_equals(directive.name, 'add_header') assert_equal(directive.name, 'add_header')
assert_equals(directive.args, ['X-Foo', 'bar', 'always']) assert_equal(directive.args, ['X-Foo', 'bar', 'always'])
assert_equals(directive.header, 'x-foo') assert_equal(directive.header, 'x-foo')
assert_equals(directive.value, 'bar') assert_equal(directive.value, 'bar')
assert_true(directive.always) assert_true(directive.always)
assert_equals(str(directive), 'add_header X-Foo bar always;') assert_equal(str(directive), 'add_header X-Foo bar always;')
def test_set(): def test_set():
@ -50,11 +50,11 @@ def test_set():
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, SetDirective) assert_is_instance(directive, SetDirective)
assert_equals(directive.name, 'set') assert_equal(directive.name, 'set')
assert_equals(directive.args, ['$foo', 'bar']) assert_equal(directive.args, ['$foo', 'bar'])
assert_equals(directive.variable, 'foo') assert_equal(directive.variable, 'foo')
assert_equals(directive.value, 'bar') assert_equal(directive.value, 'bar')
assert_equals(str(directive), 'set $foo bar;') assert_equal(str(directive), 'set $foo bar;')
assert_true(directive.provide_variables) assert_true(directive.provide_variables)
@ -63,14 +63,14 @@ def test_rewrite():
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, RewriteDirective) assert_is_instance(directive, RewriteDirective)
assert_equals(directive.name, 'rewrite') assert_equal(directive.name, 'rewrite')
assert_equals(directive.args, ['^', 'http://some']) assert_equal(directive.args, ['^', 'http://some'])
assert_equals(str(directive), 'rewrite ^ http://some;') assert_equal(str(directive), 'rewrite ^ http://some;')
assert_true(directive.provide_variables) assert_true(directive.provide_variables)
assert_equals(directive.pattern, '^') assert_equal(directive.pattern, '^')
assert_equals(directive.replace, 'http://some') assert_equal(directive.replace, 'http://some')
assert_equals(directive.flag, None) assert_equal(directive.flag, None)
def test_rewrite_flags(): def test_rewrite_flags():
@ -78,14 +78,14 @@ def test_rewrite_flags():
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, RewriteDirective) assert_is_instance(directive, RewriteDirective)
assert_equals(directive.name, 'rewrite') assert_equal(directive.name, 'rewrite')
assert_equals(directive.args, ['^/(.*)$', 'http://some/$1', 'redirect']) assert_equal(directive.args, ['^/(.*)$', 'http://some/$1', 'redirect'])
assert_equals(str(directive), 'rewrite ^/(.*)$ http://some/$1 redirect;') assert_equal(str(directive), 'rewrite ^/(.*)$ http://some/$1 redirect;')
assert_true(directive.provide_variables) assert_true(directive.provide_variables)
assert_equals(directive.pattern, '^/(.*)$') assert_equal(directive.pattern, '^/(.*)$')
assert_equals(directive.replace, 'http://some/$1') assert_equal(directive.replace, 'http://some/$1')
assert_equals(directive.flag, 'redirect') assert_equal(directive.flag, 'redirect')
def test_root(): def test_root():
@ -93,9 +93,9 @@ def test_root():
directive = _get_parsed(config) directive = _get_parsed(config)
assert_is_instance(directive, RootDirective) assert_is_instance(directive, RootDirective)
assert_equals(directive.name, 'root') assert_equal(directive.name, 'root')
assert_equals(directive.args, ['/var/www/html']) assert_equal(directive.args, ['/var/www/html'])
assert_equals(str(directive), 'root /var/www/html;') assert_equal(str(directive), 'root /var/www/html;')
assert_true(directive.provide_variables) assert_true(directive.provide_variables)
assert_equals(directive.path, '/var/www/html') assert_equal(directive.path, '/var/www/html')

4
tests/parser/test_nginx_parser.py
View File

@ -1,8 +1,8 @@
from nose.tools import assert_equal from nose.tools import assert_equal
from tests.asserts import assert_is_instance from tests.asserts import assert_is_instance
from gixy.parser.nginx_parser import NginxParser from gixy.parser.nginx_parser import NginxParser
from gixy.directives.directive import * from gixy.directives.directive import Directive, SetDirective, RewriteDirective
from gixy.directives.block import * from gixy.directives.block import Block, Root, HttpBlock, ServerBlock, LocationBlock, IfBlock, IncludeBlock
def _parse(config): def _parse(config):

42
tests/parser/test_raw_parser.py
View File

@ -1,5 +1,5 @@
from nose.tools import assert_equals from nose.tools import assert_equal
from gixy.parser.raw_parser import * from gixy.parser.raw_parser import RawParser
def test_directive(): def test_directive():
@ -11,8 +11,8 @@ set $foo "bar";
set $foo 'bar'; set $foo 'bar';
proxy_pass http://unix:/run/sock.socket; proxy_pass http://unix:/run/sock.socket;
rewrite ^/([a-zA-Z0-9]+)$ /$1/${arg_v}.pb break; rewrite ^/([a-zA-Z0-9]+)$ /$1/${arg_v}.pb break;
server_name some.tld ~^(www\.)?podberi.(?:ru|com|ua)$ server_name some.tld ~^(www\\.)?podberi.(?:ru|com|ua)$
~^(www\.)?guru.yandex.ru$; ~^(www\\.)?guru.yandex.ru$;
''' '''
expected = [ expected = [
@ -23,7 +23,7 @@ rewrite ^/([a-zA-Z0-9]+)$ /$1/${arg_v}.pb break;
['set', '$foo', 'bar'], ['set', '$foo', 'bar'],
['proxy_pass', 'http://unix:/run/sock.socket'], ['proxy_pass', 'http://unix:/run/sock.socket'],
['rewrite', '^/([a-zA-Z0-9]+)$', '/$1/${arg_v}.pb', 'break'], ['rewrite', '^/([a-zA-Z0-9]+)$', '/$1/${arg_v}.pb', 'break'],
['server_name', 'some.tld', '~^(www\.)?podberi.(?:ru|com|ua)$', '~^(www\.)?guru.yandex.ru$'] ['server_name', 'some.tld', '~^(www\\.)?podberi.(?:ru|com|ua)$', '~^(www\\.)?guru.yandex.ru$']
] ]
assert_config(config, expected) assert_config(config, expected)
@ -63,7 +63,7 @@ location ~* ^/baz$ {
location ^~ ^/bazz { location ^~ ^/bazz {
} }
# Whitespace may be omitted:(( # Whitespace may be omitted:((
location ~\.(js|css)$ { location ~\\.(js|css)$ {
} }
''' '''
@ -73,7 +73,7 @@ location ~\.(js|css)$ {
['location', ['~*', '^/baz$'], []], ['location', ['~*', '^/baz$'], []],
['location', ['^~', '^/bazz'], []], ['location', ['^~', '^/bazz'], []],
['Whitespace may be omitted:(('], ['Whitespace may be omitted:(('],
['location', ['~', '\.(js|css)$'], []]] ['location', ['~', '\\.(js|css)$'], []]]
assert_config(config, expected) assert_config(config, expected)
@ -222,14 +222,14 @@ if (!-e "/var/data/$dataset") {
return 503; return 503;
} }
if ($https_or_slb = (by_\(sl\)b|https)) { if ($https_or_slb = (by_\\(sl\\)b|https)) {
} }
if ($host ~* (lori|rage2)\.yandex\.(ru|ua|com|com\.tr)) { if ($host ~* (lori|rage2)\\.yandex\\.(ru|ua|com|com\\.tr)) {
set $x_frame_options ALLOW; set $x_frame_options ALLOW;
} }
if ($request_filename ~* ^.*?/(\d+_)([^/]+)$) { if ($request_filename ~* ^.*?/(\\d+_)([^/]+)$) {
} }
if ($http_user_agent ~* "^WordPress.*; verifying pingback") { if ($http_user_agent ~* "^WordPress.*; verifying pingback") {
@ -258,12 +258,12 @@ if ($foo = "BAR") { rewrite ^(.*)$ /bar; }
['if', ['!-e', '/var/data/$dataset'], [ ['if', ['!-e', '/var/data/$dataset'], [
['return', '503'] ['return', '503']
]], ]],
['if', ['$https_or_slb', '=', '(by_\(sl\)b|https)'], [ ['if', ['$https_or_slb', '=', '(by_\\(sl\\)b|https)'], [
]], ]],
['if', ['$host', '~*', '(lori|rage2)\.yandex\.(ru|ua|com|com\.tr)'], [ ['if', ['$host', '~*', '(lori|rage2)\\.yandex\\.(ru|ua|com|com\\.tr)'], [
['set', '$x_frame_options', 'ALLOW'] ['set', '$x_frame_options', 'ALLOW']
]], ]],
['if', ['$request_filename', '~*', '^.*?/(\d+_)([^/]+)$'], [ ['if', ['$request_filename', '~*', '^.*?/(\\d+_)([^/]+)$'], [
]], ]],
['if', ['$http_user_agent', '~*', '^WordPress.*; verifying pingback'], [ ['if', ['$http_user_agent', '~*', '^WordPress.*; verifying pingback'], [
]], ]],
@ -360,14 +360,14 @@ server {
def test_issue_8(): def test_issue_8():
config = ''' config = '''
# http://nginx.org/ru/docs/http/ngx_http_upstream_module.html # http://nginx.org/ru/docs/http/ngx_http_upstream_module.html
if ($http_referer ~* (\.(ru|ua|by|kz)/(pages/music|partners/|page-no-rights\.xml)) ) { if ($http_referer ~* (\\.(ru|ua|by|kz)/(pages/music|partners/|page-no-rights\\.xml)) ) {
set $temp A; set $temp A;
} }
''' '''
expected = [ expected = [
['http://nginx.org/ru/docs/http/ngx_http_upstream_module.html'], ['http://nginx.org/ru/docs/http/ngx_http_upstream_module.html'],
['if', ['$http_referer', '~*', '(\.(ru|ua|by|kz)/(pages/music|partners/|page-no-rights\.xml))'], [ ['if', ['$http_referer', '~*', '(\\.(ru|ua|by|kz)/(pages/music|partners/|page-no-rights\\.xml))'], [
['set', '$temp', 'A'] ['set', '$temp', 'A']
]] ]]
] ]
@ -415,9 +415,9 @@ location = /lua {
['content_by_lua_block', [], [ ['content_by_lua_block', [], [
'local', 'res', '=', 'ngx.location.capture(', '"/some_other_location"', ')', 'local', 'res', '=', 'ngx.location.capture(', '"/some_other_location"', ')',
'if', 'res', 'then', 'if', 'res', 'then',
'ngx.say(', '"status: "', ',', 'res.status)', 'ngx.say(', '"status: "', ',', 'res.status)',
'ngx.say(', '"body:"', ')', 'ngx.say(', '"body:"', ')',
'ngx.print(res.body)', 'ngx.print(res.body)',
'end']] 'end']]
]] ]]
] ]
@ -442,7 +442,7 @@ location = /foo {
['location', ['=', '/foo'], [ ['location', ['=', '/foo'], [
['rewrite_by_lua_block', [], [ ['rewrite_by_lua_block', [], [
'res', '=', 'ngx.location.capture(', '"/memc"', ',', 'res', '=', 'ngx.location.capture(', '"/memc"', ',',
['args', '=', ['cmd', '=', '"incr"', ',', 'key', '=', 'ngx.var.uri']], ['args', '=', ['cmd', '=', '"incr"', ',', 'key', '=', 'ngx.var.uri']],
')']], ')']],
['proxy_pass', 'http://blah.blah.com'] ['proxy_pass', 'http://blah.blah.com']
]] ]]
@ -556,9 +556,9 @@ add_header X-Test "Windows-1251";
''' '''
actual = RawParser().parse(config) actual = RawParser().parse(config)
assert_equals(len(actual.asList()), 2) assert_equal(len(actual.asList()), 2)
def assert_config(config, expected): def assert_config(config, expected):
actual = RawParser().parse(config) actual = RawParser().parse(config)
assert_equals(actual.asList(), expected) assert_equal(actual.asList(), expected)

17
tests/plugins/test_simply.py
View File

@ -1,13 +1,13 @@
from nose.tools import assert_equals, assert_true from nose.tools import assert_equal, assert_true
from tests.asserts import assert_in from tests.asserts import assert_in
import os import os
from os import path from os import path
import json import json
from ..utils import *
from gixy.core.manager import Manager as Gixy from gixy.core.manager import Manager as Gixy
from gixy.core.plugins_manager import PluginsManager from gixy.core.plugins_manager import PluginsManager
from gixy.core.config import Config from gixy.core.config import Config
from gixy.formatters.base import BaseFormatter
def setup_module(): def setup_module():
@ -57,7 +57,8 @@ def test_from_config():
assert_true(plugin in tested_plugins, assert_true(plugin in tested_plugins,
'Plugin {name!r} should have at least one simple test config'.format(name=plugin)) 'Plugin {name!r} should have at least one simple test config'.format(name=plugin))
assert_true(plugin in tested_fp_plugins, assert_true(plugin in tested_fp_plugins,
'Plugin {name!r} should have at least one simple test config with false positive'.format(name=plugin)) 'Plugin {name!r} should have at least one simple test config with false positive'
.format(name=plugin))
def parse_plugin_options(config_path): def parse_plugin_options(config_path):
@ -86,15 +87,15 @@ def check_configuration(plugin, config_path, test_config):
formatter.feed(config_path, yoda) formatter.feed(config_path, yoda)
_, results = formatter.reports.popitem() _, results = formatter.reports.popitem()
assert_equals(len(results), 1, 'Should have one report') assert_equal(len(results), 1, 'Should have one report')
result = results[0] result = results[0]
if 'severity' in test_config: if 'severity' in test_config:
if not hasattr(test_config['severity'], '__iter__'): if not hasattr(test_config['severity'], '__iter__'):
assert_equals(result['severity'], test_config['severity']) assert_equal(result['severity'], test_config['severity'])
else: else:
assert_in(result['severity'], test_config['severity']) assert_in(result['severity'], test_config['severity'])
assert_equals(result['plugin'], plugin) assert_equal(result['plugin'], plugin)
assert_true(result['summary']) assert_true(result['summary'])
assert_true(result['description']) assert_true(result['description'])
assert_true(result['config']) assert_true(result['config'])
@ -105,5 +106,5 @@ def check_configuration(plugin, config_path, test_config):
def check_configuration_fp(plugin, config_path, test_config): def check_configuration_fp(plugin, config_path, test_config):
with yoda_provider(plugin) as yoda: with yoda_provider(plugin) as yoda:
yoda.audit(config_path, open(config_path, mode='r')) yoda.audit(config_path, open(config_path, mode='r'))
assert_equals(len([x for x in yoda.results]), 0, assert_equal(len([x for x in yoda.results]), 0,
'False positive configuration must not trigger any plugins') 'False positive configuration must not trigger any plugins')

2
tests/utils.py
View File

@ -54,7 +54,7 @@ class Matcher(object):
""" """
Try to match a single stored value (dv) with a supplied value (v). Try to match a single stored value (dv) with a supplied value (v).
""" """
if type(v) != type(dv): if type(v) is not type(dv):
result = False result = False
elif type(dv) is not str or k not in self._partial_matches: elif type(dv) is not str or k not in self._partial_matches:
result = (v == dv) result = (v == dv)

5
tox.ini
View File

@ -1,5 +1,5 @@
[tox] [tox]
envlist = py26, py27, py34, py35, py36, py37, flake8 envlist = py39, py310, py311, py312, py313, flake8
skip_missing_interpreters = True skip_missing_interpreters = True
[testenv] [testenv]
@ -12,8 +12,7 @@ commands = nosetests -v
deps = deps =
flake8 flake8
basepython = python3 basepython = python3
commands = commands = flake8
flake8 setup.py gixy
[flake8] [flake8]
max_line_length = 120 max_line_length = 120