Engenho &amp; Engenhocas

Engenhocas Estratégia

Raios de luz para levar a Internet a lugares remotos

Para ler

Analítica Big Data Cloud Imagem IoT

Fog computing e a IoT

Para ler

Carreira Estratégia Projecto

Entrosamento em equipas

Para ler

Agile Framework Imagem Projecto

Scrum Values make the system work

Para ler

Engenhocas Estratégia Windows

Novidades do sistema Andromeda da Microsoft

Para ler

Ferramenta Framework IDE Imagem Visual Studio

Behaviour-Driven Development em .NET com SpecFlow

Para ler

SpecFlow é uma ferramenta da família Cucumber que a partir da especificação dos testes ao estilo Given/When/Then (GWT) aplicando a gramática Gherkin gera o código fonte para automação e testes em .NET.

As features são escritas como uma série de cenários, usando a linguagem natural, com gramática formal e definida como Business Readable, Domain Specific Language.

O SpecFlow suporta as frameworks da família xUnit.

Diagrama UML desenhado com a app web draw.io

A secção Getting Started explica todo o processo, desde a instalação à execução e automação de testes. O pré-requisito é ter o Visual Studio.

Exemplo de especificação em Gherkin

Feature: Addition
In order to calculate totals
As a user
I want to calculate the sum of multiple numbers

Scenario: Add two numbers
Given I have entered 10 into the calculator
And I have entered 50 into the calculator
When I press add
Then the result should be 60 on the screen

Código gerado pelo SpecFlow (C#) para o passo "Given"

[Given("I have entered (.*) into the calculator")]
public void GivenIHaveEnteredSomethingIntoTheCalculator(int number)
{
    calculator = new Calculator();
    calculator.Enter(number);
}

Exemplo Prático

Relacionado: Os três pilares dos testes e qualidade Agile, Do requisito à user story

Referências: Effective Tests: Test First, Automated Acceptance Testing with SpecFlow and Gherkin

ASP.NET Caching Desenvolvimento Framework Software Patterns Web

Separated Presentation // Observer Pattern // Events and Delegates

Para ler

Separated Presentation

Ao aplicar este padrão, a apresentação e a lógica de negócio são mantidas em camadas separadas, divididas por dois módulos lógicos com responsabilidades distintas e bem definidas.

Observer Pattern

As alterações são despoletadas por meio de eventos e tratadas pela lógica de negócio conseguindo-se baixo acoplamento.

Exemplo

Exemplo básico deste conceito aplicado à gestão de estado em memória.

Lógica de Negócio

IStateValue.cs

public interface IStateValue
    {
        object Value { get; set; }
        string KeyName { get; set; }
        void SetDefault();
        object this[string KeyName] { get; set; }
    }

CachingEventArgs.cs

 public class CachingEventArgs : EventArgs
    {
        public IStateValue ApplicationStateBase { get; set; }
    }

    public delegate void InitializeStorageContextEventHandler(object sender, IStateValue stateValue);

ICachingEvent.cs

public interface ICachingEvent
    {
        void OnInitializeStorageContext();
        event InitializeStorageContextEventHandler InitializeStorageContext;
    }

Controller.cs

public class Controller
    {
        private IStateValue _stateValue;

        public void InitializeStorage(IStateValue stateValue)
        {
            _stateValue = stateValue;
            CheckValue();
        }

        public void CheckValue()
        {
            var result = _stateValue?.Value;
            
            if (result == null)
            {
                _stateValue.SetDefault();
            }

        }

    }

Logic.cs

public class Logic
    {
        readonly Controller _controller;
        ICachingEvent _caching;
        
        public Logic(ICachingEvent caching)
        {
            _controller = new Controller();

            _caching = caching;

            _caching.InitializeStorageContext += InitializeStorage;

        }

        private void InitializeStorage(object sender, IStateValue stateValue)
        {
            _controller.InitializeStorage(stateValue);
        }
    }

Apresentação

Camada desenvolvida em ASP.NET Web Forms.

StateValue.cs

public class StateValue<T> : IStateValue where T : class
    {
        private string _keyName;
        private HttpSessionState _sessionState;
        private T _value;

        #region IStateValue Members

        public StateValue() { StateStorage = HttpContext.Current.Session; }

        public StateValue(string keyName) : this()
        {
            Add(keyName);
        }

        public HttpSessionState StateStorage
        {
            get { return _sessionState; }
            set { _sessionState = value; }
        }

        #endregion

        #region IStateValue Implementation

        public object this[string KeyName]
        {
            get { return _sessionState[KeyName]; }
            set { _sessionState[KeyName] = (T) value; }
        }

        public object Value
        {
            get
            {
                if (StateStorage == null || StateStorage[_keyName] == null)
                {
                    return _value;
                }

                return StateStorage[_keyName];
            }

            set
            {
                _value = (T) value;

                if (StateStorage != null)
                {
                    StateStorage[_keyName] = (T) value;
                }
            }
        }

        public string KeyName
        {
            get { return _keyName; }
            set { _keyName = value; }
        }

        public void SetDefault()
        {
            _value = default(T);
        }

        #endregion

        public void Add(string keyName)
        {
            Add(keyName, default(T));
        }

        public void Add(string keyName, T value)
        {
            if (StateStorage[keyName] == null)
            {
                _sessionState.Add(keyName, value);
                _value = value;
            }

            _keyName = keyName;
        }

        public void ClearAll()
        {
            _sessionState.Clear();
        }

        public void Clear(string keyName)
        {
            StateStorage[keyName] = null;
        }
    }

StateValueForm.aspx

<div>
 <asp:Button ID="Button1" runat="server" Text="Button" OnClick="Button1_Click" />
 <br />
 <asp:Label ID="Label1" runat="server" Text=""></asp:Label>
</div>

StateValueForm.aspx.cs

public partial class StateValueForm : System.Web.UI.Page, ICachingEvent
{
 Logic logic;

 IStateValue stateValue;

 public event InitializeStorageContextEventHandler InitializeStorageContext;

 protected override void OnPreInit(EventArgs e)
 {
  logic = new Logic(this);

  base.OnPreInit(e);
 }

 protected void Page_Load(object sender, EventArgs e)
 {
  stateValue = new StateValue<string>("FirstKey");
 }

 protected void Button1_Click(object sender, EventArgs e)
 {
  stateValue.Value = Guid.NewGuid().ToString();

  OnInitializeStorageContext();

  Label1.Text = (string)stateValue.Value;

 }

 public void OnInitializeStorageContext()
 {
  if (InitializeStorageContext != null)
  {
   InitializeStorageContext(this, stateValue);
  }
 }
}

Referências: Exploring the Observer Design Pattern, Observer Design Pattern (Delegates/Events)