Ejemplo n.º 1
0
    def test_filter_specs(self):
        delegate_spec = DimensionSpec("dim", "out").build()
        filter_specs = [
            (
                ListFilteredSpec(["val1", "val2"]),
                {
                    "type": "listFiltered",
                    "delegate": delegate_spec,
                    "values": ["val1", "val2"],
                },
            ),
            (
                ListFilteredSpec(["val1", "val2"], is_whitelist=False),
                {
                    "type": "listFiltered",
                    "delegate": delegate_spec,
                    "values": ["val1", "val2"],
                    "isWhitelist": False,
                },
            ),
            (
                RegexFilteredSpec(r"\w+"),
                {
                    "type": "regexFiltered",
                    "delegate": delegate_spec,
                    "pattern": "\\w+"
                },
            ),
        ]

        for filter_spec, expected_dim_spec in filter_specs:
            dim_spec = DimensionSpec("dim", "out", filter_spec=filter_spec)
            actual = dim_spec.build()

            assert actual == expected_dim_spec
Ejemplo n.º 2
0
    def test_extraction_functions(self):
        js_func = 'function(x) {return x};'
        ext_fns = [
            (RegexExtraction(r'\w+'), {'type': 'regex', 'expr': '\\w+'}),
            (PartialExtraction(r'\w+'), {'type': 'partial', 'expr': '\\w+'}),
            (JavascriptExtraction(js_func), {
                'type': 'javascript',
                'function': js_func,
                'injective': False
            }),
            (MapLookupExtraction(TestMapLookupExtraction.mapping), {
                'type': 'lookup',
                'lookup': {
                    'type': 'map',
                    'map': TestMapLookupExtraction.mapping
                },
                'retainMissingValue': False,
                'replaceMissingValueWith': None,
                'injective': False
            })
        ]

        for ext_fn, expected_ext_fn in ext_fns:
            dim_spec = DimensionSpec('dim', 'out', extraction_function=ext_fn)
            actual = dim_spec.build()
            expected = {
                'type': 'extraction',
                'dimension': 'dim',
                'outputName': 'out',
                'extractionFn': expected_ext_fn
            }

            assert actual == expected
Ejemplo n.º 3
0
    def test_filter_specs(self):
        delegate_spec = DimensionSpec('dim', 'out').build()
        filter_specs = [
            (ListFilteredSpec(['val1', 'val2']), {
                'type': 'listFiltered',
                'delegate': delegate_spec,
                'values': ['val1', 'val2'],
            }),
            (ListFilteredSpec(['val1', 'val2'], is_whitelist=False), {
                'type': 'listFiltered',
                'delegate': delegate_spec,
                'values': ['val1', 'val2'],
                'isWhitelist': False,
            }),
            (RegexFilteredSpec(r'\w+'), {
                'type': 'regexFiltered',
                'delegate': delegate_spec,
                'pattern': '\\w+',
            })
        ]

        for filter_spec, expected_dim_spec in filter_specs:
            dim_spec = DimensionSpec('dim', 'out', filter_spec=filter_spec)
            actual = dim_spec.build()

            assert actual == expected_dim_spec
Ejemplo n.º 4
0
    def test_filter_specs(self):
        delegate_spec = DimensionSpec('dim', 'out').build()
        filter_specs = [(ListFilteredSpec(['val1', 'val2']), {
            'type': 'listFiltered',
            'delegate': delegate_spec,
            'values': ['val1', 'val2'],
        }),
                        (ListFilteredSpec(['val1', 'val2'],
                                          is_whitelist=False), {
                                              'type': 'listFiltered',
                                              'delegate': delegate_spec,
                                              'values': ['val1', 'val2'],
                                              'isWhitelist': False,
                                          }),
                        (RegexFilteredSpec(r'\w+'), {
                            'type': 'regexFiltered',
                            'delegate': delegate_spec,
                            'pattern': '\\w+',
                        })]

        for filter_spec, expected_dim_spec in filter_specs:
            dim_spec = DimensionSpec('dim', 'out', filter_spec=filter_spec)
            actual = dim_spec.build()

            assert actual == expected_dim_spec
Ejemplo n.º 5
0
    def test_extraction_functions(self):
        js_func = 'function(x) {return x};'
        ext_fns = [
            (RegexExtraction(r'\w+'), {'type': 'regex', 'expr': '\\w+'}),
            (PartialExtraction(r'\w+'), {'type': 'partial', 'expr': '\\w+'}),
            (JavascriptExtraction(js_func), {
                'type': 'javascript',
                'function': js_func,
                'injective': False
            }),
            (MapLookupExtraction(TestMapLookupExtraction.mapping), {
                'type': 'lookup',
                'lookup': {
                    'type': 'map',
                    'map': TestMapLookupExtraction.mapping
                },
                'retainMissingValue': False,
                'replaceMissingValueWith': None,
                'injective': False
            })
        ]

        for ext_fn, expected_ext_fn in ext_fns:
            dim_spec = DimensionSpec('dim', 'out', extraction_function=ext_fn)
            actual = dim_spec.build()
            expected = {
                'type': 'extraction',
                'dimension': 'dim',
                'outputName': 'out',
                'extractionFn': expected_ext_fn
            }

            assert actual == expected
Ejemplo n.º 6
0
    def test_extraction_functions(self):
        js_func = "function(x) {return x};"
        ext_fns = [
            (RegexExtraction(r"\w+"), {
                "type": "regex",
                "expr": "\\w+"
            }),
            (PartialExtraction(r"\w+"), {
                "type": "partial",
                "expr": "\\w+"
            }),
            (
                JavascriptExtraction(js_func),
                {
                    "type": "javascript",
                    "function": js_func,
                    "injective": False
                },
            ),
            (
                MapLookupExtraction(TestMapLookupExtraction.mapping),
                {
                    "type": "lookup",
                    "lookup": {
                        "type": "map",
                        "map": TestMapLookupExtraction.mapping
                    },
                    "retainMissingValue": False,
                    "replaceMissingValueWith": None,
                    "injective": False,
                },
            ),
        ]

        for ext_fn, expected_ext_fn in ext_fns:
            dim_spec = DimensionSpec("dim", "out", extraction_function=ext_fn)
            actual = dim_spec.build()
            expected = {
                "type": "extraction",
                "dimension": "dim",
                "outputName": "out",
                "extractionFn": expected_ext_fn,
            }

            assert actual == expected
Ejemplo n.º 7
0
    def test_extraction_functions(self):
        js_func = "function(x) {return x};"
        ext_fns = [
            (RegexExtraction(r"\w+"), {"type": "regex", "expr": "\\w+"}),
            (PartialExtraction(r"\w+"), {"type": "partial", "expr": "\\w+"}),
            (JavascriptExtraction(js_func), {"type": "javascript", "function": js_func, "injective": False}),
            (
                MapLookupExtraction(TestMapLookupExtraction.mapping),
                {
                    "type": "lookup",
                    "lookup": {"type": "map", "map": TestMapLookupExtraction.mapping},
                    "retainMissingValue": False,
                    "replaceMissingValueWith": None,
                    "injective": False,
                },
            ),
        ]

        for ext_fn, expected_ext_fn in ext_fns:
            dim_spec = DimensionSpec("dim", "out", extraction_function=ext_fn)
            actual = dim_spec.build()
            expected = {"type": "extraction", "dimension": "dim", "outputName": "out", "extractionFn": expected_ext_fn}

            assert actual == expected
Ejemplo n.º 8
0
    def test_regex_filtered_spec(self):
        dim_spec = DimensionSpec('dim', 'out').build()
        regex_filtered_spec = RegexFilteredSpec(r'\w+')
        actual = regex_filtered_spec.build(dim_spec)
        expected_dim_spec = {
            'type': 'default',
            'dimension': 'dim',
            'outputName': 'out'
        }
        expected = {
            'type': 'regexFiltered',
            'delegate': expected_dim_spec,
            'pattern': '\\w+',
        }

        assert actual == expected
