ParserTest::convertSgmlToXmlProvider() - Code Metrics - Inspection of "Set XDEBUG_MODE" - jacques/ofxparser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (e17e02)

by Jacques

created 2021-03-02 16:18 UTC

ParserTest::convertSgmlToXmlProvider() A

↳ Parent: ParserTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	38
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	19
c	0
b	0
f	0
dl	0
loc	38
rs	9.6333
cc	1
nc	1
nop	0

<?php

namespace OfxParserTest;

use PHPUnit\Framework\TestCase;
use OfxParser\Parser;

/**
 * @covers OfxParser\Parser
 */
class ParserTest extends TestCase
{
    public function testCreditCardStatementTransactionsAreLoaded()
    {
        $parser = new Parser();
        $ofx = $parser->loadFromFile(__DIR__ . '/../fixtures/ofxdata-credit-card.ofx');

        $account = reset($ofx->bankAccounts);
        self::assertSame('1234567891234567', (string)$account->accountNumber);
    }

    public function testParseHeader()
    {
        $parser = new Parser();
        $ofx = $parser->loadFromFile(__DIR__ . '/../fixtures/ofxdata.ofx');

        $header = [
            'OFXHEADER' => '100',
            'DATA' => 'OFXSGML',
            'VERSION' => '103',
            'SECURITY' => 'NONE',
            'ENCODING' => 'USASCII',
            'CHARSET' => '1252',
            'COMPRESSION' => 'NONE',
            'OLDFILEUID' => 'NONE',
            'NEWFILEUID' => 'NONE',
        ];

        self::assertSame($header, $ofx->header);
    }

    public function testParseXMLHeader()
    {
        $parser = new Parser();
        $ofx = $parser->loadFromFile(__DIR__ . '/../fixtures/ofxdata-xml.ofx');

        $header = [
            'OFXHEADER' => '200',
            'VERSION' => '200',
            'SECURITY' => 'NONE',
            'OLDFILEUID' => 'NONE',
            'NEWFILEUID' => 'NONE',
        ];

        self::assertSame($header, $ofx->header);
    }

    public function testXmlLoadStringThrowsExceptionWithInvalidXml()
    {
        $invalidXml = '<invalid xml>';

        $method = new \ReflectionMethod(Parser::class, 'xmlLoadString');
        $method->setAccessible(true);

        try {
            $method->invoke(new Parser(), $invalidXml);
        } catch (\Exception $e) {
            if (stripos($e->getMessage(), 'Failed to parse OFX') !== false) {
                $this->assertTrue(true);
                return true;
            }

            throw $e;
        }

        self::fail('Method xmlLoadString did not raise an expected exception parsing an invalid XML string');
    }

    public function testXmlLoadStringLoadsValidXml()
    {
        $validXml = '<fooRoot><foo>bar</foo></fooRoot>';

        $method = new \ReflectionMethod(Parser::class, 'xmlLoadString');
        $method->setAccessible(true);

        $xml = $method->invoke(new Parser(), $validXml);

        self::assertInstanceOf('SimpleXMLElement', $xml);
        self::assertEquals('bar', (string)$xml->foo);
    }

    /**
     * @return array
     */
    public function closeUnclosedXmlTagsProvider()
    {
        return [
            ['<SOMETHING>', '<SOMETHING>'],
            ['<SOMETHING>foo</SOMETHING>', '<SOMETHING>foo'],
            ['<SOMETHING>foo</SOMETHING>', '<SOMETHING>foo</SOMETHING>'],
            ['<BANKID>XXXXX</BANKID>', '<BANKID>XXXXX</BANKID>'],
            ['<ACCTID>XXXXXXXXXXX</ACCTID>', '<ACCTID>XXXXXXXXXXX</ACCTID>'],
            ['<ACCTID>-198.98</ACCTID>', '<ACCTID>-198.98</ACCTID>'],
            ['<ACCTID>-198.98</ACCTID>', '<ACCTID>-198.98'],
            ['<MEMO></MEMO>', '<MEMO>'],
        ];
    }

    /**
     * @dataProvider closeUnclosedXmlTagsProvider
     * @param $expected
     * @param $input
     */
    public function testCloseUnclosedXmlTags($expected, $input)
    {
        $method = new \ReflectionMethod(Parser::class, 'closeUnclosedXmlTags');
        $method->setAccessible(true);

        $parser = new Parser();

        self::assertEquals($expected, $method->invoke($parser, $input));
    }

