ToneTest::testDocumentToneAnalysis() - Code Metrics - Inspection of "Code quality" - adam-paterson/ibm-watson-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#19)

by Adam

created 2017-10-07 08:56 UTC

ToneTest::testDocumentToneAnalysis() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	25
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	25
rs	8.8571
c	1
b	0
f	0
cc	1
eloc	14
nc	1
nop	0

<?php

namespace IBM\Watson\ToneAnalyzer\tests\Api;

use GuzzleHttp\Psr7\Response;
use Http\Client\HttpClient;
use IBM\Watson\Common\Hydrator\HydratorInterface;
use IBM\Watson\Common\Hydrator\ModelHydrator;
use IBM\Watson\Common\RequestBuilder;
use IBM\Watson\ToneAnalyzer\Api\Tone;
use PHPUnit\Framework\TestCase;
use Mockery as m;

class ToneTest extends TestCase
{
    private $httpClient;
    private $hydrator;
    private $requestBuilder;

    public function setUp()
    {
        $this->httpClient = m::mock(HttpClient::class);
        $this->hydrator = m::mock(new ModelHydrator(), HydratorInterface::class);
        $this->requestBuilder = new RequestBuilder();
    }

    /**
     * @expectedException \IBM\Watson\Common\Exception\InsufficientPrivilegesException
     * @expectedExceptionMessage Not Authorized
     */
    public function testUnauthorized()
    {
        $this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () {
            return new Response(401, [], '{"error":"Not Authorized"}');
        });

        $tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);

        $tone->analyze('text');
    }

    /**
     * @expectedException \IBM\Watson\Common\Exception\NotFoundException
     * @expectedExceptionMessage Not Found
     */
    public function testNotFound()
    {
        $this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () {
            return new Response(404, [], '{"error":"Not Found"}');
        });

        $tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
        $tone->analyze('text');
    }

    /**
     * @expectedException \IBM\Watson\Common\Exception\UnknownErrorException
     * @expectedExceptionMessage Unknown Error
     */
    public function testUnknownError()
    {
        $this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () {
            return new Response(900, [], '{"error":"Unknown Error"}');
        });

        $tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
        $tone->analyze('text');
    }

    public function testDocumentToneAnalysis()
    {
        $rawResponse = '{"document_tone": {"tones": [{"score": 0.6165,"tone_id": "sadness","tone_name": "Sadness"}]}}';

        $this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () use ($rawResponse) {
            return new Response(200, ['Content-Type' => 'application/json'], $rawResponse);
        });

        $tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);

        $response = $tone->analyze(
            'text',
            ['content_language' => 'en', 'accept_language' => 'en', 'learning_opt_out' => true]
        );

        $tones = $response->getDocumentAnalysis()->getTones();

        $this->assertNotEmpty($tones);

        $firstTone = $tones[0];

        $this->assertEquals('sadness', $firstTone->getId());
        $this->assertEquals('Sadness', $firstTone->getName());
        $this->assertEquals(0.6165, $firstTone->getScore());
    }

    public function testSentenceToneAnaysis()
    {
        $rawResponse = '{
  "document_tone": {
    "tones": [
      {
        "score": 0.6165,
        "tone_id": "sadness",
        "tone_name": "Sadness"
      },
      {
        "score": 0.829888,
        "tone_id": "analytical",
        "tone_name": "Analytical"
      }
    ]
  },
  "sentences_tone": [
    {
      "sentence_id": 0,
      "text": "Team, I know that times are tough!",
      "tones": [
        {
          "score": 0.801827,
          "tone_id": "analytical",
          "tone_name": "Analytical"
        }
      ]
    },
    {
      "sentence_id": 1,
      "text": "Product sales have been disappointing for the past three quarters.",
      "tones": [
        {
          "score": 0.771241,
          "tone_id": "sadness",
          "tone_name": "Sadness"
        },
        {
          "score": 0.687768,
          "tone_id": "analytical",
          "tone_name": "Analytical"
        }
      ]
    },
    {
      "sentence_id": 2,
      "text": "We have a competitive product, but we need to do a better job of selling it!",
      "tones": [
        {
          "score": 0.506763,
          "tone_id": "analytical",
          "tone_name": "Analytical"
        }
      ]
    }
  ]
}';

        $this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () use ($rawResponse) {
            return new Response(200, ['Content-Type' => 'application/json'], $rawResponse);
        });

        $tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);

        $response = $tone->analyze('text', ['content_language' => 'en', 'accept_language' => 'en']);

        $sentences = $response->getSentenceAnalysis()->getSentences();

        $this->assertNotEmpty($sentences);

        $firstSentence = $sentences[0];

        $this->assertEquals(0, $firstSentence->getId());
        $this->assertEquals('Team, I know that times are tough!', $firstSentence->getText());

        $tones = $firstSentence->getTones();

        $this->assertNotEmpty($tones);
    }

    public function testAnalyzeHtml()
    {
        $rawResponse = '{"document_tone": {"tones": [{"score": 0.6165,"tone_id": "sadness","tone_name": "Sadness"}]}}';

        $this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () use ($rawResponse) {
            return new Response(200, ['Content-Type' => 'application/json'], $rawResponse);
        });

        $tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);

        $response = $tone->analyze('<div>Some HTML to test</div>', ['is_html' => true]);

        $tones = $response->getDocumentAnalysis()->getTones();

        $this->assertNotEmpty($tones);
    }

    public function testAnalyzeJson()
    {
        $rawResponse = '{"document_tone": {"tones": [{"score": 0.6165,"tone_id": "sadness","tone_name": "Sadness"}]}}';

        $this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () use ($rawResponse) {
            return new Response(200, ['Content-Type' => 'application/json'], $rawResponse);
        });

        $tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);

        $response = $tone->analyze('{"text": "Some text to analyze"}');

        $tones = $response->getDocumentAnalysis()->getTones();

        $this->assertNotEmpty($tones);
    }
}


