удобочитаемая замена IEnumerable интерфейсов

Я думаю, что то, что у вас есть, очень хорошо — довольно кратко и ясно.

Если вы действительно хотите избавиться от класса, вы можете использовать метод создания замены для IRibbonCommand:

    private IRibbonCommand Create(string tab, string group, string name)
    {
        var cmd = Substitute.For<IRibbonCommand>();
        cmd.Tab.Returns(tab);
        cmd.Group.Returns(group);
        cmd.Name.Returns(name);
        return cmd;
    }

    [Fact]
    public void Initialize_BuildsCorrectRibbonTree()
    {
        var ribbonCommands = new[] {
            Create("tab1", "group1", "name1"),
            Create("tab1", "group1", "name2"),
            Create("tab2", "group1", "name3"),
            Create("tab2", "group1", "name4")
        };
        var commands = Substitute.For<IRibbonCommandsProvider>();
        commands.GetRibbonCommands().Returns(ribbonCommands);
        // ...
    }

Это не дает вам многого, хотя это означает, что ваш тестовый код будет более защищен от изменений в интерфейсе IRibbonCommand (например, дополнительное свойство не потребует изменения вашего тестового кода), и означает, что вы можете проверять полученные вызовы и заглушать другие вызовы. по отдельным предметам.

В стороне: можно использовать имена аргументов, если вы хотите более точно соответствовать исходному коду:

    Create(tab: "tab1", group: "group1", name: "name1"),

В качестве альтернативы вы можете настроить команду внутри теста. Затем переместите config func из теста и, возможно, обобщите его для других типов по ходу дела. Ягни это.

ОБНОВЛЕНО до рабочего теста

[Test]
public void Test()
{
    Func<Action<IRibbonCommand>, IRibbonCommand> cmd = config =>
    {
        var c = Substitute.For<IRibbonCommand>();
        config(c);
        return c;
    };

    var ribbonCommands = new[]
    {
        cmd(c => { c.Tab.Returns("Tab1"); c.Group.Returns("Group1"); c.Name.Returns("Name1"); }),
        cmd(c => { c.Tab.Returns("Tab1"); c.Group.Returns("Group1"); c.Name.Returns("Name2"); }),
        cmd(c => { c.Tab.Returns("Tab2"); c.Group.Returns("Group1"); c.Name.Returns("Name3"); }),
        cmd(c => { c.Tab.Returns("Tab2"); c.Group.Returns("Group1"); c.Name.Returns("Name4"); })
    };

    var commandsProvider = Substitute.For<IRibbonCommandsProvider>();
    commandsProvider.GetRibbonCommands().Returns(ribbonCommands);
}

Я не вижу ничего из коробки, что будет делать то, что вам нужно. Один из вариантов может заключаться в том, чтобы вы написали свой собственный метод расширения, чтобы упростить конструкцию. Итак, что-то вроде этого:

public static class ReadOnlySubstitute {
   static public T For<T>(object source) where T : class {
      var sub = Substitute.For<T>();

      foreach (var prop in source.GetType().GetProperties()) {
         sub.GetType().GetProperty(prop.Name).GetValue(sub).Returns(prop.GetValue(source));
      }
      return sub;
   }
}

Приведенный выше код фактически создает замену для данного интерфейса, а затем устанавливает возврат для каждого из свойств, указанных в предоставленном объекте.

Затем это можно использовать в вашем тесте, чтобы предоставить анонимным объектам параметры:

[Test]
public void Initialize_BuildsCorrectRibbonTree() {
    var ribbonCommands = new[]
    {
       ReadOnlySubstitute.For<IRibbonCommand>(new {Tab="Tab1", Group="Grp1", Name="Nam1"}),
       ReadOnlySubstitute.For<IRibbonCommand>(new {Tab="Tab1", Group="Grp1", Name="Nam2"}),
       ReadOnlySubstitute.For<IRibbonCommand>(new {Tab="Tab2", Group="Grp1", Name="Nam3"}),
       ReadOnlySubstitute.For<IRibbonCommand>(new {Tab="Tab2", Group="Grp2", Name="Nam3"})
    };

    var commands = Substitute.For<IRibbonCommandsProvider>();
    commands.GetRibbonCommands().Returns(ribbonCommands);
    ....
}

Это не так лаконично, как использование класса RibbonCommand, так как вы должны построить массив перед передачей его в метод Returns, потому что NSubstitute запутается, если вы попытаетесь установить Returns для элементов одновременно с GetRibbonCommands, но я думаю, что это довольно близко.

Это действительно улучшение (субъективное) ответа @dadhi в сочетании с ответом @David Tchepak на другой вопрос.

Таким образом, вместо того, чтобы создавать новый Func для каждого интерфейса, который вы хотите использовать, как описано @dadhi, вы можете вместо этого создать общий метод, который принимает Action. Вы можете быть этим в общем классе, примерно так:

static class ConfiguredSub {
    public static T For<T>(Action<T> config) where T : class {
        var c = Substitute.For<T>();
        config(c);
        return c;
    }
}

Проблема, с которой я столкнулся в моем другом ответе, заключалась в том, что если вы вложили Returns, NSubstitute запутается и начнет генерировать исключения. Оказывается, как описано @David здесь, вы можете передать Func, чтобы отложить выполнение и обойти эту проблему. Если вы объедините эти две вещи, вы получите что-то очень близкое к тому, что вам нужно.

[Test]
public void Initialize_BuildsCorrectRibbonTree() {

    var commands = Substitute.For<IRibbonCommandsProvider>();
    commands.GetRibbonCommands().Returns(x => new[] {    
        ConfiguredSub.For<IRibbonCommand>(subst => 
                                      { 
                                          subst.Tab.Returns("Tab1"); 
                                          subst.Group.Returns("Group1"); 
                                          subst.Name.Returns("Name1"); 
                                      }),
        ConfiguredSub.For<IRibbonCommand>(subst => 
                                      { 
                                          subst.Tab.Returns("Tab1"); 
                                          subst.Group.Returns("Group1"); 
                                          subst.Name.Returns("Name2"); 
                                      }),
        ConfiguredSub.For<IRibbonCommand>(subst => 
                                      { 
                                          subst.Tab.Returns("Tab2"); 
                                          subst.Group.Returns("Group1"); 
                                          subst.Name.Returns("Name3"); 
                                      }),
        ConfiguredSub.For<IRibbonCommand>(subst => 
                                      { 
                                          subst.Tab.Returns("Tab2"); 
                                          subst.Group.Returns("Group1"); 
                                          subst.Name.Returns("Name4"); 
                                      })
    });

    // ...

}