CsvToMysqlTest::testDefaults() - Code Metrics - logikostech/csv-to-mysql - Measure and Improve Code Quality continuously with Scrutinizer

CsvToMysqlTest::testDefaults() A
last analyzed 2018-06-14 11:14 UTC

↳ Parent: CsvToMysqlTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
c	0
b	0
f	0
rs	9.4285
cc	1
eloc	7
nc	1
nop	0

<?php

namespace LogikosTest\Csv\CsvToMysql;

use Logikos\Csv\CsvToMysql\LoadDataInFile;

class CsvToMysqlTest extends TestCase {
  const DB_NAME_AND_TABLE = 'staging.people';

  public function testLoadDataInFile() {
    $this->assertInstanceOf(LoadDataInFile::class, new LoadDataInFile());
  }

  /** @dataProvider delimiters */
  public function testSetAndGetDelimiter($delimiter) {
    $ld = new LoadDataInFile();
    $ld->setDelimiter($delimiter);
    $this->assertSame($delimiter, $ld->getDelimiter());
  }
  public function delimiters() { return [[','], ["\t"], ['|']]; }

  /** @dataProvider enclosures */
  public function testSetAndGetEnclosure($enclosure) {
    $ld = new LoadDataInFile();
    $ld->setEnclosure($enclosure);
    $this->assertSame($enclosure, $ld->getEnclosure());
  }
  public function enclosures() { return [['"'], ['\''], ['`']]; }

  /** @dataProvider escapes */
  public function testSetAndGetEscape($escape) {
    $ld = new LoadDataInFile();
    $ld->setEscape($escape);
    $this->assertSame($escape, $ld->getEscape());
  }
  public function escapes() { return [['\\'], ['`']]; }

  /** @dataProvider ignoreLines */
  public function testSetAndGetIgnoreLines($lines) {
    $ld = new LoadDataInFile();
    $ld->setIgnoreLines($lines);
    $this->assertSame($lines, $ld->getIgnoreLines());
  }
  public function ignoreLines() { return [[0], [1], [2]]; }

  public function testDefaults() {
    $ld = new LoadDataInFile();
    $this->assertSame(',',   $ld->getDelimiter());
    $this->assertSame('"',   $ld->getEnclosure());
    $this->assertSame('\\',  $ld->getEscape());
    $this->assertSame('\\n', $ld->getEOL());
    $this->assertSame(0,     $ld->getIgnoreLines());
  }

  public function testSetAndGetTableName() {
    $ld = new LoadDataInFile();
    $ld->setTableName(self::DB_NAME_AND_TABLE);
    $this->assertSame(self::DB_NAME_AND_TABLE, $ld->getTableName());
  }

  public function testSetAndGetEOL() {
    $ld = new LoadDataInFile();
    $ld->setEOL(";");
    $this->assertSame(";", $ld->getEOL());
  }

  public function testSetAndGetCsvFile() {
    $csvFile = $this->csvFile();
    $ld = new LoadDataInFile();
    $ld->setCsvFile($csvFile);
    $this->assertSame($csvFile, $ld->getCsvFile());
  }

  public function testColumnMap() {
    $ld = new LoadDataInFile();
    $map = ['firstname', 'lastname', null, null, 'age'];
    $ld->setColMap($map);
    $expected = 'firstname = @col1, lastname = @col2, age = @col5';
    $this->assertEquals(
        $this->normalizeWhitespace($expected),
        $this->normalizeWhitespace($ld->getSetExpression())
    );
    $this->assertEquals(
        ['@col1', '@col2', '@col3', '@col4', '@col5'],
        $ld->getColVars()
    );
    $this->assertEquals($map, $ld->getColMap());
  }

  public function testStaticColumns() {
    $ld = new LoadDataInFile();
    $binds = [
        'request_id' => 23,
        'cdate' => '2018-06-12'
    ];
    $ld->SetColumnBinds($binds);
    $this->assertSame($binds, $ld->getColumnBinds());
    $this->assertEquals(
        $this->normalizeWhitespace("request_id = :request_id, cdate = :cdate"),
        $this->normalizeWhitespace($ld->getSetExpression())
    );
    $this->assertEquals(
        [':request_id'=>23, ':cdate'=>'2018-06-12'],
        $ld->getBinds()
    );
  }

