Как написать единичный тест [дубликат]

Я знаю, что это старый вопрос, но ни одно из этих решений не разработано для меня. Я закончил использовать offset (). Top, чтобы получить желаемые результаты. Вот что я использовал для мягкой прокрутки экрана до последнего сообщения в приложении для чата:

$("#html, body").stop().animate({
     scrollTop: $("#last-message").offset().top
}, 2000);

Надеюсь, это поможет кому-то другому.

710
задан MattSayar 24 March 2016 в 18:25
поделиться

31 ответ

Stub

Я считаю, что самое большое различие заключается в том, что заглушка, которую вы уже написали с предопределенным поведением. Таким образом, у вас будет класс, который реализует зависимость (абстрактный класс или интерфейс, скорее всего), которые вы притворяетесь для целей тестирования, и методы будут просто пропущены с заданными ответами. Они не сделали бы ничего необычного, и вы бы уже написали закодированный код для него вне вашего теста.

Mock

Макет - это то, что в рамках вашего теста вы должны с вашими ожиданиями. Макет не настроен заранее, так что у вас есть код, который делает это в вашем тесте. Mocks в пути определяется во время выполнения, так как код, который устанавливает ожидания, должен выполняться до того, как они что-либо сделают.

Разница

Тесты, написанные с помощью mocks, обычно следуют шаблону initialize -> set expectations -> exercise -> verify тестирование. Хотя предварительно написанная заглушка будет следовать за initialize -> exercise -> verify.

Сходство

Цель состоит в том, чтобы исключить тестирование всех зависимостей класса или функции, чтобы ваши тесты были более целенаправленными и более простыми в том, что они пытаются доказать.

533
ответ дан 030 17 August 2018 в 17:42
поделиться

Я наткнулся на эту интересную статью от UncleBob The Little Mocker . Это объясняет всю терминологию очень легко понять, поэтому она полезна для новичков. Статья Мартина Фаулерса читается специально для начинающих, таких как я.

3
ответ дан A.I 17 August 2018 в 17:42
поделиться

Я думаю, что самое важное различие между ними - их намерения.

Позвольте мне объяснить это в WHY stub vs. WHY mock

Предположим, что я пишу тестовый код для

[x6]

twitter_api.stub(:public_timeline).and_return(public_timeline_array)
client_ui.should_receive(:insert_timeline_above).with(public_timeline_array)
controller.refresh_public_timeline
  • STUB: Сетевое подключение к API twitter очень медленное, что замедляет мой тест. Я знаю, что он вернет временные рамки, поэтому я сделал stub, имитирующий HTTP twitter API, так что мой тест будет работать очень быстро, и я могу запустить тест, даже если я в автономном режиме.
  • MOCK: Я еще не написал ни одного из моих методов пользовательского интерфейса, и я не уверен, какие методы мне нужно написать для моего объекта ui. Я надеюсь узнать, как мой контроллер будет взаимодействовать с моим объектом ui, написав тестовый код.

Написав mock, вы обнаружите, что отношения сотрудничества с объектами проверяются, когда ожидание выполняется, тогда как только stub имитирует поведение объекта.

Предлагаю прочитать эту статью, если вы хотите узнать больше о mocks: http://jmock.org/oopsla2004.pdf

17
ответ дан Adam Parkin 17 August 2018 в 17:42
поделиться
  • 1
    Это пример ужасного кода. – aarkerio 11 February 2014 в 20:10
  • 2
    Я думаю, что у вас есть правильная идея, но Диллон Кирнс объяснил это намного яснее. – O'Rooney 25 November 2014 в 21:56

См. ниже пример mocks vs stub с использованием C # и рамки Moq. Moq не имеет специального ключевого слова для Stub, но вы также можете использовать Mock-объект для создания заглушек.

