Neste post vou falar sobre o que eu acho que seria o ambiente ideal de desenvolvimento de projetos SharePoint, conforme o cenário, ele pode ser alterado sem problemas. O objetivo principal é mais uma orientação inicial do que um manual de como montar o ambiente.

Este post faz parte de uma série de posts sobre entendimento do SharePoint 2010, acesse o post principal para ver os outros assuntos: Entendendo o SharePoint 2010

No site da Microsof tem um link bem interessante Setting Up the Development Environment for SharePoint 2010 on Windows Vista, Windows 7, and Windows Server 2008 que trata sobre parte do conteúdo que vou falar aqui, recomendo dar uma olhada.

Para o desenvolvimento de projetos SharePoint visualizo 4 ambientes distintos: ambiente de desenvolvimento individual, ambiente de integração, ambiente de homologação e ambiente de produção. Conforme o tamanho do projeto ou outros requisitos, nem todos os ambiente são necessários. Projetos pequenos podem ser feito com menos servidores e projetos maiores podem necessitar de outros ambientes.

A arquitetura física dos servidores não é algo importante para este artigo, coloquei os servidores apenas para explicar os ambiente.

Ambiente de Desenvolvimento Individual

Este é o ambiente onde um desenvolvedor irá trabalhar, por isso ele vai precisar de pelo menos um SharePoint, Visual Studio, Office, SQL Server, etcs. A questão é onde colocar isso tudo.

Prefiro a utilização de máquinas virtuais, instalar o Windows Server 2008 R2 (ou esperar o Windows 8) para virtualizar todos os ambientes necessários. Digo isso porque se instalar o SharePoint no host do computador do desenvolvedor, conforme os projetos o ambiente poderá ser comprometido, ainda mais se forem projetos em versões direrentes do SharePoint como SharePoint 2007, WSS 3.0, SharePoint Foundation. Se a equipe trabalhar apenas com um projeto ou o cliente for interno e não consultoria onde existem vários projetos para vários clientes, considere instalar tudo no computador físico mesmo ao invés de virtualizar.

Independente da escolha de virtualizar ou não, é necessário ter o Visual Studio 2010 na mesma máquina do SharePoint, sem isso a experiência de desenvolvimento, leia aqui produditivade, será comprometida.

Cada máquina virtual poderá conter a farm completa do SharePoint com o SQL Server, SharePoint, Visual Studio. As ferramentas do Office e SharePoint Designer podem ficar na máquina do desenvolvedor sem problema, já que elas não são necessárias no ambiente e assim economizam espaço em disco e tempo de instalação.

O SQL Server pode ficar dentro da máquina virtual, ou se preferirem no computador do desenvolvedor ou até em um servidor de bando de dados de desenvolvimento. Eu prefiro que fique na máquina virtual do desenvolvedor, mesmo ocupando um pouco mais de recurso da máquina, assim ele pode ter versões diferentes, conforme o projeto. Não é requisito o banco estar na mesma versão do ambiente de produção, mas acredito que quanto mais próximo melhor.

Outra opção é utilizar o WTS (Windows Terminal Services), mas não gosto dela nem um pouco. Com 2 desenvolvedores na mesma máquina serão comuns os problemas de precisar reiniciar o IIS e afetar o debug ou outras atividades do outro desenvolvedor, imagina colocar 4, 6 ou 10 –pessoas desenvolvendo na mesma máquina. É IIS reset a toda hora.

O AD pode ser o AD da empresa, utilizando uma OU separada, ou se necessário, criar um AD específico para o projeto. Isso seria necessário onde integrações com o perfil de usuários mais customizadas e complexas fossem necessárias.

É neste ambiente que o desenvolvedor vai desenvolver e testar a sua unidade, seja teste manual ou teste automatizado. Mas é muito importante ele garantir que a unidade dele funcione antes de liberar.

A imagem 01 detalha o ambiente de desenvolvimento, onde existe o computador de cada desenvolvedor e esse virtualiza tudo que necessário.

Imagem 01: Ambiente de desenvolvimento individual

Ambiente de Integração

Como cada desenvolvedor trabalha na sua máquina, é importante ter um ambiente para que o trabalho de todos seja testado em conjunto. Cada unidade foi festada individualmente, agora é hora de colocar tudo junto e testar para ver se continuam funcionando. Não é difícil aparecerem diversos erros devido a alterações de configurações do ambiente, campos, tipos de conteúdo, ou outras alterações feitas em uma unidade e que uma outra unidade esperava esses valores de forma diferente. Por isso este ambiente é tão importante.

