HtmlTest::testCanApplyAlignment() - Code Metrics - Inspection of "Borders are complete even on rowspanned columns us..." - PHPOffice/PhpSpreadsheet - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7cb488...7e1257 )

by Adrien

created 2020-07-19 05:05 UTC

HtmlTest::testCanApplyAlignment() A

↳ Parent: HtmlTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	35
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	17
nc	1
nop	0
dl	0
loc	35
rs	9.7
c	0
b	0
f	0

<?php

namespace PhpOffice\PhpSpreadsheetTests\Reader;

use PhpOffice\PhpSpreadsheet\Reader\Html;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Font;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
use PHPUnit\Framework\TestCase;

class HtmlTest extends TestCase
{
    public function testCsvWithAngleBracket(): void
    {
        $filename = 'tests/data/Reader/HTML/csv_with_angle_bracket.csv';
        $reader = new Html();
        self::assertFalse($reader->canRead($filename));
    }

    public function providerCanReadVerySmallFile()
    {
        $padding = str_repeat('a', 2048);

        return [
            [true, ' <html> ' . $padding . ' </html> '],
            [true, ' <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html>' . $padding . '</html>'],
            [true, '<html></html>'],
            [false, ''],
        ];
    }

    /**
     * @dataProvider providerCanReadVerySmallFile
     *
     * @param bool $expected
     * @param string $content
     */
    public function testCanReadVerySmallFile($expected, $content): void
    {
        $filename = $this->createHtml($content);
        $reader = new Html();
        $actual = $reader->canRead($filename);

        self::assertSame($expected, $actual);

        unlink($filename);
    }

    public function testBackgroundColorInRanding(): void
    {
        $html = '<table>
                    <tr>
                        <td style="background-color: #000000;color: #FFFFFF">Blue background</td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);
        $style = $firstSheet->getCell('A1')->getStyle();

        self::assertEquals('FFFFFF', $style->getFont()->getColor()->getRGB());

