option

1
<?php
2

3
declare(strict_types=1);
4
namespace Upside\Std\Test\Option;
5

6
use PHPUnit\Framework\TestCase;
7
use function Upside\Std\From;
8
use function Upside\Std\None;
9
use function Upside\Std\Some;
10

11
//TODO: Добавить больше кейсов проверки например с разными типами данных
12
class OptionTest extends TestCase
13
{
14
    public function test_from(): void
15
    {
16
        $some_data = 'test';
17
        $none_data = null;
18

19
        $none = From($none_data);
20
        $some = From($some_data);
21

22
        $this->assertTrue($none->is_none());
23
        $this->assertFalse($none->is_some());
24
        $this->assertTrue($some->is_some());
25
        $this->assertFalse($some->is_none());
26
        $this->assertEquals($some_data, $some->unwrap());
27
    }
28

29
    public function test_some(): void
30
    {
31
        $some_data = 'test';
32
        $some = Some($some_data);
33

34
        $this->assertFalse($some->is_none());
35
        $this->assertTrue($some->is_some());
36
        $this->assertEquals($some_data, $some->unwrap());
37
    }
38

39
    public function test_none(): void
40
    {
41
        $none = None();
42

43
        $this->assertFalse($none->is_some());
44
        $this->assertTrue($none->is_none());
45
    }
46

47
    public function test_is_some(): void
48
    {
49
        $some = Some('test');
50
        $none = None();
51

52
        $this->assertTrue($some->is_some());
53
        $this->assertFalse($none->is_some());
54
    }
55

56
    public function test_is_none(): void
57
    {
58
        $some = Some('test');
59
        $none = None();
60

61
        $this->assertFalse($some->is_none());
62
        $this->assertTrue($none->is_none());
63
    }
64

65
    public function test_unwrap(): void
66
    {
67
        $some_data = 'test';
68
        $some = Some($some_data);
69

70
        $this->assertEquals($some_data, $some->unwrap());
71
    }
72

73
    public function test_unwrap_exception(): void
74
    {
75
        $this->expectException(\RuntimeException::class);
76
        $this->expectExceptionMessage('The option is none');
77

78
        $none = None();
79
        $none->unwrap();
80
    }
81

82
    public function test_unwrap_or(): void
83
    {
84
        $some_data = 'test';
85
        $some = Some($some_data);
86
        $none = None();
87

88
        $this->assertEquals($some_data, $some->unwrap_or('default'));
89
        $this->assertEquals('default', $none->unwrap_or('default'));
90
    }
91

92
    public function test_unwrap_or_callback(): void
93
    {
94
        $some_data = 'test';
95
        $callback_data = 'callback';
96
        $callback = fn() => $callback_data;
97

98
        $some = Some($some_data);
99
        $none = None();
100

101
        $this->assertEquals($some_data, $some->unwrap_or_else($callback));
102
        $this->assertEquals($callback_data, $none->unwrap_or_else($callback));
103
    }
104

105
    public function test_expect(): void
106
    {
107
        $msg = 'test';
108

109
        $this->expectException(\RuntimeException::class);
110
        $this->expectExceptionMessage($msg);
111

112
        $none = None();
113
        $none->expect($msg);
114
    }
115

116
    public function test_expect_or(): void
117
    {
118
        $msg = 'test';
119

120
        $this->expectException(\LogicException::class);
121
        $this->expectExceptionMessage($msg);
122

123
        $none = None();
124
        $none->expect_or(new \LogicException($msg));
125
    }
126
}
127