    public function convertSgmlToXmlProvider()
    {
        return [
            [<<<HERE
<SOMETHING>
    <FOO>bar
    <BAZ>bat</BAZ>
</SOMETHING>
HERE
        , <<<HERE
<SOMETHING>
<FOO>bar</FOO>
<BAZ>bat</BAZ>
</SOMETHING>
HERE
            ], [<<<HERE
<BANKACCTFROM>
<BANKID>XXXXX</BANKID>
<BRANCHID>XXXXX</BRANCHID>
<ACCTID>XXXXXXXXXXX</ACCTID>
<ACCTTYPE>CHECKING</ACCTTYPE>
</BANKACCTFROM>
HERE
                ,<<<HERE
<BANKACCTFROM>
<BANKID>XXXXX</BANKID>
<BRANCHID>XXXXX</BRANCHID>
<ACCTID>XXXXXXXXXXX</ACCTID>
<ACCTTYPE>CHECKING</ACCTTYPE>
</BANKACCTFROM>
HERE
            ],[<<<HERE
<SOMETHING>
    <FOO>bar & restaurant
    <BAZ>bat</BAZ>
</SOMETHING>
HERE
        , <<<HERE
<SOMETHING>
<FOO>bar &amp; restaurant</FOO>
<BAZ>bat</BAZ>
</SOMETHING>
HERE
            ],
        ];
    }

    /**
     * @dataProvider convertSgmlToXmlProvider
     */
    public function testConvertSgmlToXml($sgml, $expected)
    {
        $method = new \ReflectionMethod(Parser::class, 'convertSgmlToXml');
        $method->setAccessible(true);

        self::assertEquals($expected, $method->invoke(new Parser, $sgml));
    }

    public function testLoadFromFileWhenFileDoesNotExist()
    {
        $this->expectException(\InvalidArgumentException::class);

        $parser = new Parser();
        $parser->loadFromFile('a non-existent file');
    }

    /**
     * @dataProvider loadFromStringProvider
     */
    public function testLoadFromFileWhenFileDoesExist($filename)
    {
        if (!file_exists($filename)) {
            self::markTestSkipped('Could not find data file, cannot test loadFromFile method fully');
        }

        /** @var Parser|\PHPUnit_Framework_MockObject_MockObject $parser */
        $parser = $this->getMockBuilder(Parser::class)
                         ->setMethods(['loadFromString'])
                         ->getMock();
        $parser->expects(self::once())->method('loadFromString');
        $parser->loadFromFile($filename);
    }

    /**
     * @return array
     */
    public function loadFromStringProvider()
    {
        return [
            'ofxdata.ofx' => [dirname(__DIR__).'/fixtures/ofxdata.ofx'],
            'ofxdata-oneline.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-oneline.ofx'],
            'ofxdata-cmfr.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-cmfr.ofx'],
            'ofxdata-bb.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-bb.ofx'],
            'ofxdata-bb-two-stmtrs.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-bb-two-stmtrs.ofx'],
            'ofxdata-credit-card.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-credit-card.ofx'],
            'ofxdata-bpbfc.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-bpbfc.ofx'],
            'ofxdata-memoWithQuotes.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-memoWithQuotes.ofx'],
            'ofxdata-emptyDateTime.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-emptyDateTime.ofx'],
            'ofxdata-memoWithAmpersand.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-memoWithAmpersand.ofx'],
            'ofxdata-banking-xml200.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-banking-xml200.ofx'],
        ];
    }

    /**
     * @param string $filename
     * @throws \Exception
     * @dataProvider loadFromStringProvider
     */
    public function testLoadFromString($filename)
    {
        if (!file_exists($filename)) {
            self::markTestSkipped('Could not find data file, cannot test loadFromString method fully');
        }

        $content = file_get_contents($filename);

        $parser = new Parser();

        try {
            $parser->loadFromString($content);
        } catch (\Exception $e) {
            throw $e;
        }

        $this->assertTrue(true);
    }

    public function testXmlLoadStringWithSelfClosingTag()
    {
        $parser = new Parser();

        try {
            $ofx = $parser->loadFromFile(__DIR__ . '/../fixtures/ofxdata-selfclose.ofx');

        } catch (\RuntimeException $e) {
            if (stripos($e->getMessage(), 'Failed to parse OFX') !== false) {
                self::assertTrue(false, 'Xml with invalid self closing tag');
            }
        }

        self::assertTrue(true);
    }
}


