BugsnagTest::testNotifyCallback() - Code Metrics - Violet88github/silverstripe-bugsnag-module-vue - Measure and Improve Code Quality continuously with Scrutinizer

BugsnagTest::testNotifyCallback() A
last analyzed 2023-01-09 10:19 UTC

↳ Parent: BugsnagTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	1
eloc	12
c	2
b	0
f	0
nc	1
nop	0
dl	0
loc	17
rs	9.8666

<?php

namespace Violet88\BugsnagModule\Tests;

use Composer\InstalledVersions;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Environment;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Security\Security;
use Violet88\BugsnagModule\Bugsnag;

/**
 * @covers \Violet88\BugsnagModule\Bugsnag
 */
class BugsnagTest extends SapphireTest
{
    protected function setUp(): void
    {
        parent::setUp();
        Environment::setEnv('BUGSNAG_API_KEY', '1234567890');
        Environment::setEnv('BUGSNAG_ACTIVE', 'true');
    }
    public function testGetExtraOption()
    {
        $stub = $this->getMockBuilder(Bugsnag::class)
            ->setMethods(['getExtraOptions'])
            ->getMock();

        $extraOptions = [
            'key' => 'value'
        ];

        $stub->method('getExtraOptions')
            ->willReturn($extraOptions);

        $this->assertEquals($extraOptions, $stub->getExtraOptions());
    }