A presença do Visual Studio nesse ambiente pode ser necessária para depurar os erros ou garantiar algum comportamento.

A implantação das unidades dos desenvolvedores poder ser feita utilizando integração contínua, ou seja, cada vez que um desenvolvedor faz um check in de fonte (liberou a sua unidade) o TFS (Team Foundation Server – ferramenta da Microsoft para gerenciamento de fontes e ciclo de vida de aplicativos) baixa e compila todos os fontes no servidor de integração e executa os testes automaticamente. Qualquer erro que acontecer os desenvolvedores serã avisados e corrigem o erro o mais rápido possível, geralmente quem fez o check in que gerou o erro. Esta automatização é opcional, a outra forma é fazer o deploy manual toda vez que a unidade estiver pronta, mas o tempo para executar o mesmo procedimento será muito maior.

A imagem 02 mostra uma ideia do ambiente de integração, lembrando que o número de sevidores e a arquitetura deles pode varia conforme as necessidades do projeto.

Imagem 02: Ambiente de integração

Ambiente de Homologação

O ambiente de homologação é o mais comum existir em projetos de software, geralmente é onde o cliente faz o aceite de tudo o que foi criado. Neste ambiente não existe nenhuma ferramante de desenvolvimento e ele precisa ser o mais similar possível ao ambiente de produção, para evitar problemas na hora de implatar. Se o ambiente de homologação for muito diferente do de produção, erros arquiteturais de servidores e serviços não serão pegos, além de outros erros que podem acontecer. Por isso reforço, quanto mais similar ao ambiente de produção melhor.

Imagem 03: Ambiente de homologação

Ambiente de Produção

Este é, sem questão alguma, o ambiente mais importante de todos. Aqui os serviços não podem parar e o site tem que estar disponível para o usuário sempre. Ferramentas de desenvolvimento não são bem vindas aqui, apenas em exceções muito urgente e que não podem ser resolvidas sem a instalação das ferramentas.

Sempre que for instalar alguma unidade no ambiente, lembre de avisar os usuários de possíveis paradas no serviço e dê preferência em fazer fora do horário.

Imagem 04: Ambiente de produção

Antes do evento começar veio o pessoal da rádio e fez uma entrevista com o Nogare, foi muito legal pelo nível de interesse e das perguntas que fizeram, a rádio chega a ter uma audiência de 150.000 pessoas.

Os números do evento foram melhores do que esperávamos, o sábado estava chuvoso e um pouco frio, já que Botucatu é a segunda cidade mais alta de São Paulo, mas mesmo assim foram 160 pessoas participar do evento.

Site oficial do evento: MS Techday Botucatu.

A primeira palestra foi do Daniel Donda, sobre Windows 8 e Windows Server 2012. A próxima foi a minha que falei sobre SharePoint para Sites Internet. Após o almoço o Diego Nogare falou sobre BI e logo mais veio o Lucas Romão falando de Windows Azure.

As palestras foram sensacionais, é incrível como a já assisti algumas palestras várias vezes mas sempre tem novidades, muito bom o empenho dos palestrantes em trazer sempre novidades.

O pessoal de Botucatu foi muito receptivo e tratou a gente muito bem, gostei muito da recepção. Espero poder voltar para para outros eventos.

Imagem 01: Pessoal do evento no encerramento

Imagem 02: Eu palestrando sobre SharePoint

Link das fotos

Participem e contribuam!

Neste post vou mostrar algumas opções de como resolver o problema.

O responsável por fazer com que esse recurso funciona é um serviço do Windows chamado WebClient, algumas formas para verificar e resolver o problema:

1. Verifique se o serviço do Windows chamado WebClient ou Cliente de Web está ativado no computador do usuário, se não estiver ative-o e configure para iniciar automaticamente;
2. Se o serviço não existir, pode ser que o seu Windows 7 seja das edições Home ou fale com o administrador da rede pra verificar se não existe nenhuma GPO para desabilitar o serviço;
3. Em algumas situações pode ser que o serviço não exista no Windows, para isso baixe e instale o update do WebClient e tente novamente.

Com os passos acima o comportamento deverá ser normalizado.

Post publicado na TechNet Wiki: Microsoft Office Não Consegue Salvar Documentos no SharePoint

Neste post vou mostrar como acessar os dados do SharePont Online através do web service Lists.asmx.

Para trabalhar com dados do SharePoint Online o desenvolvedor deve prestar atençãoa  dois pontos:

1. A classe ClaimClientContext retorna um ClientContext ao invés de Lists, como seria experado ao se trabalhar com o Lists.asmx;
2. A referência ao serviço https://sites/_vti_bin/Lists.asmx deve ser feita na opção avançada da inclusão da referência ao serviço, lá em adicionar referência web. Se for adicionada como serviço não irá funcionar da forma descrita neste post.

O código completo deste projeto está no GitHub SharePoint-Demos e contém diversos outros exemplo. O nome do projeto é ListASMXDemo.

Algumas alterações foram necessárias na classe ClaimClientContext, como alterar o retorno do método GetAuthenticatedContext para retornar Lists, conforme a listagem 01, e alterar a regra do método GetAuthenticatedContext (listagem 02) para trabalhar Lists ao invés de ClientContext.

Neste post vou mostrar apenas a implementação da classe RepositorioTarefas, para ver as demais acesse os fontes do projeto.

public static SharePointLists.Lists GetAuthenticatedContext(string targetSiteUrl)
{
    return (GetAuthenticatedContext(targetSiteUrl, 0, 0));
}

Listagem 01: Método GetAuthenticatedContext alterado

/// <summary>
/// This method will return a ClientContext object with the authentication cookie set.
/// The ClientContext should be disposed of as any other IDisposable
/// </summary>
/// <param name=”targetSiteUrl”></param>
/// <returns></returns>
public static SharePointLists.Lists GetAuthenticatedContext(string targetSiteUrl, int popUpWidth, int popUpHeight)
{
    CookieCollection cookies = null;
    cookies = ClaimClientContext.GetAuthenticatedCookies(targetSiteUrl, popUpWidth, popUpHeight);
    if (cookies == null) return null;

    SharePointLists.Lists contexto = new SharePointLists.Lists();

    try
    {
        contexto.CookieContainer = new CookieContainer();
        foreach (Cookie cookie in cookies)
        {
            contexto.CookieContainer.Add(cookie);
        }
    }
    catch
    {
        if (contexto != null) contexto.Dispose();
        throw;
    }

    return contexto;
}

Listagem 02: Método GetAuthenticatedContext alterado

Com a classe ClaimClientContext devidamente alterada, agora vamos implementar a classe de repositório de tarefas. A listagem 03 mostra as referências, classe e construtor padrão da classe.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.ServiceModel;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using ListsASMXDemo.Entidades;
using ListsASMXDemo.Helpers;

namespace ListsASMXDemo
{
    public class RepositorioTarefas
    {
        private SharePointLists.Lists Contexto;

        public RepositorioTarefas()
        {
            Contexto = ClaimClientContext.GetAuthenticatedContext(Constants.ENDRECO_SITE);
            Contexto.Url = Constants.ENDRECO_SITE + “/_vti_bin/Lists.asmx”;
        }

Listagem 03: Campos e construtor da classe RepositorioTarefas

O método ObterTodos retorna todas as tarefas cadastradas no SharePoint, veja como os parâmetros são montados para buscar os dados. No exemplo da listagem 04 todos os campos são retornado, mas poderam ser apenas algunas campos como id e título, por exemplo. Como o retorno do método é um XmlNode, quanto menos informação inútil eu retornar, melhor será.

public List<Tarefa> ObterTodos()
{
     XmlDocument xmlDoc = new System.Xml.XmlDocument();

     XmlNode ndQuery = xmlDoc.CreateNode(XmlNodeType.Element, “Query”, “”);
     XmlNode ndViewFields = xmlDoc.CreateNode(XmlNodeType.Element, “ViewFields”, “”);
    
     XmlNode ndQueryOptions = xmlDoc.CreateNode(XmlNodeType.Element, “QueryOptions”, “”);
     ndQueryOptions.InnerXml = “<IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns>”;

     XmlNode ndListItems = Contexto.GetListItems(“Tarefas”, null, ndQuery, ndViewFields, null, ndQueryOptions, null);

     return TarefaConverterHelper.ItensParaTarefas(ndListItems);
}

Listagem 04: Método ObterTodos

O método ObterPorID retorna apenas a tarefa conforme o id passado por parâmetro. Usa CAML para fazer o filtro, conforme listagem  05.

public Tarefa ObterPorID(int id)
{
     XmlDocument xmlDoc = new System.Xml.XmlDocument();

     XmlNode ndQuery = xmlDoc.CreateNode(XmlNodeType.Element, “Query”, “”);
     XmlNode ndViewFields =  xmlDoc.CreateNode(XmlNodeType.Element, “ViewFields”, “”);
     XmlNode ndQueryOptions = xmlDoc.CreateNode(XmlNodeType.Element, “QueryOptions”, “”);

     ndQueryOptions.InnerXml = “<IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns>”;

     ndQuery.InnerXml = “<Where><Eq><FieldRef Name=’ID’/>” +
                        “<Value Type=’Number’>” + id.ToString() + “</Value></Eq></Where>”;

     XmlNode ndListItems = Contexto.GetListItems(“Tarefas”, null, ndQuery, ndViewFields, null, ndQueryOptions, null);

     return TarefaConverterHelper.ItensParaTarefas(ndListItems)[0];
}

Listagem 05: Método ObterPorID

O método para buscar pelo título da tarefa é muito parecido com o de obter pelo id, a única coisa que muda é a query CAML que é passada para o método GetListItems, conforme a listagem 06.

