Login using System.Noticeably.Different.WebSite;
February 22, 2012 NoticeablyDifferent
Search for
 
Testing The Adapter Pattern 
    #region Code
public interface IAdaptee {
    void SpecificRequest();
}
 
public class Target {
    public virtual void Request() { }
}
 
public class Adapter : Target{
    IAdaptee adaptee;
 
    public Adapter() {
        adaptee = AdapteeFactory.Instance.Adaptee;
    }
 
    public override void Request() {
        adaptee.SpecificRequest();
    }
}
 
public class Adaptee : IAdaptee{
    public void SpecificRequest() { }
}
 
public class AdapteeFactory {
 
    private System.Collections.Hashtable adapteeCollection = new System.Collections.Hashtable();
 
    public static readonly AdapteeFactory Instance = new AdapteeFactory();
 
    private AdapteeFactory() {
        ResetAdaptees();
    }
 
    public void ReplaceAdaptee(System.Type type, IAdaptee adaptee) {
        adapteeCollection[type] = adaptee;
    }
 
    private void ResetAdaptees() {
        adapteeCollection.Clear();
        adapteeCollection.Add(typeof(IAdaptee), new Adaptee());
    }
 
    public void Reset() {
        ResetAdaptees();
    }
 
    public IAdaptee Adaptee {
        get { return (IAdaptee)adapteeCollection[typeof(IAdaptee)]; }
    }
}
    #endregion
 
    #region Unit Tests
public class MockAdaptee : IAdaptee {
    public bool specificRequestCalled = false;
 
    public void SpecificRequest() {
        specificRequestCalled = true;
    }
}
 
[TestFixture]
public class AdapterTests {
    Adapter adapter;
    MockAdaptee adaptee;
 
    [SetUp]
    public void SetUp() {
        adaptee = new MockAdaptee();
        AdapteeFactory.Instance.ReplaceAdaptee(typeof(IAdaptee), adaptee);
        adapter = new Adapter();
    }
 
    [TearDown]
    public void TearDown() {
        AdapteeFactory.Instance.Reset();
    }
 
    [Test]
    public void AdapterCallsAdapteeSpecificRequest() {
        Assert.IsFalse(adaptee.specificRequestCalled, "SpecificRequest not called");
        adapter.Request();
        Assert.IsTrue(adaptee.specificRequestCalled, "SpecificRequest called");
    }
}
 
[TestFixture]
public class TargetTests {
    Target target;
 
    [SetUp]
    public void SetUp() {
        target = new Target();
    }
 
    [Test]
    public void RequestPerformsExpectedAction() {
        //TODO: Assert that the Request method performs its expected action(s)
    }
}
 
[TestFixture]
public class AdapteeTests {
    Adaptee target;
 
    [SetUp]
    public void SetUp() {
        target = new Adaptee();
    }
 
    [Test]
    public void SpecificRequestPerformsExpectedAction() {
        //TODO: Assert that the SpecificRequest method performs its expected action(s)
    }
}
 
[TestFixture]
public class AdapteeFactoryTests {
 
    IAdaptee adaptee = new MockAdaptee();
 
    public AdapteeFactoryTests() { }
 
    [SetUp]
    public void SetUp() {
        AdapteeFactory.Instance.Reset();
    }
 
    [Test]
    public void RealAdapteeIsDefault() {
        Assert.AreEqual(typeof(Adaptee), AdapteeFactory.Instance.Adaptee.GetType());
    }
 
    [Test]
    public void AdapteeReplacedAndReturned() {
        Assert.AreEqual(typeof(Adaptee), AdapteeFactory.Instance.Adaptee.GetType());
        AdapteeFactory.Instance.ReplaceAdaptee(typeof(IAdaptee), new MockAdaptee());
        Assert.AreEqual(typeof(MockAdaptee), AdapteeFactory.Instance.Adaptee.GetType());
        AdapteeFactory.Instance.Reset();
        Assert.AreEqual(typeof(Adaptee), AdapteeFactory.Instance.Adaptee.GetType());
    }
}
    #endregion
© Jason Hunt 2007  This work is licensed under a Creative Commons Attribution 2.5 Canada License.