        unlink($filename);
    }

    public function testCanApplyInlineBordersStyles(): void
    {
        $html = '<table>
                    <tr>
                        <td style="border: 1px solid #333333;">Thin border</td>
                        <td style="border-bottom: 1px solid #333333;">Border bottom</td>
                        <td style="border-top: 1px solid #333333;">Border top</td>
                        <td style="border-left: 1px solid #333333;">Border left</td>
                        <td style="border-right: 1px solid #333333;">Border right</td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);
        $style = $firstSheet->getCell('A1')->getStyle();
        $borders = $style->getBorders();

        /** @var Border $border */
        foreach ([$borders->getTop(), $borders->getBottom(), $borders->getLeft(), $borders->getRight()] as $border) {
            self::assertEquals('333333', $border->getColor()->getRGB());
            self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());
        }

        $style = $firstSheet->getCell('B1')->getStyle();
        $border = $style->getBorders()->getBottom();
        self::assertEquals('333333', $border->getColor()->getRGB());
        self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());

        $style = $firstSheet->getCell('C1')->getStyle();
        $border = $style->getBorders()->getTop();
        self::assertEquals('333333', $border->getColor()->getRGB());
        self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());

        $style = $firstSheet->getCell('D1')->getStyle();
        $border = $style->getBorders()->getLeft();
        self::assertEquals('333333', $border->getColor()->getRGB());
        self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());

        $style = $firstSheet->getCell('E1')->getStyle();
        $border = $style->getBorders()->getRight();
        self::assertEquals('333333', $border->getColor()->getRGB());
        self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());

        unlink($filename);
    }

    public function testCanApplyInlineFontStyles(): void
    {
        $html = '<table>
                    <tr>
                        <td style="font-size: 16px;">16px</td>
                        <td style="font-family: \'Times New Roman\'">Times New Roman</td>
                        <td style="font-weight: bold;">Bold</td>
                        <td style="font-style: italic;">Italic</td>
                        <td style="text-decoration: underline;">Underline</td>
                        <td style="text-decoration: line-through;">Line through</td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);

        $style = $firstSheet->getCell('A1')->getStyle();
        self::assertEquals(16, $style->getFont()->getSize());

        $style = $firstSheet->getCell('B1')->getStyle();
        self::assertEquals('Times New Roman', $style->getFont()->getName());

        $style = $firstSheet->getCell('C1')->getStyle();
        self::assertTrue($style->getFont()->getBold());

        $style = $firstSheet->getCell('D1')->getStyle();
        self::assertTrue($style->getFont()->getItalic());

        $style = $firstSheet->getCell('E1')->getStyle();
        self::assertEquals(Font::UNDERLINE_SINGLE, $style->getFont()->getUnderline());

        $style = $firstSheet->getCell('F1')->getStyle();
        self::assertTrue($style->getFont()->getStrikethrough());

        unlink($filename);
    }

    public function testCanApplyInlineWidth(): void
    {
        $html = '<table>
                    <tr>
                        <td width="50">50px</td>
                        <td style="width: 100px;">100px</td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);

        $dimension = $firstSheet->getColumnDimension('A');
        self::assertEquals(50, $dimension->getWidth());

        $dimension = $firstSheet->getColumnDimension('B');
        self::assertEquals(100, $dimension->getWidth());

        unlink($filename);
    }

    public function testCanApplyInlineHeight(): void
    {
        $html = '<table>
                    <tr>
                        <td height="50">1</td>
                    </tr>
                    <tr>
                        <td style="height: 100px;">2</td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);

        $dimension = $firstSheet->getRowDimension(1);
        self::assertEquals(50, $dimension->getRowHeight());

        $dimension = $firstSheet->getRowDimension(2);
        self::assertEquals(100, $dimension->getRowHeight());

        unlink($filename);
    }

    public function testCanApplyAlignment(): void
    {
        $html = '<table>
                    <tr>
                        <td align="center">Center align</td>
                        <td valign="center">Center valign</td>
                        <td style="text-align: center;">Center align</td>
                        <td style="vertical-align: center;">Center valign</td>
                        <td style="text-indent: 10px;">Text indent</td>
                        <td style="word-wrap: break-word;">Wraptext</td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);

        $style = $firstSheet->getCell('A1')->getStyle();
        self::assertEquals(Alignment::HORIZONTAL_CENTER, $style->getAlignment()->getHorizontal());

        $style = $firstSheet->getCell('B1')->getStyle();
        self::assertEquals(Alignment::VERTICAL_CENTER, $style->getAlignment()->getVertical());

        $style = $firstSheet->getCell('C1')->getStyle();
        self::assertEquals(Alignment::HORIZONTAL_CENTER, $style->getAlignment()->getHorizontal());

        $style = $firstSheet->getCell('D1')->getStyle();
        self::assertEquals(Alignment::VERTICAL_CENTER, $style->getAlignment()->getVertical());

        $style = $firstSheet->getCell('E1')->getStyle();
        self::assertEquals(10, $style->getAlignment()->getIndent());

        $style = $firstSheet->getCell('F1')->getStyle();
        self::assertTrue($style->getAlignment()->getWrapText());

        unlink($filename);
    }

    public function testCanApplyInlineDataFormat(): void
    {
        $html = '<table>
                    <tr>
                        <td data-format="mmm-yy">2019-02-02 12:34:00</td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);

        $style = $firstSheet->getCell('A1')->getStyle();
        self::assertEquals('mmm-yy', $style->getNumberFormat()->getFormatCode());

        unlink($filename);
    }

    public function testCanInsertImage(): void
    {
        $imagePath = realpath(__DIR__ . '/../../data/Reader/HTML/image.jpg');

        $html = '<table>
                    <tr>
                        <td><img src="' . $imagePath . '" alt=""></td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);

        /** @var Drawing $drawing */
        $drawing = $firstSheet->getDrawingCollection()[0];
        self::assertEquals($imagePath, $drawing->getPath());
        self::assertEquals('A1', $drawing->getCoordinates());

        unlink($filename);
    }

    public function testCanApplyCellWrapping(): void
    {
        $html = '<table>
                    <tr>
                        <td>Hello World</td>
                    </tr>
                    <tr>
                        <td>Hello<br />World</td>
                    </tr>
                    <tr>
                        <td>Hello<br>World</td>
                    </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);

        $cellStyle = $firstSheet->getStyle('A1');
        self::assertFalse($cellStyle->getAlignment()->getWrapText());

        $cellStyle = $firstSheet->getStyle('A2');
        self::assertTrue($cellStyle->getAlignment()->getWrapText());
        $cellValue = $firstSheet->getCell('A2')->getValue();
        self::assertStringContainsString("\n", $cellValue);

        $cellStyle = $firstSheet->getStyle('A3');
        self::assertTrue($cellStyle->getAlignment()->getWrapText());
        $cellValue = $firstSheet->getCell('A3')->getValue();
        self::assertStringContainsString("\n", $cellValue);

        unlink($filename);
    }

    public function testCanLoadFromString(): void
    {
        $html = '<table>
                    <tr>
                        <td>Hello World</td>
                    </tr>
                    <tr>
                        <td>Hello<br />World</td>
                    </tr>
                    <tr>
                        <td>Hello<br>World</td>
                    </tr>
                </table>';
        $spreadsheet = (new Html())->loadFromString($html);
        $firstSheet = $spreadsheet->getSheet(0);

        $cellStyle = $firstSheet->getStyle('A1');
        self::assertFalse($cellStyle->getAlignment()->getWrapText());

        $cellStyle = $firstSheet->getStyle('A2');
        self::assertTrue($cellStyle->getAlignment()->getWrapText());
        $cellValue = $firstSheet->getCell('A2')->getValue();
        self::assertStringContainsString("\n", $cellValue);

        $cellStyle = $firstSheet->getStyle('A3');
        self::assertTrue($cellStyle->getAlignment()->getWrapText());
        $cellValue = $firstSheet->getCell('A3')->getValue();
        self::assertStringContainsString("\n", $cellValue);
    }

    public function testCanLoadFromStringIntoExistingSpreadsheet(): void
    {
        $html = '<table>
                    <tr>
                        <td>Hello World</td>
                    </tr>
                    <tr>
                        <td>Hello<br />World</td>
                    </tr>
                    <tr>
                        <td>Hello<br>World</td>
                    </tr>
                </table>';
        $reader = new Html();
        $spreadsheet = $reader->loadFromString($html);
        $firstSheet = $spreadsheet->getSheet(0);

        $cellStyle = $firstSheet->getStyle('A1');
        self::assertFalse($cellStyle->getAlignment()->getWrapText());

        $cellStyle = $firstSheet->getStyle('A2');
        self::assertTrue($cellStyle->getAlignment()->getWrapText());
        $cellValue = $firstSheet->getCell('A2')->getValue();
        self::assertStringContainsString("\n", $cellValue);

        $cellStyle = $firstSheet->getStyle('A3');
        self::assertTrue($cellStyle->getAlignment()->getWrapText());
        $cellValue = $firstSheet->getCell('A3')->getValue();
        self::assertStringContainsString("\n", $cellValue);

        $reader->setSheetIndex(1);
        $html = '<table>
                    <tr>
                        <td>Goodbye World</td>
                    </tr>
                </table>';

        self::assertEquals(1, $spreadsheet->getSheetCount());
        $spreadsheet = $reader->loadFromString($html, $spreadsheet);
        self::assertEquals(2, $spreadsheet->getSheetCount());
    }

    /**
     * @param string $html
     *
     * @return string
     */
    private function createHtml($html)
    {
        $filename = tempnam(sys_get_temp_dir(), 'html');
        file_put_contents($filename, $html);

        return $filename;
    }

    /**
     * @param $filename
     *
     * @return \PhpOffice\PhpSpreadsheet\Spreadsheet
     */
    private function loadHtmlIntoSpreadsheet($filename)
    {
        return (new Html())->load($filename);
    }

    public function testRowspanInRendering(): void
    {
        $filename = 'tests/data/Reader/HTML/rowspan.html';
        $reader = new Html();
        $spreadsheet = $reader->load($filename);

        $actual = $spreadsheet->getActiveSheet()->getMergeCells();
        self::assertSame(['A2:C2' => 'A2:C2'], $actual);
    }

    public function testTextIndentUseRowspan(): void
    {
        $html = '<table>
                  <tr>
                    <td>1</td>
                    <td rowspan="2" style="vertical-align: center;">Center Align</td>
                    <td>Row</td>
                  </tr>
                  <tr>
                    <td>2</td>
                    <td style="text-indent:10px">Text Indent</td>
                  </tr>
                </table>';
        $filename = $this->createHtml($html);
        $spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
        $firstSheet = $spreadsheet->getSheet(0);
        $style = $firstSheet->getCell('C2')->getStyle();
        self::assertEquals(10, $style->getAlignment()->getIndent());
        unlink($filename);
    }

    public function testBorderWithRowspanAndColspan(): void
    {
        $html = '<table>
                    <tr>
                        <td style="border: 1px solid black;">NOT SPANNED</td>
                        <td rowspan="2" colspan="2" style="border: 1px solid black;">SPANNED</td>
                    </tr>
                    <tr>
                        <td style="border: 1px solid black;">NOT SPANNED</td>
                    </tr>
                </table>';

        $reader = new Html();
        $spreadsheet = $reader->loadFromString($html);
        $firstSheet = $spreadsheet->getSheet(0);
        $style = $firstSheet->getStyle('B1:C2');

        $borders = $style->getBorders();

        $totalBorders = [
            $borders->getTop(),
            $borders->getLeft(),
            $borders->getBottom(),
            $borders->getRight(),
        ];

        foreach ($totalBorders as $border) {
            self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());
        }
    }
}