 public List<Tarefa> ObterPorFiltro(string titulo)
{
     XmlDocument xmlDoc = new System.Xml.XmlDocument();

     XmlNode ndQuery = xmlDoc.CreateNode(XmlNodeType.Element, “Query”, “”);
     XmlNode ndViewFields = xmlDoc.CreateNode(XmlNodeType.Element, “ViewFields”, “”);
     XmlNode ndQueryOptions = xmlDoc.CreateNode(XmlNodeType.Element, “QueryOptions”, “”);

     ndQueryOptions.InnerXml = “<IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns>”;

     ndQuery.InnerXml = “<Where><Contains><FieldRef Name=’Title’/>” +
                        “<Value Type=’Text’>” + titulo + “</Value></Contains></Where>”;

     XmlNode ndListItems = Contexto.GetListItems(“Tarefas”, null, ndQuery, ndViewFields, null, ndQueryOptions, null);

     return TarefaConverterHelper.ItensParaTarefas(ndListItems);
}

Listagem 06: Método ObterPorFiltros

Os métodos Salvar e Excluir, nas listagems 07 e 08 respectivamente, são idênticos, neles um parâmetro Method com o cmd adequado são passados para o método UpdateListItems. Esse método pode receber inclusão, edição ou exclusão de diversmos itens ao mesmo tempo. Para isso é necessário montar o XML e informar todos os dados.

 public Tarefa Salvar(Tarefa tarefa)
{
     ///*Get Name attribute values (GUIDs) for list and view. */
     System.Xml.XmlNode ndListView = Contexto.GetListAndView(“Tarefas”, “”);
     string strListID = ndListView.ChildNodes[0].Attributes["Name"].Value;
     string strViewID = ndListView.ChildNodes[1].Attributes["Name"].Value;

     /*Create an XmlDocument object and construct a Batch element and its
     attributes. Note that an empty ViewName parameter causes the method to use the default view. */
     System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
     System.Xml.XmlElement batchElement = doc.CreateElement(“Batch”);
     batchElement.SetAttribute(“OnError”, “Continue”);
     batchElement.SetAttribute(“ListVersion”, “1″);
     batchElement.SetAttribute(“ViewName”, strViewID);

     batchElement.InnerXml = TarefaConverterHelper.TarefaParaXML(tarefa);

     Contexto.UpdateListItems(strListID, batchElement);

     return tarefa;
}

Listagem 07: Método Salvar

public void Excluir(int id)
{
     /*Get Name attribute values (GUIDs) for list and view. */
     System.Xml.XmlNode ndListView = Contexto.GetListAndView(“Tarefas”, “”);
     string strListID = ndListView.ChildNodes[0].Attributes["Name"].Value;
     string strViewID = ndListView.ChildNodes[1].Attributes["Name"].Value;

     /*Create an XmlDocument object and construct a Batch element and its
     attributes. Note that an empty ViewName parameter causes the method to use the default view. */
     System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
     System.Xml.XmlElement batchElement = doc.CreateElement(“Batch”);
     batchElement.SetAttribute(“OnError”, “Continue”);
     batchElement.SetAttribute(“ListVersion”, “1″);
     batchElement.SetAttribute(“ViewName”, strViewID);

     batchElement.InnerXml = “<Method ID=’0′ Cmd=’Delete’><Field Name=’ID’>” + id.ToString() + “</Field></Method>”;

     Contexto.UpdateListItems(strListID, batchElement);
}

Listagem 08: Método Excluir

Para testar a solução, sem precisar implementar a camada de apresentação ou o restante das regras de negócio implementei testes unitários, facilitando assim bastante o desenvolvimento.

Neste post vou mostrar como trabalhar com esses dados do SharePoint Online, para isso vou utilizar uma lista de tarefas padrão do SharePoint e a API para acesso remoto através do .NET.

Para fazer a COM (Client Object Model) acessar o SharePoint Online temos um desafio bem grande: a autenticação. Se utilizar a mesma rotina que é utilizada no SharePoint local, não é possível conectar no SharePoint Onlin, dá erro de 403 Forbidden. Todo material que eu achei para resolver isso segue o mesmo padrão, criar uma classe, como por exemplo a implementação disponível na Code Gallery ClaimClientContext, que consiste na chamada da tela de login para o usuário informar as credenciais e depois pegar o cookie gerado para autenticar. Se o usuário salvar a senha não irá solicitar as credenciais novamente.

Com esse problema resolvido, o restante do código é igual para as soluções de SharePoint Online ou SharePoint OnPremise, o código completo deste projeto está no GitHub SharePoint-Demos e contém diversos outros exemplo.

Neste post vou mostrar apenas a implementação da classe RepositorioTarefas, para ver as demais acesse os fontes do projeto.

A listagem 01 mostra a classe repositórios que abstrai a camada de SharePoint, para fazer isso criei uma classe chamada Tarefa e cada interação com o repositório ela é transformada de tarefa para item de lista ou item de lista para tarefa, conforme a necessidade. Esse código está na classe de helper chamada TarefaConverterHelper.

O método ClaimClientContext.GetAuthenticatedContext retorna um objeto do tipo ClientContext, se o objetivo for utilizar o SharePoint OnPremise este método deve ser substituído pela criação do ClientContext padrão.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.Client;
using ClientObjectModelDemo.Entidades;
using System.Net;
using ClientObjectModelDemo.Helpers;

namespace ClientObjectModelDemo
{
    public class RepositorioTarefas
    {

