MnemonicFlowTest.java

package com.example.bip39.integration;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import com.example.bip39.api.Bip39Service;
import com.example.bip39.api.DefaultBip39Service;
import com.example.bip39.error.Bip39ErrorCode;
import com.example.bip39.error.Bip39Exception;
import com.example.bip39.model.ValidationResult;
import java.util.HexFormat;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.jupiter.api.Test;

class MnemonicFlowTest {

  private static final String RAW_ZERO_ENTROPY_MNEMONIC =
      "  ABANDON\tabandon\nABANDON\rabandon  abandon\tabandon\nabandon\rabandon"
          + "  abandon\tabandon\nABANDON\rABOUT  ";

  private static final String NORMALIZED_ZERO_ENTROPY_MNEMONIC =
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon"
          + " about";

  private static final String ZERO_ENTROPY_SEED_WITH_TREZOR =
      "c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e5349553"
          + "1f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04";

  @Test
  void preparesUiInputWhilePreservingOriginalText() {
    MnemonicFlow mnemonicFlow = new MnemonicFlow(new DefaultBip39Service());

    PreparedMnemonicInput preparedMnemonicInput =
        mnemonicFlow.prepareInput(RAW_ZERO_ENTROPY_MNEMONIC);

    assertEquals(RAW_ZERO_ENTROPY_MNEMONIC, preparedMnemonicInput.originalInput());
    assertEquals(NORMALIZED_ZERO_ENTROPY_MNEMONIC, preparedMnemonicInput.normalizedMnemonic());
  }

  @Test
  void validatesNormalizedInputSeparatelyFromDerivation() {
    MnemonicFlow mnemonicFlow = new MnemonicFlow(new DefaultBip39Service());

    ValidationResult validationResult =
        mnemonicFlow.validatePreparedInput(mnemonicFlow.prepareInput(RAW_ZERO_ENTROPY_MNEMONIC));

    assertTrue(validationResult.ok());
    assertEquals(NORMALIZED_ZERO_ENTROPY_MNEMONIC, validationResult.normalizedMnemonic());
  }

  @Test
  void validatesBeforeDerivingSeedWhenRequested() {
    RecordingBip39Service bip39Service = new RecordingBip39Service();
    MnemonicFlow mnemonicFlow = new MnemonicFlow(bip39Service);
    PreparedMnemonicInput preparedMnemonicInput =
        new PreparedMnemonicInput("abandon typo", "abandon typo");

    Bip39Exception exception =
        assertThrows(
            Bip39Exception.class,
            () -> mnemonicFlow.validateThenDeriveSeed(preparedMnemonicInput, "TREZOR"));

    assertEquals(Bip39ErrorCode.ERR_INVALID_WORD_COUNT, exception.getErrorCode());
    assertFalse(bip39Service.mnemonicToSeedCalled.get());
  }

  @Test
  void forwardsValidatedSeedToBip32Consumer() {
    MnemonicFlow mnemonicFlow = new MnemonicFlow(new DefaultBip39Service());
    AtomicReference<byte[]> capturedSeed = new AtomicReference<>();

    byte[] returnedSeed =
        mnemonicFlow.validateThenSendSeedToBip32(
            RAW_ZERO_ENTROPY_MNEMONIC, "TREZOR", capturedSeed::set);

    assertEquals(ZERO_ENTROPY_SEED_WITH_TREZOR, HexFormat.of().formatHex(returnedSeed));
    assertArrayEquals(returnedSeed, capturedSeed.get());
    assertNotSame(returnedSeed, capturedSeed.get());
  }

  @Test
  void mapsErrorCodesToUiMessages() {
    MnemonicFlow mnemonicFlow = new MnemonicFlow(new DefaultBip39Service());

    assertEquals(
        "Mnemonic contains a word outside the English BIP39 list.",
        mnemonicFlow.uiMessage(Bip39ErrorCode.ERR_WORD_NOT_IN_LIST));
    assertEquals(
        "Mnemonic checksum does not match the words provided.",
        mnemonicFlow.uiMessage(Bip39ErrorCode.ERR_CHECKSUM_MISMATCH));
  }

  private static final class RecordingBip39Service implements Bip39Service {

    private final AtomicBoolean mnemonicToSeedCalled = new AtomicBoolean(false);

    @Override
    public String entropyToMnemonic(byte[] entropy) {
      throw new UnsupportedOperationException();
    }

    @Override
    public byte[] mnemonicToEntropy(String mnemonic) {
      throw new UnsupportedOperationException();
    }

    @Override
    public byte[] mnemonicToEntropy(java.util.List<String> words) {
      throw new UnsupportedOperationException();
    }

    @Override
    public ValidationResult validateMnemonic(String mnemonic) {
      return ValidationResult.failure(Bip39ErrorCode.ERR_INVALID_WORD_COUNT, mnemonic, 2, null);
    }

    @Override
    public ValidationResult validateMnemonic(java.util.List<String> words) {
      throw new UnsupportedOperationException();
    }

    @Override
    public byte[] mnemonicToSeed(String mnemonic, String passphrase) {
      mnemonicToSeedCalled.set(true);
      return new byte[64];
    }

    @Override
    public byte[] mnemonicToSeed(java.util.List<String> words, String passphrase) {
      throw new UnsupportedOperationException();
    }
  }
}