public void Install_should_install_if_a_package_has_not_been_installed_yet()
{
// Arrange
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var proj = fixture.Freeze<Project>();
var pwPkg = new ProjectWidePackage("Prig", "2.0.0", proj);
var mocks = new MockRepository(MockBehavior.Strict);
{
var m = mocks.Create<IVsPackageInstallerServices>();
m.Setup(_ => _.IsPackageInstalledEx(proj, "Prig", "2.0.0")).Returns(false);
m.Setup(_ => _.IsPackageInstalled(proj, "Prig")).Returns(false);
fixture.Inject(m);
}
{
var m = mocks.Create<IVsPackageUninstaller>();
fixture.Inject(m);
}
{
var m = mocks.Create<IVsPackageInstaller>();
m.Setup(_ => _.InstallPackage(default(string), proj, "Prig", "2.0.0", false));
fixture.Inject(m);
}
var pwInstllr = fixture.NewProjectWideInstaller();
// Act
pwInstllr.Install(pwPkg);
// Assert
mocks.VerifyAll();
}
public UnitTest1()
{
var mock = new Moq.MockRepository(MockBehavior.Default);
logMocking = mock.Create <ILogFile>();
var dac = mock.Create <IAccountDAC>();
sut = new ATMController(logMocking.Object, dac.Object);
var accounts = new List <Account>()
{
new Account()
{
Username = "******", Balance = 500
},
new Account()
{
Username = "******", Balance = 50
},
};
dac.Setup(dac => dac.GetAllAccounts())
.Returns(accounts);
// this.sut = sut;
}
public void SerializeTest()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockTimeSpan = mockRepository.Create<IStringSerializer<TimeSpan>>();
var mockDaysOfWeek = mockRepository.Create<IStringSerializer<DaysOfWeek>>();
var mockIEnumerableDateTime = mockRepository.Create<IStringSerializer<IEnumerable<DateTime>>>();
var timeSpanRuleInfoSerializer = new TimeSpanRuleInfoSerializer(mockTimeSpan.Object, mockDaysOfWeek.Object,
mockIEnumerableDateTime.Object);
var expMin = new TimeSpan(150);
var expMax = new TimeSpan(250);
var expDaysOfWeek = new DaysOfWeek(DayOfWeek.Monday, DayOfWeek.Thursday);
var expDateTimes = new[] {new DateTime(1), new DateTime(100), new DateTime(500)};
var exp = new TimeSpanRuleInfo(expMin, expMax, expDaysOfWeek, expDateTimes);
mockTimeSpan.Setup(x => x.Serialize(expMin)).Returns("150").Verifiable();
mockTimeSpan.Setup(x => x.Serialize(expMax)).Returns("250").Verifiable();
mockDaysOfWeek.Setup(x => x.Serialize(expDaysOfWeek)).Returns("1,4").Verifiable();
mockIEnumerableDateTime.Setup(x => x.Serialize(expDateTimes)).Returns("datetimes").Verifiable();
Assert.AreEqual("150\x001E250\x001E1,4\x001Edatetimes", timeSpanRuleInfoSerializer.Serialize(exp));
mockRepository.VerifyAll();
}
public void WhenDataReaderIsDBNullReturnsTrue_ThenTheFieldIsNotSetInTheRow()
{
List<string> columns = new List<string>();
MockRepository mockRepository = new MockRepository(MockBehavior.Strict);
Mock<IDataReader> dataReaderMock = mockRepository.Create<IDataReader>();
dataReaderMock.SetupSequence(x => x.Read()).Returns(true).Returns(false);
dataReaderMock.SetupGet(x => x.FieldCount).Returns(2);
dataReaderMock.Setup(x => x.IsDBNull(0)).Returns(false);
dataReaderMock.Setup(x => x.IsDBNull(1)).Returns(true);
dataReaderMock.Setup(x => x.GetValue(0)).Returns(0);
dataReaderMock.Setup(x => x.GetName(It.IsInRange<int>(0, 1, Range.Inclusive))).Returns<int>(n => "Col" + n);
Mock<IDataRow> rowMock = mockRepository.Create<IDataRow>();
rowMock.SetupSet(x => x[0] = 0);
Mock<ISimpleDataTable> dataTableMock = mockRepository.Create<ISimpleDataTable>();
dataTableMock.SetupGet(x => x.ColumnNames).Returns(columns);
dataTableMock.Setup(x => x.NewRow()).Returns(rowMock.Object);
DataReaderAdapter target = new DataReaderAdapter();
target.Fill(dataTableMock.Object, dataReaderMock.Object);
dataTableMock.Verify(x => x.NewRow(), Times.Once());
dataReaderMock.Verify(x => x.GetValue(0), Times.Once());
dataReaderMock.Verify(x => x.GetValue(1), Times.Never());
rowMock.VerifySet(x => x[0] = It.IsAny<int>(), Times.Once());
rowMock.VerifySet(x => x[1] = It.IsAny<int>(), Times.Never());
}
protected CommandMarginControllerTest()
{
_factory = new MockRepository(MockBehavior.Strict);
_marginControl = new CommandMarginControl();
_marginControl.CommandLineTextBox.Text = String.Empty;
_search = _factory.Create<IIncrementalSearch>();
_search.SetupGet(x => x.InSearch).Returns(false);
_search.SetupGet(x => x.InPasteWait).Returns(false);
_vimBuffer = new MockVimBuffer();
_vimBuffer.IncrementalSearchImpl = _search.Object;
_vimBuffer.VimImpl = MockObjectFactory.CreateVim(factory: _factory).Object;
_vimBuffer.CommandModeImpl = _factory.Create<ICommandMode>(MockBehavior.Loose).Object;
var textBuffer = CreateTextBuffer(new []{""});
_vimBuffer.TextViewImpl = TextEditorFactoryService.CreateTextView(textBuffer);
Mock<IVimGlobalSettings> globalSettings = new Mock<IVimGlobalSettings>();
_vimBuffer.GlobalSettingsImpl = globalSettings.Object;
var editorFormatMap = _factory.Create<IEditorFormatMap>(MockBehavior.Loose);
editorFormatMap.Setup(x => x.GetProperties(It.IsAny<string>())).Returns(new ResourceDictionary());
var parentVisualElement = _factory.Create<FrameworkElement>();
_controller = new CommandMarginController(
_vimBuffer,
parentVisualElement.Object,
_marginControl,
VimEditorHost.EditorFormatMapService.GetEditorFormatMap(_vimBuffer.TextView),
VimEditorHost.ClassificationFormatMapService.GetClassificationFormatMap(_vimBuffer.TextView));
}
public void SutDoesNotEqualOtherWithDifferentNodes()
{
// Arrange
var moqRepo = new MockRepository(MockBehavior.Default);
var sut = new CompositeMortgageApplicationProcessor
{
Nodes = new[]
{
moqRepo.Create<IMortgageApplicationProcessor>().Object,
moqRepo.Create<IMortgageApplicationProcessor>().Object,
moqRepo.Create<IMortgageApplicationProcessor>().Object
}
};
var other = new CompositeMortgageApplicationProcessor
{
Nodes = new[]
{
moqRepo.Create<IMortgageApplicationProcessor>().Object,
moqRepo.Create<IMortgageApplicationProcessor>().Object,
moqRepo.Create<IMortgageApplicationProcessor>().Object
}
};
// Act
var actual = sut.Equals(other);
// Assert
Assert.False(actual);
}
public VsCommandTargetTest()
{
_textView = CreateTextView("");
_buffer = Vim.CreateVimBuffer(_textView);
_bufferCoordinator = new VimBufferCoordinator(_buffer);
_vim = _buffer.Vim;
_factory = new MockRepository(MockBehavior.Strict);
// By default Resharper isn't loaded
_resharperUtil = _factory.Create<IResharperUtil>();
_resharperUtil.SetupGet(x => x.IsInstalled).Returns(false);
_nextTarget = _factory.Create<IOleCommandTarget>(MockBehavior.Strict);
_vsAdapter = _factory.Create<IVsAdapter>();
_vsAdapter.SetupGet(x => x.KeyboardDevice).Returns(InputManager.Current.PrimaryKeyboardDevice);
_vsAdapter.Setup(x => x.InAutomationFunction).Returns(false);
_vsAdapter.Setup(x => x.InDebugMode).Returns(false);
_vsAdapter.Setup(x => x.IsIncrementalSearchActive(It.IsAny<ITextView>())).Returns(false);
_broker = _factory.Create<IDisplayWindowBroker>(MockBehavior.Loose);
var oldCommandFilter = _nextTarget.Object;
var vsTextView = _factory.Create<IVsTextView>(MockBehavior.Loose);
vsTextView.Setup(x => x.AddCommandFilter(It.IsAny<IOleCommandTarget>(), out oldCommandFilter)).Returns(0);
var result = VsCommandTarget.Create(
_bufferCoordinator,
vsTextView.Object,
_vsAdapter.Object,
_broker.Object,
_resharperUtil.Object,
KeyUtil);
Assert.True(result.IsSuccess);
_targetRaw = result.Value;
_target = _targetRaw;
}
public void Create(params string[] lines)
{
_textView = CreateTextView(lines);
_textView.Caret.MoveTo(new SnapshotPoint(_textView.TextSnapshot, 0));
_textBuffer = _textView.TextBuffer;
_factory = new MockRepository(MockBehavior.Strict);
_editOpts = _factory.Create<IEditorOperations>();
_vimHost = _factory.Create<IVimHost>();
_vimHost.Setup(x => x.IsDirty(It.IsAny<ITextBuffer>())).Returns(false);
_operations = _factory.Create<ICommonOperations>();
_operations.SetupGet(x => x.EditorOperations).Returns(_editOpts.Object);
_statusUtil = _factory.Create<IStatusUtil>();
_fileSystem = _factory.Create<IFileSystem>(MockBehavior.Strict);
_foldManager = _factory.Create<IFoldManager>(MockBehavior.Strict);
_vimData = new VimData();
_vim = MockObjectFactory.CreateVim(RegisterMap, host: _vimHost.Object, vimData: _vimData, factory: _factory);
var localSettings = new LocalSettings(Vim.GlobalSettings);
var vimTextBuffer = MockObjectFactory.CreateVimTextBuffer(
_textBuffer,
vim: _vim.Object,
localSettings: localSettings,
factory: _factory);
var vimBufferData = CreateVimBufferData(
vimTextBuffer.Object,
_textView,
statusUtil: _statusUtil.Object);
var vimBuffer = CreateVimBuffer(vimBufferData);
_interpreter = new Interpreter.Interpreter(
vimBuffer,
_operations.Object,
_foldManager.Object,
_fileSystem.Object,
_factory.Create<IBufferTrackingService>().Object);
}
public UserBusinessLogicTests()
{
MockFactory = new MockRepository(MockBehavior.Loose) { DefaultValue = DefaultValue.Mock };
MockedUserBusinessLogic = MockFactory.Create<IUserBusinessLogic>();
MockedUserRepository = MockFactory.Create<IUserRepository>();
}
public async Task Add_BadRequest_InvalidQuantity()
{
var repo = new Moq.MockRepository(Moq.MockBehavior.Strict);
var cartId = 42;
var items = new System.Collections.Generic.Dictionary <string, int>()
{
{ "article1", 0 }
};
var queryItems = new webapi.Controllers.CartItems {
Items = items
};
var cartItems = new cart.grain.CartItems {
Items = items
};
// initialize grain
var cartGrain = repo.Create <ICart>();
cartGrain.Setup(x => x.Add(It.IsAny <cart.grain.CartItems>())).Returns(Task.FromResult((CartItemsStatusCode.InvalidQuantity, cartItems)));
// initialize grain factory
var grainFactory = repo.Create <IGrainFactory>();
grainFactory.Setup(x => x.GetGrain <ICart>(cartId)).Returns(cartGrain.Object);
var controller = new webapi.Controllers.CartController(grainFactory.Object);
var response = await controller.Add(cartId, queryItems) as BadRequestObjectResult;
Assert.AreEqual(400, response.StatusCode);
repo.VerifyAll();
}
public void Init()
{
_mockFactory = new MockRepository(MockBehavior.Strict);
_helper = _mockFactory.Create<IConfigurationItemsHelper>();
_resolver = _mockFactory.Create<IConfigurationTypeResolver>();
_reader = new ConfigurationItemsReader(_resolver.Object, _helper.Object);
}
public void Init()
{
_mockRepository = new MockRepository(MockBehavior.Strict);
_fdResolver = _mockRepository.Create<IFirstDayOfWeekResolver>();
_weekPadding = _mockRepository.Create<IWeekPaddingCalculator>();
}
public async Task InvokeTest()
{
var mr = new MockRepository(MockBehavior.Strict);
var next = mr.Create<OwinMiddleware>(MockBehavior.Strict, (OwinMiddleware) null);
var ctx = mr.Create<IOwinContext>();
var logger = mr.Create<ILog>();
var exception = new Exception();
logger.Setup(x => x.Fatal(It.IsAny<object>(), exception)).Verifiable();
next.Setup(x => x.Invoke(ctx.Object)).Returns(async () =>
{
await Task.Delay(1);
throw exception;
}).Verifiable();
var mw = new ExceptionHandlerMiddleware(next.Object, logger.Object);
try
{
await mw.Invoke(ctx.Object);
}
catch (Exception e)
{
Assert.AreEqual(exception, e);
}
mr.VerifyAll();
}
public void testProsesNotaPengeluaran()
{
var transactionDate = new DateTime(2015, 10, 26);
var periodId = new PeriodeId(new DateTime(2015, 11, 1), new DateTime(2015, 11, 6));
var listAkun = new string[] { "Ayam" };
var listSummaryAkun = new List<SummaryAkunDto>()
{
new SummaryAkunDto(){ PeriodId = "20151104",Akun ="Ayam", Nominal=600000.0}
};
var factory = new MockRepository(MockBehavior.Loose);
var mockRepository = factory.Create<IRepository>();
var mockCashFlow = factory.Create<ICashFlow>();
var mockPengeluaran = factory.Create<INotaPengeluaran>();
var mockCurrentPeriod = factory.Create<IPeriod>();
mockRepository.Setup(t => t.FindPeriodForDate(transactionDate)).Returns(mockCurrentPeriod.Object);
mockCurrentPeriod.SetupGet(t => t.PeriodId).Returns(periodId);
mockRepository.Setup(t => t.FindCashFlowByPeriod(periodId)).Returns(mockCashFlow.Object);
mockPengeluaran.SetupGet(t => t.Date).Returns(transactionDate);
mockPengeluaran.Setup(t => t.ListAkun()).Returns(listAkun);
mockRepository.Setup(t => t.ListSummaryAkunIn(mockCurrentPeriod.Object, listAkun)).Returns(listSummaryAkun);
mockCashFlow.Setup(t => t.ChangePengeluaran(It.IsAny<string>(), It.IsAny<double>(),It.IsAny<int>()));
mockRepository.Setup(t => t.Save(mockCashFlow.Object));
var service = new ProcessNotaPengeluaran();
service.Repository = mockRepository.Object;
service.Process(mockPengeluaran.Object);
factory.VerifyAll();
}
public void ProduceOfferReturnsCorrectResult(
string locationName,
string currentTime)
{
// Arrange
var moqRepo = new MockRepository(MockBehavior.Default);
var sut = new DateAndLocationMortgageApplicationProcessor
{
LocationProvider = moqRepo.Create<ILocationProvider>().Object,
TimeProvider = moqRepo.Create<ITimeProvider>().Object
};
Mock.Get(sut.LocationProvider)
.Setup(lp => lp.GetCurrentLocationName())
.Returns(locationName);
Mock.Get(sut.TimeProvider)
.Setup(tp => tp.GetCurrentTime())
.Returns(DateTimeOffset.Parse(currentTime));
// Act
var dummyApplication = new MortgageApplication();
var actual = sut.ProduceOffer(dummyApplication);
// Assert
var expected = new IRendering[]
{
new TextRendering(
locationName +
", " +
DateTimeOffset.Parse(currentTime).ToString("D")),
new LineBreakRendering()
};
Assert.Equal(expected, actual);
}
public async Task InvokeErrorTest()
{
var mr = new MockRepository(MockBehavior.Strict);
var next = mr.Create<OwinMiddleware>(MockBehavior.Strict, (OwinMiddleware)null);
var ctx = mr.Create<IOwinContext>();
var logger = mr.Create<ILog>();
var exception = new Exception();
var request = mr.Create<IOwinRequest>();
ctx.SetupGet(x => x.Request).Returns(request.Object).Verifiable();
logger.Setup(x => x.Info(It.IsAny<string>())).Throws(exception);
request.SetupGet(x => x.Method).Returns("fasefaes").Verifiable();
request.SetupGet(x => x.Uri).Returns(new Uri("http://ya.ru")).Verifiable();
request.SetupGet(x => x.RemoteIpAddress).Returns("asefasergsdrg").Verifiable();
request.SetupGet(x => x.RemotePort).Returns(11).Verifiable();
var mw = new LoggerMiddleware(next.Object, logger.Object);
try
{
await mw.Invoke(ctx.Object);
}
catch (Exception e)
{
Assert.AreEqual(exception, e);
return;
}
finally
{
mr.VerifyAll();
}
Assert.Fail();
}
protected VimTest()
{
_factory = new MockRepository(MockBehavior.Strict);
_globalSettings = new GlobalSettings();
_fileSystem = _factory.Create<IFileSystem>(MockBehavior.Strict);
_bufferFactory = VimBufferFactory;
_simpleListener = new SimpleListener();
var creationListeners = new [] { new Lazy<IVimBufferCreationListener>(() => _simpleListener) };
var map = new Dictionary<string, VariableValue>();
_keyMap = new KeyMap(_globalSettings, map);
_vimHost = _factory.Create<IVimHost>(MockBehavior.Strict);
_vimHost.Setup(x => x.CreateHiddenTextView()).Returns(CreateTextView());
_vimHost.Setup(x => x.AutoSynchronizeSettings).Returns(true);
_vimRaw = new Vim(
_vimHost.Object,
_bufferFactory,
CompositionContainer.GetExportedValue<IVimInterpreterFactory>(),
creationListeners.ToFSharpList(),
_globalSettings,
_factory.Create<IMarkMap>().Object,
_keyMap,
MockObjectFactory.CreateClipboardDevice().Object,
_factory.Create<ISearchService>().Object,
_fileSystem.Object,
new VimData(_globalSettings),
_factory.Create<IBulkOperations>().Object,
map,
new EditorToSettingSynchronizer());
_vim = _vimRaw;
_vim.AutoLoadVimRc = false;
}
public void Create(bool haveHistory = true)
{
_factory = new MockRepository(MockBehavior.Strict);
_statusUtil = _factory.Create<IStatusUtil>();
var editorOperationsFactoryService = _factory.Create<IEditorOperationsFactoryService>();
if (haveHistory)
{
_textUndoHistory = _factory.Create<ITextUndoHistory>();
_textUndoHistory.Setup(x => x.Undo(It.IsAny<int>())).Callback<int>(count => { _undoCount += count; });
_textUndoHistory.Setup(x => x.Redo(It.IsAny<int>())).Callback<int>(count => { _redoCount += count; });
_undoRedoOperationsRaw = new UndoRedoOperations(
_statusUtil.Object,
FSharpOption.Create(_textUndoHistory.Object),
editorOperationsFactoryService.Object);
}
else
{
_undoRedoOperationsRaw = new UndoRedoOperations(
_statusUtil.Object,
FSharpOption<ITextUndoHistory>.None,
editorOperationsFactoryService.Object);
}
_undoRedoOperations = _undoRedoOperationsRaw;
}
public void WhenDataReaderGetNameReturnsNull_ThenTheColumnIndexIsUsedAsColumnName()
{
List<string> columns = new List<string>();
MockRepository mockRepository = new MockRepository(MockBehavior.Strict);
Mock<IDataReader> dataReaderMock = mockRepository.Create<IDataReader>();
dataReaderMock.SetupSequence(x => x.Read()).Returns(true).Returns(false);
dataReaderMock.SetupGet(x => x.FieldCount).Returns(2);
dataReaderMock.Setup(x => x.IsDBNull(It.IsInRange<int>(0, 1, Range.Inclusive))).Returns(false);
dataReaderMock.Setup(x => x.GetValue(It.IsInRange<int>(0, 1, Range.Inclusive))).Returns<int>(n => n);
dataReaderMock.Setup(x => x.GetName(It.IsInRange<int>(0, 1, Range.Inclusive))).Returns((string)null);
Mock<IDataRow> rowMock = mockRepository.Create<IDataRow>();
rowMock.SetupSet(x => x[0] = 0);
rowMock.SetupSet(x => x[1] = 1);
Mock<ISimpleDataTable> dataTableMock = mockRepository.Create<ISimpleDataTable>();
dataTableMock.SetupGet(x => x.ColumnNames).Returns(columns);
dataTableMock.Setup(x => x.NewRow()).Returns(rowMock.Object);
DataReaderAdapter target = new DataReaderAdapter();
target.Fill(dataTableMock.Object, dataReaderMock.Object);
dataTableMock.Verify(x => x.NewRow(), Times.Once());
dataReaderMock.Verify(x => x.GetName(It.IsAny<int>()), Times.Exactly(2));
Assert.Equal(2, columns.Count);
Assert.Equal("0", columns[0]);
Assert.Equal("1", columns[1]);
}
public async Task InvokeTest()
{
var mr = new MockRepository(MockBehavior.Strict);
var next = mr.Create<OwinMiddleware>(MockBehavior.Strict, (OwinMiddleware)null);
var ctx = mr.Create<IOwinContext>();
var cidStore = mr.Create<ICorrelationIdStore>();
var response = mr.Create<IOwinResponse>();
var hDict = new HeaderDictionary(new Dictionary<string, string[]>());
var correlationId = new CorrelationId();
next.Setup(x => x.Invoke(ctx.Object)).Returns(Task.CompletedTask).Verifiable();
ctx.SetupGet(x => x.Response).Returns(response.Object).Verifiable();
response.SetupGet(x => x.Headers).Returns(hDict).Verifiable();
cidStore.Setup(x => x.Read()).Returns(correlationId).Verifiable();
Assert.AreEqual(0, hDict.Count);
var midleware = new SetCorrelationIdHeaderMiddleware(next.Object, cidStore.Object);
await midleware.Invoke(ctx.Object);
Assert.AreEqual(1, hDict.Count);
var actual = hDict["X-CORRELATIONID"];
Assert.AreEqual(correlationId.ToString(), actual);
mr.VerifyAll();
}
public SelectionChangeTrackerTest()
{
_factory = new MockRepository(MockBehavior.Loose);
_selection = _factory.Create<ITextSelection>();
_textView = MockObjectFactory.CreateTextView(
selection: _selection.Object,
factory: _factory);
_vimHost = _factory.Create<IVimHost>();
_vimHost.Setup(x => x.IsFocused(_textView.Object)).Returns(true);
_vimBuffer = MockObjectFactory.CreateVimBuffer(
textView: _textView.Object,
vim: MockObjectFactory.CreateVim(host: _vimHost.Object).Object,
factory: _factory);
_vimBuffer.SetupGet(x => x.IsClosed).Returns(false);
_mouseDevice = _factory.Create<IMouseDevice>();
_selectionOverride = _factory.Create<IVisualModeSelectionOverride>();
_selectionOverride.Setup(x => x.IsInsertModePreferred(It.IsAny<ITextView>())).Returns(false);
var selectionList = new List<IVisualModeSelectionOverride>();
selectionList.Add(_selectionOverride.Object);
_context = new TestableSynchronizationContext();
_context.Install();
_tracker = new SelectionChangeTracker(_vimBuffer.Object, _factory.Create<ICommonOperations>(MockBehavior.Loose).Object, selectionList.ToFSharpList(), _mouseDevice.Object);
}
public void Init()
{
_mockFactory = new MockRepository(MockBehavior.Strict);
_attributesReader = _mockFactory.Create<IAttributesReader>();
_fieldReader = _mockFactory.Create<IEnumFieldReader>();
_field = typeof (TestEnum).GetField(TestEnum.Value.ToString());
_da = new DescriptionAttribute();
}
protected VimApplicationSettingsTest(VisualStudioVersion visualStudioVersion = VisualStudioVersion.Vs2010)
{
_factory = new MockRepository(MockBehavior.Strict);
_protectedOperations = _factory.Create<IProtectedOperations>();
_settingsStore = _factory.Create<WritableSettingsStore>();
_vimApplicationSettingsRaw = new VimApplicationSettings(visualStudioVersion, _settingsStore.Object, _protectedOperations.Object);
_vimApplicationSettings = _vimApplicationSettingsRaw;
}
public void Init()
{
_mockFactory = new MockRepository(MockBehavior.Strict);
_updateRepository = _mockFactory.Create<IUpdateRepository<TestEntity>>();
_updateMapper = _mockFactory.Create<IUpdatePathProviderMapper<TestEntityUpdateModel, TestEntity>>();
_updateEntityActionFactory = _mockFactory.Create<IUpdateEntityActionFactory>();
_pathToDbIncludeConverter = _mockFactory.Create<IPathToDbIncludeConverter>();
}
public void Init()
{
_factory = new MockRepository(MockBehavior.Strict);
_resolver = _factory.Create<IWrapperTypesResolver>();
_wrappersFactory = _factory.Create<IWrappersFactory>();
_correlationIdStore = _factory.Create<ICorrelationIdStore>();
_itemStore = _factory.Create<IItemStore>();
}
public void Setup()
{
mockRepo = new MockRepository(MockBehavior.Loose);
mockFileWrapper = mockRepo.Create<IFileWrapper>();
mockConsole= mockRepo.Create<System.IO.TextWriter>();
ISort sorter = new ArraySorter();
theProgram = new Program(mockFileWrapper.Object, sorter, mockConsole.Object);
}
public void Init()
{
_mockFactory = new MockRepository(MockBehavior.Strict);
_policyFactory = _mockFactory.Create<ICachePolicyFactory>();
_objCacheFactory = _mockFactory.Create<IObjectCacheFactory>();
new MemoryCacherFactory(_policyFactory.Object, _objCacheFactory.Object);
}
protected void Create(bool insertMode, params string[] lines)
{
_factory = new MockRepository(MockBehavior.Strict);
_factory.DefaultValue = DefaultValue.Mock;
_textView = CreateTextView(lines);
_textBuffer = _textView.TextBuffer;
_vim = _factory.Create<IVim>(MockBehavior.Loose);
_editorOptions = _factory.Create<IEditorOptions>(MockBehavior.Loose);
_textChangeTracker = _factory.Create<ITextChangeTracker>(MockBehavior.Loose);
_textChangeTracker.SetupGet(x => x.CurrentChange).Returns(FSharpOption<TextChange>.None);
_undoRedoOperations = CreateUndoRedoOperations();
_wordCompletionSessionFactoryService = _factory.Create<IWordCompletionSessionFactoryService>();
var localSettings = new LocalSettings(Vim.GlobalSettings);
_vimBuffer = Vim.CreateVimBuffer(_textView);
_globalSettings = _vimBuffer.GlobalSettings;
var vimTextBuffer = Vim.GetOrCreateVimTextBuffer(_textView.TextBuffer);
var vimBufferData = CreateVimBufferData(vimTextBuffer, _textView);
_operations = CommonOperationsFactory.GetCommonOperations(vimBufferData);
_broker = _factory.Create<IDisplayWindowBroker>();
_broker.SetupGet(x => x.IsCompletionActive).Returns(false);
_broker.SetupGet(x => x.IsQuickInfoActive).Returns(false);
_broker.SetupGet(x => x.IsSignatureHelpActive).Returns(false);
_broker.SetupGet(x => x.IsSmartTagSessionActive).Returns(false);
_insertUtil = _factory.Create<IInsertUtil>();
_motionUtil = _factory.Create<IMotionUtil>();
_commandUtil = _factory.Create<ICommandUtil>();
_capture = _factory.Create<IMotionCapture>();
// Setup the mouse. By default we say it has no buttons down as that's the normal state
_mouseDevice = _factory.Create<IMouseDevice>();
_mouseDevice.SetupGet(x => x.IsLeftButtonPressed).Returns(false);
// Setup the keyboard. By default we don't say that any button is pressed. Insert mode is usually
// only concerned with arrow keys and we will set those up as appropriate for the typing tests
_keyboardDevice = _factory.Create<IKeyboardDevice>();
_keyboardDevice.Setup(x => x.IsArrowKeyDown).Returns(false);
_modeRaw = new global::Vim.Modes.Insert.InsertMode(
_vimBuffer,
_operations,
_broker.Object,
_editorOptions.Object,
_undoRedoOperations,
_textChangeTracker.Object,
_insertUtil.Object,
_motionUtil.Object,
_commandUtil.Object,
_capture.Object,
!insertMode,
_keyboardDevice.Object,
_mouseDevice.Object,
WordUtil,
_wordCompletionSessionFactoryService.Object);
_mode = _modeRaw;
_mode.OnEnter(ModeArgument.None);
_mode.CommandRan += (sender, e) => { _lastCommandRan = e.CommandRunData; };
}
public ClientMocks(string subscriptionId)
{
repository = new MockRepository(MockBehavior.Default) {DefaultValue = DefaultValue.Mock};
var creds = CreateCredentials(subscriptionId);
ManagementClientMock = repository.Create<ManagementClient>(creds);
ComputeManagementClientMock = repository.Create<ComputeManagementClient>(creds);
StorageManagementClientMock = repository.Create<StorageManagementClient>(creds);
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
mockDeliverableServiceV2 = mockRepository.Create <IDeliverableServiceV2>();
mockIntegrationService = mockRepository.Create <IIntergrationService>();
}
public void Init()
{
_mockFactory = new MockRepository(MockBehavior.Strict);
_cacherFactory = _mockFactory.Create<ICacherFactory>();
_cacher = _mockFactory.Create<ICacher<FieldInfo>>();
_e = DayOfWeek.Friday;
_eName = _e.ToString();
_f = typeof (DayOfWeek).GetField(_eName);
}
public void TestTarget()
{
_mock = new MockRepository(MockBehavior.Strict);
_mockProvider = _mock.Create<IRepositoryProvider>();
_mockRepository = _mock.Create<IRepository>();
_mockRepository.Setup(r => r.Dispose());
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Loose)
{
DefaultValue = DefaultValue.Mock
};
mockBudgetPlanTowService = mockRepository.Create <IBudgetPlanTowService>();
mockBudgetService = mockRepository.Create <IBudgetService>();
mockMappingEngine = mockRepository.Create <IMappingEngine>();
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
mockuserRepository = mockRepository.Create <IUserRepository>();
mockuserchannelRepository = mockRepository.Create <IUserChannelRepository>();
mockuserrolemoduleRepository = mockRepository.Create <IUserRoleModuleRepository>();
mockuserdepartmenttypeRepository = mockRepository.Create <IMRMUserDepartmentTypeRepository>();
mockunitofwork = mockRepository.Create <IUnitOfWork>();
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
mockDocumentRepository = mockRepository.Create <IDocumentRepository>();
mockDocumentService = mockRepository.Create <IDocumentsService>();
mockDocumentAccessTypeRepository = mockRepository.Create <IDocumentAccessTypeRepository>();
mockMRMUserRepository = mockRepository.Create <IDocument_MRMUserRepository>();
mockUserRepository = mockRepository.Create <IUserRepository>();
mockDeliverableDocumentRepository = mockRepository.Create <IDeliverableDocumentRepository>();
mockUnitOfWork = mockRepository.Create <IUnitOfWork>();
mockUserService = mockRepository.Create <IUserService>();
mockDropDownListService = mockRepository.Create <IDropDownListService>();
mockContractRequestMasterVendorDocumentRepository = mockRepository.Create <IContractRequest_MasterVendor_DocumentRepository>();
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Loose)
{
DefaultValue = DefaultValue.Mock
};
mockProjectService = mockRepository.Create <IProjectService>();
mockContractRequestService = mockRepository.Create <IContractRequestService>();
mockBudgetService = mockRepository.Create <IBudgetService>();
mockApprovalService = mockRepository.Create <IApprovalService>();
mockInternationalService = mockRepository.Create <IInternationalService>();
mockDeliverableService = mockRepository.Create <IDeliverableService>();
mockDeliverableServiceV2 = mockRepository.Create <IDeliverableServiceV2>();
mockFinanceService = mockRepository.Create <IFinanceService>();
mockWBS_DeliverablesRepository = mockRepository.Create <IWBS_DeliverablesRepository>();
mockUserService = mockRepository.Create <IUserService>();
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Loose)
{
DefaultValue = DefaultValue.Mock
};
mockBudgetService = mockRepository.Create <IBudgetService>();
mockdeliverableService = mockRepository.Create <IDeliverableService>();
mockImageService = mockRepository.Create <IImageService>();
mockproductService = mockRepository.Create <IProductService>();
mockpropertyService = mockRepository.Create <IPropertyService>();
mockIntergrationService = mockRepository.Create <IIntergrationService>();
mockTrackApprovalService = mockRepository.Create <ITrackApprovalService>();
mockApprovalService = mockRepository.Create <IApprovalService>();
mockInternationalService = mockRepository.Create <IInternationalService>();
mockDeliverableRepository = mockRepository.Create <IDeliverableRepository>();
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
mockuserRepository = mockRepository.Create <IUserRepository>();
mockuserService = mockRepository.Create <IUserService>();
mockchannelRepository = mockRepository.Create <IChannelRepository>();
mockmoduleRepository = mockRepository.Create <IModuleRepository>();
mockuserdepartmenttypeRepository = mockRepository.Create <IMRMUserDepartmentTypeRepository>();
mockdepartmentRepository = mockRepository.Create <IDepartmentRepository>();
mockunitofwork = mockRepository.Create <IUnitOfWork>();
mockroleRepository = mockRepository.Create <IRoleRepository>();
mockusertitleRepository = mockRepository.Create <IUserTitleRepository>();
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
mockcontractrequestService = mockRepository.Create <IContractRequestService>();
mockcontractprojectservice = mockRepository.Create <IProjectService>();
mockbudgetService = mockRepository.Create <IBudgetService>();
mockdeliverablerepository = mockRepository.Create <IDeliverableRepository>();
mockVendorViewRepository = mockRepository.Create <IMasterVendorViewRepository>();
mockDeliverableVendorRepository = mockRepository.Create <IDeliverable_VendorRepository>();
mockVendorRepository = mockRepository.Create <IVendorRepository>();
mockDeliverableUserTitleMrmUserRepository = mockRepository.Create <IDeliverableUserTitleMrmUserRepository>();
mockUserRepository = mockRepository.Create <IUserRepository>();
}
public async Task Remove_Ok()
{
var repo = new Moq.MockRepository(Moq.MockBehavior.Strict);
var cartId = 42;
var items = new System.Collections.Generic.Dictionary <string, int>()
{
{ "article1", 3 }
};
var queryItems = new webapi.Controllers.CartItems {
Items = items
};
var cartItems = new cart.grain.CartItems {
Items = items
};
var emptyCartItems = new cart.grain.CartItems();
// initialize grain
var cartGrain = repo.Create <ICart>();
cartGrain.Setup(x => x.Remove(It.Is <cart.grain.CartItems>(o => o.Items["article1"] == 3))).Returns(Task.FromResult((CartItemsStatusCode.Ok, emptyCartItems)));
// initialize grain factory
var grainFactory = repo.Create <IGrainFactory>();
grainFactory.Setup(x => x.GetGrain <ICart>(cartId)).Returns(cartGrain.Object);
var controller = new webapi.Controllers.CartController(grainFactory.Object);
var response = await controller.Remove(cartId, queryItems) as OkObjectResult;
Assert.AreEqual(200, response.StatusCode);
var result = (webapi.Controllers.CartItems)response.Value;
Assert.AreEqual(0, result.Items.Count);
repo.VerifyAll();
}
public async Task Clear_Ok()
{
var repo = new Moq.MockRepository(Moq.MockBehavior.Strict);
var cartId = 42;
// initialize grain
var cartGrain = repo.Create <ICart>();
cartGrain.Setup(x => x.Clear()).Returns(Task.CompletedTask);
// initialize grain factory
var grainFactory = repo.Create <IGrainFactory>();
grainFactory.Setup(x => x.GetGrain <ICart>(cartId)).Returns(cartGrain.Object);
var controller = new webapi.Controllers.CartController(grainFactory.Object);
var response = await controller.Clear(cartId) as OkResult;
Assert.AreEqual(200, response.StatusCode);
repo.VerifyAll();
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
mockfinanceservice = mockRepository.Create <IFinanceService>();
mockApInvoiceBatchRepository = mockRepository.Create <IApInvoiceBatchRepository>();
mockInvoiceHeaderRepository = mockRepository.Create <IInvoiceHeaderRepository>();
mockIUnitOfWork = mockRepository.Create <IUnitOfWork>();
mockIInvoiceLineRepository = mockRepository.Create <IInvoiceLineRepository>();
mockFinanceService = mockRepository.Create <IFinanceService>();
mockWBS_DeliverablesRepository = mockRepository.Create <IWBS_DeliverablesRepository>();
}
public async Task OnExecute_ExceptedBehavior()
{
var topicTrendFeedReader = CreateTopicTrendFeedReader();
var moqCommandLineApplication = new CommandLineApplication();
var moqConsole = _mockRepository.Create <McMaster.Extensions.CommandLineUtils.IConsole>();
TextWriter textWriter = new StringWriter();
IList <FeedResult> feedResults = AutoFaker.Generate <FeedResult>(5);
_mockXmlReader
.Setup(st => st.GetStreamAsync(It.IsAny <Uri>()))
.ReturnsAsync(It.IsAny <Stream>());
_mockXmlReader
.Setup(st => st.ReaderAsync(It.IsAny <Stream>()))
.ReturnsAsync(feedResults);
moqConsole
.Setup(st => st.Out)
.Returns(textWriter);
await topicTrendFeedReader.OnExecute(moqCommandLineApplication, moqConsole.Object);
_mockRepository.Verify();
}
public void DemoMock01()
{
var mock = new Moq.MockRepository(Moq.MockBehavior.Default);
var logMocking = mock.Create <ILogFile>();
// var log = logMocking.Object;
//log.WriteWithdraw("sakul123", 199);
var expectedDate = DateTime.Now;
logMocking.Setup(it => it.GetCurrentDate(It.IsAny <int>()))
.Returns <int>(number =>
{
if (number == 1)
{
return(expectedDate);
}
else if (number == 2)
{
return(expectedDate.AddDays(1));
}
else
{
return(DateTime.Now);
}
}
);
var log = logMocking.Object;
var currentTime = log.GetCurrentDate(1);
// logMocking.Verify(it => it.WriteWithdraw(
// It.Is<string>(acut => acut == "sakul"),
// It.Is<double>(acut => acut == 199)));
Assert.Equal(expectedDate, currentTime);
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
mockbudgetService = mockRepository.Create <IBudgetService>();
mockunitOfWork = mockRepository.Create <IUnitOfWork>();
mockdeliverableService = mockRepository.Create <IDeliverableService>();
mockdeliverableServiceV2 = mockRepository.Create <IDeliverableServiceV2>();
mockproductService = mockRepository.Create <IProductService>();
mockpropertyService = mockRepository.Create <IPropertyService>();
mocktypeOfWorkRepository = mockRepository.Create <ITypeOfWorkRepository>();
mockBudgetByCategoryRollupRepository = mockRepository.Create <IBudgetByCategoryRollupRepository>();
mockBudgetByCategoryRepository = mockRepository.Create <IBudgetByCategoryRepository>();
mockUserChannelRepository = mockRepository.Create <IUserChannelRepository>();
mockProductFamilyRepository = mockRepository.Create <IProductFamilyRepository>();
mockdeliverableCategoryRepository = mockRepository.Create <IDeliverableCategoryRepository>();
mockForecastSnapshotRepository = mockRepository.Create <IForecastSnapshotBatchRepository>();
mockWBSElementRepository = mockRepository.Create <IWBSElementRepository>();
}
public void ClassInit()
{
mockRepository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
mockIntergrationService = mockRepository.Create <IIntergrationService>();
mockWorkOrderRepository = mockRepository.Create <IWorkOrderRepository>();
mockDeliverableRepository = mockRepository.Create <IDeliverableRepository>();
mockCalendarRepository = mockRepository.Create <ICalendarRepository>();
mockDeliverableBudgetRepository = mockRepository.Create <IDeliverableBudgetRepository>();
mockWorkOrderTransactionRepositry = mockRepository.Create <IWorkOrderTransactionRepositry>();
mockInvoiceLineRepository = mockRepository.Create <IInvoiceLineRepository>();
mockUnitOfWork = mockRepository.Create <IUnitOfWork>();
mockTypeOfWorkRepository = mockRepository.Create <ITypeOfWorkRepository>();
mockWBSFiscalYear_ChannelRepository = mockRepository.Create <IWBSFiscalYear_ChannelRepository>();
mockUserRepository = mockRepository.Create <IUserRepository>();
}
public TopicTrendFeedReaderTests()
{
_mockRepository = new Moq.MockRepository(MockBehavior.Strict);
_mockXmlReader = _mockRepository.Create <IXmlReader>();
}
public VimTest()
{
_factory = new MockRepository(MockBehavior.Strict);
_globalSettings = new GlobalSettings();
_markMap = _factory.Create<IMarkMap>(MockBehavior.Strict);
_fileSystem = _factory.Create<IFileSystem>(MockBehavior.Strict);
_bufferFactory = VimBufferFactory;
var map = new Dictionary<string, VariableValue>();
_keyMap = new KeyMap(_globalSettings, map);
_vimHost = _factory.Create<IVimHost>(MockBehavior.Strict);
_searchInfo = _factory.Create<ISearchService>(MockBehavior.Strict);
_vimRaw = new Vim(
_vimHost.Object,
_bufferFactory,
FSharpList<Lazy<IVimBufferCreationListener>>.Empty,
_globalSettings,
_markMap.Object,
_keyMap,
MockObjectFactory.CreateClipboardDevice().Object,
_searchInfo.Object,
_fileSystem.Object,
new VimData(),
_factory.Create<IBulkOperations>().Object,
map);
_vim = _vimRaw;
_vim.AutoLoadVimRc = false;
}