        private ClientContext Contexto;
        private Web Web;
        private List ListaTarefas;

        public RepositorioTarefas()
        {
            this.Contexto = ClaimClientContext.GetAuthenticatedContext(Constants.ENDRECO_SITE);
            this.Web = Contexto.Web;
            this.ListaTarefas = this.Web.Lists.GetByTitle(“Tarefas”);
        }

Listagem 01: campos e construtor da classe RepositorioTarefas

A listagem 02 mostra o método ObterTodos, que retorna todas as tarefas cadastradas na lista do SharePoint, após fazer isso converte os objetos itens de lista em objetos tarefas.

public List<Tarefa> ObterTodos()
{
    CamlQuery camlQuery = new CamlQuery();
    camlQuery.ViewXml = “<View/>”;
    ListItemCollection itens = ListaTarefas.GetItems(camlQuery);

    Contexto.Load(itens);
    Contexto.ExecuteQuery();

    return TarefaConverterHelper.ItensParaTarefas(itens);
}

Listagem 02: Método ObterTodos

A listagem 03 mostra a obtenção das tarefas passando como filtro um pedaço do título da tarefa. O filtro é feito utilizando CAML.

public List<Tarefa> ObterPorFiltro(string titulo)
{
    CamlQuery camlQuery = new CamlQuery();
    camlQuery.ViewXml = “<View><Query><Where> ” +
                        “<Contains> ” +
                        “<FieldRef Name=’Title’ /> ” +
                        “<Value Type=’Text’>” + titulo + “</Value> ” +
                        “</Contains> ” +
                        “</Where></Query></View> “;

    ListItemCollection itens = ListaTarefas.GetItems(camlQuery);

    Contexto.Load(itens);
    Contexto.ExecuteQuery();

    return TarefaConverterHelper.ItensParaTarefas(itens);
}

Método 03: Método ObterPorFiltro

Para obter apenas um item pelo id foi criado o método ObterPorID, que recebe o id da tarefa e retorna o objeto tarefa.

public Tarefa ObterPorID(int id)
{
    ListItem item = ListaTarefas.GetItemById(id);

    Contexto.Load(item);
    Contexto.ExecuteQuery();

    return TarefaConverterHelper.ItemParaTarefa(item);
}

Método 04: ObterPorID

O método Salvar salva a tarefa recebida por parâmetro no SharePoint, se for uma tarefa sem id quer dizer que é uma tarefa nova, sendo assim cria um novo item, atribui os campos e insere o novo registro. Se já tiver id só atualiza os dados e salva.

public Tarefa Salvar(Tarefa tarefa)
{
    ListItem itemTarefa;

    if (tarefa.ID == (default(int)))
    {
        ListItemCreationInformation itemCreateInfo = new ListItemCreationInformation();
        itemTarefa = ListaTarefas.AddItem(itemCreateInfo);
    }
    else
    {
        itemTarefa = ListaTarefas.GetItemById(tarefa.ID);
        Contexto.Load(itemTarefa);
        Contexto.ExecuteQuery();
    }

    itemTarefa = TarefaConverterHelper.TarefaParaItem(tarefa, itemTarefa);

    itemTarefa.Update();
    Contexto.ExecuteQuery();

    return ObterPorID(itemTarefa.Id);
}

Método 05: Método Salvar

O método excluir, conforme a listagem 06, recebe o id da tarefa e exclui no SharePoint.

public void Excluir(int id)
{
    ListItem tarefa = ListaTarefas.GetItemById(id);

    tarefa.DeleteObject();

    Contexto.ExecuteQuery();
}

Método 06: Método Excluir

Para testar a solução, sem precisar implementar a camada de apresentação ou o restante das regras de negócio implementei testes unitários, facilitando assim bastante o desenvolvimento.

O horário dos web casts será das 20:00 às 21:00.

Segue a programação:

A discussão foi muito interessante, já que na mesa estavam pessoas que eram contra e outras a favor da regulamentação. Foram 2 horas de discussão com participação da mesa e do público presente.

O formato da discussão foi parecido com um debate político onde um tema era levantado e os participantes poderiam responder e a partir dessas respostas teríam réplicas e opiniões da público. Além disso o público também pode fazer perguntas aos membros da mesa.

Antes e depois da discussão o público era em grande parte a favor da regulamentação, alguns que estavam indecisos mudaram de opinião e também ficaram a favor da regulamentação.

Particularmente acho esse um tema muito delicado e que pode gerar muita discussão. Não sou contra a regulamentar e também não sou a favor. Confuso? Não, bem simples, o que me preocupa é a forma como será feito. Se for feito de uma forma onde o profissional de informática tenha vantagens e não apenas cobraças, acho interessante.

Obrigado ao Rogério Fontes e Karina Viana pelo convite, gostei muito de ter participado.

Imagem 01: Composição da Mesa

Imagem 02: Mesa e o moderador

Para esse tipo de problema existem uma solução que consiste em substituir a camada de acesso a dados, no caso fazer um mock, e testar as regras de negócio sem precisar do SharePoint.

Neste post vou mostrar um exemplo de como fazer um mock utilizando a biblioteca Moq com o padrão repostitório para executar os testes unitários nas regras de negócio.

Entidade

Neste case vamos fazer algo bem simples, onde existirá uma entidade chamada pessoa, algumas propriedades e um método de negócio, que é bem simples e só concatena as propriedades, a listagem 01 mostra o código da classe Pessoa.

public class Pessoa
{
    public int ID { get; set; }
    public string Nome { get; set; }
    public DateTime DataNascimento { get; set; }
    public string Endereco { get; set; }
    public int Idade
    {
        get
        {
            return (int) DateTime.Now.Subtract(DataNascimento).TotalDays / 365;
        }
    }