namespace UnitTestProject2
{
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using Moq;
    [TestClass]
    public class UnitTest1
    {
        /// <summary>
        /// Test using Mock to Verify that GetNameWithPrefix method calls Repository GetName method "once" when Id is greater than Zero
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsTwelve_GetNameCalledOnce()
        {
            // Arrange 
            var mockEntityRepository = new Mock<IEntityRepository>();
            mockEntityRepository.Setup(m => m.GetName(It.IsAny<int>()));

            var entity = new EntityClass(mockEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(12);
            // Assert
            mockEntityRepository.Verify(m => m.GetName(It.IsAny<int>()), Times.Once);
        }
        /// <summary>
        /// Test using Mock to Verify that GetNameWithPrefix method doesn't call Repository GetName method when Id is Zero
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsZero_GetNameNeverCalled()
        {
            // Arrange 
            var mockEntityRepository = new Mock<IEntityRepository>();
            mockEntityRepository.Setup(m => m.GetName(It.IsAny<int>()));
            var entity = new EntityClass(mockEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(0);
            // Assert
            mockEntityRepository.Verify(m => m.GetName(It.IsAny<int>()), Times.Never);
        }
        /// <summary>
        /// Test using Stub to Verify that GetNameWithPrefix method returns Name with a Prefix
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsTwelve_ReturnsNameWithPrefix()
        {
            // Arrange 
            var stubEntityRepository = new Mock<IEntityRepository>();
            stubEntityRepository.Setup(m => m.GetName(It.IsAny<int>()))
                .Returns("Stub");
            const string EXPECTED_NAME_WITH_PREFIX = "Mr. Stub";
            var entity = new EntityClass(stubEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(12);
            // Assert
            Assert.AreEqual(EXPECTED_NAME_WITH_PREFIX, name);
        }
    }
    public class EntityClass
    {
        private IEntityRepository _entityRepository;
        public EntityClass(IEntityRepository entityRepository)
        {
            this._entityRepository = entityRepository;
        }
        public string Name { get; set; }
        public string GetNameWithPrefix(int id)
        {
            string name = string.Empty;
            if (id > 0)
            {
                name = this._entityRepository.GetName(id);
            }
            return "Mr. " + name;
        }
    }
    public interface IEntityRepository
    {
        string GetName(int id);
    }
    public class EntityRepository:IEntityRepository
    {
        public string GetName(int id)
        {
            // Code to connect to DB and get name based on Id
            return "NameFromDb";
        }
    }
}
3
ответ дан Adarsh Shah 17 August 2018 в 17:42
поделиться

следующее - мое понимание ...

  • , если вы создаете тестовые объекты локально и кормите свою локальную службу этим, вы используете макет объекта. это даст тест на метод, который вы реализовали в своей локальной службе. он используется для проверки поведения
  • , когда вы получаете тестовые данные от реального поставщика услуг, хотя из тестовой версии интерфейса и получения тестовой версии объекта вы работаете с заглушками, которые могут иметь заглушки логику для принятия определенного ввода и предоставления соответствующего результата, чтобы помочь вам выполнить проверку состояния ...
0
ответ дан Andy Lin 17 August 2018 в 17:42
поделиться

Этот слайд объясняет основные различия очень хорошо.

* Из CSE 403 Лекция 16, Вашингтонский университет (слайд, созданный «Marty Stepp «)

8
ответ дан Aviram Fireberger 17 August 2018 в 17:42
поделиться

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

Stub - заглушка является действительной полной работой реализация метода или функции (или группы методов и функций, например, в случае закодированного класса), который имеет идентичный интерфейс / подпись для метода, функции или группы методов и функций, для которых он выполняется. Зарезервированная реализация, как правило, будет делать только то, что приемлемо в контексте единичного теста, а это значит, что он не будет выполнять IO, например, при одновременном подражании поведению вещи, которую он забивает.

0
ответ дан Didier A. 17 August 2018 в 17:42
поделиться

В курсе codeschool.com , Rails Testing для Zombies , они дают это определение терминов:

Stub

< blockquote>

Для замены метода кодом, возвращающим заданный результат.

Mock

Заглушка с утверждением о вызове метода.

Итак, как сказал Шон Копенгавер в своем ответе, разница в том, что издеваются над ожиданиями (т. е. делают утверждения, о том, вызваны ли они или как они вызваны).

153
ответ дан Dillon Kearns 17 August 2018 в 17:42
поделиться
  • 1
    В дополнение к сообщению Dillon, подумайте об этом, у вас есть класс под названием «MakeACake», которые берут несколько библиотек: Молоко, Яйца, Сахар, Духовка. – aarkerio 11 February 2014 в 21:37

Справа от статьи Mock Roles, а не Objects , разработчиками jMock:

Stub - это фиктивные реализации производственного кода, которые возвращают законченные результаты. Mock Objects действуют как заглушки, но также включают в себя утверждения для взаимодействия взаимодействий целевого объекта со своими соседями.

Итак, основными отличиями являются:

  • ожидания, установленные на заглушках, обычно являются общими, в то время как ожидания, установленные на mocks, могут быть более «умными» (например, вернуть это при первом вызове, это на втором и т. д.).
  • заглушки в основном используются для настройки косвенных входы SUT, в то время как макеты могут использоваться для тестирования как косвенных входов, так и косвенных выходов SUT.

Подводя итог, также пытаясь разогнать путаницу из статьи Фаулера title: mocks - это заглушки, но они не только заглушки.

6
ответ дан Dimos 17 August 2018 в 17:42
поделиться
  • 1
    я думаю, что вы правы, но именно поэтому статья Фаулера сбивает с толку, название статьи - «Mocks Are not Stubs» ... но они ARE ?! _ (ツ) _ / ¯ – stonedauwg 7 December 2016 в 17:14
  • 2
    @stonedauwg, действительно, я отредактировал свой пост, чтобы включить ваш каламбур и разъяснения. Надеюсь, это поможет немного больше. – Dimos 7 September 2017 в 19:03
  • 3
    @stonedauwg, макет не является заглушкой, подобно прямоугольнику, не квадрату. :) – seanriordan08 8 November 2017 в 20:07

Штыри используются для методов с ожидаемым возвращаемым значением, которое вы настраиваете в своем тесте. Mocks используются для методов void, которые проверяются в Assert, которые они вызывают.

0
ответ дан Elisabeth 17 August 2018 в 17:42
поделиться

Если вы сравниваете его с отладкой:

Stub похож на то, чтобы убедиться, что метод возвращает правильное значение

. Mock похож на фактически вступающий в метод и убедившись, что все внутри правильное значение перед возвратом правильного значения.

13
ответ дан happygilmore 17 August 2018 в 17:42
поделиться

Штук - простой поддельный объект. Это просто гарантирует, что тест проходит гладко. Макет более умный. Вы подтверждаете, что ваш тест проходит через него.

230
ответ дан Honey 17 August 2018 в 17:42
поделиться
  • 1
    Я думаю, что это самое кратким и точным ответом. Еда на вынос: макет IS-A. stackoverflow.com/a/17810004/2288628 - это более длинная версия этого ответа. – PoweredByRice 6 October 2014 в 01:12
  • 2
    Я не думаю, что макет - это заглушка. Mocks используются для утверждения и никогда не должны возвращать данные, заглушки используются для возврата данных и никогда не должны утверждать. – dave1010 3 August 2015 в 14:00
  • 3
    @ dave1010 Mocks наиболее определенно может вернуть данные или даже выбросить исключение. Они должны делать это в ответ на переданные им параметры. – Trenton 17 August 2015 в 18:33
  • 4
    @trenton, если объект возвращается или выбрасывается на основе данных, переданных тогда, это подделка , а не макет. Stub проверяет, как ваш SUT обрабатывает получение сообщений, извиняет, как ваши сообщения SUT отправляют . Смешивание 2, вероятно, приведет к плохому дизайну OO. – dave1010 24 August 2015 в 07:41
  • 5
    Можете ли вы привести пример кода STUB и макет (с минимальными строками кода)? благодаря – vsync 9 November 2015 в 19:48

много действительных ответов там, но я думаю, стоит упомянуть эту форму дядя боб: https://8thlight.com/blog/uncle-bob/2014/05/14/TheLittleMocker.html

лучшее объяснение с примерами!

2
ответ дан Kasper 17 August 2018 в 17:42
поделиться

Штыри не терпят неудачу в ваших тестах, макет может.

104
ответ дан mk_ 17 August 2018 в 17:42
поделиться
  • 1
    И я думаю, что это хорошо, вы знаете, что после того, как тесты будут иметь такое же поведение после рефакторинга. – RodriKing 23 May 2018 в 11:25

Подделка fake - это общий термин, который может использоваться для описания либо заглушки, либо макетного объекта (рукописного или иного), потому что оба они выглядят как реальный объект.

]

Является ли подделка заглушкой или макетом, зависит от того, как она используется в текущем тесте. Если он используется для проверки взаимодействия (утверждается против), это макет объекта. В противном случае это заглушка.

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

Что означает тестовый запуск? Например, в нижеприведенном коде:

 public void Analyze(string filename)
        {
            if(filename.Length<8)
            {
                try
                {
                    errorService.LogError("long file entered named:" + filename);
                }
                catch (Exception e)
                {
                    mailService.SendEMail("admin@hotmail.com", "ErrorOnWebService", "someerror");
                }
            }
        }

Вы хотите протестировать метод mailService.SendEMail () , чтобы сделать это, чтобы вы могли имитировать исключение в вашем тестовом методе, так что вы просто необходимо создать класс Fake Stub errorService для имитации этого результата, тогда ваш тестовый код сможет протестировать метод mailService.SendEMail (). Как вы видите, вам нужно смоделировать результат, который является результатом другого класса External Dependency ErrorService.

8
ответ дан Mustafa Ekici 17 August 2018 в 17:42
поделиться

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

unit test -> stub

unit test -> unit -> stub

unit test утверждает результаты и состояние устройства

. Сначала тестовый модуль создает заглушку и настраивает возвращаемые значения. Затем модульный тест создает блок и устанавливает на него заглушку. Теперь модульный тест вызывает устройство, которое, в свою очередь, вызывает заглушку. Наконец, модульный тест делает утверждения о результатах вызова метода на единицу.

Mock похож на заглушку, только он также имеет методы, позволяющие определить, какие методы вызывают в Mock. Используя макет, можно, таким образом, проверить, правильно ли устройство может обрабатывать различные возвращаемые значения, а также если устройство правильно использует соавтор. Например, вы не можете увидеть значение, возвращаемое с объекта dao, если данные были прочитаны из базы данных с помощью Statement или PreparedStatement. Также вы не видите, был ли вызван метод connection.close () перед возвратом значения. Это возможно с издевательствами. Другими словами, mocks позволяет тестировать полное взаимодействие блоков с сотрудником. Не только методы соавтора, возвращающие значения, используемые устройством. Использование макета в единичном тесте может быть выражено следующим образом:

unit test -> mock

unit test -> unit -> mock

unit test утверждает, что результат и состояние единицы

unit test подтверждают методы, называемые mock

Подробнее >> Здесь

1
ответ дан M_ Fa 17 August 2018 в 17:42
поделиться

Мне нравится объяснение, высказанное Роем Ошеровым [видео ссылка] .

Каждый созданный класс или объект является Fake. Это макет, если вы проверяете на него вызовы. В противном случае это заглушка.

10
ответ дан nitishagar 17 August 2018 в 17:42
поделиться

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