1			<?php
2
3			namespace PhpOffice\PhpSpreadsheetTests\Reader;
4
5			use PhpOffice\PhpSpreadsheet\Reader\Html;
6			use PhpOffice\PhpSpreadsheet\Style\Alignment;
7			use PhpOffice\PhpSpreadsheet\Style\Border;
8			use PhpOffice\PhpSpreadsheet\Style\Font;
9			use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
10			use PHPUnit\Framework\TestCase;
11
12			class HtmlTest extends TestCase
13			{
14			public function testCsvWithAngleBracket(): void
15			{
16			$filename = 'tests/data/Reader/HTML/csv_with_angle_bracket.csv';
17			$reader = new Html();
18			self::assertFalse($reader->canRead($filename));
19			}
20
21			public function providerCanReadVerySmallFile()
22			{
23			$padding = str_repeat('a', 2048);
24
25			return [
26			[true, ' <html> ' . $padding . ' </html> '],
27			[true, ' <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html>' . $padding . '</html>'],
28			[true, '<html></html>'],
29			[false, ''],
30			];
31			}
32
33			/**
34			* @dataProvider providerCanReadVerySmallFile
35			*
36			* @param bool $expected
37			* @param string $content
38			*/
39			public function testCanReadVerySmallFile($expected, $content): void
40			{
41			$filename = $this->createHtml($content);
42			$reader = new Html();
43			$actual = $reader->canRead($filename);
44
45			self::assertSame($expected, $actual);
46
47			unlink($filename);
48			}
49
50			public function testBackgroundColorInRanding(): void
51			{
52			$html = '<table>
53			<tr>
54			<td style="background-color: #000000;color: #FFFFFF">Blue background</td>
55			</tr>
56			</table>';
57			$filename = $this->createHtml($html);
58			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
59			$firstSheet = $spreadsheet->getSheet(0);
60			$style = $firstSheet->getCell('A1')->getStyle();
61
62			self::assertEquals('FFFFFF', $style->getFont()->getColor()->getRGB());
63
64			unlink($filename);
65			}
66
67			public function testCanApplyInlineBordersStyles(): void
68			{
69			$html = '<table>
70			<tr>
71			<td style="border: 1px solid #333333;">Thin border</td>
72			<td style="border-bottom: 1px solid #333333;">Border bottom</td>
73			<td style="border-top: 1px solid #333333;">Border top</td>
74			<td style="border-left: 1px solid #333333;">Border left</td>
75			<td style="border-right: 1px solid #333333;">Border right</td>
76			</tr>
77			</table>';
78			$filename = $this->createHtml($html);
79			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
80			$firstSheet = $spreadsheet->getSheet(0);
81			$style = $firstSheet->getCell('A1')->getStyle();
82			$borders = $style->getBorders();
83
84			/** @var Border $border */
85			foreach ([$borders->getTop(), $borders->getBottom(), $borders->getLeft(), $borders->getRight()] as $border) {
86			self::assertEquals('333333', $border->getColor()->getRGB());
87			self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());
88			}
89
90			$style = $firstSheet->getCell('B1')->getStyle();
91			$border = $style->getBorders()->getBottom();
92			self::assertEquals('333333', $border->getColor()->getRGB());
93			self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());
94
95			$style = $firstSheet->getCell('C1')->getStyle();
96			$border = $style->getBorders()->getTop();
97			self::assertEquals('333333', $border->getColor()->getRGB());
98			self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());
99
100			$style = $firstSheet->getCell('D1')->getStyle();
101			$border = $style->getBorders()->getLeft();
102			self::assertEquals('333333', $border->getColor()->getRGB());
103			self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());
104
105			$style = $firstSheet->getCell('E1')->getStyle();
106			$border = $style->getBorders()->getRight();
107			self::assertEquals('333333', $border->getColor()->getRGB());
108			self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());
109
110			unlink($filename);
111			}
112
113			public function testCanApplyInlineFontStyles(): void
114			{
115			$html = '<table>
116			<tr>
117			<td style="font-size: 16px;">16px</td>
118			<td style="font-family: \'Times New Roman\'">Times New Roman</td>
119			<td style="font-weight: bold;">Bold</td>
120			<td style="font-style: italic;">Italic</td>
121			<td style="text-decoration: underline;">Underline</td>
122			<td style="text-decoration: line-through;">Line through</td>
123			</tr>
124			</table>';
125			$filename = $this->createHtml($html);
126			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
127			$firstSheet = $spreadsheet->getSheet(0);
128
129			$style = $firstSheet->getCell('A1')->getStyle();
130			self::assertEquals(16, $style->getFont()->getSize());
131
132			$style = $firstSheet->getCell('B1')->getStyle();
133			self::assertEquals('Times New Roman', $style->getFont()->getName());
134
135			$style = $firstSheet->getCell('C1')->getStyle();
136			self::assertTrue($style->getFont()->getBold());
137
138			$style = $firstSheet->getCell('D1')->getStyle();
139			self::assertTrue($style->getFont()->getItalic());
140
141			$style = $firstSheet->getCell('E1')->getStyle();
142			self::assertEquals(Font::UNDERLINE_SINGLE, $style->getFont()->getUnderline());
143
144			$style = $firstSheet->getCell('F1')->getStyle();
145			self::assertTrue($style->getFont()->getStrikethrough());
146
147			unlink($filename);
148			}
149
150			public function testCanApplyInlineWidth(): void
151			{
152			$html = '<table>
153			<tr>
154			<td width="50">50px</td>
155			<td style="width: 100px;">100px</td>
156			</tr>
157			</table>';
158			$filename = $this->createHtml($html);
159			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
160			$firstSheet = $spreadsheet->getSheet(0);
161
162			$dimension = $firstSheet->getColumnDimension('A');
163			self::assertEquals(50, $dimension->getWidth());
164
165			$dimension = $firstSheet->getColumnDimension('B');
166			self::assertEquals(100, $dimension->getWidth());
167
168			unlink($filename);
169			}
170
171			public function testCanApplyInlineHeight(): void
172			{
173			$html = '<table>
174			<tr>
175			<td height="50">1</td>
176			</tr>
177			<tr>
178			<td style="height: 100px;">2</td>
179			</tr>
180			</table>';
181			$filename = $this->createHtml($html);
182			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
183			$firstSheet = $spreadsheet->getSheet(0);
184
185			$dimension = $firstSheet->getRowDimension(1);
186			self::assertEquals(50, $dimension->getRowHeight());
187
188			$dimension = $firstSheet->getRowDimension(2);
189			self::assertEquals(100, $dimension->getRowHeight());
190
191			unlink($filename);
192			}
193
194			public function testCanApplyAlignment(): void
195			{
196			$html = '<table>
197			<tr>
198			<td align="center">Center align</td>
199			<td valign="center">Center valign</td>
200			<td style="text-align: center;">Center align</td>
201			<td style="vertical-align: center;">Center valign</td>
202			<td style="text-indent: 10px;">Text indent</td>
203			<td style="word-wrap: break-word;">Wraptext</td>
204			</tr>
205			</table>';
206			$filename = $this->createHtml($html);
207			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
208			$firstSheet = $spreadsheet->getSheet(0);
209
210			$style = $firstSheet->getCell('A1')->getStyle();
211			self::assertEquals(Alignment::HORIZONTAL_CENTER, $style->getAlignment()->getHorizontal());
212
213			$style = $firstSheet->getCell('B1')->getStyle();
214			self::assertEquals(Alignment::VERTICAL_CENTER, $style->getAlignment()->getVertical());
215
216			$style = $firstSheet->getCell('C1')->getStyle();
217			self::assertEquals(Alignment::HORIZONTAL_CENTER, $style->getAlignment()->getHorizontal());
218
219			$style = $firstSheet->getCell('D1')->getStyle();
220			self::assertEquals(Alignment::VERTICAL_CENTER, $style->getAlignment()->getVertical());
221
222			$style = $firstSheet->getCell('E1')->getStyle();
223			self::assertEquals(10, $style->getAlignment()->getIndent());
224
225			$style = $firstSheet->getCell('F1')->getStyle();
226			self::assertTrue($style->getAlignment()->getWrapText());
227
228			unlink($filename);
229			}
230
231			public function testCanApplyInlineDataFormat(): void
232			{
233			$html = '<table>
234			<tr>
235			<td data-format="mmm-yy">2019-02-02 12:34:00</td>
236			</tr>
237			</table>';
238			$filename = $this->createHtml($html);
239			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
240			$firstSheet = $spreadsheet->getSheet(0);
241
242			$style = $firstSheet->getCell('A1')->getStyle();
243			self::assertEquals('mmm-yy', $style->getNumberFormat()->getFormatCode());
244
245			unlink($filename);
246			}
247
248			public function testCanInsertImage(): void
249			{
250			$imagePath = realpath(__DIR__ . '/../../data/Reader/HTML/image.jpg');
251
252			$html = '<table>
253			<tr>
254			<td><img src="' . $imagePath . '" alt=""></td>
255			</tr>
256			</table>';
257			$filename = $this->createHtml($html);
258			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
259			$firstSheet = $spreadsheet->getSheet(0);
260
261			/** @var Drawing $drawing */
262			$drawing = $firstSheet->getDrawingCollection()[0];
263			self::assertEquals($imagePath, $drawing->getPath());
264			self::assertEquals('A1', $drawing->getCoordinates());
265
266			unlink($filename);
267			}
268
269			public function testCanApplyCellWrapping(): void
270			{
271			$html = '<table>
272			<tr>
273			<td>Hello World</td>
274			</tr>
275			<tr>
276			<td>Hello<br />World</td>
277			</tr>
278			<tr>
279			<td>Hello<br>World</td>
280			</tr>
281			</table>';
282			$filename = $this->createHtml($html);
283			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
284			$firstSheet = $spreadsheet->getSheet(0);
285
286			$cellStyle = $firstSheet->getStyle('A1');
287			self::assertFalse($cellStyle->getAlignment()->getWrapText());
288
289			$cellStyle = $firstSheet->getStyle('A2');
290			self::assertTrue($cellStyle->getAlignment()->getWrapText());
291			$cellValue = $firstSheet->getCell('A2')->getValue();
292			self::assertStringContainsString("\n", $cellValue);
293
294			$cellStyle = $firstSheet->getStyle('A3');
295			self::assertTrue($cellStyle->getAlignment()->getWrapText());
296			$cellValue = $firstSheet->getCell('A3')->getValue();
297			self::assertStringContainsString("\n", $cellValue);
298
299			unlink($filename);
300			}
301
302			public function testCanLoadFromString(): void
303			{
304			$html = '<table>
305			<tr>
306			<td>Hello World</td>
307			</tr>
308			<tr>
309			<td>Hello<br />World</td>
310			</tr>
311			<tr>
312			<td>Hello<br>World</td>
313			</tr>
314			</table>';
315			$spreadsheet = (new Html())->loadFromString($html);
316			$firstSheet = $spreadsheet->getSheet(0);
317
318			$cellStyle = $firstSheet->getStyle('A1');
319			self::assertFalse($cellStyle->getAlignment()->getWrapText());
320
321			$cellStyle = $firstSheet->getStyle('A2');
322			self::assertTrue($cellStyle->getAlignment()->getWrapText());
323			$cellValue = $firstSheet->getCell('A2')->getValue();
324			self::assertStringContainsString("\n", $cellValue);
325
326			$cellStyle = $firstSheet->getStyle('A3');
327			self::assertTrue($cellStyle->getAlignment()->getWrapText());
328			$cellValue = $firstSheet->getCell('A3')->getValue();
329			self::assertStringContainsString("\n", $cellValue);
330			}
331
332			public function testCanLoadFromStringIntoExistingSpreadsheet(): void
333			{
334			$html = '<table>
335			<tr>
336			<td>Hello World</td>
337			</tr>
338			<tr>
339			<td>Hello<br />World</td>
340			</tr>
341			<tr>
342			<td>Hello<br>World</td>
343			</tr>
344			</table>';
345			$reader = new Html();
346			$spreadsheet = $reader->loadFromString($html);
347			$firstSheet = $spreadsheet->getSheet(0);
348
349			$cellStyle = $firstSheet->getStyle('A1');
350			self::assertFalse($cellStyle->getAlignment()->getWrapText());
351
352			$cellStyle = $firstSheet->getStyle('A2');
353			self::assertTrue($cellStyle->getAlignment()->getWrapText());
354			$cellValue = $firstSheet->getCell('A2')->getValue();
355			self::assertStringContainsString("\n", $cellValue);
356
357			$cellStyle = $firstSheet->getStyle('A3');
358			self::assertTrue($cellStyle->getAlignment()->getWrapText());
359			$cellValue = $firstSheet->getCell('A3')->getValue();
360			self::assertStringContainsString("\n", $cellValue);
361
362			$reader->setSheetIndex(1);
363			$html = '<table>
364			<tr>
365			<td>Goodbye World</td>
366			</tr>
367			</table>';
368
369			self::assertEquals(1, $spreadsheet->getSheetCount());
370			$spreadsheet = $reader->loadFromString($html, $spreadsheet);
371			self::assertEquals(2, $spreadsheet->getSheetCount());
372			}
373
374			/**
375			* @param string $html
376			*
377			* @return string
378			*/
379			private function createHtml($html)
380			{
381			$filename = tempnam(sys_get_temp_dir(), 'html');
382			file_put_contents($filename, $html);
383
384			return $filename;
385			}
386
387			/**
388			* @param $filename
389			*
390			* @return \PhpOffice\PhpSpreadsheet\Spreadsheet
391			*/
392			private function loadHtmlIntoSpreadsheet($filename)
393			{
394			return (new Html())->load($filename);
395			}
396
397			public function testRowspanInRendering(): void
398			{
399			$filename = 'tests/data/Reader/HTML/rowspan.html';
400			$reader = new Html();
401			$spreadsheet = $reader->load($filename);
402
403			$actual = $spreadsheet->getActiveSheet()->getMergeCells();
404			self::assertSame(['A2:C2' => 'A2:C2'], $actual);
405			}
406
407			public function testTextIndentUseRowspan(): void
408			{
409			$html = '<table>
410			<tr>
411			<td>1</td>
412			<td rowspan="2" style="vertical-align: center;">Center Align</td>
413			<td>Row</td>
414			</tr>
415			<tr>
416			<td>2</td>
417			<td style="text-indent:10px">Text Indent</td>
418			</tr>
419			</table>';
420			$filename = $this->createHtml($html);
421			$spreadsheet = $this->loadHtmlIntoSpreadsheet($filename);
422			$firstSheet = $spreadsheet->getSheet(0);
423			$style = $firstSheet->getCell('C2')->getStyle();
424			self::assertEquals(10, $style->getAlignment()->getIndent());
425			unlink($filename);
426			}
427
428			public function testBorderWithRowspanAndColspan(): void
429			{
430			$html = '<table>
431			<tr>
432			<td style="border: 1px solid black;">NOT SPANNED</td>
433			<td rowspan="2" colspan="2" style="border: 1px solid black;">SPANNED</td>
434			</tr>
435			<tr>
436			<td style="border: 1px solid black;">NOT SPANNED</td>
437			</tr>
438			</table>';
439
440			$reader = new Html();
441			$spreadsheet = $reader->loadFromString($html);
442			$firstSheet = $spreadsheet->getSheet(0);
443			$style = $firstSheet->getStyle('B1:C2');
444
445			$borders = $style->getBorders();
446
447			$totalBorders = [
448			$borders->getTop(),
449			$borders->getLeft(),
450			$borders->getBottom(),
451			$borders->getRight(),
452			];
453
454			foreach ($totalBorders as $border) {
455			self::assertEquals(Border::BORDER_THIN, $border->getBorderStyle());
456			}
457			}
458			}
459

PHPOffice / PhpSpreadsheet

Push — master ( 7cb488...7e1257 )

HtmlTest::testCanApplyAlignment() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like