using System;

using System.Collections.Generic;

using System.Web;

using System.Linq;

​

public class Program

{

    public static void Main()

    {

        new UnitTests().PerformUnitTest();

    }

}

​

// INSTRUCTIONS:

​

// The CustomerValidator class retrieves a value from the current HttpContext,

// uses that value to pull a record from the database, plus makes an API call.

​

// Refactor CustomerValidator so that the PerformUnitTest() method can execute 

// without interacting with any of these external services.  GetCustomerAndValidateZip()

// must still interact with all these services when run in the context of the

// host application.

​

// Adjust the unit test so that it tests one good zip code and one bad one,

// resulting in two "PASS" lines in the console.

​

// *** DEVELOPER NOTE: The explanation above this line is not very clear. You cannot test a zip code individually, only that a customer's zip code

// *** matches one that exists in the external service, so you're actually testing different customers instead. 

​

// Focus on what needs to change in CustomerValidator() and UnitTests():

// changes to the other classes would be expected in real life, but are not

// necessary for this activity.

public class UnitTests

{   

    public void PerformUnitTest() 

    {

        // construct a validator with mocked dependencies

        var customerValidator = new CustomerValidator(new MockCustomerRepository(), new MockZipCodeService());

        // try the first customer

        var result1 = customerValidator.ValidateCustomerZipByCustomerId(1) ? "PASS" : "FAIL";

        Console.WriteLine(result1);

        // try the second

        var result2 = customerValidator.ValidateCustomerZipByCustomerId(2) ? "FAIL" : "PASS";

        Console.WriteLine(result2);

    }

}

​

public class CustomerValidator

{   

    private ICustomerRepository _customerRepository;

    private IZipCodeService _zipCodeService;

    // parameterful constructor for use with a DI framework or passing arbitrary objects

    public CustomerValidator(ICustomerRepository customerRepository, IZipCodeService zipCodeService) 

    {

        _customerRepository = customerRepository;

        _zipCodeService = zipCodeService;

    }

    // Constructor to build a version of this service that defaults to external services 

    // when this class is used in the host application (parameterless, as per the example)

    // (ensures backwards compatibility only, but the app should be refactored to use the above constructor only)

    // https://blog.ploeh.dk/2011/05/30/DesignSmellDefaultConstructor/

    public CustomerValidator() 

    {

        _customerRepository = new CustomerRepository();

        _zipCodeService = new ZipCodeService();

    }

    // This method is used by the main application (not the tests) to retrieve the CustomerId from the HttpContext

    public bool GetCustomerAndValidateZip() 

    {

        var customerId = (int) HttpContext.Current.Profile.GetPropertyValue("CustomerId");

        return ValidateCustomerZipByCustomerId(customerId);

    }

    // This method is used when you want to supply the customer id to be validated during a testing scenario/test case

    // Method is called by GetCustomerAndValidateZip() when the application is being used

    public bool ValidateCustomerZipByCustomerId(int customerId) 

    {

        var customer = _customerRepository.GetCustomer(customerId);

        // this edge case is not considered in the original code, but should be

        if (customer == null) 

        {

            return false;

        }

        var allZipCodes = _zipCodeService.GetAllValidZipCodes();

        return allZipCodes.Contains(customer.ZipCode);

    }

}

​

// customer entity

public class Customer

{

    public int ID { get; set; }

    public string ZipCode { get; set; }

}

​

// interface for switching between repos (strategy pattern)

public interface ICustomerRepository {

    Customer GetCustomer(int customerId);

}

​

// customer repository

public class CustomerRepository : ICustomerRepository

{

    public Customer GetCustomer(int customerId)

    {

        var db = new DbContext();

        return db.Customers.SingleOrDefault(i => i.ID == customerId);

    }

}

​

// mock for customer repo with test customer

public class MockCustomerRepository : ICustomerRepository

{

    private List<Customer> customerRepository = new List<Customer> 

    {

        new Customer 

        {

            ID = 1,

            ZipCode = "22202"

        },

        new Customer

        {

            ID = 2,

            ZipCode = "11111"

        }

    };

    public Customer GetCustomer(int customerId)

    {

        return customerRepository.FirstOrDefault(x => x.ID == customerId);

    }

}

​

// interface for switching between services (strategy pattern)

public interface IZipCodeService 

{

    List<string> GetAllValidZipCodes();

}

​

// zip code service 

public class ZipCodeService : IZipCodeService 

{

    public List<string> GetAllValidZipCodes() 

    {

        var httpClient = new HttpClient();

        return httpClient.Get<List<string>>("http://somezipcodeapi.com/GetAll");

    }

}

​

// zip code service mock

public class MockZipCodeService : IZipCodeService 

{

    public List<string> GetAllValidZipCodes() 

    {

        return new List<string> { "22202" };

    }

}

​

// the actual entity context (external)

public class DbContext

{

    public List<Customer> Customers { get; set; }

}

​

// the actual http client (external)

public class HttpClient

{

    public T Get<T>(string url)

    {

        // perform HTTP call and return response

        return default(T);

    }

}