/// <summary> /// Uses dependency injection and inversion of control. By using these /// techniques we make the object constructing this object provide all /// of the external dependencies. The code is less fragile, reuse is /// encouraged, and there should be less bugs. /// Look at the DependencyLoader to see how we're telling the system to /// load the implementation classes for this class. /// </summary> /// <param name="fileSync"></param> /// <param name="userInteractions"></param> /// <param name="settings"></param> /// <param name="backupAccess"></param> public RunBackup( IFileSync fileSync, IInteractionContext userInteractions, ISettingsProvider settings, IBackupAccess backupAccess) { _FileSystem = fileSync; _Interactions = userInteractions; _Settings = settings; _BackupDirectory = backupAccess; _FileSystem.AppliedChange += OnAppliedChange; _FileSystem.SkippedChange += OnSkippedChange; }
public void Setup() { //Here we're doing all of the set up for this clump of tests. // Mocks basically allow us to pretend like we have a class // when we really don't just so the program runs. This really // comes in handy when you have a large interface and don't want to // create a huge real class that has to have a bunch of empty methods // that never get called. Interactions = MockRepository.GenerateStub<IInteractionContext>(); FileSync = MockRepository.GenerateStub<IFileSync>(); BackupAccess = MockRepository.GenerateStub<IBackupAccess>(); Settings = MockRepository.GenerateStub<ISettingsProvider>(); BackupRunner = new RunBackup(FileSync, Interactions, Settings, BackupAccess); Context(); Because(); }