  • Stub: фиктивный кусок кода, который позволяет выполнить пробный запуск, но вам все равно, что с ним происходит.
  • Mock: фиктивная часть кода, которую вы VERIFY вызывают правильно как часть теста.
  • Spy: фиктивный код, который перехватывает некоторые вызовы на реальный фрагмент код, позволяющий проверять вызовы без замены всего исходного объекта.
9
ответ дан O'Rooney 17 August 2018 в 17:42
поделиться
  • 1
    Хороший ответ. Макет звучит довольно похоже на Шпион, хотя, основываясь на вашем определении. Было бы неплохо, если бы вы обновили свой ответ и включили еще несколько двойных тестов. – Rowan Gontier 4 May 2018 в 09:02
  • 2
    Я не слышал о Шпионах, когда писал этот ответ. – O'Rooney 7 May 2018 в 01:52

Я думаю, что самый простой и ясный ответ на этот вопрос дан Роем Ошеровым в его книге Искусство модульного тестирования (стр. 85)

Самый простой способ сказать, что мы имеем дело с заглушкой, - это заметить, что заглушка никогда не сможет пропустить тест. Утверждения, что использование тестов всегда противоречит тестируемому классу.

С другой стороны, тест будет использовать макетный объект, чтобы проверить, не прошел тест или нет. [...]

Опять же, макет-объект - это объект, который мы используем, чтобы проверить, не прошел тест или нет.

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

25
ответ дан olibre 17 August 2018 в 17:42
поделиться

Штук - это пустая функция, которая используется во избежание необработанных исключений во время тестов:

function foo(){}

Макет - это искусственная функция, которая используется для предотвращения зависимостей ОС, окружения или оборудования во время тестов:

function foo(bar){ window = this; return window.toString(bar); }

В терминах утверждений и состояний:

2
ответ дан Paul Sweatte 17 August 2018 в 17:42
поделиться
  • 1
    +1 для добавления шпионов в глоссарий. Кроме того, я думаю, вы имеете в виду & quot; Шпионы настраиваются как mocks & quot; не "Шпионы устанавливаются как заглушки" – Sameh Deabes 23 November 2015 в 22:48

Точка проверки на наличие заглушки и макета:

