def test_hybrid_search_all_score_modifiers_fusion(self):
        """
        Tests that all score modifiers tensor, lexical, and global, work as expected together.
        They should all work independently of each other. tensor, lexical, and _score should all be modified
        Tests all fusion methods (currently only RRF / Disjunction)
        Does not test legacy unstructured index, as it does not support global score modifiers (2.15 onwards)
        """

        for index in [self.structured_text_index_score_modifiers, self.semi_structured_default_text_index]:
            with self.subTest(index=type(index)):
                # Add documents
                self.add_documents(
                    config=self.config,
                    add_docs_params=AddDocsParams(
                        index_name=index.name,
                        docs=[
                            {"_id": "doc6", "text_field_1": "HELLO WORLD"},
                            {"_id": "doc7", "text_field_1": "HELLO WORLD", "add_field_1": 1.0},  # third
                            {"_id": "doc8", "text_field_1": "HELLO WORLD", "mult_field_1": 2.0},   # second highest score
                            {"_id": "doc9", "text_field_1": "HELLO WORLD", "mult_field_1": 3.0},  # highest score
                            {"_id": "doc10", "text_field_1": "HELLO WORLD", "mult_field_2": 3.0},    # lowest score
                        ],
                        tensor_fields=["text_field_1", "text_field_2", "text_field_3"] \
                            if isinstance(index, UnstructuredMarqoIndex) else None
                    )
                )

                # Calculate unmodified RRF scores
                hybrid_res_no_global_score_modifiers = tensor_search.search(
                    config=self.config,
                    index_name=index.name,
                    text="HELLO WORLD",
                    search_method="HYBRID",
                    hybrid_parameters=HybridParameters(
                        retrievalMethod=RetrievalMethod.Disjunction,
                        rankingMethod=RankingMethod.RRF,
                        # Mult weight of 1000 used so it outweighs the add weight of 5
                        scoreModifiersLexical={
                            "multiply_score_by": [
                                {"field_name": "mult_field_1", "weight": 1000},
                                {"field_name": "mult_field_2", "weight": -1000}
                            ],
                            "add_to_score": [
                                {"field_name": "add_field_1", "weight": 5}
                            ]
                        },
                        scoreModifiersTensor={
                            "multiply_score_by": [
                                {"field_name": "mult_field_1", "weight": 1000},
                                {"field_name": "mult_field_2", "weight": -1000}
                            ],
                            "add_to_score": [
                                {"field_name": "add_field_1", "weight": 5}
                            ]
                        },
                        verbose=True
                    ),
                    result_count=10
                )

                # RRF scores without global score modifiers
                unmodified_rrf_scores = {}
                for hit in hybrid_res_no_global_score_modifiers["hits"]:
                    unmodified_rrf_scores[hit["_id"]] = hit["_score"]

                hybrid_res = tensor_search.search(
                    config=self.config,
                    index_name=index.name,
                    text="HELLO WORLD",
                    search_method="HYBRID",
                    score_modifiers=ScoreModifierLists(
                        multiply_score_by=[
                            {"field_name": "mult_field_1", "weight": 1000},
                            {"field_name": "mult_field_2", "weight": -1000}
                        ],
                        add_to_score=[
                            {"field_name": "add_field_1", "weight": 5}
                        ]
                    ),
                    hybrid_parameters=HybridParameters(
                        retrievalMethod=RetrievalMethod.Disjunction,
                        rankingMethod=RankingMethod.RRF,
                        # Mult weight of 1000 used so it outweighs the add weight of 5
                        scoreModifiersLexical={
                            "multiply_score_by": [
                                {"field_name": "mult_field_1", "weight": 1000},
                                {"field_name": "mult_field_2", "weight": -1000}
                            ],
                            "add_to_score": [
                                {"field_name": "add_field_1", "weight": 5}
                            ]
                        },
                        scoreModifiersTensor={
                            "multiply_score_by": [
                                {"field_name": "mult_field_1", "weight": 1000},
                                {"field_name": "mult_field_2", "weight": -1000}
                            ],
                            "add_to_score": [
                                {"field_name": "add_field_1", "weight": 5}
                            ]
                        },
                        verbose=True
                    ),
                    result_count=10
                )
                self.assertIn("hits", hybrid_res)

                # Score without score modifiers
                self.assertEqual(hybrid_res["hits"][3]["_id"], "doc6")  # (score)
                base_lexical_score = hybrid_res["hits"][3]["_lexical_score"]
                base_tensor_score = hybrid_res["hits"][3]["_tensor_score"]

                self.assertEqual(hybrid_res["hits"][0]["_id"], "doc9")  # highest score (score*10*3)
                self.assertAlmostEqual(hybrid_res["hits"][0]["_lexical_score"], base_lexical_score * 1000 * 3)
                self.assertAlmostEqual(hybrid_res["hits"][0]["_tensor_score"], base_tensor_score * 1000 * 3)
                self.assertAlmostEqual(hybrid_res["hits"][0]["_score"], unmodified_rrf_scores["doc9"] * 1000 * 3)

                self.assertEqual(hybrid_res["hits"][1]["_id"], "doc8")  # (score*10*2)
                self.assertAlmostEqual(hybrid_res["hits"][1]["_lexical_score"], base_lexical_score * 1000 * 2)
                self.assertAlmostEqual(hybrid_res["hits"][1]["_tensor_score"], base_tensor_score * 1000 * 2)
                self.assertAlmostEqual(hybrid_res["hits"][1]["_score"], unmodified_rrf_scores["doc8"] * 1000 * 2)

                self.assertEqual(hybrid_res["hits"][2]["_id"], "doc7")  # (score + 5*1)
                self.assertAlmostEqual(hybrid_res["hits"][2]["_lexical_score"], base_lexical_score + 5*1)
                self.assertAlmostEqual(hybrid_res["hits"][2]["_tensor_score"], base_tensor_score + 5*1)
                self.assertAlmostEqual(hybrid_res["hits"][2]["_score"], unmodified_rrf_scores["doc7"] + 5*1)

                self.assertEqual(hybrid_res["hits"][-1]["_id"], "doc10")  # lowest score (score*-10*3)
                self.assertAlmostEqual(hybrid_res["hits"][-1]["_lexical_score"], base_lexical_score * -1000 * 3)
                self.assertAlmostEqual(hybrid_res["hits"][-1]["_tensor_score"], base_tensor_score * -1000 * 3)
                self.assertAlmostEqual(hybrid_res["hits"][-1]["_score"], unmodified_rrf_scores["doc10"] * -1000 * 3)

        Tests that all score modifiers tensor, lexical, and global, work as expected together.
        They should all work independently of each other. tensor, lexical, and _score should all be modified
        Tests all fusion methods (currently only RRF / Disjunction)
        Does not test legacy unstructured index, as it does not support global score modifiers (2.15 onwards)
        
tests/integ_tests/tensor_search/integ_tests/test_hybrid_search.py