Skip to content

Commit

Permalink
refactor tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@remi-san
remi-san committed Nov 1, 2016
1 parent f5f94cf commit 1422c20
Show file tree
Hide file tree
Showing 20 changed files with 287 additions and 184 deletions.
2 changes: 1 addition & 1 deletion tests/unit/Serializer/CoordinatesSerializerTest.php
View file
Original file line number Diff line number Diff line change
Expand Up @@ -76,7 +76,7 @@ public function itShouldNotUnserializeIllegalObject()
/**
* @test
*/
public function testUnserialize()
public function itShouldUnserialize()
{
$coordinates = $this->serviceUnderTest->unserialize($this->buildSerializedCoordinates());

Expand Down
277 changes: 190 additions & 87 deletions tests/unit/Serializer/DirectMessageSerializerTest.php
View file
Original file line number Diff line number Diff line change
@@ -1,38 +1,99 @@
<?php
namespace Twitter\Test\Serializer;

use Faker\Factory;
use Mockery\Mock;
use Twitter\Object\TwitterDate;
use Twitter\Object\TwitterDirectMessage;
use Twitter\Object\TwitterEntities;
use Twitter\Object\TwitterUser;
use Twitter\Serializer\TwitterDirectMessageSerializer;
use Twitter\Serializer\TwitterEntitiesSerializer;
use Twitter\Serializer\TwitterUserSerializer;
use Twitter\Test\Mock\TwitterObjectMocker;
use Twitter\Test\Mock\TwitterSerializerMocker;
use Twitter\TwitterMessageId;
use Twitter\TwitterSerializable;

class DirectMessageSerializerTest extends \PHPUnit_Framework_TestCase
{
use TwitterObjectMocker, TwitterSerializerMocker;
/** @var int */
private $id;

/**
* @var TwitterDirectMessageSerializer
*/
private $serializer;
/** @var string */
private $text;

/**
* @var TwitterUserSerializer
*/
/** @var \DateTimeInterface */
private $date;


/** @var object */
private $serializedSender;

/** @var object */
private $serializedRecipient;

/** @var object */
private $serializedEntities;


/** @var TwitterUser | Mock */
private $sender;

/** @var TwitterUser | Mock */
private $recipient;

/** @var TwitterEntities | Mock */
private $twitterEntities;


/** @var object */
private $serializedDirectMessage;

/** @var TwitterDirectMessage */
private $directMessage;


/** @var TwitterUserSerializer | Mock */
private $userSerializer;

/**
* @var TwitterEntitiesSerializer
*/
/** @var TwitterEntitiesSerializer | Mock */
private $entitiesSerializer;


/** @var TwitterDirectMessageSerializer */
private $serviceUnderTest;



public function setUp()
{
$this->userSerializer = $this->getUserSerializer();
$this->entitiesSerializer = $this->getEntitiesSerializer();
$this->serializer = new TwitterDirectMessageSerializer(
$faker = Factory::create();

$this->id = $faker->randomNumber();
$this->text = $faker->text();
$this->date = new \DateTimeImmutable('now', new \DateTimeZone('UTC'));

$this->serializedSender = new \stdClass();
$this->serializedRecipient = new \stdClass();
$this->serializedEntities = new \stdClass();

$this->sender = \Mockery::mock(TwitterUser::class);
$this->recipient = \Mockery::mock(TwitterUser::class);
$this->twitterEntities = \Mockery::mock(TwitterEntities::class);

$this->serializedDirectMessage = $this->getSerializedDirectMessage();
$this->directMessage = TwitterDirectMessage::create(
TwitterMessageId::create($this->id),
$this->sender,
$this->recipient,
$this->text,
$this->date,
$this->twitterEntities
);

$this->userSerializer = \Mockery::mock(TwitterUserSerializer::class);
$this->entitiesSerializer = \Mockery::mock(TwitterEntitiesSerializer::class);

$this->serviceUnderTest = new TwitterDirectMessageSerializer(
$this->userSerializer,
$this->entitiesSerializer
);
Expand All @@ -46,115 +107,157 @@ public function tearDown()
/**
* @test
*/
public function testSerializeWithIllegalObject()
public function itShouldNotSerializeWithIllegalObject()
{
$user = $this->getTwitterUser(42, 'douglas');
$object = \Mockery::mock(TwitterSerializable::class);

$this->setExpectedException('\\InvalidArgumentException');
$this->setExpectedException(\InvalidArgumentException::class);

$this->serializer->serialize($user);
$this->serviceUnderTest->serialize($object);
}

/**
* @test
*/
public function testSerializeWithLegalObject()
public function itShouldSerializeWithLegalDirectMessage()
{
$id = 666;
$text = 'dm';
$date = new \DateTimeImmutable();
$this->itWillSerializeSender();
$this->itWillSerializeRecipient();
$this->itWillSerializeEntities();

$senderObj = new \stdClass();
$senderObj->type = 'sender';
$sender = $this->getTwitterUser(33, 'doc');
$this->userSerializer->shouldReceive('serialize')->with($sender)->andReturn($senderObj);
$serialized = $this->serviceUnderTest->serialize($this->directMessage)->direct_message;

$recipientObj = new \stdClass();
$recipientObj->type = 'recipient';
$recipient = $this->getTwitterUser(42, 'douglas');
$this->userSerializer->shouldReceive('serialize')->with($recipient)->andReturn($recipientObj);

$entitiesObj = new \stdClass();
$entitiesObj->type = 'entities';
$entities = $this->getTwitterEntities();
$this->entitiesSerializer->shouldReceive('serialize')->with($entities)->andReturn($entitiesObj);
$this->assertEquals($this->id, $serialized->id);
$this->assertEquals($this->serializedSender, $serialized->sender);
$this->assertEquals($this->serializedRecipient, $serialized->recipient);
$this->assertEquals($this->text, $serialized->text);
$this->assertEquals($this->date->format(TwitterDate::FORMAT), $serialized->created_at);
$this->assertEquals($this->serializedEntities, $serialized->entities);
}

$obj = $this->getDirectMessage(TwitterMessageId::create($id), $text, $sender, $entities);
$obj->shouldReceive('getRecipient')->andReturn($recipient);
$obj->shouldReceive('getDate')->andReturn($date);
/**
* @test
*/
public function itShouldUnserializeDM()
{
$this->itWillUnserializeSender();
$this->itWillUnserializeRecipient();
$this->itCanUnserializeEntities();
$this->itWillUnserializeEntities();

$serialized = $this->serializer->serialize($obj)->direct_message;
$innerDirectMessage = $this->serializedDirectMessage->direct_message;
$directMessage = $this->serviceUnderTest->unserialize($this->serializedDirectMessage);

$this->assertEquals($id, $serialized->id);
$this->assertEquals($senderObj, $serialized->sender);
$this->assertEquals($recipientObj, $serialized->recipient);
$this->assertEquals($text, $serialized->text);
$this->assertEquals($date->getTimestamp(), (new \DateTimeImmutable($serialized->created_at))->getTimestamp());
$this->assertEquals($entitiesObj, $serialized->entities);
$this->assertEquals((string) $innerDirectMessage->id, (string) $directMessage->getId());
$this->assertEquals($this->sender, $directMessage->getSender());
$this->assertEquals($this->recipient, $directMessage->getRecipient());
$this->assertEquals($innerDirectMessage->text, $directMessage->getText());
$this->assertEquals($innerDirectMessage->created_at, $directMessage->getDate()->format(TwitterDate::FORMAT));
$this->assertEquals($this->twitterEntities, $directMessage->getEntities());
}

/**
* @test
*/
public function testUnserialize()
public function itShouldNotUnserializeIllegalObject()
{
$senderObj = new \stdClass();
$senderObj->type = 'sender';
$sender = $this->getTwitterUser(33, 'doc');
$this->userSerializer->shouldReceive('unserialize')->with($senderObj)->andReturn($sender);
$obj = $this->getIllegalSerializedObject();

$recipientObj = new \stdClass();
$recipientObj->type = 'recipient';
$recipient = $this->getTwitterUser(42, 'douglas');
$this->userSerializer->shouldReceive('unserialize')->with($recipientObj)->andReturn($recipient);
$this->setExpectedException(\InvalidArgumentException::class);

$this->serviceUnderTest->unserialize($obj);
}

$entitiesObj = new \stdClass();
$entitiesObj->type = 'entities';
$entities = $this->getTwitterEntities();
$this->entitiesSerializer->shouldReceive('canUnserialize')->with($entitiesObj)->andReturn(true);
$this->entitiesSerializer->shouldReceive('unserialize')->with($entitiesObj)->andReturn($entities);
/**
* @test
*/
public function itShouldBuildUsingStaticBuilder()
{
$serializer = TwitterDirectMessageSerializer::build();

$this->assertInstanceOf(TwitterDirectMessageSerializer::class, $serializer);
}

/**
* @return \stdClass
*/
private function getSerializedDirectMessage()
{
$dmObj = new \stdClass();
$dmObj->id = 42;
$dmObj->sender = $senderObj;
$dmObj->recipient = $recipientObj;
$dmObj->text = 'direct message';
$dmObj->created_at = (new \DateTimeImmutable('2015-01-01', new \DateTimeZone('UTC')))
->format(TwitterDate::FORMAT);
$dmObj->entities = $entitiesObj;
$dmObj->id = $this->id;
$dmObj->sender = $this->serializedSender;
$dmObj->recipient = $this->serializedRecipient;
$dmObj->text = $this->text;
$dmObj->created_at = $this->date->format(TwitterDate::FORMAT);
$dmObj->entities = $this->serializedEntities;

$superDmObject = new \stdClass();
$superDmObject->direct_message = $dmObj;

$dm = $this->serializer->unserialize($superDmObject);

$this->assertEquals((string) $dmObj->id, (string) $dm->getId());
$this->assertEquals($sender, $dm->getSender());
$this->assertEquals($recipient, $dm->getRecipient());
$this->assertEquals($dmObj->text, $dm->getText());
$this->assertEquals(new \DateTimeImmutable($dmObj->created_at), $dm->getDate());
$this->assertEquals($entities, $dm->getEntities());
return $superDmObject;
}

/**
* @test
* @return \stdClass
*/
public function testIllegalUnserialize()
private function getIllegalSerializedObject()
{
$obj = new \stdClass();
return new \stdClass();
}

$this->setExpectedException(\InvalidArgumentException::class);
private function itWillSerializeSender()
{
$this->userSerializer
->shouldReceive('serialize')
->with($this->sender)
->andReturn($this->serializedSender);
}

$this->serializer->unserialize($obj);
private function itWillSerializeRecipient()
{
$this->userSerializer
->shouldReceive('serialize')
->with($this->recipient)
->andReturn($this->serializedRecipient);
}

/**
* @test
*/
public function testStaticBuilder()
private function itWillSerializeEntities()
{
$serializer = TwitterDirectMessageSerializer::build();
$this->entitiesSerializer
->shouldReceive('serialize')
->with($this->twitterEntities)
->andReturn($this->serializedEntities);
}

$this->assertInstanceOf(TwitterDirectMessageSerializer::class, $serializer);
private function itWillUnserializeSender()
{
$this->userSerializer
->shouldReceive('unserialize')
->with($this->serializedSender)
->andReturn($this->sender);
}

private function itWillUnserializeRecipient()
{
$this->userSerializer
->shouldReceive('unserialize')
->with($this->serializedRecipient)
->andReturn($this->recipient);
}

private function itWillUnserializeEntities()
{
$this->entitiesSerializer
->shouldReceive('unserialize')
->with($this->serializedEntities)
->andReturn($this->twitterEntities);
}

private function itCanUnserializeEntities()
{
$this->entitiesSerializer
->shouldReceive('canUnserialize')
->with($this->serializedEntities)
->andReturn(true);
}
}
10 changes: 5 additions & 5 deletions tests/unit/Serializer/DisconnectSerializerTest.php
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ public function tearDown()
/**
* @test
*/
public function testSerializeWithIllegalObject()
public function itShouldNotSerializeWithIllegalObject()
{
$user = $this->getTwitterUser(42, 'douglas');

Expand All @@ -39,7 +39,7 @@ public function testSerializeWithIllegalObject()
/**
* @test
*/
public function testSerializeWithLegalObject()
public function itShouldSerializeWithLegalObject()
{
$code = '42';
$streamName = 'abcde';
Expand All @@ -60,7 +60,7 @@ public function testSerializeWithLegalObject()
/**
* @test
*/
public function testUnserialize()
public function itShouldUnserialize()
{
$disconnectObj = new \stdClass();
$disconnectObj->code = 'code';
Expand All @@ -80,7 +80,7 @@ public function testUnserialize()
/**
* @test
*/
public function testIllegalUnserialize()
public function itShouldNotUnserializeIllegalObject()
{
$obj = new \stdClass();

Expand All @@ -92,7 +92,7 @@ public function testIllegalUnserialize()
/**
* @test
*/
public function testStaticBuilder()
public function itShouldBuildUsingStaticBuilder()
{
$serializer = TwitterDisconnectSerializer::build();

Expand Down

0 comments on commit 1422c20

Please sign in to comment.