Implementar caso de uso e teste

[bidoofreak 0]

Oi pessoal, tudo bem?

 

Me foi passado um teste, mas eu não sei como resolver, estou bem perdido.

 

É um Post Service Client (no estilo de uma rede social)

 

Tenho a seguinte definição:

 

Uploaded with ImageShack.us

 

Me foi passado que deveria criar o modelo de design e a implementação desse modelo em PHP 5.3, utilizando design patterns e técnicas de design claras e adequadas.

 

Tem um caso de uso, que fala basicamente que dos atores e a estória, onde o fluxo é:

 

PSC mantém uma lista de posts

PSC mantém a referência do autor dos posts

PSC pode listar os posts

PSC pode deletar os posts

 

Pré-condição:

Um valor não-nulo pra ser armazenado

 

Pós-condição:

Uma mensagem de sucesso no armazenamento do post

 

E me foi passado um caso de teste, que precisa ser resolvido:

 

Regras de adição/inserção

Um titulo e um autor preenchidos - retorna true

Titulo ou autor vazio - retorna falso

Titulo maior que 255 caracteres - VAZIO - joga uma excessão

 

Só que galera eu to muito perdido nem sei por onde começar! Sei que tenho que implementar as classes Post e Posts, mas como vou fazer a implementação dos métodos de inserção e remoção? Preciso implementar alguma coisa a mais?

 

Por favor alguem me ajudaaa!

 

brigado

[João Batista Neto 448]

Primeiro, eu realmente gostaria de saber a origem desse exercício.

 

Segundo, o caso de uso:

 

 

O usuário pode fazer algumas coisas, todas essas coisas serão feitas através de uma interface gráfica de usuário :seta: GUI :seta: View

 

Cada caso de uso é uma ação que o usuário pode tomar, essas ações são como comandos :seta: Command :seta: e são responsabilidade de um Controller manipular.

 

Quando o controlador estiver manipulando uma requisição, ele acionará uma Model, responsável pelas regras de negócio. No caso da inserção de um novo post, uma atividade ocorrerá:

 

 

Então, de forma simplista, você possui casos de uso, que são manipulados por controladores e possui atividades, que fazem parte das regras de negócio. Toda interação do usuário com a aplicação é feita através de uma interface de usuário:

 

 

A arquitetura MVC separa cada uma dessas camadas, isso significa que cada uma possui uma responsabilidade clara e bem definida.

 

No caso, o Controller apenas manipula a requisição do usuário e delega à Model a responsabilidade das regras de negócios:

 

<?php
class Controller {
public function handleUserRequest() {
}
}

 

A Model faz todo o trabalho de validação dos dados do usuário, não é responsabilidade da Model lidar com o protocolo HTTP ou decidir o que fazer, ela apenas executa os comandos passados pelo Controller, ou seja, ela sabe como fazer:

 

<?php
class Model {
public function getPostIterator() {
}

public function createPost() {
}

public function readPost() {
}

public function updatePost() {
}

public function deletePost() {
}
}

 

Quando o trabalho da Model estiver concluído, dados serão retornados ao usuário, sejam mensagens de erro/sucesso ou listagens de posts, formulários para criação, visualização, atualização ou exclusão:

 

<?php
class View {
public function show() {
}
}

 

Quando falamos sobre ações de usuário e comandos, falamos sobre um padrão chamado Command:

 

 

Como pode ver, temos alguns participantes ai:

 

Invoker é quem manda executar um comando.

Receiver é quem usa a interface de Command para executar o comando.

 

O ConcreteCommand é o cara que conhece como a ação é executada no Receiver, DeleteCommand, por exemplo, pode ser o método deletePost() na nossa Model.

 

Bom, então temos ações de usuário :seta: requisições HTTP :seta: que são manipuladas pelo Controller e viram Commands :seta: que são executadas na Model.

 

A modelagem dessa aplicação seria alguma coisa assim:

 

 

Strategy :seta: Como você pode ter algorítimos diferentes para contextos diferentes (Mobile, Web, Desktop), você pode encapsular a família de algorítimos utilizando o padrão GoF Strategy, dessa forma você pode variar o algorítimo do contexto.

 

Command :seta: Com Command, você encapsulará a requisição do usuário como um objeto.

 

Observer :seta: Permitirá que sua Model, caso tenha seu estado modificado, notifique a View sobre seu novo estado e, dessa forma, o usuário tenha sua GUI atualizada também.

 

AbstractFactory :seta: Como a exibição em um dispositivo móvel é menor que a de um desktop, você precisa ser capaz de criar componentes que se adequem nos dois casos. Com AbstractFactory, sua View utilizará as interfaces de Botões, Posts, Formulário, etc... sem precisar saber de fato, onde o componente será exibido.

 

Com a modelagem, você já tem um ponto de partida, agora para finalizar, você precisa dos testes e, para isso, você pode utilizar PHPUnit :seta: http://www.phpunit.d...6/en/index.html

 

Seria alguma coisa como:

 

<?php
require_once 'Application.php';
require_once 'PHPUnit/Framework/TestCase.php';

/**
* Application test case
*/
class ApplicationTestTest extends PHPUnit_Framework_TestCase {
/**
 * @var Application
 */
private $application;

/**
 * Prepares the environment before running a test.
 */
protected function setUp() {
	parent::setUp();

	$this->application = new Application();
}

/**
 * Cleans up the environment after running a test.
 */
protected function tearDown() {
	$this->application = null;

	parent::tearDown();
}

/**
 * Tests $application->setAuthor() with null
 * @expectedException InvalidArgumentException
 */
public function testSetAuthorWithNull() {
	$this->application->setAuthor( null ); //this should throw an InvalidArgumentException
}

/**
 * Teste $application->setAuthor() with valid content
 */
public function testSetAuthor() {
	$author = 'Some psc Author';
	$this->application->setAuthor( $author );

	$this->assertEquals( $author , $this->application->getAuthor() );
}
}

 

Agora é só se divertir com a implementação.

 

;)