public void setUpDataBase() throws Exception {

    when(mockPluginDatabaseSystem.openDatabase(any(UUID.class), anyString()))
        .thenReturn(mockDatabase);
    when(mockDatabaseFactory.newTableFactory(any(UUID.class), anyString()))
        .thenReturn(mockFactoryTable);
    when(mockDatabase.getTable(anyString())).thenReturn(mockDatabaseTable);
    when(mockDatabaseTable.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
    when(mockDatabase.newTransaction()).thenReturn(mockTransaction);
    subAppResourcesDAO = new SubAppResourcesInstallationNetworkServiceDAO(mockPluginDatabaseSystem);
    subAppResourcesDAO = new SubAppResourcesInstallationNetworkServiceDAO(mockPluginDatabaseSystem);

    String path = "path1";
    String skinName = "skinName1";
    String navigationStructureVersion = "version1";
    repository = new Repository(skinName, navigationStructureVersion, path);

    subAppResourcesDAO.initializeDatabase(
        UUID.randomUUID(), SubAppResourcesNetworkServiceDatabaseConstants.DATABASE_NAME);
    skinId = UUID.randomUUID();
    subAppResourcesDAO.createRepository(repository, skinId);
    when(mockDatabase.getTable(anyString())).thenReturn(mockDatabaseTable);
    mockDatabaseTable.setUUIDFilter(
        SubAppResourcesNetworkServiceDatabaseConstants.REPOSITORIES_SKIN_ID_COLUMN_NAME,
        skinId,
        DatabaseFilterType.EQUAL);
    mockDatabaseTable.loadToMemory();
    when(mockDatabaseTable.getRecords()).thenReturn(databaseTableRecordList);
    when(databaseTableRecordList.get(anyInt())).thenReturn(mockDatabaseTableRecord);
    when(mockDatabaseTableRecord.getStringValue(anyString())).thenReturn(anyString());
  }
  /**
   * Gets the amount of transaction in ProtocolStatus as Pending Notified from the specified table
   *
   * @param transactionType
   * @return
   * @throws CantExecuteDatabaseOperationException
   */
  public int getPendingNotifiedTransactions(TransactionTypes transactionType)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable;
    if (transactionType == TransactionTypes.OUTGOING) {
      databaseTable =
          database.getTable(BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TABLE_NAME);
      databaseTable.setStringFilter(
          BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
          ProtocolStatus.TO_BE_NOTIFIED.getCode(),
          DatabaseFilterType.EQUAL);
    } else {
      databaseTable =
          database.getTable(BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_TABLE_NAME);
      databaseTable.setStringFilter(
          BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
          ProtocolStatus.TO_BE_NOTIFIED.getCode(),
          DatabaseFilterType.EQUAL);
    }

    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    /** I return the amount of records. */
    return databaseTable.getRecords().size();
  }
  /**
   * Gets both incoming and outgoing transactions hash stored in the database
   *
   * @return
   * @throws CantExecuteDatabaseOperationException
   */
  public Set<String> getStoredStransactionsHash() throws CantExecuteDatabaseOperationException {
    Set<String> transactionsSet = new HashSet<>();

    /** Loads and puts in the transactionsSet the list of stored Hashes */
    DatabaseTable databaseTable =
        database.getTable(BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_TABLE_NAME);
    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    for (DatabaseTableRecord record : databaseTable.getRecords()) {
      transactionsSet.add(
          record.getStringValue(
              BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_HASH_COLUMN_NAME));
    }

    /** Loads and puts in the transactionsSet the list of stored Hashes */
    databaseTable =
        database.getTable(BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TABLE_NAME);
    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    for (DatabaseTableRecord record : databaseTable.getRecords()) {
      transactionsSet.add(
          record.getStringValue(
              BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_HASH_COLUMN_NAME));
    }

    return transactionsSet;
  }
  private void setUpMockitoRules() throws Exception {

    when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
    when(mockDatabaseTable.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
    when(mockDatabase.getTable(
            AssetIssuingTransactionDatabaseConstants.DIGITAL_ASSET_TRANSACTION_TABLE_NAME))
        .thenReturn(mockDatabaseTable);
    when(mockDatabase.getTable(
            AssetIssuingTransactionDatabaseConstants
                .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_TABLE_NAME))
        .thenReturn(mockDatabaseTable2);
    when(mockDatabaseTable2.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
    when(mockDatabaseTable2.getRecords()).thenReturn(records);
    when(pluginDatabaseSystem.openDatabase(
            pluginId, AssetIssuingTransactionDatabaseConstants.DIGITAL_ASSET_TRANSACTION_DATABASE))
        .thenReturn(mockDatabase);

    when(deviceUser.getPublicKey()).thenReturn("myPublicKey");
    when(deviceUserManager.getLoggedInDeviceUser()).thenReturn(deviceUser);

    when(actorAssetIssuerManager.getActorAssetIssuer()).thenReturn(actorAssetIssuer);

    when(eventManager.getNewListener(
            EventType.INCOMING_ASSET_ON_CRYPTO_NETWORK_WAITING_TRANSFERENCE_ASSET_ISSUER))
        .thenReturn(fermatEventListener1);
    when(eventManager.getNewListener(
            EventType.INCOMING_ASSET_ON_BLOCKCHAIN_WAITING_TRANSFERENCE_ASSET_ISSUER))
        .thenReturn(fermatEventListener2);
    when(eventManager.getNewListener(
            EventType.INCOMING_ASSET_REVERSED_ON_BLOCKCHAIN_WAITING_TRANSFERENCE_ASSET_ISSUER))
        .thenReturn(fermatEventListener3);
    when(eventManager.getNewListener(
            EventType.INCOMING_ASSET_REVERSED_ON_CRYPTO_NETWORK_WAITING_TRANSFERENCE_ASSET_ISSUER))
        .thenReturn(fermatEventListener4);

    when(pluginFileSystem.createTextFile(
            this.pluginId,
            "digital-asset-issuing/publicKey",
            "name.xml",
            FilePrivacy.PUBLIC,
            FileLifeSpan.PERMANENT))
        .thenReturn(pluginTextFile);
    when(bitcoinWalletManager.loadWallet(this.walletPublicKey)).thenReturn(bitcoinWalletWallet);
    when(bitcoinWalletWallet.getBalance(BalanceType.AVAILABLE)).thenReturn(bitcoinWalletBalance);
    when(bitcoinWalletBalance.getBalance()).thenReturn(bitcoinWalletAvailableBalance);
    when(assetVaultManager.getNewAssetVaultCryptoAddress(this.blockchainNetworkType))
        .thenReturn(cryptoAddress);
    //        doNothing().when(assetIssuingPluginRoot).issueAssets(digitalAsset, 1, walletPublicKey,
    // blockchainNetworkType);
  }
  /**
   * Gets the pending transaction data from the specified table
   *
   * @param transactionType
   * @return
   */
  private List<TransactionProtocolData> getPendingTransactionProtocolData(
      TransactionTypes transactionType) throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable;
    String transactionIdColumnName;

    List<TransactionProtocolData> transactionProtocolDataList = new ArrayList<>();

    if (transactionType == TransactionTypes.INCOMING) {
      databaseTable =
          database.getTable(BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_TABLE_NAME);
      databaseTable.setStringFilter(
          BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
          ProtocolStatus.TO_BE_NOTIFIED.getCode(),
          DatabaseFilterType.EQUAL);
      transactionIdColumnName =
          BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_TRX_ID_COLUMN_NAME;
    } else {
      databaseTable =
          database.getTable(BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TABLE_NAME);
      databaseTable.setStringFilter(
          BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
          ProtocolStatus.TO_BE_NOTIFIED.getCode(),
          DatabaseFilterType.EQUAL);
      transactionIdColumnName =
          BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TRX_ID_COLUMN_NAME;
    }

    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    /** Will form the TransactionProtocolData object from the records */
    for (DatabaseTableRecord record : databaseTable.getRecords()) {
      TransactionProtocolData transactionProtocolData = new TransactionProtocolData();
      transactionProtocolData.setTransactionId(
          UUID.fromString(record.getStringValue(transactionIdColumnName)));
      transactionProtocolData.setCryptoTransaction(
          getCryptoTransactionFromRecord(transactionType, record));
      transactionProtocolData.setAction(Action.APPLY);
      transactionProtocolData.setTimestamp(
          System.currentTimeMillis()
              / 1000L); // todo I need to convert the stored saved date to long

      transactionProtocolDataList.add(transactionProtocolData);
    }

    return transactionProtocolDataList;
  }
  public final List<DeveloperDatabaseTableRecord> getDatabaseTableContent(
      final DeveloperObjectFactory developerObjectFactory,
      final DeveloperDatabaseTable developerDatabaseTable) {

    final List<DeveloperDatabaseTableRecord> returnedRecords = new ArrayList<>();

    final DatabaseTable selectedTable = database.getTable(developerDatabaseTable.getName());

    try {

      selectedTable.loadToMemory();
      final List<DatabaseTableRecord> records = selectedTable.getRecords();

      for (final DatabaseTableRecord row : records) {

        final List<String> developerRow = new ArrayList<>();

        for (DatabaseRecord field : row.getValues()) developerRow.add(field.getValue());

        returnedRecords.add(
            developerObjectFactory.getNewDeveloperDatabaseTableRecord(developerRow));
      }

    } catch (CantLoadTableToMemoryException cantLoadTableToMemory) {

      return returnedRecords;
    } catch (Exception e) {
      return returnedRecords;
    }
    return returnedRecords;
  }
  /**
   * Saves and outgoing transaction into the database
   *
   * @param hash
   * @param cryptoStatus
   * @param blockDepth
   * @param addressTo
   * @param addressFrom
   * @param value
   * @param op_Return
   * @param protocolStatus
   * @throws CantExecuteDatabaseOperationException
   */
  public void saveNewOutgoingTransaction(
      String hash,
      CryptoStatus cryptoStatus,
      int blockDepth,
      CryptoAddress addressTo,
      CryptoAddress addressFrom,
      long value,
      String op_Return,
      ProtocolStatus protocolStatus)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TABLE_NAME);
    DatabaseTableRecord record = databaseTable.getEmptyRecord();

    /** generates the trx_id */
    UUID trxId = UUID.randomUUID();

    record.setUUIDValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_TRX_ID_COLUMN_NAME, trxId);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_HASH_COLUMN_NAME, hash);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_CRYPTO_STATUS_COLUMN_NAME,
        cryptoStatus.getCode());
    record.setIntegerValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_BLOCK_DEPTH_COLUMN_NAME,
        blockDepth);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_ADDRESS_TO_COLUMN_NAME,
        addressTo.getAddress());
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_ADDRESS_FROM_COLUMN_NAME,
        addressFrom.getAddress());
    record.setDoubleValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_VALUE_COLUMN_NAME, value);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_OP_RETURN_COLUMN_NAME,
        op_Return);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
        protocolStatus.getCode());
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_LAST_UPDATE_COLUMN_NAME,
        getCurrentDateTime());
    try {
      databaseTable.insertRecord(record);
    } catch (CantInsertRecordException e) {
      StringBuilder outputMessage =
          new StringBuilder(
              "There was an error inserting a new transaction in the Outgoing Transactions Table. Transaction record is:");
      outputMessage.append(System.lineSeparator());
      outputMessage.append(XMLParser.parseObject(record));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "database issue.");
    }
  }
 public List<DeveloperDatabaseTableRecord> getDatabaseTableContent(
     DeveloperObjectFactory developerObjectFactory,
     DeveloperDatabaseTable developerDatabaseTable) {
   /** Will get the records for the given table */
   List<DeveloperDatabaseTableRecord> returnedRecords =
       new ArrayList<DeveloperDatabaseTableRecord>();
   /** I load the passed table name from the SQLite database. */
   DatabaseTable selectedTable = database.getTable(developerDatabaseTable.getName());
   try {
     selectedTable.loadToMemory();
     List<DatabaseTableRecord> records = selectedTable.getRecords();
     for (DatabaseTableRecord row : records) {
       List<String> developerRow = new ArrayList<String>();
       /** for each row in the table list */
       for (DatabaseRecord field : row.getValues()) {
         /** I get each row and save them into a List<String> */
         developerRow.add(field.getValue());
       }
       /** I create the Developer Database record */
       returnedRecords.add(
           developerObjectFactory.getNewDeveloperDatabaseTableRecord(developerRow));
     }
     /** return the list of DeveloperRecords for the passed table. */
   } catch (CantLoadTableToMemoryException cantLoadTableToMemory) {
     /** if there was an error, I will returned an empty list. */
     database.closeDatabase();
     return returnedRecords;
   } catch (Exception e) {
     database.closeDatabase();
     return returnedRecords;
   }
   database.closeDatabase();
   return returnedRecords;
 }
  public boolean isGenesisTransactionRegistered(String genesisTransaction)
      throws CantExecuteQueryException {
    try {
      this.database = openDatabase();
      DatabaseTable databaseTable;
      databaseTable = database.getTable(AssetReceptionDatabaseConstants.ASSET_RECEPTION_TABLE_NAME);
      databaseTable.addStringFilter(
          AssetReceptionDatabaseConstants.ASSET_RECEPTION_GENESIS_TRANSACTION_COLUMN_NAME,
          genesisTransaction,
          DatabaseFilterType.EQUAL);
      databaseTable.loadToMemory();

      return !databaseTable.getRecords().isEmpty();
    } catch (CantLoadTableToMemoryException exception) {

      throw new CantExecuteQueryException(
          "Error executing query in DB.",
          exception,
          "Checking if genesis transaction exists in database.",
          "Cannot load table to memory.");
    } catch (Exception exception) {

      throw new CantExecuteQueryException(
          CantExecuteQueryException.DEFAULT_MESSAGE,
          FermatException.wrapException(exception),
          "Checking if genesis transaction exits in database.",
          "Unexpected exception");
    }
  }