  • Штук - это фиктивная реализация, выполняемая пользователем статическим способом, означающая, что в Stub записывается код реализации. Таким образом, он не может обрабатывать определение сервиса и динамическое состояние. Обычно это выполняется в рамках JUnit без использования насмешливой структуры.
  • Mock - также фиктивная реализация, но ее реализация выполнена динамически, используя Mocking frameworks, такие как Mockito. Таким образом, мы можем обрабатывать определение условий и услуг как динамические способы, т. Е. Mocks может динамически создаваться из кода во время выполнения. Таким образом, используя mock, мы можем динамически выполнять Stub.
1
ответ дан Premraj 17 August 2018 в 17:42
поделиться

Быть предельно ясным и практичным:

Stub: класс или объект, который реализует методы класса / объекта, которые будут подделаны, и всегда возвращает то, что вы хотите.

Пример в JavaScript:

var Stub = {
   method_a: function(param_a, param_b){
      return 'This is an static result';
   }
}

Mock: то же самое, что и заглушка, но добавляет некоторую логику, которая «проверяет» при вызове метода, поэтому вы можете быть уверены, что некоторая реализация вызывает этот метод.

Как говорит @mLevan, представьте, что вы тестируете класс регистрации пользователя. После вызова Save, он должен вызвать SendConfirmationEmail.

Очень глупый код Пример:

var Mock = {
   calls: {
      method_a: 0
   }

   method_a: function(param_a, param_b){
     this.method_a++; 
     console.log('Mock.method_a its been called!');
   }
}
10
ответ дан R01010010 17 August 2018 в 17:42
поделиться

Я использовал примеры python в своем ответе, чтобы проиллюстрировать различия.

Stub - Stubbing - это технология разработки программного обеспечения, используемая для реализации методов классов на раннем этапе жизненного цикла разработки. Они обычно используются как заполнители для реализации известного интерфейса, где интерфейс завершен или известен, но реализация еще не известна или не доработана. Вы начинаете с заглушек, что просто означает, что вы только записываете определение функции вниз и оставляете фактический код позже. Преимущество в том, что вы не забудете методы, и вы можете продолжать думать о своем дизайне, видя его в коде. Вы также можете заставить свою заглушку вернуть статический ответ, чтобы ответ мог быть использован другими частями вашего кода немедленно. Объекты-заглушки предоставляют действительный ответ, но он статичен независимо от того, какой вход вы проходите, вы всегда получите тот же ответ:

class Foo(object):
    def bar1(self):
        pass

    def bar2(self):
        #or ...
        raise NotImplementedError

    def bar3(self):
        #or return dummy data
        return "Dummy Data"

Макетные объекты используются в ложных тестовых случаях, они проверяют, что определенные методы вызываются на этих объектах. Макетные объекты - это моделируемые объекты, которые управляют действиями реальных объектов. Обычно вы создаете макет объекта для проверки поведения какого-либо другого объекта. Mocks позволяет имитировать ресурсы, которые либо недоступны, либо слишком громоздки для модульного тестирования.

mymodule.py:

import os
import os.path

def rm(filename):
    if os.path.isfile(filename):
        os.remove(filename)

test.py:

from mymodule import rm
import mock
import unittest

class RmTestCase(unittest.TestCase):
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os):
        rm("any path")
        # test that rm called os.remove with the right parameters
        mock_os.remove.assert_called_with("any path")