1			<?php
2
3			namespace IBM\Watson\ToneAnalyzer\tests\Api;
4
5			use GuzzleHttp\Psr7\Response;
6			use Http\Client\HttpClient;
7			use IBM\Watson\Common\Hydrator\HydratorInterface;
8			use IBM\Watson\Common\Hydrator\ModelHydrator;
9			use IBM\Watson\Common\RequestBuilder;
10			use IBM\Watson\ToneAnalyzer\Api\Tone;
11			use PHPUnit\Framework\TestCase;
12			use Mockery as m;
13
14			class ToneTest extends TestCase
15			{
16			private $httpClient;
17			private $hydrator;
18			private $requestBuilder;
19
20			public function setUp()
21			{
22			$this->httpClient = m::mock(HttpClient::class);
23			$this->hydrator = m::mock(new ModelHydrator(), HydratorInterface::class);
24			$this->requestBuilder = new RequestBuilder();
25			}
26
27			/**
28			* @expectedException \IBM\Watson\Common\Exception\InsufficientPrivilegesException
29			* @expectedExceptionMessage Not Authorized
30			*/
31			public function testUnauthorized()
32			{
33			$this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () {
34			return new Response(401, [], '{"error":"Not Authorized"}');
35			});
36
37			$tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
38
39			$tone->analyze('text');
40			}
41
42			/**
43			* @expectedException \IBM\Watson\Common\Exception\NotFoundException
44			* @expectedExceptionMessage Not Found
45			*/
46			public function testNotFound()
47			{
48			$this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () {
49			return new Response(404, [], '{"error":"Not Found"}');
50			});
51
52			$tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
53			$tone->analyze('text');
54			}
55
56			/**
57			* @expectedException \IBM\Watson\Common\Exception\UnknownErrorException
58			* @expectedExceptionMessage Unknown Error
59			*/
60			public function testUnknownError()
61			{
62			$this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () {
63			return new Response(900, [], '{"error":"Unknown Error"}');
64			});
65
66			$tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
67			$tone->analyze('text');
68			}
69
70			public function testDocumentToneAnalysis()
71			{
72			$rawResponse = '{"document_tone": {"tones": [{"score": 0.6165,"tone_id": "sadness","tone_name": "Sadness"}]}}';
73
74			$this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () use ($rawResponse) {
75			return new Response(200, ['Content-Type' => 'application/json'], $rawResponse);
76			});
77
78			$tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
79
80			$response = $tone->analyze(
81			'text',
82			['content_language' => 'en', 'accept_language' => 'en', 'learning_opt_out' => true]
83			);
84
85			$tones = $response->getDocumentAnalysis()->getTones();
86
87			$this->assertNotEmpty($tones);
88
89			$firstTone = $tones[0];
90
91			$this->assertEquals('sadness', $firstTone->getId());
92			$this->assertEquals('Sadness', $firstTone->getName());
93			$this->assertEquals(0.6165, $firstTone->getScore());
94			}
95
96			public function testSentenceToneAnaysis()
97			{
98			$rawResponse = '{
99			"document_tone": {
100			"tones": [
101			{
102			"score": 0.6165,
103			"tone_id": "sadness",
104			"tone_name": "Sadness"
105			},
106			{
107			"score": 0.829888,
108			"tone_id": "analytical",
109			"tone_name": "Analytical"
110			}
111			]
112			},
113			"sentences_tone": [
114			{
115			"sentence_id": 0,
116			"text": "Team, I know that times are tough!",
117			"tones": [
118			{
119			"score": 0.801827,
120			"tone_id": "analytical",
121			"tone_name": "Analytical"
122			}
123			]
124			},
125			{
126			"sentence_id": 1,
127			"text": "Product sales have been disappointing for the past three quarters.",
128			"tones": [
129			{
130			"score": 0.771241,
131			"tone_id": "sadness",
132			"tone_name": "Sadness"
133			},
134			{
135			"score": 0.687768,
136			"tone_id": "analytical",
137			"tone_name": "Analytical"
138			}
139			]
140			},
141			{
142			"sentence_id": 2,
143			"text": "We have a competitive product, but we need to do a better job of selling it!",
144			"tones": [
145			{
146			"score": 0.506763,
147			"tone_id": "analytical",
148			"tone_name": "Analytical"
149			}
150			]
151			}
152			]
153			}';
154
155			$this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () use ($rawResponse) {
156			return new Response(200, ['Content-Type' => 'application/json'], $rawResponse);
157			});
158
159			$tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
160
161			$response = $tone->analyze('text', ['content_language' => 'en', 'accept_language' => 'en']);
162
163			$sentences = $response->getSentenceAnalysis()->getSentences();
164
165			$this->assertNotEmpty($sentences);
166
167			$firstSentence = $sentences[0];
168
169			$this->assertEquals(0, $firstSentence->getId());
170			$this->assertEquals('Team, I know that times are tough!', $firstSentence->getText());
171
172			$tones = $firstSentence->getTones();
173
174			$this->assertNotEmpty($tones);
175			}
176
177			public function testAnalyzeHtml()
178			{
179			$rawResponse = '{"document_tone": {"tones": [{"score": 0.6165,"tone_id": "sadness","tone_name": "Sadness"}]}}';
180
181			$this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () use ($rawResponse) {
182			return new Response(200, ['Content-Type' => 'application/json'], $rawResponse);
183			});
184
185			$tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
186
187			$response = $tone->analyze('<div>Some HTML to test</div>', ['is_html' => true]);
188
189			$tones = $response->getDocumentAnalysis()->getTones();
190
191			$this->assertNotEmpty($tones);
192			}
193
194			public function testAnalyzeJson()
195			{
196			$rawResponse = '{"document_tone": {"tones": [{"score": 0.6165,"tone_id": "sadness","tone_name": "Sadness"}]}}';
197
198			$this->httpClient->shouldReceive('sendRequest')->once()->andReturnUsing(function () use ($rawResponse) {
199			return new Response(200, ['Content-Type' => 'application/json'], $rawResponse);
200			});
201
202			$tone = new Tone($this->httpClient, $this->hydrator, $this->requestBuilder);
203
204			$response = $tone->analyze('{"text": "Some text to analyze"}');
205
206			$tones = $response->getDocumentAnalysis()->getTones();
207
208			$this->assertNotEmpty($tones);
209			}
210			}
211

adam-paterson / ibm-watson-sdk

Pull Request — develop (#19)

ToneTest::testDocumentToneAnalysis() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like