    public function testAddExtraOption()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->addExtraOption('key', 'value');
        $this->assertEquals(['key' => 'value'], $bugsnag->getExtraOptions());
    }

    public function testAddExtraOptionReturnsSelfRef()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $this->assertEquals($bugsnag, $bugsnag->addExtraOption('key', 'value'));
    }

    public function testRemoveExtraOption()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->addExtraOption('key', 'value');
        $bugsnag->removeExtraOption('key');
        $this->assertEquals([], $bugsnag->getExtraOptions());
    }

    public function testRemoveExtraOptionReturnsSelfRef()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $this->assertEquals($bugsnag, $bugsnag->removeExtraOption('key'));
    }

    public function testGetStandardSeverity()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $this->assertEquals(
            Environment::getEnv('BUGSNAG_STANDARD_SEVERITY'),
            $bugsnag->getStandardSeverity()
        );
    }

    public function testReset()
    {
        $bugsnag = new Bugsnag();
        $bugsnag->addExtraOption('key', 'value');
        $this->assertEquals(['key' => 'value'], $bugsnag->getExtraOptions());
        $bugsnag->reset();
        $this->assertEquals([], $bugsnag->getExtraOptions());
    }

    public function testAddUserInfo()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();

        $memberMock = $this->getMockBuilder('SilverStripe\Security\Member')
            ->setMethods(['ID', 'Email', 'FirstName', 'Surname', 'Groups'])
            ->getMock();

        $groupMock = $this->getMockBuilder('SilverStripe\Security\Group')
            ->setMethods(['column'])
            ->getMock();

        $groupMock->method('column')
            ->willReturn(['group1', 'group2']);

        $memberMock->data()->ID = 1;

        $memberMock->data()->Email = '[email protected]';

        $memberMock->data()->FirstName = 'Test';

        $memberMock->data()->Surname = 'Test';

        $memberMock->method('Groups')
            ->willReturn($groupMock);

        Security::setCurrentUser($memberMock);

        $bugsnag->addUserInfo(true);

        $this->assertEquals([
            'User' => [
                'ID' => 1,
                'Email' => '[email protected]',
                'FirstName' => 'Test',
                'Surname' => 'Test',
                'Groups' => ['group1', 'group2']
            ]
        ], $bugsnag->getExtraOptions());

        $bugsnag->addUserInfo(false);
        $this->assertEquals([], $bugsnag->getExtraOptions());
    }

    public function testSendException()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['notifyException'])
            ->getMock();

        Environment::setEnv('BUGSNAG_ACTIVE', 'true');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;
        $bugsnag->addExtraOption('key', 'value');
        $this->assertEquals(['key' => 'value'], $bugsnag->getExtraOptions());

        $clientMock->expects($this->once())
            ->method('notifyException')
            ->willReturn(true);

        $bugsnag->sendException(new \Exception('test'));
        $this->assertEquals([], $bugsnag->getExtraOptions());
    }

    protected static function getMethod($name)
    {
        $class = new \ReflectionClass('Violet88\BugsnagModule\Bugsnag');
        $method = $class->getMethod($name);
        $method->setAccessible(true);
        return $method;
    }

    public function testNotifyCallback()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $notify = self::getMethod('notifyCallback');
        $obj = new Bugsnag();
        $report = $this->getMockBuilder('Bugsnag\Report')
            ->disableOriginalConstructor()
            ->setMethods(['setSeverity', 'setMetaData'])
            ->getMock();

        $report->expects($this->once())
            ->method('setSeverity');

        $report->expects($this->once())
            ->method('setMetaData');

        $notify->invokeArgs($obj, [$report, 'info']);
    }

    public function testSendExceptionCallsGetStandardSeverity()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['notifyException'])
            ->getMock();

        $bugsnag = $this->getMockBuilder('Violet88\BugsnagModule\Bugsnag')
            ->setMethods(['getStandardSeverity', 'getBugsnag'])
            ->getMock();

        $bugsnag->method('getBugsnag')
            ->willReturn($clientMock);

        $bugsnag->expects($this->once())
            ->method('getStandardSeverity')
            ->willReturn('error');

        $bugsnag->sendException(new \Exception('test'));
    }

    public function testSendExceptionCallsNotifyWhenNotHandled()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['notify'])
            ->getMock();

        $bugsnag = $this->getMockBuilder('Violet88\BugsnagModule\Bugsnag')
            ->setMethods(['getStandardSeverity', 'getBugsnag'])
            ->getMock();

        $bugsnag->method('getBugsnag')
            ->willReturn($clientMock);

        $clientMock->expects($this->once())
            ->method('notify')
            ->willReturn(true);

        $bugsnag->sendException(new \Exception('test'), 'info', true, false);
    }

    public function testSetAppType()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['setAppType'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        $clientMock->expects($this->once())
            ->method('setAppType');

        $bugsnag->setAppType('test');
    }

    public function testSetAppTypeReturnsSelfRef()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $result = $bugsnag->setAppType('test');
        $this->assertEquals($result, $bugsnag);
    }

    public function testSetAppVersion()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['setAppVersion'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        $clientMock->expects($this->once())
            ->method('setAppVersion');

        $bugsnag->setAppVersion('1.0.0');
    }

    public function testSetAppVersionReturnsSelfRef()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $result = $bugsnag->setAppVersion('1.0.0');
        $this->assertEquals($result, $bugsnag);
    }

    public function testSetReleaseStage()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['setReleaseStage'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        $clientMock->expects($this->once())
            ->method('setReleaseStage');

        $bugsnag->setReleaseStage('0.1');
    }

    public function testSetReleaseStageReturnsSelfRef()
    {
        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $result = $bugsnag->setReleaseStage('0.1');
        $this->assertEquals($result, $bugsnag);
    }

    public function testSendError()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['notifyError'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        $clientMock->expects($this->once())
            ->method('notifyError')
            ->willReturn(true);

        $bugsnag->sendError('test');
        $this->assertEquals([], $bugsnag->getExtraOptions());
    }

    public function testSetEndpoint()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['setNotifyEndpoint'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        $clientMock->expects($this->once())
            ->method('setNotifyEndpoint');

        $bugsnag->setEndpoint('/test');
    }

    public function testSetEndpointReturnsSelfRef()
    {
        $bugsnag = new Bugsnag();
        $result = $bugsnag->setEndpoint('/test');
        $this->assertEquals($result, $bugsnag);
    }

    public function testNotifyBuild()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['build'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        $clientMock->expects($this->once())
            ->method('build')
            ->willReturn(true);

        $bugsnag->notifyBuild('test@github', 'test', '1.0.0', 'test');
    }

    public function testAddVersion()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['setAppVersion'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        $clientMock->expects($this->once())
            ->method('setAppVersion')
            ->with(InstalledVersions::getRootPackage()['pretty_version']);

        $bugsnag->addVersion();

        $bugsnag->addVersion(false);

        $this->assertEquals([], $bugsnag->getExtraOptions());
    }

    public function testAddPackages()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['setAppVersion'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        self::assertEquals([], $bugsnag->getExtraOptions());

        $bugsnag->addPackages();

        self::assertEquals(InstalledVersions::getInstalledPackages(), $bugsnag->getExtraOptions()['Packages']);

        $bugsnag->addPackages(false);

        self::assertEquals([], $bugsnag->getExtraOptions());
    }

    public function testAddPackagesWithVersions()
    {
        $bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
            ->setConstructorArgs(['API_KEY'])
            ->getMock();

        $clientMock = $this->getMockBuilder('Bugsnag\Client')
            ->setConstructorArgs([$bugsnagConfigMock])
            ->setMethods(['setAppVersion'])
            ->getMock();

        Environment::setEnv('BUGSNAG_API_KEY', 'test');
        $bugsnag = new Bugsnag();
        $bugsnag->bugsnag = $clientMock;

        self::assertEquals([], $bugsnag->getExtraOptions());

        $bugsnag->addPackagesWithVersions();

        $bugsnag->addPackagesWithVersions(false);

        self::assertEquals([], $bugsnag->getExtraOptions());
    }
}