1			<?php
2
3			namespace OfxParserTest;
4
5			use PHPUnit\Framework\TestCase;
6			use OfxParser\Parser;
7
8			/**
9			* @covers OfxParser\Parser
10			*/
11			class ParserTest extends TestCase
12			{
13			public function testCreditCardStatementTransactionsAreLoaded()
14			{
15			$parser = new Parser();
16			$ofx = $parser->loadFromFile(__DIR__ . '/../fixtures/ofxdata-credit-card.ofx');
17
18			$account = reset($ofx->bankAccounts);
19			self::assertSame('1234567891234567', (string)$account->accountNumber);
20			}
21
22			public function testParseHeader()
23			{
24			$parser = new Parser();
25			$ofx = $parser->loadFromFile(__DIR__ . '/../fixtures/ofxdata.ofx');
26
27			$header = [
28			'OFXHEADER' => '100',
29			'DATA' => 'OFXSGML',
30			'VERSION' => '103',
31			'SECURITY' => 'NONE',
32			'ENCODING' => 'USASCII',
33			'CHARSET' => '1252',
34			'COMPRESSION' => 'NONE',
35			'OLDFILEUID' => 'NONE',
36			'NEWFILEUID' => 'NONE',
37			];
38
39			self::assertSame($header, $ofx->header);
40			}
41
42			public function testParseXMLHeader()
43			{
44			$parser = new Parser();
45			$ofx = $parser->loadFromFile(__DIR__ . '/../fixtures/ofxdata-xml.ofx');
46
47			$header = [
48			'OFXHEADER' => '200',
49			'VERSION' => '200',
50			'SECURITY' => 'NONE',
51			'OLDFILEUID' => 'NONE',
52			'NEWFILEUID' => 'NONE',
53			];
54
55			self::assertSame($header, $ofx->header);
56			}
57
58			public function testXmlLoadStringThrowsExceptionWithInvalidXml()
59			{
60			$invalidXml = '<invalid xml>';
61
62			$method = new \ReflectionMethod(Parser::class, 'xmlLoadString');
63			$method->setAccessible(true);
64
65			try {
66			$method->invoke(new Parser(), $invalidXml);
67			} catch (\Exception $e) {
68			if (stripos($e->getMessage(), 'Failed to parse OFX') !== false) {
69			$this->assertTrue(true);
70			return true;
71			}
72
73			throw $e;
74			}
75
76			self::fail('Method xmlLoadString did not raise an expected exception parsing an invalid XML string');
77			}
78
79			public function testXmlLoadStringLoadsValidXml()
80			{
81			$validXml = '<fooRoot><foo>bar</foo></fooRoot>';
82
83			$method = new \ReflectionMethod(Parser::class, 'xmlLoadString');
84			$method->setAccessible(true);
85
86			$xml = $method->invoke(new Parser(), $validXml);
87
88			self::assertInstanceOf('SimpleXMLElement', $xml);
89			self::assertEquals('bar', (string)$xml->foo);
90			}
91
92			/**
93			* @return array
94			*/
95			public function closeUnclosedXmlTagsProvider()
96			{
97			return [
98			['<SOMETHING>', '<SOMETHING>'],
99			['<SOMETHING>foo</SOMETHING>', '<SOMETHING>foo'],
100			['<SOMETHING>foo</SOMETHING>', '<SOMETHING>foo</SOMETHING>'],
101			['<BANKID>XXXXX</BANKID>', '<BANKID>XXXXX</BANKID>'],
102			['<ACCTID>XXXXXXXXXXX</ACCTID>', '<ACCTID>XXXXXXXXXXX</ACCTID>'],
103			['<ACCTID>-198.98</ACCTID>', '<ACCTID>-198.98</ACCTID>'],
104			['<ACCTID>-198.98</ACCTID>', '<ACCTID>-198.98'],
105			['<MEMO></MEMO>', '<MEMO>'],
106			];
107			}
108
109			/**
110			* @dataProvider closeUnclosedXmlTagsProvider
111			* @param $expected
112			* @param $input
113			*/
114			public function testCloseUnclosedXmlTags($expected, $input)
115			{
116			$method = new \ReflectionMethod(Parser::class, 'closeUnclosedXmlTags');
117			$method->setAccessible(true);
118
119			$parser = new Parser();
120
121			self::assertEquals($expected, $method->invoke($parser, $input));
122			}
123
124			public function convertSgmlToXmlProvider()
125			{
126			return [
127			[<<<HERE
128			<SOMETHING>
129			<FOO>bar
130			<BAZ>bat</BAZ>
131			</SOMETHING>
132			HERE
133			, <<<HERE
134			<SOMETHING>
135			<FOO>bar</FOO>
136			<BAZ>bat</BAZ>
137			</SOMETHING>
138			HERE
139			], [<<<HERE
140			<BANKACCTFROM>
141			<BANKID>XXXXX</BANKID>
142			<BRANCHID>XXXXX</BRANCHID>
143			<ACCTID>XXXXXXXXXXX</ACCTID>
144			<ACCTTYPE>CHECKING</ACCTTYPE>
145			</BANKACCTFROM>
146			HERE
147			,<<<HERE
148			<BANKACCTFROM>
149			<BANKID>XXXXX</BANKID>
150			<BRANCHID>XXXXX</BRANCHID>
151			<ACCTID>XXXXXXXXXXX</ACCTID>
152			<ACCTTYPE>CHECKING</ACCTTYPE>
153			</BANKACCTFROM>
154			HERE
155			],[<<<HERE
156			<SOMETHING>
157			<FOO>bar & restaurant
158			<BAZ>bat</BAZ>
159			</SOMETHING>
160			HERE
161			, <<<HERE
162			<SOMETHING>
163			<FOO>bar & restaurant</FOO>
164			<BAZ>bat</BAZ>
165			</SOMETHING>
166			HERE
167			],
168			];
169			}
170
171			/**
172			* @dataProvider convertSgmlToXmlProvider
173			*/
174			public function testConvertSgmlToXml($sgml, $expected)
175			{
176			$method = new \ReflectionMethod(Parser::class, 'convertSgmlToXml');
177			$method->setAccessible(true);
178
179			self::assertEquals($expected, $method->invoke(new Parser, $sgml));
180			}
181
182			public function testLoadFromFileWhenFileDoesNotExist()
183			{
184			$this->expectException(\InvalidArgumentException::class);
185
186			$parser = new Parser();
187			$parser->loadFromFile('a non-existent file');
188			}
189
190			/**
191			* @dataProvider loadFromStringProvider
192			*/
193			public function testLoadFromFileWhenFileDoesExist($filename)
194			{
195			if (!file_exists($filename)) {
196			self::markTestSkipped('Could not find data file, cannot test loadFromFile method fully');
197			}
198
199			/** @var Parser\|\PHPUnit_Framework_MockObject_MockObject $parser */
200			$parser = $this->getMockBuilder(Parser::class)
201			->setMethods(['loadFromString'])
202			->getMock();
203			$parser->expects(self::once())->method('loadFromString');
204			$parser->loadFromFile($filename);
205			}
206
207			/**
208			* @return array
209			*/
210			public function loadFromStringProvider()
211			{
212			return [
213			'ofxdata.ofx' => [dirname(__DIR__).'/fixtures/ofxdata.ofx'],
214			'ofxdata-oneline.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-oneline.ofx'],
215			'ofxdata-cmfr.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-cmfr.ofx'],
216			'ofxdata-bb.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-bb.ofx'],
217			'ofxdata-bb-two-stmtrs.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-bb-two-stmtrs.ofx'],
218			'ofxdata-credit-card.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-credit-card.ofx'],
219			'ofxdata-bpbfc.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-bpbfc.ofx'],
220			'ofxdata-memoWithQuotes.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-memoWithQuotes.ofx'],
221			'ofxdata-emptyDateTime.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-emptyDateTime.ofx'],
222			'ofxdata-memoWithAmpersand.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-memoWithAmpersand.ofx'],
223			'ofxdata-banking-xml200.ofx' => [dirname(__DIR__).'/fixtures/ofxdata-banking-xml200.ofx'],
224			];
225			}
226
227			/**
228			* @param string $filename
229			* @throws \Exception
230			* @dataProvider loadFromStringProvider
231			*/
232			public function testLoadFromString($filename)
233			{
234			if (!file_exists($filename)) {
235			self::markTestSkipped('Could not find data file, cannot test loadFromString method fully');
236			}
237
238			$content = file_get_contents($filename);
239
240			$parser = new Parser();
241
242			try {
243			$parser->loadFromString($content);
244			} catch (\Exception $e) {
245			throw $e;
246			}
247
248			$this->assertTrue(true);
249			}
250
251			public function testXmlLoadStringWithSelfClosingTag()
252			{
253			$parser = new Parser();
254
255			try {
256			$ofx = $parser->loadFromFile(__DIR__ . '/../fixtures/ofxdata-selfclose.ofx');
			0 ignored issues – show Unused Code introduced 2021-03-02 16:20 UTC by Report Bug Copy Issue Report The assignment to `$ofx` is dead and can be removed. Loading history...
257			} catch (\RuntimeException $e) {
258			if (stripos($e->getMessage(), 'Failed to parse OFX') !== false) {
259			self::assertTrue(false, 'Xml with invalid self closing tag');
260			}
261			}
262
263			self::assertTrue(true);
264			}
265			}
266

jacques / ofxparser

Branch — master (e17e02)

ParserTest::convertSgmlToXmlProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like