def test_create_queryset_with_multiple_sorting():
    """
    Create QuerySet with Multiple Sorting
    """
    # When create a query block
    t = QuerySet("foobar")

    # And I add sorting
    s = Sort("_id", order="asc")
    t.order_by(s)

    ss = Sort("_id", order="desc")
    t.order_by(ss)

    # Then I see the appropriate JSON
    results = {
        "sort": [
            {
                "_id": {
                    "order": "asc"
                }
            },
            {
                "_id": {
                    "order": "desc"
                }
            }
        ],
        "query": {
            "match_all": {}
        }
    }

    homogeneous(t._query, results)

def test_create_queryset_with_multiple_scoring():
    """
    Create QuerySet with Multiple Scoring
    """
    # When create a query block
    t = QuerySet("foobar")

    # And I add scoring
    s = ScriptScore("foo = 0.0")
    t.score(s)

    # And I add more scoring
    ss = ScriptScore("foo = 1.0")
    t.score(ss)

    # Then I see the appropriate JSON
    results = {
        "query": {
            "function_score": {
                "query": {"match_all": {}},
                "script_score": {
                    "script": "foo = 1.0"
                },
                "boost_mode": "replace"
            }
        }
    }

    homogeneous(t._query, results)

def test_create_queryset_with_scoring():
    """
    Create QuerySet with Scoring, Minimum Score and Track Scores
    """
    # When create a query block
    t = QuerySet("foobar")

    # And I add scoring
    s = ScriptScore("foo = 0.0")
    t.score(s, min_score=0, track_scores=True)

    # Then I see the appropriate JSON
    results = {
        "min_score": 0,
        "track_scores": True,
        "query": {
            "function_score": {
                "functions": [
                    {
                        "script_score": {
                            "script": "foo = 0.0"
                        }
                    }
                ],
                "query": {"match_all": {}},
                "boost_mode": "replace",
                "score_mode": "multiply"
            }
        }
    }

    homogeneous(t._query, results)

def test_create_queryset_with_filters():
    """
    Create QuerySet with Multiple Filters
    """
    # When create a query block
    t = QuerySet("foobar")

    # And I add a filter
    t.filter(Term("foo", "bar"))
    t.filter(Term("foobar", "foobar"))

    # Then I see the appropriate JSON
    results = {
        "query": {
            "filtered": {
                "query": {"match_all": {}},
                "filter": {
                    "and": [
                        {
                            "term": {
                                "foo": "bar"
                            }
                        },
                        {
                            "term": {
                                "foobar": "foobar"
                            }
                        }
                    ]
                }
            }
        }
    }

    homogeneous(t._query, results)

def test_create_filter():
    """
    Create Default Filter
    """
    # When create a filter block
    t = Filter()

    # Then I see the appropriate JSON
    results = {"and": []}

    homogeneous(t, results)

def test_filter_with_and():
    """
    Create AND Filter
    """
    # When create a filter block
    t = Filter("and")

    # Then I see the appropriate JSON
    results = {"and": []}

    homogeneous(t, results)

def test_filter_with_or():
    """
    Create OR Filter
    """
    # When create a filter block
    t = Filter("or")

    # Then I see the appropriate JSON
    results = {"or": []}

    homogeneous(t, results)

def test_create_queryset_with_filters_and_scoring():
    """
    Create QuerySet with Scoring and Multiple Filters
    """
    # When create a query block
    t = QuerySet("foobar")

    # And I add filtering
    t.filter(Term("foo", "bar"))

    # And I add scoring
    s = ScriptScore("foo = 0.0")
    t.score(s)

    # And I add a second filter
    t.filter(Term("foobar", "foobar"))

    # Then I see the appropriate JSON
    results = {
        "query": {
            "function_score": {
                "query": {
                    "filtered": {
                        "query": {"match_all": {}},
                        "filter": {
                            "and": [
                                {
                                    "term": {
                                        "foo": "bar"
                                    }
                                },
                                {
                                    "term": {
                                        "foobar": "foobar"
                                    }
                                }
                            ]
                        }
                    }
                },
                "functions": [
                    {
                        "script_score": {
                            "script": "foo = 0.0"
                        }
                    }
                ],
                "boost_mode": "replace",
                "score_mode": "multiply"
            }
        }
    }

    homogeneous(t._query, results)

def test_create_bool():
    """
    Create Bool Block
    """
    # When I create a Bool block
    t = Bool()

    # Then I see the appropriate JSON
    results = {
        "bool": {}
    }

    homogeneous(t, results)

def test_add_match_all():
    """
    Create Match All Block
    """
    # When add a match all filter
    t = MatchAll()

    # Then I see the appropriate JSON
    results = {
        "match_all": {}
    }

    homogeneous(t, results)

def test_create_queryset():
    """
    Create Default QuerySet
    """
    # When create a queryset
    t = QuerySet("foobar")

    # Then I see the appropriate JSON
    results = {
        "query": {"match_all": {}}
    }

    homogeneous(t._query, results)

def test_add_score():
    """
    Create Score Block
    """
    # When add a Score field
    t = ScriptScore("foo")

    # Then I see the appropriate JSON
    results = {
        "script": "foo"
    }

    homogeneous(t, results)

def test_add_filter():
    """
    Create Filter with Block
    """
    # When I create a filter
    t = Filter()

    # And add a block
    t.filter(Term("foo", "bar"))

    # Then I see the appropriate JSON
    results = {"and": [{"term": {"foo": "bar"}}]}

    homogeneous(t, results)

def test_add_score_with_lang():
    """
    Create Score Block with Language
    """
    # When add a Score field
    t = ScriptScore("foo", lang="mvel")

    # Then I see the appropriate JSON
    results = {
        "script": "foo",
        "lang": "mvel"
    }

    homogeneous(t, results)

def test_add_terms():
    """
    Create Terms Block
    """
    # When add a Terms field
    t = Terms("foo", ["bar", "baz"])

    # Then I see the appropriate JSON
    results = {
        "terms": {
            "foo": ["bar", "baz"]
        }
    }

    homogeneous(t, results)

def test_add_sort_desc():
    """
    Create Sort Block Descending
    """
    # When add a Sort block
    t = Sort("foo", order="dsc")

    # Then I see the appropriate JSON
    results = {
        "foo": {
            "order": "dsc"
        }
    }

    homogeneous(t, results)

def test_add_type():
    """
    Create Type Block
    """
    # When add a Type Block
    t = Type("foo")

    # Then I see the appropriate JSON
    results = {
        "type": {
            "value": "foo"
        }
    }

    homogeneous(t, results)

def test_add_sort():
    """
    Create Sort Block
    """
    # When add a Sort block
    t = Sort("foo")

    # Then I see the appropriate JSON
    results = {
        "foo": {
            "order": "asc"
        }
    }

    homogeneous(t, results)

def test_missing():
    """
    Create Missing Block
    """
    # When add a Missing Block
    t = Missing("foo")

    # Then I see the appropriate JSON
    results = {
        "missing": {
            "field": "foo"
        }
    }

    homogeneous(t, results)

def test_add_agg():
    """
    Create aggregations block
    """
    # When add an agg block
    t = Aggregations("agg_name", "field_name", "metric")

    # Then I see correct json
    results = {
        "agg_name": {
            "metric": {"field": "field_name"}
        }
    }

    homogeneous(t, results)