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

expect(service.arrange({sits: goodValue})).to.match({succeed: {id: notEmpty(string())}});

const Schema = {
    arrange: ...,
    arrangeResult: ...,
}


@validate(Schema.arrange)
@useAudit(Schema.arrange, Schema.arranged)
@useEvent(Schema.arrangeResult)
@presenter(Schema.arrangeResult)
arrange(request: typeof Schema.arrange): Result<[Error, typeof Schema.arrangeResult]> {
...
}

P>expect(service.arrange({sits: goodValue})).to.match({succeed: {id: notEmpty(string())}});

tryAcceptComposition :: Reservation -> IO (Maybe Int)
tryAcceptComposition reservation = runMaybeT $ 
liftIO (DB.readReservations connectionString $ date reservation)
>>= MaybeT . return . flip (tryAccept 10) reservation
>>= liftIO . DB.createReservation connectionString

	Не понял ты о чём. Я о "главном герое" статьи, вот этом классе:

P> Вы по прежнему думаете, что моки избавляют от интеграционных тестов. Ровно наоборот — сверх обычных юнитов вам надо понаписывать моки на все кейсы, и всё равно придется писать интеграционные тесты.

expect(new class().tryTryAcceptComposition(parameter)).to.eq(value);

Ну так внедрение зависимостей DI+CI это и есть плоская иерархия.

Expectation failed: ControllerX tryAccept to have metadata {...}

const tryAccept = Metadata.from(ControllerX, 'tryAccept')

expext(tryAccept).metadata.to.match({...})

P>При чем здесь сайд эффекты?

P>expect(new class().tryTryAcceptComposition(parameter)).to.eq(value);
P>

tryAcceptComposition :: Reservation -> IO (Maybe Int)
tryAcceptComposition reservation = runMaybeT $ 
  liftIO (DB.readReservations connectionString $ date reservation)
  >>= MaybeT . return . flip (tryAccept 10) reservation
  >>= liftIO . DB.createReservation connectionString

P>Expectation failed: ControllerX tryAccept to have metadata {...}
P>

P>const tryAccept = Metadata.from(ControllerX, 'tryAccept')
P>expext(tryAccept).metadata.to.match({...})
P>

controllerX.tryAccept(...)
verify(metadata).to.match(...);

const main = require('./app');
const crypto = require('crypto');

jest.mock('crypto', () => {
  return {
    createHmac: jest.fn().mockReturnThis(),
    update: jest.fn().mockReturnThis(),
    digest: jest.fn(() => '123'),
  };
});

describe('64386858', () => {
  it('should pass', () => {
    const logSpy = jest.spyOn(console, 'log');
    main();
    expect(crypto.createHmac).toBeCalledWith('sha256', 'API_TOKEN');
    expect(crypto.update).toBeCalledWith(JSON.stringify({}));
    expect(crypto.digest).toBeCalledWith('hex');
    expect(logSpy).toBeCalledWith('verified successfully. Implement next logic');
    logSpy.mockRestore();
  });
});

P>>expect(new class().tryTryAcceptComposition(parameter)).to.eq(value);
P>>

curl -X POST -H "Content-Type: application/json" -d '{<резервирование>}' http://localhost:3000/api/v3/reservation

curl -X POST -H "Content-Type: application/json" -d '{<резервирование>}' http://localhost:3000/api/v3/reservation

P>>Expectation failed: ControllerX tryAccept to have metadata {...}
P>>

P>>const tryAccept = Metadata.from(ControllerX, 'tryAccept')
P>>expext(tryAccept).metadata.to.match({...})
P>>

·>controllerX.tryAccept(...)
·>verify(metadata).to.match(...);
·>

P>    expect(crypto.createHmac).toBeCalledWith('sha256', 'API_TOKEN');

