Simplify replaceInstrument() to use DOM-level ChangePart directly

Remove dependency on notation module by using engraving::ChangePart
command directly instead of going through INotationParts. This:
- Eliminates need for NotationMock and NotationPartsMock in tests
- Simplifies test setup (no mock injection required)
- Keeps the implementation purely at the engraving layer
- Makes the API self-contained within the plugin API module

Author: manolo

src/engraving/api/tests/mocks/globalcontextmock.h

@@ -33,38 +33,11 @@
 #include "engraving/api/v1/score.h"
 #include "engraving/api/v1/part.h"
 
-#include "mocks/globalcontextmock.h"
-#include "mocks/notationmock.h"
-#include "mocks/notationpartsmock.h"
-
 using namespace mu::engraving;
-using namespace mu::notation;
-using namespace mu::context;
-using ::testing::Return;
-using ::testing::_;
-using ::testing::NiceMock;
 
 class Engraving_ApiScoreTests : public ::testing::Test
 {
 public:
-    void SetUp() override
-    {
-        m_globalContext = std::make_shared<NiceMock<GlobalContextMock> >();
-        m_notation = std::make_shared<NiceMock<NotationMock> >();
-        m_notationParts = std::make_shared<NiceMock<NotationPartsMock> >();
-    }
-
-    void TearDown() override
-    {
-        m_notationParts.reset();
-        m_notation.reset();
-        m_globalContext.reset();
-    }
-
-protected:
-    std::shared_ptr<NiceMock<GlobalContextMock> > m_globalContext;
-    std::shared_ptr<NiceMock<NotationMock> > m_notation;
-    std::shared_ptr<NiceMock<NotationPartsMock> > m_notationParts;
 };
 
 //---------------------------------------------------------
@@ -197,14 +170,13 @@ TEST_F(Engraving_ApiScoreTests, replaceInstrumentRedo)
 }
 
 //---------------------------------------------------------
-//   testReplaceInstrumentApiWithMocks
+//   testReplaceInstrumentApi
 //   Test the Plugin API Score::replaceInstrument() method
-//   using mocks to verify the correct call chain
 //---------------------------------------------------------
 
-TEST_F(Engraving_ApiScoreTests, replaceInstrumentApiWithMocks)
+TEST_F(Engraving_ApiScoreTests, replaceInstrumentApi)
 {
-    // [GIVEN] A score with a part and mocked notation layer
+    // [GIVEN] A score with a part
     MasterScore* domScore = compat::ScoreAccess::createMasterScore(nullptr);
 
     Part* domPart = new Part(domScore);
@@ -213,34 +185,22 @@ TEST_F(Engraving_ApiScoreTests, replaceInstrumentApiWithMocks)
 
     // Set initial instrument
     Instrument initialInstrument;
-    initialInstrument.setId(u"wind.flutes.flute");
+    initialInstrument.setId(u"test.flute");
     initialInstrument.setTrackName(u"Flute");
     domPart->setInstrument(initialInstrument);
 
-    // Setup mock chain: GlobalContext -> Notation -> NotationParts
-    ON_CALL(*m_globalContext, currentNotation())
-    .WillByDefault(Return(m_notation));
-    ON_CALL(*m_notation, parts())
-    .WillByDefault(Return(m_notationParts));
-
-    // [EXPECT] replaceInstrument to be called on NotationParts with correct parameters
-    EXPECT_CALL(*m_notationParts, replaceInstrument(_, _, _))
-    .Times(1);
+    EXPECT_EQ(domPart->instrumentId(), QString("test.flute"));
 
-    // Register the mock in IOC
-    muse::modularity::globalIoc()->registerExport<IGlobalContext>("test", m_globalContext);
-
-    // Create API wrapper for the score
+    // Create API wrappers
     apiv1::Score apiScore(domScore);
-
-    // Create API wrapper for the part
     apiv1::Part* apiPart = new apiv1::Part(domPart, apiv1::Ownership::SCORE);
 
-    // [WHEN] We call replaceInstrument through the API
+    // [WHEN] We call replaceInstrument through the API with a valid instrument
     apiScore.replaceInstrument(apiPart, "violin");
 
-    // Cleanup
-    muse::modularity::globalIoc()->unregister<IGlobalContext>("test");
+    // [THEN] The instrument should be changed to violin
+    EXPECT_EQ(domPart->instrumentId(), QString("violin"));
+
     delete apiPart;
     delete domScore;
 }
@@ -257,7 +217,7 @@ TEST_F(Engraving_ApiScoreTests, replaceInstrumentApiNullPart)
     apiv1::Score apiScore(domScore);
 
     // [WHEN/THEN] Calling with null part should not crash
-    apiScore.replaceInstrument(nullptr, "strings.violin");
+    apiScore.replaceInstrument(nullptr, "violin");
 
     delete domScore;
 }
@@ -276,13 +236,20 @@ TEST_F(Engraving_ApiScoreTests, replaceInstrumentApiInvalidInstrument)
     domScore->appendPart(domPart);
     domScore->appendStaff(Factory::createStaff(domPart));
 
+    // Set initial instrument
+    Instrument initialInstrument;
+    initialInstrument.setId(u"test.initial");
+    domPart->setInstrument(initialInstrument);
+
     apiv1::Score apiScore(domScore);
     apiv1::Part* apiPart = new apiv1::Part(domPart, apiv1::Ownership::SCORE);
 
-    // [WHEN/THEN] Calling with invalid instrument ID should not crash
-    // (instrument templates are not loaded in test environment, so any ID is "invalid")
+    // [WHEN] Calling with invalid instrument ID
     apiScore.replaceInstrument(apiPart, "nonexistent.instrument.xyz");
 
+    // [THEN] Instrument should remain unchanged
+    EXPECT_EQ(domPart->instrumentId(), QString("test.initial"));
+
     delete apiPart;
     delete domScore;
 }

src/engraving/api/tests/mocks/notationmock.h

@@ -30,14 +30,10 @@
 #include "dom/score.h"
 #include "dom/segment.h"
 #include "dom/text.h"
+#include "editing/editpart.h"
 #include "editing/editsystemlocks.h"
 #include "types/typesconv.h"
 
-// notation
-#include "notation/inotation.h"
-#include "notation/inotationparts.h"
-#include "notation/notationtypes.h"
-
 // api
 #include "apistructs.h"
 #include "cursor.h"
@@ -184,18 +180,11 @@ void Score::replaceInstrument(apiv1::Part* part, const QString& instrumentId)
         return;
     }
 
-    mu::notation::INotationPartsPtr parts = notation() ? notation()->parts() : nullptr;
-    if (!parts) {
-        LOGW("replaceInstrument: notation parts is null");
-        return;
-    }
-
-    mu::notation::InstrumentKey instrumentKey;
-    instrumentKey.partId = muse::ID(part->part()->id());
-    instrumentKey.instrumentId = muse::String::fromQString(part->part()->instrumentId());
-    instrumentKey.tick = mu::engraving::Part::MAIN_INSTRUMENT_TICK;
+    mu::engraving::Part* domPart = part->part();
+    mu::engraving::Instrument newInstrument = mu::engraving::Instrument::fromTemplate(t);
+    String newPartName = t->trackName;
 
-    parts->replaceInstrument(instrumentKey, mu::engraving::Instrument::fromTemplate(t));
+    score()->undo(new ChangePart(domPart, new mu::engraving::Instrument(newInstrument), newPartName));
 }
 
 //---------------------------------------------------------