Ejemplo n.º 9
0
    def test_regex_filtered_spec(self):
        dim_spec = DimensionSpec("dim", "out").build()
        regex_filtered_spec = RegexFilteredSpec(r"\w+")
        actual = regex_filtered_spec.build(dim_spec)
        expected_dim_spec = {
            "type": "default",
            "dimension": "dim",
            "outputName": "out"
        }
        expected = {
            "type": "regexFiltered",
            "delegate": expected_dim_spec,
            "pattern": "\\w+",
        }

        assert actual == expected
Ejemplo n.º 10
0
    def test_list_filtered_spec(self):
        dim_spec = DimensionSpec('dim', 'out').build()
        list_filtered_spec = ListFilteredSpec(['val1', 'val2'])
        actual = list_filtered_spec.build(dim_spec)
        expected_dim_spec = {
            'type': 'default',
            'dimension': 'dim',
            'outputName': 'out'
        }
        expected = {
            'type': 'listFiltered',
            'delegate': expected_dim_spec,
            'values': ['val1', 'val2'],
        }

        assert actual == expected
Ejemplo n.º 11
0
    def test_list_filtered_spec(self):
        dim_spec = DimensionSpec("dim", "out").build()
        list_filtered_spec = ListFilteredSpec(["val1", "val2"])
        actual = list_filtered_spec.build(dim_spec)
        expected_dim_spec = {
            "type": "default",
            "dimension": "dim",
            "outputName": "out"
        }
        expected = {
            "type": "listFiltered",
            "delegate": expected_dim_spec,
            "values": ["val1", "val2"],
        }

        assert actual == expected
Ejemplo n.º 12
0
 def test_columnComparison_filter(self):
     actual = filters.Filter.build_filter(
         filters.Filter(type='columnComparison',
                        dimensions=['dim1',
                                    DimensionSpec('dim2', 'dim2')]))
     expected = {
         'type':
         'columnComparison',
         'dimensions': [
             'dim1', {
                 'type': 'default',
                 'dimension': 'dim2',
                 'outputName': 'dim2'
             }
         ]
     }
     assert actual == expected
Ejemplo n.º 13
0
    def test_default(self):
        dim_spec = DimensionSpec('dim', 'out')
        actual = dim_spec.build()
        expected = {'type': 'default', 'dimension': 'dim', 'outputName': 'out'}

        assert actual == expected
Ejemplo n.º 14
0
    def test_default(self):
        dim_spec = DimensionSpec("dim", "out")
        actual = dim_spec.build()
        expected = {"type": "default", "dimension": "dim", "outputName": "out"}

        assert actual == expected
Ejemplo n.º 15
0
    def test_build_dimension(self):
        assert build_dimension("raw_dim") == "raw_dim"

        dim_spec = DimensionSpec("dim", "out")
        assert build_dimension(dim_spec) == dim_spec.build()
Ejemplo n.º 16
0
    def test_build_dimension(self):
        assert build_dimension('raw_dim') == 'raw_dim'

        dim_spec = DimensionSpec('dim', 'out')
        assert build_dimension(dim_spec) == dim_spec.build()
Ejemplo n.º 17
0
    def test_default(self):
        dim_spec = DimensionSpec('dim', 'out')
        actual = dim_spec.build()
        expected = {'type': 'default', 'dimension': 'dim', 'outputName': 'out'}

        assert actual == expected
Ejemplo n.º 18
0
    def test_build_dimension(self):
        assert build_dimension("raw_dim") == "raw_dim"

        dim_spec = DimensionSpec("dim", "out")
        assert build_dimension(dim_spec) == dim_spec.build()
Ejemplo n.º 19
0
    def test_default(self):
        dim_spec = DimensionSpec("dim", "out")
        actual = dim_spec.build()
        expected = {"type": "default", "dimension": "dim", "outputName": "out"}

        assert actual == expected
Ejemplo n.º 20
0
    def test_build_dimension(self):
        assert build_dimension('raw_dim') == 'raw_dim'

        dim_spec = DimensionSpec('dim', 'out')
        assert build_dimension(dim_spec) == dim_spec.build()