    public string ConcatenarDadosUsuario()
    {
        return string.Format(“ID: {0}, Nome: {1}, Idade: {2}, Endereço: {3}”, this.ID.ToString(), this.Nome, this.Idade.ToString(), this.Endereco);
    }
}

Listagem 01: Implementação da classe pessoa

Repositório

Utilizando o padrão repositório todos os métodos de acesso a dados ficam na classe repositório, facilidando a sua substituição na hora do teste. O primeiro passo é construir a interface, conforme a listagem 02, depois implementar a classe que irá acessar o SharePoint para trabalhar com os dados. Por não haver necessidade, a classe que implementa a interface do repositório não foi implementada, apenas criadas com os métodos padrão. Em um ambiente real ela precisa ser implementada e é a partir dela que todo o acesso ao SharePoint é feito.

public interface IRepositorioPessoas
{

    Pessoa ObterPorID(int pessoaID);

    List<Pessoa> ObterTodos();

    List<Pessoa> ObterPorFiltro(string nome);

    Pessoa Salvar(Pessoa pessoa);

    bool Excluir(int ID);
}

Listagem 02: A interface seguindo padrão repositório

public class RepositorioPessoa: IRepositorioPessoas
{
    public Pessoa ObterPorID(int pessoaID)
    {
        throw new NotImplementedException();
    }

    public List<Pessoa> ObterTodos()
    {
        throw new NotImplementedException();
    }

    public List<Pessoa> ObterPorFiltro(string nome)
    {
        throw new NotImplementedException();
    }

    public Pessoa Salvar(Pessoa pessoa)
    {
        throw new NotImplementedException();
    }