  public function testGetSetExpressionIncludesColMapAndColBinds() {
    $ld = new LoadDataInFile();
    $ld->setColMap(['firstname']);
    $ld->setColumnBinds(['request_id'=>23]);
    $expected = "firstname = @col1, request_id = :request_id";
    $this->assertEquals(
        $this->normalizeWhitespace($expected),
        $this->normalizeWhitespace($ld->getSetExpression())
    );
  }

  public function testSQL() {
    $file = $this->csvFile();

    $ld = new LoadDataInFile();
    $ld->setCsvFile($file);
    $ld->setTableName(self::DB_NAME_AND_TABLE);
    $ld->setIgnoreLines(3);
    $ld->setColMap([
        'firstname',
        'lastname',
        null,
        null,
        'age'
    ]);
    $ld->setColumnBinds([
        'request_id'=>23, 'cdate' => '2018-06-12'
    ]);

    $expectedSql  = "
      LOAD DATA LOCAL INFILE '{$file}'
      INTO TABLE ".self::DB_NAME_AND_TABLE."
      FIELDS TERMINATED BY ','
      OPTIONALLY ENCLOSED BY '\"'
      ESCAPED BY '\\\\'
      LINES TERMINATED BY '\\n'
      IGNORE 3 LINES
      ( @col1, @col2, @col3, @col4, @col5 )
      SET firstname = @col1, lastname = @col2, age = @col5,
      request_id = :request_id, cdate = :cdate
    ";

    $this->assertSame(
        $this->normalizeWhitespace($expectedSql),
        $this->normalizeWhitespace($ld->getQuery())
    );
  }

  protected function normalizeWhitespace($string) {
    return trim(
        $this->forceSingleSpaces(
            $this->forceSingleLine($string)
        )
    );
  }
  protected function forceSingleSpaces($string) {
    return preg_replace('/ {2,}/', ' ', $string);
  }
  protected function forceSingleLine($string) {
    return str_replace(PHP_EOL, ' ', $string);
  }

  protected function csvFile() {
    $csvFile = $this->buildCsvFromArray([
        ['name', 'age'],
        ['adam', 30],
        ['bob',  31],
        ['cody', 32]
    ]);
    return $csvFile;
  }

}

1			<?php
2
3			namespace LogikosTest\Csv\CsvToMysql;
4
5			use Logikos\Csv\CsvToMysql\LoadDataInFile;
6
7			class CsvToMysqlTest extends TestCase {
8			const DB_NAME_AND_TABLE = 'staging.people';
9
10			public function testLoadDataInFile() {
11			$this->assertInstanceOf(LoadDataInFile::class, new LoadDataInFile());
12			}
13
14			/** @dataProvider delimiters */
15			public function testSetAndGetDelimiter($delimiter) {
16			$ld = new LoadDataInFile();
17			$ld->setDelimiter($delimiter);
18			$this->assertSame($delimiter, $ld->getDelimiter());
19			}
20			public function delimiters() { return [[','], ["\t"], ['\|']]; }
21
22			/** @dataProvider enclosures */
23			public function testSetAndGetEnclosure($enclosure) {
24			$ld = new LoadDataInFile();
25			$ld->setEnclosure($enclosure);
26			$this->assertSame($enclosure, $ld->getEnclosure());
27			}
28			public function enclosures() { return [['"'], ['\''], ['`']]; }
29
30			/** @dataProvider escapes */
31			public function testSetAndGetEscape($escape) {
32			$ld = new LoadDataInFile();
33			$ld->setEscape($escape);
34			$this->assertSame($escape, $ld->getEscape());
35			}
36			public function escapes() { return [['\\'], ['`']]; }
37
38			/** @dataProvider ignoreLines */
39			public function testSetAndGetIgnoreLines($lines) {
40			$ld = new LoadDataInFile();
41			$ld->setIgnoreLines($lines);
42			$this->assertSame($lines, $ld->getIgnoreLines());
43			}
44			public function ignoreLines() { return [[0], [1], [2]]; }
45
46			public function testDefaults() {
47			$ld = new LoadDataInFile();
48			$this->assertSame(',', $ld->getDelimiter());
49			$this->assertSame('"', $ld->getEnclosure());
50			$this->assertSame('\\', $ld->getEscape());
51			$this->assertSame('\\n', $ld->getEOL());
52			$this->assertSame(0, $ld->getIgnoreLines());
53			}
54
55			public function testSetAndGetTableName() {
56			$ld = new LoadDataInFile();
57			$ld->setTableName(self::DB_NAME_AND_TABLE);
58			$this->assertSame(self::DB_NAME_AND_TABLE, $ld->getTableName());
59			}
60
61			public function testSetAndGetEOL() {
62			$ld = new LoadDataInFile();
63			$ld->setEOL(";");
64			$this->assertSame(";", $ld->getEOL());
65			}
66
67			public function testSetAndGetCsvFile() {
68			$csvFile = $this->csvFile();
69			$ld = new LoadDataInFile();
70			$ld->setCsvFile($csvFile);
71			$this->assertSame($csvFile, $ld->getCsvFile());
72			}
73
74			public function testColumnMap() {
75			$ld = new LoadDataInFile();
76			$map = ['firstname', 'lastname', null, null, 'age'];
77			$ld->setColMap($map);
78			$expected = 'firstname = @col1, lastname = @col2, age = @col5';
79			$this->assertEquals(
80			$this->normalizeWhitespace($expected),
81			$this->normalizeWhitespace($ld->getSetExpression())
82			);
83			$this->assertEquals(
84			['@col1', '@col2', '@col3', '@col4', '@col5'],
85			$ld->getColVars()
86			);
87			$this->assertEquals($map, $ld->getColMap());
88			}
89
90			public function testStaticColumns() {
91			$ld = new LoadDataInFile();
92			$binds = [
93			'request_id' => 23,
94			'cdate' => '2018-06-12'
95			];
96			$ld->SetColumnBinds($binds);
97			$this->assertSame($binds, $ld->getColumnBinds());
98			$this->assertEquals(
99			$this->normalizeWhitespace("request_id = :request_id, cdate = :cdate"),
100			$this->normalizeWhitespace($ld->getSetExpression())
101			);
102			$this->assertEquals(
103			[':request_id'=>23, ':cdate'=>'2018-06-12'],
104			$ld->getBinds()
105			);
106			}
107
108			public function testGetSetExpressionIncludesColMapAndColBinds() {
109			$ld = new LoadDataInFile();
110			$ld->setColMap(['firstname']);
111			$ld->setColumnBinds(['request_id'=>23]);
112			$expected = "firstname = @col1, request_id = :request_id";
113			$this->assertEquals(
114			$this->normalizeWhitespace($expected),
115			$this->normalizeWhitespace($ld->getSetExpression())
116			);
117			}
118
119			public function testSQL() {
120			$file = $this->csvFile();
121
122			$ld = new LoadDataInFile();
123			$ld->setCsvFile($file);
124			$ld->setTableName(self::DB_NAME_AND_TABLE);
125			$ld->setIgnoreLines(3);
126			$ld->setColMap([
127			'firstname',
128			'lastname',
129			null,
130			null,
131			'age'
132			]);
133			$ld->setColumnBinds([
134			'request_id'=>23, 'cdate' => '2018-06-12'
135			]);
136
137			$expectedSql = "
138			LOAD DATA LOCAL INFILE '{$file}'
139			INTO TABLE ".self::DB_NAME_AND_TABLE."
140			FIELDS TERMINATED BY ','
141			OPTIONALLY ENCLOSED BY '\"'
142			ESCAPED BY '\\\\'
143			LINES TERMINATED BY '\\n'
144			IGNORE 3 LINES
145			( @col1, @col2, @col3, @col4, @col5 )
146			SET firstname = @col1, lastname = @col2, age = @col5,
147			request_id = :request_id, cdate = :cdate
148			";
149
150			$this->assertSame(
151			$this->normalizeWhitespace($expectedSql),
152			$this->normalizeWhitespace($ld->getQuery())
153			);
154			}
155
156			protected function normalizeWhitespace($string) {
157			return trim(
158			$this->forceSingleSpaces(
159			$this->forceSingleLine($string)
160			)
161			);
162			}
163			protected function forceSingleSpaces($string) {
164			return preg_replace('/ {2,}/', ' ', $string);
165			}
166			protected function forceSingleLine($string) {
167			return str_replace(PHP_EOL, ' ', $string);
168			}
169
170			protected function csvFile() {
171			$csvFile = $this->buildCsvFromArray([
172			['name', 'age'],
173			['adam', 30],
174			['bob', 31],
175			['cody', 32]
176			]);
177			return $csvFile;
178			}
179
180			}

logikostech / csv-to-mysql

CsvToMysqlTest::testDefaults() A last analyzed 2018-06-14 11:14 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CsvToMysqlTest::testDefaults() A
last analyzed 2018-06-14 11:14 UTC