When separating your unit tests into their own directory you have to do something like this, when you want to run all your tests from the eclipse plug-in RDT: class TestRequireFinder def _load(file_name) require File.expand_path(File.dirname(__FILE__)) +'/' + file_name end end test = TestRequireFinder.new
[snipstart] --- In testdrivendevelopment@yahoogroups.com, "Kelly Anderson" <kellycoinguy@...> wrote: > > My TDD code throws more exceptions generally... so I'd really like to > hear more about your thoughts on this subject. > [snipend] Using the example as shown in: What is Exceptional? [126], The Pragmatic Programmer (converted from java to C#).
private TextReader ipstream;
public void open_passwd() { try { ipstream = new StreamReader(@"..\etc\passwd"); } catch(Exception) { throw new FileNotFoundException("No Password File Found"); } }
public bool open_user_file(string fname) { if (!File.Exists(fname)) return false;
ipstream = new StreamReader(fname);
return true; }
public void OpenUserFile(string fname) { if (!File.Exists(fname)) { Fire_FileDoesNotExistEvent(); return; }
ipstream = new StreamReader(fname); }
The method open_passwd has a dependency on passwd file. The second method is not dependent on a specific file. (In my opinion both methods are ripe to be refactored). Would you have written either of these methods with TDD/Refactoring. The point is that because of that dependency on the first method it has to have some way to communicate to the client that the part of the contract it is responsible for cannot be fulfilled. Also I am not saying that when you write code you shouldn't ever throw an exception.
As far as I have been able to determine there are only three standard ways objects can communicate in an OOP methodology.
using System; using System.IO; using NUnit.Framework;
namespace UnitTestAlarmSystem { [TestFixture] public class Test_FileOpener_NoExceptions { private const string FILE_NAME = "Tester"; private TextFileOpener textFileOpener; private ShutDownSystem shutDownSystem; private bool isNoFile;
[TestFixtureSetUp] public void TestFixtureSetUp() { textFileOpener = new TextFileOpener(); shutDownSystem = new ShutDownSystem(); }
[TestFixtureTearDown] public void TestFixtureTearDown() { shutDownSystem = null; textFileOpener = null; }
[Test] public void TestExceptionMessagesNoFile() { LoadFileForm form = new LoadFileForm(textFileOpener, shutDownSystem); form.ButtonClickException(); Assert.IsTrue(form.IsException); }
[Test] public void TestCommandMessageNoFile() { LoadFileForm form = new LoadFileForm(textFileOpener, shutDownSystem); form.SetFileName(FILE_NAME); form.ButtonClickCommand(); Assert.IsTrue(form.IsCommand); }
[Test] public void TestEventMessageNoFile() { isNoFile = false; textFileOpener.WhenLoadFile += new EventHandler(shutDownSystem.WhenNoFileHandler); textFileOpener.WhenLoadFile += new EventHandler(WhenNoFileHandler);
LoadFileForm form = new LoadFileForm(textFileOpener); form.SetFileName(FILE_NAME); form.ButtonClickEvent(); Assert.IsTrue(isNoFile); }
private void WhenNoFileHandler(object sender, EventArgs e) { isNoFile = true; } }
public class LoadFileForm { private TextFileOpener textFileOpener; private ShutDownSystem shutDownSystem; private string mFileName; private bool isCommand = false; private bool isException = false;
public LoadFileForm(TextFileOpener opener, ShutDownSystem shutDown) { textFileOpener = opener; shutDownSystem = shutDown; }
public LoadFileForm(TextFileOpener opener) { textFileOpener = opener; }
public bool IsException { get { return isException; } }
public bool IsCommand { get { return isCommand; } }
public void ButtonClickException() { try { textFileOpener.open_passwd(); //Process file } catch (Exception ex) { isException = true; shutDownSystem.SetException(ex.Message);
shutDownSystem.Execute(); } }
public void ButtonClickCommand() { bool fileOpenResult = textFileOpener.open_user_file(mFileName);
if (fileOpenResult) { //Process file } else { isCommand = true; shutDownSystem.SetException("No File Found {Command}"); shutDownSystem.Execute(); } }
public void ButtonClickEvent() { textFileOpener.OpenUserFile(mFileName); //Process file }
public void SetFileName(string file_NAME) { mFileName = file_NAME; } }
public class ShutDownSystem { private string mException;
public void Execute() { Console.WriteLine(mException); //Shut Down Logic }
public void WhenNoFileHandler(object sender, EventArgs e) { Console.WriteLine("No File Found {Event}"); //Shut Down Logic }
public void SetException(string exceptionMessage) { mException = exceptionMessage; } }
public class TextFileOpener { public event EventHandler WhenLoadFile;
private TextReader ipstream;
public TextReader Ipstream { get { return ipstream; } }
public void open_passwd() { try { ipstream = new StreamReader(@"..\etc\passwd"); } catch (Exception) { throw new FileNotFoundException("No File Found {Exception}"); } }
public bool open_user_file(string fname) { if (!File.Exists(fname)) return false;
ipstream = new StreamReader(fname);
return true; }
public void OpenUserFile(string fname) { if (!File.Exists(fname)) { Fire_FileDoesNotExistEvent(); return; }
ipstream = new StreamReader(fname); }
private void Fire_FileDoesNotExistEvent() { if (WhenLoadFile != null) WhenLoadFile.Invoke(null, null); } } }
Spike:
Ah... Encapsulates Application State as derived from event/command messages. Pretty sweet.
Was looking over event sourcing. I'm still trying to scratch my head. Will Keep plowing ahead and leave more remarks
public class SubmissionModelLayer : SubmissionModel
{
public event EventHandler SubmissionCompleteEvent;
public event EventHandler SubmissionIncompleteEvent;
private SubmittedApplication mApplication;
private ServiceLocater mLocater;
public SubmissionModelLayer(ServiceLocater locater)
{
mLocater = locater;
}
public void SubmitApplication(SubmittedApplication application)
{
mApplication = application;
mApplication.ValidateApplication(mLocater.GetValidationService());
if(IsNotValidSubmisssion())
return;
mApplication.StoreApplication(mLocater.GetDataService());
if(IsNotStoredSubmission())
return;
mApplication.NotifyCustomer(mLocater.GetMessageService());
if (IsNotNotifiedSubmission())
return;
Fire_CompleteEvent();
}
private bool IsNotNotifiedSubmission()
{
if (!mApplication.IsCustomerNotified)
{
Fire_InCompleteEvent();
return true;
}
return false;
}
private bool IsNotStoredSubmission()
{
if (!mApplication.IsStored)
{
Fire_InCompleteEvent();
return true;
}
return false;
}
private bool IsNotValidSubmisssion()
{
if (!mApplication.IsValid)
{
Fire_InCompleteEvent();
return true;
}
return false;
}
private void Fire_InCompleteEvent()
{
if (SubmissionIncompleteEvent != null)
SubmissionIncompleteEvent.Invoke(null, EventArgs.Empty);
}
private void Fire_CompleteEvent()
{
if (SubmissionCompleteEvent != null)
SubmissionCompleteEvent.Invoke(null, EventArgs.Empty);
}
}
Looking at the above code you can see that the submission service is injected into the application. Encapsulation is more than just hiding data, but also is about protecting the client from having to know more than it needs to. I know it sounds like I said the same thing, but when writing the code if you focus more on hiding data than protecting the client then you might run into something like the following:
The code needs to extract a boolean value from the validator then pass it back into the application. The original code did all this in the application object.
To keep track of the presenter first event connection, use a sequence diagram.
The diagram is driven from Atomic Object's Ruby Code.
Presenter First: Mappers. Plain and simple. Maps events to actions/commands required on the injected objects in the presenter.
People who use code to communicate their ideas of software design should give their unit tests along with their implemented code. To me that only seems to be polite. If you’re going to be on a discussion group that has its main focus to be unit testing, you should give examples in unit tests. Give me your intention not your implementation. I really don’t care if you used a long or an integer to implement a counter inside your implementation. If unit testing is the documentation of the code and no other documentation is needed, why is so much implementation used in examples?
Normally there are 3 data states in Presenter First design.
public class ReformatAction : CommandAction
{
public ReformatAction(ViewAggregator viewAggregator,
DomainService domainService) : base(viewAggregator, domainService){}
public override void Execute()
{
string formatModuleName = ViewAggregator.GetSelectedModuleName();
ModuleDTO moduleDTO = ViewAggregator.GetModule();
if (ViewAggregator.IsDirty)
Service.SetModule(moduleDTO);
ViewAggregator.SetModule(Service.GetModule(formatModuleName));
}
}
This code example is the wiring between the view and domain. It is a command object. It pulls the module name from the view, pulls the module, if view is dirty then save module, reload saved module to view. The formating comes from where? See what happens in the service:
public void SetModule(ModuleDTO module)
{
mModuleTable[module.GetModuleName()] = module.GetBody();
}
So we see that it is all done in the service. But you say your unformatting and saving the unformatted int the module table. Correct. Look at this piece:
public string GetBody()
{
ModuleUnformatter mu = new ModuleUnformatter(mBody);
mu.UnformatModule();
return mBody = mu.Module;
}
public string GetFormattedBody()
{
ModuleFormatter mf = new ModuleFormatter(mBody);
mf.FormatBody();
return mf.Module;
}
Ask yourself why didn’t I just transfer the formatted directly into the text box…
Next Post #3: How to utilize command pattern so that the Presenter holds no instance of Domain or View and is nothing but command messages and event messages.Post #4: Either Mocking and Unit Testing Presenter First or Event Handling.
Presenter First is a pattern that includes Event Mapper (Presenter), Domain (Model), and Server (View) objects.
Figure 1.