if __name__ == '__main__':
    unittest.main()

Это очень простой пример, который просто запускает rm и утверждает параметр, с которым он был вызван. Вы можете использовать mock с объектами, а не только функциями, как показано здесь, и вы также можете вернуть значение, чтобы макет мог использоваться для замены заглушки для тестирования.

Подробнее о unittest.mock , примечание в python 2.x mock не входит в unittest, но является загружаемым модулем, который можно загрузить через pip (pip install mock).

Я также прочитал «The Art of Unit Testing «Роем Ошеровым, и я думаю, было бы здорово, если бы подобная книга была написана с использованием примеров Python и Python. Если кто-нибудь знает такую ​​книгу, пожалуйста, разделите. Приветствия:)

2
ответ дан radtek 17 August 2018 в 17:42
поделиться

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

  • Манекен - просто фиктивные значения, чтобы удовлетворить API. Пример : Если вы тестируете метод класса, который требует много обязательных параметров в конструкторе, который не имеет эффекта в вашем тесте, тогда вы можете создать фиктивные объекты для цель создания новых экземпляров класса.
  • Fake - создать тестовую реализацию класса, который может иметь зависимость от некоторой внешней инфраструктуры. (Хорошая практика заключается в том, что ваш модульный тест НЕ взаимодействует с внешней инфраструктурой.) Пример : Создайте поддельную реализацию для доступа к базе данных, замените ее на коллекцию in-memory.
  • Методы переопределения заглушек для возврата жестко заданных значений, также называемых state-based. Пример : ваш тестовый класс зависит от метода Calculate(), который занимает 5 минут. Вместо того, чтобы ждать 5 минут, вы можете заменить его реальную реализацию заглушкой, которая возвращает жестко заданные значения; занимая лишь небольшую часть времени.
  • Mock - очень похоже на Stub, но interaction-based, а не на состояние. Это означает, что вы не ожидаете, что Mock вернет некоторое значение, но предположим, что выполняется конкретный порядок вызовов методов. Пример. Вы тестируете класс регистрации пользователя. После вызова Save он должен вызвать SendConfirmationEmail.

Stubs и Mocks на самом деле являются подтипами Mock, и реальная реализация swap с тестовой реализацией, но по разным конкретным причинам.

163
ответ дан Rafael Espinoza 17 August 2018 в 17:42
поделиться
  • 1
    Хороший ответ! Любой конкретный ресурс, который вы рекомендуете для погружения глубже? – dotslash 7 November 2015 в 10:37
  • 2
    ИМО это лучший ответ, поскольку он дает четкие и краткие примеры. Просто, что он не цитирует «Фаулер» и описывает абстрактные идеи. – James 22 March 2017 в 14:45
  • 3
    Лучший ответ, стыд, я почти не видел. – oche 8 December 2017 в 00:11
  • Stub vs. Mocks Stubs предоставляют конкретные ответы на вызовы методов ex: myStubbedService.getValues ​​() просто возвращает строку, требуемую тестируемым кодом, используемым тестируемым кодом для изоляции, не может не выполнить проверку ex: myStubbedService.getValues () просто возвращает заштрихованное значение, часто реализующее абстрактные методы. Mocks «superset» of stub; может утверждать, что определенные методы называются ex: убедитесь, что myMockedService.getValues ​​() вызывается только один раз, используемый для проверки поведения тестируемого кода, может завершиться с ошибкой ex: убедитесь, что myMockedService.getValues ​​() был вызван один раз; проверка завершилась неудачно, поскольку myMockedService.getValues ​​() не был вызван моим проверенным кодом, часто издевается над интерфейсами
5
ответ дан Relu Mesaros 17 August 2018 в 17:42
поделиться

Mock - это просто тестирование поведения, следя за тем, чтобы вызывались определенные методы.

Что вы подразумеваете под Apple?

17
ответ дан roufamatic 17 August 2018 в 17:42
поделиться

Предисловие