Exemple #10
0
  private List<String> getValueListFromTableByColumn(
      String referenceValue, String table, String referenceColumn, String returningColumn)
      throws CantCheckAssetReceptionProgressException {

    try {
      this.database = openDatabase();
      DatabaseTable databaseTable;
      List<String> returningList = new ArrayList<>();
      databaseTable = database.getTable(table);
      databaseTable.addStringFilter(referenceColumn, referenceValue, DatabaseFilterType.EQUAL);
      databaseTable.loadToMemory();
      for (DatabaseTableRecord record : databaseTable.getRecords()) {
        returningList.add(record.getStringValue(returningColumn));
      }

      return returningList;
    } catch (CantLoadTableToMemoryException exception) {

      throw new CantCheckAssetReceptionProgressException(
          exception, "Getting " + referenceColumn + " list", "Cannot load table to memory");
    } catch (CantExecuteDatabaseOperationException exception) {

      throw new CantCheckAssetReceptionProgressException(
          exception,
          "Getting " + referenceColumn + " list",
          "Cannot open or find the Asset Reception database");
    } catch (Exception exception) {

      throw new CantCheckAssetReceptionProgressException(
          FermatException.wrapException(exception),
          "Getting " + referenceColumn + " list",
          "Unexpected exception");
    }
  }
