Asserts that a variable is not empty.
| public static assertNotEmpty ( mixed $actual, string $message = '' ) | ||
| $actual | mixed | |
| $message | string | |
/**
* @Then /^I should see "(?P<text>[^"]*)" in (?P<tableName>[\w\d\-]+) table row with "(?P<row>[^"]*)"$/
* @Then /^I should see "(?P<text>[^"]*)" in (?P<row>\d+)(st|nd|rd|th)? (?P<tableName>[\w\d\-]+) table row$/
*/
public function assertTableRowContains($text, $row, $tableName)
{
$table = $this->findTable($tableName);
$row = is_numeric($row) ? $table->getRow($row - 1) : $table->findRow($row);
Assert::assertNotEmpty($row, "Couldn't find row {$row} in table: " . PHP_EOL . $table->dump());
Assert::assertContains($text, $row, "Couldn't find {$text} in row " . $table->dumpRows(array($row)));
}
public function testAPICreatePrimes_1()
{
$this->app->make('CounterpartySenderMockBuilder')->installMockCounterpartySenderDependencies($this->app, $this);
// setup
list($payment_address, $sample_txos) = $this->setupPrimes();
// api tester
$api_tester = $this->getAPITester();
$create_primes_vars = ['size' => CurrencyUtil::satoshisToValue(5430), 'count' => 3];
$response = $api_tester->callAPIWithAuthentication('POST', '/api/v1/primes/' . $payment_address['uuid'], $create_primes_vars);
$api_data = json_decode($response->getContent(), true);
PHPUnit::assertEquals(0, $api_data['oldPrimedCount']);
PHPUnit::assertEquals(3, $api_data['newPrimedCount']);
PHPUnit::assertNotEmpty($api_data['txid']);
PHPUnit::assertEquals(true, $api_data['primed']);
// check the composed transaction
$composed_transaction_raw = DB::connection('untransacted')->table('composed_transactions')->first();
$send_data = app('TransactionComposerHelper')->parseBTCTransaction($composed_transaction_raw->transaction);
$bitcoin_address = $payment_address['address'];
PHPUnit::assertCount(3, $send_data['change']);
PHPUnit::assertEquals($bitcoin_address, $send_data['destination']);
PHPUnit::assertEquals(5430, $send_data['btc_amount']);
PHPUnit::assertEquals($bitcoin_address, $send_data['change'][0][0]);
PHPUnit::assertEquals(5430, $send_data['change'][0][1]);
PHPUnit::assertEquals($bitcoin_address, $send_data['change'][1][0]);
PHPUnit::assertEquals(5430, $send_data['change'][1][1]);
}
/**
* @Then the select field should be flagged as required
*/
public function theSelectFieldShouldBeFlaggedAsRequired()
{
$nodeElements = $this->getSession()->getPage()->findAll('css', sprintf('div.ezfield-identifier-%s fieldset select', self::$fieldIdentifier));
Assertion::assertNotEmpty($nodeElements, 'The select field is not marked as required');
foreach ($nodeElements as $nodeElement) {
Assertion::assertEquals('required', $nodeElement->getAttribute('required'), sprintf('select with id %s is not flagged as required', $nodeElement->getAttribute('id')));
}
}
protected function _testCreate()
{
if ($this->_model->getId()) {
\PHPUnit_Framework_Assert::fail("Can't run creation test for models with defined id");
}
$this->_model->save();
\PHPUnit_Framework_Assert::assertNotEmpty($this->_model->getId(), 'CRUD Create error');
}
/**
* Assert that displayed breadcrumbs on category page equals to passed from fixture.
*
* @param BrowserInterface $browser
* @param Category $category
* @param CatalogCategoryView $catalogCategoryView
* @return void
*/
public function processAssert(BrowserInterface $browser, Category $category, CatalogCategoryView $catalogCategoryView)
{
$this->browser = $browser;
$this->openCategory($category);
$breadcrumbs = $this->getBreadcrumbs($category);
\PHPUnit_Framework_Assert::assertNotEmpty($breadcrumbs, 'No breadcrumbs on category \'' . $category->getName() . '\' page.');
$pageBreadcrumbs = $catalogCategoryView->getBreadcrumbs()->getText();
\PHPUnit_Framework_Assert::assertEquals($breadcrumbs, $pageBreadcrumbs, 'Wrong breadcrumbs of category page.' . "\nExpected: " . $breadcrumbs . "\nActual: " . $pageBreadcrumbs);
}
/**
* Checks the integrity of operations links.
*
* @param mixed[] $operations_links
*/
protected function assertOperationsLinks(array $operations_links)
{
foreach ($operations_links as $link) {
\PHPUnit_Framework_Assert::assertArrayHasKey('title', $link);
\PHPUnit_Framework_Assert::assertNotEmpty($link['title']);
\PHPUnit_Framework_Assert::assertArrayHasKey('url', $link);
\PHPUnit_Framework_Assert::assertInstanceOf(Url::class, $link['url']);
}
}
/**
* @inheritdoc
*/
protected function assertDataNotPersisted($name, array $criterias)
{
$table = $this->convertNameToTable($this->singularize($name));
foreach ($criterias as $criteria) {
$criteria = $this->applyMapping($this->getFieldMapping($table), $criteria);
$this->transformFixture($table, $criteria);
$match = $this->find($table, $criteria);
Assert::assertNotEmpty($match, sprintf('There should not be a record in table "%s" with these criteria: %s', $table, json_encode($criteria)));
}
}
public function testSendRequest()
{
if (!$this->CONNECTION_IS_SET) {
$this->markTestIncomplete("Authorization credentials must be defined as environment vars.");
}
$xcpd_client = new Client($this->CONNECTION_STRING, $this->RPC_USER, $this->RPC_PASSWORD);
$response_data = $xcpd_client->get_block_info(['block_index' => 312600]);
// echo json_encode($response_data, 192)."\n";
PHPUnit::assertNotEmpty($response_data);
PHPUnit::assertEquals('312600', $response_data['block_index']);
}
public function testCLIListUsers()
{
$kernel = $this->app['Illuminate\\Contracts\\Console\\Kernel'];
// insert
$kernel->call('api:new-user', ['email' => '*****@*****.**']);
// list
$kernel->call('api:list-users');
$output = $kernel->output();
PHPUnit::assertNotEmpty($output);
PHPUnit::assertContains('*****@*****.**', $output);
}
public function testFindByUUID()
{
// insert
$monitored_address_repo = $this->app->make('App\\Repositories\\MonitoredAddressRepository');
$monitored_address_helper = $this->app->make('\\MonitoredAddressHelper');
$created_address = $monitored_address_repo->create($monitored_address_helper->sampleDBVars(['address' => '1recipient111111111111111111111111']));
// load from repo
$loaded_address_model = $monitored_address_repo->findByUuid($created_address['uuid']);
PHPUnit::assertNotEmpty($loaded_address_model);
PHPUnit::assertEquals($created_address['id'], $loaded_address_model['id']);
PHPUnit::assertEquals($created_address['address'], $loaded_address_model['address']);
}
public function testParsePHP()
{
$parser = new Parser();
$php_string = <<<'EOT'
$a = 5;
$c = $a + 2;
return $c;
EOT;
$stmts = $parser->parsePHPString($php_string);
PHPUnit::assertNotEmpty($stmts);
}
public function testUpdateByUUID()
{
// insert
$user_repo = $this->app->make('App\\Repositories\\UserRepository');
$created_user_model = $user_repo->create($this->app->make('\\UserHelper')->sampleDBVars());
// update
$user_repo->updateByUuid($created_user_model['uuid'], ['email' => '*****@*****.**']);
// load from repo again
$loaded_user_model = $user_repo->findByUuid($created_user_model['uuid']);
PHPUnit::assertNotEmpty($loaded_user_model);
PHPUnit::assertEquals('*****@*****.**', $loaded_user_model['email']);
PHPUnit::assertEquals($created_user_model['password'], $loaded_user_model['password']);
}
/**
* @param $orderId
* @param OrderIndex $orderIndex
* @param SalesOrderView $salesOrderView
* @param BraintreeSettlementReportIndex $braintreeSettlementReportIndex
* @throws \Exception
*/
public function processAssert($orderId, OrderIndex $orderIndex, SalesOrderView $salesOrderView, BraintreeSettlementReportIndex $braintreeSettlementReportIndex)
{
$this->salesOrderView = $salesOrderView;
$this->settlementReportIndex = $braintreeSettlementReportIndex;
$orderIndex->open();
$orderIndex->getSalesOrderGrid()->searchAndOpen(['id' => $orderId]);
$transactionId = $this->getTransactionId();
\PHPUnit_Framework_Assert::assertNotEmpty($transactionId);
$this->settlementReportIndex->open();
$grid = $this->settlementReportIndex->getSettlementReportGrid();
$grid->search(['id' => $transactionId]);
$ids = $grid->getTransactionIds();
\PHPUnit_Framework_Assert::assertTrue(in_array($transactionId, $ids));
}
/**
* @When I select :packageName package version :version
*/
public function iSelectPackage($packageName, $version)
{
$package = $this->packages[strtolower($packageName)];
Assertion::assertNotNull($package, "Package '{$packageName}' not defined");
// first select the package
$fields = $this->getXpath()->findFields($package);
Assertion::assertNotEmpty($fields, "Couldn't find '{$package}' field");
$fields[0]->check();
// now verify version
// IMPORTANT: only verify the values shown on the page, does not actually
// verify if the package is in a given version
$versionLabel = "{$packageName} (ver. {$version})";
$this->iSeeTitle($versionLabel);
}
public function testFindAllTransactionsConfirmedInBlockHashes()
{
// insert
$created_transaction_models = [];
$created_transaction_models[] = $this->txHelper()->createSampleTransaction('sample_xcp_parsed_01.json', ['txid' => 'TX01', 'bitcoinTx' => ['blockhash' => 'BLOCKHASH01']]);
$created_transaction_models[] = $this->txHelper()->createSampleTransaction('sample_xcp_parsed_01.json', ['txid' => 'TX02', 'bitcoinTx' => ['blockhash' => 'BLOCKHASH02']]);
$created_transaction_models[] = $this->txHelper()->createSampleTransaction('sample_xcp_parsed_01.json', ['txid' => 'TX03', 'bitcoinTx' => ['blockhash' => 'BLOCKHASH03']]);
// load from repo
$tx_repo = $this->app->make('App\\Repositories\\TransactionRepository');
$loaded_transaction_models = $tx_repo->findAllTransactionsConfirmedInBlockHashes(['BLOCKHASH02', 'BLOCKHASH03']);
PHPUnit::assertNotEmpty($loaded_transaction_models);
PHPUnit::assertCount(2, $loaded_transaction_models);
PHPUnit::assertEquals('TX02', $loaded_transaction_models[0]['txid']);
PHPUnit::assertEquals('TX03', $loaded_transaction_models[1]['txid']);
}
public function testBitcoinTransactionEventBuilder()
{
$mock_calls = $this->app->make('CounterpartySenderMockBuilder')->installMockCounterpartySenderDependencies($this->app, $this);
$enhanced_builder = app('App\\Handlers\\XChain\\Network\\Bitcoin\\EnhancedBitcoindTransactionBuilder');
$bitcoin_data = $enhanced_builder->buildTransactionData('d0010d7ddb1662e381520d29177ea83f81f87428879b57735a894cad8dcae2a2');
$builder = app('App\\Handlers\\XChain\\Network\\Bitcoin\\BitcoinTransactionEventBuilder');
$ts = time() * 1000;
$parsed_data = $builder->buildParsedTransactionData($bitcoin_data, $ts);
PHPUnit::assertNotEmpty($parsed_data['counterpartyTx']);
PHPUnit::assertEquals(1013.54979902, $parsed_data['counterpartyTx']['quantity']);
PHPUnit::assertEquals(101354979902, $parsed_data['counterpartyTx']['quantitySat']);
PHPUnit::assertEquals(1.25E-5, $parsed_data['counterpartyTx']['dustSize']);
PHPUnit::assertEquals(1250, $parsed_data['counterpartyTx']['dustSizeSat']);
$expected_fingerprint = hash('sha256', 'b61bff55d9c5b14f32515b2b00eaf72d3f1c1b951f0747b3199ade27544efd74:2' . '|OP_DUP OP_HASH160 c56cb39f9b289c0ec4ef6943fa107c904820fe09 OP_EQUALVERIFY OP_CHECKSIG' . '|1 022cacedc1a455d6665433a2d852951b52014def0fb4769a3323a7ab0cccc1adc3 03e74c5611fa7923392e1390838caf81814003baba2fab77e2c8a4bd9834ae6fa1 020ba30b3409037b6653fdcc916775fe7f2a2dbca9b934cd51e5d207f56a8178e7 3 OP_CHECKMULTISIG' . '|OP_DUP OP_HASH160 76d12dfbe58981a0008ab832f6f02ebfd2f78661 OP_EQUALVERIFY OP_CHECKSIG');
PHPUnit::assertEquals($expected_fingerprint, $parsed_data['transactionFingerprint']);
}
/**
* Assert that comment about authorized amount exist in Comments History section on order page in Admin.
*
* @param SalesOrderView $salesOrderView
* @param OrderIndex $salesOrder
* @param string $orderId
* @param array $transactionDetails
* @throws \Exception
*/
public function processAssert(SalesOrderView $salesOrderView, OrderIndex $salesOrder, $orderId, array $transactionDetails)
{
$transactionId = '';
$salesOrder->open();
$salesOrder->getSalesOrderGrid()->searchAndOpen(['id' => $orderId]);
$comment = $salesOrderView->getOrderHistoryBlock()->getCommentsHistory();
preg_match('/(ID: ")(\\w+-*\\w+)(")/', $comment, $matches);
if (!empty($matches[2])) {
$transactionId = $matches[2];
}
\PHPUnit_Framework_Assert::assertNotEmpty($transactionId);
$orderForm = $salesOrderView->getOrderForm()->openTab('transactions');
/** @var Grid $grid */
$grid = $orderForm->getTab('transactions')->getGridBlock();
$actualTxnIds = $grid->getIds();
\PHPUnit_Framework_Assert::assertEquals($transactionDetails, $actualTxnIds[$transactionId], 'Incorrect transaction details for the order #' . $orderId);
}
/**
* Step Definition my Ip Stored In User Table.
*
* @Then /^My Ip stored in user table$/
*/
public function myIpStoredInUserTable()
{
$storedIp = $this->getContainer()->get('security.context')->getToken()->getUser()->getLastloginClientIp();
\PHPUnit_Framework_Assert::assertNotEmpty($storedIp);
// TODO Behat access to request_stack
// $currentIp = $this
// ->getContainer()
// ->get('request_stack')
// ->getCurrentRequest()
// ->server
// ->get('REMOTE_ADDR');
// echo var_dump($currentIp);
// \PHPUnit_Framework_Assert::assertSame(
// $currentIp,
// $storedIp,
// 'user table stored Ip and curret Ip have to same'
// );
}
public function testSendRequests()
{
if (!$this->CONNECTION_IS_SET) {
$this->markTestIncomplete("Please define environment var INSIGHT_CONNECTION_STRING to run this test.");
return;
}
$insight_client = new Client($this->CONNECTION_STRING);
$response_data = $insight_client->getTransaction('6ce4509eff0a955855e5a4690152e003982894be130491cccdb2af93cb9a68ab');
// echo json_encode($response_data, 192)."\n";
PHPUnit::assertNotEmpty($response_data);
PHPUnit::assertEquals('6ce4509eff0a955855e5a4690152e003982894be130491cccdb2af93cb9a68ab', $response_data['txid']);
PHPUnit::assertEquals('1', $response_data['version']);
$response_data = $insight_client->getBlock('000000000000000015f697b296584d9d443d2225c67df9033157a9efe4a8faa0');
// echo json_encode($response_data, 192)."\n";
PHPUnit::assertNotEmpty($response_data);
PHPUnit::assertEquals('000000000000000015f697b296584d9d443d2225c67df9033157a9efe4a8faa0', $response_data['hash']);
PHPUnit::assertEquals('2', $response_data['version']);
}
public function testAuthenticationHeaders()
{
$generator = new Generator();
$api = Phake::partialMock('Tokenly\\APIClient\\TokenlyAPI', 'https://127.0.0.1/api/v1', $generator, 'MY_CLIENT_ID', 'MY_CLIENT_SECRET');
$headers_generated = [];
Phake::when($api)->callRequest(Phake::anyParameters())->thenReturnCallback(function ($url, $headers, $body, $method, $options) use(&$headers_generated) {
$response = new Requests_Response();
$response->body = json_encode(['sample' => 'output']);
$headers_generated = $headers;
return $response;
});
$result = $api->call('GET', 'method/one', ['foo' => 'bar']);
PHPUnit::assertEquals(['sample' => 'output'], $result);
// check headers
PHPUnit::assertNotEmpty($headers_generated);
$nonce = $headers_generated['X-TOKENLY-AUTH-NONCE'];
PHPUnit::assertGreaterThanOrEqual(time(), $nonce);
PHPUnit::assertEquals('MY_CLIENT_ID', $headers_generated['X-TOKENLY-AUTH-API-TOKEN']);
$expected_signature = $this->expectedSignature($nonce);
PHPUnit::assertEquals($expected_signature, $headers_generated['X-TOKENLY-AUTH-SIGNATURE']);
}
public function testFindAllAsOfHeight()
{
// insert
$created_block_model_1 = $this->blockHelper()->createSampleBlock('default_parsed_block_01.json', ['hash' => 'BLOCKHASH01', 'height' => 333000, 'parsed_block' => ['height' => 333000]]);
$created_block_model_2 = $this->blockHelper()->createSampleBlock('default_parsed_block_01.json', ['hash' => 'BLOCKHASH02', 'height' => 333001, 'parsed_block' => ['height' => 333001]]);
// create 3 and 4 in the wrong order
$created_block_model_4 = $this->blockHelper()->createSampleBlock('default_parsed_block_01.json', ['hash' => 'BLOCKHASH04', 'height' => 333003, 'parsed_block' => ['height' => 333003]]);
$created_block_model_3 = $this->blockHelper()->createSampleBlock('default_parsed_block_01.json', ['hash' => 'BLOCKHASH03', 'height' => 333002, 'parsed_block' => ['height' => 333002]]);
// load all as of 333003
$block_repo = $this->app->make('App\\Repositories\\BlockRepository');
$loaded_block_models = $block_repo->findAllAsOfHeight(333003);
PHPUnit::assertNotEmpty($loaded_block_models);
PHPUnit::assertCount(1, $loaded_block_models->all());
PHPUnit::assertEquals('BLOCKHASH04', $loaded_block_models[0]['hash']);
// load all as of 333002
$block_repo = $this->app->make('App\\Repositories\\BlockRepository');
$loaded_block_models = $block_repo->findAllAsOfHeight(333002);
PHPUnit::assertNotEmpty($loaded_block_models);
PHPUnit::assertCount(2, $loaded_block_models->all());
PHPUnit::assertEquals('BLOCKHASH03', $loaded_block_models[0]['hash']);
PHPUnit::assertEquals('BLOCKHASH04', $loaded_block_models[1]['hash']);
}
public function testOpReturnParser()
{
$parser = new Parser();
$tx_data = $this->getSampleCounterpartyTransaction4();
$counterparty_data = $parser->parseBitcoinTransaction($tx_data, 2);
PHPUnit::assertNotEmpty($counterparty_data);
// 1 SOUP
PHPUnit::assertEquals('send', $counterparty_data['type']);
PHPUnit::assertEquals('1MFHQCPGtcSfNPXAS6NryWja3TbUN9239Y', $counterparty_data['sources'][0]);
PHPUnit::assertEquals('1Q7VHJDEzVj7YZBVseQWgYvVj3DWDCLwDE', $counterparty_data['destinations'][0]);
PHPUnit::assertEquals('SOUP', $counterparty_data['asset']);
PHPUnit::assertEquals(1 * self::SATOSHI, $counterparty_data['quantity']);
$tx_data = $this->getSampleCounterpartyTransaction5();
$counterparty_data = $parser->parseBitcoinTransaction($tx_data, 2);
PHPUnit::assertNotEmpty($counterparty_data);
// 50 SOUP
PHPUnit::assertEquals('send', $counterparty_data['type']);
PHPUnit::assertEquals('12iVwKP7jCPnuYy7jbAbyXnZ3FxvgLwvGK', $counterparty_data['sources'][0]);
PHPUnit::assertEquals('1KUsjZKrkd7LYRV7pbnNJtofsq1HAiz6MF', $counterparty_data['destinations'][0]);
PHPUnit::assertEquals('SOUP', $counterparty_data['asset']);
PHPUnit::assertEquals(50 * self::SATOSHI, $counterparty_data['quantity']);
}
public function testAddNotification()
{
$monitored_address_repo = $this->app->make('App\\Repositories\\MonitoredAddressRepository');
$monitored_address_helper = $this->app->make('\\MonitoredAddressHelper');
$created_address_model = $monitored_address_repo->create($monitored_address_helper->sampleDBVars());
// insert
$notification_helper = $this->app->make('\\NotificationHelper');
$created_notification_model = $notification_helper->createSampleNotification($created_address_model);
// load from repo
$notification_repo = $this->app->make('App\\Repositories\\NotificationRepository');
$loaded_notification_model = $notification_repo->findById($created_notification_model['id']);
PHPUnit::assertNotEmpty($loaded_notification_model);
PHPUnit::assertNotEmpty($loaded_notification_model['uuid']);
PHPUnit::assertEquals($created_notification_model['id'], $loaded_notification_model['id']);
PHPUnit::assertEquals($created_address_model['id'], $loaded_notification_model['monitored_address_id']);
PHPUnit::assertEquals('new', $loaded_notification_model['status']);
// load by address
$loaded_notification_models = $notification_repo->findByMonitoredAddressId($created_address_model['id']);
PHPUnit::assertNotEmpty($loaded_notification_models);
$loaded_notification_model = $loaded_notification_models[0];
PHPUnit::assertNotEmpty($loaded_notification_model);
PHPUnit::assertNotEmpty($loaded_notification_model['uuid']);
PHPUnit::assertEquals($created_notification_model['id'], $loaded_notification_model['id']);
}
public function testPaymentAddressSenderForCounterpartySend()
{
$mock_calls = app('CounterpartySenderMockBuilder')->installMockCounterpartySenderDependencies($this->app, $this);
$user = $this->app->make('\\UserHelper')->createSampleUser();
list($payment_address, $input_utxos) = $this->makeAddressAndSampleTXOs($user);
$sender = app('App\\Blockchain\\Sender\\PaymentAddressSender');
$dust_size = 1.234E-5;
$sender->sendByRequestID('request001', $payment_address, '1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i', '100', 'TOKENLY', $float_fee = null, $dust_size, $is_sweep = false);
// check the first sent call
$send_details = app('TransactionComposerHelper')->parseCounterpartyTransaction($mock_calls['btcd'][0]['args'][0]);
PHPUnit::assertEquals('1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i', $send_details['destination']);
PHPUnit::assertEquals('TOKENLY', $send_details['asset']);
PHPUnit::assertEquals(CurrencyUtil::valueToSatoshis(100), $send_details['quantity']);
PHPUnit::assertEquals(CurrencyUtil::valueToSatoshis(0.4999), $send_details['sum_out']);
PHPUnit::assertEquals(CurrencyUtil::valueToSatoshis($dust_size), $send_details['btc_dust_size']);
// make sure that the composed transaction is correct
$composed_transaction_repository = app('App\\Repositories\\ComposedTransactionRepository');
$composed_tx_model = $composed_transaction_repository->getComposedTransactionByRequestID('request001');
PHPUnit::assertNotEmpty($composed_tx_model['txid']);
PHPUnit::assertNotEmpty($composed_tx_model['transaction']);
PHPUnit::assertNotEmpty($composed_tx_model['utxos']);
PHPUnit::assertEquals($input_utxos[6]['txid'] . ':' . $input_utxos[6]['n'], $composed_tx_model['utxos'][0]);
PHPUnit::assertEquals('request001', $composed_tx_model['request_id']);
}
public function testSendTXOsWithChangeCreatesUTXOs()
{
// receiving a transaction adds TXOs
$txo_repository = $this->app->make('App\\Repositories\\TXORepository');
// setup monitors
$payment_address_helper = app('PaymentAddressHelper');
$sending_address_one = $payment_address_helper->createSamplePaymentAddress(null, ['address' => '1AuTJDwH6xNqxRLEjPB7m86dgmerYVQ5G1']);
// create some TXOs
$sample_txos = [];
$txid = $this->TXOHelper()->nextTXID();
$sample_txos[0] = $this->TXOHelper()->createSampleTXO($sending_address_one, ['txid' => $txid, 'n' => 0]);
$sample_txos[1] = $this->TXOHelper()->createSampleTXO($sending_address_one, ['txid' => $txid, 'n' => 1]);
// send a transaction (0)
$sending_tx = $this->buildTransactionWithUTXOs([$sample_txos[0]]);
$this->sendTransactionWithConfirmations($sending_tx, 0);
// confirm SENDING
$loaded_txo = $txo_repository->findByTXIDAndOffset($txid, 0);
PHPUnit::assertEquals(TXO::SENDING, $loaded_txo['type'], 'Unexpected type of ' . TXO::typeIntegerToString($loaded_txo['type']));
PHPUnit::assertTrue($loaded_txo['spent']);
// find the change UTXO
$loaded_change_txo = $txo_repository->findByTXIDAndOffset($sending_tx['txid'], 1);
PHPUnit::assertEquals(361213, $loaded_change_txo['amount']);
PHPUnit::assertNotEmpty($loaded_change_txo);
}
/**
* Asserts that a variable is not empty.
*
* @param mixed $actual
* @param string $message
* @throws PHPUnit_Framework_AssertionFailedError
*/
function assertNotEmpty($actual, $message = '')
{
return PHPUnit_Framework_Assert::assertNotEmpty($actual, $message);
}
/**
* Checks that variable is not empty.
*
* @param $actual
* @param string $message
*/
protected function assertNotEmpty($actual, $message = '')
{
\PHPUnit_Framework_Assert::assertNotEmpty($actual, $message);
}
public function seeExceptionThrown($classname, $message = null)
{
\PHPUnit_Framework_Assert::assertNotEmpty($this->thrownExceptions, "No exception was thrown");
foreach ($this->thrownExceptions as $e) {
if ($e instanceof $classname) {
\PHPUnit_Framework_Assert::assertInstanceOf($classname, $e);
if ($message) {
\PHPUnit_Framework_Assert::assertContains($message, $e->getMessage());
}
return;
}
}
}
/**
* @Then on :pageSection I (should) see (the) (following) links:
*
* @deprecated deprecated since version 6.3.0
*/
public function onPageSectionISeeLinks(TableNode $table, $pageSection = null)
{
trigger_error("iSeeLinks is deprecated since v6.3.0 and will be removed in v7.0.0", E_USER_DEPRECATED);
$rows = $table->getRows();
array_shift($rows);
foreach ($rows as $row) {
$link = $row[0];
$el = $this->getXpath()->findLinks($link, $this->makeXpathForBlock($pageSection));
Assertion::assertNotEmpty($el, "Unexpected link found");
}
}
public function toBeTruthy()
{
if ($this->negate) {
a::assertEmpty($this->actual);
} else {
a::assertNotEmpty($this->actual);
}
}