    public bool Excluir(int ID)
    {
        throw new NotImplementedException();
    }
}

Listagem 03: Classe que trabalhar com os dados do SharePoint e implementa a inteface da listagem 02

Teste

A classe de teste é uma classe de teste unitário do Visual Studio, além da implementação feita na listagem 03 é necessário por a referência no projeto a biblioteca Moq (using Moq), que pode ser baixada diretamente pelo Visual Studio através do NuGet Packages (ou pelo site do Moq).

A implementação da classe de teste é um pouco diferente de um testes normal, a primeira coisa a ser feita, na criação da classe de teste é criar o objeto moq para simular a nossa classe de negócio. Todos os dados e regras dos métodos serão implementados neste momento, veja o construtor PessoaTeste, onde um repositório de dados é montado e os métodos implementados. Vejam que é implementação do método mesmo, com as regras sobre os dados recém criados.

A partir do momento que todas as interações com os dados estão feitas, os testes podem ser criados e executados. Como as regras de negócio ficam em outra camada, é simples obter os dados fake e passar para eles e depois obter o resultado, possibilitando assim o teste das regras mesmo sem ter o repositório de dados oficial, no caso o SharePoint.

[TestClass]
public class PessoaTest
{
    public readonly IRepositorioPessoas MockRepositorioPessoa;

    public PessoaTest()
    {
        List<Pessoa> pessoas = new List<Pessoa>
            {
               new Pessoa {ID = 1, Nome = “Pedro de Lara”, Endereco = “Rua Sem Nome, Nr 1″, DataNascimento = new DateTime(1990, 01, 01)},
               new Pessoa {ID = 2, Nome = “Carlos Lara da Silva”, Endereco = “Rua Sem Nome, Nr 2″, DataNascimento = new DateTime(1980, 12, 23)},
               new Pessoa {ID = 3, Nome = “João Cunha”, Endereco = “Rua Sem Nome, Nr 3″, DataNascimento = new DateTime(1989, 02, 02)

            }
    };

    // Criação do Mock utilizando Moq
    Mock<IRepositorioPessoas> mockProductRepository = new Mock<IRepositorioPessoas>();

    // Nas linhas abaixo os métodos estão sendo configurados no mock

    // Retorna todas as pessoas
    mockProductRepository.Setup(mr => mr.ObterTodos()).Returns(pessoas);

    // Retorna a pessoa pelo ID
    mockProductRepository.Setup(mr => mr.ObterPorID(
        It.IsAny<int>())).Returns((int i) => pessoas.Where(
        p => p.ID == i).Single());

    // Retorna as pessoas pelo filtro do nome
    mockProductRepository.Setup(mr => mr.ObterPorFiltro(
        It.IsAny<string>())).Returns((string i) => pessoas.Where(
        p => p.Nome.Contains(i)).ToList());

    // Exclui a pessoa com ID passado por parâmetro
    mockProductRepository.Setup(mr => mr.Excluir(It.IsAny<int>())).Returns(
        (int id) =>
        {
            Pessoa pessoa = pessoas.Where(p => p.ID == id).Single();
            pessoas.Remove(pessoa);

            return true;
        });

    // Salva (insere ou altera) uma pessoa
    mockProductRepository.Setup(mr => mr.Salvar(It.IsAny<Pessoa>())).Returns(
        (Pessoa pessoa) =>
        {
            DateTime now = DateTime.Now;

            if (pessoa.ID.Equals(default(int)))
            {
                // Insere a pessoa nova
                pessoa.ID  = pessoas.Count() + 1;
                pessoas.Add(pessoa);

                return pessoa;
            }
            else
            {
                // Atualiza a pessoa existente
                var original = pessoas.Where(
                    q => q.ID == pessoa.ID).Single();

                if (original == null)
                {
                    return null;
                }

                original.Nome = pessoa.Nome;
                original.Endereco = pessoa.Endereco;
                original.DataNascimento = pessoa.DataNascimento;

                return original;
            }
        });

        // Finaliza a configuração do mock
        this.MockRepositorioPessoa = mockProductRepository.Object;
    }

    /// <summary>
    /// Verifica se todos as pessoas foram retornadas
    /// </summary>
    [TestMethod]
    public void PodeRetornarTodasPessoas()
    {
        // Obtém todas as pessoas
        IList<Pessoa> pessoas = this.MockRepositorioPessoa.ObterTodos();

        Assert.IsNotNull(pessoas); // Teste se é nulo
        Assert.AreEqual(3, pessoas.Count); // Verifica o número de pessoas retornadas
    }