Exemple #11
0
  private boolean isAssetsByReceptionStatus(ReceptionStatus receptionStatus)
      throws CantExecuteQueryException {
    try {
      this.database = openDatabase();
      DatabaseTable databaseTable;
      databaseTable = database.getTable(AssetReceptionDatabaseConstants.ASSET_RECEPTION_TABLE_NAME);
      databaseTable.addStringFilter(
          AssetReceptionDatabaseConstants.ASSET_RECEPTION_RECEPTION_STATUS_COLUMN_NAME,
          receptionStatus.getCode(),
          DatabaseFilterType.EQUAL);
      databaseTable.addStringFilter(
          AssetReceptionDatabaseConstants.ASSET_RECEPTION_CRYPTO_STATUS_COLUMN_NAME,
          CryptoStatus.PENDING_SUBMIT.getCode(),
          DatabaseFilterType.EQUAL);
      databaseTable.loadToMemory();

      return !databaseTable.getRecords().isEmpty();
    } catch (CantLoadTableToMemoryException exception) {

      throw new CantExecuteQueryException(
          "Error executing query in DB.",
          exception,
          "Getting assets by reception status.",
          "Cannot load table to memory.");
    } catch (Exception exception) {

      throw new CantExecuteQueryException(
          CantExecuteQueryException.DEFAULT_MESSAGE,
          FermatException.wrapException(exception),
          "Getting assets by reception status.",
          "Unexpected exception");
    }
  }
  @Override
  public int getPublicKeyPosition(String address) throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_TABLE_NAME);
    databaseTable.addStringFilter(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_ADDRESS_COLUMN_NAME,
        address,
        DatabaseFilterType.EQUAL);

    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    List<DatabaseTableRecord> databaseTableRecords = databaseTable.getRecords();
    if (databaseTableRecords.size() != 0) {
      return databaseTableRecords
          .get(0)
          .getIntegerValue(
              AssetsOverBitcoinCryptoVaultDatabaseConstants
                  .KEY_MAINTENANCE_DETAIL_KEY_DEPTH_COLUMN_NAME);
    } else return 0;
  }
  public void setUpMockitoRules() throws Exception {

    when(mockPluginDatabaseSystem.openDatabase(pluginId, pluginId.toString()))
        .thenReturn(mockDatabase);

    when(mockExtraUserActorDatabaseFactory.createDatabase(pluginId, pluginId.toString()))
        .thenReturn(mockDatabase);

    when(mockDatabase.getTable(ExtraUserActorDatabaseConstants.EXTRA_USER_TABLE_NAME))
        .thenReturn(mockTable);
    when(mockTable.getRecords()).thenReturn(mockRecords);
    when(mockRecords.get(anyInt())).thenReturn(mockTableRecord);
    when(mockPluginFileSystem.getBinaryFile(
            any(UUID.class),
            anyString(),
            anyString(),
            any(FilePrivacy.class),
            any(FileLifeSpan.class)))
        .thenReturn(mockBinaryFile);

    when(mockPluginFileSystem.getTextFile(
            any(UUID.class),
            anyString(),
            anyString(),
            any(FilePrivacy.class),
            any(FileLifeSpan.class)))
        .thenReturn(mockFile);

    when(mockBinaryFile.getContent()).thenReturn(new byte[100]);
  }
  /**
   * Gets the next It to be used to create a new HierarchyAccountId
   *
   * @return
   */
  public int getNextAvailableHierarchyAccountId() throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_TABLE_NAME);
    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    /** returns the next available Id to be used. */
    List<DatabaseTableRecord> databaseTableRecords = databaseTable.getRecords();
    if (databaseTableRecords.isEmpty()) return 0;
    else {
      int hierarchyAccountId = 0;
      for (DatabaseTableRecord record : databaseTableRecords) {
        if (record.getIntegerValue(
                AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_ID_COLUMN_NAME)
            > hierarchyAccountId)
          hierarchyAccountId =
              record.getIntegerValue(
                  AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_ID_COLUMN_NAME);
      }

      return hierarchyAccountId + 1;
    }
  }
  @Before
  public void setUp() throws Exception {

    bitcoinCryptoVault = new BitcoinCryptoVault(userPublicKey);
    bitcoinCryptoVault.setPluginFileSystem(pluginFileSystem);
    bitcoinCryptoVault.setPluginDatabaseSystem(pluginDatabaseSystem);
    bitcoinCryptoVault.setPluginFileSystem(pluginFileSystem);
    bitcoinCryptoVault.setUserPublicKey(userPublicKey);
    bitcoinCryptoVault.setDatabase(mockDatabase);

    bitcoinCryptoVault.setPluginId(pluginId);
    bitcoinCryptoVault.setLogManager(mockLogManager);
    when(pluginFileSystem.createTextFile(
            pluginId,
            userPublicKey,
            userPublicKey.toString() + ".vault",
            FilePrivacy.PRIVATE,
            FileLifeSpan.PERMANENT))
        .thenReturn(mockPluginTextFile);

    bitcoinCryptoVault.loadOrCreateVault();

    when(pluginDatabaseSystem.openDatabase(pluginId, userPublicKey)).thenReturn(mockDatabase);
    when(mockDatabase.getTable(anyString())).thenReturn(mockTable);
    when(mockDatabase.newTransaction()).thenReturn(mockDatabaseTransaction);
    when(mockTable.getRecords()).thenReturn(mockRecords);
    Mockito.doReturn(mockRecord).when(mockRecords).get(0);
  }
Exemple #16
0
  private boolean isPendingEventsBySource(EventSource eventSource)
      throws CantExecuteQueryException {
    try {
      this.database = openDatabase();
      DatabaseTable databaseTable;
      databaseTable =
          database.getTable(
              AssetReceptionDatabaseConstants.ASSET_RECEPTION_EVENTS_RECORDED_TABLE_NAME);
      databaseTable.addStringFilter(
          AssetReceptionDatabaseConstants.ASSET_RECEPTION_EVENTS_RECORDED_STATUS_COLUMN_NAME,
          EventStatus.PENDING.getCode(),
          DatabaseFilterType.EQUAL);
      databaseTable.addStringFilter(
          AssetReceptionDatabaseConstants.ASSET_RECEPTION_EVENTS_RECORDED_SOURCE_COLUMN_NAME,
          eventSource.getCode(),
          DatabaseFilterType.EQUAL);
      databaseTable.loadToMemory();

      return !databaseTable.getRecords().isEmpty();
    } catch (CantLoadTableToMemoryException exception) {

      throw new CantExecuteQueryException(
          "Error executing query in DB.",
          exception,
          "Getting pending events.",
          "Cannot load table to memory.");
    } catch (Exception exception) {

      throw new CantExecuteQueryException(
          CantExecuteQueryException.DEFAULT_MESSAGE,
          FermatException.wrapException(exception),
          "Getting pending events.",
          "Unexpected exception");
    }
  }
Exemple #17
0
  public boolean isPendingTransactions(CryptoStatus cryptoStatus) throws CantExecuteQueryException {
    try {
      this.database = openDatabase();
      DatabaseTable databaseTable;
      databaseTable = database.getTable(AssetReceptionDatabaseConstants.ASSET_RECEPTION_TABLE_NAME);
      databaseTable.addStringFilter(
          AssetReceptionDatabaseConstants.ASSET_RECEPTION_PROTOCOL_STATUS_COLUMN_NAME,
          ProtocolStatus.TO_BE_NOTIFIED.getCode(),
          DatabaseFilterType.EQUAL);
      databaseTable.addStringFilter(
          AssetReceptionDatabaseConstants.ASSET_RECEPTION_CRYPTO_STATUS_COLUMN_NAME,
          cryptoStatus.getCode(),
          DatabaseFilterType.EQUAL);
      databaseTable.loadToMemory();

      return !databaseTable.getRecords().isEmpty();
    } catch (CantLoadTableToMemoryException exception) {

      throw new CantExecuteQueryException(
          "Error executing query in DB.",
          exception,
          "Getting pending transactions.",
          "Cannot load table to memory.");
    } catch (Exception exception) {

      throw new CantExecuteQueryException(
          CantExecuteQueryException.DEFAULT_MESSAGE,
          FermatException.wrapException(exception),
          "Getting pending transactions.",
          "Unexpected exception");
    }
  }
  private void setUpMockitoRules() throws Exception {

    when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
    when(mockDatabaseTable.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
    when(mockDatabase.getTable(AssetIssuingDatabaseConstants.ASSET_ISSUING_TABLE_NAME))
        .thenReturn(mockDatabaseTable);
    when(pluginDatabaseSystem.openDatabase(
            pluginId, AssetIssuingDatabaseConstants.ASSET_ISSUING_DATABASE))
        .thenReturn(mockDatabase);

    //        when(mockExtraUserActorDatabaseFactory.createDatabase(pluginId,
    // pluginId.toString())).thenReturn(mockDatabase);
    when(deviceUser.getPublicKey()).thenReturn("myPublicKey");
    when(deviceUserManager.getLoggedInDeviceUser()).thenReturn(deviceUser);
    when(eventManager.getNewListener(
            EventType.INCOMING_ASSET_ON_CRYPTO_NETWORK_WAITING_TRANSFERENCE_ASSET_ISSUER))
        .thenReturn(fermatEventListener1);
    when(eventManager.getNewListener(
            EventType.INCOMING_ASSET_ON_BLOCKCHAIN_WAITING_TRANSFERENCE_ASSET_ISSUER))
        .thenReturn(fermatEventListener2);
    when(eventManager.getNewListener(
            EventType.INCOMING_ASSET_REVERSED_ON_BLOCKCHAIN_WAITING_TRANSFERENCE_ASSET_ISSUER))
        .thenReturn(fermatEventListener3);
    when(eventManager.getNewListener(
            EventType.INCOMING_ASSET_REVERSED_ON_CRYPTO_NETWORK_WAITING_TRANSFERENCE_ASSET_ISSUER))
        .thenReturn(fermatEventListener4);
    when(eventManager.getNewListener(EventType.RECEIVED_NEW_DIGITAL_ASSET_METADATA_NOTIFICATION))
        .thenReturn(fermatEventListener5);

    when(actorAssetIssuerManager.getActorAssetIssuer()).thenReturn(actorAssetIssuer);
  }
 private void mockitoRules() throws Exception {
   when(database.getTable(AssetIssuingDatabaseConstants.ASSET_ISSUING_TABLE_NAME))
       .thenReturn(databaseTable);
   when(databaseTable.getRecords()).thenReturn(records);
   when(databaseTableRecord.getIntegerValue(
           AssetIssuingDatabaseConstants.ASSET_ISSUING_ASSETS_COMPLETED_COLUMN_NAME))
       .thenReturn(issuedAssetsExpected);
 }
  /**
   * Gets the crypto Status list that are in pending status from the specified table.
   *
   * @param transactionType
   * @return
   */
  public Set<CryptoStatus> getPendingCryptoStatus(TransactionTypes transactionType)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable;
    String cryptoStatusColumnName;
    Set<CryptoStatus> cryptoStatuses = new HashSet<>();

    /** Will set up filters and column names depending on the transaction type. */
    if (transactionType == TransactionTypes.OUTGOING) {
      databaseTable =
          database.getTable(BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TABLE_NAME);
      databaseTable.setStringFilter(
          BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
          ProtocolStatus.TO_BE_NOTIFIED.getCode(),
          DatabaseFilterType.EQUAL);
      cryptoStatusColumnName =
          BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_CRYPTO_STATUS_COLUMN_NAME;
    } else {
      databaseTable =
          database.getTable(BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_TABLE_NAME);
      databaseTable.setStringFilter(
          BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
          ProtocolStatus.TO_BE_NOTIFIED.getCode(),
          DatabaseFilterType.EQUAL);
      cryptoStatusColumnName =
          BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_CRYPTO_STATUS_COLUMN_NAME;
    }

    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    /** get all the CryptoStatus and remove duplicates as Im storing them in a set. */
    for (DatabaseTableRecord record : databaseTable.getRecords()) {
      try {
        CryptoStatus cryptoStatus =
            CryptoStatus.getByCode(record.getStringValue(cryptoStatusColumnName));
        cryptoStatuses.add(cryptoStatus);
      } catch (InvalidParameterException e) {
        e.printStackTrace();
      }
    }

    return cryptoStatuses;
  }
 private void mockitoRules() throws Exception {
   when(database.getTable(AssetIssuingDatabaseConstants.ASSET_ISSUING_METADATA_TABLE))
       .thenReturn(databaseTable);
   when(databaseTable.getRecords()).thenReturn(records);
   when(databaseTableRecord.getStringValue(
           AssetIssuingDatabaseConstants.ASSET_ISSUING_GENESIS_TRANSACTION_COLUMN_NAME))
       .thenReturn(genesisTransactionExpected);
 }
  @Test
  public void GetBalance_GeneralException_ReturnsAvailableBalance() throws Exception {
    when(mockDatabase.getTable(BitcoinWalletDatabaseConstants.BITCOIN_WALLET_BALANCE_TABLE_NAME))
        .thenReturn(null);

    catchException(testBalance).getBalance();
    assertThat(caughtException()).isNotNull().isInstanceOf(CantCalculateBalanceException.class);
  }
  /**
   * Updates the Key detailed table for this account and key, with the passed addres
   *
   * @param hierarchyAccountId
   * @param ecKey
   * @param cryptoAddress
   * @param blockchainNetworkType
   */
  public void updateKeyDetailedStatsWithNewAddress(
      int hierarchyAccountId,
      ECKey ecKey,
      CryptoAddress cryptoAddress,
      BlockchainNetworkType blockchainNetworkType)
      throws CantExecuteDatabaseOperationException, UnexpectedResultReturnedFromDatabaseException {
    /** If we are not allowed to save detailed information then we will exit */
    if (!VaultKeyMaintenanceParameters.STORE_DETAILED_KEY_INFORMATION) return;

    DatabaseTable databaseTable =
        database.getTable(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_TABLE_NAME);
    databaseTable.addStringFilter(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_ACCOUNT_ID_COLUMN_NAME,
        String.valueOf(hierarchyAccountId),
        DatabaseFilterType.EQUAL);
    databaseTable.addStringFilter(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_PUBLIC_KEY_COLUMN_NAME,
        ecKey.getPublicKeyAsHex(),
        DatabaseFilterType.EQUAL);

    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    if (databaseTable.getRecords().size() == 0) {
      StringBuilder output = new StringBuilder("The key " + ecKey.toString());
      output.append(System.lineSeparator());
      output.append("which generated the address " + cryptoAddress.getAddress());
      output.append(System.lineSeparator());
      output.append("is not a key derived from the vault.");

      throw new UnexpectedResultReturnedFromDatabaseException(
          null, output.toString(), "Vault derivation miss match");
    }

    DatabaseTableRecord record = databaseTable.getRecords().get(0);
    record.setStringValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_ADDRESS_COLUMN_NAME,
        cryptoAddress.getAddress());
    record.setStringValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_DETAIL_BLOCKCHAIN_NETWORK_TYPE_COLUMN_NAME,
        blockchainNetworkType.getCode());
    try {
      databaseTable.updateRecord(record);
    } catch (CantUpdateRecordException e) {
      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          "error updating record",
          "database issue");
    }
  }
 private void insertInitialBalancesRecord(final Database database)
     throws CantInsertRecordException {
   DatabaseTable balancesTable =
       database.getTable(
           BitcoinLossProtectedWalletDatabaseConstants.LOSS_PROTECTED_WALLET_BALANCE_TABLE_NAME);
   List<DatabaseTableRecord> initialListRecord = constructBalanceInitialRecord(balancesTable);
   for (DatabaseTableRecord initalRecord : initialListRecord) {
     balancesTable.insertRecord(initalRecord);
   }
 }
 @Before
 public void setUpMockitoRules() {
   when(mockDatabase.getTable(BitcoinWalletDatabaseConstants.BITCOIN_WALLET_BALANCE_TABLE_NAME))
       .thenReturn(mockTable);
   when(mockTable.getRecords()).thenReturn(mockRecords);
   when(mockRecords.get(0)).thenReturn(mockRecord);
   when(mockRecord.getLongValue(
           BitcoinWalletDatabaseConstants.BITCOIN_WALLET_BALANCE_TABLE_BOOK_BALANCE_COLUMN_NAME))
       .thenReturn(mockBookBalance);
 }
 private void setUpMockitoGeneralRules() throws Exception {
   when(mockPluginDatabaseSystem.createDatabase(
           pluginId, IntraWalletUserActorDatabaseConstants.INTRA_WALLET_USER_DATABASE_NAME))
       .thenReturn(mockDatabase);
   when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
   when(mockDatabaseFactory.newTableFactory(
           pluginId, IntraWalletUserActorDatabaseConstants.INTRA_WALLET_USER_TABLE_NAME))
       .thenReturn(mockIntraUserTableFactory);
   when(mockDatabase.getTable(IntraWalletUserActorDatabaseConstants.INTRA_WALLET_USER_TABLE_NAME))
       .thenReturn(mockTable);
   when(mockTable.getEmptyRecord()).thenReturn(mockTableRecord);
 }
 @Test
 public void test() {
   List<DatabaseTableRecord> records = mock(ArrayList.class);
   when(database.getTable(anyString())).thenReturn(table);
   when(database.newTransaction()).thenReturn(transaction);
   when(table.getRecords()).thenReturn(records);
   when(table.getEmptyRecord()).thenReturn(record);
   when(records.isEmpty()).thenReturn(true);
   VaultEventListeners eventListeners =
       new VaultEventListeners(database, errorManager, eventManager, logManager);
   eventListeners.onCoinsReceived(wallet, tx, Coin.CENT, Coin.CENT);
 }
 public void setUpMockitoRules() throws Exception {
   when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
   when(mockDatabaseTable.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
   when(mockDatabase.getTable(CryptoIndexDatabaseConstants.CRYPTO_INDEX_TABLE_NAME))
       .thenReturn(mockDatabaseTable);
   when(mockPluginDatabaseSystem.openDatabase(
           pluginId, CryptoIndexDatabaseConstants.CRYPTO_INDEX_DATABASE_NAME))
       .thenReturn(mockDatabase);
   when(mockCryptoIndexDatabaseFactory.createDatabase(
           pluginId, CryptoIndexDatabaseConstants.CRYPTO_INDEX_DATABASE_NAME))
       .thenReturn(mockDatabase);
   cryptoIndexDao = new CryptoIndexDao(mockPluginDatabaseSystem, pluginId);
 }
  /**
   * searches for the public key and notifies if is exists.
   *
   * @param redeemPointPublicKey
   * @return
   */
  public boolean isExistingRedeemPoint(String redeemPointPublicKey)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_TABLE_NAME);
    databaseTable.addStringFilter(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_DESCRIPTION_COLUMN_NAME,
        redeemPointPublicKey,
        DatabaseFilterType.EQUAL);

    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    return !databaseTable.getRecords().isEmpty();
  }
  /**
   * If the transaction exists in the IncomingTransactions table it will return true, otherwise it
   * will return false
   *
   * @param txHash
   * @return
   */
  public boolean isIncomingTransaction(String txHash) throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_TABLE_NAME);
    databaseTable.setStringFilter(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_HASH_COLUMN_NAME,
        txHash,
        DatabaseFilterType.EQUAL);

    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    if (databaseTable.getRecords().size() > 0) return true;
    else return false;
  }