summaryrefslogtreecommitdiff
path: root/test/test_classes.php
blob: 77d67f382dbb7cd619aba09e855de235a1dd2434 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
<?php

    /**
     *
     * Mock version of the PDOStatement class.
     *
     */
    class MockPDOStatement extends PDOStatement {

        private $current_row = 0;
        /**
         * Return some dummy data
         */
        public function fetch(
            $fetch_style = PDO::FETCH_BOTH,
            $cursor_orientation = PDO::FETCH_ORI_NEXT,
            $cursor_offset = 0
        ) {
            if ($this->current_row == 5) {
                return false;
            } else {
                $this->current_row++;
                return array('name' => 'Fred', 'age' => 10, 'id' => '1');
            }
        }
    }

    /**
     *
     * Mock database class implementing a subset
     * of the PDO API.
     *
     */
    class MockPDO extends PDO {

        /**
         * Return a dummy PDO statement
         */
        public function prepare($statement, $driver_options=array()) {
            $this->last_query = new MockPDOStatement($statement);
            return $this->last_query;
        }
    }

    /**
     * Another mock PDOStatement class, for testing multiple connections
     */
    class DummyDifferentPDOStatement extends PDOStatement {

        private $current_row = 0;
        /**
         * Return some dummy data
         */
        public function fetch(
            $fetch_style = PDO::FETCH_BOTH,
            $cursor_orientation = PDO::FETCH_ORI_NEXT,
            $cursor_offset = 0
        ) {
            if ($this->current_row == 5) {
                return false;
            } else {
                $this->current_row++;
                return array('name' => 'Steve', 'age' => 80, 'id' => "{$this->current_row}");
            }
        }
    }

    /**
     * A different mock database class, for testing multiple connections
     * Mock database class implementing a subset of the PDO API.
     */
    class DummyDifferentPDO extends PDO {

        /**
         * Return a dummy PDO statement
         */
        public function prepare($statement, $driver_options = array()) {
            $this->last_query = new DummyDifferentPDOStatement($statement);
            return $this->last_query;
        }
    }

    /**
     *
     * Class to provide simple testing functionality
     *
     */
    class Tester {

        private static $passed_tests = array();
        private static $failed_tests = array();
        private static $db;

        private static $term_colours = array(
            'BLACK' => "30",
            'RED' => "31",
            'GREEN' => "32",
            'DEFAULT' => "00",
        );

        /**
         * Format a line for printing. Detects
         * if the script is being run from the command
         * line or from a browser.
         *
         * Colouring code loosely based on
         * http://www.zend.com//code/codex.php?ozid=1112&single=1
         */
        private static function format_line($line, $colour='DEFAULT') {
            if (isset($_SERVER['HTTP_USER_AGENT'])) {
                $colour = strtolower($colour);
                return "<p style=\"color: $colour;\">$line</p>\n";
            } else {
                $colour = self::$term_colours[$colour];
                return chr(27) . "[0;{$colour}m{$line}" . chr(27) . "[00m\n";
            }
        }

        /**
         * Report a passed test
         */
        public static function report_pass($test_name) {
            echo self::format_line("PASS: $test_name", 'GREEN');
            self::$passed_tests[] = $test_name;
        }

        /**
         * Report a failed test
         */
        public static function report_failure($test_name, $expected, $actual) {
            echo self::format_line("FAIL: $test_name", 'RED');
            echo self::format_line("Expected: $expected", 'RED');
            echo self::format_line("Actual: $actual", 'RED');
            self::$failed_tests[] = $test_name;
        }

        /**
         * Print a summary of passed and failed test counts
         */
        public static function report() {
            $passed_count = count(self::$passed_tests);
            $failed_count = count(self::$failed_tests);
            echo self::format_line('');
            echo self::format_line("$passed_count tests passed. $failed_count tests failed.");

            if ($failed_count != 0) {
                echo self::format_line("Failed tests: " . join(", ", self::$failed_tests));
            }
        }

        /**
         * Check the provided string is equal to the last
         * query generated by the dummy database class.
         */
        public static function check_equal_query($test_name, $query) {
            $last_query = ORM::get_last_query();
            self::check_equal_string($test_name, $query, $last_query);
        }

        /**
         * Check the provided strings are equal
         */
        public static function check_equal_string($test_name, $s1, $s2) {
            if ($s1 === $s2) {
                self::report_pass($test_name);
            } else {
                self::report_failure($test_name, $s1, $s2);
            }
        }
    }