Result doSomething(Request r) {
  if(validateThing(r.part1)) {
    wroom(r.zcxv);
    if(validateThing(r.part2) {
      return NiceResult(r.a, r.b);
    } else {
      foBarBaz();
      return SoSoResult(meh(r));
    }
  } else {
    taramparam(r.aaa);
    return NoNoNo(zzzz(r));
  }
}

P>>>expect(new class().tryTryAcceptComposition(parameter)).to.eq(value);
P>>>

var db = new Db(connectionString);
var repo = new Repo(db);
var bl = new BlService(repo);
var ctl = new Controller(bl);
var server = new Server(port);
server.handle("/path", ctl);
server.start();

P>Я думал вы собираетесь замокать все зависимости контроллера, но вы похоже бьете все рекорды

P>curl -X POST -H "Content-Type: application/json" -d '{<резервирование>}' http://localhost:3000/api/v3/reservation
P>

P>curl -X POST -H "Content-Type: application/json" -d '{<резервирование>}' http://localhost:3000/api/v3/reservation
P>

P>>>Expectation failed: ControllerX tryAccept to have metadata {...}
P>>>

P>>>const tryAccept = Metadata.from(ControllerX, 'tryAccept')
P>>>expext(tryAccept).metadata.to.match({...})
P>>>

P>·>controllerX.tryAccept(...)
P>·>verify(metadata).to.match(...);
P>·>

P>Ну то есть tryAccept что в вашем тесте это никакой не конкретный метод?

P>>    expect(crypto.createHmac).toBeCalledWith('sha256', 'API_TOKEN');
·>

const stream = Stream.from({Sample.id, Sample.version, Sample.content});

expect(Token.from(stream, Sample.secret)).to.eq(Sample.sha256);

·>Result doSomething(Request r) {
·>  if(validateThing(r.part1)) {
·>    wroom(r.zcxv);
·>    if(validateThing(r.part2) {
·>      return NiceResult(r.a, r.b);
·>    } else {
·>      foBarBaz();
·>      return SoSoResult(meh(r));
·>    }
·>  } else {
·>    taramparam(r.aaa);
·>    return NoNoNo(zzzz(r));
·>  }
·>}
·>

     foBarBaz(); <- здесь у вас сайд эффекты
     return SoSoResult(meh(r));

     const toDo = calculate(); // покрыто юнит тестами, т.к. простые вычисления без сайд эффектов
     
     return SoSoChanges(todo);

·>var db = new Db(connectionString);
·>var repo = new Repo(db);
·>var bl = new BlService(repo);
·>var ctl = new Controller(bl);
·>var server = new Server(port);
·>server.handle("/path", ctl);
·>server.start();
·>

const getUser = repository.getUser(id); // покрыто юнит тестом
const oldUser = db.execute(getUser);
const newUser = bl.modifyUser(oldUser); // покрыто юнит тестом
const updateUser = repository.updateUser(oldUser, newUser); // покрыто юнит тестом
const updatedUser = db.execute(updateUser); 

return updatedUser;

handler(id, ctx, metadata) {
    const useCase = UpdateUser.from(ctx); // покрыто юнит тестом
    const serializer = Serializer.from(ctx, metadata) // покрыто юнит тестом
    const result = userCase.invoke(id); 

    return serializer.toResponse(result); // покрыто юнит тестом
}

P>>Я думал вы собираетесь замокать все зависимости контроллера, но вы похоже бьете все рекорды

P>>curl -X POST -H "Content-Type: application/json" -d '{<резервирование>}' http://localhost:3000/api/v3/reservation
P>>

@Test void shouldVerify()
{
  // deps
  var console = mock(Console.class);
  var crypto = mock(Crypto.class);
  var hmac = mock(Hmac.class);
  // set up
  when(crypto.createHmac("sha256", "API_TOKEN")).thenReturn(hmac);//factory pattern
  when(hmac.digest("hex")).thenReturn("123");
  //sut
  var app = new App(console, crypto);// dependency injection
  app.main();
  //verify
  verify(hmac).update("{}");
  verify(console).log("verified successfully. Implement next logic");
  //тут ещё не хватает проверок, что "123" где-то правильно использовалось в результатах.
}

P>const stream = Stream.from({Sample.id, Sample.version, Sample.content});
P>expect(Token.from(stream, Sample.secret)).to.eq(Sample.sha256);
P>

class UserController {
  Response update(Request r) {
    var id = extractId(r);
    var data = extractData(r);
    var result = bl.modifyUser(id, data);
    return result.isSuccess ? Response(r.correlationId, prepare(result)) : Failure("sorry");
  }
}

P> прямых — одна, а непрямых — все дочерние от того же репозитория

P>> прямых — одна, а непрямых — все дочерние от того же репозитория

  @Operation({method: 'PATCH', route:'/users', summary: 'modify user', responseType: User, })
  modify(@Req() req: RawBodyRequest<User>): Promise<User> {
  ...
  }

http_handler(request):
  v1, v2, v3 = parse_and_validate(request)  // pure
  result = do_logic(v1, v2, v3)
  return serialize(result)  // pure

do_logic(v1, v2, v3):
  // работаем с БД
  p = repo.get(v1)

  // получаем дополнительные данные из внешнего источника
  if что-то(p):  
    p2 = external_service.request(v2)
    p = update(p, p2)

  // отправляем в БД и условную кафку
  if что-то(p):   
    repo.put(v3)
    another_external_service.send(v3)

  result = serialize(p)  // pure
  return result

Mocks are objects pre-programmed with expectations which form a specification of the calls they are expected to receive

class Logic(v1, v2, v3):  // параметры-значения в конструкторе
  def run(load, load2, commit): // эффекты-зависимости здесь, эдакий аналог импорта
     p = ctx.load(self.v1) 

     if что-то(p):  
       p2 = ctx.load2(self.v2) // load2 - абстракция так себе, должно быть хорошее имя
       p = update(p, p2)

     if что-то(p):   
       ctx.commit(self.v3)
      
     return p

def do_logic(v1,v2,v3):
  l = Logic(v1,v2,v3)
  p = l.run(
    load = ..., repo  // здесь и ниже хватит простой лямбды
    load2 = ...., svc
    commit = ..., repo+kafka // как вариант, для кафки можно протащить доп. имя, например event
  );

  Return serialize(p)

do_logic(v1, v2, v3):
  p = repo.get(v1)

  if что-то(p):  
    arg = repo.get(v2) // появился доп параметр, который надо вытащить из бд
    p2 = external_service.request(v2, arg)
    p = update(p, p2)

...

do_logic(v1, v2, v3):
  p = self.load(v1)

  if что-то(p):  
    p2 = self.load2(v2)
    p = update(p, p2)

  if что-то(p):   
    self.commit(v3)

  result = serialize(p) 
  return result

Mocks are objects pre-programmed with expectations which form a specification of the calls they are expected to receive

expect(query).to.deep.eq(pattern)

P>>Я вам пишу про разные кейсы из того что вижу, а вы все пытаетесь причину во мне найти

дай всё по страницам по фильтру на дату отсортированым

P>>Вы вот сами путаете моки и стабы

P>>expect(query).to.deep.eq(pattern)
P>>

{
  sql: 'select * from users where id=?',
  params: [id],
  transformations: {
     in: [fn1],
     out: [fn2]
  }
}

P>>вот, вы начинате понимать, для чего нужны интеграционные Здесь вам понадобится тест компонента с подклееной реальной бд. И без этого никак.

P>>Вы там что, на каждый коммит всю систему переписываете?

P>class Logic(v1, v2, v3):  // параметры-значения в конструкторе
P>  def run(load, load2, commit): // эффекты-зависимости здесь, эдакий аналог импорта
P>     p = ctx.load(self.v1) 

P>     if что-то(p):  
P>       p2 = ctx.load2(self.v2) // load2 - абстракция так себе, должно быть хорошее имя
P>       p = update(p, p2)

P>     if что-то(p):   
P>       ctx.commit(self.v3)
      
P>     return p
P>

if v1:
  return value1
else if v2:
  return value2
else:
  raise

P>do_logic(v1, v2, v3):
P>  p = self.load(v1)

P>  if что-то(p):  
P>    p2 = self.load2(v2)
P>    p = update(p, p2)

P>  if что-то(p):   
P>    self.commit(v3)

P>  result = serialize(p) 
P>  return result
P>

@test()
@params(
    1,2,3,4,5,6  // и так на каждую строчку в табличке
)
@params(
    8,4,2,1,3,5 // точно так же и исключения прокидывают
)
...   сколько строчек, столько и тестов фактически выполнится
"a cool name test name" (v1, v2, v3, repo1, svc, repo2, result) {
   let logic = Logic(v1,v2,v3);

   let r = logic.run({
      load: () => repo1,
      load2: () => svc,
      ... и так прокидываем все что надо
   }) 

   expect(r).to.deep.eq(result)
}

Б>if v1:
Б>  return value1
Б>else if v2:
Б>  return value2
Б>else:
Б>  raise
Б>

() => value1
() => value2

P>Ага, тесты "как написано" Вам придется написать много больше, чем один тест — как минимум, пространство входов более-менее покрыть. Моками вы вспотеете это покрывать.

P>Принципиальное отличе of вместо from

P>>>Ну да — для вас перебулшитить тесты проблемой не является Еще и настаиваете, что так и надо.

P>>>Проходит же. Вот я и интересуюсь, кто настрочил горы непотребства

P>·>Жуть. Ну ладно. Т.е. тут мы тестируем репозиторий и ассертим текст sql

var testSubject = new MyRepo("connectionString");// по возможности in-mem dbms, но может быть и реальная

var id = 42;
testSubject.save(new User(id, "Vasya")));
var actual = testSubject.getUser(id);
assert actual.getName().equals("Vasya");

const getUser = repository.getUser(id);
const oldUser = db.execute(getUser);

P>>>Шота я этого за 4 года не заметил

P>Если значение hmac во всех кейсах совпадает с нашим, это куда лучшая проверка. Но вместо этого вы берете моки т.к. "это бизнес-требования"

P>>>Ага, тесты "как написано" Вам придется написать много больше, чем один тест — как минимум, пространство входов более-менее покрыть. Моками вы вспотеете это покрывать.

P>>>Принципиальное отличе of вместо from

{
load: () => repo1,
load2: () => svc,
... и так прокидываем все что надо
}

P>Вот видите — вам тоже нужны такие тесты Только вы предпочитаете косвенную проверку.

P>·>const getUser = repository.getUser(id);
P>·>const oldUser = db.execute(getUser);
P>·>

P>И это в любом случае нужно делать, и никакие моки от этого не избавляют. Можно просто отказаться от таких тестов типа "у нас смок тест бд". Тоже вариант, и собственно моки здесь снова никак не помогают

P>Вы так и не рассказали, чем это хуже. Вы предложили конский запрос тестировать косвенно

P>Из этого никак не следует, что и в тестах будет так же. Нам не нужно сравнивать трассы всех тестов вообще. Вы вы еще предложите трассы нагрузочных тестов сравнивать или трассы за весь спринт