Существует несколько определений объектов, которые не являются реальными. Общий термин - тест двойной. Ссылка

Согласно статья Мартина Фаулера :

  • Объекты Dummy передаются, но никогда не используются. Обычно они используются для заполнения списков параметров.
  • Фальшивые объекты фактически имеют рабочие реализации, но обычно используют некоторый ярлык, который делает их непригодными для производства (в качестве примера используется база данных с памятью).
  • Штукеры предоставляют консервированные ответы на вызовы, сделанные во время теста, обычно вообще не реагируют на что-либо вне того, что запрограммировано для теста. Stubs также может записывать информацию о вызовах, таких как заглушка шлюза электронной почты, которая запоминает отправленные сообщения, или, может быть, только то, сколько сообщений он отправил.
  • Mocks - это то, о чем мы говорим здесь: объекты, запрограммированные ожиданиями, которые формируют спецификацию ожидаемых вызовов.

Стиль

Mocks vs Stubs = Поведенческое тестирование vs State тестирование

Принцип

Согласно принципу Проверяйте только одну вещь на тест , в одном тесте может быть несколько заглушек, но обычно есть только один mock

Жизненный цикл

Жизненный цикл тестирования с заглушками:

  1. Настройка - подготовить тестируемый объект и его коллабораторы.
  2. Упражнение - проверить функциональность.
  3. Проверить состояние - использовать утверждения для проверки состояния объекта.
  4. Teardown - очистка ресурсов.

Test жизненный цикл с mocks:

  1. Данные установки - Подготовьте объект, который bein g
  2. Ожидания настройки - Подготовьте ожидания в макете, который используется первичным объектом.
  3. Упражнение - проверьте функциональность.
  4. Проверьте ожидания - убедитесь, что правильные методы были вызваны в mock.
  5. Проверить состояние - использовать утверждения для проверки состояния объекта.
  6. Teardown - очистить ресурсы.

Резюме

Оба теста mocks и stubs дают ответ на вопрос: Каков результат?

Тестирование с помощью mocks также интересует: How результат был достигнут?

649
ответ дан Ryszard Dżegan 17 August 2018 в 17:42
поделиться
  • 1
    Подождите, издевается также возвратные консервированные ответы? Потому что иначе они отвечают на вопрос? – wolfdawn 7 May 2017 в 15:59
  • 2
    Из того, что вы написали, я могу сказать, что mocks = stubs + ожидания и проверки, потому что mocks & quot; предоставляют консервированные ответы на вызовы, сделанные во время теста, обычно вообще не реагируют на что-либо вне того, что запрограммировано для теста & quot; (аналогично заглушкам). И пример, который Фаулер показал как пример заглушки, на самом деле является примером шпиона! Это означает, что макет - это заглушка, а шпион - заглушка. А заглушка - это всего лишь объект, который имеет несколько методов работы. Это также объясняет, почему Mockito не рекомендовал метод stub (). – kolobok 8 July 2018 в 20:35

Штук - это поддельный объект, созданный для целей тестирования. Макет - это заглушка, которая регистрирует, действительно ли ожидались ожидаемые вызовы.

2
ответ дан simon.denel 17 August 2018 в 17:42
поделиться

Stub помогает нам запустить тест. Как? Он дает значения, которые помогают запустить тест. Эти значения сами по себе не являются реальными, и мы создали эти значения только для запуска теста. Например, мы создаем HashMap, чтобы дать нам значения, похожие на значения в таблице базы данных. Поэтому вместо прямого взаимодействия с базой данных мы взаимодействуем с Hashmap.

Mock - это поддельный объект, который запускает тест. где мы положим assert.

2
ответ дан user965884 17 August 2018 в 17:42
поделиться
  • 1
    «Поэтому вместо прямого взаимодействия с базой данных мы взаимодействуем с Hashmap». ... потому что whe не успел закодировать модуль базы данных, и мы не смогли запустить тестовый код без использования заглушки. В противном случае тот же Hasmap был бы насмешкой! правильно? – Boris Däppen 24 October 2015 в 11:39
0
ответ дан Alireza Rahmani 6 September 2018 в 11:27
поделиться
Другие вопросы по тегам:

Похожие вопросы: