FM / unit

/home/desid573/public_html/app/braintree/tests/unit/

/home/desid573/public_html/app/braintree/tests/unit

Name	Size	Mode	Actions
ClientApi/	-	0755	rm
Result/	-	0755	rm
AddOnTest.php	887	0644	edit dl rm
AddressTest.php	2293	0644	edit dl rm
AuthorizationAdjustmentTest.php	1060	0644	edit dl rm
BraintreeTest.php	701	0644	edit dl rm
ConfigurationTest.php	18393	0644	edit dl rm
CreditCardTest.php	5068	0644	edit dl rm
CreditCardVerificationTest.php	747	0644	edit dl rm
CustomerTest.php	1936	0644	edit dl rm
DigestTest.php	3560	0644	edit dl rm
DisbursementDetailsTest.php	618	0644	edit dl rm
DisbursementTest.php	3215	0644	edit dl rm
DiscountTest.php	928	0644	edit dl rm
DisputeTest.php	16853	0644	edit dl rm
DocumentUploadTest.php	434	0644	edit dl rm
EndsWithNodeTest.php	343	0644	edit dl rm
GatewayTest.php	1650	0644	edit dl rm
HttpTest.php	2056	0644	edit dl rm
InstanceTest.php	1083	0644	edit dl rm
MerchantAccountTest.php	3119	0644	edit dl rm
MultipleValueNodeTest.php	566	0644	edit dl rm
MultipleValueOrTextNodeTest.php	1470	0644	edit dl rm
OAuthAccessRevocationTest.php	399	0644	edit dl rm
OAuthTest.php	1947	0644	edit dl rm
PaginatedCollectionTest.php	2700	0644	edit dl rm
PaymentMethodTest.php	4407	0644	edit dl rm
PayPalAccountTest.php	1307	0644	edit dl rm
RangeNodeTest.php	1012	0644	edit dl rm
ResourceCollectionTest.php	2918	0644	edit dl rm
SanityTest.php	515	0644	edit dl rm
SubscriptionSearchTest.php	2151	0644	edit dl rm
SubscriptionTest.php	506	0644	edit dl rm
TextNodeTest.php	1086	0644	edit dl rm
TransactionLineItemTest.php	572	0644	edit dl rm
TransactionTest.php	4300	0644	edit dl rm
TransparentRedirectTest.php	1033	0644	edit dl rm
UnknownPaymentMethodTest.php	770	0644	edit dl rm
UsBankAccountTest.php	1768	0644	edit dl rm
UsBankAccountVerificationTest.php	941	0644	edit dl rm
UtilTest.php	12998	0644	edit dl rm
WebhookNotificationTest.php	40053	0644	edit dl rm
Xml_GeneratorTest.php	2975	0644	edit dl rm
Xml_ParserTest.php	18668	0644	edit dl rm

Edit: /home/desid573/public_html/app/braintree/tests/unit/DisputeTest.php (16853B)

<?php
namespace Test\Unit;

require_once dirname(__DIR__) . '/Setup.php';

use DateTime;
use Test\Setup;
use Braintree;

class DisputeTest extends Setup
{
    private $attributes;

public function __construct() {
        $this->attributes = [
            'amount' => '100.00',
            'amountDisputed' => '100.00',
            'amountWon' => '0.00',
            'caseNumber' => 'CB123456',
            'createdAt' => DateTime::createFromFormat('Ymd-His', '20130410-105039'),
            'currencyIsoCode' => 'USD',
            'dateOpened' => DateTime::createFromFormat('Ymd-His', '20130401-000000'),
            'dateWon' => DateTime::createFromFormat('Ymd-His', '20130402-000000'),
            'forwardedComments' => 'Forwarded comments',
            'id' => '123456',
            'kind' => 'chargeback',
            'merchantAccountId' => 'abc123',
            'originalDisputeId' => 'original_dispute_id',
            'reason' => 'fraud',
            'reasonCode' => '83',
            'reasonDescription' => 'Reason code 83 description',
            'receivedDate' => DateTime::createFromFormat('Ymd-His', '20130410-000410'),
            'referenceNumber' => '123456',
            'replyByDate' => DateTime::createFromFormat('Ymd-His', '20130417-0000417'),
            'status' => 'open',
            'updatedAt' => DateTime::createFromFormat('Ymd-His', '20130410-105039'),
            'evidence' => [[
                'category' => NULL,
                'comment' => NULL,
                'createdAt' => DateTime::createFromFormat('Ymd-His', '20130411-105039'),
                'id' => 'evidence1',
                'sentToProcessorAt' => NULL,
                'sequenceNumber' => NULL,
                'url' => 'url_of_file_evidence',
            ],[
                'comment' => 'text evidence',
                'createdAt' => DateTime::createFromFormat('Ymd-His', '20130411-105039'),
                'id' => 'evidence2',
                'sentToProcessorAt' => '2009-04-11',
                'url' => NULL,
            ]],
            'statusHistory' => [[
                'effectiveDate' => '2013-04-10',
                'status' => 'open',
                'timestamp' => DateTime::createFromFormat('Ymd-His', '20130410-105039'),
            ]],
            'transaction' => [
                'id' => 'transaction_id',
                'amount' => '100.00',
                'createdAt' => DateTime::createFromFormat('Ymd-His', '20130319-105039'),
                'orderId' => NULL,
                'purchaseOrderNumber' => 'po',
                'paymentInstrumentSubtype' => 'Visa',
            ]
        ];
    }

public function testLegacyConstructor()
    {
        $legacyParams = [
            'transaction' => [
                'id' => 'transaction_id',
                'amount' => '100.00',
            ],
            'id' => '123456',
            'currencyIsoCode' => 'USD',
            'status' => 'open',
            'amount' => '100.00',
            'receivedDate' => DateTime::createFromFormat('Ymd-His', '20130410-000410'),
            'replyByDate' => DateTime::createFromFormat('Ymd-His', '20130421-000421'),
            'reason' => 'fraud',
            'transactionIds' => [
                'asdf', 'qwer'
            ],
            'dateOpened' => DateTime::createFromFormat('Ymd-His', '20130410-000410'),
            'dateWon' =>DateTime::createFromFormat('Ymd-His', '20130422-000422'),
            'kind' => 'chargeback'
        ];

$dispute = Braintree\Dispute::factory($legacyParams);

$this->assertEquals('123456', $dispute->id);
        $this->assertEquals('100.00', $dispute->amount);
        $this->assertEquals('USD', $dispute->currencyIsoCode);
        $this->assertEquals(Braintree\Dispute::FRAUD, $dispute->reason);
        $this->assertEquals(Braintree\Dispute::OPEN, $dispute->status);
        $this->assertEquals(Braintree\Dispute::Open, $dispute->status);
        $this->assertEquals('transaction_id', $dispute->transactionDetails->id);
        $this->assertEquals('100.00', $dispute->transactionDetails->amount);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130410-000410'), $dispute->dateOpened);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130422-000422'), $dispute->dateWon);
        $this->assertEquals(Braintree\Dispute::CHARGEBACK, $dispute->kind);
    }

public function testLegacyParamsWithNewAttributes()
    {
        $dispute = Braintree\Dispute::factory($this->attributes);

$this->assertEquals('123456', $dispute->id);
        $this->assertEquals('100.00', $dispute->amount);
        $this->assertEquals('USD', $dispute->currencyIsoCode);
        $this->assertEquals(Braintree\Dispute::FRAUD, $dispute->reason);
        $this->assertEquals(Braintree\Dispute::Open, $dispute->status);
        $this->assertEquals(Braintree\Dispute::OPEN, $dispute->status);
        $this->assertEquals('transaction_id', $dispute->transactionDetails->id);
        $this->assertEquals('100.00', $dispute->transactionDetails->amount);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130401-000000'), $dispute->dateOpened);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130402-000000'), $dispute->dateWon);
        $this->assertEquals(Braintree\Dispute::CHARGEBACK, $dispute->kind);
    }

public function testConstructorPopulatesNewFields()
    {
        $dispute = Braintree\Dispute::factory($this->attributes);

$this->assertEquals("100.00", $dispute->amountDisputed);
        $this->assertEquals("0.00", $dispute->amountWon);
        $this->assertEquals("CB123456", $dispute->caseNumber);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130410-105039'), $dispute->createdAt);
        $this->assertEquals("Forwarded comments", $dispute->forwardedComments);
        $this->assertEquals("abc123", $dispute->merchantAccountId);
        $this->assertEquals("original_dispute_id", $dispute->originalDisputeId);
        $this->assertEquals("83", $dispute->reasonCode);
        $this->assertEquals("Reason code 83 description", $dispute->reasonDescription);
        $this->assertEquals("123456", $dispute->referenceNumber);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130410-105039'), $dispute->updatedAt);
        $this->assertNull($dispute->evidence[0]->comment);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130411-105039'), $dispute->evidence[0]->createdAt);
        $this->assertNull($dispute->evidence[0]->category);
        $this->assertEquals('evidence1', $dispute->evidence[0]->id);
        $this->assertNull($dispute->evidence[0]->sentToProcessorAt);
        $this->assertNull($dispute->evidence[0]->sequenceNumber);
        $this->assertEquals('url_of_file_evidence', $dispute->evidence[0]->url);
        $this->assertEquals('text evidence', $dispute->evidence[1]->comment);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130411-105039'), $dispute->evidence[1]->createdAt);
        $this->assertEquals('evidence2', $dispute->evidence[1]->id);
        $this->assertEquals('2009-04-11', $dispute->evidence[1]->sentToProcessorAt);
        $this->assertNull($dispute->evidence[1]->url);
        $this->assertEquals('2013-04-10', $dispute->statusHistory[0]->effectiveDate);
        $this->assertEquals('open', $dispute->statusHistory[0]->status);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130410-105039'), $dispute->statusHistory[0]->timestamp);
    }

public function testConstructorHandlesNullFields()
    {
        $emptyAttributes = [
            'amount' => NULL,
            'dateOpened' => NULL,
            'dateWon' => NULL,
            'evidence' => NULL,
            'replyByDate' => NULL,
            'statusHistory' => NULL
        ];

$attrs = array_merge([], $this->attributes, $emptyAttributes);

$dispute = Braintree\Dispute::factory($attrs);

$this->assertNull($dispute->amount);
        $this->assertNull($dispute->dateOpened);
        $this->assertNull($dispute->dateWon);
        $this->assertNull($dispute->evidence);
        $this->assertNull($dispute->replyByDate);
        $this->assertNull($dispute->statusHistory);
    }

public function testConstructorPopulatesTransaction()
    {
        $dispute = Braintree\Dispute::factory($this->attributes);

$this->assertEquals('transaction_id', $dispute->transaction->id);
        $this->assertEquals('100.00', $dispute->transaction->amount);
        $this->assertEquals(DateTime::createFromFormat('Ymd-His', '20130319-105039'), $dispute->transaction->createdAt);
        $this->assertNull($dispute->transaction->orderId);
        $this->assertEquals('po', $dispute->transaction->purchaseOrderNumber);
        $this->assertEquals('Visa', $dispute->transaction->paymentInstrumentSubtype);
    }

public function testAcceptNullRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id "" not found');

Braintree\Dispute::accept(null);
    }

public function testAcceptEmptyIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id " " not found');

Braintree\Dispute::accept(" ");
    }

public function testAddTextEvidenceEmptyIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id " " not found');

Braintree\Dispute::addTextEvidence(" ", "evidence");
    }

public function testAddTextEvidenceNullIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id "" not found');

Braintree\Dispute::addTextEvidence(null, "evidence");
    }

public function testAddTextEvidenceEmptyEvidenceRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'content cannot be blank');

Braintree\Dispute::addTextEvidence("disputeId", " ");
    }

public function testAddTextEvidenceNullEvidenceRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'content cannot be blank');

Braintree\Dispute::addTextEvidence("disputeId", null);
    }

public function testAddTextEvidenceBlankRequestContentRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'content cannot be blank');

Braintree\Dispute::addTextEvidence("disputeId",
            [
                'content' => ' ',
                'category' => 'CARRIER_NAME',
                'sequenceNumber' => '0',
            ]
        );
    }

public function testAddTextEvidenceNullRequestContentRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'content cannot be blank');