1			<?php
2
3			namespace Violet88\BugsnagModule\Tests;
4
5			use Composer\InstalledVersions;
6			use SilverStripe\Core\Config\Config;
7			use SilverStripe\Core\Environment;
8			use SilverStripe\Dev\SapphireTest;
9			use SilverStripe\Security\Security;
10			use Violet88\BugsnagModule\Bugsnag;
11
12			/**
13			* @covers \Violet88\BugsnagModule\Bugsnag
14			*/
15			class BugsnagTest extends SapphireTest
16			{
17			protected function setUp(): void
18			{
19			parent::setUp();
20			Environment::setEnv('BUGSNAG_API_KEY', '1234567890');
21			Environment::setEnv('BUGSNAG_ACTIVE', 'true');
22			}
23			public function testGetExtraOption()
24			{
25			$stub = $this->getMockBuilder(Bugsnag::class)
26			->setMethods(['getExtraOptions'])
27			->getMock();
28
29			$extraOptions = [
30			'key' => 'value'
31			];
32
33			$stub->method('getExtraOptions')
34			->willReturn($extraOptions);
35
36			$this->assertEquals($extraOptions, $stub->getExtraOptions());
37			}
38
39			public function testAddExtraOption()
40			{
41			Environment::setEnv('BUGSNAG_API_KEY', 'test');
42			$bugsnag = new Bugsnag();
43			$bugsnag->addExtraOption('key', 'value');
44			$this->assertEquals(['key' => 'value'], $bugsnag->getExtraOptions());
45			}
46
47			public function testAddExtraOptionReturnsSelfRef()
48			{
49			Environment::setEnv('BUGSNAG_API_KEY', 'test');
50			$bugsnag = new Bugsnag();
51			$this->assertEquals($bugsnag, $bugsnag->addExtraOption('key', 'value'));
52			}
53
54			public function testRemoveExtraOption()
55			{
56			Environment::setEnv('BUGSNAG_API_KEY', 'test');
57			$bugsnag = new Bugsnag();
58			$bugsnag->addExtraOption('key', 'value');
59			$bugsnag->removeExtraOption('key');
60			$this->assertEquals([], $bugsnag->getExtraOptions());
61			}
62
63			public function testRemoveExtraOptionReturnsSelfRef()
64			{
65			Environment::setEnv('BUGSNAG_API_KEY', 'test');
66			$bugsnag = new Bugsnag();
67			$this->assertEquals($bugsnag, $bugsnag->removeExtraOption('key'));
68			}
69
70			public function testGetStandardSeverity()
71			{
72			Environment::setEnv('BUGSNAG_API_KEY', 'test');
73			$bugsnag = new Bugsnag();
74			$this->assertEquals(
75			Environment::getEnv('BUGSNAG_STANDARD_SEVERITY'),
76			$bugsnag->getStandardSeverity()
77			);
78			}
79
80			public function testReset()
81			{
82			$bugsnag = new Bugsnag();
83			$bugsnag->addExtraOption('key', 'value');
84			$this->assertEquals(['key' => 'value'], $bugsnag->getExtraOptions());
85			$bugsnag->reset();
86			$this->assertEquals([], $bugsnag->getExtraOptions());
87			}
88
89			public function testAddUserInfo()
90			{
91			Environment::setEnv('BUGSNAG_API_KEY', 'test');
92			$bugsnag = new Bugsnag();
93
94			$memberMock = $this->getMockBuilder('SilverStripe\Security\Member')
95			->setMethods(['ID', 'Email', 'FirstName', 'Surname', 'Groups'])
96			->getMock();
97
98			$groupMock = $this->getMockBuilder('SilverStripe\Security\Group')
99			->setMethods(['column'])
100			->getMock();
101
102			$groupMock->method('column')
103			->willReturn(['group1', 'group2']);
104
105			$memberMock->data()->ID = 1;
106
107			$memberMock->data()->Email = '[email protected]';
108
109			$memberMock->data()->FirstName = 'Test';
110
111			$memberMock->data()->Surname = 'Test';
112
113			$memberMock->method('Groups')
114			->willReturn($groupMock);
115
116			Security::setCurrentUser($memberMock);
117
118			$bugsnag->addUserInfo(true);
119
120			$this->assertEquals([
121			'User' => [
122			'ID' => 1,
123			'Email' => '[email protected]',
124			'FirstName' => 'Test',
125			'Surname' => 'Test',
126			'Groups' => ['group1', 'group2']
127			]
128			], $bugsnag->getExtraOptions());
129
130			$bugsnag->addUserInfo(false);
131			$this->assertEquals([], $bugsnag->getExtraOptions());
132			}
133
134			public function testSendException()
135			{
136			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
137			->setConstructorArgs(['API_KEY'])
138			->getMock();
139
140			$clientMock = $this->getMockBuilder('Bugsnag\Client')
141			->setConstructorArgs([$bugsnagConfigMock])
142			->setMethods(['notifyException'])
143			->getMock();
144
145			Environment::setEnv('BUGSNAG_ACTIVE', 'true');
146			$bugsnag = new Bugsnag();
147			$bugsnag->bugsnag = $clientMock;
148			$bugsnag->addExtraOption('key', 'value');
149			$this->assertEquals(['key' => 'value'], $bugsnag->getExtraOptions());
150
151			$clientMock->expects($this->once())
152			->method('notifyException')
153			->willReturn(true);
154
155			$bugsnag->sendException(new \Exception('test'));
156			$this->assertEquals([], $bugsnag->getExtraOptions());
157			}
158
159			protected static function getMethod($name)
160			{
161			$class = new \ReflectionClass('Violet88\BugsnagModule\Bugsnag');
162			$method = $class->getMethod($name);
163			$method->setAccessible(true);
164			return $method;
165			}
166
167			public function testNotifyCallback()
168			{
169			Environment::setEnv('BUGSNAG_API_KEY', 'test');
170			$notify = self::getMethod('notifyCallback');
171			$obj = new Bugsnag();
172			$report = $this->getMockBuilder('Bugsnag\Report')
173			->disableOriginalConstructor()
174			->setMethods(['setSeverity', 'setMetaData'])
175			->getMock();
176
177			$report->expects($this->once())
178			->method('setSeverity');
179
180			$report->expects($this->once())
181			->method('setMetaData');
182
183			$notify->invokeArgs($obj, [$report, 'info']);
184			}
185
186			public function testSendExceptionCallsGetStandardSeverity()
187			{
188			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
189			->setConstructorArgs(['API_KEY'])
190			->getMock();
191
192			$clientMock = $this->getMockBuilder('Bugsnag\Client')
193			->setConstructorArgs([$bugsnagConfigMock])
194			->setMethods(['notifyException'])
195			->getMock();
196
197			$bugsnag = $this->getMockBuilder('Violet88\BugsnagModule\Bugsnag')
198			->setMethods(['getStandardSeverity', 'getBugsnag'])
199			->getMock();
200
201			$bugsnag->method('getBugsnag')
202			->willReturn($clientMock);
203
204			$bugsnag->expects($this->once())
205			->method('getStandardSeverity')
206			->willReturn('error');
207
208			$bugsnag->sendException(new \Exception('test'));
209			}
210
211			public function testSendExceptionCallsNotifyWhenNotHandled()
212			{
213			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
214			->setConstructorArgs(['API_KEY'])
215			->getMock();
216
217			$clientMock = $this->getMockBuilder('Bugsnag\Client')
218			->setConstructorArgs([$bugsnagConfigMock])
219			->setMethods(['notify'])
220			->getMock();
221
222			$bugsnag = $this->getMockBuilder('Violet88\BugsnagModule\Bugsnag')
223			->setMethods(['getStandardSeverity', 'getBugsnag'])
224			->getMock();
225
226			$bugsnag->method('getBugsnag')
227			->willReturn($clientMock);
228
229			$clientMock->expects($this->once())
230			->method('notify')
231			->willReturn(true);
232
233			$bugsnag->sendException(new \Exception('test'), 'info', true, false);
234			}
235
236			public function testSetAppType()
237			{
238			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
239			->setConstructorArgs(['API_KEY'])
240			->getMock();
241
242			$clientMock = $this->getMockBuilder('Bugsnag\Client')
243			->setConstructorArgs([$bugsnagConfigMock])
244			->setMethods(['setAppType'])
245			->getMock();
246
247			Environment::setEnv('BUGSNAG_API_KEY', 'test');
248			$bugsnag = new Bugsnag();
249			$bugsnag->bugsnag = $clientMock;
250
251			$clientMock->expects($this->once())
252			->method('setAppType');
253
254			$bugsnag->setAppType('test');
255			}
256
257			public function testSetAppTypeReturnsSelfRef()
258			{
259			Environment::setEnv('BUGSNAG_API_KEY', 'test');
260			$bugsnag = new Bugsnag();
261			$result = $bugsnag->setAppType('test');
262			$this->assertEquals($result, $bugsnag);
263			}
264
265			public function testSetAppVersion()
266			{
267			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
268			->setConstructorArgs(['API_KEY'])
269			->getMock();
270
271			$clientMock = $this->getMockBuilder('Bugsnag\Client')
272			->setConstructorArgs([$bugsnagConfigMock])
273			->setMethods(['setAppVersion'])
274			->getMock();
275
276			Environment::setEnv('BUGSNAG_API_KEY', 'test');
277			$bugsnag = new Bugsnag();
278			$bugsnag->bugsnag = $clientMock;
279
280			$clientMock->expects($this->once())
281			->method('setAppVersion');
282
283			$bugsnag->setAppVersion('1.0.0');
284			}
285
286			public function testSetAppVersionReturnsSelfRef()
287			{
288			Environment::setEnv('BUGSNAG_API_KEY', 'test');
289			$bugsnag = new Bugsnag();
290			$result = $bugsnag->setAppVersion('1.0.0');
291			$this->assertEquals($result, $bugsnag);
292			}
293
294			public function testSetReleaseStage()
295			{
296			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
297			->setConstructorArgs(['API_KEY'])
298			->getMock();
299
300			$clientMock = $this->getMockBuilder('Bugsnag\Client')
301			->setConstructorArgs([$bugsnagConfigMock])
302			->setMethods(['setReleaseStage'])
303			->getMock();
304
305			Environment::setEnv('BUGSNAG_API_KEY', 'test');
306			$bugsnag = new Bugsnag();
307			$bugsnag->bugsnag = $clientMock;
308
309			$clientMock->expects($this->once())
310			->method('setReleaseStage');
311
312			$bugsnag->setReleaseStage('0.1');
313			}
314
315			public function testSetReleaseStageReturnsSelfRef()
316			{
317			Environment::setEnv('BUGSNAG_API_KEY', 'test');
318			$bugsnag = new Bugsnag();
319			$result = $bugsnag->setReleaseStage('0.1');
320			$this->assertEquals($result, $bugsnag);
321			}
322
323			public function testSendError()
324			{
325			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
326			->setConstructorArgs(['API_KEY'])
327			->getMock();
328
329			$clientMock = $this->getMockBuilder('Bugsnag\Client')
330			->setConstructorArgs([$bugsnagConfigMock])
331			->setMethods(['notifyError'])
332			->getMock();
333
334			Environment::setEnv('BUGSNAG_API_KEY', 'test');
335			$bugsnag = new Bugsnag();
336			$bugsnag->bugsnag = $clientMock;
337
338			$clientMock->expects($this->once())
339			->method('notifyError')
340			->willReturn(true);
341
342			$bugsnag->sendError('test');
343			$this->assertEquals([], $bugsnag->getExtraOptions());
344			}
345
346			public function testSetEndpoint()
347			{
348			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
349			->setConstructorArgs(['API_KEY'])
350			->getMock();
351
352			$clientMock = $this->getMockBuilder('Bugsnag\Client')
353			->setConstructorArgs([$bugsnagConfigMock])
354			->setMethods(['setNotifyEndpoint'])
355			->getMock();
356
357			Environment::setEnv('BUGSNAG_API_KEY', 'test');
358			$bugsnag = new Bugsnag();
359			$bugsnag->bugsnag = $clientMock;
360
361			$clientMock->expects($this->once())
362			->method('setNotifyEndpoint');
363
364			$bugsnag->setEndpoint('/test');
365			}
366
367			public function testSetEndpointReturnsSelfRef()
368			{
369			$bugsnag = new Bugsnag();
370			$result = $bugsnag->setEndpoint('/test');
371			$this->assertEquals($result, $bugsnag);
372			}
373
374			public function testNotifyBuild()
375			{
376			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
377			->setConstructorArgs(['API_KEY'])
378			->getMock();
379
380			$clientMock = $this->getMockBuilder('Bugsnag\Client')
381			->setConstructorArgs([$bugsnagConfigMock])
382			->setMethods(['build'])
383			->getMock();
384
385			Environment::setEnv('BUGSNAG_API_KEY', 'test');
386			$bugsnag = new Bugsnag();
387			$bugsnag->bugsnag = $clientMock;
388
389			$clientMock->expects($this->once())
390			->method('build')
391			->willReturn(true);
392
393			$bugsnag->notifyBuild('test@github', 'test', '1.0.0', 'test');
394			}
395
396			public function testAddVersion()
397			{
398			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
399			->setConstructorArgs(['API_KEY'])
400			->getMock();
401
402			$clientMock = $this->getMockBuilder('Bugsnag\Client')
403			->setConstructorArgs([$bugsnagConfigMock])
404			->setMethods(['setAppVersion'])
405			->getMock();
406
407			Environment::setEnv('BUGSNAG_API_KEY', 'test');
408			$bugsnag = new Bugsnag();
409			$bugsnag->bugsnag = $clientMock;
410
411			$clientMock->expects($this->once())
412			->method('setAppVersion')
413			->with(InstalledVersions::getRootPackage()['pretty_version']);
414
415			$bugsnag->addVersion();
416
417			$bugsnag->addVersion(false);
418
419			$this->assertEquals([], $bugsnag->getExtraOptions());
420			}
421
422			public function testAddPackages()
423			{
424			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
425			->setConstructorArgs(['API_KEY'])
426			->getMock();
427
428			$clientMock = $this->getMockBuilder('Bugsnag\Client')
429			->setConstructorArgs([$bugsnagConfigMock])
430			->setMethods(['setAppVersion'])
431			->getMock();
432
433			Environment::setEnv('BUGSNAG_API_KEY', 'test');
434			$bugsnag = new Bugsnag();
435			$bugsnag->bugsnag = $clientMock;
436
437			self::assertEquals([], $bugsnag->getExtraOptions());
438
439			$bugsnag->addPackages();
440
441			self::assertEquals(InstalledVersions::getInstalledPackages(), $bugsnag->getExtraOptions()['Packages']);
442
443			$bugsnag->addPackages(false);
444
445			self::assertEquals([], $bugsnag->getExtraOptions());
446			}
447
448			public function testAddPackagesWithVersions()
449			{
450			$bugsnagConfigMock = $this->getMockBuilder('Bugsnag\Configuration')
451			->setConstructorArgs(['API_KEY'])
452			->getMock();
453
454			$clientMock = $this->getMockBuilder('Bugsnag\Client')
455			->setConstructorArgs([$bugsnagConfigMock])
456			->setMethods(['setAppVersion'])
457			->getMock();
458
459			Environment::setEnv('BUGSNAG_API_KEY', 'test');
460			$bugsnag = new Bugsnag();
461			$bugsnag->bugsnag = $clientMock;
462
463			self::assertEquals([], $bugsnag->getExtraOptions());
464
465			$bugsnag->addPackagesWithVersions();
466
467			$bugsnag->addPackagesWithVersions(false);
468
469			self::assertEquals([], $bugsnag->getExtraOptions());
470			}
471			}
472

Violet88github / silverstripe-bugsnag-module-vue

BugsnagTest::testNotifyCallback() A last analyzed 2023-01-09 10:19 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

BugsnagTest::testNotifyCallback() A
last analyzed 2023-01-09 10:19 UTC