    /// <summary>
    /// Verifica se todos se a pessoa foi retornada a partir do ID
    /// </summary>
    [TestMethod]
    public void PodeRetornarPessoaPorID()
    {
        // Obtém a pessoa com ID 1
        Pessoa pessoa = this.MockRepositorioPessoa.ObterPorID(1);

        Assert.IsNotNull(pessoa); // Teste se é nulo
        Assert.AreEqual(1, pessoa.ID); // Verifica a pessoa retornada é a correta
    }

    /// <summary>
    /// Verifica se todos as pessoas foram retornadas pelo filtro
    /// </summary>
    [TestMethod]
    public void PodeRetornarObterPorFiltro()
    {
        string nome = “Lara”;

        // Obtém a pessoa com ID 1
List<Pessoa> pessoas = this.MockRepositorioPessoa.ObterPorFiltro(nome);

        Assert.IsNotNull(pessoas); // Teste se é nulo
        Assert.AreEqual(2, pessoas.Count); // Verifica a pessoa retornada é a correta
        Assert.AreEqual(true, pessoas[0].Nome.Contains(nome)); // Verifica a pessoa retornada é a correta
        Assert.AreEqual(true, pessoas[1].Nome.Contains(nome)); // Verifica a pessoa retornada é a correta
    }

    /// <summary>
    /// Verifica se a pessoa pode ser inserida
    /// </summary>
    [TestMethod]
    public void PodeInserir()
    {
        Pessoa pessoa = new Pessoa();
        pessoa.Nome = “Pessoa da Silva”;
        pessoa.Endereco = “Rua com Nome 123, nr 12, CEP 34032-000″;
        pessoa.DataNascimento = new DateTime(1979, 12, 21);

        int contador = this.MockRepositorioPessoa.ObterTodos().Count;

        // Salva a pessoa
        pessoa = this.MockRepositorioPessoa.Salvar(pessoa);

        Assert.IsNotNull(pessoa); // Teste se é nulo
        Assert.AreEqual(pessoa.ID, contador + 1);
    }

    /// <summary>
    /// Verifica se a pessoa pode ser alterada
    /// </summary>
    [TestMethod]
    public void PodeAlterar()
    {
        Pessoa pessoa = new Pessoa();
        int id = 1;
        pessoa.ID = id;
        string nome = “Pessoa da Silva”;
        pessoa.Nome = nome;
        pessoa.Endereco = “Rua com Nome 123, nr 12, CEP 34032-000″;
        pessoa.DataNascimento = new DateTime(1979, 12, 21);

        int contador = this.MockRepositorioPessoa.ObterTodos().Count;

        // Salva a pessoa
        pessoa = this.MockRepositorioPessoa.Salvar(pessoa);

        Assert.IsNotNull(pessoa); // Teste se é nulo
        Assert.AreEqual(pessoa.ID, id);
        Assert.AreEqual(pessoa.Nome, nome);
    }

    /// <summary>
    /// Verifica se todos as pessoas foram retornadas
    /// </summary>
    [TestMethod]
    public void PodeExcluir()
    {
        int id = 3;

        // Obtém a pessoa com ID 1
        bool excluido = this.MockRepositorioPessoa.Excluir(id);

        Assert.AreEqual(true, excluido);
    }

    /// <summary>
    /// Verifica se todos as pessoas foram retornadas
    /// </summary>
    [TestMethod]
    public void PodeConcacentarDadosUsuario()
    {
        Pessoa pessoa = this.MockRepositorioPessoa.ObterPorID(2);

        string dadosUsuario = pessoa.ConcatenarDadosUsuario();
        string dadosUsuarioCalculado = string.Format(“ID: {0}, Nome: {1}, Idade: {2}, Endereço: {3}”, pessoa.ID.ToString(), pessoa.Nome, pessoa.Idade.ToString(), pessoa.Endereco);

        Assert.AreEqual(dadosUsuario, dadosUsuarioCalculado);
    }
}

Listagem 03: Implementação do teste unitário

O código-fonte está disponível no GitHub: Testes-Unitarios-SharePoint

Como vários cursos participaram da palestra o foco foi direcionado em como eles poderiam tirar proveito do SharePoint como usuários e usuários avançados, além de poderem propor ou contratar soluções de maneira mais eficiente.

Gostaria de agradecer ao Gesmar Júnior e a professora Lilian Paiva pela oportunidade.

Imagem 01: Cartaz de divulgação da palestra

Imagem 02: Iniciando a palestra

Mais fotos