Braintree\Dispute::addTextEvidence("disputeId",
            [
                'content' => null,
                'category' => 'CARRIER_NAME',
                'sequenceNumber' => '0',
            ]
        );
    }

public function testAddTextEvidenceBlankRequestCategoryRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'category cannot be blank');

Braintree\Dispute::addTextEvidence("disputeId",
            [
                'content' => 'UPS',
                'category' => '',
                'sequenceNumber' => '0',
            ]
        );
    }

public function testAddTextEvidenceBlankRequestSequenceNumberRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'sequenceNumber cannot be blank');

Braintree\Dispute::addTextEvidence("disputeId",
            [
                'content' => 'UPS',
                'category' => 'CARRIER_NAME',
                'sequenceNumber' => '',
            ]
        );
    }

public function testAddTextEvidenceNonIntegerNumberRequestSequenceNumberRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'sequenceNumber must be an int');

Braintree\Dispute::addTextEvidence("disputeId",
            [
                'content' => 'UPS',
                'category' => 'CARRIER_NAME',
                'sequenceNumber' => '4.5',
            ]
        );
    }

public function testAddTextEvidenceNonIntegerStringRequestSequenceNumberRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'sequenceNumber must be an int');

Braintree\Dispute::addTextEvidence("disputeId",
            [
                'content' => 'UPS',
                'category' => 'CARRIER_NAME',
                'sequenceNumber' => 'Blah',
            ]
        );
    }

public function testAddFileEvidenceEmptyIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id " " not found');

Braintree\Dispute::addFileEvidence(" ", 1);
    }

public function testAddFileEvidenceNullIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id "" not found');

Braintree\Dispute::addFileEvidence(null, 1);
    }

public function testAddFileEvidenceEmptyEvidenceRaisesValueException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'document with id " " not found');

Braintree\Dispute::addFileEvidence("disputeId", " ");
    }

public function testAddFileEvidenceNullEvidenceRaisesValueException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'document with id "" not found');

Braintree\Dispute::addFileEvidence("disputeId", null);
    }

public function testAddFileEvidenceBlankRequestContentRaisesValueException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'document with id " " not found');

Braintree\Dispute::addFileEvidence("disputeId",
            [
                'documentId' => ' ',
                'category' => 'GENERAL',
            ]
        );
    }

public function testAddFileEvidenceNullRequestContentRaisesValueException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'document with id "" not found');

Braintree\Dispute::addFileEvidence("disputeId",
            [
                'documentId' => null,
                'category' => 'GENERAL',
            ]
        );
    }

public function testAddFileEvidenceBlankRequestCategoryRaisesValueException()
    {
        $this->setExpectedException('InvalidArgumentException', 'category cannot be blank');

Braintree\Dispute::addFileEvidence("disputeId",
            [
                'documentId' => '123',
                'category' => '',
            ]
        );
    }

public function testFinalizeNullRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id "" not found');

Braintree\Dispute::finalize(null);
    }

public function testFinalizeEmptyIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id " " not found');

Braintree\Dispute::finalize(" ");
    }

public function testFindingNullRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id "" not found');

Braintree\Dispute::find(null);
    }

public function testFindingEmptyIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'dispute with id " " not found');

Braintree\Dispute::find(" ");
    }

public function testRemoveEvidenceEmptyDisputeIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'evidence with id "evidence" for dispute with id " " not found');

Braintree\Dispute::removeEvidence(" ", "evidence");
    }

public function testRemoveEvidenceNullDisputeIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'evidence with id "evidence" for dispute with id "" not found');

Braintree\Dispute::removeEvidence(null, "evidence");
    }

public function testRemoveEvidenceEvidenceNullIdRaisesNotFoundException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'evidence with id "" for dispute with id "dispute_id" not found');

Braintree\Dispute::removeEvidence("dispute_id", null);
    }

public function testRemoveEvidenceEmptyEvidenceIdRaisesValueException()
    {
        $this->setExpectedException('Braintree\Exception\NotFound', 'evidence with id " " for dispute with id "dispute_id" not found');

Braintree\Dispute::removeEvidence("dispute_id", " ");
    }
}

cmd: